o01eg/sendxmppd-rs - Change TGO4TIWURN54UFBLMUX4EZTZBG3TE5F4VRL56BTLOINCKJEUDD7QC

Fix README

Created by O01eg on November 17, 2020

TGO4TIWURN54UFBLMUX4EZTZBG3TE5F4VRL56BTLOINCKJEUDD7QC

Dependencies

In channels

main

Change contents

File deletion: bitbucket-pipelines.yml

BF:BFD[1.0] → [3.0:25]

BF:BFD[3.25] → [3.26:26]

B:BD[3.26] → [3.27:703]

B:BD[3.703] → [4.32:155]

B:BD[3.703] → [5.0:123]

∅:BD[5.123] → [3.703:919]

∅:BD[4.155] → [3.703:919]

B:BD[3.703] → [3.703:919]

∅:BD[6.7214] → [3.988:1054]

∅:BD[7.101] → [3.988:1054]

B:BD[3.988] → [3.988:1054]

∅:BD[8.27] → [3.1100:1194]

B:BD[3.1100] → [3.1100:1194]

B:BD[3.1247] → [3.1247:1321]

∅:BD[6.7420] → [3.1321:1375]

∅:BD[7.307] → [3.1321:1375]

B:BD[3.1321] → [3.1321:1375]

B:BD[3.1194] → [3.1194:1247]

B:BD[3.1194] → [8.28:62]

B:BD[8.62] → [7.102:307]

B:BD[8.62] → [6.7215:7420]

B:BD[3.1054] → [3.1054:1100]

B:BD[3.1054] → [8.0:27]

B:BD[3.919] → [7.32:101]

B:BD[3.919] → [6.7145:7214]

B:BD[3.919] → [3.919:988]

# This is a sample build configuration for Rust.
# Check our guides at https://confluence.atlassian.com/x/5Q4SMw for more examples.
# Only use spaces to indent your .yml configuration.
# -----
# You can specify a custom docker image from Docker Hub as your build environment.
image: rust:latest
pipelines:
  default:
    - step:
        caches:
          - crates
        script:
#         - apt-get update
#         - apt-get install --no-install-recommends -y libsdl2-dev
          - rustc --verbose --version
          - cargo update -v
          - cargo build -v
          - cargo test -v
          - rustup component add clippy-preview
          - cargo clippy --all -v
          - rustup component add rustfmt-preview
          - cargo fmt -- --version
          - cargo fmt --all -- --check
          - rustup component add rustfmt-preview
          - cargo fmt -- --version
          - cargo fmt --all -- --check
    - step:
        name: Nightly
        image: rustlang/rust:nightly
        caches:
          - crates
        script:
#         - apt-get update
#         - apt-get install --no-install-recommends -y libsdl2-dev
          - rustc --verbose --version
          - cargo update -v
          - cargo test -v
          - rustup component add clippy-preview --toolchain nightly
          - cargo fmt -- --version
          - cargo fmt --all -- --check
definitions:
  caches:
    crates: /usr/local/cargo/
          - cargo clippy --all -v --features nightly
          - cargo clippy --all -v
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
          - cargo fmt -- --version
          - cargo fmt --all -- --check
================================
          - cargo fix --edition
<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
          - cargo fmt -- --version
          - cargo fmt --all -- --check
================================
          - cargo fix --edition
<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
          - cargo build --features nightly -v
          - cargo build -v
          - rustup component add rustfmt-preview --toolchain nightly
          - rustup component add rustfmt-preview --toolchain nightly
          - rustup component add rustfmt-preview --toolchain nightly

File deletion: rustfmt.toml
BF:BFD[1.0] → [9.1946:1960]
BF:BFD[9.1960] → [9.1961:1961]
B:BD[9.1961] → [9.1962:2082]
```
max_width = 100
reorder_imports = true
reorder_modules = true
use_field_init_shorthand = true
use_try_shorthand = true
```
File deletion: src
BF:BFD[1.0] → [10.0:5]
BF:BFD[10.5] → [10.6:6]

File deletion: main.rs

BF:BFD[10.6] → [10.7:16]

BF:BFD[10.16] → [10.17:17]

B:BD[9.21] → [11.0:23]

B:BD[11.24] → [11.24:48]

B:BD[9.61] → [12.3497:3519]

B:BD[9.61] → [9.61:121]

B:BD[9.121] → [13.1691:1719]

B:BD[9.193] → [13.1720:1752]

B:BD[9.275] → [11.49:77]

B:BD[9.304] → [13.1790:1817]

B:BD[9.337] → [14.279:280]

B:BD[9.434] → [9.434:435]

B:BD[10.30] → [15.4181:4557]

B:BD[15.4582] → [15.4582:4583]

B:BD[15.4671] → [15.4671:5134]

B:BD[15.5542] → [15.5542:5662]

B:BD[15.5777] → [15.5777:5799]

B:BD[15.5818] → [15.5818:5833]

B:BD[15.5895] → [15.5895:6040]

B:BD[15.6121] → [16.1623:1695]

B:BD[15.6219] → [15.6219:6255]

B:BD[15.6295] → [15.6295:6317]

B:BD[15.6345] → [15.6345:6356]

B:BD[15.6455] → [15.6455:6484]

∅:BD[17.51465] → [10.61:63]

∅:BD[18.30298] → [10.61:63]

∅:BD[19.237] → [10.61:63]

∅:BD[20.6824] → [10.61:63]

∅:BD[2.3841] → [10.61:63]

∅:BD[9.1383] → [10.61:63]

∅:BD[21.35342] → [10.61:63]

∅:BD[22.6215] → [10.61:63]

∅:BD[4.31] → [10.61:63]

∅:BD[7.31] → [10.61:63]

∅:BD[13.3346] → [10.61:63]

∅:BD[23.2450] → [10.61:63]

∅:BD[11.680] → [10.61:63]

∅:BD[15.6590] → [10.61:63]

∅:BD[24.430] → [10.61:63]

B:BD[10.61] → [10.61:63]

B:BD[15.6484] → [15.6484:6590]

B:BD[15.6455] → [16.1832:1861]

B:BD[15.6356] → [15.6356:6455]

B:BD[15.6345] → [16.1765:1831]

B:BD[15.6317] → [15.6317:6345]

B:BD[15.6295] → [16.1746:1764]

B:BD[15.6255] → [15.6255:6295]

B:BD[15.6219] → [16.1696:1745]

B:BD[15.6040] → [15.6040:6121]

B:BD[15.6121] → [15.6121:6219]

B:BD[15.6040] → [25.4231:4312]

B:BD[15.6040] → [26.2370:2449]

B:BD[15.6040] → [27.676:755]

B:BD[15.5833] → [15.5833:5895]

B:BD[15.5833] → [25.4168:4230]

B:BD[15.5833] → [28.807:878]

B:BD[15.5833] → [26.2298:2369]

B:BD[15.5799] → [15.5799:5818]

B:BD[15.5799] → [25.4149:4167]

B:BD[25.2832] → [25.2832:2854]

B:BD[25.2854] → [25.2854:4148]

B:BD[25.2854] → [26.2278:2297]

B:BD[15.5662] → [15.5662:5777]

B:BD[15.5662] → [25.2670:2832]

B:BD[15.5662] → [26.2162:2277]

B:BD[15.5134] → [15.5134:5542]

B:BD[15.5134] → [25.1897:2669]

B:BD[15.5134] → [26.1753:2161]

B:BD[15.4583] → [15.4583:4671]

B:BD[15.4583] → [25.1808:1896]

B:BD[15.4583] → [28.717:806]

B:BD[15.4583] → [26.1663:1752]

B:BD[15.4557] → [15.4557:4582]

B:BD[15.4557] → [25.1782:1807]

B:BD[15.4557] → [28.682:716]

B:BD[15.4557] → [26.1628:1662]

B:BD[10.30] → [10.30:61]

B:BD[10.30] → [7.0:31]

B:BD[10.30] → [4.0:31]

B:BD[10.30] → [22.4338:4363]

B:BD[20.4638] → [24.152:177]

B:BD[20.4673] → [24.178:266]

B:BD[20.4954] → [24.267:292]

B:BD[20.5039] → [20.5039:5105]

B:BD[20.5106] → [22.4597:4663]

B:BD[20.5155] → [24.293:339]

B:BD[20.5995] → [24.340:396]

B:BD[20.6049] → [24.397:430]

B:BD[20.6049] → [29.33412:34224]

B:BD[20.6049] → [30.11305:12117]

B:BD[20.6049] → [20.6049:6389]

B:BD[20.6536] → [20.6536:6824]

B:BD[20.6389] → [31.8404:8551]

B:BD[20.6389] → [32.4717:4805]

B:BD[20.6389] → [33.7460:7607]

B:BD[20.6389] → [20.6389:6536]

B:BD[20.6389] → [34.7310:7457]

B:BD[20.6389] → [35.10922:11010]

B:BD[20.6389] → [36.7022:7110]

B:BD[20.6389] → [37.13451:13539]

B:BD[20.6049] → [38.12917:13729]

B:BD[20.6049] → [39.2731:3543]

B:BD[20.5995] → [22.5445:5561]

B:BD[20.5995] → [20.5995:6048]

B:BD[20.6048] → [20.6048:6049]

B:BD[20.6049] → [22.5562:6215]

B:BD[20.5155] → [40.9740:9784]

B:BD[20.5155] → [41.4703:4747]

B:BD[20.5155] → [31.7623:8403]

B:BD[20.5155] → [42.14017:14061]

B:BD[20.5155] → [43.18717:18761]

B:BD[20.5155] → [29.33339:33411]

B:BD[20.5935] → [20.5935:5995]

B:BD[20.5155] → [44.85:865]

B:BD[20.5155] → [45.4555:5335]

B:BD[20.5155] → [46.59409:59453]

B:BD[20.5155] → [47.8156:8200]

B:BD[20.5155] → [22.4664:5444]

B:BD[20.5155] → [48.13645:13689]

B:BD[20.5155] → [30.11221:11293]

B:BD[30.11293] → [30.11293:11304]

B:BD[20.5155] → [49.12434:13203]

B:BD[20.5155] → [50.2897:2941]

B:BD[20.5155] → [51.5635:5679]

B:BD[20.5155] → [20.5155:5935]

B:BD[20.5155] → [52.5761:5805]

B:BD[20.5155] → [38.12833:12916]

B:BD[20.5155] → [53.3653:4433]

B:BD[20.5155] → [54.7041:7821]

B:BD[20.5155] → [35.10141:10921]

B:BD[20.5155] → [55.31335:31379]

B:BD[20.5155] → [39.2647:2730]

B:BD[20.5105] → [20.5105:5106]

B:BD[20.5106] → [20.5106:5155]

B:BD[20.4954] → [31.7556:7622]

B:BD[20.4954] → [32.4609:4716]

B:BD[20.4954] → [22.4489:4596]

B:BD[20.4954] → [33.7393:7459]

B:BD[20.4954] → [20.4954:5020]

B:BD[20.5020] → [20.5020:5039]

B:BD[20.4954] → [34.7243:7309]

B:BD[20.4954] → [35.10033:10140]

B:BD[20.4954] → [36.6914:7021]

B:BD[20.4954] → [37.13343:13450]

B:BD[20.4673] → [22.4399:4488]

B:BD[20.4673] → [20.4673:4762]

B:BD[20.4762] → [20.4762:4954]

B:BD[20.4638] → [22.4364:4398]

B:BD[20.4638] → [20.4638:4672]

B:BD[20.4672] → [20.4672:4673]

B:BD[10.30] → [9.436:1093]

B:BD[9.1118] → [9.1118:1137]

B:BD[9.1137] → [13.1868:1934]

B:BD[9.1187] → [13.1935:2766]

B:BD[19.203] → [13.2767:2858]

B:BD[13.3038] → [56.3631:3729]

B:BD[56.3800] → [56.3800:3811]

B:BD[56.3729] → [56.3729:3800]

B:BD[13.3112] → [13.3112:3346]

B:BD[56.3729] → [57.435:463]

B:BD[11.177] → [11.177:205]

B:BD[11.281] → [11.281:379]

B:BD[11.440] → [11.440:680]

B:BD[11.379] → [11.379:440]

B:BD[11.379] → [14.397:461]

B:BD[11.205] → [11.205:281]

B:BD[11.205] → [14.315:396]

B:BD[13.3038] → [13.3038:3112]

B:BD[11.177] → [13.2859:3038]

B:BD[11.177] → [19.204:237]

B:BD[9.1187] → [9.1187:1293]

B:BD[11.176] → [11.176:177]

B:BD[9.1350] → [11.114:176]

B:BD[9.1350] → [9.1350:1383]

B:BD[9.1293] → [9.1293:1350]

B:BD[9.1293] → [19.150:203]

B:BD[9.1137] → [9.1137:1187]

B:BD[9.1093] → [9.1093:1118]

B:BD[9.1093] → [19.83:149]

B:BD[10.30] → [20.4262:4287]

B:BD[20.4287] → [20.4287:4638]

B:BD[10.30] → [19.57:82]

B:BD[10.30] → [18.30267:30298]

∅:BD[21.33632] → [17.48806:49182]

B:BD[10.30] → [17.48806:49182]

∅:BD[58.51581] → [17.49216:49217]

∅:BD[59.45260] → [17.49216:49217]

B:BD[17.49216] → [17.49216:49217]

∅:BD[58.51671] → [17.49306:49351]

∅:BD[59.45349] → [17.49306:49351]

B:BD[17.49306] → [17.49306:49351]

B:BD[17.49388] → [17.49388:49498]

B:BD[17.49605] → [17.49605:49624]

∅:BD[21.33759] → [17.49624:49625]

B:BD[17.49624] → [17.49624:49625]

∅:BD[21.33827] → [17.49690:49740]

B:BD[17.49690] → [17.49690:49740]

B:BD[58.51863] → [58.51863:51923]

∅:BD[21.33877] → [17.49936:49937]

B:BD[17.49936] → [17.49936:49937]

B:BD[17.50000] → [58.51924:52736]

B:BD[17.50840] → [59.46249:46330]

B:BD[17.51089] → [59.46331:46478]

∅:BD[21.35274] → [17.51239:51270]

B:BD[17.51239] → [17.51239:51270]

∅:BD[2.3797] → [17.51329:51359]

∅:BD[21.35298] → [17.51329:51359]

∅:BD[23.2398] → [17.51329:51359]

B:BD[17.51329] → [17.51329:51359]

B:BD[21.35330] → [21.35330:35331]

B:BD[21.35331] → [23.2399:2450]

B:BD[21.35331] → [21.35331:35342]

B:BD[21.35331] → [2.3798:3841]

B:BD[17.51360] → [21.35299:35330]

B:BD[17.51360] → [17.51360:51465]

B:BD[17.51359] → [17.51359:51360]

B:BD[17.51270] → [23.2374:2398]

B:BD[17.51270] → [21.35275:35298]

B:BD[17.51270] → [2.3774:3797]

B:BD[17.51270] → [17.51270:51329]

B:BD[17.51089] → [58.52817:52905]

B:BD[17.51177] → [17.51177:51239]

B:BD[17.51089] → [17.51089:51177]

B:BD[17.50840] → [58.52737:52816]

B:BD[17.50919] → [17.50919:51089]

B:BD[17.50840] → [17.50840:50919]

B:BD[17.50000] → [60.45505:45551]

∅:BD[21.34647] → [60.46310:46317]

B:BD[60.46310] → [60.46310:46317]

B:BD[60.46317] → [21.34648:35274]

B:BD[60.45551] → [21.33878:34435]

∅:BD[2.3773] → [21.34581:34647]

∅:BD[23.2373] → [21.34581:34647]

B:BD[21.34581] → [21.34581:34647]

B:BD[21.34435] → [23.1996:2373]

B:BD[21.34435] → [21.34435:34581]

B:BD[21.34435] → [2.3627:3773]

B:BD[60.45551] → [60.45551:46310]

B:BD[17.50000] → [17.50000:50382]

B:BD[17.50812] → [17.50812:50840]

B:BD[17.50382] → [61.36123:36208]

B:BD[17.50382] → [17.50382:50812]

B:BD[17.49937] → [17.49937:50000]

B:BD[17.49883] → [17.49883:49936]

B:BD[17.49740] → [59.45417:46248]

B:BD[17.49740] → [58.51780:51863]

B:BD[17.49740] → [62.69256:69300]

B:BD[17.49740] → [60.45421:45504]

B:BD[60.45504] → [21.33828:33877]

B:BD[17.49740] → [17.49740:49883]

B:BD[17.49625] → [21.33760:33827]

B:BD[17.49625] → [17.49625:49690]

B:BD[17.49498] → [59.45350:45416]

B:BD[17.49498] → [58.51672:51779]

B:BD[17.49498] → [17.49498:49605]

B:BD[17.49351] → [63.47721:47758]

B:BD[17.49351] → [64.30988:31025]

B:BD[17.49351] → [21.33633:33699]

∅:BD[2.3626] → [21.33738:33759]

∅:BD[23.1995] → [21.33738:33759]

B:BD[21.33738] → [21.33738:33759]

B:BD[21.33699] → [23.1876:1995]

B:BD[21.33699] → [21.33699:33738]

B:BD[21.33699] → [2.3587:3626]

B:BD[17.49351] → [65.30802:30839]

B:BD[17.49351] → [17.49351:49388]

B:BD[17.49217] → [59.45261:45349]

B:BD[17.49217] → [58.51582:51671]

B:BD[17.49217] → [17.49217:49306]

B:BD[17.49182] → [59.45235:45260]

B:BD[17.49182] → [58.51547:51581]

B:BD[17.49182] → [17.49182:49216]

B:BD[9.338] → [9.338:434]

B:BD[9.337] → [9.337:338]

B:BD[14.280] → [13.1818:1867]

B:BD[14.280] → [14.280:314]

B:BD[9.275] → [9.275:304]

B:BD[9.304] → [9.304:337]

B:BD[11.77] → [11.77:113]

B:BD[9.275] → [13.1753:1789]

B:BD[9.193] → [9.193:228]

B:BD[9.228] → [9.228:275]

B:BD[9.121] → [9.121:193]

B:BD[9.22] → [9.22:61]

B:BD[9.61] → [19.0:56]

B:BD[9.21] → [9.21:22]

B:BD[11.23] → [11.23:24]

B:BD[9.21] → [13.1642:1690]

B:BD[20.3533] → [22.3862:3885]

B:BD[22.3885] → [43.13874:13903]

B:BD[20.3621] → [22.3911:3933]

B:BD[20.3656] → [22.3934:3990]

B:BD[20.3759] → [22.3991:4019]

B:BD[20.3839] → [22.4020:4055]

B:BD[20.3893] → [22.4056:4083]

B:BD[20.3921] → [24.0:35]

B:BD[20.4000] → [22.4117:4153]

B:BD[20.4065] → [22.4154:4155]

B:BD[20.4092] → [20.4092:4105]

B:BD[20.4260] → [40.4141:5074]

B:BD[41.4702] → [40.5075:9738]

B:BD[40.9739] → [42.13538:14016]

B:BD[55.31331] → [55.31331:31333]

B:BD[55.31334] → [43.18238:18716]

B:BD[55.31334] → [48.13166:13644]

B:BD[55.31333] → [55.31333:31334]

B:BD[40.9739] → [55.30856:31331]

B:BD[40.9738] → [40.9738:9739]

B:BD[20.4260] → [41.98:908]

B:BD[50.399] → [41.909:4701]

B:BD[41.4701] → [41.4701:4702]

B:BD[50.399] → [50.399:886]

B:BD[66.266] → [67.0:2690]

B:BD[50.2600] → [66.422:507]

B:BD[50.2532] → [66.362:421]

B:BD[66.266] → [66.266:361]

B:BD[50.2213] → [66.239:266]

B:BD[68.928] → [68.928:2045]

B:BD[68.2147] → [68.2147:2182]

B:BD[68.2182] → [68.2182:2212]

B:BD[68.2045] → [69.683:825]

B:BD[68.2045] → [68.2045:2147]

B:BD[66.143] → [66.143:238]

B:BD[50.1157] → [66.60:143]

B:BD[68.2182] → [69.826:854]

B:BD[66.266] → [69.589:682]

B:BD[50.1410] → [69.331:588]

B:BD[68.453] → [69.276:330]

B:BD[66.143] → [69.114:275]

B:BD[50.2681] → [50.2681:2896]

B:BD[50.2600] → [50.2600:2681]

B:BD[50.2569] → [50.2569:2600]

B:BD[50.2532] → [50.2532:2569]

B:BD[50.2302] → [50.2302:2532]

B:BD[50.2241] → [50.2241:2302]

B:BD[50.1410] → [50.1410:2213]

B:BD[50.2213] → [50.2213:2241]

B:BD[50.1384] → [50.1384:1410]

B:BD[50.1346] → [50.1346:1384]

B:BD[50.1303] → [50.1303:1346]

B:BD[50.1241] → [50.1241:1303]

B:BD[50.1157] → [50.1157:1241]

B:BD[20.4261] → [50.887:1157]

B:BD[50.2532] → [68.2284:2353]

B:BD[68.2212] → [68.2212:2283]

B:BD[66.266] → [68.834:928]

B:BD[68.653] → [68.653:833]

B:BD[50.1410] → [68.454:653]

B:BD[50.1346] → [68.398:453]

B:BD[68.325] → [68.325:397]

B:BD[66.143] → [68.220:325]

B:BD[50.399] → [51.482:5634]

B:BD[20.4260] → [20.4260:4261]

B:BD[20.4260] → [42.9249:13537]

B:BD[20.4260] → [50.90:266]

B:BD[68.114] → [69.0:113]

B:BD[50.303] → [50.303:398]

B:BD[50.398] → [50.398:399]

B:BD[68.114] → [68.114:219]

B:BD[50.266] → [66.0:59]

B:BD[50.266] → [50.266:303]

B:BD[50.266] → [68.45:114]

B:BD[20.4260] → [51.123:481]

B:BD[55.30772] → [55.30772:30773]

B:BD[22.4337] → [43.13949:13950]

B:BD[6.2109] → [70.315:358]

B:BD[6.2314] → [6.2314:2315]

B:BD[43.14630] → [70.359:414]

B:BD[43.14764] → [70.415:478]

B:BD[43.14893] → [43.14893:14894]

B:BD[6.2401] → [70.479:551]

B:BD[43.14948] → [43.14948:15247]

B:BD[43.15295] → [43.15295:15385]

B:BD[43.15414] → [43.15414:15523]

B:BD[6.3856] → [70.613:681]

B:BD[6.4267] → [70.682:750]

B:BD[43.18122] → [43.18122:18136]

B:BD[6.5970] → [70.751:819]

B:BD[6.6381] → [70.820:888]

B:BD[6.7006] → [70.889:949]

B:BD[6.7006] → [6.7006:7054]

B:BD[6.7054] → [6.7054:7130]

B:BD[6.6381] → [6.6381:6437]

B:BD[6.6437] → [6.6437:7006]

B:BD[6.5970] → [6.5970:6026]

B:BD[6.6026] → [6.6026:6381]

B:BD[43.18136] → [43.18136:18237]

B:BD[43.18136] → [6.4535:5970]

B:BD[6.4267] → [6.4267:4323]

B:BD[6.4323] → [6.4323:4534]

B:BD[43.16148] → [43.16148:16228]

B:BD[43.16228] → [43.16228:18122]

B:BD[38.9485] → [47.7879:7935]

B:BD[38.9908] → [47.7936:7992]

B:BD[38.11636] → [47.7993:8049]

B:BD[38.12059] → [47.8050:8106]

B:BD[38.12696] → [47.8107:8155]

B:BD[38.12696] → [30.11160:11220]

B:BD[38.12756] → [38.12756:12832]

B:BD[38.12696] → [38.12696:12756]

B:BD[38.12059] → [30.11091:11159]

B:BD[38.12127] → [38.12127:12696]

B:BD[38.12059] → [38.12059:12127]

B:BD[38.11636] → [30.11022:11090]

B:BD[38.11704] → [38.11704:12059]

B:BD[38.11636] → [38.11636:11704]

B:BD[38.9908] → [30.10953:11021]

B:BD[38.9976] → [38.9976:11636]

B:BD[38.9908] → [38.9908:9976]

B:BD[6.7130] → [6.7130:7144]

B:BD[6.3856] → [6.3856:3912]

B:BD[6.3912] → [6.3912:4267]

B:BD[38.9485] → [30.10884:10952]

B:BD[38.9485] → [38.9485:9553]

B:BD[38.9553] → [38.9553:9908]

B:BD[43.16148] → [71.4006:4092]

B:BD[43.15523] → [43.15523:16148]

B:BD[43.15523] → [6.2576:3856]

B:BD[43.15523] → [52.3155:5760]

B:BD[43.15523] → [38.8205:9485]

B:BD[43.15385] → [43.15385:15414]

B:BD[43.15385] → [6.2538:2575]

B:BD[43.15385] → [52.3125:3154]

B:BD[43.15385] → [38.8167:8204]

B:BD[43.15247] → [70.552:612]

B:BD[43.15247] → [43.15247:15295]

B:BD[43.15247] → [47.7830:7878]

B:BD[43.15247] → [30.10823:10883]

B:BD[43.15247] → [52.3076:3124]

B:BD[43.15247] → [38.8106:8166]

B:BD[6.2459] → [6.2459:2537]

B:BD[6.2458] → [6.2458:2459]

B:BD[38.7954] → [47.7772:7829]

B:BD[38.8027] → [29.27444:33338]

B:BD[38.8027] → [38.8027:8105]

B:BD[38.7954] → [30.10750:10822]

B:BD[38.7954] → [38.7954:8026]

B:BD[38.8026] → [38.8026:8027]

B:BD[6.2401] → [6.2401:2458]

B:BD[6.2459] → [52.3021:3075]

B:BD[6.2459] → [38.7869:7954]

B:BD[43.14894] → [43.14894:14948]

B:BD[43.14894] → [6.2316:2401]

B:BD[43.14867] → [43.14867:14893]

B:BD[43.14764] → [43.14764:14844]

B:BD[43.14844] → [43.14844:14867]

B:BD[70.414] → [39.2546:2646]

B:BD[43.14630] → [43.14630:14673]

B:BD[43.14673] → [43.14673:14764]

B:BD[43.14630] → [47.7534:7771]

B:BD[43.14630] → [30.10594:10749]

B:BD[43.14630] → [52.2783:3020]

B:BD[43.14630] → [38.7713:7868]

B:BD[6.2109] → [6.2109:2140]

B:BD[6.2140] → [6.2140:2314]

B:BD[43.13950] → [43.13950:14630]

B:BD[43.13950] → [6.1995:2109]

B:BD[22.4337] → [29.26091:26092]

B:BD[29.26092] → [29.26092:26249]

B:BD[29.26410] → [29.26410:27159]

B:BD[29.27259] → [29.27259:27443]

B:BD[29.27159] → [29.27159:27259]

B:BD[29.27159] → [46.59231:59408]

B:BD[29.26249] → [29.26249:26410]

B:BD[29.26249] → [46.58917:59230]

B:BD[29.26092] → [46.58868:58916]

B:BD[22.4337] → [48.8877:11076]

B:BD[48.11156] → [48.11156:13165]

B:BD[48.11076] → [48.11076:11156]

B:BD[48.11076] → [72.5404:5490]

B:BD[22.4337] → [38.7380:7495]

B:BD[38.7538] → [38.7538:7712]

B:BD[38.7495] → [47.7502:7533]

B:BD[38.7495] → [30.10550:10593]

B:BD[38.7495] → [38.7495:7538]

B:BD[55.30773] → [24.57:151]

B:BD[55.30773] → [22.4210:4337]

B:BD[55.30773] → [55.30773:30855]

B:BD[20.4260] → [55.26567:30772]

B:BD[20.4105] → [24.36:56]

B:BD[20.4105] → [22.4182:4209]

B:BD[20.4105] → [20.4105:4260]

B:BD[22.4155] → [43.13904:13948]

B:BD[22.4155] → [29.26046:26090]

B:BD[22.4155] → [46.58815:58867]

B:BD[22.4155] → [22.4155:4181]

B:BD[22.4155] → [48.8832:8876]

B:BD[22.4155] → [49.12407:12433]

B:BD[22.4155] → [53.3626:3652]

B:BD[20.4065] → [20.4065:4066]

B:BD[20.4066] → [40.4096:4140]

B:BD[20.4066] → [41.53:97]

B:BD[20.4066] → [31.7529:7555]

B:BD[20.4066] → [42.9204:9248]

B:BD[20.4066] → [44.58:84]

B:BD[20.4066] → [45.4528:4554]

B:BD[20.4066] → [50.53:89]

B:BD[20.4066] → [51.78:122]

B:BD[20.4066] → [20.4066:4092]

B:BD[20.4066] → [68.0:44]

B:BD[20.4066] → [54.7014:7040]

B:BD[20.4066] → [35.10006:10032]

B:BD[20.4066] → [55.26522:26566]

B:BD[20.4000] → [20.4000:4036]

B:BD[20.4036] → [20.4036:4065]

B:BD[20.3921] → [31.7496:7528]

B:BD[20.3921] → [44.25:57]

B:BD[20.3921] → [45.4495:4527]

B:BD[20.3921] → [22.4084:4116]

B:BD[20.3921] → [49.12374:12406]

B:BD[20.3921] → [20.3921:3953]

B:BD[20.3953] → [20.3953:4000]

B:BD[20.3921] → [53.3593:3625]

B:BD[20.3921] → [54.6981:7013]

B:BD[20.3921] → [35.9973:10005]

B:BD[20.3893] → [20.3893:3920]

B:BD[20.3920] → [20.3920:3921]

B:BD[20.3839] → [20.3839:3874]

B:BD[20.3874] → [20.3874:3893]

B:BD[20.3759] → [20.3759:3787]

B:BD[20.3787] → [20.3787:3839]

B:BD[20.3656] → [20.3656:3712]

B:BD[20.3712] → [20.3712:3759]

B:BD[20.3621] → [49.12351:12373]

B:BD[20.3621] → [20.3621:3643]

B:BD[20.3643] → [20.3643:3656]

B:BD[20.3581] → [20.3581:3621]

B:BD[20.3621] → [53.3570:3592]

B:BD[20.3621] → [54.6958:6980]

B:BD[22.3885] → [29.26016:26045]

B:BD[22.3885] → [22.3885:3910]

B:BD[22.3885] → [48.8802:8831]

B:BD[20.3533] → [20.3533:3556]

B:BD[20.3556] → [42.9174:9203]

B:BD[20.3556] → [20.3556:3581]

B:BD[20.3556] → [55.26492:26521]

B:BD[15.3878] → [26.1470:1505]

B:BD[15.4109] → [15.4109:4129]

B:BD[15.4140] → [15.4140:4179]

B:BD[16.1583] → [25.1742:1781]

B:BD[16.1583] → [28.635:681]

B:BD[16.1583] → [16.1583:1622]

B:BD[16.1583] → [26.1581:1627]

B:BD[15.4179] → [15.4179:4180]

B:BD[15.4179] → [16.1558:1583]

B:BD[15.4140] → [25.1702:1741]

B:BD[15.4140] → [28.588:634]

B:BD[15.4140] → [26.1534:1580]

B:BD[15.4129] → [15.4129:4140]

B:BD[15.4109] → [25.1681:1701]

B:BD[15.4109] → [28.560:587]

B:BD[15.4109] → [26.1506:1533]

B:BD[15.3878] → [27.640:675]

B:BD[10.17] → [15.3551:3878]

B:BD[15.3878] → [15.3878:4109]

B:BD[10.17] → [10.18:30]

B:BD[10.17] → [9.0:21]

B:BD[10.17] → [20.3512:3533]

B:BD[10.17] → [17.40817:40861]

∅:BD[58.44056] → [17.40890:40916]

B:BD[17.40890] → [17.40890:40916]

B:BD[17.40955] → [59.45051:45073]

B:BD[17.41151] → [58.44057:44092]

B:BD[17.41232] → [73.35245:35284]

B:BD[17.41233] → [59.45074:45106]

∅:BD[59.45106] → [17.41233:41280]

B:BD[17.41233] → [17.41233:41280]

∅:BD[21.28813] → [17.41345:41346]

B:BD[17.41345] → [17.41345:41346]

B:BD[17.41390] → [17.41390:41391]

B:BD[17.41391] → [17.41391:41403]

∅:BD[58.44205] → [17.41430:41441]

∅:BD[59.45154] → [17.41430:41441]

B:BD[17.41430] → [17.41430:41441]

∅:BD[58.44252] → [17.41487:41512]

∅:BD[59.45194] → [17.41487:41512]

B:BD[17.41487] → [17.41487:41512]

∅:BD[21.33360] → [17.48631:48632]

∅:BD[58.51372] → [17.48631:48632]

∅:BD[59.45234] → [17.48631:48632]

B:BD[17.48631] → [17.48631:48632]

∅:BD[21.33538] → [58.51537:51546]

B:BD[58.51537] → [58.51537:51546]

B:BD[58.51546] → [21.33539:33632]

B:BD[17.48632] → [58.51373:51537]

B:BD[17.48632] → [21.33361:33538]

B:BD[17.48632] → [17.48632:48805]

B:BD[17.41512] → [59.45195:45234]

B:BD[17.41512] → [58.44253:44300]

B:BD[58.44414] → [58.44414:44457]

B:BD[58.44629] → [58.44629:44652]

∅:BD[21.29149] → [58.44708:44711]

B:BD[58.44708] → [58.44708:44711]

∅:BD[21.29247] → [58.44807:44840]

B:BD[58.44807] → [58.44807:44840]

∅:BD[21.29551] → [58.44953:44954]

B:BD[58.44953] → [58.44953:44954]

∅:BD[21.29613] → [58.45024:45176]

B:BD[58.45024] → [58.45024:45176]

∅:BD[21.29679] → [58.45232:45312]

B:BD[58.45232] → [58.45232:45312]

∅:BD[60.44949] → [58.45467:45579]

∅:BD[62.68871] → [58.45467:45579]

B:BD[58.45467] → [58.45467:45579]

∅:BD[74.38816] → [58.45651:45652]

∅:BD[60.45022] → [58.45651:45652]

∅:BD[21.30244] → [58.45651:45652]

∅:BD[62.68929] → [58.45651:45652]

B:BD[58.45651] → [58.45651:45652]

∅:BD[74.38921] → [58.45730:45785]

B:BD[58.45730] → [58.45730:45785]

B:BD[58.45785] → [58.45785:45842]

∅:BD[21.30283] → [58.45842:45946]

B:BD[58.45842] → [58.45842:45946]

B:BD[58.46029] → [58.46029:46089]

∅:BD[21.30483] → [58.46165:46179]

B:BD[58.46165] → [58.46165:46179]

B:BD[58.46216] → [58.46216:47605]

B:BD[58.47673] → [58.47673:48028]

B:BD[58.48096] → [58.48096:48321]

B:BD[58.48360] → [58.48360:49756]

B:BD[58.49824] → [58.49824:50179]

B:BD[58.50247] → [58.50247:50359]

B:BD[58.50458] → [58.50458:50472]

B:BD[75.11154] → [76.1883:1961]

B:BD[75.11564] → [76.1962:2055]

B:BD[75.11941] → [75.11941:12020]

B:BD[75.12020] → [75.12020:12560]

B:BD[75.11941] → [23.1789:1875]

B:BD[75.11564] → [75.11564:11654]

B:BD[75.11654] → [75.11654:11941]

B:BD[75.11154] → [75.11154:11229]

B:BD[75.11229] → [75.11229:11564]

∅:BD[2.3586] → [58.50966:51009]

∅:BD[21.32912] → [58.50966:51009]

∅:BD[75.12560] → [58.50966:51009]

B:BD[58.50966] → [58.50966:51009]

∅:BD[21.32967] → [58.51065:51068]

B:BD[58.51065] → [58.51065:51068]

∅:BD[21.33056] → [58.51182:51215]

B:BD[58.51182] → [58.51182:51215]

B:BD[58.51215] → [76.2056:2094]

B:BD[58.51215] → [58.51215:51372]

∅:BD[76.2094] → [21.33057:33360]

B:BD[58.51215] → [21.33057:33360]

B:BD[58.51068] → [58.51068:51182]

B:BD[58.51068] → [21.32968:33056]

B:BD[58.51009] → [58.51009:51065]

B:BD[58.51009] → [21.32913:32967]

B:BD[58.50509] → [58.50509:50816]

B:BD[58.50876] → [58.50876:50966]

B:BD[58.50816] → [58.50816:50876]

B:BD[58.50816] → [62.69207:69255]

B:BD[58.50816] → [60.45360:45420]

B:BD[58.50472] → [75.10603:11154]

B:BD[58.50472] → [58.50472:50509]

B:BD[58.50472] → [21.31793:32912]

B:BD[58.50472] → [74.43626:43666]

B:BD[58.50381] → [58.50381:50458]

B:BD[58.50381] → [21.31773:31792]

B:BD[58.50359] → [58.50359:50381]

B:BD[58.50179] → [58.50179:50247]

B:BD[58.50179] → [62.69150:69206]

B:BD[58.50179] → [60.45291:45359]

B:BD[58.49756] → [58.49756:49824]

B:BD[58.49756] → [62.69093:69149]

B:BD[58.49756] → [60.45222:45290]

B:BD[58.48321] → [58.48321:48360]

B:BD[58.48321] → [74.41399:43625]

B:BD[58.48028] → [58.48028:48096]

B:BD[58.48028] → [62.69036:69092]

B:BD[58.48028] → [60.45153:45221]

B:BD[58.47605] → [58.47605:47673]

B:BD[58.47605] → [62.68979:69035]

B:BD[58.47605] → [60.45084:45152]

B:BD[58.46179] → [58.46179:46216]

B:BD[58.46179] → [74.39206:39307]

B:BD[74.39307] → [21.30484:30833]

∅:BD[2.2286] → [21.30908:31243]

∅:BD[76.1442] → [21.30908:31243]

B:BD[21.30908] → [21.30908:31243]

∅:BD[2.2382] → [75.7463:7750]

∅:BD[76.1536] → [75.7463:7750]

B:BD[75.7463] → [75.7463:7750]

∅:BD[2.2466] → [75.7833:7952]

∅:BD[23.1610] → [75.7833:7952]

B:BD[75.7833] → [75.7833:7952]

B:BD[75.8400] → [76.1537:1615]

B:BD[75.8806] → [76.1616:1709]

B:BD[75.9183] → [75.9183:9262]

B:BD[75.10098] → [76.1710:1788]

B:BD[75.10512] → [76.1789:1882]

B:BD[21.31625] → [23.1698:1788]

B:BD[21.31708] → [21.31708:31772]

B:BD[21.31625] → [21.31625:31708]

B:BD[75.10512] → [75.10512:10602]

B:BD[75.10098] → [75.10098:10173]

B:BD[75.10173] → [75.10173:10512]

B:BD[75.9262] → [75.9262:10098]

B:BD[75.9183] → [23.1611:1697]

B:BD[75.8806] → [75.8806:8896]

B:BD[75.8896] → [75.8896:9183]

B:BD[75.8400] → [75.8400:8475]

B:BD[75.8475] → [75.8475:8806]

B:BD[75.7952] → [75.7952:8400]

B:BD[75.7952] → [2.2467:3586]

B:BD[75.7750] → [75.7750:7833]

B:BD[75.7750] → [23.1520:1610]

B:BD[75.7750] → [2.2383:2466]

B:BD[21.31338] → [21.31338:31625]

B:BD[21.31243] → [76.1443:1536]

B:BD[21.31243] → [75.7373:7463]

B:BD[21.31243] → [21.31243:31338]

B:BD[21.31243] → [2.2287:2382]

B:BD[21.30833] → [76.1364:1442]

B:BD[21.30833] → [21.30833:30908]

B:BD[21.30833] → [2.2211:2286]

B:BD[74.39307] → [74.39307:41398]

B:BD[58.46089] → [58.46089:46165]

B:BD[58.46029] → [62.68930:68978]

B:BD[58.46029] → [60.45023:45083]

B:BD[58.45946] → [58.45946:46029]

B:BD[58.45946] → [74.38980:39030]

∅:BD[21.30404] → [74.39177:39205]

B:BD[74.39177] → [74.39177:39205]

B:BD[74.39205] → [21.30405:30483]

B:BD[74.39030] → [21.30284:30404]

B:BD[74.39030] → [74.39030:39177]

B:BD[58.45785] → [74.38922:38979]

B:BD[74.38979] → [21.30245:30283]

B:BD[58.45652] → [58.45652:45730]

B:BD[58.45652] → [74.38817:38921]

B:BD[58.45579] → [58.45579:45651]

B:BD[58.45579] → [62.68872:68929]

B:BD[58.45579] → [60.44950:45022]

B:BD[60.45022] → [74.38252:38253]

∅:BD[21.29746] → [74.38345:38441]

B:BD[74.38345] → [74.38345:38441]

B:BD[74.38441] → [21.29747:30244]

B:BD[74.38441] → [74.38441:38816]

B:BD[74.38253] → [21.29680:29746]

B:BD[74.38253] → [74.38253:38345]

B:BD[58.45312] → [58.45312:45467]

B:BD[58.45312] → [62.68634:68871]

B:BD[58.45312] → [60.44794:44949]

B:BD[58.45176] → [58.45176:45232]

B:BD[58.45176] → [21.29614:29679]

B:BD[58.44954] → [58.44954:45024]

B:BD[58.44954] → [21.29552:29613]

B:BD[58.44840] → [76.1325:1363]

B:BD[58.44840] → [58.44840:44953]

∅:BD[76.1363] → [21.29248:29551]

B:BD[58.44840] → [21.29248:29551]

B:BD[58.44711] → [58.44711:44807]

B:BD[58.44711] → [21.29150:29247]

B:BD[58.44652] → [58.44652:44708]

B:BD[58.44652] → [21.29095:29149]

B:BD[58.44457] → [58.44457:44629]

B:BD[58.44414] → [62.68602:68633]

∅:BD[21.29094] → [60.44750:44793]

B:BD[58.44414] → [60.44750:44793]

B:BD[58.44300] → [58.44300:44414]

B:BD[58.44300] → [21.28814:29094]

B:BD[17.41512] → [17.41512:48631]

B:BD[17.41441] → [59.45155:45194]

B:BD[17.41441] → [58.44206:44252]

B:BD[17.41441] → [17.41441:41487]

B:BD[17.41403] → [59.45134:45154]

B:BD[17.41403] → [58.44178:44205]

B:BD[17.41403] → [17.41403:41430]

B:BD[17.41346] → [59.45107:45133]

B:BD[17.41346] → [58.44133:44177]

B:BD[17.41346] → [17.41346:41390]

B:BD[17.41280] → [21.28783:28813]

B:BD[17.41280] → [17.41280:41345]

B:BD[17.41232] → [58.44093:44132]

B:BD[17.41232] → [77.37170:37209]

B:BD[17.41232] → [60.44710:44749]

B:BD[17.41186] → [17.41186:41232]

B:BD[17.41232] → [17.41232:41233]

B:BD[17.41151] → [17.41151:41186]

B:BD[17.40916] → [17.40916:40955]

B:BD[17.40955] → [17.40955:41151]

B:BD[17.40861] → [58.44027:44056]

B:BD[17.40861] → [17.40861:40890]

#![deny(missing_docs)]
//! XMPP client service
extern crate minidom;
#[macro_use]
extern crate serde_derive;
extern crate tokio;
extern crate tokio_channel;
use hyper::service::service_fn;
use tokio::prelude::future;
use tokio::prelude::Sink;
    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),
        .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))
        .shared();
    let (cmd_send, cmd_recv) = tokio_channel::mpsc::channel(10);
    let http_server = Server::bind(&config.http)
        .serve(move || {
            let cmd_send = cmd_send.clone();
                            Response::builder()
                                .status(hyper::StatusCode::BAD_REQUEST)
                    }
            })
        .map_err(|e| error!("server error: {}", e));
    let mut rt = Runtime::new().expect("Cann't start tokio");
    rt.spawn(http_server);
        let recv = stop_receiver(cmd_recv, ctrl_c.clone().map(|_| ()));
        ctrt.block_on(xmpp_process(
            cmd_recv,
        ))
    info!("Server stopper");
}
    xmpp_join
        .join()
        .expect("Join xmpp thread")
        .expect("Result xmpp thread");
    info!("Server stopped");
    });
    info!("Server started");
    rt.shutdown_on_idle().wait().expect("Shutdown error");
        ));
        info!("Stopping xmpp thread");
        result
            config.account,
            recv,
            ctrl_c.clone().map(|_| ()),
        let result = ctrt.block_on(xmpp_process(
    let xmpp_join = std::thread::spawn(move || -> Result<(), tokio::io::Error> {
        // Launch single-threaded runtime
        let mut ctrt = current_thread::Runtime::new()?;
    let xmpp_join = std::thread::spawn(move || -> Result<(), tokio::io::Error> {
    let xmpp_join = std::thread::spawn(move || -> Result<(), failure::Error> {
    let xmpp_join = std::thread::spawn(move || -> Result<(), failure::Error> {
        }).with_graceful_shutdown(ctrl_c.clone().map(|_| ()))
        }).with_graceful_shutdown(ctrl_c.clone().map(|_| ()))
        })
        .with_graceful_shutdown(ctrl_c.clone().map(|_| ()))
        })
        .with_graceful_shutdown(ctrl_c.clone().map(|_| ()))
                })
                }
                    }
                    Ok(xmpp_to) => {
                        info!("Got request");
                        Box::new(
                            cmd_send
                                .clone()
                                .send(XmppCommand { xmpp_to })
                                .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
                                                ))),
                                        )
                                    }
                                }),
                        ) as Box<Future<Item = _, Error = _> + Send>
                })
                                .body(Body::from(format!("Command sent error: {}", e))),
                        )
                                .body(Body::from(format!("Unknown destination: {}", err))),
                        )) as Box<Future<Item = _, Error = _> + Send>
                                .body(Body::from(format!("Command sent error: {}", e))),
                        )
            service_fn(move |_req: Request<Body>| {
                info!("Got request");
                cmd_send.clone().send(XmppCommand {}).then(|r| match r {
                    Ok(_) => tokio::prelude::future::ok(Response::new(Body::from("Accepted"))),
                    Err(e) => {
                        error!("Command sent error: {}", e);
                        tokio::prelude::future::result(
            service_fn(move |req: Request<Body>| {
                let xmpp_to_opt = req.headers().get("X-XMPP-To");
                let xmpp_to_res: Result<String, std::borrow::Cow<str>> = xmpp_to_opt.map_or_else(
                    || Err("none".into()),
                    |xmpp_to| {
                        xmpp_to.to_str().map(|x| x.to_owned()).map_err(|e| {
                            format!("\"{}\" {}", String::from_utf8_lossy(xmpp_to.as_bytes()), e)
                                .into()
                        })
                    },
                );
                match xmpp_to_res {
                    Err(err) => {
                        warn!("Unknown destination: {}", err);
                        Box::new(tokio::prelude::future::result(
            service_fn(move |_req: Request<Body>| {
                info!("Got request");
                cmd_send.clone().send(XmppCommand {}).then(|r| match r {
                    Ok(_) => tokio::prelude::future::ok(Response::new(Body::from("Accepted"))),
                    Err(e) => {
                        error!("Command sent error: {}", e);
                        tokio::prelude::future::result(
    let config = Config::new(args.value_of("config").expect("Mandatory option config"))
    let config = Config::new(args.value_of("config").expect("Mandatory option config"))
    let config = Config::read(args.value_of("config").expect("Mandatory option config"))
    let config = Config::read(args.value_of("config").expect("Mandatory option config"))
        ).get_matches();
        ).get_matches();
        )
        .get_matches();
        )
        .get_matches();
    println!("Hello, world!");
    println!("Hello, world!");
    println!("Hello, world!");
    env_logger::init();
        ).get_matches();
    let config = Config::new(args.value_of("config").expect("Mandatory option config"))
        .map_err(|_| ())
    let (cmd_send, cmd_recv) = tokio_channel::mpsc::channel(10);
    let (cmd_send, cmd_recv) = tokio_channel::mpsc::channel(10);
        .serve(|| service_fn_ok(hello_world))
        .map_err(|e| eprintln!("server error: {}", e));
    hyper::rt::run(http_server);
    if let Some(ping) = config.account.ping {
        let ping = tokio::timer::Interval::new_interval(std::time::Duration::from_secs(ping));
        rt.spawn(
            ping.map_err(|e| {
                error!("Ping error: {}", e);
            })
            .for_each(move |_| {
                cmd_send
                    .clone()
                    .send(XmppCommand::Ping)
                    .map_err(|e| {
                        error!("Ping command error: {}", e);
                    })
                    .map(|_| ())
            })
            .select(
                ctrl_c
                    .clone()
                    .map(|_| ())
                    .map_err(|e| error!("ping server error: {}", e)),
            )
            .map(|_| ())
            .map_err(|_| ()),
        );
    }
    if let Some(ping) = config.account.ping {
        let ping = tokio::timer::Interval::new_interval(std::time::Duration::from_secs(ping));
        rt.spawn(
            ping.map_err(|e| {
                error!("Ping error: {}", e);
            })
            .for_each(move |_| {
                cmd_send
                    .clone()
                    .send(XmppCommand::Ping)
                    .map_err(|e| {
                        error!("Ping command error: {}", e);
                    })
                    .map(|_| ())
            })
            .select(
                ctrl_c
                    .clone()
                    .map(|_| ())
                    .map_err(|e| error!("ping server error: {}", e)),
            )
            .map(|_| ())
            .map_err(|_| ()),
        );
    }
    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()?;
        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");
        let result = ctrt.block_on(xmpp_process(
            ctrl_c.clone().map(|_| ()),
            recv,
            config.account,
        ));
        let result = ctrt.block_on(xmpp_process(ctrl_c.clone(), recv, config.account));
        let result = ctrt.block_on(xmpp_process(
            ctrl_c.clone().map(|_| ()),
            recv,
            config.account,
        ));
        let result = ctrt.block_on(xmpp_process(
            ctrl_c.clone().map(|_| ()),
            recv,
            config.account,
        ));
        let result = ctrt.block_on(xmpp_process(
            ctrl_c.clone().map(|_| ()),
            recv,
            config.account,
        ));
        let result = ctrt.block_on(xmpp_process(ctrl_c.clone(), recv, config.account));
        let result = ctrt.block_on(xmpp_process(ctrl_c.clone(), recv, config.account));
        let result = ctrt.block_on(xmpp_process(ctrl_c.clone(), recv, config.account));
    if let Some(ping) = config.account.ping {
        let ping = tokio::timer::Interval::new_interval(std::time::Duration::from_secs(ping));
        rt.spawn(
            ping.map_err(|e| {
                error!("Ping error: {}", e);
            })
            .for_each(move |_| {
                cmd_send
                    .clone()
                    .send(XmppCommand::Ping)
                    .map_err(|e| {
                        error!("Ping command error: {}", e);
                    })
                    .map(|_| ())
            })
            .select(
                ctrl_c
                    .clone()
                    .map(|_| ())
                    .map_err(|e| error!("ping server error: {}", e)),
            )
            .map(|_| ())
            .map_err(|_| ()),
        );
    }
    if let Some(ping) = config.account.ping {
        let ping = tokio::timer::Interval::new_interval(std::time::Duration::from_secs(ping));
        rt.spawn(
            ping.map_err(|e| {
                error!("Ping error: {}", e);
            })
            .for_each(move |_| {
                cmd_send
                    .clone()
                    .send(XmppCommand::Ping)
                    .map_err(|e| {
                        error!("Ping command error: {}", e);
                    })
                    .map(|_| ())
            })
            .select(
                ctrl_c
                    .clone()
                    .map(|_| ())
                    .map_err(|e| error!("ping server error: {}", e)),
            )
            .map(|_| ())
            .map_err(|_| ()),
        );
    }
        .map_err(|e| error!("server error: {}", e));
    let mut rt = Runtime::new().expect("Cann't start tokio");
        .map_err(|e| error!("server error: {}", e));
    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");
        .serve(MakeServiceCmd { cmd_send })
        .serve(MakeServiceCmd { cmd_send })
        .serve(move || {
            let cmd_send = cmd_send.clone();
            service_fn(move |_req: Request<Body>| {
                info!("Got request");
                cmd_send.clone().send(XmppCommand {}).then(|r| match r {
                    Ok(_) => tokio::prelude::future::ok(Response::new(Body::from("Accepted"))),
                    Err(e) => {
                        error!("Command sent error: {}", e);
                        tokio::prelude::future::result(
                            Response::builder()
                                .status(hyper::StatusCode::BAD_REQUEST)
                                .body(Body::from(format!("Command sent error: {}", e))),
                        )
                    }
                })
            })
        })
        .serve(MakeServiceCmd { cmd_send })
        .serve(MakeServiceCmd { cmd_send })
        .serve(MakeServiceCmd {
            cmd_send: cmd_send.clone(),
        .with_graceful_shutdown(ctrl_c.clone().map(|_| ()))
        .serve(move || {
            let cmd_send = cmd_send.clone();
            service_fn(move |_req: Request<Body>| {
                info!("Got request");
                cmd_send.clone().send(XmppCommand {}).then(|r| match r {
                    Ok(_) => tokio::prelude::future::ok(Response::new(Body::from("Accepted"))),
                    Err(e) => {
                        error!("Command sent error: {}", e);
                        tokio::prelude::future::result(
                            Response::builder()
                                .status(hyper::StatusCode::BAD_REQUEST)
                                .body(Body::from(format!("Command sent error: {}", e))),
                        )
                    }
                })
            })
        })
        .serve(move || {
            let cmd_send = cmd_send.clone();
            service_fn(move |_req: Request<Body>| {
                info!("Got request");
                cmd_send.clone().send(XmppCommand {}).then(|r| match r {
                    Ok(_) => tokio::prelude::future::ok(Response::new(Body::from("Accepted"))),
                    Err(e) => {
                        error!("Command sent error: {}", e);
                        tokio::prelude::future::result(
                            Response::builder()
                                .status(hyper::StatusCode::BAD_REQUEST)
                                .body(Body::from(format!("Command sent error: {}", e))),
                        )
                    }
                })
            })
        })
        .serve(MakeServiceCmd { cmd_send })
        .serve(MakeServiceCmd { cmd_send })
        .serve(move || {
            let cmd_send = cmd_send.clone();
            service_fn(move |_req: Request<Body>| {
                info!("Got request");
                cmd_send.clone().send(XmppCommand {}).then(|r| match r {
                    Ok(_) => tokio::prelude::future::ok(Response::new(Body::from("Accepted"))),
                    Err(e) => {
                        error!("Command sent error: {}", e);
                        tokio::prelude::future::result(
                            Response::builder()
                                .status(hyper::StatusCode::BAD_REQUEST)
                                .body(Body::from(format!("Command sent error: {}", e))),
                        )
                    }
                })
            })
        })
        .serve(MakeServiceCmd { cmd_send })
        .serve(MakeServiceCmd {
            cmd_send: cmd_send.clone(),
        })
        .serve(move || {
            let cmd_send = cmd_send.clone();
            service_fn(move |_req: Request<Body>| {
                info!("Got request");
                cmd_send.clone().send(XmppCommand {}).then(|r| match r {
                    Ok(_) => tokio::prelude::future::ok(Response::new(Body::from("Accepted"))),
                    Err(e) => {
                        error!("Command sent error: {}", e);
                        tokio::prelude::future::result(
                            Response::builder()
                                .status(hyper::StatusCode::BAD_REQUEST)
                                .body(Body::from(format!("Command sent error: {}", e))),
                        )
                    }
                })
            })
        .serve(MakeServiceCmd { cmd_send })
        .serve(MakeServiceCmd { cmd_send })
        .serve(move || {
            let cmd_send = cmd_send.clone();
            service_fn(move |_req: Request<Body>| {
                info!("Got request");
                cmd_send.clone().send(XmppCommand {}).then(|r| match r {
                    Ok(_) => tokio::prelude::future::ok(Response::new(Body::from("Accepted"))),
                    Err(e) => {
                        error!("Command sent error: {}", e);
                        tokio::prelude::future::result(
                            Response::builder()
                                .status(hyper::StatusCode::BAD_REQUEST)
                                .body(Body::from(format!("Command sent error: {}", e))),
                        )
                    }
                })
            })
        })
        .serve(MakeServiceCmd { cmd_send })
        .serve(MakeServiceCmd {
            cmd_send: cmd_send.clone(),
        })
        .serve(move || {
            let cmd_send = cmd_send.clone();
            service_fn(move |_req: Request<Body>| {
                info!("Got request");
                cmd_send.clone().send(XmppCommand {}).then(|r| match r {
                    Ok(_) => tokio::prelude::future::ok(Response::new(Body::from("Accepted"))),
                    Err(e) => {
                        error!("Command sent error: {}", e);
                        tokio::prelude::future::result(
                            Response::builder()
                                .status(hyper::StatusCode::BAD_REQUEST)
                                .body(Body::from(format!("Command sent error: {}", e))),
                        )
                    }
                })
            })
        })
        .serve(move || {
            let cmd_send = cmd_send.clone();
            service_fn(move |_req: Request<Body>| {
                info!("Got request");
                cmd_send.clone().send(XmppCommand {}).then(|r| match r {
                    Ok(_) => tokio::prelude::future::ok(Response::new(Body::from("Accepted"))),
                    Err(e) => {
                        error!("Command sent error: {}", e);
                        tokio::prelude::future::result(
                            Response::builder()
                                .status(hyper::StatusCode::BAD_REQUEST)
                                .body(Body::from(format!("Command sent error: {}", e))),
                        )
                    }
                })
            })
        })
        .serve(move || {
            let cmd_send = cmd_send.clone();
            service_fn(move |_req: Request<Body>| {
                info!("Got request");
                cmd_send.clone().send(XmppCommand {}).then(|r| match r {
                    Ok(_) => tokio::prelude::future::ok(Response::new(Body::from("Accepted"))),
                    Err(e) => {
                        error!("Command sent error: {}", e);
                        tokio::prelude::future::result(
                            Response::builder()
                                .status(hyper::StatusCode::BAD_REQUEST)
                                .body(Body::from(format!("Command sent error: {}", e))),
                        )
                    }
                })
            })
        })
        .serve(MakeServiceCmd { cmd_send })
        .serve(MakeServiceCmd {
            cmd_send: cmd_send.clone(),
        })
    let http_server = Server::bind(&config.http)
        .map_err(|e| error!("Cann't get CTRL+C signal: {}", e.0))
        .map_err(|e| {
            error!("Cann't get CTRL+C signal: {}", e.0);
            e.0
        })
        .map_err(|e| {
            error!("Cann't get CTRL+C signal: {}", e.0);
            e.0
        })
        .map_err(|e| error!("Cann't get CTRL+C signal: {}", e.0))
        .map_err(|e| error!("Cann't get CTRL+C signal: {}", e.0))
        .shared();
        .map_err(|e| error!("Cann't get CTRL+C signal: {}", e.0))
        .map_err(|e| {
            error!("Cann't get CTRL+C signal: {}", e.0);
            e.0
        })
        .map_err(|e| {
            error!("Cann't get CTRL+C signal: {}", e.0);
            e.0
        })
        .map_err(|e| {
            error!("Cann't get CTRL+C signal: {}", e.0);
            e.0
        })
    let config = Config::read(args.value_of("config").expect("Mandatory option config"))
    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(|_| ())
        )
        .get_matches();
        )
        .get_matches();
    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::new(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(|_| ())
        .shared();
    let (cmd_send, cmd_recv) = tokio_channel::mpsc::channel(10);
        .serve(move || {
            let cmd_send = cmd_send.clone();
            service_fn(move |_req: Request<Body>| {
                info!("Got request");
                cmd_send.clone().send(XmppCommand {}).then(|r| match r {
                    Ok(_) => tokio::prelude::future::ok(Response::new(Body::from("Accepted"))),
                    Err(e) => {
                        error!("Command sent error: {}", e);
                        tokio::prelude::future::result(
                            Response::builder()
                                .status(hyper::StatusCode::BAD_REQUEST)
                                .body(Body::from(format!("Command sent error: {}", e))),
                        )
                    }
                })
            })
        }).with_graceful_shutdown(ctrl_c.clone().map(|_| ()))
    let mut rt = Runtime::new().expect("Cann't start tokio");
    rt.spawn(http_server);
        ctrt.block_on(xmpp_process(
            ctrl_c.clone().map(|_| ()),
            cmd_recv,
        ))
            &config.account.jid,
            &config.account.password,
    });
    info!("Server started");
    rt.shutdown_on_idle().wait().expect("Shutdown error");
    info!("Server stopper");
    xmpp_join
        .join()
        .expect("Join xmpp thread")
        .expect("Result xmpp thread");
            config.account,
    rt.spawn(http_server);
        // Launch single-threaded runtime
        let mut ctrt = current_thread::Runtime::new()?;
    });
    println!("Server started");
    rt.shutdown_on_idle().wait().expect("Shutdown error");
    println!("Server stopper");
    xmpp_join
        .join()
        .expect("Join xmpp thread")
        .expect("Result xmpp thread");
        ctrt.block_on(future::ok::<_, tokio::io::Error>(()))
        ctrt.block_on(xmpp_process(ctrl_c.clone().map(|_| ())))
    let xmpp_join = std::thread::spawn(|| -> Result<(), tokio::io::Error> {
    let xmpp_join = std::thread::spawn(move || -> Result<(), tokio::io::Error> {
        ctrt.block_on(xmpp_process(ctrl_c.clone().map(|_| ()), cmd_recv))
    let xmpp_join = std::thread::spawn(move || -> Result<(), tokio::io::Error> {
        // Launch single-threaded runtime
        let mut ctrt = current_thread::Runtime::new()?;
    hyper::rt::run(http_server);
        .serve(|| service_fn_ok(hello_world))
        .with_graceful_shutdown(ctrl_c.clone().map(|_| ()))
    let mut rt = Runtime::new().expect("Cann't start tokio");
    hyper::rt::run(http_server);
        .map_err(|e| eprintln!("server error: {}", e));
        .map_err(|e| error!("server error: {}", e));
    let http_server = Server::bind(&config.http)
        .map_err(|_| ())
        .map_err(|e| error!("Cann't get CTRL+C signal: {}", e.0))
    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),
    env_logger::init();
    println!("Hello, world!");
    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),
        .expect("Cann't read config file");
    let ctrl_c = tokio_signal::ctrl_c()
        .flatten_stream()
        .into_future()
        .map(|_| ())
        .shared();
    let http_server = Server::bind(&config.http)
        .with_graceful_shutdown(ctrl_c.clone().map(|_| ()))
    if let Some(ping) = config.account.ping {
        let ping = tokio::timer::Interval::new_interval(std::time::Duration::from_secs(ping));
        rt.spawn(
            ping.map_err(|e| {
                error!("Ping error: {}", e);
            })
            .for_each(move |_| {
                cmd_send
                    .clone()
                    .send(XmppCommand::Ping)
                    .map_err(|e| {
                        error!("Ping command error: {}", e);
                    })
                    .map(|_| ())
            })
            .select(
                ctrl_c
                    .clone()
                    .map(|_| ())
                    .map_err(|e| error!("ping server error: {}", e)),
            )
            .map(|_| ())
            .map_err(|_| ()),
        );
    }
    let xmpp_join = std::thread::spawn(move || -> Result<(), tokio::io::Error> {
        let result = ctrt.block_on(xmpp_process(
            ctrl_c.clone().map(|_| ()),
            recv,
            config.account,
        ));
    info!("Server started");
    info!("Server stopped");
    xmpp_join.join().expect("Join to xmpp thread")
    Ok(())
    xmpp_join.join().unwrap();
    Ok(())
    xmpp_join.join().unwrap();
    xmpp_join
        .join()
        .expect("Join xmpp thread")
        .expect("Result xmpp thread");
    http_server.await?;
    http_server.await;
    http_server.await;
    rt.shutdown_on_idle().wait().expect("Shutdown error");
        let result = ctrt.block_on(xmpp_process(ctrl_c.clone(), recv, config.account));
        info!("Stopping xmpp thread");
        result
    });
        let result = ctrt.block_on(xmpp_process(ctrl_c.clone(), recv, config.account));
    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 xmpp_join = std::thread::spawn(move || -> Result<(), failure::Error> {
    if let Some(ping) = config.account.ping {
    }
    let xmpp_join = std::thread::Builder::new()
        .name("XMPP Thread".into())
        .spawn(move || -> Result<(), failure::Error> {
            let recv = stop_receiver(cmd_recv, ctrl_c.clone());
            // Launch single-threaded runtime
            let mut ctrt = tokio::runtime::Builder::new()
                .basic_scheduler()
                .enable_time()
                .enable_io()
                .build()?;
            let result = ctrt.block_on(xmpp_process(ctrl_c.clone(), recv, config.account));
            info!("Stopping xmpp thread");
            result
        })
        .expect("XMPP Thread");
        let mut ping = tokio::time::interval(std::time::Duration::from_secs(ping));
        let mut ctrl_c = ctrl_c.clone();
        tokio::spawn(async move {
            loop {
                let tick = ping.tick();
                tokio::pin!(tick);
                match futures_util::future::select(ctrl_c, tick).await {
                    futures_util::future::Either::Left((_, _)) => break,
                    futures_util::future::Either::Right((_, ctrl_c__)) => {
                        ctrl_c = ctrl_c__;
                        info!("Tick");
                    }
                }
            }
        });
                        if let Err(e) = cmd_send.clone().send(XmppCommand::Ping).await {
                            error!("Cannot send ping command: {}", e);
                        }
                        if let Err(e) = cmd_send.send(XmppCommand::TimeoutCleanup).await {
                            error!("Cann't send cleanup command: {}", e);
                        }
                        cmd_send.clone().send(XmppCommand::Ping).await;
                        cmd_send.send(XmppCommand::TimeoutCleanup).await;
                        cmd_send.clone().send(XmppCommand::Ping).await;
                        cmd_send.send(XmppCommand::TimeoutCleanup).await;
        let ping = tokio::timer::Interval::new_interval(std::time::Duration::from_secs(ping));
        rt.spawn(
            ping.map_err(|e| {
                error!("Ping error: {}", e);
            })
            .for_each(move |_| {
                cmd_send
                    .clone()
                    .send(XmppCommand::Ping)
                    .map_err(|e| {
                        error!("Ping command error: {}", e);
                    })
                    .map(|_| ())
            })
            .select(
                ctrl_c
                    .clone()
                    .map(|_| ())
                    .map_err(|e| error!("ping server error: {}", e)),
            )
            .map(|_| ())
            .map_err(|_| ()),
        );
    if let Some(ping) = config.account.ping {
        let ping = tokio::timer::Interval::new_interval(std::time::Duration::from_secs(ping));
        rt.spawn(
            ping.map_err(|e| {
                error!("Ping error: {}", e);
            })
            .for_each(move |_| {
                cmd_send
                    .clone()
                    .send(XmppCommand::Ping)
    rt.spawn(http_server);
                    .and_then(|cmd_send| cmd_send.send(XmppCommand::TimeoutCleanup))
                    .map_err(|e| {
                        error!("Ping command error: {}", e);
                    })
                    .map(|_| ())
            })
            .select(
                ctrl_c
                    .clone()
                    .map(|_| ())
                    .map_err(|e| error!("ping server error: {}", e)),
            )
            .map(|_| ())
            .map_err(|_| ()),
        );
    }
    let mut rt = Runtime::new().expect("Cann't start tokio");
        .map_err(|e| error!("server error: {}", e));
        .serve(move || {
            let cmd_send = cmd_send.clone();
            service_fn(move |_req: Request<Body>| {
                info!("Got request");
                cmd_send.clone().send(XmppCommand {}).then(|r| match r {
                    Ok(_) => tokio::prelude::future::ok(Response::new(Body::from("Accepted"))),
                    Err(e) => {
                        error!("Command sent error: {}", e);
                        tokio::prelude::future::result(
                            Response::builder()
                                .status(hyper::StatusCode::BAD_REQUEST)
                                .body(Body::from(format!("Command sent error: {}", e))),
                        )
                    }
                })
            })
        }).with_graceful_shutdown(ctrl_c.clone().map(|_| ()))
        .serve(MakeServiceCmd {
            cmd_send: cmd_send.clone(),
        })
        .serve(MakeServiceCmd { cmd_send })
        .serve(MakeServiceCmd {
            cmd_send: cmd_send.clone(),
        })
        .with_graceful_shutdown(ctrl_c.clone());
        .serve(MakeServiceCmd {
            cmd_send: cmd_send.clone(),
        })
        .with_graceful_shutdown(ctrl_c.clone().map(|_| ()))
    let (mut cmd_send, cmd_recv) = tokio::sync::mpsc::channel(10);
    let (cmd_send, cmd_recv) = tokio_channel::mpsc::channel(10);
        .map_err(|e| error!("Cann't get CTRL+C signal: {}", e.0))
        .map_err(|e| {
            error!("Cann't get CTRL+C signal: {}", e.0);
            e.0
        })
        .map_err(|e| {
            error!("Cann't get CTRL+C signal: {}", e.0);
            e.0
        })
    use hyper::rt::{Future, Stream};
    use hyper::rt::{Future, Stream};
    use futures_util::future::FutureExt;
    let ctrl_c = async {
    }
    .shared();
        if let Err(e) = tokio::signal::ctrl_c().await {
            error!("Cann't wait for Ctrl+C: {}", e);
        }
        tokio::signal::ctrl_c().await;
        tokio::signal::ctrl_c().await;
    use hyper::rt::{Future, Stream};
    use hyper::rt::{Future, Stream};
    let config = Config::new(args.value_of("config").expect("Mandatory option config"))
    let config = Config::read(args.value_of("config").expect("Mandatory option config"))
    let config = Config::read(args.value_of("config").expect("Mandatory option config"))
        ).get_matches();
        )
        .get_matches();
        )
        .get_matches();
fn hello_world(_req: Request<Body>) -> Response<Body> {
    Response::new(Body::from("Test"))
}
mod xmpp;
use xmpp::{xmpp_process, XmppCommand};
mod xmpp;
use xmpp::xmpp_process;
use tokio::runtime::Runtime;
mod config;
use config::Config;
use tokio::runtime::current_thread;
use tokio::runtime::current_thread;
use hyper::service::service_fn_ok;
use hyper::{Body, Request, Response, Server};
extern crate tokio_signal;
extern crate tokio_xmpp;
extern crate toml;
extern crate clap;
extern crate hyper;
#[macro_use]
extern crate log;
extern crate env_logger;
#![deny(missing_docs)]
//! XMPP client service
#![deny(missing_docs)]
#![deny(bare_trait_objects)]
extern crate minidom;
extern crate log;
extern crate env_logger;
#[macro_use]
extern crate tokio_channel;
#[macro_use]
extern crate failure;
extern crate xmpp_parsers;
use hyper::service::service_fn_ok;
use tokio::runtime::current_thread;
mod config;
struct ServiceCmd {
    cmd_send: tokio_channel::mpsc::Sender<XmppCommand>,
}
impl hyper::service::Service for ServiceCmd {
    type ReqBody = Body;
    type ResBody = Body;
    type Error = Box<dyn std::error::Error + Sync + Send + 'static>;
    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<jid::Jid, failure::Error> = xmpp_to_opt.map_or_else(
            || Err(format_err!("No X-XMPP-To header")),
            |xmpp_to| {
                std::str::from_utf8(xmpp_to.as_bytes())
                    .map_err(|e| e.into())
                    .and_then(|s| {
                        std::str::FromStr::from_str(s).map_err(|e: jid::JidParseError| e.into())
                    })
            },
        );
        match xmpp_to_res {
            Err(err) => {
                warn!("Unknown destination: {}", err);
                Box::new(tokio::prelude::future::result(
                    Response::builder()
                        .status(hyper::StatusCode::BAD_REQUEST)
                        .body(Body::from(format!("Unknown destination: {}", err)))
                        .map_err(|e| {
                            Box::new(e) as Box<dyn std::error::Error + Sync + Send + 'static>
                        }),
                )) as Box<Future<Item = _, Error = _> + Send + 'static>
            }
            Ok(xmpp_to) => {
                info!("Got request. Reading body...");
                let cmd_send = self.cmd_send.clone();
                Box::new(
                    req.into_body()
                        .map_err(|e| {
                            Box::new(e) as Box<dyn std::error::Error + Sync + Send + 'static>
                        })
                        .fold(String::new(), |mut acc, ch| {
                            std::str::from_utf8(&*ch).map(|s| {
                                acc.push_str(s);
                                acc
                            })
                        })
                        .and_then(move |message: String| {
                            if !message.is_empty() {
                                Box::new(
                                    cmd_send
                                        .clone()
                                        .send(XmppCommand { xmpp_to, message })
                                        .then(|r| match r {
                                            Ok(_) => tokio::prelude::future::ok(Response::new(
                                                Body::from("Accepted"),
                                            )),
                                            Err(e) => {
                                                error!("Command sent error: {}", e);
                                                tokio::prelude::future::result(
                                                    Response::builder()
                                                        .status(hyper::StatusCode::BAD_REQUEST)
                                                        .body(Body::from(format!(
                                                            "Command sent error: {}",
                                                            e
                                                        ))),
                                                )
                                            }
                                        })
                                        .map_err(|e| {
                                            Box::new(e)
                                                as Box<
                                                    dyn std::error::Error + Sync + Send + 'static,
                                                >
                                        }),
                                )
                            } else {
                                warn!("Empty message");
                                Box::new(tokio::prelude::future::result(
                                    Response::builder()
                                        .status(hyper::StatusCode::BAD_REQUEST)
                                        .body(Body::from("Empty message"))
                                        .map_err(|e| {
                                            Box::new(e)
                                                as Box<
                                                    dyn std::error::Error + Sync + Send + 'static,
                                                >
                                        }),
                                ))
                                    as Box<Future<Item = _, Error = _> + Send + 'static>
                            }
                        }),
                ) as Box<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 = Box<dyn std::error::Error + Sync + Send + 'static>;
    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(),
        })
    }
}
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(),
        })
    }
}
}
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(),
        })
    }
}
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(),
        })
    }
}
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(),
        })
    }
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<String, std::borrow::Cow<str>> = xmpp_to_opt.map_or_else(
            || Err("none".into()),
            |xmpp_to| {
                xmpp_to.to_str().map(|x| x.to_owned()).map_err(|e| {
                    format!("\"{}\" {}", String::from_utf8_lossy(xmpp_to.as_bytes()), e).into()
                })
            },
        );
        match xmpp_to_res {
            Err(err) => {
                warn!("Unknown destination: {}", err);
                Box::new(tokio::prelude::future::result(
                    Response::builder()
                        .status(hyper::StatusCode::BAD_REQUEST)
                        .body(Body::from(format!("Unknown destination: {}", err)))
                        .map_err(|e| e.into()),
                )) as Box<Future<Item = _, Error = _> + Send + 'static>
            }
            Ok(xmpp_to) => {
                info!("Got request. Reading body...");
                let cmd_send = self.cmd_send.clone();
                Box::new(
                    req.into_body()
                        .map_err(|e| e.into())
                        .fold(String::new(), |mut acc, ch| {
                            std::str::from_utf8(&*ch).map(|s| {
                                acc.push_str(s);
                                acc
                            })
                        })
                        .and_then(move |msg: String| {
                            if !msg.is_empty() {
                                Box::new(
                                    cmd_send
                                        .clone()
                                        .send(XmppCommand { xmpp_to })
                                        .then(|r| match r {
                                            Ok(_) => tokio::prelude::future::ok(Response::new(
                                                Body::from("Accepted"),
                                            )),
                                            Err(e) => {
                                                error!("Command sent error: {}", e);
                                                tokio::prelude::future::result(
                                                    Response::builder()
                                                        .status(hyper::StatusCode::BAD_REQUEST)
                                                        .body(Body::from(format!(
                                                            "Command sent error: {}",
                                                            e
                                                        ))),
                                                )
                                            }
                                        })
                                        .map_err(|e| e.into()),
                                )
                            } else {
                                warn!("Empty message");
                                Box::new(tokio::prelude::future::result(
                                    Response::builder()
                                        .status(hyper::StatusCode::BAD_REQUEST)
                                        .body(Body::from("Empty message"))
                                        .map_err(|e| e.into()),
                                ))
                                    as Box<Future<Item = _, Error = _> + Send + 'static>
                            }
                        }),
                ) as Box<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(),
        })
    }
}
    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<String, std::borrow::Cow<str>> = xmpp_to_opt.map_or_else(
            || Err("none".into()),
            |xmpp_to| {
                xmpp_to.to_str().map(|x| x.to_owned()).map_err(|e| {
                    format!("\"{}\" {}", String::from_utf8_lossy(xmpp_to.as_bytes()), e).into()
                })
            },
        );
                        .and_then(move |msg: String| {
                            if !msg.is_empty() {
                                Box::new(
                                    cmd_send
                                        .clone()
                                        .send(XmppCommand { xmpp_to })
                                        .then(|r| match r {
                                            Ok(_) => tokio::prelude::future::ok(Response::new(
                                                Body::from("Accepted"),
                                            )),
                                            Err(e) => {
                                                error!("Command sent error: {}", e);
                                                tokio::prelude::future::result(
                                                    Response::builder()
                                                        .status(hyper::StatusCode::BAD_REQUEST)
                                                        .body(Body::from(format!(
                                                            "Command sent error: {}",
                                                            e
                                                        ))),
                                                )
                                            }
                                        })
                                        .map_err(|e| {
                                            Box::new(e)
                                                as Box<
                                                    dyn std::error::Error + Sync + Send + 'static,
                                                >
                                        }),
                                )
                            } else {
                                warn!("Empty message");
                                Box::new(tokio::prelude::future::result(
                                    Response::builder()
                                        .status(hyper::StatusCode::BAD_REQUEST)
                                        .body(Body::from("Empty message"))
                                        .map_err(|e| {
                                            Box::new(e)
                                                as Box<
                                                    dyn std::error::Error + Sync + Send + 'static,
                                                >
                                        }),
                                ))
                                    as Box<Future<Item = _, Error = _> + Send + 'static>
                            }
    type Future = tokio::prelude::future::FutureResult<ServiceCmd, Self::MakeError>;
    type Error = Box<dyn std::error::Error + Sync + Send>;
                        .map_err(|e| Box::new(e) as Box<dyn std::error::Error + Sync + Send>),
                        })
                                .clone()
                                .send(XmppCommand { xmpp_to })
                                .then(|r| match r {
                                    Ok(_) => tokio::prelude::future::ok(Response::new(Body::from(
                                        "Accepted",
                                    ))),
                                    Err(e) => {
                                        error!("Command sent error: {}", e);
                                        tokio::prelude::future::result(
                                            Response::builder()
                                                .status(hyper::StatusCode::BAD_REQUEST)
                                                .body(Body::from(format!(
                                                    "Command sent error: {}",
                                                    e
                                                ))),
                                        )
                                    }
                                })
                                .map_err(|e| {
                                })
                       // }),
                                    Box::new(e)
                                        as Box<dyn std::error::Error + Sync + Send + 'static>
                                    Box::new(e) as Box<dyn std::error::Error + Sync + Send + 'static>
                        .map_err(|e| Box::new(e) as Box<dyn std::error::Error + Sync + Send>),
                        .body(Body::from(format!("Unknown destination: {}", err)))
                        }),
                        .and_then(move |_msg: String| {
                            cmd_send
                    req.into_body()
                        .map_err(|e| {
                            Box::new(e) as Box<dyn std::error::Error + Sync + Send + 'static>
                        })
                        .fold(String::new(), |mut acc, ch| {
                let cmd_send = self.cmd_send.clone();
                        .map_err(|e| {
                            Box::new(e) as Box<dyn std::error::Error + Sync + Send + 'static>
                        }),
    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(),
        })
    }
}
    type Future = tokio::prelude::future::FutureResult<ServiceCmd, Self::Error>;
    type Service = ServiceCmd;
    type Error = hyper::http::Error;
            }
        }
    }
}
struct MakeServiceCmd {
    cmd_send: tokio_channel::mpsc::Sender<XmppCommand>,
}
impl<Ctx> hyper::service::MakeService<Ctx> for MakeServiceCmd {
    type ReqBody = Body;
    type ResBody = Body;
                ) as Box<Future<Item = _, Error = _> + Send>
                    self.cmd_send
                        .clone()
                        .send(XmppCommand { xmpp_to })
                        .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))),
                                )
                            }
                        }),
                Box::new(
                info!("Got request");
            }
            Ok(xmpp_to) => {
                )) as Box<Future<Item = _, Error = _> + Send>
                        .body(Body::from(format!("Unknown destination: {}", err))),
        match xmpp_to_res {
            Err(err) => {
                warn!("Unknown destination: {}", err);
                Box::new(tokio::prelude::future::result(
                    Response::builder()
                        .status(hyper::StatusCode::BAD_REQUEST)
    type Error = Box<dyn std::error::Error + Sync + Send + 'static>;
                ) as Box<Future<Item = _, Error = _> + Send + 'static>
                        .and_then(|msg: String| {*/
                            self.cmd_send
                            std::str::from_utf8(&*ch).map(|s| {
                                acc.push_str(s);
                                acc
                            })
                    /*req.into_body()
                        .map_err(|e| Box::new(e) as Box<dyn std::error::Error + Sync + Send + 'static>)
                        .fold(String::new(), |acc, ch| {
                info!("Got request. Reading body...");
                )) as Box<Future<Item = _, Error = _> + Send + 'static>
                        .map_err(|e| Box::new(e) as Box<dyn std::error::Error + Sync + 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<String, std::borrow::Cow<str>> = xmpp_to_opt.map_or_else(
            || Err("none".into()),
            |xmpp_to| {
                xmpp_to.to_str().map(|x| x.to_owned()).map_err(|e| {
                    format!("\"{}\" {}", String::from_utf8_lossy(xmpp_to.as_bytes()), e).into()
                })
            },
        );
        match xmpp_to_res {
            Err(err) => {
                warn!("Unknown destination: {}", err);
                Box::new(tokio::prelude::future::result(
                    Response::builder()
                        .status(hyper::StatusCode::BAD_REQUEST)
                        .body(Body::from(format!("Unknown destination: {}", err)))
                        .map_err(|e| {
                            Box::new(e) as Box<dyn std::error::Error + Sync + Send + 'static>
                        }),
                )) as Box<Future<Item = _, Error = _> + Send + 'static>
            }
            Ok(xmpp_to) => {
                info!("Got request. Reading body...");
                let cmd_send = self.cmd_send.clone();
                Box::new(
                    req.into_body()
                        .map_err(|e| {
                            Box::new(e) as Box<dyn std::error::Error + Sync + Send + 'static>
                        })
                        .fold(String::new(), |mut acc, ch| {
                            std::str::from_utf8(&*ch).map(|s| {
                                acc.push_str(s);
                                acc
                            })
                        })
                        .and_then(move |message: String| {
                            if !message.is_empty() {
                                Box::new(
                                    cmd_send
                                        .clone()
                                        .send(XmppCommand { xmpp_to, message })
                                        .then(|r| match r {
                                            Ok(_) => tokio::prelude::future::ok(Response::new(
                                                Body::from("Accepted"),
                                            )),
                                            Err(e) => {
                                                error!("Command sent error: {}", e);
                                                tokio::prelude::future::result(
                                                    Response::builder()
                                                        .status(hyper::StatusCode::BAD_REQUEST)
                                                        .body(Body::from(format!(
                                                            "Command sent error: {}",
                                                            e
                                                        ))),
                                                )
                                            }
                                        })
                                        .map_err(|e| {
                                            Box::new(e)
                                                as Box<
                                                    dyn std::error::Error + Sync + Send + 'static,
                                                >
                                        }),
                                )
                            } else {
                                warn!("Empty message");
                                Box::new(tokio::prelude::future::result(
                                    Response::builder()
                                        .status(hyper::StatusCode::BAD_REQUEST)
                                        .body(Body::from("Empty message"))
                                        .map_err(|e| {
                                            Box::new(e)
                                                as Box<
                                                    dyn std::error::Error + Sync + Send + 'static,
                                                >
                                        }),
                                ))
                                    as Box<Future<Item = _, Error = _> + Send + 'static>
                            }
                        }),
                ) as Box<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 = Box<dyn std::error::Error + Sync + Send + 'static>;
    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(),
        })
    }
}
struct ServiceCmd {
    cmd_send: tokio_channel::mpsc::Sender<XmppCommand>,
}
impl hyper::service::Service for ServiceCmd {
    type ReqBody = Body;
    type ResBody = Body;
    type Error = failure::Error;
    type Future =
        Box<dyn Future<Item = Response<Self::ResBody>, Error = Self::Error> + Send + 'static>;
    fn call(&mut self, req: Request<Self::ReqBody>) -> Self::Future {
        let xmpp_to_opt = req.headers().get("X-XMPP-To");
        let xmpp_to_res: Result<xmpp_parsers::Jid, failure::Error> = xmpp_to_opt.map_or_else(
            || Err(format_err!("No X-XMPP-To header")),
            |xmpp_to| {
                std::str::from_utf8(xmpp_to.as_bytes())
                    .map_err(|e| e.into())
                    .and_then(|s| {
                        std::str::FromStr::from_str(s)
                            .map_err(|e: xmpp_parsers::JidParseError| e.into())
                    })
            },
        );
        match xmpp_to_res {
            Err(err) => {
                warn!("Unknown destination: {}", err);
                Box::new(tokio::prelude::future::result(
                    Response::builder()
                        .status(hyper::StatusCode::BAD_REQUEST)
                        .body(Body::from(format!("Unknown destination: {}", err)))
                        .map_err(|e| e.into()),
                )) as Box<dyn Future<Item = _, Error = _> + Send + 'static>
            }
            Ok(xmpp_to) => {
                info!("Got request. Reading body...");
                let cmd_send = self.cmd_send.clone();
                Box::new(
                    req.into_body()
                        .map_err(|e| e.into())
                        .fold(String::new(), |mut acc, ch| {
                            std::str::from_utf8(&*ch).map(|s| {
                                acc.push_str(s);
                                acc
                            })
                        })
                        .and_then(move |message: String| {
                            if !message.is_empty() {
                                Box::new(
                                    cmd_send
                                        .clone()
                                        .send(XmppCommand { xmpp_to, message })
                                        .then(|r| match r {
                                            Ok(_) => tokio::prelude::future::ok(Response::new(
                                                Body::from("Accepted"),
                                            )),
                                            Err(e) => {
                                                error!("Command sent error: {}", e);
                                                tokio::prelude::future::result(
                                                    Response::builder()
                                                        .status(hyper::StatusCode::BAD_REQUEST)
                                                        .body(Body::from(format!(
                                                            "Command sent error: {}",
                                                            e
                                                        ))),
                                                )
                                            }
                                        })
                                        .map_err(|e| e.into()),
                                )
                            } else {
                                warn!("Empty message");
                                Box::new(tokio::prelude::future::result(
                                    Response::builder()
                                        .status(hyper::StatusCode::BAD_REQUEST)
                                        .body(Body::from("Empty message"))
                                        .map_err(|e| e.into()),
                                ))
                                    as Box<dyn Future<Item = _, Error = _> + Send + 'static>
                            }
                        }),
                ) as Box<dyn Future<Item = _, Error = _> + Send + 'static>
            }
        }
    }
}
struct MakeServiceCmd {
    cmd_send: tokio_channel::mpsc::Sender<XmppCommand>,
}
struct ServiceCmd {
    cmd_send: tokio_channel::mpsc::Sender<XmppCommand>,
}
impl hyper::service::Service for ServiceCmd {
    type ReqBody = Body;
    type ResBody = Body;
    type Future =
        Box<dyn Future<Item = Response<Self::ResBody>, Error = Self::Error> + Send + 'static>;
    type Future = Box<dyn Future<Item = Response<Self::ResBody>, Error = Self::Error> + Send>;
    type Future = Box<dyn Future<Item = Response<Self::ResBody>, Error = Self::Error> + Send + 'static>;
    type Error = Box<dyn std::error::Error + Sync + Send>;
    type Error = hyper::http::Error;
    type Error = Box<dyn std::error::Error + Sync + Send + 'static>;
struct ServiceCmd {
    cmd_send: tokio_channel::mpsc::Sender<XmppCommand>,
}
impl hyper::service::Service for ServiceCmd {
    type ReqBody = Body;
    type ResBody = Body;
    type Error = Box<dyn std::error::Error + Sync + Send + 'static>;
    type Future =
        Box<dyn Future<Item = Response<Self::ResBody>, Error = Self::Error> + Send + 'static>;
        .map_err(std::convert::Into::into)
                    .map_err(std::convert::Into::into)
                            .map_err(std::convert::Into::into)
            .map(|h| h.to_str().map(std::string::ToString::to_string));
                warn!("Unknown destination: {}", err);
                Box::new(tokio::prelude::future::result(
                    Response::builder()
                        .status(hyper::StatusCode::BAD_REQUEST)
                        .body(Body::from(format!("Unknown destination: {}", err)))
                )) as Box<dyn Future<Item = _, Error = _> + Send + 'static>
            }
                info!("Got request. Reading body...");
                let cmd_send = self.cmd_send.clone();
                                .map_err(std::convert::Into::into),
                                .map_err(std::convert::Into::into),
            }
                                .map_err(std::convert::Into::into),
                                .map_err(std::convert::Into::into),
                        .map_err(std::convert::Into::into),
                        .map_err(|e| e.into()),
                )) as Box<dyn Future<Item = _, Error = _> + Send + 'static>
                                .map_err(|e| e.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(|e| e.into()),
                        )
                    } else {
                        warn!("Empty message");
                        Box::new(tokio::prelude::future::result(
                            Response::builder()
                                .status(hyper::StatusCode::BAD_REQUEST)
                                .body(Body::from("Empty message"))
        }
    }
}
struct MakeServiceCmd {
    cmd_send: tokio_channel::mpsc::Sender<XmppCommand>,
}
            (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(|e| e.into()),
                        ))
                            as Box<dyn Future<Item = _, Error = _> + Send + 'static>
                    }
                })) as Box<dyn Future<Item = _, Error = _> + Send + 'static>
                                        .send(XmppCommand { xmpp_to, message })
                                        .then(|r| match r {
                                            Ok(_) => tokio::prelude::future::ok(Response::new(
                                                Body::from("Accepted"),
                                            )),
                                            Err(e) => {
                                                error!("Command sent error: {}", e);
                                                tokio::prelude::future::result(
                                                    Response::builder()
                                                        .status(hyper::StatusCode::BAD_REQUEST)
                                                        .body(Body::from(format!(
                                                            "Command sent error: {}",
                                                            e
                                                        ))),
                                                )
                                            }
                                        })
                                        .map_err(|e| e.into()),
                                )
                            } else {
                                warn!("Empty message");
                                Box::new(tokio::prelude::future::result(
                                    Response::builder()
                                        .status(hyper::StatusCode::BAD_REQUEST)
                                        .body(Body::from("Empty message"))
                                        .map_err(|e| e.into()),
                                ))
                                    as Box<dyn Future<Item = _, Error = _> + Send + 'static>
                            }
                        }),
                ) as Box<dyn Future<Item = _, Error = _> + Send + 'static>
                                .map_err(|e| e.into()),
                                .map_err(|e| e.into()),
                                .map_err(|e| e.into()),
                                .map_err(|e| e.into()),
                        .map_err(|e| e.into()),
                        .map_err(std::convert::Into::into),
                )) as Box<dyn Future<Item = _, Error = _> + Send + 'static>
                        .map_err(std::convert::Into::into),
                                .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),
                                .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),
                                .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),
            }
                                .map_err(|e| e.into()),
                        )
                    } else {
                        warn!("Empty message");
                        Box::new(tokio::prelude::future::result(
                            Response::builder()
                                .status(hyper::StatusCode::BAD_REQUEST)
                                .body(Body::from("Empty message"))
                                .map_err(std::convert::Into::into),
                                .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"))
                                        .send(XmppCommand::Chat { xmpp_to, message })
                Box::new(
                    req.into_body()
                        .map_err(|e| e.into())
                        .fold(String::new(), |mut acc, ch| {
                            std::str::from_utf8(&*ch).map(|s| {
                                acc.push_str(s);
                                acc
                            })
                        })
                        .and_then(move |message: String| {
                            if !message.is_empty() {
                                Box::new(
                                    cmd_send
                                        .clone()
                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
                                                ))),
                                        )
                                    }
                                })
                Box::new(
                    req.into_body()
                        .map_err(|e| e.into())
                        .fold(String::new(), |mut acc, ch| {
                            std::str::from_utf8(&*ch).map(|s| {
                                acc.push_str(s);
                                acc
                            })
                        })
                        .and_then(move |message: String| {
                            if !message.is_empty() {
                                Box::new(
                                    cmd_send
                                        .clone()
                                        .send(XmppCommand::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(|e| e.into()),
                                )
                            } else {
                                warn!("Empty message");
                                Box::new(tokio::prelude::future::result(
                                    Response::builder()
                                        .status(hyper::StatusCode::BAD_REQUEST)
                                        .body(Body::from("Empty message"))
                                        .map_err(|e| e.into()),
                                ))
                                    as Box<dyn Future<Item = _, Error = _> + Send + 'static>
                            }
                        }),
                ) as Box<dyn Future<Item = _, Error = _> + Send + 'static>
                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
                                                ))),
                                        )
                                    }
                                })
            Ok(xmpp_to) => {
            (None, Ok(xmpp_to)) => {
            Ok(xmpp_to) => {
            (None, Ok(xmpp_to)) => {
                        .map_err(std::convert::Into::into),
                        .map_err(|e| e.into()),
                        .map_err(|e| e.into()),
                        .map_err(std::convert::Into::into),
                        .map_err(|e| e.into()),
                        .map_err(std::convert::Into::into),
        match (xmpp_muc_opt, xmpp_to_res) {
            (None, Err(err)) => {
            .map(|h| h.to_str().map(|s| s.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(),
        })
    }
}
        match (xmpp_muc_opt, xmpp_to_res) {
            (None, Err(err)) => {
            .map(|h| h.to_str().map(std::string::ToString::to_string));
            .map(|h| h.to_str().map(std::string::ToString::to_string));
            .map(|h| h.to_str().map(|s| s.to_string()));
        match xmpp_to_res {
            Err(err) => {
        let xmpp_muc_opt = req
            .headers()
            .get("X-XMPP-Muc")
        match xmpp_to_res {
            Err(err) => {
        let xmpp_muc_opt = req
            .headers()
            .get("X-XMPP-Muc")
            },
        );
                            .map_err(|e: xmpp_parsers::JidParseError| e.into())
                    })
                    .and_then(|s| std::str::FromStr::from_str(s).map_err(std::convert::Into::into))
                    .map_err(|e| e.into())
                    .and_then(|s| {
                        std::str::FromStr::from_str(s)
                    .map_err(|e| e.into())
                    .and_then(|s| {
                        std::str::FromStr::from_str(s)
                            .map_err(|e: xmpp_parsers::JidParseError| e.into())
                    })
                    .map_err(std::convert::Into::into)
                    .and_then(|s| std::str::FromStr::from_str(s).map_err(std::convert::Into::into))
                    .map_err(|e| e.into())
                    .and_then(|s| {
                        std::str::FromStr::from_str(s)
                            .map_err(|e: xmpp_parsers::JidParseError| e.into())
                    })
                    .map_err(std::convert::Into::into)
                    .and_then(|s| std::str::FromStr::from_str(s).map_err(std::convert::Into::into))
        .map_err(|e| e.into())
        .fold(String::new(), |mut acc, ch| {
            std::str::from_utf8(&*ch).map(|s| {
                acc.push_str(s);
                acc
            })
        })
}
struct ServiceCmd {
    cmd_send: tokio_channel::mpsc::Sender<XmppCommand>,
}
impl hyper::service::Service for ServiceCmd {
    type ReqBody = Body;
    type ResBody = Body;
    type Error = failure::Error;
    type Future =
        Box<dyn Future<Item = Response<Self::ResBody>, Error = Self::Error> + Send + 'static>;
    fn call(&mut self, req: Request<Self::ReqBody>) -> Self::Future {
        let xmpp_to_opt = req.headers().get("X-XMPP-To");
        let xmpp_to_res: Result<xmpp_parsers::Jid, failure::Error> = xmpp_to_opt.map_or_else(
            || Err(format_err!("No X-XMPP-To header")),
            |xmpp_to| {
                std::str::from_utf8(xmpp_to.as_bytes())
fn body_to_string(req: Request<Body>) -> impl Future<Item = String, Error = failure::Error> {
    req.into_body()
fn body_to_string(req: Request<Body>) -> impl Future<Item = String, Error = failure::Error> {
    req.into_body()
        .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)
            },
        );
        let xmpp_muc_opt = req
            .headers()
            .get("X-XMPP-Muc")
            .map(|h| h.to_str().map(std::string::ToString::to_string));
                    .and_then(|s| std::str::FromStr::from_str(s).map_err(std::convert::Into::into))
                    .and_then(|s| {
                        std::str::FromStr::from_str(s)
                            .map_err(std::convert::Into::into)
                    })
        .fold(String::new(), |mut acc, ch| {
            std::str::from_utf8(&*ch).map(|s| {
                acc.push_str(s);
                acc
            })
        .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)
/// Return future with body converted to String
struct ServiceCmd {
    cmd_send: tokio_channel::mpsc::Sender<XmppCommand>,
}
impl hyper::service::Service for ServiceCmd {
    type ReqBody = Body;
    type ResBody = Body;
    type Error = failure::Error;
    type Future =
        Box<dyn Future<Item = Response<Self::ResBody>, Error = Self::Error> + Send + 'static>;
    fn call(&mut self, req: Request<Self::ReqBody>) -> Self::Future {
        let xmpp_to_opt = req.headers().get("X-XMPP-To");
        let xmpp_to_res: Result<xmpp_parsers::Jid, failure::Error> = xmpp_to_opt.map_or_else(
            || Err(format_err!("No X-XMPP-To header")),
            |xmpp_to| {
                std::str::from_utf8(xmpp_to.as_bytes())
                    .map_err(|e| e.into())
                    .and_then(|s| {
                        std::str::FromStr::from_str(s)
                            .map_err(|e: xmpp_parsers::JidParseError| e.into())
                    })
            },
        );
        match xmpp_to_res {
            Err(err) => {
                warn!("Unknown destination: {}", err);
                Box::new(tokio::prelude::future::result(
                    Response::builder()
                        .status(hyper::StatusCode::BAD_REQUEST)
                        .body(Body::from(format!("Unknown destination: {}", err)))
                        .map_err(|e| e.into()),
                )) as Box<dyn Future<Item = _, Error = _> + Send + 'static>
            }
            Ok(xmpp_to) => {
                info!("Got request. Reading body...");
                let cmd_send = self.cmd_send.clone();
                Box::new(
                    req.into_body()
                        .map_err(|e| e.into())
                        .fold(String::new(), |mut acc, ch| {
                            std::str::from_utf8(&*ch).map(|s| {
                                acc.push_str(s);
                                acc
                            })
                        })
                        .and_then(move |message: String| {
                            if !message.is_empty() {
                                Box::new(
                                    cmd_send
                                        .clone()
                                        .then(|r| match r {
                                            Ok(_) => tokio::prelude::future::ok(Response::new(
                                                Body::from("Accepted"),
                                            )),
                                            Err(e) => {
                                                error!("Command sent error: {}", e);
                                                tokio::prelude::future::result(
                                                    Response::builder()
                                                        .status(hyper::StatusCode::BAD_REQUEST)
                                                        .body(Body::from(format!(
                                                            "Command sent error: {}",
                                                            e
                                                        ))),
                                                )
                                            }
                                        })
                                        .map_err(|e| e.into()),
                                )
                            } else {
                                warn!("Empty message");
                                Box::new(tokio::prelude::future::result(
                                    Response::builder()
                                        .status(hyper::StatusCode::BAD_REQUEST)
                                        .body(Body::from("Empty message"))
                                        .map_err(|e| e.into()),
                                ))
                                    as Box<dyn Future<Item = _, Error = _> + Send + 'static>
                            }
                        }),
                ) as Box<dyn Future<Item = _, Error = _> + Send + 'static>
            }
        }
    }
}
struct MakeServiceCmd {
    cmd_send: tokio_channel::mpsc::Sender<XmppCommand>,
}
                                        .send(XmppCommand { xmpp_to, message })
                                        .send(XmppCommand::Chat { xmpp_to, message })
fn body_to_string(req: Request<Body>) -> impl Future<Item = String, Error = failure::Error> {
    req.into_body()
        .fold(String::new(), |mut acc, ch| {
            std::str::from_utf8(&*ch).map(|s| {
                acc.push_str(s);
                acc
            })
        })
}
        .map_err(|e| e.into())
        .map_err(std::convert::Into::into)
        .map_err(std::convert::Into::into)
fn hello_world(_req: Request<Body>) -> Response<Body> {
    Response::new(Body::from("Test"))
mod xmpp;
use crate::xmpp::{xmpp_process, XmppCommand};
mod stoppable_receiver;
use crate::stoppable_receiver::stop_receiver;
struct MakeServiceCmd {
    cmd_send: tokio_channel::mpsc::Sender<XmppCommand>,
}
struct ServiceCmd {
    cmd_send: tokio_channel::mpsc::Sender<XmppCommand>,
}
impl hyper::service::Service for ServiceCmd {
    type ReqBody = Body;
    type ResBody = Body;
    type Error = failure::Error;
    type Future =
        Box<dyn Future<Item = Response<Self::ResBody>, Error = Self::Error> + Send + 'static>;
    fn call(&mut self, req: Request<Self::ReqBody>) -> Self::Future {
        let xmpp_to_opt = req.headers().get("X-XMPP-To");
        let xmpp_to_res: Result<xmpp_parsers::Jid, failure::Error> = xmpp_to_opt.map_or_else(
            || Err(format_err!("No X-XMPP-To header")),
            |xmpp_to| {
                std::str::from_utf8(xmpp_to.as_bytes())
                    .map_err(|e| e.into())
                    .and_then(|s| {
                        std::str::FromStr::from_str(s)
                            .map_err(|e: xmpp_parsers::JidParseError| e.into())
                    })
            },
        );
        match xmpp_to_res {
            Err(err) => {
                warn!("Unknown destination: {}", err);
                Box::new(tokio::prelude::future::result(
                    Response::builder()
                        .status(hyper::StatusCode::BAD_REQUEST)
                        .body(Body::from(format!("Unknown destination: {}", err)))
                        .map_err(|e| e.into()),
                )) as Box<dyn Future<Item = _, Error = _> + Send + 'static>
            }
            Ok(xmpp_to) => {
                info!("Got request. Reading body...");
                let cmd_send = self.cmd_send.clone();
                Box::new(
                    req.into_body()
                        .map_err(|e| e.into())
                        .fold(String::new(), |mut acc, ch| {
                            std::str::from_utf8(&*ch).map(|s| {
                                acc.push_str(s);
                                acc
                            })
                        })
                        .and_then(move |message: String| {
                            if !message.is_empty() {
                                Box::new(
                                    cmd_send
                                        .clone()
                                        .send(XmppCommand { xmpp_to, message })
                                        .then(|r| match r {
                                            Ok(_) => tokio::prelude::future::ok(Response::new(
                                                Body::from("Accepted"),
                                            )),
                                            Err(e) => {
                                                error!("Command sent error: {}", e);
                                                tokio::prelude::future::result(
                                                    Response::builder()
                                                        .status(hyper::StatusCode::BAD_REQUEST)
                                                        .body(Body::from(format!(
                                                            "Command sent error: {}",
                                                            e
                                                        ))),
                                                )
                                            }
                                        })
                                        .map_err(|e| e.into()),
                                )
                            } else {
                                warn!("Empty message");
                                Box::new(tokio::prelude::future::result(
                                    Response::builder()
                                        .status(hyper::StatusCode::BAD_REQUEST)
                                        .body(Body::from("Empty message"))
                                        .map_err(|e| e.into()),
                                ))
                                    as Box<dyn Future<Item = _, Error = _> + Send + 'static>
                            }
                        }),
                ) as Box<dyn Future<Item = _, Error = _> + Send + 'static>
            }
        }
    }
}
use config::Config;
use crate::config::Config;
use crate::config::Config;
mod xmpp;
use crate::xmpp::{xmpp_process, XmppCommand};
mod stoppable_receiver;
use crate::stoppable_receiver::stop_receiver;
use tokio::prelude::{Future, Sink, Stream};
use tokio::prelude::{Future, Sink, Stream};
use tokio::prelude::{future, Future, Sink, Stream};
use tokio::prelude::Sink;
use tokio::prelude::{Future, Sink, Stream};
use tokio::prelude::Sink;
use tokio::prelude::Sink;
use tokio::prelude::{Future, Sink, Stream};
use tokio::prelude::{Future, Sink, Stream};
use tokio::prelude::Sink;
use tokio::prelude::{Future, Sink, Stream};
use tokio::prelude::Sink;
use tokio::prelude::Sink;
use tokio::prelude::{Future, Sink};
use tokio::prelude::{Future, Sink, Stream};
use tokio::prelude::Sink;
use tokio::prelude::{Future, Sink, Stream};
use tokio::prelude::Sink;
use tokio::prelude::Sink;
use tokio::prelude::{Future, Sink, Stream};
use tokio::runtime::current_thread;
use tokio::runtime::Runtime;
use hyper::service::service_fn;
use hyper::service::service_fn;
use hyper::service::service_fn;
use hyper::service::service_fn;
use hyper::service::service_fn;
use hyper::service::service_fn;
use hyper::{Body, Request, Response, Server};
use hyper::service::service_fn;
use hyper::service::service_fn;
use hyper::service::service_fn;
extern crate xmpp_parsers;
#[macro_use]
extern crate failure;
extern crate toml;
extern crate tokio_channel;
extern crate tokio_signal;
extern crate tokio_xmpp;
extern crate log;
extern crate env_logger;
#[macro_use]
extern crate serde_derive;
extern crate tokio;
extern crate minidom;
extern crate minidom;
#[macro_use]
extern crate clap;
extern crate hyper;
extern crate minidom;
extern crate minidom;
#![deny(bare_trait_objects)]
//! XMPP client service
#![deny(bare_trait_objects)]
#![deny(missing_docs)]
#![deny(bare_trait_objects)]
//! XMPP client service
#![deny(bare_trait_objects)]
#[macro_use]
extern crate failure;
use config::Config;
use xmpp::{xmpp_process, XmppCommand};
use stoppable_receiver::stop_receiver;
use crate::stoppable_receiver::stop_receiver;
use stoppable_receiver::stop_receiver;
use crate::stoppable_receiver::stop_receiver;
mod stoppable_receiver;
use xmpp::{xmpp_process, XmppCommand};
use crate::xmpp::{xmpp_process, XmppCommand};
use crate::xmpp::{xmpp_process, XmppCommand};
mod xmpp;
use config::Config;
use crate::config::Config;
use crate::config::Config;
#[macro_use]
extern crate failure;
#![deny(deprecated)]
#![deny(missing_docs)]
//! XMPP client service
extern crate clap;
extern crate hyper;
extern crate minidom;
#[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;
extern crate toml;
extern crate xmpp_parsers;
use hyper::service::service_fn;
use hyper::{Body, Request, Response, Server};
use tokio::runtime::current_thread;
use tokio::runtime::Runtime;
use tokio::prelude::Sink;
mod config;
fn main() {
#![deny(deprecated)]
#![deny(deprecated)]
#![deny(deprecated)]
#![deny(missing_docs)]
//! XMPP client service
extern crate minidom;
#[macro_use]
extern crate failure;
#[macro_use]
extern crate lazy_static;
use hyper::service::service_fn;
use hyper::{Body, Request, Response, Server};
mod config;
mod xmpp;
mod stoppable_receiver;
    }
}
/// Entry point of daemon
#[tokio::main]
pub async fn main() -> Result<(), failure::Error> {
    fn make_service(&mut self, _ctx: Ctx) -> Self::Future {
        tokio::prelude::future::ok(ServiceCmd {
            cmd_send: self.cmd_send.clone(),
        })
    fn call(&mut self, _: T) -> Self::Future {
        let cmd_send = self.cmd_send.clone();
        let fut = async move { Ok(ServiceCmd { cmd_send }) };
        Box::pin(fut)
    fn make_service(&mut self, _ctx: Ctx) -> Self::Future {
        tokio::prelude::future::ok(ServiceCmd {
            cmd_send: self.cmd_send.clone(),
        })
    }
}
use stoppable_receiver::stop_receiver;
use crate::stoppable_receiver::stop_receiver;
        .map_err(std::convert::Into::into)
}
struct ServiceCmd {
}
    type Error = failure::Error;
        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(
            |xmpp_to| {
                std::str::from_utf8(xmpp_to.as_bytes())
            },
        );
        let xmpp_muc_opt = req
            .headers()
            .get("X-XMPP-Muc")
                warn!("Unknown destination: {}", err);
                Box::new(tokio::prelude::future::result(
                    Response::builder()
                        .status(hyper::StatusCode::BAD_REQUEST)
                        .map_err(std::convert::Into::into),
            }
                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
                                                ))),
                                        )
                                    }
                                })
                        )
                    } else {
                        warn!("Empty message");
                        Box::new(tokio::prelude::future::result(
                            Response::builder()
                                .status(hyper::StatusCode::BAD_REQUEST)
                                .body(Body::from("Empty message"))
                        ))
                            as Box<dyn Future<Item = _, Error = _> + Send + 'static>
                    }
                })) as Box<dyn Future<Item = _, Error = _> + Send + 'static>
            }
                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
                                                ))),
                                        )
                                    }
                                })
                        )
                    } else {
                        warn!("Empty message");
                        Box::new(tokio::prelude::future::result(
                            Response::builder()
                                .status(hyper::StatusCode::BAD_REQUEST)
                                .body(Body::from("Empty message"))
                        ))
                            as Box<dyn Future<Item = _, Error = _> + Send + 'static>
            }
                                    .body(Body::from("Accepted".to_string()))
                                        .body(Body::from("Cann't send command".to_string()))
                            .body(Body::from(format!("Cann't get chat text")))
                            .map_err(std::convert::Into::into),
                    }
                })
            }
            (Some(Err(err)), _, _) => {
                warn!("Unknown muc destination: {}", err);
                Box::pin(async move {
                    Response::builder()
                        .status(hyper::StatusCode::BAD_REQUEST)
                        .body(Body::from(format!("Unknown muc destination: {}", err,)))
                        .map_err(std::convert::Into::into)
                })
            }
                            .body(Body::from(format!("Cann't get chat text: {}", e)))
                                        .body(Body::from(format!("Cann't send command")))
                                        .map_err(std::convert::Into::into)
                                }
                            }
                        }
                        Err(e) => Response::builder()
                            .status(hyper::StatusCode::BAD_REQUEST)
                                    .body(Body::from(format!("Accepted")))
                                    .map_err(std::convert::Into::into),
                                Err(e) => {
                                    error!("Cann't send MUC chat command: {}", e);
                                    Response::builder()
                                        .status(hyper::StatusCode::BAD_REQUEST)
        }
    }
}
struct MakeServiceCmd {
}
    type Error = failure::Error;
    #[allow(clippy::type_complexity)]
    type Service = ServiceCmd;
    type Future = tokio::prelude::future::FutureResult<ServiceCmd, Self::MakeError>;
    type MakeError = hyper::http::Error;
    type Future = std::pin::Pin<
        Box<dyn std::future::Future<Output = Result<Self::Response, Self::Error>> + Send>,
    >;
    fn poll_ready(
        &mut self,
        _: &mut std::task::Context,
    ) -> std::task::Poll<Result<(), Self::Error>> {
        std::task::Poll::Ready(Ok(()))
    }
impl<Ctx> hyper::service::MakeService<Ctx> for MakeServiceCmd {
    type ReqBody = Body;
    type ResBody = Body;
impl<T> hyper::service::Service<T> for MakeServiceCmd {
    type Response = ServiceCmd;
    cmd_send: tokio_channel::mpsc::Sender<XmppCommand>,
    cmd_send: tokio::sync::mpsc::Sender<XmppCommand>,
                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)))
                )) as Box<dyn Future<Item = _, Error = _> + Send + 'static>
            }
                        .map_err(std::convert::Into::into),
                        .map_err(|e| e.into()),
                        .map_err(std::convert::Into::into),
            (Some(Ok(muc_id)), _, _) => {
                info!("Got MUC chat request. Reading body...");
                let mut cmd_send = self.cmd_send.clone();
                Box::pin(async move {
                    match body_to_string(req).await {
                        Ok(message) => {
                            match cmd_send
                                .send(XmppCommand::Chatroom { muc_id, message })
                                .await
                            {
                                Ok(_) => Response::builder()
            (Some(Err(err)), _) => {
            (None, Ok(xmpp_to), _) => Box::pin(async {
                Response::builder()
                    .status(hyper::StatusCode::BAD_REQUEST)
                    .body(Body::from(format!("SOON")))
                    .map_err(std::convert::Into::into)
            }),
            (Some(Ok(muc_id)), _, Ok(show)) => Box::pin(async {
                Response::builder()
                    .status(hyper::StatusCode::BAD_REQUEST)
                    .body(Body::from(format!("SOON")))
                    .map_err(std::convert::Into::into)
            }),
            (Some(Ok(muc_id)), _, _) => Box::pin(async {
                Response::builder()
                    .status(hyper::StatusCode::BAD_REQUEST)
                    .body(Body::from(format!("SOON")))
                    .map_err(std::convert::Into::into)
            }),
            (Some(Err(err)), _, _) => Box::pin(async {
                Response::builder()
                    .status(hyper::StatusCode::BAD_REQUEST)
                    .body(Body::from(format!("SOON")))
                    .map_err(std::convert::Into::into)
            }),
            (Some(Err(err)), _, _) => {
                })) as Box<dyn Future<Item = _, Error = _> + Send + 'static>
                })
                    }
                                .map_err(std::convert::Into::into),
                                .map_err(|e| e.into()),
                                .map_err(std::convert::Into::into),
                                .map_err(std::convert::Into::into),
                                .map_err(|e| e.into()),
                                .map_err(std::convert::Into::into),
            (Some(Ok(muc_id)), _) => {
            (Some(Ok(muc_id)), _, Ok(show)) => {
                info!("Got MUC presence request. Reading body...");
                let cmd_send = self.cmd_send.clone();
                Box::new(body_to_string(req).and_then(move |message: String| {
                    if !message.is_empty() {
                        Box::new(
                            cmd_send
                                .clone()
                                .send(XmppCommand::ChatroomPresence { muc_id, show, message })
                                .then(|r| match r {
                                    Ok(_) => tokio::prelude::future::ok(Response::new(Body::from(
                                        "Accepted",
                                    ))),
                                    Err(e) => {
                                        error!("Command sent error: {}", e);
                                        tokio::prelude::future::result(
                                            Response::builder()
                                                .status(hyper::StatusCode::BAD_REQUEST)
                                                .body(Body::from(format!(
                                                    "Command sent error: {}",
                                                    e
                                                ))),
                                        )
                                    }
                                })
                                .map_err(std::convert::Into::into),
                        )
                    } else {
                        warn!("Empty message");
                        Box::new(tokio::prelude::future::result(
                            Response::builder()
                                .status(hyper::StatusCode::BAD_REQUEST)
                                .body(Body::from("Empty message"))
                                .map_err(std::convert::Into::into),
                        ))
                            as Box<dyn Future<Item = _, Error = _> + Send + 'static>
                    }
                })) as Box<dyn Future<Item = _, Error = _> + Send + 'static>
            }
            (Some(Ok(muc_id)), _, _) => {
                                .map_err(std::convert::Into::into),
                                .map_err(|e| e.into()),
                                .map_err(std::convert::Into::into),
                                .map_err(std::convert::Into::into),
                                .map_err(|e| e.into()),
                                .map_err(std::convert::Into::into),
            (None, Ok(xmpp_to)) => {
            (None, _, Ok(show)) => {
                info!("Got presence request. Reading body...");
                let mut cmd_send = self.cmd_send.clone();
                Box::pin(async move {
                    match body_to_string(req).await {
                        Ok(message) => {
                            match cmd_send.send(XmppCommand::Presence { show, message }).await {
                                Ok(_) => Response::builder()
                                    .map_err(std::convert::Into::into),
                                Err(e) => {
                                    error!("Cann't send presence command: {}", e);
                                    Response::builder()
                                        .status(hyper::StatusCode::BAD_REQUEST)
                                        .map_err(std::convert::Into::into)
                                }
                            }
                        }
                        Err(e) => Response::builder()
                            .status(hyper::StatusCode::BAD_REQUEST)
                            .map_err(std::convert::Into::into),
                    }
                })
            }
                                    .body(Body::from("Accepted".to_string()))
                                        .body(Body::from("Cann't send command".to_string()))
                            .body(Body::from(format!("Cann't get chat text")))
                                    .body(Body::from("Accepted".to_string()))
                                        .body(Body::from("Cann't send command".to_string()))
                            .body(Body::from(format!("Cann't get presence text: {}", e)))
                            .map_err(std::convert::Into::into),
                            .body(Body::from(format!("Cann't get presence text")))
                                        .body(Body::from(format!("Cann't send command")))
                                    .body(Body::from(format!("Accepted")))
                                    .map_err(std::convert::Into::into),
                                Err(e) => {
                                    error!("Cann't send MUC presence command: {}", e);
                                    Response::builder()
                                        .status(hyper::StatusCode::BAD_REQUEST)
                            .map_err(std::convert::Into::into),
                    }
                })
            }
            (Some(Ok(muc_id)), _, Ok(show)) => {
                info!("Got MUC presence request. Reading body...");
                let mut cmd_send = self.cmd_send.clone();
                Box::pin(async move {
                    match body_to_string(req).await {
                        Ok(message) => {
                            match cmd_send
                                .send(XmppCommand::ChatroomPresence {
                                    muc_id,
                                    show,
                                    message,
                                })
                                .await
                            {
                                Ok(_) => Response::builder()
                            .body(Body::from(format!("Cann't get chat text: {}", e)))
                                        .body(Body::from(format!("Cann't send command")))
                                        .map_err(std::convert::Into::into)
                                }
                            }
                        }
                        Err(e) => Response::builder()
                            .status(hyper::StatusCode::BAD_REQUEST)
                                    .body(Body::from(format!("Accepted")))
                                    .map_err(std::convert::Into::into),
                                Err(e) => {
                                    error!("Cann't send chat command: {}", e);
                                    Response::builder()
                                        .status(hyper::StatusCode::BAD_REQUEST)
            (None, Ok(xmpp_to), _) => {
                info!("Got chat request. Reading body...");
                let mut cmd_send = self.cmd_send.clone();
                Box::pin(async move {
                    match body_to_string(req).await {
                        Ok(message) => {
                            match cmd_send.send(XmppCommand::Chat { xmpp_to, message }).await {
                                Ok(_) => Response::builder()
            (None, Ok(xmpp_to), _) => Box::pin(async {
                Response::builder()
                    .status(hyper::StatusCode::BAD_REQUEST)
                    .body(Body::from(format!("SOON")))
                    .map_err(std::convert::Into::into)
            }),
            (Some(Ok(muc_id)), _, Ok(show)) => Box::pin(async {
                Response::builder()
                    .status(hyper::StatusCode::BAD_REQUEST)
                    .body(Body::from(format!("SOON")))
                    .map_err(std::convert::Into::into)
            }),
            (Some(Ok(muc_id)), _, _) => Box::pin(async {
                Response::builder()
                    .status(hyper::StatusCode::BAD_REQUEST)
                    .body(Body::from(format!("SOON")))
                    .map_err(std::convert::Into::into)
            }),
            (Some(Err(err)), _, _) => Box::pin(async {
                Response::builder()
                    .status(hyper::StatusCode::BAD_REQUEST)
                    .body(Body::from(format!("SOON")))
                    .map_err(std::convert::Into::into)
            }),
                            .body(Body::from(format!("Cann't get presence text")))
                            .body(Body::from(format!("Cann't get presence text: {}", e)))
                            .body(Body::from(format!("Cann't get presence text")))
                                        .map_err(std::convert::Into::into)
                                }
                            }
                        }
                        Err(e) => Response::builder()
                            .status(hyper::StatusCode::BAD_REQUEST)
                                        .body(Body::from("Cann't send command".to_string()))
                                        .body(Body::from(format!("Cann't send command")))
                                        .body(Body::from(format!("Cann't get presence text")))
                                        .body(Body::from(format!("Cann't get presence text")))
                                    .body(Body::from("Accepted".to_string()))
                                    .body(Body::from(format!("Accepted")))
                                    .body(Body::from(format!("Accepted")))
                let cmd_send = self.cmd_send.clone();
                Box::new(body_to_string(req).and_then(move |message: String| {
                    if !message.is_empty() {
                        Box::new(
                            cmd_send
                                .clone()
                                .send(XmppCommand::Presence { show, message })
                                .then(|r| match r {
                                    Ok(_) => tokio::prelude::future::ok(Response::new(Body::from(
                                        "Accepted",
                                    ))),
                                    Err(e) => {
                                        error!("Command sent error: {}", e);
                                        tokio::prelude::future::result(
                                            Response::builder()
                                                .status(hyper::StatusCode::BAD_REQUEST)
                                                .body(Body::from(format!(
                                                    "Command sent error: {}",
                                                    e
                                                ))),
                                        )
                                    }
                                })
                                .map_err(std::convert::Into::into),
                        )
                    } else {
                        warn!("Empty message");
                        Box::new(tokio::prelude::future::result(
                            Response::builder()
                                .status(hyper::StatusCode::BAD_REQUEST)
                                .body(Body::from("Empty message"))
                                .map_err(std::convert::Into::into),
                        ))
                            as Box<dyn Future<Item = _, Error = _> + Send + 'static>
                    }
                })) as Box<dyn Future<Item = _, Error = _> + Send + 'static>
            }
            (None, Ok(xmpp_to), _) => {
                )) as Box<dyn Future<Item = _, Error = _> + Send + 'static>
                        .map_err(|e| e.into()),
                        .map_err(std::convert::Into::into),
                        .body(Body::from(format!("Unknown destination: {}", err)))
                        .body(Body::from(format!(
                        )))
                        .map_err(std::convert::Into::into)
                })
                            "Unknown destination: {}\nUnknown destination2: {}",
                            err, err2,
                            "Unknown destination: {}\nUnknown destination: {}",
                            err,
                            err2,
                warn!("Unknown destination2: {}", err2);
                Box::pin(async move {
        match (xmpp_muc_opt, xmpp_to_res) {
            (None, Err(err)) => {
        match (xmpp_muc_opt, xmpp_to_res, xmpp_pres_res) {
            (None, Err(err), Err(err2)) => {
            .map(|h| h.to_str().map(std::string::ToString::to_string));
            .map(|h| h.to_str().map(|s| s.to_string()));
            .map(|h| h.to_str().map(std::string::ToString::to_string));
        let xmpp_pres_res: Result<xmpp_parsers::presence::Show, failure::Error> = xmpp_pres_opt
            .map_or_else(
                || Err(failure::format_err!("No X-XMPP-Presence header")),
                |show| {
                    std::str::from_utf8(show.as_bytes())
                        .map_err(std::convert::Into::into)
                        .and_then(|s| {
                            std::str::FromStr::from_str(s)
                                .map_err(|e| failure::format_err!("Incorrect presence {}", e))
                        })
                },
            );
            .map_or_else(|| Err(format_err!("No X-XMPP-Presence header")),
            |show| {
                std::str::from_utf8(show.as_bytes())
                    .map_err(std::convert::Into::into)
                    .and_then(|s| std::str::FromStr::from_str(s)
                        .map_err(|e| format_err!("Incorrect presence {}", e) ))
            },
        );
        let xmpp_pres_opt = req.headers().get("X-XMPP-Presence");
        let xmpp_pres_opt = req
            .headers()
            .get("X-XMPP-Presence");
                    .map_err(std::convert::Into::into)
                    .and_then(|s| std::str::FromStr::from_str(s).map_err(std::convert::Into::into))
                    .map_err(|e| e.into())
                    .and_then(|s| {
                        std::str::FromStr::from_str(s)
                            .map_err(|e: xmpp_parsers::JidParseError| e.into())
                    })
                    .map_err(std::convert::Into::into)
                    .and_then(|s| std::str::FromStr::from_str(s).map_err(std::convert::Into::into))
            || Err(format_err!("No X-XMPP-To header")),
            || Err(failure::format_err!("No X-XMPP-To header")),
    fn call(&mut self, req: Request<Self::ReqBody>) -> Self::Future {
    fn call(&mut self, req: Request<Body>) -> Self::Future {
    #[allow(clippy::type_complexity)]
    type Future =
        Box<dyn Future<Item = Response<Self::ResBody>, Error = Self::Error> + Send + 'static>;
    type Future = std::pin::Pin<
        Box<dyn std::future::Future<Output = Result<Self::Response, Self::Error>> + Send>,
    >;
    fn poll_ready(
        &mut self,
        _: &mut std::task::Context,
    ) -> std::task::Poll<Result<(), Self::Error>> {
        std::task::Poll::Ready(Ok(()))
    }
impl hyper::service::Service for ServiceCmd {
    type ReqBody = Body;
    type ResBody = Body;
impl hyper::service::Service<Request<Body>> for ServiceCmd {
    type Response = Response<Body>;
    cmd_send: tokio_channel::mpsc::Sender<XmppCommand>,
    cmd_send: tokio::sync::mpsc::Sender<XmppCommand>,
        .fold(String::new(), |mut acc, ch| {
            std::str::from_utf8(&*ch).map(|s| {
                acc.push_str(s);
                acc
            })
        })
        .map_err(|e| e.into())
        .map_err(std::convert::Into::into)
fn body_to_string(req: Request<Body>) -> impl Future<Item = String, Error = failure::Error> {
    req.into_body()
/// Return future with body converted to String
async fn body_to_string(req: Request<Body>) -> Result<String, failure::Error> {
    let whole_body = hyper::body::to_bytes(req.into_body()).await?;
    std::str::from_utf8(&whole_body)
        .map(std::string::ToString::to_string)
use crate::stoppable_receiver::stop_receiver;
fn body_to_string(req: Request<Body>) -> impl Future<Item = String, Error = failure::Error> {
    req.into_body()
        .map_err(std::convert::Into::into)
        .fold(String::new(), |mut acc, ch| {
            std::str::from_utf8(&*ch).map(|s| {
                acc.push_str(s);
                acc
            })
        })
}
struct ServiceCmd {
    cmd_send: tokio_channel::mpsc::Sender<XmppCommand>,
}
impl hyper::service::Service for ServiceCmd {
    type ReqBody = Body;
    type ResBody = Body;
    type Error = failure::Error;
    type Future =
        Box<dyn Future<Item = Response<Self::ResBody>, Error = Self::Error> + Send + 'static>;
    fn call(&mut self, req: Request<Self::ReqBody>) -> Self::Future {
        let xmpp_to_opt = req.headers().get("X-XMPP-To");
        let xmpp_to_res: Result<xmpp_parsers::Jid, failure::Error> = xmpp_to_opt.map_or_else(
            || Err(format_err!("No X-XMPP-To header")),
            |xmpp_to| {
                std::str::from_utf8(xmpp_to.as_bytes())
                    .map_err(std::convert::Into::into)
                    .and_then(|s| std::str::FromStr::from_str(s).map_err(std::convert::Into::into))
            },
        );
        let xmpp_muc_opt = req
            .headers()
            .get("X-XMPP-Muc")
            .map(|h| h.to_str().map(std::string::ToString::to_string));
        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;
use xmpp::{xmpp_process, XmppCommand};
use crate::xmpp::{xmpp_process, XmppCommand};
use crate::xmpp::{xmpp_process, XmppCommand};
use config::Config;
use crate::config::Config;
use crate::config::Config;
use tokio::prelude::Sink;
use tokio::prelude::{Future, Sink, Stream};
use tokio::prelude::{Future, Sink, Stream};
use log::{error, info, warn};
use tokio::runtime::current_thread;
use tokio::runtime::Runtime;
#[macro_use]
extern crate lazy_static;
#[macro_use]
extern crate lazy_static;
#[macro_use]
extern crate lazy_static;
extern crate toml;
extern crate xmpp_parsers;
#[macro_use]
extern crate failure;
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;
#![deny(bare_trait_objects)]
#![deny(bare_trait_objects)]

File deletion: stoppable_receiver.rs

BF:BFD[10.6] → [16.426:449]

BF:BFD[16.449] → [16.450:450]

∅:BD[21.27862] → [58.43965:43966]

B:BD[58.43965] → [58.43965:43966]

∅:BD[21.27893] → [16.559:560]

B:BD[16.559] → [16.559:560]

∅:BD[21.28011] → [16.618:645]

B:BD[16.618] → [16.618:645]

∅:BD[21.28023] → [16.645:688]

B:BD[16.645] → [16.645:688]

B:BD[16.755] → [58.43967:43981]

∅:BD[21.28093] → [16.771:790]

B:BD[16.771] → [16.771:790]

B:BD[16.811] → [16.811:812]

∅:BD[21.28622] → [16.1281:1292]

B:BD[16.1281] → [16.1281:1292]

∅:BD[26.1469] → [16.1322:1331]

∅:BD[78.711] → [16.1322:1331]

∅:BD[21.28654] → [16.1322:1331]

∅:BD[25.1680] → [16.1322:1331]

∅:BD[58.44011] → [16.1322:1331]

∅:BD[59.45050] → [16.1322:1331]

B:BD[16.1322] → [16.1322:1331]

B:BD[16.1445] → [58.44012:44026]

∅:BD[21.28782] → [16.1461:1557]

B:BD[16.1461] → [16.1461:1557]

B:BD[16.1445] → [16.1445:1459]

B:BD[16.1459] → [16.1459:1461]

B:BD[16.1331] → [16.1331:1445]

B:BD[16.1331] → [21.28655:28782]

B:BD[16.1292] → [59.45020:45050]

B:BD[16.1292] → [58.43982:44011]

B:BD[16.1292] → [25.1650:1680]

B:BD[16.1292] → [16.1292:1322]

B:BD[16.1292] → [21.28623:28654]

B:BD[16.1292] → [78.682:711]

B:BD[16.1292] → [26.1440:1469]

B:BD[16.812] → [16.812:1281]

B:BD[16.812] → [21.28094:28622]

B:BD[16.790] → [16.790:811]

B:BD[16.755] → [16.755:769]

B:BD[16.769] → [16.769:771]

B:BD[16.688] → [16.688:755]

B:BD[16.688] → [21.28024:28093]

B:BD[16.645] → [21.28012:28023]

B:BD[16.560] → [16.560:618]

B:BD[16.560] → [21.27894:28011]

B:BD[58.43966] → [21.27863:27893]

B:BD[16.473] → [16.473:559]

B:BD[16.450] → [58.43944:43965]

B:BD[16.450] → [16.451:473]

B:BD[16.450] → [21.27757:27862]


    receiver: Receiver<T>,
    stop_future: F,
    finished: bool,
}
    T: Debug,
    type Item = T;
        }
    }
}
    T: Debug,
    StoppableReceiver {
        receiver,
        stop_future,
        finished: false,
    }
}
    T: Debug,
{
pub fn stop_receiver<T, F>(receiver: Receiver<T>, stop_future: F) -> StoppableReceiver<T, F>
where
    F: Future,
pub fn stop_receiver<T, F: Future<Output = ()>>(
    receiver: Receiver<T>,
    stop_future: F,
) -> StoppableReceiver<T, F> {
        self.receiver.poll();
        self.receiver.poll()
        self.receiver.poll();
        self.receiver.poll();
        receiver.poll_recv(cx)
        self.receiver.poll()
        self.receiver.poll()
    fn poll(&mut self) -> Poll<Option<Self::Item>, Self::Error> {
        if !self.finished {
            match self.stop_future.poll() {
                Err(_) => {
                    self.receiver.close();
                    self.finished = true;
                }
                Ok(Async::Ready(_)) => {
                    self.receiver.close();
                    self.finished = true;
                }
                Ok(Async::NotReady) => {}
            }
    fn poll_next(
        self: Pin<&mut Self>,
        cx: &mut std::task::Context,
    ) -> std::task::Poll<Option<Self::Item>> {
        let StoppableReceiverProj {
            mut receiver,
            stop_future,
            finished,
        } = self.project();
        if *finished {
            return std::task::Poll::Ready(None);
        }
        if let std::task::Poll::Ready(_) = stop_future.poll(cx) {
            *finished = true;
            receiver.close();
            return std::task::Poll::Ready(None);
    type Error = ();
    T: Debug,
{
impl<T, F> Stream for StoppableReceiver<T, F>
where
    F: Future,
impl<T, F: Future<Output = ()>> Stream for StoppableReceiver<T, F> {
    #[pin]
pub struct StoppableReceiver<T, F>
where
    F: Future,
{
#[pin_project(project = StoppableReceiverProj)]
pub struct StoppableReceiver<T, F: Future<Output = ()>> {
    #[pin]
use pin_project::pin_project;
use tokio::prelude::{Async, Future, Poll, Stream};
use tokio_channel::mpsc::Receiver;
use std::fmt::Debug;
use std::fmt::Debug;
use std::future::Future;
use std::pin::Pin;
use tokio::stream::Stream;
use tokio::sync::mpsc::Receiver;

File deletion: config.rs

BF:BFD[10.6] → [9.1384:1395]

BF:BFD[9.1395] → [9.1396:1396]

B:BD[9.1396] → [24.431:462]

B:BD[9.1396] → [63.47759:47801]

B:BD[9.1396] → [79.1945:1976]

B:BD[9.1396] → [29.34225:34256]

B:BD[9.1396] → [58.52906:52937]

B:BD[9.1396] → [30.12118:12149]

B:BD[9.1396] → [77.37210:37241]

∅:BD[39.3575] → [9.1397:1450]

∅:BD[17.51497] → [9.1397:1450]

∅:BD[38.13761] → [9.1397:1450]

∅:BD[60.46349] → [9.1397:1450]

∅:BD[77.37241] → [9.1397:1450]

∅:BD[30.12149] → [9.1397:1450]

∅:BD[58.52937] → [9.1397:1450]

∅:BD[29.34256] → [9.1397:1450]

∅:BD[79.1976] → [9.1397:1450]

∅:BD[63.47801] → [9.1397:1450]

∅:BD[24.462] → [9.1397:1450]

B:BD[9.1396] → [9.1397:1450]

B:BD[9.1450] → [21.35343:35375]

∅:BD[21.35375] → [9.1450:1502]

B:BD[9.1450] → [9.1450:1502]

∅:BD[55.31463] → [9.1523:1549]

∅:BD[49.13225] → [9.1523:1549]

∅:BD[72.5512] → [9.1523:1549]

∅:BD[48.13773] → [9.1523:1549]

∅:BD[58.53021] → [9.1523:1549]

∅:BD[29.34340] → [9.1523:1549]

∅:BD[43.18845] → [9.1523:1549]

∅:BD[59.46500] → [9.1523:1549]

∅:BD[24.484] → [9.1523:1549]

B:BD[9.1523] → [9.1523:1549]

B:BD[24.549] → [24.549:603]

B:BD[24.549] → [22.6216:6271]

B:BD[9.1549] → [24.485:549]

B:BD[9.1549] → [79.1977:2096]

B:BD[9.1549] → [29.34341:34487]

B:BD[9.1549] → [58.53022:53168]

B:BD[9.1549] → [30.12150:12296]

∅:BD[39.3722] → [9.1549:1664]

∅:BD[17.51644] → [9.1549:1664]

∅:BD[38.13908] → [9.1549:1664]

∅:BD[60.46496] → [9.1549:1664]

∅:BD[30.12296] → [9.1549:1664]

∅:BD[22.6271] → [9.1549:1664]

∅:BD[58.53168] → [9.1549:1664]

∅:BD[29.34487] → [9.1549:1664]

∅:BD[79.2096] → [9.1549:1664]

∅:BD[63.48278] → [9.1549:1664]

∅:BD[24.603] → [9.1549:1664]

B:BD[9.1549] → [9.1549:1664]

B:BD[9.1664] → [63.48279:48375]

∅:BD[63.48375] → [9.1664:1681]

B:BD[9.1664] → [9.1664:1681]

∅:BD[26.2513] → [9.1745:1943]

∅:BD[22.6335] → [9.1745:1943]

∅:BD[28.942] → [9.1745:1943]

∅:BD[25.4377] → [9.1745:1943]

∅:BD[58.53232] → [9.1745:1943]

∅:BD[59.46565] → [9.1745:1943]

∅:BD[24.668] → [9.1745:1943]

B:BD[9.1745] → [9.1745:1943]

B:BD[55.31467] → [24.669:780]

B:BD[55.31619] → [24.781:1347]

B:BD[55.31619] → [48.13858:13976]

B:BD[55.31619] → [55.31619:31737]

B:BD[29.34761] → [29.34761:35510]

B:BD[55.31467] → [48.13774:13857]

B:BD[43.19119] → [30.12297:13046]

B:BD[43.19119] → [38.13909:14658]

B:BD[29.34761] → [17.51645:52394]

B:BD[55.31467] → [55.31467:31550]

B:BD[55.31550] → [55.31550:31619]

B:BD[43.19119] → [39.3723:4472]

B:BD[9.1943] → [43.18846:19119]

B:BD[9.1943] → [29.34488:34761]

B:BD[9.1943] → [58.53233:53506]

B:BD[58.53506] → [58.53506:54255]

B:BD[58.53506] → [60.46497:47246]

∅:BD[39.4472] → [9.1943:1945]

∅:BD[55.31737] → [9.1943:1945]

∅:BD[17.52394] → [9.1943:1945]

∅:BD[38.14658] → [9.1943:1945]

∅:BD[60.47246] → [9.1943:1945]

∅:BD[30.13046] → [9.1943:1945]

∅:BD[48.13976] → [9.1943:1945]

∅:BD[58.54255] → [9.1943:1945]

∅:BD[29.35510] → [9.1943:1945]

∅:BD[43.19119] → [9.1943:1945]

∅:BD[24.1347] → [9.1943:1945]

B:BD[9.1943] → [9.1943:1945]

B:BD[9.1945] → [79.2097:2846]

B:BD[9.1943] → [55.31464:31467]

B:BD[9.1681] → [24.604:668]

B:BD[9.1681] → [59.46501:46565]

B:BD[9.1681] → [58.53169:53232]

B:BD[9.1681] → [25.4313:4377]

B:BD[9.1681] → [28.879:942]

B:BD[9.1681] → [22.6272:6335]

B:BD[9.1681] → [9.1681:1745]

B:BD[9.1681] → [26.2450:2513]

B:BD[9.1549] → [60.46350:46496]

B:BD[60.46496] → [63.47802:48278]

B:BD[9.1549] → [38.13762:13908]

B:BD[9.1549] → [17.51498:51644]

B:BD[9.1549] → [39.3576:3722]

B:BD[9.1502] → [24.463:484]

B:BD[9.1502] → [59.46479:46500]

B:BD[9.1502] → [43.18762:18845]

B:BD[9.1502] → [29.34257:34340]

B:BD[9.1502] → [58.52938:53021]

B:BD[9.1502] → [48.13690:13773]

B:BD[9.1502] → [72.5491:5512]

B:BD[9.1502] → [9.1502:1523]

B:BD[9.1502] → [49.13204:13225]

B:BD[9.1502] → [55.31380:31463]

B:BD[9.1396] → [60.46318:46349]

B:BD[9.1396] → [38.13730:13761]

B:BD[9.1396] → [17.51466:51497]

B:BD[9.1396] → [39.3544:3575]

use std::collections::HashMap;
use std::collections::{HashMap, HashSet};
use std::collections::HashMap;
use std::collections::HashMap;
use std::collections::HashMap;
use std::collections::HashMap;
use std::collections::HashMap;
use std::fs::File;
use std::io;
use std::path::Path;
use serde_derive::Deserialize;
#[derive(Debug, Deserialize)]
pub struct Account {
    pub password: String,
    pub chatroom: HashMap<String, xmpp_parsers::Jid>,
    pub chatrooms: HashMap<String, xmpp_parsers::Jid>,
    #[serde(default, deserialize_with = "deserialize_jid_map")]
    #[serde(default, deserialize_with = "deserialize_jid_map")]
    pub chatrooms: HashMap<String, xmpp_parsers::Jid>,
    #[serde(default, deserialize_with = "deserialize_jid_map")]
    pub chatrooms: HashMap<String, xmpp_parsers::Jid>,
    pub ping: Option<u64>,
    #[serde(default, deserialize_with = "deserialize_jid_map")]
    pub chatrooms: HashMap<String, xmpp_parsers::Jid>,
    pub ping: Option<u64>,
    #[serde(default, deserialize_with = "deserialize_jid_map")]
    pub chatrooms: HashMap<String, xmpp_parsers::Jid>,
    pub ping: Option<u64>,
}
#[derive(Debug, Deserialize)]
pub struct Config {
    pub account: Account,
    pub http: std::net::SocketAddr,
    /// map from command name to command definition
    pub commands: HashMap<String, Command>,
}
impl Config {
        use std::io::Read;
        let mut f = File::open(path)?;
        let mut buffer = String::new();
        f.read_to_string(&mut buffer)?;
        Ok(toml::from_str(&buffer).unwrap())
    }
fn deserialize_jid_map<'de, D>(
    deserializer: D,
) -> Result<HashMap<String, xmpp_parsers::Jid>, D::Error>
    let s = HashMap::<String, String>::deserialize(deserializer)?;
    let size = s.len();
    s.into_iter()
        .map(|(k, v)| (k, std::str::FromStr::from_str(&v)))
        .take_while(|(_k, r)| r.is_ok())
        .fold(Ok(HashMap::with_capacity(size)), |res, (k, r)| match res {
            Ok(mut res) => match r {
                Ok(v) => {
                    res.insert(k, v);
                    Ok(res)
                }
                Err(e) => Err(e),
            },
            Err(e) => Err(e),
        })
        .map_err(serde::de::Error::custom)
    let s = String::deserialize(deserializer)?;
    std::str::FromStr::from_str(&s).map_err(serde::de::Error::custom)
    let s = String::deserialize(deserializer)?;
    std::str::FromStr::from_str(&s).map_err(serde::de::Error::custom)
}
fn deserialize_jid_map<'de, D>(
    deserializer: D,
) -> Result<HashMap<String, xmpp_parsers::Jid>, D::Error>
where
    D: serde::Deserializer<'de>,
{
    use serde::Deserialize;
    let s = HashMap::<String, String>::deserialize(deserializer)?;
    let size = s.len();
    s.into_iter()
        .map(|(k, v)| (k, std::str::FromStr::from_str(&v)))
        .take_while(|(_k, r)| r.is_ok())
        .fold(Ok(HashMap::with_capacity(size)), |res, (k, r)| match res {
            Ok(mut res) => match r {
                Ok(v) => {
                    res.insert(k, v);
                    Ok(res)
                }
                Err(e) => Err(e),
            },
            Err(e) => Err(e),
        })
        .map_err(serde::de::Error::custom)
fn deserialize_jid<'de, D>(deserializer: D) -> Result<xmpp_parsers::Jid, D::Error>
}
fn deserialize_jid_map<'de, D>(
    deserializer: D,
) -> Result<HashMap<String, xmpp_parsers::Jid>, D::Error>
where
    D: serde::Deserializer<'de>,
{
    use serde::Deserialize;
    let s = HashMap::<String, String>::deserialize(deserializer)?;
    let size = s.len();
    s.into_iter()
        .map(|(k, v)| (k, std::str::FromStr::from_str(&v)))
        .take_while(|(_k, r)| r.is_ok())
        .fold(Ok(HashMap::with_capacity(size)), |res, (k, r)| match res {
            Ok(mut res) => match r {
                Ok(v) => {
                    res.insert(k, v);
                    Ok(res)
                }
                Err(e) => Err(e),
            },
            Err(e) => Err(e),
        })
        .map_err(serde::de::Error::custom)
}
fn deserialize_jid_map<'de, D>(
    deserializer: D,
) -> Result<HashMap<String, xmpp_parsers::Jid>, D::Error>
where
    D: serde::Deserializer<'de>,
{
    use serde::Deserialize;
    let s = HashMap::<String, String>::deserialize(deserializer)?;
    let size = s.len();
    s.into_iter()
        .map(|(k, v)| (k, std::str::FromStr::from_str(&v)))
        .take_while(|(_k, r)| r.is_ok())
        .fold(Ok(HashMap::with_capacity(size)), |res, (k, r)| match res {
            Ok(mut res) => match r {
                Ok(v) => {
                    res.insert(k, v);
                    Ok(res)
                }
                Err(e) => Err(e),
            },
            Err(e) => Err(e),
        })
        .map_err(serde::de::Error::custom)
}
fn deserialize_jid_map<'de, D>(
    deserializer: D,
) -> Result<HashMap<String, xmpp_parsers::Jid>, D::Error>
where
    D: serde::Deserializer<'de>,
{
    use serde::Deserialize;
    let s = HashMap::<String, String>::deserialize(deserializer)?;
    let size = s.len();
    s.into_iter()
        .map(|(k, v)| (k, std::str::FromStr::from_str(&v)))
        .take_while(|(_k, r)| r.is_ok())
        .fold(Ok(HashMap::with_capacity(size)), |res, (k, r)| match res {
            Ok(mut res) => match r {
                Ok(v) => {
                    res.insert(k, v);
                    Ok(res)
                }
                Err(e) => Err(e),
            },
            Err(e) => Err(e),
        })
        .map_err(serde::de::Error::custom)
fn deserialize_jid<'de, D>(deserializer: D) -> Result<xmpp_parsers::Jid, D::Error>
where
    D: serde::Deserializer<'de>,
{
    use serde::Deserialize;
}
fn deserialize_jid_map<'de, D>(
    deserializer: D,
) -> Result<HashMap<String, xmpp_parsers::Jid>, D::Error>
where
    D: serde::Deserializer<'de>,
{
    use serde::Deserialize;
    let s = HashMap::<String, String>::deserialize(deserializer)?;
    let size = s.len();
    s.into_iter()
        .map(|(k, v)| (k, std::str::FromStr::from_str(&v)))
        .take_while(|(_k, r)| r.is_ok())
        .fold(Ok(HashMap::with_capacity(size)), |res, (k, r)| match res {
            Ok(mut res) => match r {
                Ok(v) => {
                    res.insert(k, v);
                    Ok(res)
                }
                Err(e) => Err(e),
            },
            Err(e) => Err(e),
        })
        .map_err(serde::de::Error::custom)
}
fn deserialize_jid<'de, D>(deserializer: D) -> Result<xmpp_parsers::Jid, D::Error>
where
    D: serde::Deserializer<'de>,
{
    use serde::Deserialize;
    let s = String::deserialize(deserializer)?;
    std::str::FromStr::from_str(&s).map_err(serde::de::Error::custom)
}
fn deserialize_jid<'de, D>(deserializer: D) -> Result<xmpp_parsers::Jid, D::Error>
where
    D: serde::Deserializer<'de>,
{
    use serde::Deserialize;
    let s = String::deserialize(deserializer)?;
    std::str::FromStr::from_str(&s).map_err(serde::de::Error::custom)
}
fn deserialize_jid<'de, D>(deserializer: D) -> Result<xmpp_parsers::Jid, D::Error>
where
    D: serde::Deserializer<'de>,
{
    use serde::Deserialize;
    let s = String::deserialize(deserializer)?;
    std::str::FromStr::from_str(&s).map_err(serde::de::Error::custom)
}
fn deserialize_jid_map<'de, D>(
    deserializer: D,
) -> Result<HashMap<String, xmpp_parsers::Jid>, D::Error>
where
    D: serde::Deserializer<'de>,
{
    use serde::Deserialize;
    let s = HashMap::<String, String>::deserialize(deserializer)?;
    let size = s.len();
    s.into_iter()
        .map(|(k, v)| (k, std::str::FromStr::from_str(&v)))
        .take_while(|(_k, r)| r.is_ok())
        .fold(Ok(HashMap::with_capacity(size)), |res, (k, r)| match res {
            Ok(mut res) => match r {
                Ok(v) => {
                    res.insert(k, v);
                    Ok(res)
                }
                Err(e) => Err(e),
            },
            Err(e) => Err(e),
        })
        .map_err(serde::de::Error::custom)
}
fn deserialize_jid_map<'de, D>(
    deserializer: D,
) -> Result<HashMap<String, xmpp_parsers::Jid>, D::Error>
where
    D: serde::Deserializer<'de>,
{
    use serde::Deserialize;
    let s = HashMap::<String, String>::deserialize(deserializer)?;
    let size = s.len();
    s.into_iter()
        .map(|(k, v)| (k, std::str::FromStr::from_str(&v)))
        .take_while(|(_k, r)| r.is_ok())
        .fold(Ok(HashMap::with_capacity(size)), |res, (k, r)| match res {
            Ok(mut res) => match r {
                Ok(v) => {
                    res.insert(k, v);
                    Ok(res)
                }
                Err(e) => Err(e),
            },
            Err(e) => Err(e),
        })
        .map_err(serde::de::Error::custom)
}
fn deserialize_jid_map<'de, D>(
    deserializer: D,
) -> Result<HashMap<String, xmpp_parsers::Jid>, D::Error>
where
    D: serde::Deserializer<'de>,
{
    use serde::Deserialize;
    let s = HashMap::<String, String>::deserialize(deserializer)?;
    let size = s.len();
    s.into_iter()
        .map(|(k, v)| (k, std::str::FromStr::from_str(&v)))
        .take_while(|(_k, r)| r.is_ok())
        .fold(Ok(HashMap::with_capacity(size)), |res, (k, r)| match res {
            Ok(mut res) => match r {
                Ok(v) => {
                    res.insert(k, v);
                    Ok(res)
                }
                Err(e) => Err(e),
            },
            Err(e) => Err(e),
        })
        .map_err(serde::de::Error::custom)
}
}
    pub fn new<P: AsRef<Path>>(path: P) -> io::Result<Config> {
    pub fn new<P: AsRef<Path>>(path: P) -> io::Result<Config> {
    pub fn read<P: AsRef<Path>>(path: P) -> io::Result<Self> {
    pub fn new<P: AsRef<Path>>(path: P) -> io::Result<Config> {
    pub fn read<P: AsRef<Path>>(path: P) -> io::Result<Self> {
    pub fn read<P: AsRef<Path>>(path: P) -> io::Result<Self> {
    pub fn new<P: AsRef<Path>>(path: P) -> io::Result<Config> {
    pub fn read<P: AsRef<Path>>(path: P) -> io::Result<Self> {
    #[serde(default, deserialize_with = "deserialize_jid_map")]
    pub chatrooms: HashMap<String, xmpp_parsers::Jid>,
    pub ping: Option<u64>,
}
#[derive(Debug, Deserialize)]
pub struct CmdArgs {
    pub name: String,
}
/// Allowed sources of command
#[derive(Debug, Deserialize, PartialEq, Eq, Hash)]
pub enum Source {
    /// Direct message
    Message,
    /// Groupchat message
    GroupChat,
    /// Private groupchat message
    PrivateGroupChat,
}
/// Command to execute
#[derive(Debug, Deserialize)]
pub struct Command {
    pub source: HashSet<Source>,
    /// Command arguments
    pub args: Vec<CmdArgs>,
    #[serde(default, deserialize_with = "deserialize_jid_map")]
    pub chatrooms: HashMap<String, xmpp_parsers::Jid>,
    pub ping: Option<u64>,
    #[serde(default, deserialize_with = "deserialize_jid_map")]
    pub chatrooms: HashMap<String, xmpp_parsers::Jid>,
    pub ping: Option<u64>,
    #[serde(default, deserialize_with = "deserialize_jid_map")]
    pub chatrooms: HashMap<String, xmpp_parsers::Jid>,
    pub ping: Option<u64>,
    pub jid: String,
    pub jid: String,
    #[serde(deserialize_with = "deserialize_jid")]
    pub jid: xmpp_parsers::Jid,
    #[serde(deserialize_with = "deserialize_jid")]
    pub jid: xmpp_parsers::Jid,
    #[serde(deserialize_with = "deserialize_jid")]
    pub jid: xmpp_parsers::Jid,
    #[serde(deserialize_with = "deserialize_jid")]
    pub jid: xmpp_parsers::Jid,
    pub jid: String,
    pub jid: String,
    pub jid: String,
    #[serde(deserialize_with = "deserialize_jid")]
    pub jid: xmpp_parsers::Jid,
use std::collections::HashMap;
use std::collections::HashMap;
use std::collections::HashMap;
use std::collections::HashMap;

File deletion: xmpp
BF:BFD[10.6] → [80.0:6]
BF:BFD[80.6] → [80.7:7]

File deletion: stanzas.rs

BF:BFD[80.7] → [15.0:12]

BF:BFD[15.12] → [15.13:13]

∅:BD[26.28] → [15.35:57]

∅:BD[28.28] → [15.35:57]

∅:BD[25.21] → [15.35:57]

∅:BD[58.35308] → [15.35:57]

∅:BD[59.34168] → [15.35:57]

B:BD[15.35] → [15.35:57]

B:BD[81.26] → [82.0:57]

B:BD[55.26] → [43.0:57]

B:BD[43.57] → [30.0:30]

B:BD[43.57] → [38.0:30]

B:BD[43.57] → [39.0:30]

B:BD[55.26] → [29.0:57]

B:BD[29.57] → [29.57:87]

B:BD[29.57] → [17.29190:29220]

B:BD[55.26] → [48.0:57]

B:BD[55.26] → [55.26:83]

B:BD[15.57] → [40.0:26]

∅:BD[39.30] → [15.57:141]

∅:BD[37.26] → [15.57:141]

∅:BD[55.83] → [15.57:141]

∅:BD[81.26] → [15.57:141]

∅:BD[17.29220] → [15.57:141]

∅:BD[38.30] → [15.57:141]

∅:BD[83.26] → [15.57:141]

∅:BD[60.39008] → [15.57:141]

∅:BD[84.26] → [15.57:141]

∅:BD[30.30] → [15.57:141]

∅:BD[48.57] → [15.57:141]

∅:BD[58.35422] → [15.57:141]

∅:BD[29.87] → [15.57:141]

∅:BD[43.57] → [15.57:141]

∅:BD[40.26] → [15.57:141]

∅:BD[82.57] → [15.57:141]

B:BD[15.57] → [15.57:141]

B:BD[29.130] → [85.33891:33967]

B:BD[29.130] → [86.32200:32276]

B:BD[29.130] → [87.32681:32757]

B:BD[15.141] → [40.27:61]

∅:BD[87.32757] → [15.141:142]

∅:BD[74.35660] → [15.141:142]

∅:BD[37.61] → [15.141:142]

∅:BD[55.126] → [15.141:142]

∅:BD[81.61] → [15.141:142]

∅:BD[88.42] → [15.141:142]

∅:BD[83.61] → [15.141:142]

∅:BD[60.39127] → [15.141:142]

∅:BD[84.61] → [15.141:142]

∅:BD[49.34] → [15.141:142]

∅:BD[77.34223] → [15.141:142]

∅:BD[21.22242] → [15.141:142]

∅:BD[89.42] → [15.141:142]

∅:BD[58.35541] → [15.141:142]

∅:BD[90.34] → [15.141:142]

∅:BD[29.130] → [15.141:142]

∅:BD[86.32276] → [15.141:142]

∅:BD[85.33967] → [15.141:142]

∅:BD[40.61] → [15.141:142]

B:BD[15.141] → [15.141:142]

∅:BD[87.32812] → [15.196:254]

∅:BD[74.35741] → [15.196:254]

∅:BD[21.22331] → [15.196:254]

∅:BD[91.29381] → [15.196:254]

B:BD[15.196] → [15.196:254]

B:BD[15.254] → [15.254:294]

B:BD[15.325] → [15.325:397]

B:BD[15.419] → [40.62:272]

B:BD[55.196] → [92.0:126]

B:BD[55.359] → [29.1690:1928]

B:BD[17.30150] → [85.34221:34312]

B:BD[17.30356] → [85.34313:34817]

B:BD[17.30372] → [17.30372:30374]

B:BD[17.30374] → [86.32814:33309]

B:BD[87.33169] → [87.33169:33662]

B:BD[17.30356] → [86.32804:32813]

B:BD[17.30356] → [91.29508:29524]

B:BD[17.30356] → [17.30356:30372]

B:BD[17.30356] → [93.32760:32776]

B:BD[87.33167] → [87.33167:33169]

B:BD[17.30356] → [87.33158:33167]

B:BD[17.30150] → [86.32712:32803]

B:BD[17.30150] → [91.29411:29507]

B:BD[29.1930] → [29.1930:2362]

B:BD[17.30150] → [17.30150:30246]

B:BD[17.30246] → [17.30246:30356]

B:BD[29.1930] → [17.29702:30150]

B:BD[17.30150] → [93.32663:32759]

B:BD[17.30150] → [87.33066:33157]

B:BD[29.1928] → [29.1928:1930]

B:BD[55.359] → [55.359:360]

B:BD[43.128] → [92.127:480]

B:BD[43.309] → [43.309:361]

B:BD[48.182] → [43.597:909]

B:BD[43.929] → [43.929:931]

B:BD[6.254] → [6.254:256]

B:BD[6.256] → [79.0:240]

B:BD[39.33] → [38.528:594]

B:BD[38.669] → [38.669:768]

B:BD[38.967] → [38.967:1031]

B:BD[38.768] → [92.525:685]

B:BD[38.768] → [38.768:967]

B:BD[38.594] → [92.481:524]

B:BD[38.594] → [38.594:669]

B:BD[39.33] → [39.33:510]

B:BD[6.254] → [39.31:33]

B:BD[43.931] → [6.0:254]

B:BD[38.309] → [30.512:1184]

B:BD[38.309] → [38.309:527]

B:BD[43.909] → [43.909:929]

B:BD[43.909] → [38.31:309]

B:BD[48.182] → [48.182:596]

B:BD[82.207] → [82.207:227]

B:BD[82.455] → [82.455:457]

B:BD[82.296] → [82.296:455]

B:BD[82.229] → [82.229:296]

B:BD[81.272] → [82.228:229]

B:BD[82.229] → [42.186:262]

B:BD[82.227] → [55.953:1191]

B:BD[55.796] → [48.597:931]

B:BD[55.796] → [55.796:952]

B:BD[55.794] → [48.180:182]

B:BD[55.794] → [55.794:796]

B:BD[43.361] → [43.361:596]

B:BD[55.794] → [43.180:309]

B:BD[55.613] → [43.129:179]

B:BD[43.128] → [47.162:526]

B:BD[55.613] → [48.129:179]

B:BD[43.128] → [30.158:511]

B:BD[55.613] → [55.613:663]

B:BD[55.663] → [55.663:794]

B:BD[55.430] → [55.430:613]

B:BD[94.52] → [94.52:181]

B:BD[43.309] → [94.0:52]

B:BD[55.360] → [43.58:128]

B:BD[55.360] → [22.0:61]

B:BD[55.360] → [48.58:128]

B:BD[55.360] → [53.0:61]

B:BD[55.360] → [55.360:430]

B:BD[55.196] → [29.131:257]

B:BD[29.330] → [29.330:683]

B:BD[29.686] → [86.32277:32526]

B:BD[29.812] → [86.32530:32711]

B:BD[29.812] → [29.812:864]

∅:BD[58.37326] → [29.1413:1435]

B:BD[29.1413] → [29.1413:1435]

B:BD[29.1435] → [29.1435:1689]

B:BD[29.1435] → [58.37327:37402]

∅:BD[21.22850] → [58.37464:37581]

B:BD[58.37464] → [58.37464:37581]

B:BD[58.37821] → [58.37821:37823]

B:BD[58.38736] → [58.38736:38738]

B:BD[58.38122] → [58.38122:38736]

B:BD[58.38031] → [58.38031:38122]

B:BD[95.38492] → [95.38492:38601]

B:BD[58.38738] → [95.38263:38492]

B:BD[96.38022] → [96.38022:38149]

B:BD[58.38736] → [96.37341:38022]

B:BD[58.38031] → [96.37247:37340]

B:BD[95.38492] → [97.38884:39275]

B:BD[96.38022] → [97.38762:38883]

B:BD[58.37823] → [58.37823:38031]

B:BD[58.37581] → [58.37581:37821]

B:BD[58.37581] → [60.40044:40352]

B:BD[60.40395] → [60.40395:40475]

∅:BD[21.22983] → [60.40475:40491]

B:BD[60.40475] → [60.40475:40491]

∅:BD[74.37135] → [60.41574:41576]

∅:BD[98.39009] → [60.41574:41576]

∅:BD[77.35891] → [60.41574:41576]

∅:BD[64.29707] → [60.41574:41576]

B:BD[60.41574] → [60.41574:41576]

B:BD[60.41576] → [21.23452:25110]

B:BD[60.41576] → [60.41576:42720]

B:BD[60.40697] → [60.40697:41574]

B:BD[60.40587] → [60.40587:40697]

B:BD[60.40494] → [60.40494:40587]

B:BD[60.40697] → [98.38993:39009]

B:BD[60.40494] → [98.38896:38992]

B:BD[60.40491] → [77.35183:35186]

∅:BD[74.36630] → [77.35277:35387]

∅:BD[21.23077] → [77.35277:35387]

∅:BD[64.29690] → [77.35277:35387]

B:BD[77.35277] → [77.35277:35387]

B:BD[77.35387] → [64.29691:29707]

B:BD[77.35387] → [77.35387:35891]

B:BD[77.35387] → [74.36631:36643]

B:BD[74.36643] → [21.23078:23451]

∅:BD[21.23451] → [74.36643:37135]

B:BD[74.36643] → [74.36643:37135]

B:BD[77.35186] → [64.29594:29690]

B:BD[77.35186] → [21.22984:23077]

B:BD[77.35186] → [77.35186:35277]

B:BD[77.35186] → [74.36539:36630]

B:BD[60.40491] → [60.40491:40494]

B:BD[60.40352] → [63.39423:39498]

B:BD[60.40352] → [21.22851:22983]

B:BD[60.40352] → [77.35139:35182]

B:BD[60.40352] → [60.40352:40395]

B:BD[58.37402] → [58.37402:37464]

B:BD[58.37402] → [21.22786:22850]

B:BD[29.864] → [29.864:1413]

B:BD[99.29264] → [99.29264:29393]

B:BD[29.686] → [29.686:812]

B:BD[29.812] → [99.29212:29264]

B:BD[29.812] → [65.29284:29465]

B:BD[86.32526] → [86.32526:32529]

B:BD[29.683] → [29.683:686]

B:BD[29.330] → [46.29352:29716]

B:BD[29.330] → [17.29348:29701]

B:BD[17.29701] → [85.33968:34220]

B:BD[87.32816] → [87.32816:33065]

B:BD[17.29701] → [87.32813:32816]

B:BD[29.257] → [29.257:330]

B:BD[81.156] → [90.35:54]

B:BD[55.196] → [46.29190:29351]

B:BD[55.196] → [47.0:161]

B:BD[81.156] → [89.43:66]

B:BD[55.196] → [30.31:157]

B:BD[55.196] → [49.35:196]

B:BD[15.419] → [84.62:272]

B:BD[15.419] → [83.62:272]

B:BD[81.156] → [88.43:66]

B:BD[55.196] → [17.29221:29347]

B:BD[81.175] → [81.175:198]

B:BD[81.270] → [89.67:445]

B:BD[81.270] → [88.67:70]

B:BD[88.131] → [88.131:314]

B:BD[88.314] → [42.71:121]

B:BD[88.445] → [82.58:61]

B:BD[82.115] → [82.115:207]

B:BD[82.61] → [82.61:115]

B:BD[82.61] → [42.122:185]

B:BD[88.314] → [88.314:445]

B:BD[88.70] → [42.0:70]

B:BD[88.70] → [88.70:131]

B:BD[81.198] → [81.198:270]

B:BD[81.270] → [81.270:272]

B:BD[81.156] → [81.156:175]

B:BD[15.419] → [81.62:156]

B:BD[55.196] → [55.196:357]

B:BD[55.357] → [55.357:359]

B:BD[15.419] → [37.62:272]

B:BD[15.397] → [15.397:419]

∅:BD[74.35840] → [58.35542:35611]

∅:BD[21.22388] → [58.35542:35611]

B:BD[15.397] → [58.35542:35611]

∅:BD[60.39254] → [58.35737:35740]

∅:BD[77.34350] → [58.35737:35740]

∅:BD[62.38923] → [58.35737:35740]

∅:BD[63.39057] → [58.35737:35740]

B:BD[58.35737] → [58.35737:35740]

B:BD[58.35810] → [63.39058:39422]

∅:BD[77.34956] → [60.39858:39861]

∅:BD[63.39422] → [60.39858:39861]

B:BD[60.39858] → [60.39858:39861]

∅:BD[74.36156] → [58.36481:36544]

∅:BD[21.22539] → [58.36481:36544]

∅:BD[100.30611] → [58.36481:36544]

B:BD[58.36481] → [58.36481:36544]

B:BD[58.36596] → [58.36596:36777]

B:BD[58.36777] → [58.36777:37015]

∅:BD[74.36388] → [58.37111:37269]

∅:BD[21.22724] → [58.37111:37269]

B:BD[58.37111] → [58.37111:37269]

∅:BD[74.36538] → [58.37269:37326]

B:BD[58.37269] → [58.37269:37326]

B:BD[58.37269] → [74.36389:36446]

∅:BD[21.22785] → [74.36532:36538]

B:BD[74.36532] → [74.36532:36538]

B:BD[74.36446] → [21.22725:22785]

B:BD[74.36446] → [74.36446:36532]

B:BD[58.37015] → [58.37015:37111]

B:BD[58.37015] → [74.36223:36319]

∅:BD[21.22708] → [74.36343:36369]

B:BD[74.36343] → [74.36343:36369]

B:BD[74.36369] → [21.22709:22724]

B:BD[74.36369] → [74.36369:36388]

B:BD[74.36319] → [21.22676:22708]

B:BD[74.36319] → [74.36319:36343]

B:BD[58.36544] → [100.30612:30640]

B:BD[58.36544] → [58.36544:36596]

B:BD[58.36544] → [21.22540:22568]

∅:BD[21.22568] → [77.34957:35009]

∅:BD[100.30640] → [77.34957:35009]

B:BD[58.36544] → [77.34957:35009]

∅:BD[74.36222] → [77.35074:35138]

∅:BD[21.22646] → [77.35074:35138]

∅:BD[100.30718] → [77.35074:35138]

B:BD[77.35074] → [77.35074:35138]

B:BD[77.35138] → [100.30719:30747]

B:BD[77.35138] → [21.22647:22675]

B:BD[77.35009] → [100.30641:30718]

B:BD[77.35009] → [21.22569:22646]

B:BD[77.35009] → [77.35009:35074]

B:BD[77.35009] → [74.36157:36222]

∅:BD[77.35138] → [60.39862:39914]

∅:BD[21.22675] → [60.39862:39914]

∅:BD[100.30747] → [60.39862:39914]

B:BD[58.36544] → [60.39862:39914]

B:BD[60.39914] → [60.39914:40043]

B:BD[60.39861] → [100.30536:30611]

B:BD[60.39861] → [74.35841:36093]

B:BD[74.36093] → [21.22464:22539]

B:BD[74.36093] → [74.36093:36156]

B:BD[58.35810] → [58.35810:36163]

B:BD[58.36166] → [58.36166:36418]

B:BD[58.36418] → [58.36418:36481]

B:BD[58.36166] → [60.39609:39858]

B:BD[58.36163] → [58.36163:36166]

B:BD[58.35810] → [62.38924:39288]

∅:BD[21.22463] → [77.34351:34704]

B:BD[58.35810] → [77.34351:34704]

B:BD[77.34704] → [77.34704:34956]

B:BD[58.35810] → [60.39255:39608]

B:BD[58.35740] → [58.35740:35810]

B:BD[58.35740] → [21.22389:22463]

B:BD[58.35611] → [63.38896:39057]

B:BD[58.35611] → [58.35611:35737]

B:BD[58.35611] → [62.38762:38923]

B:BD[58.35611] → [77.34224:34350]

B:BD[58.35611] → [60.39128:39254]

B:BD[15.397] → [55.127:196]

B:BD[15.325] → [74.35797:35840]

B:BD[15.294] → [15.294:325]

B:BD[15.254] → [91.29382:29410]

B:BD[15.254] → [74.35742:35796]

B:BD[74.35796] → [21.22332:22388]

B:BD[15.142] → [15.142:196]

B:BD[15.142] → [91.29310:29381]

B:BD[15.142] → [21.22243:22331]

B:BD[15.142] → [74.35661:35741]

B:BD[15.142] → [87.32758:32812]

B:BD[15.141] → [29.88:130]

B:BD[15.141] → [90.0:34]

B:BD[15.141] → [58.35423:35465]

B:BD[58.35465] → [58.35465:35541]

B:BD[58.35465] → [77.34147:34223]

B:BD[58.35465] → [60.39009:39127]

B:BD[58.35465] → [74.35584:35660]

B:BD[74.35660] → [21.22166:22242]

B:BD[15.141] → [89.0:42]

B:BD[15.141] → [49.0:34]

B:BD[15.141] → [84.27:61]

B:BD[15.141] → [83.27:61]

B:BD[15.141] → [88.0:42]

B:BD[15.141] → [81.27:61]

B:BD[15.141] → [55.84:126]

B:BD[15.141] → [37.27:61]

∅:BD[60.38977] → [58.35309:35392]

∅:BD[21.22165] → [58.35309:35392]

∅:BD[96.37246] → [58.35309:35392]

∅:BD[95.38262] → [58.35309:35392]

B:BD[15.57] → [58.35309:35392]

B:BD[58.35392] → [58.35392:35422]

B:BD[58.35392] → [60.38978:39008]

B:BD[15.57] → [95.38181:38262]

B:BD[15.57] → [96.37183:37246]

B:BD[15.57] → [21.22084:22165]

B:BD[15.57] → [84.0:26]

B:BD[15.57] → [60.38896:38977]

B:BD[15.57] → [83.0:26]

B:BD[15.57] → [81.0:26]

B:BD[15.57] → [55.0:26]

B:BD[15.57] → [37.0:26]

B:BD[15.13] → [59.34147:34168]

B:BD[15.13] → [15.14:35]

B:BD[15.13] → [58.35280:35308]

B:BD[15.13] → [25.0:21]

B:BD[15.13] → [28.0:28]

B:BD[15.13] → [26.0:28]

use minidom::Element;
use xmpp_parsers::message::{Body, Message, MessageType};
use xmpp_parsers::message::{Body, Message, MessageType};
use xmpp_parsers::ping::Ping;
use xmpp_parsers::ping::Ping;
use xmpp_parsers::ping::Ping;
use xmpp_parsers::message::{Body, Message, MessageType};
use xmpp_parsers::ping::Ping;
use xmpp_parsers::ping::Ping;
use xmpp_parsers::message::{Body, Message, MessageType};
use xmpp_parsers::message::{Body, Message, MessageType};
use xmpp_parsers::iq::Iq;
use xmpp_parsers::presence::{Presence, Show as PresenceShow, Type as PresenceType};
use xmpp_parsers::stanza_error::{DefinedCondition, ErrorType, StanzaError};
use xmpp_parsers::stanza_error::{DefinedCondition, ErrorType, StanzaError};
use xmpp_parsers::stanza_error::{DefinedCondition, ErrorType, StanzaError};
use xmpp_parsers::roster::Roster;
    let mut presence = Presence::new(PresenceType::None);
    presence.show = PresenceShow::Chat;
        .insert(String::from("en"), String::from("Echoing messages."));
pub fn make_get_roster(id: &str) -> Element {
    let mut get_roster = Iq::from_get(Roster {
        ver: None,
        items: vec![],
    });
    get_roster.id = Some(id.to_string());
    get_roster.into()
}
    Iq::from_get(
        id,
        Roster {
            items: vec![],
            ver: None,
        },
    )
    .into()
pub fn make_muc_presence_leave(from: xmpp_parsers::Jid, to: xmpp_parsers::Jid) -> Element {
    let mut presence = Presence::new(PresenceType::Unavailable);
    presence.from = Some(from);
    presence.to = Some(to);
    presence.into()
pub fn make_pong(id: &str, from: xmpp_parsers::Jid, to: Option<xmpp_parsers::Jid>) -> Iq {
    pong
}
pub fn make_iq_unsupported_error(
    id: String,
    from: xmpp_parsers::Jid,
    to: Option<xmpp_parsers::Jid>,
) -> Iq {
    let mut error = Iq::from_error(
        id,
        StanzaError {
            type_: ErrorType::Cancel,
            by: Some(from.clone()),
            defined_condition: DefinedCondition::ServiceUnavailable,
            texts: std::collections::BTreeMap::new(),
            other: None,
        },
    );
    error.from = Some(from);
    error.to = to;
    error
}
pub fn make_iq_unsupported_error(
    id: String,
    from: xmpp_parsers::Jid,
    to: Option<xmpp_parsers::Jid>,
) -> Iq {
    let mut error = Iq::from_error(
        id,
        StanzaError {
            type_: ErrorType::Cancel,
            by: Some(from.clone()),
            defined_condition: DefinedCondition::ServiceUnavailable,
            texts: std::collections::BTreeMap::new(),
            other: None,
        },
    );
    error.from = Some(from);
    error.to = to;
    error
}
pub fn make_iq_unsupported_error(
    id: String,
    from: xmpp_parsers::Jid,
    to: Option<xmpp_parsers::Jid>,
) -> Iq {
    let mut error = Iq::from_error(
        id,
        StanzaError {
            type_: ErrorType::Cancel,
            by: Some(from.clone()),
            defined_condition: DefinedCondition::ServiceUnavailable,
            texts: std::collections::BTreeMap::new(),
            other: None,
        },
    );
    error.from = Some(from);
    error.to = to;
    error
    pong
    pong.into()
    pong.into()
    pong.into()
}
    pong
pub fn make_pong(id: &str, from: xmpp_parsers::Jid, to: Option<xmpp_parsers::Jid>) -> Iq {
pub fn make_pong(id: &str, from: xmpp_parsers::Jid, to: Option<xmpp_parsers::Jid>) -> Element {
pub fn make_ping(id: &str, from: xmpp_parsers::Jid) -> Element {
    let mut ping = Iq::from_get(id, Ping);
    ping.to = Some(from.clone().into_domain_jid());
    ping.from = Some(from);
    ping.into()
}
pub fn make_pong(id: &str, from: xmpp_parsers::Jid, to: Option<xmpp_parsers::Jid>) -> Element {
    let mut pong = Iq::from_result(id, None as Option<Roster>);
    pong.from = Some(from);
    pong.to = to;
    pong.into()
}
pub fn make_pong(id: &str, from: xmpp_parsers::Jid, to: Option<xmpp_parsers::Jid>) -> Element {
    let mut pong = Iq::from_result(id, None as Option<Roster>);
    pong.from = Some(from);
    pong.to = to;
pub fn make_muc_presence_leave(from: xmpp_parsers::Jid, to: xmpp_parsers::Jid) -> Element {
    let mut presence = Presence::new(PresenceType::Unavailable);
    presence.from = Some(from);
    presence.to = Some(to);
    presence.into()
}
pub fn make_ping(id: &str, from: xmpp_parsers::Jid) -> Element {
    let mut ping = Iq::from_get(id, Ping);
    ping.to = Some(from.clone().into_domain_jid());
    ping.from = Some(from);
    ping.into()
}
pub fn make_pong(id: &str, from: xmpp_parsers::Jid, to: Option<xmpp_parsers::Jid>) -> Element {
pub fn make_pong(id: &str, from: xmpp_parsers::Jid, to: Option<xmpp_parsers::Jid>) -> Iq {
}
    Iq::from_set(
        id,
        Roster {
            items: vec![Item {
                jid,
                name: None,
                subscription: xmpp_parsers::roster::Subscription::None,
                ask: xmpp_parsers::roster::Ask::None,
                groups: vec![],
            }],
            ver: None,
        },
    )
    .into()
    presence.to = Some(jid);
    presence.into()
}
pub fn make_muc_presence(id: &str, from: xmpp_parsers::Jid, to: xmpp_parsers::Jid) -> Element {
    let mut presence = Presence::new(PresenceType::None);
    presence.from = Some(from);
    presence.to = Some(to);
    presence.id = Some(id.to_string());
    presence.add_payload(xmpp_parsers::muc::Muc::new());
}
}
pub fn make_muc_presence_leave(from: xmpp_parsers::Jid, to: xmpp_parsers::Jid) -> Element {
    let mut presence = Presence::new(PresenceType::Unavailable);
    presence.from = Some(from);
    presence.to = Some(to);
    presence.into()
}
pub fn make_ping(id: &str, from: xmpp_parsers::Jid) -> Element {
    ping.to = Some(from.clone().into_domain_jid());
    ping.from = Some(from);
    ping.into()
}
    pong.from = Some(from);
    pong.to = to;
    pong.into()
}
pub fn make_pong(id: &str, from: xmpp_parsers::Jid, to: Option<xmpp_parsers::Jid>) -> Element {
    let mut pong = Iq::from_result(id, None as Option<Roster>);
pub fn make_pong(
    id: Option<String>,
    from: xmpp_parsers::Jid,
    to: Option<xmpp_parsers::Jid>,
) -> Element {
    let mut pong = Iq::from_result(None as Option<Roster>);
    pong.id = id;
    let mut ping = Iq::from_get(id, Ping);
    let mut ping = Iq::from_get(Ping);
    ping.id = Some(id.to_string());
pub fn make_muc_presence_leave(from: xmpp_parsers::Jid, to: xmpp_parsers::Jid) -> Element {
    let mut presence = Presence::new(PresenceType::Unavailable);
    presence.from = Some(from);
    presence.to = Some(to);
    presence.into()
}
pub fn make_ping(id: &str, from: xmpp_parsers::Jid) -> Element {
    let mut ping = Iq::from_get(Ping);
    ping.id = Some(id.to_string());
    ping.to = Some(from.clone().into_domain_jid());
    ping.from = Some(from);
    ping.into()
}
pub fn make_muc_message(to: xmpp_parsers::Jid, text: String) -> Element {
    let mut message = Message::new(Some(to.into_bare_jid()));
    message.bodies.insert(String::new(), Body(text));
    message.type_ = MessageType::Groupchat;
    message.into()
pub fn make_muc_presence_leave(from: xmpp_parsers::Jid, to: xmpp_parsers::Jid) -> Element {
    let mut presence = Presence::new(PresenceType::Unavailable);
    presence.from = Some(from);
    presence.to = Some(to);
    presence.into()
}
pub fn make_ping(id: &str, from: xmpp_parsers::Jid) -> Element {
    let mut ping = Iq::from_get(id, Ping);
    ping.to = Some(from.clone().into_domain_jid());
    ping.from = Some(from);
    ping.into()
}
pub fn make_pong(id: &str, from: xmpp_parsers::Jid, to: Option<xmpp_parsers::Jid>) -> Element {
    let mut pong = Iq::from_result(id, None as Option<Roster>);
    pong.from = Some(from);
    pong.to = to;
    pong.into()
}
pub fn make_muc_presence_leave(from: xmpp_parsers::Jid, to: xmpp_parsers::Jid) -> Element {
    let mut presence = Presence::new(PresenceType::Unavailable);
    presence.from = Some(from);
    presence.to = Some(to);
    presence.into()
    presence.into()
}
pub fn make_muc_message(to: xmpp_parsers::Jid, text: String) -> Element {
    let mut message = Message::new(Some(to.into_bare_jid()));
    message.bodies.insert(String::new(), Body(text));
    message.type_ = MessageType::Groupchat;
    message.into()
}
pub fn make_ask_subscribe(jid: xmpp_parsers::Jid) -> Element {
    let mut presence = Presence::new(PresenceType::Subscribe);
    presence.to = Some(jid);
    presence.into()
}
pub fn make_chat_message(jid: xmpp_parsers::Jid, text: String) -> Element {
    let mut message = Message::new(Some(jid));
    message.bodies.insert(String::new(), Body(text));
    message.type_ = MessageType::Chat;
    message.into()
    presence.into()
}
    let mut message = Message::new(Some(jid));
    message.bodies.insert(String::new(), Body(text));
    message.type_ = MessageType::Chat;
    message.into()
pub fn make_chat_message(jid: jid::Jid, text: String) -> Element {
pub fn make_chat_message(jid: xmpp_parsers::Jid, text: String) -> Element {
}
pub fn make_chat_message(jid: xmpp_parsers::Jid, text: String) -> Element {
    let mut message = Message::new(Some(jid));
    message.bodies.insert(String::new(), Body(text));
    message.type_ = MessageType::Chat;
    message.into()
pub fn make_muc_presence(id: &str, from: xmpp_parsers::Jid, to: xmpp_parsers::Jid) -> Element {
    let mut presence = Presence::new(PresenceType::None);
    presence.from = Some(from);
    presence.to = Some(to);
    presence.id = Some(id.to_string());
    presence.add_payload(xmpp_parsers::muc::Muc::new());
    presence.into()
}
pub fn make_ask_subscribe(jid: xmpp_parsers::Jid) -> Element {
    let mut presence = Presence::new(PresenceType::Subscribe);
    presence.to = Some(jid);
}
}
pub fn make_chat_message(jid: xmpp_parsers::Jid, text: String) -> Element {
    let mut message = Message::new(Some(jid));
    message.bodies.insert(String::new(), Body(text));
    message.type_ = MessageType::Chat;
    message.into()
}
pub fn make_ask_subscribe(jid: xmpp_parsers::Jid) -> Element {
    let mut presence = Presence::new(PresenceType::Subscribe);
            ask: xmpp_parsers::roster::Ask::None,
    let mut add_roster = Iq::from_set(Roster {
        items: vec![Item {
            jid,
            name: None,
            subscription: xmpp_parsers::roster::Subscription::None,
            ask: xmpp_parsers::roster::Ask::None,
            groups: vec![],
        }],
        ver: None,
    });
    add_roster.id = Some(id.to_string());
    add_roster.into()
            ask: xmpp_parsers::roster::Ask::None,
    Iq::from_set(
        id,
        Roster {
            items: vec![Item {
                jid,
                name: None,
                subscription: xmpp_parsers::roster::Subscription::None,
                ask: xmpp_parsers::roster::Ask::None,
                groups: vec![],
            }],
            ver: None,
        },
    )
    .into()
            ask: xmpp_parsers::roster::Ask::None,
            groups: vec![],
        }],
        ver: None,
    });
    add_roster.id = Some(id.to_string());
    add_roster.into()
    let mut add_roster = Iq::from_set(Roster {
        items: vec![Item {
            jid,
            name: None,
            subscription: xmpp_parsers::roster::Subscription::None,
pub fn make_allow_subscribe(jid: xmpp_parsers::Jid) -> Element {
    let mut presence = Presence::new(PresenceType::Subscribed);
    presence.to = Some(jid);
    presence.into()
}
pub fn make_add_roster(id: &str, jid: xmpp_parsers::Jid) -> Element {
pub fn make_add_roster(id: &str, jid: jid::Jid) -> Element {
pub fn make_add_roster(id: &str, jid: xmpp_parsers::Jid) -> Element {
pub fn make_add_roster(id: &str, jid: jid::Jid) -> Element {
pub fn make_add_roster(id: &str, jid: xmpp_parsers::Jid) -> Element {
    Iq::from_get(
        id,
        Roster {
            items: vec![],
            ver: None,
        },
    )
    .into()
    Iq::from_set(
        id,
        Roster {
            items: vec![Item {
                jid,
                name: None,
                subscription: xmpp_parsers::roster::Subscription::None,
                ask: xmpp_parsers::roster::Ask::None,
                groups: vec![],
            }],
            ver: None,
        },
    )
    .into()
pub fn make_roster_push_answer(
    id: String,
    from: xmpp_parsers::Jid,
    to: Option<xmpp_parsers::Jid>,
) -> Iq {
    let mut answer = Iq::from_result(id, None as Option<Roster>);
    answer.from = Some(from);
    answer.to = to;
    answer
    presence.to = Some(jid);
    presence.into()
}
pub fn make_allow_subscribe(jid: xmpp_parsers::Jid) -> Element {
    let mut presence = Presence::new(PresenceType::Subscribed);
    presence.to = Some(jid);
    presence.into()
}
    presence.into()
}
pub fn make_muc_message(to: xmpp_parsers::Jid, text: String) -> Element {
    let mut message = Message::new(Some(to.into_bare_jid()));
    message.bodies.insert(String::new(), Body(text));
    message.type_ = MessageType::Groupchat;
    message.into()
pub fn make_muc_message(to: xmpp_parsers::Jid, text: String) -> Element {
    message.bodies.insert(String::new(), Body(text));
    message.type_ = MessageType::Groupchat;
    message.into()
}
}
    let mut pong = Iq::from_result(id, None as Option<Roster>);
    pong.from = Some(from);
    pong.to = to;
    pong
}
pub fn make_iq_unsupported_error(
    id: String,
    from: xmpp_parsers::Jid,
    to: Option<xmpp_parsers::Jid>,
) -> Iq {
    let mut error = Iq::from_error(
        id,
        StanzaError {
            type_: ErrorType::Cancel,
            by: Some(from.clone()),
            defined_condition: DefinedCondition::ServiceUnavailable,
            texts: std::collections::BTreeMap::new(),
            other: None,
        },
    );
    error.from = Some(from);
    error.to = to;
    error
pub fn make_pong(id: &str, from: xmpp_parsers::Jid, to: Option<xmpp_parsers::Jid>) -> Iq {
            items: vec![],
        }),
    );
    result.from = Some(from);
    result.to = to;
    result
}
pub fn make_disco_items_result(
    id: String,
    from: xmpp_parsers::Jid,
    to: Option<xmpp_parsers::Jid>,
) -> Iq {
    let mut result = Iq::from_result(
        id,
        Some(DiscoItemsResult {
            node: None,
            ],
            extensions: vec![],
        }),
    );
    result.from = Some(from);
    result.to = to;
    result
}
pub fn make_disco_info_result(
    id: String,
    from: xmpp_parsers::Jid,
    to: Option<xmpp_parsers::Jid>,
) -> Iq {
    let mut result = Iq::from_result(
        id,
        Some(DiscoInfoResult {
            node: None,
            identities: vec![Identity {
                category: "client".to_string(),
                type_: "bot".to_string(),
                name: None,
                lang: None,
            }],
            features: vec![
                Feature {
                    var: "http://jabber.org/protocol/disco#info".to_string(),
                },
                Feature {
                    var: "urn:xmpp:ping".to_string(),
                },
pub fn make_pong(id: String, from: xmpp_parsers::Jid, to: Option<xmpp_parsers::Jid>) -> Iq {
            items: vec![],
        }),
    );
    result.from = Some(from);
    result.to = to;
    result
}
pub fn make_disco_items_commands(
    id: String,
    from: xmpp_parsers::Jid,
    to: Option<xmpp_parsers::Jid>,
) -> Iq {
    let mut result = Iq::from_result(
        id,
        Some(DiscoItemsResult {
            node: Some("http://jabber.org/protocol/commands".to_string()),
                Feature {
                    var: "http://jabber.org/protocol/commands".to_string(),
                },
pub fn make_ping(id: &str, from: xmpp_parsers::Jid) -> Element {
    let mut ping = Iq::from_get(id, Ping);
    ping.to = Some(from.clone().into_domain_jid());
    ping.from = Some(from);
    ping.into()
}
}
pub fn make_muc_presence_leave(from: xmpp_parsers::Jid, to: xmpp_parsers::Jid) -> Element {
    let mut presence = Presence::new(PresenceType::Unavailable);
    presence.from = Some(from);
    presence.to = Some(to);
    presence.into()
}
pub fn make_muc_presence_leave(from: xmpp_parsers::Jid, to: xmpp_parsers::Jid) -> Element {
    let mut presence = Presence::new(PresenceType::Unavailable);
    presence.from = Some(from);
    presence.to = Some(to);
    presence.into()
}
pub fn make_ping(id: &str, from: xmpp_parsers::Jid) -> Element {
    ping.to = Some(from.clone().into_domain_jid());
    ping.from = Some(from);
    ping.into()
}
pub fn make_disco_info_result(
    id: String,
    from: xmpp_parsers::Jid,
    to: Option<xmpp_parsers::Jid>,
) -> Iq {
    let mut result = Iq::from_result(
        id,
        Some(DiscoInfoResult {
            node: None,
            identities: vec![Identity {
                category: "client".to_string(),
                type_: "bot".to_string(),
                name: None,
                lang: None,
            }],
            features: vec![
                Feature {
                    var: "http://jabber.org/protocol/disco#info".to_string(),
                },
                Feature {
                    var: "urn:xmpp:ping".to_string(),
                },
                Feature {
                    var: "http://jabber.org/protocol/commands".to_string(),
                },
            ],
            extensions: vec![],
        }),
    );
    result.from = Some(from);
    result.to = to;
    result
}
pub fn make_disco_items_result(
    id: String,
    from: xmpp_parsers::Jid,
    to: Option<xmpp_parsers::Jid>,
) -> Iq {
    let mut result = Iq::from_result(
        id,
        Some(DiscoItemsResult {
            node: None,
            items: vec![],
        }),
    );
    result.from = Some(from);
    result.to = to;
    result
}
pub fn make_disco_items_commands(
    id: String,
    from: xmpp_parsers::Jid,
    to: Option<xmpp_parsers::Jid>,
) -> Iq {
    let mut result = Iq::from_result(
        id,
        Some(DiscoItemsResult {
            node: Some("http://jabber.org/protocol/commands".to_string()),
            items: vec![],
        }),
    );
    result.from = Some(from);
    result.to = to;
    result
}
pub fn make_disco_info_result(
    id: String,
    from: xmpp_parsers::Jid,
    to: Option<xmpp_parsers::Jid>,
) -> Iq {
    let mut result = Iq::from_result(
        id,
        Some(DiscoInfoResult {
            node: None,
            identities: vec![Identity {
                category: "client".to_string(),
                type_: "bot".to_string(),
                name: None,
                lang: None,
            }],
            features: vec![
                Feature {
                    var: "http://jabber.org/protocol/disco#info".to_string(),
                },
                Feature {
                    var: "urn:xmpp:ping".to_string(),
                },
            ],
            extensions: vec![],
        }),
    );
    result.from = Some(from);
    result.to = to;
    result
}
pub fn make_disco_items_result(
    id: String,
    from: xmpp_parsers::Jid,
    to: Option<xmpp_parsers::Jid>,
) -> Iq {
    let mut result = Iq::from_result(
        id,
        Some(DiscoItemsResult {
            node: None,
            items: vec![],
        }),
    );
    result.from = Some(from);
    result.to = to;
    result
    pong
}
pub fn make_version(id: String, from: xmpp_parsers::Jid, to: Option<xmpp_parsers::Jid>) -> Iq {
    let mut version = Iq::from_result(
        id,
        Some(VersionResult {
            name: "SendXmppDRust".to_string(),
            version: "0.1.0".to_string(),
            os: None,
        }),
    );
    version.from = Some(from);
    version.to = to;
    version
}
pub fn make_iq_unsupported_error(
    id: String,
    from: xmpp_parsers::Jid,
    to: Option<xmpp_parsers::Jid>,
) -> Iq {
    let mut error = Iq::from_error(
        id,
        StanzaError {
            type_: ErrorType::Cancel,
            by: Some(from.clone()),
            defined_condition: DefinedCondition::ServiceUnavailable,
            texts: std::collections::BTreeMap::new(),
            other: None,
        },
    );
    error.from = Some(from);
    error.to = to;
    error
    let mut pong = Iq::from_result(id, None as Option<Roster>);
    pong.from = Some(from);
    pong.to = to;
pub fn make_pong(id: String, from: xmpp_parsers::Jid, to: Option<xmpp_parsers::Jid>) -> Iq {
    pong.into()
pub fn make_pong(id: &str, from: xmpp_parsers::Jid, to: Option<xmpp_parsers::Jid>) -> Element {
}
    let mut pong = Iq::from_result(id, None as Option<Roster>);
    pong.from = Some(from);
    pong.to = to;
    pong.into()
    pong
}
pub fn make_iq_unsupported_error(
    id: String,
    from: xmpp_parsers::Jid,
    to: Option<xmpp_parsers::Jid>,
) -> Iq {
    let mut error = Iq::from_error(
        id,
        StanzaError {
            type_: ErrorType::Cancel,
            by: Some(from.clone()),
            defined_condition: DefinedCondition::ServiceUnavailable,
            texts: std::collections::BTreeMap::new(),
            other: None,
        },
    );
    error.from = Some(from);
    error.to = to;
    error
    pong
}
pub fn make_version(id: String, from: xmpp_parsers::Jid, to: Option<xmpp_parsers::Jid>) -> Iq {
    let mut version = Iq::from_result(
        id,
        Some(VersionResult {
            name: "SendXmppDRust".to_string(),
            version: "0.1.0".to_string(),
            os: None,
        }),
    );
    version.from = Some(from);
    version.to = to;
    version
}
pub fn make_iq_unsupported_error(
    id: String,
    from: xmpp_parsers::Jid,
    to: Option<xmpp_parsers::Jid>,
) -> Iq {
    let mut error = Iq::from_error(
        id,
        StanzaError {
            type_: ErrorType::Cancel,
            by: Some(from.clone()),
            defined_condition: DefinedCondition::ServiceUnavailable,
            texts: std::collections::BTreeMap::new(),
            other: None,
        },
    );
    error.from = Some(from);
    error.to = to;
    error
pub fn make_pong(id: &str, from: xmpp_parsers::Jid, to: Option<xmpp_parsers::Jid>) -> Element {
pub fn make_pong(id: String, from: xmpp_parsers::Jid, to: Option<xmpp_parsers::Jid>) -> Iq {
pub fn make_pong(id: &str, from: xmpp_parsers::Jid, to: Option<xmpp_parsers::Jid>) -> Iq {
pub fn make_pong(id: &str, from: xmpp_parsers::Jid, to: Option<xmpp_parsers::Jid>) -> Iq {
}
    let mut ping = Iq::from_get(Ping);
    ping.id = Some(id.to_string());
    let ping = Iq::from_get(id, Ping)
        .with_to(Jid::Bare(BareJid::domain(from.clone().domain())))
        .with_from(from);
    let mut ping = Iq::from_get(id, Ping);
    let mut ping = Iq::from_get(id, Ping);
    let mut message = Message::new(Some(to.into_bare_jid()));
    let mut message = Message::new(Some(Jid::Bare(to.into())));
pub fn make_chat_message(jid: xmpp_parsers::Jid, text: String) -> Element {
    let mut message = Message::new(Some(jid));
    message.bodies.insert(String::new(), Body(text));
    message.type_ = MessageType::Chat;
    message.into()
}
pub fn make_muc_presence(id: &str, from: xmpp_parsers::Jid, to: xmpp_parsers::Jid) -> Element {
    let mut presence = Presence::new(PresenceType::None);
    presence.from = Some(from);
    presence.to = Some(to);
    presence.id = Some(id.to_string());
    presence.add_payload(xmpp_parsers::muc::Muc::new());
pub fn make_allow_subscribe(jid: xmpp_parsers::Jid) -> Element {
    let mut presence = Presence::new(PresenceType::Subscribed);
pub fn make_ask_subscribe(jid: xmpp_parsers::Jid) -> Element {
    let mut presence = Presence::new(PresenceType::Subscribe);
    presence.to = Some(jid);
    presence.into()
}
    presence.to = Some(jid);
    presence.into()
}
pub fn make_allow_subscribe(jid: xmpp_parsers::Jid) -> Element {
    let mut presence = Presence::new(PresenceType::Subscribed);
}
}
    let mut add_roster = Iq::from_set(Roster {
        items: vec![Item {
            jid,
            name: None,
            subscription: xmpp_parsers::roster::Subscription::None,
            ask: xmpp_parsers::roster::Ask::None,
            groups: vec![],
        }],
        ver: None,
    });
    add_roster.id = Some(id.to_string());
    add_roster.into()
    Iq::from_set(
        id,
        Roster {
            items: vec![Item {
                jid,
                name: None,
                subscription: xmpp_parsers::roster::Subscription::None,
                ask: xmpp_parsers::roster::Ask::None,
                groups: vec![],
            }],
            ver: None,
        },
    )
    .into()
}
pub fn make_roster_push_answer(
    id: String,
    from: xmpp_parsers::Jid,
    to: Option<xmpp_parsers::Jid>,
) -> Iq {
    let mut answer = Iq::from_result(id, None as Option<Roster>);
    answer.from = Some(from);
    answer.to = to;
    answer
pub fn make_roster_push_answer(
    id: String,
    from: xmpp_parsers::Jid,
    to: Option<xmpp_parsers::Jid>,
) -> Iq {
    let mut answer = Iq::from_result(id, None as Option<Roster>);
    answer.from = Some(from);
    answer.to = to;
    answer
}
}
pub fn make_add_roster(id: &str, jid: xmpp_parsers::Jid) -> Element {
        ver: None,
    let mut get_roster = Iq::from_get(Roster {
        items: vec![],
        ver: None,
    });
    get_roster.id = Some(id.to_string());
    get_roster.into()
    let mut get_roster = Iq::from_get(Roster {
        items: vec![],
        ver: None,
    });
    get_roster.id = Some(id.to_string());
    get_roster.into()
        items: vec![],
    Iq::from_get(
        id,
        Roster {
            items: vec![],
            ver: None,
        },
    )
    .into()
    let mut get_roster = Iq::from_get(Roster {
        ver: None,
        items: vec![],
    });
    get_roster.id = Some(id.to_string());
    get_roster.into()
pub fn make_get_roster(id: &str) -> Element {
    let mut get_roster = Iq::from_get(Roster {
        ver: None,
        items: vec![],
    });
    get_roster.id = Some(id.to_string());
    get_roster.into()
}
pub fn make_get_roster(id: &str) -> Element {
    let mut get_roster = Iq::from_get(Roster {
        ver: None,
        items: vec![],
    });
    get_roster.id = Some(id.to_string());
    get_roster.into()
}
        items: vec![],
    Iq::from_get(
        id,
        Roster {
            items: vec![],
            ver: None,
        },
    )
    .into()
        items: vec![],
}
pub fn make_add_roster(id: &str, jid: jid::Jid) -> Element {
    let mut add_roster = Iq::from_set(Roster {
        items: vec![Item {
            jid,
            name: None,
            subscription: xmpp_parsers::roster::Subscription::None,
            groups: vec![],
        }],
        ver: None,
    });
    add_roster.id = Some(id.to_string());
    add_roster.into()
}
    let mut add_roster = Iq::from_set(Roster {
        items: vec![Item {
            jid,
            name: None,
            subscription: xmpp_parsers::roster::Subscription::None,
            ask: xmpp_parsers::roster::Ask::None,
}
    let mut presence = Presence::new(PresenceType::Subscribe);
    presence.to = Some(jid);
pub fn make_ask_subscribe(jid: jid::Jid) -> Element {
pub fn make_ask_subscribe(jid: xmpp_parsers::Jid) -> Element {
            groups: vec![],
        }],
        ver: None,
    });
    add_roster.id = Some(id.to_string());
    add_roster.into()
pub fn make_add_roster(id: &str, jid: xmpp_parsers::Jid) -> Element {
pub fn make_add_roster(id: &str, jid: jid::Jid) -> Element {
    });
    get_roster.id = Some(id.to_string());
    get_roster.into()
}
        ver: None,
pub fn make_get_roster(id: &str) -> Element {
    let mut get_roster = Iq::from_get(Roster {
    let mut get_roster = Iq::from_get(Roster {
        items: vec![],
        ver: None,
    });
    get_roster.id = Some(id.to_string());
    get_roster.into()
}
pub fn make_get_roster(id: &str) -> Element {
    let mut get_roster = Iq::from_get(Roster {
        ver: None,
        items: vec![],
    });
    get_roster.id = Some(id.to_string());
    get_roster.into()
}
    presence.into()
}
    presence.into()
}
pub fn make_get_roster(id: &str) -> Element {
}
    let mut add_roster = Iq::from_set(Roster {
        items: vec![Item {
            jid,
            name: None,
            subscription: xmpp_parsers::roster::Subscription::None,
            ask: xmpp_parsers::roster::Ask::None,
            groups: vec![],
        }],
        ver: None,
    });
    add_roster.id = Some(id.to_string());
    add_roster.into()
}
    let mut presence = Presence::new(PresenceType::Subscribe);
pub fn make_allow_subscribe(jid: xmpp_parsers::Jid) -> Element {
    let mut presence = Presence::new(PresenceType::Subscribed);
    presence.to = Some(jid);
    presence.into()
}
pub fn make_chat_message(jid: xmpp_parsers::Jid, text: String) -> Element {
    let mut message = Message::new(Some(jid));
    message.bodies.insert(String::new(), Body(text));
    message.type_ = MessageType::Chat;
    message.into()
}
    let mut presence = Presence::new(PresenceType::None);
    presence.from = Some(from);
    presence.to = Some(to);
    presence.id = Some(id.to_string());
    presence.add_payload(xmpp_parsers::muc::Muc::new());
    presence.show = show;
    if let Some(text) = text {
    }
        presence.statuses.insert(String::from("en"), text);
        presence
            .statuses
            .insert(String::from("en"), text);
pub fn make_muc_presence(id: &str, from: xmpp_parsers::Jid, to: xmpp_parsers::Jid) -> Element {
pub fn make_muc_presence(
    id: &str,
    from: xmpp_parsers::Jid,
    to: xmpp_parsers::Jid,
    text: Option<String>,
) -> Element {
    ) -> Element {
    show: Option<PresenceShow>,
    show: PresenceShow,
    presence.id = Some(id);
    presence.to = Some(jid);
    presence.into()
}
    presence.id = Some(id);
    presence.to = Some(jid);
    presence.into()
}
    let mut presence = Presence::new(PresenceType::Subscribed);
    presence.id = Some(id);
    presence.id = Some(id);
pub fn make_allow_subscribe(id: String, jid: xmpp_parsers::Jid) -> Element {
pub fn make_allow_subscribe(id: String, jid: xmpp_parsers::Jid) -> Element {
pub fn make_allow_subscribe(jid: xmpp_parsers::Jid) -> Element {
pub fn make_allow_subscribe(jid: xmpp_parsers::Jid) -> Element {
    presence.to = Some(jid);
    presence.into()
}
pub fn make_allow_subscribe(jid: xmpp_parsers::Jid) -> Element {
    let mut presence = Presence::new(PresenceType::Subscribed);
pub fn make_ask_subscribe(id: String, jid: xmpp_parsers::Jid) -> Element {
pub fn make_roster_push_answer(
    id: String,
    from: xmpp_parsers::Jid,
    to: Option<xmpp_parsers::Jid>,
) -> Iq {
    let mut answer = Iq::from_result(id, None as Option<Roster>);
    answer.from = Some(from);
    answer.to = to;
    answer
}
pub fn make_ask_subscribe(id: String, jid: xmpp_parsers::Jid) -> Element {
pub fn make_ask_subscribe(jid: xmpp_parsers::Jid) -> Element {
    Iq::from_set(
        id,
        Roster {
            items: vec![Item {
                jid,
                name: None,
                subscription: xmpp_parsers::roster::Subscription::None,
                ask: xmpp_parsers::roster::Ask::None,
                groups: vec![],
            }],
            ver: None,
        },
    )
    .into()
pub fn make_roster_push_answer(
    id: String,
    from: xmpp_parsers::Jid,
    to: Option<xmpp_parsers::Jid>,
) -> Iq {
    let mut answer = Iq::from_result(id, None as Option<Roster>);
    answer.from = Some(from);
    answer.to = to;
    answer
}
pub fn make_ask_subscribe(jid: xmpp_parsers::Jid) -> Element {
pub fn make_roster_push_answer(
    id: String,
    from: xmpp_parsers::Jid,
    to: Option<xmpp_parsers::Jid>,
) -> Iq {
    let mut answer = Iq::from_result(id, None as Option<Roster>);
    answer.from = Some(from);
    answer.to = to;
    answer
}
    let mut add_roster = Iq::from_set(Roster {
        items: vec![Item {
            jid,
            name: None,
            subscription: xmpp_parsers::roster::Subscription::None,
            ask: xmpp_parsers::roster::Ask::None,
            groups: vec![],
        }],
        ver: None,
    });
    add_roster.id = Some(id.to_string());
    add_roster.into()
    Iq::from_set(
        id,
        Roster {
            items: vec![Item {
                jid,
                name: None,
                subscription: xmpp_parsers::roster::Subscription::None,
                ask: xmpp_parsers::roster::Ask::None,
                groups: vec![],
            }],
            ver: None,
        },
    )
    .into()
}
pub fn make_roster_push_answer(
    id: String,
    from: xmpp_parsers::Jid,
    to: Option<xmpp_parsers::Jid>,
) -> Iq {
    let mut answer = Iq::from_result(id, None as Option<Roster>);
    answer.from = Some(from);
    answer.to = to;
    answer
    Iq::from_set(
        id,
        Roster {
            items: vec![Item {
                jid,
                name: None,
                subscription: xmpp_parsers::roster::Subscription::None,
                ask: xmpp_parsers::roster::Ask::None,
                groups: vec![],
            }],
            ver: None,
        },
    )
    .into()
pub fn make_add_roster(id: &str, jid: xmpp_parsers::Jid) -> Element {
pub fn make_add_roster(id: &str, jid: xmpp_parsers::BareJid) -> Element {
    let mut get_roster = Iq::from_get(Roster {
        items: vec![],
        ver: None,
    });
    get_roster.id = Some(id.to_string());
    get_roster.into()
    Iq::from_get(
        id,
        Roster {
            items: vec![],
            ver: None,
        },
    )
    .into()
    let mut get_roster = Iq::from_get(Roster {
        items: vec![],
        ver: None,
    });
    get_roster.id = Some(id.to_string());
    get_roster.into()
    Iq::from_get(
        id,
        Roster {
            items: vec![],
            ver: None,
        },
    )
    .into()
    Iq::from_get(
        id,
        Roster {
            items: vec![],
            ver: None,
        },
    )
    .into()
    presence.into()
}
pub fn make_get_roster(id: &str) -> Element {
        .insert(String::from("en"), text);
    presence
        .statuses
    presence.id = Some(id);
    presence.id = Some(id);
    presence.show = show;
    presence.statuses.insert(String::from("en"), text);
pub fn make_presence(_account: &Account) -> Element {
pub fn make_init_presence(id: String, _account: &Account) -> Element {
pub fn make_presence(id: String, show: Option<PresenceShow>, text: String) -> Element {
pub fn make_presence(id: String, show: PresenceShow, text: String) -> Element {
pub fn make_presence(_account: &Account) -> Element {
use xmpp_parsers::roster::{Item, Roster};
use xmpp_parsers::roster::Roster;
use xmpp_parsers::roster::{Item, Roster};
use xmpp_parsers::stanza_error::{DefinedCondition, ErrorType, StanzaError};
use xmpp_parsers::stanza_error::{DefinedCondition, ErrorType, StanzaError};
use xmpp_parsers::stanza_error::{DefinedCondition, ErrorType, StanzaError};
use xmpp_parsers::version::VersionResult;
use xmpp_parsers::stanza_error::{DefinedCondition, ErrorType, StanzaError};
use xmpp_parsers::version::VersionResult;
use xmpp_parsers::{BareJid, Jid};
use xmpp_parsers::roster::{Item, Roster};
use xmpp_parsers::roster::Roster;
use xmpp_parsers::roster::Roster;
use xmpp_parsers::roster::Roster;
use xmpp_parsers::roster::{Item, Roster};
use xmpp_parsers::roster::Roster;
use xmpp_parsers::roster::{Item, Roster};
use xmpp_parsers::roster::Roster;
use xmpp_parsers::iq::Iq;
use xmpp_parsers::message::{Body, Message, MessageType};
use xmpp_parsers::ping::Ping;
use xmpp_parsers::ping::Ping;
use xmpp_parsers::disco::{DiscoInfoResult, DiscoItemsResult, Feature, Identity};
use xmpp_parsers::disco::{DiscoInfoResult, Feature, Identity};
use xmpp_parsers::disco::{DiscoInfoResult, DiscoItemsResult, Feature, Identity};
use xmpp_parsers::iq::Iq;
use xmpp_parsers::disco::{DiscoInfoResult, DiscoItemsResult, Feature, Identity};
use xmpp_parsers::iq::Iq;
use xmpp_parsers::iq::Iq;
use xmpp_parsers::iq::Iq;
use xmpp_parsers::iq::Iq;
use config::Account;
use config::Account;
use crate::config::Account;
use config::Account;
use crate::config::Account;
use crate::config::Account;

File deletion: element_processor.rs

BF:BFD[80.7] → [49.11278:11300]

BF:BFD[49.11300] → [49.11301:11301]

B:BD[49.11301] → [101.31556:32632]

B:BD[49.11301] → [73.34147:35244]

B:BD[49.11301] → [59.43922:45019]

B:BD[49.11301] → [85.35026:36102]

B:BD[49.11301] → [102.42803:43905]

B:BD[49.11301] → [100.30748:31824]

B:BD[49.11301] → [76.227:1324]

B:BD[49.11301] → [63.46618:47720]

B:BD[49.11301] → [86.33451:34527]

B:BD[49.11301] → [91.29525:30601]

B:BD[49.11301] → [75.6275:7372]

B:BD[49.11301] → [103.36205:37302]

B:BD[49.11301] → [29.24939:26015]

B:BD[49.11301] → [23.422:1519]

B:BD[49.11301] → [64.29911:30987]

B:BD[49.11301] → [58.42846:43943]

B:BD[49.11301] → [95.38602:39699]

B:BD[49.11301] → [46.57738:58814]

B:BD[49.11301] → [104.35371:36468]

B:BD[49.11301] → [62.67504:68601]

B:BD[49.11301] → [61.35046:36122]

B:BD[49.11301] → [96.38150:39247]

B:BD[49.11301] → [21.26659:27756]

B:BD[49.11301] → [65.29725:30801]

B:BD[49.11301] → [77.36072:37169]

B:BD[49.11301] → [105.32663:33739]

B:BD[49.11301] → [106.32849:33925]

B:BD[49.11301] → [49.11302:12350]

B:BD[49.11301] → [60.43612:44709]

B:BD[49.11301] → [2.1113:2210]

B:BD[49.11301] → [98.67691:68793]

B:BD[49.11301] → [18.29190:30266]

B:BD[49.11301] → [107.32132:33208]

B:BD[49.11301] → [17.39740:40816]

B:BD[49.11301] → [99.29525:30601]

B:BD[49.11301] → [97.39276:40373]

B:BD[49.11301] → [74.37175:38251]

B:BD[49.11301] → [93.62002:63078]

B:BD[49.11301] → [87.33663:34739]

B:BD[49.11301] → [108.33892:34968]

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

File deletion: xmpp_connection.rs

BF:BFD[80.7] → [99.0:20]

BF:BFD[99.20] → [99.21:21]

∅:BD[21.34] → [74.153:232]

B:BD[74.153] → [74.153:232]

∅:BD[2.46] → [21.81:112]

∅:BD[23.38] → [21.81:112]

B:BD[21.81] → [21.81:112]

B:BD[74.232] → [23.0:38]

B:BD[74.232] → [21.35:81]

B:BD[74.232] → [2.0:46]

∅:BD[21.112] → [74.232:491]

B:BD[74.232] → [74.232:491]

∅:BD[21.222] → [74.620:1576]

B:BD[74.620] → [74.620:1576]

∅:BD[21.255] → [74.1604:2605]

B:BD[74.1604] → [74.1604:2605]

B:BD[74.2650] → [74.2650:3169]

∅:BD[21.302] → [74.3192:4850]

B:BD[74.3192] → [74.3192:4850]

B:BD[74.4850] → [21.303:768]

∅:BD[21.768] → [74.4850:4943]

B:BD[74.4850] → [74.4850:4943]

∅:BD[21.800] → [74.4970:5119]

B:BD[74.4970] → [74.4970:5119]

∅:BD[21.863] → [74.5178:5201]

B:BD[74.5178] → [74.5178:5201]

B:BD[74.5201] → [21.864:985]

∅:BD[21.985] → [74.5201:5525]

B:BD[74.5201] → [74.5201:5525]

∅:BD[21.1028] → [74.5590:5612]

B:BD[74.5590] → [74.5590:5612]

∅:BD[21.1054] → [74.5632:5751]

B:BD[74.5632] → [74.5632:5751]

∅:BD[21.4065] → [74.5870:5873]

B:BD[74.5870] → [74.5870:5873]

∅:BD[21.4197] → [74.5940:6166]

B:BD[74.5940] → [74.5940:6166]

∅:BD[21.5634] → [74.6215:7147]

B:BD[74.6215] → [74.6215:7147]

∅:BD[21.5727] → [74.7276:7286]

B:BD[74.7276] → [74.7276:7286]

∅:BD[21.5791] → [74.7401:7407]

B:BD[74.7401] → [74.7401:7407]

∅:BD[21.5835] → [74.7444:7541]

B:BD[74.7444] → [74.7444:7541]

∅:BD[21.5886] → [74.7665:7682]

B:BD[74.7665] → [74.7665:7682]

∅:BD[21.7343] → [74.8108:8109]

B:BD[74.8108] → [74.8108:8109]

∅:BD[21.7708] → [74.8313:8314]

B:BD[74.8313] → [74.8313:8314]

∅:BD[21.8016] → [74.10292:10342]

B:BD[74.10292] → [74.10292:10342]

∅:BD[21.8657] → [74.10356:10552]

B:BD[74.10356] → [74.10356:10552]

∅:BD[21.8877] → [74.10838:10860]

B:BD[74.10838] → [74.10838:10860]

B:BD[74.10860] → [21.8878:9584]

∅:BD[21.9584] → [74.10860:10884]

B:BD[74.10860] → [74.10860:10884]

B:BD[74.10884] → [21.9585:9618]

∅:BD[21.9618] → [74.10884:11111]

B:BD[74.10884] → [74.10884:11111]

∅:BD[21.10855] → [74.11880:11894]

B:BD[74.11880] → [74.11880:11894]

∅:BD[21.11140] → [74.11988:11998]

B:BD[74.11988] → [74.11988:11998]

∅:BD[21.11405] → [74.12217:12444]

B:BD[74.12217] → [74.12217:12444]

∅:BD[21.11503] → [74.12888:13283]

B:BD[74.12888] → [74.12888:13283]

∅:BD[21.11652] → [74.13431:13833]

B:BD[74.13431] → [74.13431:13833]

∅:BD[21.12524] → [74.13992:14274]

B:BD[74.13992] → [74.13992:14274]

∅:BD[21.13579] → [74.14587:14611]

B:BD[74.14587] → [74.14587:14611]

∅:BD[21.13674] → [74.14760:14770]

B:BD[74.14760] → [74.14760:14770]

B:BD[74.14820] → [74.14820:14886]

∅:BD[21.13727] → [74.14926:14932]

B:BD[74.14926] → [74.14926:14932]

∅:BD[2.306] → [21.13772:14592]

B:BD[21.13772] → [21.13772:14592]

∅:BD[21.14592] → [74.17020:17058]

B:BD[74.17020] → [74.17020:17058]

∅:BD[21.14805] → [74.18037:18075]

B:BD[74.18037] → [74.18037:18075]

∅:BD[21.15517] → [74.18823:18824]

B:BD[74.18823] → [74.18823:18824]

∅:BD[21.16584] → [74.22012:22030]

B:BD[74.22012] → [74.22012:22030]

∅:BD[21.16609] → [74.22055:22288]

B:BD[74.22055] → [74.22055:22288]

∅:BD[21.16648] → [74.22319:22535]

B:BD[74.22319] → [74.22319:22535]

∅:BD[21.16759] → [74.22607:22662]

B:BD[74.22607] → [74.22607:22662]

∅:BD[21.16810] → [74.22705:22729]

B:BD[74.22705] → [74.22705:22729]

∅:BD[21.16880] → [74.22801:22811]

B:BD[74.22801] → [74.22801:22811]

∅:BD[21.16934] → [74.22871:22877]

B:BD[74.22871] → [74.22871:22877]

∅:BD[21.17056] → [74.23130:23198]

B:BD[74.23130] → [74.23130:23198]

B:BD[74.23238] → [74.23238:23304]

∅:BD[21.17101] → [74.23337:23373]

B:BD[74.23337] → [74.23337:23373]

∅:BD[21.17155] → [74.23510:23521]

B:BD[74.23510] → [74.23510:23521]

∅:BD[21.17681] → [74.23869:23887]

B:BD[74.23869] → [74.23869:23887]

∅:BD[21.18002] → [74.24290:24297]

B:BD[74.24290] → [74.24290:24297]

∅:BD[21.18052] → [74.24339:24363]

B:BD[74.24339] → [74.24339:24363]

∅:BD[21.18122] → [74.24435:24445]

B:BD[74.24435] → [74.24435:24445]

∅:BD[21.18176] → [74.24528:24534]

B:BD[74.24528] → [74.24528:24534]

∅:BD[21.18215] → [74.24687:24688]

B:BD[74.24687] → [74.24687:24688]

∅:BD[21.18387] → [74.24945:25011]

B:BD[74.24945] → [74.24945:25011]

∅:BD[21.18920] → [74.25355:25373]

B:BD[74.25355] → [74.25355:25373]

B:BD[74.29388] → [74.29388:29402]

B:BD[74.29402] → [21.18921:19219]

B:BD[74.29419] → [75.0:4341]

B:BD[75.4341] → [75.4341:4358]

∅:BD[75.4358] → [21.19220:19300]

B:BD[74.29419] → [21.19220:19300]

∅:BD[21.19300] → [74.29507:29527]

B:BD[74.29507] → [74.29507:29527]

∅:BD[75.5968] → [74.31069:31257]

B:BD[74.31069] → [74.31069:31257]

∅:BD[21.19492] → [74.31426:31598]

B:BD[74.31426] → [74.31426:31598]

∅:BD[21.19752] → [74.31990:32009]

B:BD[74.31990] → [74.31990:32009]

B:BD[74.32009] → [21.19753:19972]

∅:BD[21.19972] → [74.32009:32274]

B:BD[74.32009] → [74.32009:32274]

∅:BD[21.20350] → [74.32374:32664]

B:BD[74.32374] → [74.32374:32664]

∅:BD[21.20501] → [74.32817:32872]

B:BD[74.32817] → [74.32817:32872]

B:BD[74.32872] → [21.20502:20528]

B:BD[74.32872] → [2.513:539]

∅:BD[2.539] → [74.32872:32882]

∅:BD[21.20528] → [74.32872:32882]

B:BD[74.32872] → [74.32872:32882]

B:BD[74.32882] → [21.20529:20549]

∅:BD[21.20549] → [74.32882:32889]

B:BD[74.32882] → [74.32882:32889]

∅:BD[21.20693] → [74.34079:34089]

B:BD[74.34079] → [74.34079:34089]

∅:BD[21.20747] → [74.34172:34178]

B:BD[74.34172] → [74.34172:34178]

∅:BD[21.22083] → [74.35575:35583]

B:BD[74.35575] → [74.35575:35583]

B:BD[74.34178] → [21.20748:21530]

∅:BD[2.618] → [21.21608:22083]

∅:BD[75.6274] → [21.21608:22083]

B:BD[21.21608] → [21.21608:22083]

B:BD[21.21530] → [75.5969:6274]

B:BD[21.21530] → [21.21530:21608]

B:BD[21.21530] → [2.540:618]

B:BD[74.34178] → [74.34178:35575]

B:BD[74.34089] → [21.20694:20747]

B:BD[74.34089] → [74.34089:34172]

B:BD[74.32889] → [21.20550:20693]

B:BD[74.32889] → [74.32889:34079]

B:BD[74.32664] → [21.20351:20501]

B:BD[74.32664] → [74.32664:32817]

B:BD[74.32274] → [21.19973:20350]

B:BD[74.32274] → [74.32274:32374]

B:BD[74.31598] → [21.19493:19752]

B:BD[74.31598] → [74.31598:31990]

B:BD[74.31257] → [21.19301:19492]

B:BD[74.31257] → [74.31257:31426]

B:BD[74.29527] → [75.4359:5968]

B:BD[74.29527] → [74.29527:31069]

B:BD[74.29419] → [74.29419:29507]

B:BD[74.29402] → [74.29402:29419]

B:BD[74.25373] → [74.25373:29388]

B:BD[74.25011] → [21.18388:18606]

∅:BD[2.512] → [21.18663:18920]

∅:BD[23.270] → [21.18663:18920]

B:BD[21.18663] → [21.18663:18920]

B:BD[21.18606] → [23.223:270]

B:BD[21.18606] → [21.18606:18663]

B:BD[21.18606] → [2.455:512]

B:BD[74.25011] → [74.25011:25355]

B:BD[74.24688] → [21.18216:18387]

B:BD[74.24688] → [74.24688:24945]

B:BD[74.24534] → [21.18177:18215]

B:BD[74.24534] → [74.24534:24687]

B:BD[74.24445] → [21.18123:18176]

B:BD[74.24445] → [74.24445:24528]

B:BD[74.24363] → [21.18053:18122]

B:BD[74.24363] → [74.24363:24435]

B:BD[74.24297] → [21.18003:18052]

B:BD[74.24297] → [74.24297:24339]

B:BD[74.23887] → [21.17682:18002]

B:BD[74.23887] → [74.23887:24290]

B:BD[74.23521] → [21.17156:17681]

B:BD[74.23521] → [74.23521:23869]

B:BD[74.23373] → [21.17102:17155]

B:BD[74.23373] → [74.23373:23510]

B:BD[74.23304] → [21.17057:17101]

B:BD[74.23304] → [74.23304:23337]

B:BD[74.23198] → [74.23198:23238]

B:BD[74.22877] → [21.16935:17056]

B:BD[74.22877] → [74.22877:23130]

B:BD[74.22811] → [21.16881:16934]

B:BD[74.22811] → [74.22811:22871]

B:BD[74.22729] → [21.16811:16880]

B:BD[74.22729] → [74.22729:22801]

B:BD[74.22662] → [21.16760:16810]

B:BD[74.22662] → [74.22662:22705]

B:BD[74.22535] → [21.16649:16759]

B:BD[74.22535] → [74.22535:22607]

B:BD[74.22288] → [21.16610:16648]

B:BD[74.22288] → [74.22288:22319]

B:BD[74.22030] → [21.16585:16609]

B:BD[74.22030] → [74.22030:22055]

B:BD[74.18824] → [21.15518:15705]

∅:BD[2.393] → [21.15791:16029]

∅:BD[23.163] → [21.15791:16029]

B:BD[21.15791] → [21.15791:16029]

∅:BD[2.454] → [21.16089:16584]

∅:BD[23.222] → [21.16089:16584]

B:BD[21.16089] → [21.16089:16584]

B:BD[21.16029] → [23.164:222]

B:BD[21.16029] → [21.16029:16089]

B:BD[21.16029] → [2.394:454]

B:BD[21.15705] → [23.77:163]

B:BD[21.15705] → [21.15705:15791]

B:BD[21.15705] → [2.307:393]

B:BD[74.18824] → [74.18824:22012]

B:BD[74.18075] → [21.14806:15517]

B:BD[74.18075] → [74.18075:18823]

B:BD[74.17058] → [21.14593:14805]

B:BD[74.17058] → [74.17058:18037]

B:BD[74.14932] → [21.13728:13772]

B:BD[74.14932] → [2.262:306]

B:BD[74.14932] → [74.14932:17020]

B:BD[74.14886] → [21.13675:13727]

B:BD[74.14886] → [74.14886:14926]

B:BD[74.14770] → [74.14770:14820]

B:BD[74.14611] → [21.13580:13674]

B:BD[74.14611] → [74.14611:14760]

B:BD[74.14274] → [21.12525:13579]

B:BD[74.14274] → [74.14274:14587]

B:BD[74.13833] → [21.11653:12524]

B:BD[74.13833] → [74.13833:13992]

B:BD[74.13283] → [21.11504:11652]

B:BD[74.13283] → [74.13283:13431]

B:BD[74.12444] → [21.11406:11503]

B:BD[74.12444] → [74.12444:12888]

B:BD[74.11998] → [21.11141:11405]

B:BD[74.11998] → [74.11998:12217]

B:BD[74.11894] → [21.10856:11140]

B:BD[74.11894] → [74.11894:11988]

B:BD[74.11111] → [21.9619:10855]

B:BD[74.11111] → [74.11111:11880]

B:BD[74.10552] → [21.8658:8877]

B:BD[74.10552] → [74.10552:10838]

B:BD[74.10342] → [21.8017:8389]

B:BD[76.204] → [76.204:226]

B:BD[76.226] → [2.47:261]

∅:BD[2.261] → [21.8625:8657]

∅:BD[76.226] → [21.8625:8657]

B:BD[21.8625] → [21.8625:8657]

B:BD[21.8411] → [76.0:204]

B:BD[21.8411] → [21.8411:8559]

B:BD[21.8602] → [21.8602:8625]

B:BD[21.8559] → [23.39:76]

B:BD[21.8559] → [21.8559:8602]

B:BD[21.8389] → [21.8389:8411]

B:BD[74.10342] → [74.10342:10356]

B:BD[74.8314] → [21.7709:8016]

B:BD[74.8314] → [74.8314:10292]

B:BD[74.8109] → [21.7344:7708]

B:BD[74.8109] → [74.8109:8313]

B:BD[74.7682] → [21.5887:7343]

B:BD[74.7682] → [74.7682:8108]

B:BD[74.7541] → [21.5836:5886]

B:BD[74.7541] → [74.7541:7665]

B:BD[74.7407] → [21.5792:5835]

B:BD[74.7407] → [74.7407:7444]

B:BD[74.7286] → [21.5728:5791]

B:BD[74.7286] → [74.7286:7401]

B:BD[74.7147] → [21.5635:5727]

B:BD[74.7147] → [74.7147:7276]

B:BD[74.6166] → [21.4198:5634]

B:BD[74.6166] → [74.6166:6215]

B:BD[74.5873] → [21.4066:4197]

B:BD[74.5873] → [74.5873:5940]

B:BD[74.5751] → [21.1055:4065]

B:BD[74.5751] → [74.5751:5870]

B:BD[74.5612] → [21.1029:1054]

B:BD[74.5612] → [74.5612:5632]

B:BD[74.5525] → [21.986:1028]

B:BD[74.5525] → [74.5525:5590]

B:BD[74.5119] → [21.801:863]

B:BD[74.5119] → [74.5119:5178]

B:BD[74.4943] → [21.769:800]

B:BD[74.4943] → [74.4943:4970]

B:BD[74.3169] → [21.256:302]

B:BD[74.3169] → [74.3169:3192]

B:BD[74.2605] → [74.2605:2650]

B:BD[74.1576] → [21.223:255]

B:BD[74.1576] → [74.1576:1604]

B:BD[74.491] → [21.113:222]

B:BD[74.491] → [74.491:620]

B:BD[99.21] → [101.0:31555]

B:BD[99.21] → [73.0:34146]

B:BD[99.21] → [59.0:34146]

B:BD[99.21] → [85.0:33890]

B:BD[99.21] → [102.0:38895]

B:BD[99.21] → [100.0:30535]

B:BD[99.21] → [63.0:38895]

B:BD[99.21] → [86.0:32199]

B:BD[99.21] → [91.0:29309]

B:BD[99.21] → [103.0:36204]

B:BD[99.21] → [64.0:29593]

B:BD[99.21] → [58.0:35279]

B:BD[99.21] → [95.0:38180]

B:BD[99.21] → [46.0:29189]

B:BD[99.21] → [104.0:35370]

B:BD[99.21] → [62.0:38761]

B:BD[99.21] → [61.0:35045]

B:BD[99.21] → [96.0:37182]

B:BD[99.21] → [21.0:34]

B:BD[99.21] → [65.0:29283]

B:BD[99.21] → [77.0:34146]

B:BD[99.21] → [105.0:32662]

B:BD[99.21] → [106.0:32848]

B:BD[99.21] → [60.0:38895]

B:BD[99.21] → [98.0:38895]

B:BD[99.21] → [18.0:29189]

B:BD[99.21] → [107.0:32131]

B:BD[99.21] → [17.0:29189]

B:BD[99.21] → [99.22:29211]

B:BD[99.21] → [97.0:38761]

B:BD[99.21] → [74.0:153]

B:BD[99.21] → [93.0:32662]

B:BD[99.21] → [87.0:32680]

B:BD[99.21] → [108.0:33891]

use std::collections::{HashMap, VecDeque};
use std::time::{Duration, Instant};
use log::{error, info, warn};
use tokio_xmpp::{AsyncClient, Event};
use tokio_xmpp::{AsyncClient, Event, Packet};
use tokio_xmpp::{AsyncClient, Event, Packet};
use super::stanzas;
use super::element_processor;
use crate::config;
#[derive(Debug)]
pub enum XmppCommand {
    /// Send message to someone by jid
    Chat {
        xmpp_to: xmpp_parsers::Jid,
        message: String,
    },
    /// Send message to MUC
    Ping,
    /// Set presence status
    Presence {
        show: xmpp_parsers::presence::Show,
        message: String,
    },
    /// Send presence status to MUC
    ChatroomPresence {
        muc_id: String,
        show: xmpp_parsers::presence::Show,
        message: String,
    },
    /// Check iq requests if some have expired timeouts
    TimeoutCleanup,
}
/// trait of processing iq
/// each function consumes handlers and
/// returns false if connection should be reset
trait IqHandler {
    /// process result
    fn result(
        self: Box<Self>,
        conn: &mut XmppConnection,
        opt_element: Option<xmpp_parsers::Element>,
    ) -> bool;
    /// process error
    fn error(
        self: Box<Self>,
        conn: &mut XmppConnection,
        error: xmpp_parsers::stanza_error::StanzaError,
    ) -> bool;
    /// process tmeout
    fn timeout(self: Box<Self>, conn: &mut XmppConnection) -> bool;
}
struct AddRosterIqHandler {
}
impl IqHandler for AddRosterIqHandler {
    fn result(
        self: Box<Self>,
        conn: &mut XmppConnection,
        opt_element: Option<xmpp_parsers::Element>,
    ) -> bool {
        match opt_element {
            Some(element) => {
                warn!(
                    "Wrong payload when adding {} to roster: {}",
                    self.jid,
                    String::from(&element)
                );
            }
            None => {
                if conn.state.data.roster.contains_key(&self.jid) {
                    info!("Jid {} updated to roster", self.jid);
                } else {
                    info!("Jid {} added in roster", self.jid);
                    conn.state.data.roster.insert(
                        self.jid.clone(),
                        (
                            xmpp_parsers::roster::Subscription::None,
                            xmpp_parsers::roster::Ask::None,
                        ),
                    );
                }
            }
        }
        true
    }
    fn error(
        self: Box<Self>,
        _conn: &mut XmppConnection,
        _error: xmpp_parsers::stanza_error::StanzaError,
    ) -> bool {
        true
    }
    fn timeout(self: Box<Self>, _conn: &mut XmppConnection) -> bool {
        true // ignore
    }
}
struct PingIqHandler {}
impl IqHandler for PingIqHandler {
    fn result(
        self: Box<Self>,
        _conn: &mut XmppConnection,
        _opt_element: Option<xmpp_parsers::Element>,
    ) -> bool {
    }
    fn error(
        self: Box<Self>,
        _conn: &mut XmppConnection,
        _error: xmpp_parsers::stanza_error::StanzaError,
    ) -> bool {
        false
    }
    fn timeout(self: Box<Self>, _conn: &mut XmppConnection) -> bool {
        false
    }
}
struct InitRosterIqHandler {}
impl IqHandler for InitRosterIqHandler {
    fn result(
        self: Box<Self>,
        conn: &mut XmppConnection,
        opt_element: Option<xmpp_parsers::Element>,
    ) -> bool {
        if let Some(result) = opt_element {
            use std::convert::TryInto;
            match result.try_into() as Result<xmpp_parsers::roster::Roster, _> {
                Ok(roster) => {
                    conn.state.data.roster_init = true;
                    conn.state.data.roster.clear();
                    info!("Got first roster:");
                    for i in roster.items {
                        info!(" >>> {:?}", i);
                        conn.state
                            .data
                            .roster
                            .insert(i.jid, (i.subscription, i.ask));
                    }
                    true
                }
                Err(e) => {
                    error!("Cann't parse roster: {}", e);
                    false
                }
            }
        } else {
            error!("No roster responded");
            false
        }
    }
    fn error(
        self: Box<Self>,
        _conn: &mut XmppConnection,
        _error: xmpp_parsers::stanza_error::StanzaError,
    ) -> bool {
        false
    }
    fn timeout(self: Box<Self>, _conn: &mut XmppConnection) -> bool {
        false
    }
}
/// data for awaiting iq answer
struct IqWait {
    /// time of sending iq
    sent: Instant,
    /// timeout
    timeout: Duration,
    /// handler for iq processing
    handler: Box<dyn IqHandler>,
}
impl IqWait {
    pub fn new<T: IqHandler + 'static>(timeout_secs: u64, handler: T) -> IqWait {
        IqWait {
            sent: Instant::now(),
            timeout: Duration::from_secs(timeout_secs),
            handler: Box::new(handler),
        }
    }
}
#[derive(Default)]
struct XmppData {
    /// known roster data
    roster: HashMap<
        (
            xmpp_parsers::roster::Subscription,
            xmpp_parsers::roster::Ask,
        ),
    >,
    /// if roster was initialized
    roster_init: bool,
    /// if self-presence accepted
    /// ToDo: remove it as it is used only for initialization
    self_presence: bool,
    /// ids counter
    counter: usize,
    /// 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>,
    /// map from iq's id to handler of this type of iqs
}
struct XmppState {
    data: XmppData,
}
pub struct XmppConnection {
    account: std::rc::Rc<config::Account>,
    state: XmppState,
}
}
        let mut incoming = element_processor::Processor::new(&|_, e| {
            warn!("Unknown stanza {}", String::from(&e));
            true
        });
        incoming.register(&XmppConnection::incoming_iq_processing);
}
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
    where
    {
        let MaybeXmppConnection { account, state } = self;
        if let Some(state) = state {
        } else {
                        }
                    }),
        }
    }
}
impl XmppConnection {
    /// base XMPP processing
    /// Returns false on error to disconnect
    fn xmpp_processing(&mut self, event: &Event) -> bool {
        match event {
                false
            }
        }
    }
    /// Process roster push
    /// see RFC 6212 2.1.6. Roster Push
    fn incoming_iq_processing_set_roster(
        &mut self,
        roster: xmpp_parsers::roster::Roster,
    ) -> Box<dyn IqRequestHandler> {
        for i in roster.items {
            if let Some(ref mut rdata) = self.state.data.roster.get_mut(&i.jid) {
                info!("Update {} in roster", i.jid);
                rdata.0 = i.subscription;
                rdata.1 = i.ask;
            } else {
                info!("Add {} to roster", i.jid);
                self.state
                    .data
                    .roster
                    .insert(i.jid.clone(), (i.subscription, i.ask));
            }
        }
        Box::new(IqSetRoster {})
    }
    /// Enforce to answer to IQ "set"
    fn incoming_iq_processing_set(
        &mut self,
        id: String,
        from: Option<xmpp_parsers::Jid>,
        element: minidom::Element,
    ) -> xmpp_parsers::iq::Iq {
            }
        }
    }
    /// Enforce to answer to IQ "get"
    fn incoming_iq_processing_get(
        &mut self,
        id: String,
        from: Option<xmpp_parsers::Jid>,
        element: minidom::Element,
    ) -> xmpp_parsers::iq::Iq {
    }
    fn incoming_iq_processing(&mut self, iq: xmpp_parsers::iq::Iq) -> bool {
        match iq.payload {
            xmpp_parsers::iq::IqType::Set(element) => {
                let iq_answer = self.incoming_iq_processing_set(iq.id, iq.from, element);
                self.state.data.send_queue.push_back(iq_answer.into());
            }
            xmpp_parsers::iq::IqType::Error(e) => {
                }
                error!("iq error: {:?}", e);
                return false;
            }
            xmpp_parsers::iq::IqType::Get(element) => {
                let iq_answer = self.incoming_iq_processing_get(iq.id, iq.from, element);
                self.state.data.send_queue.push_back(iq_answer.into());
            }
            xmpp_parsers::iq::IqType::Result(opt_element) => {
                }
                warn!(
                    "Unwanted iq result id {} from {:?}: {:?}",
                    iq.id,
                    iq.from,
                    opt_element.map(|e| String::from(&e))
                );
            }
        }
        true
    }
        stop_future: F,
    where
        S: FnMut(&mut Self, Event) -> Result<bool, ()> + 'static,
    {
        let mut stop_future = stop_future;
        loop {
            if let Some(send_element) = self.state.data.send_queue.pop_front() {
                info!("Sending {}", String::from(&send_element));
                let stop = {
                    let send_future = self.state.client.send_stanza(send_element);
                    tokio::pin!(send_future);
                    match futures_util::future::select(stop_future, send_future).await {
                        Either::Left((stop, send_future)) => {
                            if stop_fatal {
                                warn!("Sending interrupted!");
                            } else {
                                match send_future.await {
                                    Ok(_) => {
                                        info!("Sent!");
                                    }
                                    }
                }
    }
    /// 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 {
                info!("Online!");
                Ok(true)
            }
            Event::Stanza(s) => {
                warn!("Stanza before online: {}", String::from(&s));
                Ok(false)
            }
                Err(())
            }
        }
    }
        stop_future: F,
    where
    {
        let get_roster = stanzas::make_get_roster(&id_init_roster);
        info!("Quering roster... {}", String::from(&get_roster));
            id_init_roster.clone(),
        );
                }
    }
        stop_future: F,
    where
    {
        info!("Sending presence... {}", String::from(&presence));
                }
            }
        };
        if let Some(stop_future) = stop_future {
            self.processing(
                move |conn, _| Ok(conn.state.data.self_presence),
                stop_future,
                true,
            )
            .await
        } else {
            (Ok(self), Either::Right(()))
    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(&std::convert::From::from(xmpp_to.clone()))
                {
                    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.counter += 1;
                        let id_presence_subscribe =
                            format!("id_presence_subscribe{}", self.state.data.counter);
                        self.state
                            .data
                            .send_queue
                            .push_back(stanzas::make_ask_subscribe(
                                id_presence_subscribe,
                                xmpp_to.clone(),
                            ));
                    } else {
                        warn!(
                            "Not subscribed to {}. Currently in {:?} state",
                            xmpp_to, rdata.1
                        );
                        self.state.data.counter += 1;
                        let id_presence_subscribe =
                            format!("id_presence_subscribe{}", self.state.data.counter);
                        self.state
                            .data
                            .send_queue
                            .push_back(stanzas::make_ask_subscribe(
                                id_presence_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.counter += 1;
                        let id_presence_subscribed =
                            format!("id_presence_subscribed{}", self.state.data.counter);
                        self.state
                            .data
                            .send_queue
                            .push_back(stanzas::make_allow_subscribe(
                                id_presence_subscribed,
                                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,
                        std::convert::From::from(xmpp_to.clone()),
                    );
                    info!("Adding jid {} to roster id {}", xmpp_to, id_add_roster);
                    self.state.data.pending_ids.insert(
                        id_add_roster,
                        IqWait::new(
                            60,
                            AddRosterIqHandler {
                                jid: std::convert::From::from(xmpp_to.clone()),
                            },
                        ),
                    );
                    self.state.data.send_queue.push_back(add_roster);
                }
            }
        }
    }
    pub fn process_command(mut self, cmd: XmppCommand) -> MaybeXmppConnection {
        match cmd {
            XmppCommand::Presence { show, message } => {
                self.state.data.counter += 1;
                let id_presence = format!("id_presence{}", self.state.data.counter);
            }
            XmppCommand::Ping => {
                self.state.data.counter += 1;
                let id_ping = format!("id_ping{}", self.state.data.counter);
                );
                self.state.data.send_queue.push_back(ping);
                self.state
                    .data
                    .pending_ids
                    .insert(id_ping, IqWait::new(30, PingIqHandler {}));
            }
            XmppCommand::TimeoutCleanup => {
                let now = Instant::now();
                let timeouted: Vec<String> = self
                    .state
                    .data
                    .pending_ids
                    .iter()
                            Some(id.to_string())
                        } else {
                            None
                        }
                    })
                    .collect();
                let mut correct = true;
                timeouted.into_iter().for_each(|id| {
                    }
                })
            }
            _ => todo!(),
            _ => todo!(),
        }
        self.into()
    }
    where
    {
    }
}
        for chatroom in &self.account.chatrooms {
            self.state.data.counter += 1;
            let id_muc_presence = format!("id_muc_presence{}", self.state.data.counter);
            let muc_presence = stanzas::make_muc_presence(
                &id_muc_presence,
                self.account.jid.clone(),
                chatroom.1.clone(),
                None,
                None,
            );
            info!("Sending muc presence... {}", String::from(&muc_presence));
            let opt_stop_future = {
                let send_future = self.state.client.send_stanza(muc_presence);
                tokio::pin!(send_future);
                match futures_util::future::select(stop_future, send_future).await {
                    Either::Left(((), _)) => None,
                    Either::Right((Err(e), f)) => {
                        error!("Send self-presence stanza error: {}", e);
                        return (Err(self.account), Either::Left(f));
                    }
                }
            };
            if let Some(f) = opt_stop_future {
                stop_future = f;
            } else {
                return (Ok(self), Either::Right(()));
            }
        }
        (Ok(self), Either::Left(stop_future))
                    Either::Right((Ok(_), stop_future)) => {
                        self.state
                            .data
                            .mucs
                            .insert(chatroom.0.clone(), chatroom.1.clone());
                        Some(stop_future)
                    }
                    Either::Right((Ok(_), stop_future)) => Some(stop_future),
                    Either::Right((Ok(_), stop_future)) => Some(stop_future),
        let XmppConnection { account, state } = self;
        let account2 = account.clone();
        let account3 = account.clone();
        stream::iter_ok(account.chatrooms.clone())
            .fold(state, move |XmppState { client, mut data }, muc_jid| {
                data.counter += 1;
                let id_muc_presence = format!("id_muc_presence{}", data.counter);
                let muc_presence = stanzas::make_muc_presence(
                    &id_muc_presence,
                    account2.jid.clone(),
                    muc_jid.1.clone(),
                    xmpp_parsers::presence::Show::None,
                    None,
                );
                info!("Sending muc presence... {}", String::from(&muc_presence));
                let account4 = account2.clone();
                use tokio::prelude::Sink;
                client
                    .send(Packet::Stanza(muc_presence))
                    .map_err(|e| {
                        error!("Error on send muc presence: {}", e);
                        account4
                    })
                    .and_then(|client| {
                        data.mucs.insert(muc_jid.0, muc_jid.1);
                        future::ok(XmppState { client, data })
                    })
            })
            .map(|state| XmppConnection {
                account: account3,
                state,
            })
        F: std::future::Future<Output = ()> + Unpin,
        F: Future<Error = E> + 'static,
        E: Into<failure::Error> + 'static,
    async fn enter_mucs<F>(
        mut self,
        mut stop_future: F,
    ) -> (Result<Self, std::rc::Rc<config::Account>>, Either<F, ()>)
    pub fn shutdown(self) -> impl Future<Item = (), Error = failure::Error> {
        info!("Shutdown connection");
        let XmppConnection { account, state } = self;
        stream::iter_ok(
            state
                .data
                .mucs
                .values()
                .map(std::clone::Clone::clone)
                .collect::<Vec<_>>(),
        )
        .fold(state, move |XmppState { client, data }, muc_jid| {
            let muc_presence =
                stanzas::make_muc_presence_leave(account.jid.clone(), muc_jid.clone());
            info!(
                "Sending muc leave presence... {}",
                String::from(&muc_presence)
            );
            use tokio::prelude::Sink;
            client
                .send(Packet::Stanza(muc_presence))
                .map_err(|e| {
                    error!("Error on send muc presence: {}", e);
                    e
                })
                .and_then(|client| future::ok(XmppState { client, data }))
        })
        .map(|_| ())
    }
    fn enter_mucs<F, E>(
        self,
        _stop_future: F,
    ) -> impl Future<Item = Self, Error = std::rc::Rc<config::Account>>
                    if let Some(data) = self.state.data.pending_ids.remove(&id) {
                        correct &= data.handler.timeout(&mut self);
                    if let Some((_, handler)) = self.state.data.pending_ids.remove(&id) {
                        correct &= handler.timeout(&mut self);
                    .filter_map(|(id, data)| {
                        if now >= data.sent + data.timeout {
                            warn!(
                                "Timeout for {} was {:?} expected {:?}",
                                id,
                                now - data.sent,
                                data.timeout
                            );
                    .filter_map(|(id, (timeout, _))| {
                        if now >= *timeout {
                let ping = stanzas::make_ping(
                    &id_ping,
                    self.state
                        .client
                        .bound_jid()
                        .map_or_else(|| self.account.jid.clone(), |j| j.clone()),
                let ping = stanzas::make_ping(&id_ping, self.state.client.jid.clone());
                self.state.data.send_queue.push_back(ping);
                self.state.data.pending_ids.insert(
                    id_ping,
                    (
                        Instant::now() + Duration::from_secs(30),
                        Box::new(PingIqHandler {}),
                    ),
                self.state.data.send_queue.push_back(stanzas::make_presence(
                    id_presence,
                    Some(show),
                    message,
                ));
                self.state
                    .data
                    .send_queue
                    .push_back(stanzas::make_presence(id_presence, show, message));
            XmppCommand::Chat { xmpp_to, message } => {
                self.state
                    .data
                    .outgoing_mailbox
                    .entry(xmpp_to.clone())
                    .or_default()
                    .push(message);
                self.process_jid(&xmpp_to);
            }
            XmppCommand::Chatroom { muc_id, message } => {
                if let Some(muc) = self.state.data.mucs.get(&muc_id) {
                    self.state
                        .data
                        .send_queue
                        .push_back(stanzas::make_muc_message(muc.clone(), message));
                } else {
                    error!("Not found MUC {}", muc_id);
                }
            }
            XmppCommand::ChatroomPresence {
                muc_id,
                show,
                message,
            } => {
                if let Some(muc) = self.state.data.mucs.get(&muc_id) {
                    self.state.data.counter += 1;
                    let id_presence = format!("id_presence{}", self.state.data.counter);
                    self.state
                        .data
                        .send_queue
                        .push_back(stanzas::make_muc_presence(
                            &id_presence,
                            self.account.jid.clone(),
                            muc.clone(),
                            Some(show),
                            Some(message),
                        ));
                } else {
                    error!("Not found MUC {}", muc_id);
                }
            }
            XmppCommand::Chat { xmpp_to, message } => {
                self.state
                    .data
                    .outgoing_mailbox
                    .entry(xmpp_to.clone())
                    .or_default()
                    .push(message);
                self.process_jid(&xmpp_to);
            }
            XmppCommand::Chatroom { muc_id, message } => {
                if let Some(muc) = self.state.data.mucs.get(&muc_id) {
                    self.state
                        .data
                        .send_queue
                        .push_back(stanzas::make_muc_message(muc.clone(), message));
                } else {
                    error!("Not found MUC {}", muc_id);
                }
            }
            XmppCommand::ChatroomPresence { muc_id, show, message } => {
                if let Some(muc) = self.state.data.mucs.get(&muc_id) {
                    self.state.data.counter += 1;
                    let id_presence = format!("id_presence{}", self.state.data.counter);
                    self.state
                        .data
                        .send_queue
                        .push_back(stanzas::make_muc_presence(
                            &id_presence,
                            self.account.jid.clone(),
                            muc.clone(),
                            show,
                            Some(message),
                        ));
                } else {
                    error!("Not found MUC {}", muc_id);
                }
            }
    pub fn process_command(&mut self, cmd: XmppCommand) {
        info!("Got command");
        }
    }
                .processing(
                    move |conn, event| {
                        if let Event::Stanza(s) = event {
                            use std::convert::TryInto;
                            match s.try_into() as Result<xmpp_parsers::presence::Presence, _> {
                                Ok(presence) => {
                                    Ok(presence.from.as_ref() == Some(&conn.state.client.jid))
                                }
                                Err(e) => {
                                    warn!("Not a self-presence: {}", e);
                                    Ok(false)
                                }
                            }
                        } else {
                            error!("Wrong event while waiting self-presence");
                            Err(())
                        }
                    },
                    stop_future,
                )
                .map_err(|(account, _)| account)
                .and_then(|(conn, r)| match r {
                    Ok(Either::A(_)) => future::ok(conn),
                    Ok(Either::B(_)) => future::err(conn.account),
                    Err(_e) => future::err(conn.account),
                })
            })
    }
    fn process_jid(&mut self, xmpp_to: &xmpp_parsers::Jid) {
        if let Some(ref mut mailbox) = self.state.data.outgoing_mailbox.get_mut(xmpp_to) {
            if !mailbox.is_empty() {
                if let Some(ref mut rdata) = self.state.data.roster.get_mut(xmpp_to) {
                    info!("Jid {} in roster", xmpp_to);
                    let sub_to = match rdata.0 {
                        xmpp_parsers::roster::Subscription::To => true,
                        xmpp_parsers::roster::Subscription::Both => true,
                        _ => false,
                    };
                    if sub_to {
                        info!("Subscribed to {}", xmpp_to);
                        self.state.data.send_queue.extend(
                            mailbox.drain(..).map(|message| {
                                stanzas::make_chat_message(xmpp_to.clone(), message)
                            }),
                        );
                    } else if rdata.1 == xmpp_parsers::roster::Ask::None {
                        info!("Not subscribed to {}", xmpp_to);
                        self.state
                            .data
                            .send_queue
                            .push_back(stanzas::make_ask_subscribe(xmpp_to.clone()));
                    }
                    let sub_from = match rdata.0 {
                        xmpp_parsers::roster::Subscription::From => true,
                        xmpp_parsers::roster::Subscription::Both => true,
                        _ => false,
                    };
                    if !sub_from {
                        info!("Not subscription from {}", xmpp_to);
                        self.state
                            .data
                            .send_queue
                            .push_back(stanzas::make_allow_subscribe(xmpp_to.clone()));
                    }
                } else {
                    info!("Jid {} not in roster", xmpp_to);
                    self.state.data.counter += 1;
                    let id_add_roster = format!("id_add_roster{}", self.state.data.counter);
                    let add_roster = stanzas::make_add_roster(&id_add_roster, xmpp_to.clone());
                    info!("Adding jid {} to roster id {}", xmpp_to, id_add_roster);
                    self.state.data.pending_ids.insert(
                        id_add_roster,
                        (
                            Instant::now() + Duration::from_secs(60),
                            Box::new(AddRosterIqHandler {
                                jid: xmpp_to.clone(),
                            }),
                        ),
                    );
                    self.state.data.send_queue.push_back(add_roster);
                }
        let stop_future = {
            let send_future = self.state.client.send_stanza(presence);
            tokio::pin!(send_future);
            match futures_util::future::select(stop_future, send_future).await {
                Either::Right((Ok(_), stop_future)) => Some(stop_future),
                Either::Right((Err(e), f)) => {
                    error!("Send self-presence stanza error: {}", e);
                    return (Err(self.account), Either::Left(f));
                Either::Left(((), _)) => None,
                Either::Left(((), send_future)) => None,
                Either::Left(((), send_future)) => None,
        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,
        let id_presence = format!("id_init_presence{}", self.state.data.counter);
        let presence = stanzas::make_presence(id_presence, None, "Online!".to_string());
        data.counter += 1;
        let id_presence = format!("id_init_presence{}", data.counter);
        let presence = stanzas::make_presence(id_presence, xmpp_parsers::presence::Show::None, "Online!".to_string());
        let account2 = account.clone();
        self.state.data.counter += 1;
        let XmppConnection {
            account,
            state: XmppState { client, mut data },
        } = self;
        use tokio::prelude::Sink;
        F: std::future::Future<Output = ()> + Unpin,
        F: Future<Error = E> + 'static,
        E: Into<failure::Error> + 'static,
    ) -> (Result<Self, std::rc::Rc<config::Account>>, Either<F, ()>)
    ) -> impl Future<Item = Self, Error = std::rc::Rc<config::Account>>
    async fn self_presence<F>(
        mut self,
    fn self_presence<F, E>(
        self,
            }
        };
        if let Some(stop_future) = stop_future {
            self.processing(
                move |conn, _| Ok(conn.state.data.roster_init),
                stop_future,
                true,
            )
            .await
        } else {
            (Ok(self), Either::Right(()))
        }
                .processing(move |conn, _| Ok(conn.state.data.roster_init), stop_future)
                .map_err(|(account, _)| account)
                .and_then(|(conn, r)| match r {
                    Ok(Either::A(_)) => future::ok(conn),
                    Ok(Either::B(_)) => future::err(conn.account),
                    Err(_e) => future::err(conn.account),
                })
            })
        let stop_future = {
            let send_future = self.state.client.send_stanza(get_roster);
            tokio::pin!(send_future);
            match futures_util::future::select(stop_future, send_future).await {
                Either::Left(((), _)) => None,
                Either::Right((Ok(_), stop_future)) => Some(stop_future),
                Either::Right((Err(e), f)) => {
                    error!("Send initial roster stanza error: {}", e);
                    return (Err(self.account), Either::Left(f));
        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,
            IqWait::new(60, InitRosterIqHandler {}),
            (
                Instant::now() + Duration::from_secs(60),
                Box::new(InitRosterIqHandler {}),
            ),
        self.state.data.pending_ids.insert(
        data.pending_ids.insert(
        let account2 = account.clone();
        self.state.data.counter += 1;
        let id_init_roster = format!("id_init_roster{}", self.state.data.counter);
        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);
        F: std::future::Future<Output = ()> + Unpin,
        F: Future<Error = E> + 'static,
        E: 'static,
    ) -> (Result<Self, std::rc::Rc<config::Account>>, Either<F, ()>)
    ) -> impl Future<Item = Self, Error = std::rc::Rc<config::Account>>
    async fn initial_roster<F>(
        mut self,
    fn initial_roster<F, E>(
        self,
            Event::Disconnected(e) => {
                error!("Disconnected while waiting online: {:?}", e);
            _ => {
                error!("Disconnected while online");
            Event::Online { .. } => {
            Event::Online => {
            }
        }
            },
        )
                let recv_future = self.state.client.next();
                tokio::pin!(recv_future);
                match futures_util::future::select(stop_future, recv_future).await {
                    Either::Right((None, f)) => {
                        break (Err(self.account), Either::Left(f));
                    }
                    Either::Right((Some(event), f)) => {
                        stop_future = f;
                            match stop_condition(&mut self, event) {
                                Ok(true) => break (Ok(self), Either::Left(stop_future)),
                                Ok(false) => {}
                                Err(_) => break (Err(self.account), Either::Left(stop_future)),
                            }
                        } else {
                            break (Err(self.account), Either::Left(stop_future));
                        }
                    }
                        if self.xmpp_processing(&event) {
                        if (self.xmpp_processing(&event)) {
                        if (self.xmpp_processing(&event)) {
                    Either::Left((stop, _)) => break (Ok(self), Either::Right(stop)),
                    Either::Left((stop, s)) => break (Ok(self), Either::Right(stop)),
                    Either::Left((stop, s)) => break (Ok(self), Either::Right(stop)),
                                        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)))
                                    }
                                }
                            }),
                    )
                                }
                            }
                            stop
                        }
                        Either::Right((Ok(_), f)) => {
                            info!("Sent!");
                            stop_future = f;
                            continue;
                        }
                        Either::Right((Err(e), f)) => {
                            error!("Send stanza error: {}", e);
                            break (Err(self.account), Either::Left(f));
                        }
                    }
                };
                break (Ok(self), Either::Right(stop));
            } else {
                use futures_util::StreamExt;
                                })),
                            }),
                    ) 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,
                                        };
                                    Err(e) => {
                                        error!("Send stanza error: {}", e);
                                        break (Err(self.account), Either::Right(stop));
                                })),
                                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)))
        let account = self.account.clone();
        let account = self.account.clone();
        future::loop_fn(
            (self, stop_future, stop_condition),
            |(xmpp, stop_future, mut stop_condition)| {
                // ToDo: check timeouts if iqs
                let XmppConnection {
                    state: XmppState { client, mut data },
                    account,
                } = xmpp;
                if let Some(send_element) = data.send_queue.pop_front() {
                    use tokio::prelude::Sink;
                    info!("Sending {}", String::from(&send_element));
                    Box::new(
                        client
                            .send(Packet::Stanza(send_element))
                            .select2(stop_future)
                            .then(move |r| match r {
                                Ok(Either::A((client, b))) => {
                                    Box::new(future::ok(future::Loop::Continue((
                                        XmppConnection {
                                            state: XmppState { client, data },
                                            account,
                                        },
                                        b,
                                        stop_condition,
                                    ))))
                                        as Box<dyn Future<Item = _, Error = _>>
                                }
                                Ok(Either::B((t, a))) => Box::new(a.then(|r| match r {
                                    Ok(client) => future::ok(future::Loop::Break((
                                        XmppConnection {
                                            state: XmppState { client, data },
                                            account,
                                        },
                                        Ok(Either::B(t)),
                                    ))),
                                    Err(se) => {
                                        warn!("XMPP sending error: {}", se);
                                        future::err((account, Ok(Either::B(t))))
        F: std::future::Future<Output = O> + Unpin,
        T: 'static,
        E: 'static,
        F: Future<Item = T, Error = E> + 'static,
        stop_fatal: bool,
    ) -> (Result<Self, std::rc::Rc<config::Account>>, Either<F, O>)
    ) -> impl Future<
        Item = (Self, Result<Either<F, T>, E>),
        Error = (std::rc::Rc<config::Account>, Result<Either<F, T>, E>),
    >
    fn incoming_presence_processing(&mut self, presence: xmpp_parsers::presence::Presence) -> bool {
        if presence.from.as_ref() == Some(&self.account.jid) {
            info!("Self-presence accepted");
            self.state.data.self_presence = true;
        } else {
            warn!("Incoming presence stanza: {:?}", presence);
        }
        true
    }
    fn incoming_message_processing(&mut self, message: xmpp_parsers::message::Message) -> bool {
        for payload in message.payloads.iter() {
            use std::convert::TryInto;
            if let Some(_delay) =
                payload.clone().try_into().ok() as Option<xmpp_parsers::delay::Delay>
            {
                return true; // ignore delayed messages
            }
        }
        warn!("Incoming message stanza: {:?}", message);
        true
    }
    /// first data: return Ok(conn) if still connected, Err(account) if disconnected
    /// second data: true if stopped
    pub async fn processing<S, F, O>(
        mut self,
        mut stop_condition: S,
    /// 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,
                if let Some((_, data)) = self.state.data.pending_ids.remove_entry(&iq.id) {
                    let now = Instant::now();
                    if data.sent + data.timeout > now {
                        info!(
                            "Timeout for {} was {:?} expected {:?}",
                            iq.id,
                            now - data.sent,
                            data.timeout
                        );
                        return data.handler.result(self, opt_element);
                    } else {
                        warn!(
                            "Timeout for {} was {:?} expected {:?}",
                            iq.id,
                            now - data.sent,
                            data.timeout
                        );
                        return data.handler.timeout(self);
                    }
                if let Some((_, handler)) = self.state.data.pending_ids.remove_entry(&iq.id) {
                    return handler.1.result(self, opt_element);
                if let Some((_, data)) = self.state.data.pending_ids.remove_entry(&iq.id) {
                    return data.handler.error(self, e);
                if let Some((_, handler)) = self.state.data.pending_ids.remove_entry(&iq.id) {
                    return handler.1.error(self, e);
        INCOMING_IQ_GET
            .process(self, element)
            .process(self, id, from)
        use std::convert::TryInto;
        if let Some(_ping) = element.clone().try_into().ok() as Option<xmpp_parsers::ping::Ping> {
            return stanzas::make_pong(&id, self.state.client.jid.clone(), from);
        }
        warn!(
            "Unsupported IQ get request from {:?}: {}",
            from,
            String::from(&element)
        );
        stanzas::make_iq_unsupported_error(id, self.state.client.jid.clone(), from)
    }
    /// Process version query
    /// see XEP-0092: Software Version
    fn incoming_iq_processing_get_version(
        &mut self,
        _version: xmpp_parsers::version::VersionQuery,
    ) -> Box<dyn IqRequestHandler> {
        Box::new(IqGetVersion {})
        warn!(
            "Unsupported IQ set request from {:?}: {}",
            from,
            String::from(&element)
        );
        stanzas::make_iq_unsupported_error(id, self.state.client.jid.clone(), from)
            Some(node) => {
                warn!("Unsupported node {}", node);
                Box::new(IqRequestUnknown {
                    element: disco.into(),
                    type_: "get",
                })
            }
            None => Box::new(IqGetDiscoItems {}),
            return stanzas::make_roster_push_answer(id, self.state.client.jid.clone(), from);
        INCOMING_IQ_SET
            .process(self, element)
            .process(self, id, from)
    }
    /// Process ping request
    /// see XEP-0199: XMPP Ping
    fn incoming_iq_processing_get_ping(
        &mut self,
        _ping: xmpp_parsers::ping::Ping,
    ) -> Box<dyn IqRequestHandler> {
        Box::new(IqGetPing {})
    }
    /// Process disco query
    /// see XEP-0030: Service Discovery
    fn incoming_iq_processing_get_disco_info(
        &mut self,
        disco: xmpp_parsers::disco::DiscoInfoQuery,
    ) -> Box<dyn IqRequestHandler> {
        if let Some(ref node) = disco.node {
            warn!("Unsupported node {}", node);
            Box::new(IqRequestUnknown {
                element: disco.into(),
                type_: "get",
            })
        } else {
            Box::new(IqGetDiscoInfo {})
        }
    }
    /// Process disco items query
    /// see XEP-0030: Service Discovery
    fn incoming_iq_processing_get_disco_items(
        &mut self,
        disco: xmpp_parsers::disco::DiscoItemsQuery,
    ) -> Box<dyn IqRequestHandler> {
        match &disco.node {
            Some(node) if node == "http://jabber.org/protocol/commands" => {
                Box::new(IqGetDiscoCommands {})
        use std::convert::TryInto;
        if let Some(roster) =
            element.clone().try_into().ok() as Option<xmpp_parsers::roster::Roster>
        {
            // RFC 6212 2.1.6. Roster Push
            for i in roster.items {
                if let Some(ref mut rdata) = self.state.data.roster.get_mut(&i.jid) {
                    info!("Update {} in roster", i.jid);
                    rdata.0 = i.subscription;
                    rdata.1 = i.ask;
                } else {
                    info!("Add {} to roster", i.jid);
                    self.state
                        .data
                        .roster
                        .insert(i.jid.clone(), (i.subscription, i.ask));
                }
                self.process_jid(&i.jid);
            Event::Stanza(stanza) => INCOMING.process(self, stanza.clone()),
            Event::Online { .. } => true,
            Event::Disconnected(error) => {
                error!("Unexpected event {:?}", error);
            Event::Stanza(stanza) => {
                let processors = XmppElementProcessor::new();
                processors.incoming.process(self, stanza.clone())
            }
            Event::Online => true,
            e => {
                warn!("Unexpected event {:?}", e);
                )
                .await;
                match connect {
                    Either::Left((_, _)) => {
                        break Err(failure::format_err!("Stop XMPP connection"))
                    }
                    Either::Right(((_, Either::Right(_)), _)) => {
                        break Err(failure::format_err!("Stop XMPP connection(2)"))
                    }
                    Either::Right(((result, Either::Left(_)), _)) => match result {
                        Ok(connection) => break Ok(connection),
                        Err(account) => {}
                    },
                }
            }
                    Either::Right(((result, Either::Left(_)), _)) => {
                        if let Ok(connection) = result {
                            break Ok(connection);
                        }
                    Either::Right(((result, Either::Left(_)), _)) => match result {
                        Ok(connection) => break Ok(connection),
                    },
                        Err(_) => {}
                        Err(account) => {}
                    }
            )
                        match (connected, stopped) {
                            (Ok(connection), Either::Left(stop_future)) => {
                                connection.enter_mucs(stop_future).await
                            }
                            (connected, stopped) => (connected, stopped),
                            // 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"))
                        let (connected, stopped) = match (connected, stopped) {
                            (Ok(connection), Either::Left(stop_future)) => {
                                connection.self_presence(stop_future).await
                            }
                            (connected, stopped) => (connected, stopped),
                        };
                            let stop_future2 = stop_future.clone();
                            let stop_future3 = stop_future.clone();
                            let stop_future4 = stop_future.clone();
            loop {
                let pin_stop_future = stop_future.clone();
                tokio::pin!(pin_stop_future);
                let connect = futures_util::future::select(
                    pin_stop_future,
                    Box::pin(async {
                        info!("xmpp initialization...");
                        let mut client = AsyncClient::new_with_jid(
                            account.jid.clone(),
                            account.password.clone(),
                        );
                        client.set_reconnect(false);
                        let stop_future = stop_future.clone();
                        let (connected, stopped) = XmppConnection {
                            state: XmppState {
                                client,
                                data: std::default::Default::default(),
                            },
                            account: account.clone(),
                        }
                        .processing(XmppConnection::online, Box::pin(stop_future), true)
                        .await;
                        let (connected, stopped) = match (connected, stopped) {
                            (Ok(connection), Either::Left(stop_future)) => {
                                connection.initial_roster(stop_future).await
                            }
                            (connected, stopped) => (connected, stopped),
                        };
            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");
            Ok(XmppConnection { account, state })
            Box::new(future::ok(XmppConnection { account, state }))
                as Box<dyn Future<Item = _, Error = _>>
        info!("xmpp check connection...");
        info!("xmpp connection...");
        F: std::future::Future<Output = ()> + Clone + 'static,
        F: future::Future + Clone + 'static,
        <F as hyper::rt::Future>::Error: Into<failure::Error> + Send,
    pub async fn connect<F>(self, stop_future: F) -> Result<XmppConnection, failure::Error>
    pub fn connect<F>(
        self,
        stop_future: F,
    ) -> impl Future<Item = XmppConnection, Error = failure::Error>
        incoming.register(&XmppConnection::incoming_presence_processing);
        incoming.register(&XmppConnection::incoming_message_processing);
        incoming
    };
    static ref INCOMING_IQ_SET: element_processor::Processor<XmppConnection, Box<dyn IqRequestHandler>, xmpp_parsers::Element> = {
        let mut iq_set =
            element_processor::Processor::new(&|_conn: &mut XmppConnection, element| {
                Box::new(IqRequestUnknown {
                    element,
                    type_: "set",
                }) as Box<dyn IqRequestHandler>
            });
        iq_set.register(&XmppConnection::incoming_iq_processing_set_roster);
        iq_set
    };
    static ref INCOMING_IQ_GET: element_processor::Processor<XmppConnection, Box<dyn IqRequestHandler>, xmpp_parsers::Element> = {
        let mut iq_get =
            element_processor::Processor::new(&|_conn: &mut XmppConnection, element| {
                Box::new(IqRequestUnknown {
                    element,
                    type_: "get",
                }) as Box<dyn IqRequestHandler>
            });
        iq_get.register(&XmppConnection::incoming_iq_processing_get_ping);
        iq_get.register(&XmppConnection::incoming_iq_processing_get_disco_info);
        iq_get.register(&XmppConnection::incoming_iq_processing_get_disco_items);
        iq_get.register(&XmppConnection::incoming_iq_processing_get_version);
        iq_get
    };
        XmppElementProcessor { incoming }
    }
lazy_static::lazy_static! {
    static ref INCOMING: element_processor::Processor<XmppConnection, bool, xmpp_parsers::Element> = {
impl XmppElementProcessor {
    fn new() -> XmppElementProcessor {
trait IqRequestHandler {
    fn process(
        self: Box<Self>,
        conn: &mut XmppConnection,
        id: String,
        from: Option<xmpp_parsers::Jid>,
    ) -> xmpp_parsers::iq::Iq;
}
struct IqRequestUnknown {
    element: xmpp_parsers::Element,
    type_: &'static str,
}
impl IqRequestHandler for IqRequestUnknown {
    fn process(
        self: Box<Self>,
        conn: &mut XmppConnection,
        id: String,
        from: Option<xmpp_parsers::Jid>,
    ) -> xmpp_parsers::iq::Iq {
        warn!(
            "Unsupported IQ {} request from {:?}: {}",
            self.type_,
            from,
            String::from(&self.element)
        );
        stanzas::make_iq_unsupported_error(id, conn.account.jid.clone(), from)
    }
}
struct IqSetRoster {}
impl IqRequestHandler for IqSetRoster {
    fn process(
        self: Box<Self>,
        conn: &mut XmppConnection,
        id: String,
        from: Option<xmpp_parsers::Jid>,
    ) -> xmpp_parsers::iq::Iq {
        info!("Got roster push {} from {:?}", id, from);
        stanzas::make_roster_push_answer(id, conn.account.jid.clone(), from)
    }
}
struct IqGetPing {}
impl IqRequestHandler for IqGetPing {
    fn process(
        self: Box<Self>,
        conn: &mut XmppConnection,
        id: String,
        from: Option<xmpp_parsers::Jid>,
    ) -> xmpp_parsers::iq::Iq {
        info!("Got ping {} from {:?}", id, from);
        stanzas::make_pong(id, conn.account.jid.clone(), from)
    }
}
struct IqGetVersion {}
impl IqRequestHandler for IqGetVersion {
    fn process(
        self: Box<Self>,
        conn: &mut XmppConnection,
        id: String,
        from: Option<xmpp_parsers::Jid>,
    ) -> xmpp_parsers::iq::Iq {
        info!("Got version query {} from {:?}", id, from);
        stanzas::make_version(id, conn.account.jid.clone(), from)
    }
}
struct IqGetDiscoInfo {}
impl IqRequestHandler for IqGetDiscoInfo {
    fn process(
        self: Box<Self>,
        conn: &mut XmppConnection,
        id: String,
        from: Option<xmpp_parsers::Jid>,
    ) -> xmpp_parsers::iq::Iq {
        info!("Got disco query {} from {:?}", id, from);
        stanzas::make_disco_info_result(id, conn.account.jid.clone(), from)
    }
}
struct IqGetDiscoItems {}
impl IqRequestHandler for IqGetDiscoItems {
    fn process(
        self: Box<Self>,
        conn: &mut XmppConnection,
        id: String,
        from: Option<xmpp_parsers::Jid>,
    ) -> xmpp_parsers::iq::Iq {
        info!("Got disco items query {} from {:?}", id, from);
        stanzas::make_disco_items_result(id, conn.account.jid.clone(), from)
    }
}
struct IqGetDiscoCommands {}
impl IqRequestHandler for IqGetDiscoCommands {
    fn process(
        self: Box<Self>,
        conn: &mut XmppConnection,
        id: String,
        from: Option<xmpp_parsers::Jid>,
    ) -> xmpp_parsers::iq::Iq {
        info!("Got disco commands query {} from {:?}", id, from);
        stanzas::make_disco_items_commands(id, conn.account.jid.clone(), from)
    }
struct XmppElementProcessor {
    incoming: element_processor::Processor<XmppConnection, bool, xmpp_parsers::Element>,
    client: AsyncClient,
    client: Client,
    pending_ids: HashMap<String, IqWait>,
    pending_ids: HashMap<String, (Instant, Box<dyn IqHandler>)>,
    /// ToDo: remove it as it is used only for initialization
    /// ToDo: remove it as it used only for initialization
        xmpp_parsers::BareJid,
        xmpp_parsers::Jid,
        info!("ping successed");
        true
        true // ignore
                conn.process_jid(&self.jid);
    jid: xmpp_parsers::BareJid,
    jid: xmpp_parsers::Jid,
    Chatroom { muc_id: String, message: String },
    /// Send ping request to the server to test connection
    Chatroom {
        muc_id: String,
        message: String,
    },
    // Send ping request to the server to test connection
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;
/// trait of processing iq
/// each function consumes handlers and
/// returns false if connection should be reset
trait IqHandler {
    /// process result
    fn result(
        self: Box<Self>,
        conn: &mut XmppConnection,
        opt_element: Option<xmpp_parsers::Element>,
    ) -> bool;
    /// process error
    fn error(
        self: Box<Self>,
        conn: &mut XmppConnection,
        error: xmpp_parsers::stanza_error::StanzaError,
    ) -> bool;
    /// process tmeout
    fn timeout(self: Box<Self>, conn: &mut XmppConnection) -> bool;
}
struct AddRosterIqHandler {
    jid: xmpp_parsers::Jid,
}
impl IqHandler for AddRosterIqHandler {
    fn result(
        self: Box<Self>,
        conn: &mut XmppConnection,
        opt_element: Option<xmpp_parsers::Element>,
    ) -> bool {
        match opt_element {
            Some(element) => {
                warn!(
                    "Wrong payload when adding {} to roster: {}",
                    self.jid,
                    String::from(&element)
                );
            }
            None => {
                if conn.state.data.roster.contains_key(&self.jid) {
                    info!("Jid {} updated to roster", self.jid);
                } else {
                    info!("Jid {} added in roster", self.jid);
                    conn.state.data.roster.insert(
                        self.jid.clone(),
                        (
                            xmpp_parsers::roster::Subscription::None,
                            xmpp_parsers::roster::Ask::None,
                        ),
                    );
                }
                conn.process_jid(&self.jid);
            }
        }
        true
    }
    fn error(
        self: Box<Self>,
        _conn: &mut XmppConnection,
        _error: xmpp_parsers::stanza_error::StanzaError,
    ) -> bool {
        true
    }
    fn timeout(self: Box<Self>, _conn: &mut XmppConnection) -> bool {
        true // ignore
    }
}
struct InitRosterIqHandler {}
impl IqHandler for InitRosterIqHandler {
    fn result(
        self: Box<Self>,
        conn: &mut XmppConnection,
        opt_element: Option<xmpp_parsers::Element>,
    ) -> bool {
        if let Some(result) = opt_element {
            use std::convert::TryInto;
            match result.try_into() as Result<xmpp_parsers::roster::Roster, _> {
                Ok(roster) => {
                    conn.state.data.roster_init = true;
                    conn.state.data.roster.clear();
                    info!("Got first roster:");
                    for i in roster.items {
                        info!(" >>> {:?}", i);
                        conn.state
                            .data
                            .roster
                            .insert(i.jid, (i.subscription, i.ask));
                    }
                    true
                }
                Err(e) => {
                    error!("Cann't parse roster: {}", e);
                    false
                }
            }
        } else {
            error!("No roster responded");
            false
        }
    }
    fn error(
        self: Box<Self>,
        _conn: &mut XmppConnection,
        _error: xmpp_parsers::stanza_error::StanzaError,
    ) -> bool {
        false
    }
    fn timeout(self: Box<Self>, _conn: &mut XmppConnection) -> bool {
        false
    }
}
#[derive(Default)]
struct XmppData {
    /// known roster data
    roster: HashMap<
        xmpp_parsers::Jid,
        (
            xmpp_parsers::roster::Subscription,
            xmpp_parsers::roster::Ask,
        ),
    >,
    /// if roster was initialized
    /// ToDo: remove it as it used only for initialization
    roster_init: bool,
    /// ids counter
    counter: usize,
    /// 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>,
    /// map from iq's id to handler of this type of iqs
    pending_ids: HashMap<String, Box<dyn IqHandler>>,
}
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 {}", String::from(&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
            }
        }
    }
    /// Enforce to answer to IQ "set"
    fn incoming_iq_processing_set(
        &mut self,
        id: String,
        from: Option<xmpp_parsers::Jid>,
        element: minidom::Element,
    ) -> xmpp_parsers::iq::Iq {
        use std::convert::TryInto;
        if let Some(roster) =
            element.clone().try_into().ok() as Option<xmpp_parsers::roster::Roster>
        {
            // RFC 6212 2.1.6. Roster Push
            for i in roster.items {
                if let Some(ref mut rdata) = self.state.data.roster.get_mut(&i.jid) {
                    info!("Update {} in roster", i.jid);
                    rdata.0 = i.subscription;
                    rdata.1 = i.ask;
                } else {
                    info!("Add {} to roster", i.jid);
                    self.state
                        .data
                        .roster
                        .insert(i.jid.clone(), (i.subscription, i.ask));
                }
                self.process_jid(&i.jid);
            }
            return stanzas::make_roster_push_answer(id, self.state.client.jid.clone(), from);
        }
        warn!(
            "Unsupported IQ set request from {:?}: {}",
            from,
            String::from(&element)
        );
        stanzas::make_iq_unsupported_error(id, self.state.client.jid.clone(), from)
    }
    /// Enforce to answer to IQ "get"
    fn incoming_iq_processing_get(
        &mut self,
        id: String,
        from: Option<xmpp_parsers::Jid>,
        element: minidom::Element,
    ) -> xmpp_parsers::iq::Iq {
        use std::convert::TryInto;
        if let Some(_ping) = element.clone().try_into().ok() as Option<xmpp_parsers::ping::Ping> {
            return stanzas::make_pong(&id, self.state.client.jid.clone(), from);
        }
        warn!(
            "Unsupported IQ get request from {:?}: {}",
            from,
            String::from(&element)
        );
        stanzas::make_iq_unsupported_error(id, self.state.client.jid.clone(), from)
    }
    fn incoming_iq_processing(&mut self, iq: xmpp_parsers::iq::Iq) -> bool {
        match iq.payload {
            xmpp_parsers::iq::IqType::Set(element) => {
                let iq_answer = self.incoming_iq_processing_set(iq.id, iq.from, element);
                self.state.data.send_queue.push_back(iq_answer.into());
            }
            xmpp_parsers::iq::IqType::Error(e) => {
                if let Some((_, handler)) = self.state.data.pending_ids.remove_entry(&iq.id) {
                    return handler.error(self, e);
                }
                error!("iq error: {:?}", e);
                return false;
            }
            xmpp_parsers::iq::IqType::Get(element) => {
                let iq_answer = self.incoming_iq_processing_get(iq.id, iq.from, element);
                self.state.data.send_queue.push_back(iq_answer.into());
            }
            xmpp_parsers::iq::IqType::Result(opt_element) => {
                if let Some((_, handler)) = self.state.data.pending_ids.remove_entry(&iq.id) {
                    return handler.result(self, opt_element);
                }
                warn!(
                    "Unwanted iq result id {} from {:?}: {:?}",
                    iq.id,
                    iq.from,
                    opt_element.map(|e| String::from(&e))
                );
            }
        }
        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 {}", String::from(&send_element));
                    Box::new(
                        client
                            .send(Packet::Stanza(send_element))
                            .select2(stop_future)
                            .then(move |r| match r {
                                Ok(Either::A((client, b))) => {
                                    Box::new(future::ok(future::Loop::Continue((
                                        XmppConnection {
                                            state: XmppState { client, data },
                                            account,
                                        },
                                        b,
                                        stop_condition,
                                    ))))
                                        as Box<dyn Future<Item = _, Error = _>>
                                }
                                Ok(Either::B((t, a))) => Box::new(a.then(|r| match r {
                                    Ok(client) => future::ok(future::Loop::Break((
                                        XmppConnection {
                                            state: XmppState { client, data },
                                            account,
                                        },
                                        Ok(Either::B(t)),
                                    ))),
                                    Err(se) => {
                                        warn!("XMPP sending error: {}", se);
                                        future::err((account, Ok(Either::B(t))))
                                    }
                                })),
                                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: {}", String::from(&s));
                Ok(false)
            }
            _ => {
                error!("Disconnected while online");
                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... {}", String::from(&get_roster));
        data.pending_ids
            .insert(id_init_roster.clone(), Box::new(InitRosterIqHandler {}));
        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, _| Ok(conn.state.data.roster_init), stop_future)
                .map_err(|(account, _)| account)
                .and_then(|(conn, r)| match r {
                    Ok(Either::A(_)) => future::ok(conn),
                    Ok(Either::B(_)) => future::err(conn.account),
                    Err(_e) => future::err(conn.account),
                })
            })
    }
    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... {}", String::from(&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());
                    info!("Adding jid {} to roster id {}", xmpp_to, id_add_roster);
                    self.state.data.pending_ids.insert(
                        id_add_roster,
                        Box::new(AddRosterIqHandler {
                            jid: xmpp_to.clone(),
                        }),
                    );
                    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... {}",
                String::from(&muc_presence)
            );
            use tokio::prelude::Sink;
            client
                .send(Packet::Stanza(muc_presence))
                .map_err(|e| {
                    error!("Error on send muc presence: {}", e);
                    e
                })
                .and_then(|client| future::ok(XmppState { client, data }))
        })
        .map(|_| ())
    }
    fn enter_mucs<F, E>(
        self,
        _stop_future: F,
    ) -> impl Future<Item = Self, Error = std::rc::Rc<config::Account>>
    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... {}", String::from(&muc_presence));
                let account4 = account2.clone();
                use tokio::prelude::Sink;
                client
                    .send(Packet::Stanza(muc_presence))
                    .map_err(|e| {
                        error!("Error on send muc presence: {}", e);
                        account4
                    })
                    .and_then(|client| {
                        data.mucs.insert(muc_jid.0, muc_jid.1);
                        future::ok(XmppState { client, data })
                    })
            })
            .map(|state| XmppConnection {
                account: account3,
                state,
            })
    }
}
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 std::time::{Duration, Instant};
use super::stanzas;
use super::element_processor;
use crate::config;
#[derive(Debug)]
pub enum XmppCommand {
    /// Send message to someone by jid
    Chat {
        xmpp_to: xmpp_parsers::Jid,
        message: String,
    },
    /// Send message to MUC
    Chatroom { muc_id: String, message: String },
    /// Send ping request to the server to test connection
    Ping,
    /// Check iq requests if some have expired timeouts
    TimeoutCleanup,
}
/// trait of processing iq
/// each function consumes handlers and
/// returns false if connection should be reset
trait IqHandler {
    /// process result
    fn result(
        self: Box<Self>,
        conn: &mut XmppConnection,
        opt_element: Option<xmpp_parsers::Element>,
    ) -> bool;
    /// process error
    fn error(
        self: Box<Self>,
        conn: &mut XmppConnection,
        error: xmpp_parsers::stanza_error::StanzaError,
    ) -> bool;
    /// process tmeout
    fn timeout(self: Box<Self>, conn: &mut XmppConnection) -> bool;
}
struct AddRosterIqHandler {
    jid: xmpp_parsers::Jid,
}
impl IqHandler for AddRosterIqHandler {
    fn result(
        self: Box<Self>,
        conn: &mut XmppConnection,
        opt_element: Option<xmpp_parsers::Element>,
    ) -> bool {
        match opt_element {
            Some(element) => {
                warn!(
                    "Wrong payload when adding {} to roster: {}",
                    self.jid,
                    String::from(&element)
                );
            }
            None => {
                if conn.state.data.roster.contains_key(&self.jid) {
                    info!("Jid {} updated to roster", self.jid);
                } else {
                    info!("Jid {} added in roster", self.jid);
                    conn.state.data.roster.insert(
                        self.jid.clone(),
                        (
                            xmpp_parsers::roster::Subscription::None,
                            xmpp_parsers::roster::Ask::None,
                        ),
                    );
                }
                conn.process_jid(&self.jid);
            }
        }
        true
    }
    fn error(
        self: Box<Self>,
        _conn: &mut XmppConnection,
        _error: xmpp_parsers::stanza_error::StanzaError,
    ) -> bool {
        true
    }
    fn timeout(self: Box<Self>, _conn: &mut XmppConnection) -> bool {
        true // ignore
    }
}
struct PingIqHandler {}
impl IqHandler for PingIqHandler {
    fn result(
        self: Box<Self>,
        _conn: &mut XmppConnection,
        _opt_element: Option<xmpp_parsers::Element>,
    ) -> bool {
        info!("ping successed");
        true
    }
    fn error(
        self: Box<Self>,
        _conn: &mut XmppConnection,
        _error: xmpp_parsers::stanza_error::StanzaError,
    ) -> bool {
        false
    }
    fn timeout(self: Box<Self>, _conn: &mut XmppConnection) -> bool {
        false
    }
}
struct InitRosterIqHandler {}
impl IqHandler for InitRosterIqHandler {
    fn result(
        self: Box<Self>,
        conn: &mut XmppConnection,
        opt_element: Option<xmpp_parsers::Element>,
    ) -> bool {
        if let Some(result) = opt_element {
            use std::convert::TryInto;
            match result.try_into() as Result<xmpp_parsers::roster::Roster, _> {
                Ok(roster) => {
                    conn.state.data.roster_init = true;
                    conn.state.data.roster.clear();
                    info!("Got first roster:");
                    for i in roster.items {
                        info!(" >>> {:?}", i);
                        conn.state
                            .data
                            .roster
                            .insert(i.jid, (i.subscription, i.ask));
                    }
                    true
                }
                Err(e) => {
                    error!("Cann't parse roster: {}", e);
                    false
                }
            }
        } else {
            error!("No roster responded");
            false
        }
    }
    fn error(
        self: Box<Self>,
        _conn: &mut XmppConnection,
        _error: xmpp_parsers::stanza_error::StanzaError,
    ) -> bool {
        false
    }
    fn timeout(self: Box<Self>, _conn: &mut XmppConnection) -> bool {
        false
    }
}
#[derive(Default)]
struct XmppData {
    /// known roster data
    roster: HashMap<
        xmpp_parsers::Jid,
        (
            xmpp_parsers::roster::Subscription,
            xmpp_parsers::roster::Ask,
        ),
    >,
    /// if roster was initialized
    /// ToDo: remove it as it is used only for initialization
    roster_init: bool,
    /// if self-presence accepted
    /// ToDo: remove it as it is used only for initialization
    self_presence: bool,
    /// ids counter
    counter: usize,
    /// 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>,
    /// map from iq's id to handler of this type of iqs
    pending_ids: HashMap<String, (Instant, Box<dyn IqHandler>)>,
}
struct XmppState {
    client: Client,
    data: XmppData,
}
pub struct XmppConnection {
    account: std::rc::Rc<config::Account>,
    state: XmppState,
}
lazy_static! {
    static ref INCOMING: element_processor::Processor<XmppConnection, bool, xmpp_parsers::Element> = {
        let mut incoming = element_processor::Processor::new(&|_, e| {
            warn!("Unknown stanza {}", String::from(&e));
            true
        });
        incoming.register(&XmppConnection::incoming_iq_processing);
        incoming.register(&XmppConnection::incoming_presence_processing);
        incoming.register(&XmppConnection::incoming_message_processing);
        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) => INCOMING.process(self, stanza.clone()),
            Event::Online => true,
            e => {
                warn!("Unexpected event {:?}", e);
                false
            }
        }
    }
    /// Enforce to answer to IQ "set"
    fn incoming_iq_processing_set(
        &mut self,
        id: String,
        from: Option<xmpp_parsers::Jid>,
        element: minidom::Element,
    ) -> xmpp_parsers::iq::Iq {
        use std::convert::TryInto;
        if let Some(roster) =
            element.clone().try_into().ok() as Option<xmpp_parsers::roster::Roster>
        {
            // RFC 6212 2.1.6. Roster Push
            info!("Got roster push {} from {:?}", id, from);
            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);
            }
            return stanzas::make_roster_push_answer(id, self.state.client.jid.clone(), from);
        }
        warn!(
            "Unsupported IQ set request from {:?}: {}",
            from,
            String::from(&element)
        );
        stanzas::make_iq_unsupported_error(id, self.state.client.jid.clone(), from)
    }
    /// Enforce to answer to IQ "get"
    fn incoming_iq_processing_get(
        &mut self,
        id: String,
        from: Option<xmpp_parsers::Jid>,
        element: minidom::Element,
    ) -> xmpp_parsers::iq::Iq {
        use std::convert::TryInto;
        if let Some(_ping) = element.clone().try_into().ok() as Option<xmpp_parsers::ping::Ping> {
            info!("Got ping {} from {:?}", id, from);
            return stanzas::make_pong(&id, self.state.client.jid.clone(), from);
        }
        warn!(
            "Unsupported IQ get request from {:?}: {}",
            from,
            String::from(&element)
        );
        stanzas::make_iq_unsupported_error(id, self.state.client.jid.clone(), from)
    }
    fn incoming_iq_processing(&mut self, iq: xmpp_parsers::iq::Iq) -> bool {
        match iq.payload {
            xmpp_parsers::iq::IqType::Set(element) => {
                let iq_answer = self.incoming_iq_processing_set(iq.id, iq.from, element);
                self.state.data.send_queue.push_back(iq_answer.into());
            }
            xmpp_parsers::iq::IqType::Error(e) => {
                if let Some((_, handler)) = self.state.data.pending_ids.remove_entry(&iq.id) {
                    return handler.1.error(self, e);
                }
                error!("iq error: {:?}", e);
                return false;
            }
            xmpp_parsers::iq::IqType::Get(element) => {
                let iq_answer = self.incoming_iq_processing_get(iq.id, iq.from, element);
                self.state.data.send_queue.push_back(iq_answer.into());
            }
            xmpp_parsers::iq::IqType::Result(opt_element) => {
                if let Some((_, handler)) = self.state.data.pending_ids.remove_entry(&iq.id) {
                    return handler.1.result(self, opt_element);
                }
                warn!(
                    "Unwanted iq result id {} from {:?}: {:?}",
                    iq.id,
                    iq.from,
                    opt_element.map(|e| String::from(&e))
                );
            }
        }
        true
    }
    fn incoming_presence_processing(&mut self, presence: xmpp_parsers::presence::Presence) -> bool {
        if presence.from.as_ref() == Some(&self.state.client.jid) {
            info!("Self-presence accepted");
            self.state.data.self_presence = true;
        } else {
            warn!("Incoming presence stanza: {:?}", presence);
        }
        true
    }
    fn incoming_message_processing(&mut self, message: xmpp_parsers::message::Message) -> bool {
        for payload in message.payloads.iter() {
            use std::convert::TryInto;
            if let Some(_delay) =
                payload.clone().try_into().ok() as Option<xmpp_parsers::delay::Delay>
            {
                return true; // ignore delayed messages
            }
        }
        warn!("Incoming message stanza: {:?}", message);
        true
    }
    /// 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)| {
                // ToDo: check timeouts if iqs
                let XmppConnection {
                    state: XmppState { client, mut data },
                    account,
                } = xmpp;
                if let Some(send_element) = data.send_queue.pop_front() {
                    use tokio::prelude::Sink;
                    info!("Sending {}", String::from(&send_element));
                    Box::new(
                        client
                            .send(Packet::Stanza(send_element))
                            .select2(stop_future)
                            .then(move |r| match r {
                                Ok(Either::A((client, b))) => {
                                    Box::new(future::ok(future::Loop::Continue((
                                        XmppConnection {
                                            state: XmppState { client, data },
                                            account,
                                        },
                                        b,
                                        stop_condition,
                                    ))))
                                        as Box<dyn Future<Item = _, Error = _>>
                                }
                                Ok(Either::B((t, a))) => Box::new(a.then(|r| match r {
                                    Ok(client) => future::ok(future::Loop::Break((
                                        XmppConnection {
                                            state: XmppState { client, data },
                                            account,
                                        },
                                        Ok(Either::B(t)),
                                    ))),
                                    Err(se) => {
                                        warn!("XMPP sending error: {}", se);
                                        future::err((account, Ok(Either::B(t))))
                                    }
                                })),
                                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: {}", String::from(&s));
                Ok(false)
            }
            _ => {
                error!("Disconnected while online");
                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... {}", String::from(&get_roster));
        data.pending_ids.insert(
            id_init_roster.clone(),
            (
                Instant::now() + Duration::from_secs(60),
                Box::new(InitRosterIqHandler {}),
            ),
        );
        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, _| Ok(conn.state.data.roster_init), stop_future)
                .map_err(|(account, _)| account)
                .and_then(|(conn, r)| match r {
                    Ok(Either::A(_)) => future::ok(conn),
                    Ok(Either::B(_)) => future::err(conn.account),
                    Err(_e) => future::err(conn.account),
                })
            })
    }
    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... {}", String::from(&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, _| Ok(conn.state.data.self_presence),
                    stop_future,
                )
                .map_err(|(account, _)| account)
                .and_then(|(conn, r)| match r {
                    Ok(Either::A(_)) => future::ok(conn),
                    Ok(Either::B(_)) => future::err(conn.account),
                    Err(_e) => future::err(conn.account),
                })
            })
    }
    fn process_jid(&mut self, xmpp_to: &xmpp_parsers::Jid) {
        if let Some(ref mut mailbox) = self.state.data.outgoing_mailbox.get_mut(xmpp_to) {
            if !mailbox.is_empty() {
                if let Some(ref mut rdata) = self.state.data.roster.get_mut(xmpp_to) {
                    info!("Jid {} in roster", xmpp_to);
                    let sub_to = match rdata.0 {
                        xmpp_parsers::roster::Subscription::To => true,
                        xmpp_parsers::roster::Subscription::Both => true,
                        _ => false,
                    };
                    if sub_to {
                        info!("Subscribed to {}", xmpp_to);
                        self.state.data.send_queue.extend(
                            mailbox.drain(..).map(|message| {
                                stanzas::make_chat_message(xmpp_to.clone(), message)
                            }),
                        );
                    } else if rdata.1 == xmpp_parsers::roster::Ask::None {
                        info!("Not subscribed to {}", xmpp_to);
                        self.state
                            .data
                            .send_queue
                            .push_back(stanzas::make_ask_subscribe(xmpp_to.clone()));
                    }
                    let sub_from = match rdata.0 {
                        xmpp_parsers::roster::Subscription::From => true,
                        xmpp_parsers::roster::Subscription::Both => true,
                        _ => false,
                    };
                    if !sub_from {
                        info!("Not subscription from {}", xmpp_to);
                        self.state
                            .data
                            .send_queue
                            .push_back(stanzas::make_allow_subscribe(xmpp_to.clone()));
                    }
                } else {
                    info!("Jid {} not in roster", xmpp_to);
                    self.state.data.counter += 1;
                    let id_add_roster = format!("id_add_roster{}", self.state.data.counter);
                    let add_roster = stanzas::make_add_roster(&id_add_roster, xmpp_to.clone());
                    info!("Adding jid {} to roster id {}", xmpp_to, id_add_roster);
                    self.state.data.pending_ids.insert(
                        id_add_roster,
                        (
                            Instant::now() + Duration::from_secs(60),
                            Box::new(AddRosterIqHandler {
                                jid: xmpp_to.clone(),
                            }),
                        ),
                    );
                    self.state.data.send_queue.push_back(add_roster);
                }
            }
        }
    }
    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);
                self.state.data.pending_ids.insert(
                    id_ping,
                    (
                        Instant::now() + Duration::from_secs(30),
                        Box::new(PingIqHandler {}),
                    ),
                );
            }
            XmppCommand::TimeoutCleanup => {
                let now = Instant::now();
                let timeouted: Vec<String> = self
                    .state
                    .data
                    .pending_ids
                    .iter()
                    .filter_map(|(id, (timeout, _))| {
                        if now >= *timeout {
                            Some(id.to_string())
                        } else {
                            None
                        }
                    })
                    .collect();
                let mut correct = true;
                timeouted.into_iter().for_each(|id| {
                    if let Some((_, handler)) = self.state.data.pending_ids.remove(&id) {
                        correct &= handler.timeout(&mut self);
                    }
                })
            }
        }
    }
    pub fn shutdown(self) -> impl Future<Item = (), Error = failure::Error> {
        info!("Shutdown connection");
        let XmppConnection { account, state } = self;
        stream::iter_ok(
            state
                .data
                .mucs
                .values()
                .map(std::clone::Clone::clone)
                .collect::<Vec<_>>(),
        )
        .fold(state, move |XmppState { client, data }, muc_jid| {
            let muc_presence =
                stanzas::make_muc_presence_leave(account.jid.clone(), muc_jid.clone());
            info!(
                "Sending muc leave presence... {}",
                String::from(&muc_presence)
            );
            use tokio::prelude::Sink;
            client
                .send(Packet::Stanza(muc_presence))
                .map_err(|e| {
                    error!("Error on send muc presence: {}", e);
                    e
                })
                .and_then(|client| future::ok(XmppState { client, data }))
        })
        .map(|_| ())
    }
    fn enter_mucs<F, E>(
        self,
        _stop_future: F,
    ) -> impl Future<Item = Self, Error = std::rc::Rc<config::Account>>
    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... {}", String::from(&muc_presence));
                let account4 = account2.clone();
                use tokio::prelude::Sink;
                client
                    .send(Packet::Stanza(muc_presence))
                    .map_err(|e| {
                        error!("Error on send muc presence: {}", e);
                        account4
                    })
                    .and_then(|client| {
                        data.mucs.insert(muc_jid.0, muc_jid.1);
                        future::ok(XmppState { client, data })
                    })
            })
            .map(|state| XmppConnection {
                account: account3,
                state,
            })
    }
}
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 std::time::{Duration, Instant};
use super::stanzas;
use super::element_processor;
use crate::config;
#[derive(Debug)]
pub enum XmppCommand {
    /// Send message to someone by jid
    Chat {
        xmpp_to: xmpp_parsers::Jid,
        message: String,
    },
    /// Send message to MUC
    Chatroom { muc_id: String, message: String },
    /// Send ping request to the server to test connection
    Ping,
    /// Check iq requests if some have expired timeouts
    TimeoutCleanup,
}
/// trait of processing iq
/// each function consumes handlers and
/// returns false if connection should be reset
trait IqHandler {
    /// process result
    fn result(
        self: Box<Self>,
        conn: &mut XmppConnection,
        opt_element: Option<xmpp_parsers::Element>,
    ) -> bool;
    /// process error
    fn error(
        self: Box<Self>,
        conn: &mut XmppConnection,
        error: xmpp_parsers::stanza_error::StanzaError,
    ) -> bool;
    /// process tmeout
    fn timeout(self: Box<Self>, conn: &mut XmppConnection) -> bool;
}
struct AddRosterIqHandler {
    jid: xmpp_parsers::Jid,
}
impl IqHandler for AddRosterIqHandler {
    fn result(
        self: Box<Self>,
        conn: &mut XmppConnection,
        opt_element: Option<xmpp_parsers::Element>,
    ) -> bool {
        match opt_element {
            Some(element) => {
                warn!(
                    "Wrong payload when adding {} to roster: {}",
                    self.jid,
                    String::from(&element)
                );
            }
            None => {
                if conn.state.data.roster.contains_key(&self.jid) {
                    info!("Jid {} updated to roster", self.jid);
                } else {
                    info!("Jid {} added in roster", self.jid);
                    conn.state.data.roster.insert(
                        self.jid.clone(),
                        (
                            xmpp_parsers::roster::Subscription::None,
                            xmpp_parsers::roster::Ask::None,
                        ),
                    );
                }
                conn.process_jid(&self.jid);
            }
        }
        true
    }
    fn error(
        self: Box<Self>,
        _conn: &mut XmppConnection,
        _error: xmpp_parsers::stanza_error::StanzaError,
    ) -> bool {
        true
    }
    fn timeout(self: Box<Self>, _conn: &mut XmppConnection) -> bool {
        true // ignore
    }
}
struct PingIqHandler {}
impl IqHandler for PingIqHandler {
    fn result(
        self: Box<Self>,
        _conn: &mut XmppConnection,
        _opt_element: Option<xmpp_parsers::Element>,
    ) -> bool {
        info!("ping successed");
        true
    }
    fn error(
        self: Box<Self>,
        _conn: &mut XmppConnection,
        _error: xmpp_parsers::stanza_error::StanzaError,
    ) -> bool {
        false
    }
    fn timeout(self: Box<Self>, _conn: &mut XmppConnection) -> bool {
        false
    }
}
struct InitRosterIqHandler {}
impl IqHandler for InitRosterIqHandler {
    fn result(
        self: Box<Self>,
        conn: &mut XmppConnection,
        opt_element: Option<xmpp_parsers::Element>,
    ) -> bool {
        if let Some(result) = opt_element {
            use std::convert::TryInto;
            match result.try_into() as Result<xmpp_parsers::roster::Roster, _> {
                Ok(roster) => {
                    conn.state.data.roster_init = true;
                    conn.state.data.roster.clear();
                    info!("Got first roster:");
                    for i in roster.items {
                        info!(" >>> {:?}", i);
                        conn.state
                            .data
                            .roster
                            .insert(i.jid, (i.subscription, i.ask));
                    }
                    true
                }
                Err(e) => {
                    error!("Cann't parse roster: {}", e);
                    false
                }
            }
        } else {
            error!("No roster responded");
            false
        }
    }
    fn error(
        self: Box<Self>,
        _conn: &mut XmppConnection,
        _error: xmpp_parsers::stanza_error::StanzaError,
    ) -> bool {
        false
    }
    fn timeout(self: Box<Self>, _conn: &mut XmppConnection) -> bool {
        false
    }
}
#[derive(Default)]
struct XmppData {
    /// known roster data
    roster: HashMap<
        xmpp_parsers::Jid,
        (
            xmpp_parsers::roster::Subscription,
            xmpp_parsers::roster::Ask,
        ),
    >,
    /// if roster was initialized
    /// ToDo: remove it as it is used only for initialization
    roster_init: bool,
    /// if self-presence accepted
    /// ToDo: remove it as it is used only for initialization
    self_presence: bool,
    /// ids counter
    counter: usize,
    /// 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>,
    /// map from iq's id to handler of this type of iqs
    pending_ids: HashMap<String, (Instant, Box<dyn IqHandler>)>,
}
struct XmppState {
    client: Client,
    data: XmppData,
}
pub struct XmppConnection {
    account: std::rc::Rc<config::Account>,
    state: XmppState,
}
lazy_static! {
    static ref INCOMING: element_processor::Processor<XmppConnection, bool, xmpp_parsers::Element> = {
        let mut incoming = element_processor::Processor::new(&|_, e| {
            warn!("Unknown stanza {}", String::from(&e));
            true
        });
        incoming.register(&XmppConnection::incoming_iq_processing);
        incoming.register(&XmppConnection::incoming_presence_processing);
        incoming.register(&XmppConnection::incoming_message_processing);
        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) => INCOMING.process(self, stanza.clone()),
            Event::Online => true,
            e => {
                warn!("Unexpected event {:?}", e);
                false
            }
        }
    }
    /// Enforce to answer to IQ "set"
    fn incoming_iq_processing_set(
        &mut self,
        id: String,
        from: Option<xmpp_parsers::Jid>,
        element: minidom::Element,
    ) -> xmpp_parsers::iq::Iq {
        use std::convert::TryInto;
        if let Some(roster) =
            element.clone().try_into().ok() as Option<xmpp_parsers::roster::Roster>
        {
            // RFC 6212 2.1.6. Roster Push
            info!("Got roster push {} from {:?}", id, from);
            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);
            }
            return stanzas::make_roster_push_answer(id, self.state.client.jid.clone(), from);
        }
        warn!(
            "Unsupported IQ set request from {:?}: {}",
            from,
            String::from(&element)
        );
        stanzas::make_iq_unsupported_error(id, self.state.client.jid.clone(), from)
    }
    /// Enforce to answer to IQ "get"
    fn incoming_iq_processing_get(
        &mut self,
        id: String,
        from: Option<xmpp_parsers::Jid>,
        element: minidom::Element,
    ) -> xmpp_parsers::iq::Iq {
        use std::convert::TryInto;
        if let Some(_ping) = element.clone().try_into().ok() as Option<xmpp_parsers::ping::Ping> {
            info!("Got ping {} from {:?}", id, from);
            return stanzas::make_pong(&id, self.state.client.jid.clone(), from);
        }
        warn!(
            "Unsupported IQ get request from {:?}: {}",
            from,
            String::from(&element)
        );
        stanzas::make_iq_unsupported_error(id, self.state.client.jid.clone(), from)
    }
    fn incoming_iq_processing(&mut self, iq: xmpp_parsers::iq::Iq) -> bool {
        match iq.payload {
            xmpp_parsers::iq::IqType::Set(element) => {
                let iq_answer = self.incoming_iq_processing_set(iq.id, iq.from, element);
                self.state.data.send_queue.push_back(iq_answer.into());
            }
            xmpp_parsers::iq::IqType::Error(e) => {
                if let Some((_, handler)) = self.state.data.pending_ids.remove_entry(&iq.id) {
                    return handler.1.error(self, e);
                }
                error!("iq error: {:?}", e);
                return false;
            }
            xmpp_parsers::iq::IqType::Get(element) => {
                let iq_answer = self.incoming_iq_processing_get(iq.id, iq.from, element);
                self.state.data.send_queue.push_back(iq_answer.into());
            }
            xmpp_parsers::iq::IqType::Result(opt_element) => {
                if let Some((_, handler)) = self.state.data.pending_ids.remove_entry(&iq.id) {
                    return handler.1.result(self, opt_element);
                }
                warn!(
                    "Unwanted iq result id {} from {:?}: {:?}",
                    iq.id,
                    iq.from,
                    opt_element.map(|e| String::from(&e))
                );
            }
        }
        true
    }
    fn incoming_presence_processing(&mut self, presence: xmpp_parsers::presence::Presence) -> bool {
        if presence.from.as_ref() == Some(&self.state.client.jid) {
            info!("Self-presence accepted");
            self.state.data.self_presence = true;
        } else {
            warn!("Incoming presence stanza: {:?}", presence);
        }
        true
    }
    fn incoming_message_processing(&mut self, message: xmpp_parsers::message::Message) -> bool {
        for payload in message.payloads.iter() {
            use std::convert::TryInto;
            if let Some(_delay) =
                payload.clone().try_into().ok() as Option<xmpp_parsers::delay::Delay>
            {
                return true; // ignore delayed messages
            }
        }
        warn!("Incoming message stanza: {:?}", message);
        true
    }
    /// 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)| {
                // ToDo: check timeouts if iqs
                let XmppConnection {
                    state: XmppState { client, mut data },
                    account,
                } = xmpp;
                if let Some(send_element) = data.send_queue.pop_front() {
                    use tokio::prelude::Sink;
                    info!("Sending {}", String::from(&send_element));
                    Box::new(
                        client
                            .send(Packet::Stanza(send_element))
                            .select2(stop_future)
                            .then(move |r| match r {
                                Ok(Either::A((client, b))) => {
                                    Box::new(future::ok(future::Loop::Continue((
                                        XmppConnection {
                                            state: XmppState { client, data },
                                            account,
                                        },
                                        b,
                                        stop_condition,
                                    ))))
                                        as Box<dyn Future<Item = _, Error = _>>
                                }
                                Ok(Either::B((t, a))) => Box::new(a.then(|r| match r {
                                    Ok(client) => future::ok(future::Loop::Break((
                                        XmppConnection {
                                            state: XmppState { client, data },
                                            account,
                                        },
                                        Ok(Either::B(t)),
                                    ))),
                                    Err(se) => {
                                        warn!("XMPP sending error: {}", se);
                                        future::err((account, Ok(Either::B(t))))
                                    }
                                })),
                                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: {}", String::from(&s));
                Ok(false)
            }
            _ => {
                error!("Disconnected while online");
                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... {}", String::from(&get_roster));
        data.pending_ids.insert(
            id_init_roster.clone(),
            (
                Instant::now() + Duration::from_secs(60),
                Box::new(InitRosterIqHandler {}),
            ),
        );
        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, _| Ok(conn.state.data.roster_init), stop_future)
                .map_err(|(account, _)| account)
                .and_then(|(conn, r)| match r {
                    Ok(Either::A(_)) => future::ok(conn),
                    Ok(Either::B(_)) => future::err(conn.account),
                    Err(_e) => future::err(conn.account),
                })
            })
    }
    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... {}", String::from(&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, _| Ok(conn.state.data.self_presence),
                    stop_future,
                )
                .map_err(|(account, _)| account)
                .and_then(|(conn, r)| match r {
                    Ok(Either::A(_)) => future::ok(conn),
                    Ok(Either::B(_)) => future::err(conn.account),
                    Err(_e) => future::err(conn.account),
                })
            })
    }
    fn process_jid(&mut self, xmpp_to: &xmpp_parsers::Jid) {
        if let Some(ref mut mailbox) = self.state.data.outgoing_mailbox.get_mut(xmpp_to) {
            if !mailbox.is_empty() {
                if let Some(ref mut rdata) = self.state.data.roster.get_mut(xmpp_to) {
                    info!("Jid {} in roster", xmpp_to);
                    let sub_to = match rdata.0 {
                        xmpp_parsers::roster::Subscription::To => true,
                        xmpp_parsers::roster::Subscription::Both => true,
                        _ => false,
                    };
                    if sub_to {
                        info!("Subscribed to {}", xmpp_to);
                        self.state.data.send_queue.extend(
                            mailbox.drain(..).map(|message| {
                                stanzas::make_chat_message(xmpp_to.clone(), message)
                            }),
                        );
                    } else if rdata.1 == xmpp_parsers::roster::Ask::None {
                        info!("Not subscribed to {}", xmpp_to);
                        self.state
                            .data
                            .send_queue
                            .push_back(stanzas::make_ask_subscribe(xmpp_to.clone()));
                    }
                    let sub_from = match rdata.0 {
                        xmpp_parsers::roster::Subscription::From => true,
                        xmpp_parsers::roster::Subscription::Both => true,
                        _ => false,
                    };
                    if !sub_from {
                        info!("Not subscription from {}", xmpp_to);
                        self.state
                            .data
                            .send_queue
                            .push_back(stanzas::make_allow_subscribe(xmpp_to.clone()));
                    }
                } else {
                    info!("Jid {} not in roster", xmpp_to);
                    self.state.data.counter += 1;
                    let id_add_roster = format!("id_add_roster{}", self.state.data.counter);
                    let add_roster = stanzas::make_add_roster(&id_add_roster, xmpp_to.clone());
                    info!("Adding jid {} to roster id {}", xmpp_to, id_add_roster);
                    self.state.data.pending_ids.insert(
                        id_add_roster,
                        (
                            Instant::now() + Duration::from_secs(60),
                            Box::new(AddRosterIqHandler {
                                jid: xmpp_to.clone(),
                            }),
                        ),
                    );
                    self.state.data.send_queue.push_back(add_roster);
                }
            }
        }
    }
    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);
                self.state.data.pending_ids.insert(
                    id_ping,
                    (
                        Instant::now() + Duration::from_secs(30),
                        Box::new(PingIqHandler {}),
                    ),
                );
            }
            XmppCommand::TimeoutCleanup => {
                let now = Instant::now();
                let timeouted: Vec<String> = self
                    .state
                    .data
                    .pending_ids
                    .iter()
                    .filter_map(|(id, (timeout, _))| {
                        if now >= *timeout {
                            Some(id.to_string())
                        } else {
                            None
                        }
                    })
                    .collect();
                let mut correct = true;
                timeouted.into_iter().for_each(|id| {
                    if let Some((_, handler)) = self.state.data.pending_ids.remove(&id) {
                        correct &= handler.timeout(&mut self);
                    }
                })
            }
        }
    }
    pub fn shutdown(self) -> impl Future<Item = (), Error = failure::Error> {
        info!("Shutdown connection");
        let XmppConnection { account, state } = self;
        stream::iter_ok(
            state
                .data
                .mucs
                .values()
                .map(std::clone::Clone::clone)
                .collect::<Vec<_>>(),
        )
        .fold(state, move |XmppState { client, data }, muc_jid| {
            let muc_presence =
                stanzas::make_muc_presence_leave(account.jid.clone(), muc_jid.clone());
            info!(
                "Sending muc leave presence... {}",
                String::from(&muc_presence)
            );
            use tokio::prelude::Sink;
            client
                .send(Packet::Stanza(muc_presence))
                .map_err(|e| {
                    error!("Error on send muc presence: {}", e);
                    e
                })
                .and_then(|client| future::ok(XmppState { client, data }))
        })
        .map(|_| ())
    }
    fn enter_mucs<F, E>(
        self,
        _stop_future: F,
    ) -> impl Future<Item = Self, Error = std::rc::Rc<config::Account>>
    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... {}", String::from(&muc_presence));
                let account4 = account2.clone();
                use tokio::prelude::Sink;
                client
                    .send(Packet::Stanza(muc_presence))
                    .map_err(|e| {
                        error!("Error on send muc presence: {}", e);
                        account4
                    })
                    .and_then(|client| {
                        data.mucs.insert(muc_jid.0, muc_jid.1);
                        future::ok(XmppState { client, data })
                    })
            })
            .map(|state| XmppConnection {
                account: account3,
                state,
            })
    }
}
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 std::time::{Duration, Instant};
use super::stanzas;
use super::element_processor;
use crate::config;
#[derive(Debug)]
pub enum XmppCommand {
    /// Send message to someone by jid
    Chat {
        xmpp_to: xmpp_parsers::Jid,
        message: String,
    },
    /// Send message to MUC
    Chatroom {
        muc_id: String,
        message: String,
    },
    // Send ping request to the server to test connection
    Ping,
    /// Check iq requests if some have expired timeouts
    TimeoutCleanup,
}
/// trait of processing iq
/// each function consumes handlers and
/// returns false if connection should be reset
trait IqHandler {
    /// process result
    fn result(
        self: Box<Self>,
        conn: &mut XmppConnection,
        opt_element: Option<xmpp_parsers::Element>,
    ) -> bool;
    /// process error
    fn error(
        self: Box<Self>,
        conn: &mut XmppConnection,
        error: xmpp_parsers::stanza_error::StanzaError,
    ) -> bool;
    /// process tmeout
    fn timeout(self: Box<Self>, conn: &mut XmppConnection) -> bool;
}
struct AddRosterIqHandler {
    jid: xmpp_parsers::Jid,
}
impl IqHandler for AddRosterIqHandler {
    fn result(
        self: Box<Self>,
        conn: &mut XmppConnection,
        opt_element: Option<xmpp_parsers::Element>,
    ) -> bool {
        match opt_element {
            Some(element) => {
                warn!(
                    "Wrong payload when adding {} to roster: {}",
                    self.jid,
                    String::from(&element)
                );
            }
            None => {
                if conn.state.data.roster.contains_key(&self.jid) {
                    info!("Jid {} updated to roster", self.jid);
                } else {
                    info!("Jid {} added in roster", self.jid);
                    conn.state.data.roster.insert(
                        self.jid.clone(),
                        (
                            xmpp_parsers::roster::Subscription::None,
                            xmpp_parsers::roster::Ask::None,
                        ),
                    );
                }
                conn.process_jid(&self.jid);
            }
        }
        true
    }
    fn error(
        self: Box<Self>,
        _conn: &mut XmppConnection,
        _error: xmpp_parsers::stanza_error::StanzaError,
    ) -> bool {
        true
    }
    fn timeout(self: Box<Self>, _conn: &mut XmppConnection) -> bool {
        true // ignore
    }
}
struct PingIqHandler {}
impl IqHandler for PingIqHandler {
    fn result(
        self: Box<Self>,
        _conn: &mut XmppConnection,
        _opt_element: Option<xmpp_parsers::Element>,
    ) -> bool {
        true // ignore
    }
    fn error(
        self: Box<Self>,
        _conn: &mut XmppConnection,
        _error: xmpp_parsers::stanza_error::StanzaError,
    ) -> bool {
        false
    }
    fn timeout(self: Box<Self>, _conn: &mut XmppConnection) -> bool {
        false
    }
}
struct InitRosterIqHandler {}
impl IqHandler for InitRosterIqHandler {
    fn result(
        self: Box<Self>,
        conn: &mut XmppConnection,
        opt_element: Option<xmpp_parsers::Element>,
    ) -> bool {
        if let Some(result) = opt_element {
            use std::convert::TryInto;
            match result.try_into() as Result<xmpp_parsers::roster::Roster, _> {
                Ok(roster) => {
                    conn.state.data.roster_init = true;
                    conn.state.data.roster.clear();
                    info!("Got first roster:");
                    for i in roster.items {
                        info!(" >>> {:?}", i);
                        conn.state
                            .data
                            .roster
                            .insert(i.jid, (i.subscription, i.ask));
                    }
                    true
                }
                Err(e) => {
                    error!("Cann't parse roster: {}", e);
                    false
                }
            }
        } else {
            error!("No roster responded");
            false
        }
    }
    fn error(
        self: Box<Self>,
        _conn: &mut XmppConnection,
        _error: xmpp_parsers::stanza_error::StanzaError,
    ) -> bool {
        false
    }
    fn timeout(self: Box<Self>, _conn: &mut XmppConnection) -> bool {
        false
    }
}
#[derive(Default)]
struct XmppData {
    /// known roster data
    roster: HashMap<
        xmpp_parsers::Jid,
        (
            xmpp_parsers::roster::Subscription,
            xmpp_parsers::roster::Ask,
        ),
    >,
    /// if roster was initialized
    /// ToDo: remove it as it used only for initialization
    roster_init: bool,
    /// ids counter
    counter: usize,
    /// 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>,
    /// map from iq's id to handler of this type of iqs
    pending_ids: HashMap<String, (Instant, Box<dyn IqHandler>)>,
}
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 {}", String::from(&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
            }
        }
    }
    /// Enforce to answer to IQ "set"
    fn incoming_iq_processing_set(
        &mut self,
        id: String,
        from: Option<xmpp_parsers::Jid>,
        element: minidom::Element,
    ) -> xmpp_parsers::iq::Iq {
        use std::convert::TryInto;
        if let Some(roster) =
            element.clone().try_into().ok() as Option<xmpp_parsers::roster::Roster>
        {
            // RFC 6212 2.1.6. Roster Push
            for i in roster.items {
                if let Some(ref mut rdata) = self.state.data.roster.get_mut(&i.jid) {
                    info!("Update {} in roster", i.jid);
                    rdata.0 = i.subscription;
                    rdata.1 = i.ask;
                } else {
                    info!("Add {} to roster", i.jid);
                    self.state
                        .data
                        .roster
                        .insert(i.jid.clone(), (i.subscription, i.ask));
                }
                self.process_jid(&i.jid);
            }
            return stanzas::make_roster_push_answer(id, self.state.client.jid.clone(), from);
        }
        warn!(
            "Unsupported IQ set request from {:?}: {}",
            from,
            String::from(&element)
        );
        stanzas::make_iq_unsupported_error(id, self.state.client.jid.clone(), from)
    }
    /// Enforce to answer to IQ "get"
    fn incoming_iq_processing_get(
        &mut self,
        id: String,
        from: Option<xmpp_parsers::Jid>,
        element: minidom::Element,
    ) -> xmpp_parsers::iq::Iq {
        use std::convert::TryInto;
        if let Some(_ping) = element.clone().try_into().ok() as Option<xmpp_parsers::ping::Ping> {
            return stanzas::make_pong(&id, self.state.client.jid.clone(), from);
        }
        warn!(
            "Unsupported IQ get request from {:?}: {}",
            from,
            String::from(&element)
        );
        stanzas::make_iq_unsupported_error(id, self.state.client.jid.clone(), from)
    }
    fn incoming_iq_processing(&mut self, iq: xmpp_parsers::iq::Iq) -> bool {
        match iq.payload {
            xmpp_parsers::iq::IqType::Set(element) => {
                let iq_answer = self.incoming_iq_processing_set(iq.id, iq.from, element);
                self.state.data.send_queue.push_back(iq_answer.into());
            }
            xmpp_parsers::iq::IqType::Error(e) => {
                if let Some((_, handler)) = self.state.data.pending_ids.remove_entry(&iq.id) {
                    return handler.1.error(self, e);
                }
                error!("iq error: {:?}", e);
                return false;
            }
            xmpp_parsers::iq::IqType::Get(element) => {
                let iq_answer = self.incoming_iq_processing_get(iq.id, iq.from, element);
                self.state.data.send_queue.push_back(iq_answer.into());
            }
            xmpp_parsers::iq::IqType::Result(opt_element) => {
                if let Some((_, handler)) = self.state.data.pending_ids.remove_entry(&iq.id) {
                    return handler.1.result(self, opt_element);
                }
                warn!(
                    "Unwanted iq result id {} from {:?}: {:?}",
                    iq.id,
                    iq.from,
                    opt_element.map(|e| String::from(&e))
                );
            }
        }
        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)| {
                // ToDo: check timeouts if iqs
                let XmppConnection {
                    state: XmppState { client, mut data },
                    account,
                } = xmpp;
                if let Some(send_element) = data.send_queue.pop_front() {
                    use tokio::prelude::Sink;
                    info!("Sending {}", String::from(&send_element));
                    Box::new(
                        client
                            .send(Packet::Stanza(send_element))
                            .select2(stop_future)
                            .then(move |r| match r {
                                Ok(Either::A((client, b))) => {
                                    Box::new(future::ok(future::Loop::Continue((
                                        XmppConnection {
                                            state: XmppState { client, data },
                                            account,
                                        },
                                        b,
                                        stop_condition,
                                    ))))
                                        as Box<dyn Future<Item = _, Error = _>>
                                }
                                Ok(Either::B((t, a))) => Box::new(a.then(|r| match r {
                                    Ok(client) => future::ok(future::Loop::Break((
                                        XmppConnection {
                                            state: XmppState { client, data },
                                            account,
                                        },
                                        Ok(Either::B(t)),
                                    ))),
                                    Err(se) => {
                                        warn!("XMPP sending error: {}", se);
                                        future::err((account, Ok(Either::B(t))))
                                    }
                                })),
                                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: {}", String::from(&s));
                Ok(false)
            }
            _ => {
                error!("Disconnected while online");
                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... {}", String::from(&get_roster));
        data.pending_ids.insert(
            id_init_roster.clone(),
            (
                Instant::now() + Duration::from_secs(60),
                Box::new(InitRosterIqHandler {}),
            ),
        );
        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, _| Ok(conn.state.data.roster_init), stop_future)
                .map_err(|(account, _)| account)
                .and_then(|(conn, r)| match r {
                    Ok(Either::A(_)) => future::ok(conn),
                    Ok(Either::B(_)) => future::err(conn.account),
                    Err(_e) => future::err(conn.account),
                })
            })
    }
    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... {}", String::from(&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());
                    info!("Adding jid {} to roster id {}", xmpp_to, id_add_roster);
                    self.state.data.pending_ids.insert(
                        id_add_roster,
                        (
                            Instant::now() + Duration::from_secs(60),
                            Box::new(AddRosterIqHandler {
                                jid: xmpp_to.clone(),
                            }),
                        ),
                    );
                    self.state.data.send_queue.push_back(add_roster);
                }
            }
        }
    }
    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);
                self.state.data.pending_ids.insert(
                    id_ping,
                    (
                        Instant::now() + Duration::from_secs(30),
                        Box::new(PingIqHandler {}),
                    ),
                );
            }
            XmppCommand::TimeoutCleanup => {
                let now = Instant::now();
                let timeouted: Vec<String> = self
                    .state
                    .data
                    .pending_ids
                    .iter()
                    .filter_map(|(id, (timeout, _))| {
                        if now >= *timeout {
                            Some(id.to_string())
                        } else {
                            None
                        }
                    })
                    .collect();
                let mut correct = true;
                timeouted.into_iter().for_each(|id| {
                    if let Some((_, handler)) = self.state.data.pending_ids.remove(&id) {
                        correct &= handler.timeout(&mut self);
                    }
                })
            }
        }
    }
    pub fn shutdown(self) -> impl Future<Item = (), Error = failure::Error> {
        info!("Shutdown connection");
        let XmppConnection { account, state } = self;
        stream::iter_ok(
            state
                .data
                .mucs
                .values()
                .map(std::clone::Clone::clone)
                .collect::<Vec<_>>(),
        )
        .fold(state, move |XmppState { client, data }, muc_jid| {
            let muc_presence =
                stanzas::make_muc_presence_leave(account.jid.clone(), muc_jid.clone());
            info!(
                "Sending muc leave presence... {}",
                String::from(&muc_presence)
            );
            use tokio::prelude::Sink;
            client
                .send(Packet::Stanza(muc_presence))
                .map_err(|e| {
                    error!("Error on send muc presence: {}", e);
                    e
                })
                .and_then(|client| future::ok(XmppState { client, data }))
        })
        .map(|_| ())
    }
    fn enter_mucs<F, E>(
        self,
        _stop_future: F,
    ) -> impl Future<Item = Self, Error = std::rc::Rc<config::Account>>
    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... {}", String::from(&muc_presence));
                let account4 = account2.clone();
                use tokio::prelude::Sink;
                client
                    .send(Packet::Stanza(muc_presence))
                    .map_err(|e| {
                        error!("Error on send muc presence: {}", e);
                        account4
                    })
                    .and_then(|client| {
                        data.mucs.insert(muc_jid.0, muc_jid.1);
                        future::ok(XmppState { client, data })
                    })
            })
            .map(|state| XmppConnection {
                account: account3,
                state,
            })
    }
}
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 std::time::{Duration, Instant};
use super::stanzas;
use super::element_processor;
use crate::config;
#[derive(Debug)]
pub enum XmppCommand {
    /// Send message to someone by jid
    Chat {
        xmpp_to: xmpp_parsers::Jid,
        message: String,
    },
    /// Send message to MUC
    Chatroom { muc_id: String, message: String },
    /// Send ping request to the server to test connection
    Ping,
    /// Check iq requests if some have expired timeouts
    TimeoutCleanup,
}
/// trait of processing iq
/// each function consumes handlers and
/// returns false if connection should be reset
trait IqHandler {
    /// process result
    fn result(
        self: Box<Self>,
        conn: &mut XmppConnection,
        opt_element: Option<xmpp_parsers::Element>,
    ) -> bool;
    /// process error
    fn error(
        self: Box<Self>,
        conn: &mut XmppConnection,
        error: xmpp_parsers::stanza_error::StanzaError,
    ) -> bool;
    /// process tmeout
    fn timeout(self: Box<Self>, conn: &mut XmppConnection) -> bool;
}
struct AddRosterIqHandler {
    jid: xmpp_parsers::Jid,
}
impl IqHandler for AddRosterIqHandler {
    fn result(
        self: Box<Self>,
        conn: &mut XmppConnection,
        opt_element: Option<xmpp_parsers::Element>,
    ) -> bool {
        match opt_element {
            Some(element) => {
                warn!(
                    "Wrong payload when adding {} to roster: {}",
                    self.jid,
                    String::from(&element)
                );
            }
            None => {
                if conn.state.data.roster.contains_key(&self.jid) {
                    info!("Jid {} updated to roster", self.jid);
                } else {
                    info!("Jid {} added in roster", self.jid);
                    conn.state.data.roster.insert(
                        self.jid.clone(),
                        (
                            xmpp_parsers::roster::Subscription::None,
                            xmpp_parsers::roster::Ask::None,
                        ),
                    );
                }
                conn.process_jid(&self.jid);
            }
        }
        true
    }
    fn error(
        self: Box<Self>,
        _conn: &mut XmppConnection,
        _error: xmpp_parsers::stanza_error::StanzaError,
    ) -> bool {
        true
    }
    fn timeout(self: Box<Self>, _conn: &mut XmppConnection) -> bool {
        true // ignore
    }
}
struct PingIqHandler {}
impl IqHandler for PingIqHandler {
    fn result(
        self: Box<Self>,
        _conn: &mut XmppConnection,
        _opt_element: Option<xmpp_parsers::Element>,
    ) -> bool {
        info!("ping successed");
        true
    }
    fn error(
        self: Box<Self>,
        _conn: &mut XmppConnection,
        _error: xmpp_parsers::stanza_error::StanzaError,
    ) -> bool {
        false
    }
    fn timeout(self: Box<Self>, _conn: &mut XmppConnection) -> bool {
        false
    }
}
struct InitRosterIqHandler {}
impl IqHandler for InitRosterIqHandler {
    fn result(
        self: Box<Self>,
        conn: &mut XmppConnection,
        opt_element: Option<xmpp_parsers::Element>,
    ) -> bool {
        if let Some(result) = opt_element {
            use std::convert::TryInto;
            match result.try_into() as Result<xmpp_parsers::roster::Roster, _> {
                Ok(roster) => {
                    conn.state.data.roster_init = true;
                    conn.state.data.roster.clear();
                    info!("Got first roster:");
                    for i in roster.items {
                        info!(" >>> {:?}", i);
                        conn.state
                            .data
                            .roster
                            .insert(i.jid, (i.subscription, i.ask));
                    }
                    true
                }
                Err(e) => {
                    error!("Cann't parse roster: {}", e);
                    false
                }
            }
        } else {
            error!("No roster responded");
            false
        }
    }
    fn error(
        self: Box<Self>,
        _conn: &mut XmppConnection,
        _error: xmpp_parsers::stanza_error::StanzaError,
    ) -> bool {
        false
    }
    fn timeout(self: Box<Self>, _conn: &mut XmppConnection) -> bool {
        false
    }
}
#[derive(Default)]
struct XmppData {
    /// known roster data
    roster: HashMap<
        xmpp_parsers::Jid,
        (
            xmpp_parsers::roster::Subscription,
            xmpp_parsers::roster::Ask,
        ),
    >,
    /// if roster was initialized
    /// ToDo: remove it as it is used only for initialization
    roster_init: bool,
    /// if self-presence accepted
    /// ToDo: remove it as it is used only for initialization
    self_presence: bool,
    /// ids counter
    counter: usize,
    /// 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>,
    /// map from iq's id to handler of this type of iqs
    pending_ids: HashMap<String, (Instant, Box<dyn IqHandler>)>,
}
struct XmppState {
    client: Client,
    data: XmppData,
}
pub struct XmppConnection {
    account: std::rc::Rc<config::Account>,
    state: XmppState,
}
trait IqRequestHandler {
    fn process(
        self: Box<Self>,
        conn: &mut XmppConnection,
        id: String,
        from: Option<xmpp_parsers::Jid>,
    ) -> xmpp_parsers::iq::Iq;
}
struct IqRequestUnknown {
    element: xmpp_parsers::Element,
    type_: &'static str,
}
impl IqRequestHandler for IqRequestUnknown {
    fn process(
        self: Box<Self>,
        conn: &mut XmppConnection,
        id: String,
        from: Option<xmpp_parsers::Jid>,
    ) -> xmpp_parsers::iq::Iq {
        warn!(
            "Unsupported IQ {} request from {:?}: {}",
            self.type_,
            from,
            String::from(&self.element)
        );
        stanzas::make_iq_unsupported_error(id, conn.state.client.jid.clone(), from)
    }
}
struct IqSetRoster {}
impl IqRequestHandler for IqSetRoster {
    fn process(
        self: Box<Self>,
        conn: &mut XmppConnection,
        id: String,
        from: Option<xmpp_parsers::Jid>,
    ) -> xmpp_parsers::iq::Iq {
        info!("Got roster push {} from {:?}", id, from);
        stanzas::make_roster_push_answer(id, conn.state.client.jid.clone(), from)
    }
}
struct IqGetPing {}
impl IqRequestHandler for IqGetPing {
    fn process(
        self: Box<Self>,
        conn: &mut XmppConnection,
        id: String,
        from: Option<xmpp_parsers::Jid>,
    ) -> xmpp_parsers::iq::Iq {
        info!("Got ping {} from {:?}", id, from);
        stanzas::make_pong(id, conn.state.client.jid.clone(), from)
    }
}
struct IqGetVersion {}
impl IqRequestHandler for IqGetVersion {
    fn process(
        self: Box<Self>,
        conn: &mut XmppConnection,
        id: String,
        from: Option<xmpp_parsers::Jid>,
    ) -> xmpp_parsers::iq::Iq {
        info!("Got version query {} from {:?}", id, from);
        stanzas::make_version(id, conn.state.client.jid.clone(), from)
    }
}
struct IqGetDiscoInfo {}
impl IqRequestHandler for IqGetDiscoInfo {
    fn process(
        self: Box<Self>,
        conn: &mut XmppConnection,
        id: String,
        from: Option<xmpp_parsers::Jid>,
    ) -> xmpp_parsers::iq::Iq {
        info!("Got disco query {} from {:?}", id, from);
        stanzas::make_disco_info_result(id, conn.state.client.jid.clone(), from)
    }
}
struct IqGetDiscoItems {}
impl IqRequestHandler for IqGetDiscoItems {
    fn process(
        self: Box<Self>,
        conn: &mut XmppConnection,
        id: String,
        from: Option<xmpp_parsers::Jid>,
    ) -> xmpp_parsers::iq::Iq {
        info!("Got disco items query {} from {:?}", id, from);
        stanzas::make_disco_items_result(id, conn.state.client.jid.clone(), from)
    }
}
lazy_static! {
    static ref INCOMING: element_processor::Processor<XmppConnection, bool, xmpp_parsers::Element> = {
        let mut incoming = element_processor::Processor::new(&|_, e| {
            warn!("Unknown stanza {}", String::from(&e));
            true
        });
        incoming.register(&XmppConnection::incoming_iq_processing);
        incoming.register(&XmppConnection::incoming_presence_processing);
        incoming.register(&XmppConnection::incoming_message_processing);
        incoming
    };
    static ref INCOMING_IQ_SET: element_processor::Processor<XmppConnection, Box<dyn IqRequestHandler>, xmpp_parsers::Element> = {
        let mut iq_set =
            element_processor::Processor::new(&|_conn: &mut XmppConnection, element| {
                Box::new(IqRequestUnknown {
                    element,
                    type_: "set",
                }) as Box<dyn IqRequestHandler>
            });
        iq_set.register(&XmppConnection::incoming_iq_processing_set_roster);
        iq_set
    };
    static ref INCOMING_IQ_GET: element_processor::Processor<XmppConnection, Box<dyn IqRequestHandler>, xmpp_parsers::Element> = {
        let mut iq_get =
            element_processor::Processor::new(&|_conn: &mut XmppConnection, element| {
                Box::new(IqRequestUnknown {
                    element,
                    type_: "get",
                }) as Box<dyn IqRequestHandler>
            });
        iq_get.register(&XmppConnection::incoming_iq_processing_get_ping);
        iq_get.register(&XmppConnection::incoming_iq_processing_get_disco_info);
        iq_get.register(&XmppConnection::incoming_iq_processing_get_disco_items);
        iq_get.register(&XmppConnection::incoming_iq_processing_get_version);
        iq_get
    };
}
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) => INCOMING.process(self, stanza.clone()),
            Event::Online => true,
            e => {
                warn!("Unexpected event {:?}", e);
                false
            }
        }
    }
    /// Process roster push
    /// see RFC 6212 2.1.6. Roster Push
    fn incoming_iq_processing_set_roster(
        &mut self,
        roster: xmpp_parsers::roster::Roster,
    ) -> Box<dyn IqRequestHandler> {
        for i in roster.items {
            if let Some(ref mut rdata) = self.state.data.roster.get_mut(&i.jid) {
                info!("Update {} in roster", i.jid);
                rdata.0 = i.subscription;
                rdata.1 = i.ask;
            } else {
                info!("Add {} to roster", i.jid);
                self.state
                    .data
                    .roster
                    .insert(i.jid.clone(), (i.subscription, i.ask));
            }
            self.process_jid(&i.jid);
        }
        Box::new(IqSetRoster {})
    }
    /// Enforce to answer to IQ "set"
    fn incoming_iq_processing_set(
        &mut self,
        id: String,
        from: Option<xmpp_parsers::Jid>,
        element: minidom::Element,
    ) -> xmpp_parsers::iq::Iq {
        INCOMING_IQ_SET
            .process(self, element)
            .process(self, id, from)
    }
    /// Process ping request
    /// see XEP-0199: XMPP Ping
    fn incoming_iq_processing_get_ping(
        &mut self,
        _ping: xmpp_parsers::ping::Ping,
    ) -> Box<dyn IqRequestHandler> {
        Box::new(IqGetPing {})
    }
    /// Process disco query
    /// see XEP-0030: Service Discovery
    fn incoming_iq_processing_get_disco_info(
        &mut self,
        disco: xmpp_parsers::disco::DiscoInfoQuery,
    ) -> Box<dyn IqRequestHandler> {
        if let Some(ref node) = disco.node {
            warn!("Unsupported node {}", node);
            Box::new(IqRequestUnknown {
                element: disco.into(),
                type_: "get",
            })
        } else {
            Box::new(IqGetDiscoInfo {})
        }
    }
    /// Process disco items query
    /// see XEP-0030: Service Discovery
    fn incoming_iq_processing_get_disco_items(
        &mut self,
        disco: xmpp_parsers::disco::DiscoItemsQuery,
    ) -> Box<dyn IqRequestHandler> {
        if let Some(ref node) = disco.node {
            warn!("Unsupported node {}", node);
            Box::new(IqRequestUnknown {
                element: disco.into(),
                type_: "get",
            })
        } else {
            Box::new(IqGetDiscoItems {})
        }
    }
    /// Process version query
    /// see XEP-0092: Software Version
    fn incoming_iq_processing_get_version(
        &mut self,
        _version: xmpp_parsers::version::VersionQuery,
    ) -> Box<dyn IqRequestHandler> {
        Box::new(IqGetVersion {})
    }
    /// Enforce to answer to IQ "get"
    fn incoming_iq_processing_get(
        &mut self,
        id: String,
        from: Option<xmpp_parsers::Jid>,
        element: minidom::Element,
    ) -> xmpp_parsers::iq::Iq {
        INCOMING_IQ_GET
            .process(self, element)
            .process(self, id, from)
    }
    fn incoming_iq_processing(&mut self, iq: xmpp_parsers::iq::Iq) -> bool {
        match iq.payload {
            xmpp_parsers::iq::IqType::Set(element) => {
                let iq_answer = self.incoming_iq_processing_set(iq.id, iq.from, element);
                self.state.data.send_queue.push_back(iq_answer.into());
            }
            xmpp_parsers::iq::IqType::Error(e) => {
                if let Some((_, handler)) = self.state.data.pending_ids.remove_entry(&iq.id) {
                    return handler.1.error(self, e);
                }
                error!("iq error: {:?}", e);
                return false;
            }
            xmpp_parsers::iq::IqType::Get(element) => {
                let iq_answer = self.incoming_iq_processing_get(iq.id, iq.from, element);
                self.state.data.send_queue.push_back(iq_answer.into());
            }
            xmpp_parsers::iq::IqType::Result(opt_element) => {
                if let Some((_, handler)) = self.state.data.pending_ids.remove_entry(&iq.id) {
                    return handler.1.result(self, opt_element);
                }
                warn!(
                    "Unwanted iq result id {} from {:?}: {:?}",
                    iq.id,
                    iq.from,
                    opt_element.map(|e| String::from(&e))
                );
            }
        }
        true
    }
    fn incoming_presence_processing(&mut self, presence: xmpp_parsers::presence::Presence) -> bool {
        if presence.from.as_ref() == Some(&self.state.client.jid) {
            info!("Self-presence accepted");
            self.state.data.self_presence = true;
        } else {
            warn!("Incoming presence stanza: {:?}", presence);
        }
        true
    }
    fn incoming_message_processing(&mut self, message: xmpp_parsers::message::Message) -> bool {
        for payload in message.payloads.iter() {
            use std::convert::TryInto;
            if let Some(_delay) =
                payload.clone().try_into().ok() as Option<xmpp_parsers::delay::Delay>
            {
                return true; // ignore delayed messages
            }
        }
        warn!("Incoming message stanza: {:?}", message);
        true
    }
    /// 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)| {
                // ToDo: check timeouts if iqs
                let XmppConnection {
                    state: XmppState { client, mut data },
                    account,
                } = xmpp;
                if let Some(send_element) = data.send_queue.pop_front() {
                    use tokio::prelude::Sink;
                    info!("Sending {}", String::from(&send_element));
                    Box::new(
                        client
                            .send(Packet::Stanza(send_element))
                            .select2(stop_future)
                            .then(move |r| match r {
                                Ok(Either::A((client, b))) => {
                                    Box::new(future::ok(future::Loop::Continue((
                                        XmppConnection {
                                            state: XmppState { client, data },
                                            account,
                                        },
                                        b,
                                        stop_condition,
                                    ))))
                                        as Box<dyn Future<Item = _, Error = _>>
                                }
                                Ok(Either::B((t, a))) => Box::new(a.then(|r| match r {
                                    Ok(client) => future::ok(future::Loop::Break((
                                        XmppConnection {
                                            state: XmppState { client, data },
                                            account,
                                        },
                                        Ok(Either::B(t)),
                                    ))),
                                    Err(se) => {
                                        warn!("XMPP sending error: {}", se);
                                        future::err((account, Ok(Either::B(t))))
                                    }
                                })),
                                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: {}", String::from(&s));
                Ok(false)
            }
            _ => {
                error!("Disconnected while online");
                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... {}", String::from(&get_roster));
        data.pending_ids.insert(
            id_init_roster.clone(),
            (
                Instant::now() + Duration::from_secs(60),
                Box::new(InitRosterIqHandler {}),
            ),
        );
        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, _| Ok(conn.state.data.roster_init), stop_future)
                .map_err(|(account, _)| account)
                .and_then(|(conn, r)| match r {
                    Ok(Either::A(_)) => future::ok(conn),
                    Ok(Either::B(_)) => future::err(conn.account),
                    Err(_e) => future::err(conn.account),
                })
            })
    }
    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... {}", String::from(&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, _| Ok(conn.state.data.self_presence),
                    stop_future,
                )
                .map_err(|(account, _)| account)
                .and_then(|(conn, r)| match r {
                    Ok(Either::A(_)) => future::ok(conn),
                    Ok(Either::B(_)) => future::err(conn.account),
                    Err(_e) => future::err(conn.account),
                })
            })
    }
    fn process_jid(&mut self, xmpp_to: &xmpp_parsers::Jid) {
        if let Some(ref mut mailbox) = self.state.data.outgoing_mailbox.get_mut(xmpp_to) {
            if !mailbox.is_empty() {
                if let Some(ref mut rdata) = self.state.data.roster.get_mut(xmpp_to) {
                    info!("Jid {} in roster", xmpp_to);
                    let sub_to = match rdata.0 {
                        xmpp_parsers::roster::Subscription::To => true,
                        xmpp_parsers::roster::Subscription::Both => true,
                        _ => false,
                    };
                    if sub_to {
                        info!("Subscribed to {}", xmpp_to);
                        self.state.data.send_queue.extend(
                            mailbox.drain(..).map(|message| {
                                stanzas::make_chat_message(xmpp_to.clone(), message)
                            }),
                        );
                    } else if rdata.1 == xmpp_parsers::roster::Ask::None {
                        info!("Not subscribed to {}", xmpp_to);
                        self.state
                            .data
                            .send_queue
                            .push_back(stanzas::make_ask_subscribe(xmpp_to.clone()));
                    }
                    let sub_from = match rdata.0 {
                        xmpp_parsers::roster::Subscription::From => true,
                        xmpp_parsers::roster::Subscription::Both => true,
                        _ => false,
                    };
                    if !sub_from {
                        info!("Not subscription from {}", xmpp_to);
                        self.state
                            .data
                            .send_queue
                            .push_back(stanzas::make_allow_subscribe(xmpp_to.clone()));
                    }
                } else {
                    info!("Jid {} not in roster", xmpp_to);
                    self.state.data.counter += 1;
                    let id_add_roster = format!("id_add_roster{}", self.state.data.counter);
                    let add_roster = stanzas::make_add_roster(&id_add_roster, xmpp_to.clone());
                    info!("Adding jid {} to roster id {}", xmpp_to, id_add_roster);
                    self.state.data.pending_ids.insert(
                        id_add_roster,
                        (
                            Instant::now() + Duration::from_secs(60),
                            Box::new(AddRosterIqHandler {
                                jid: xmpp_to.clone(),
                            }),
                        ),
                    );
                    self.state.data.send_queue.push_back(add_roster);
                }
            }
        }
    }
    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);
                self.state.data.pending_ids.insert(
                    id_ping,
                    (
                        Instant::now() + Duration::from_secs(30),
                        Box::new(PingIqHandler {}),
                    ),
                );
            }
            XmppCommand::TimeoutCleanup => {
                let now = Instant::now();
                let timeouted: Vec<String> = self
                    .state
                    .data
                    .pending_ids
                    .iter()
                    .filter_map(|(id, (timeout, _))| {
                        if now >= *timeout {
                            Some(id.to_string())
                        } else {
                            None
                        }
                    })
                    .collect();
                let mut correct = true;
                timeouted.into_iter().for_each(|id| {
                    if let Some((_, handler)) = self.state.data.pending_ids.remove(&id) {
                        correct &= handler.timeout(&mut self);
                    }
                })
            }
        }
    }
    pub fn shutdown(self) -> impl Future<Item = (), Error = failure::Error> {
        info!("Shutdown connection");
        let XmppConnection { account, state } = self;
        stream::iter_ok(
            state
                .data
                .mucs
                .values()
                .map(std::clone::Clone::clone)
                .collect::<Vec<_>>(),
        )
        .fold(state, move |XmppState { client, data }, muc_jid| {
            let muc_presence =
                stanzas::make_muc_presence_leave(account.jid.clone(), muc_jid.clone());
            info!(
                "Sending muc leave presence... {}",
                String::from(&muc_presence)
            );
            use tokio::prelude::Sink;
            client
                .send(Packet::Stanza(muc_presence))
                .map_err(|e| {
                    error!("Error on send muc presence: {}", e);
                    e
                })
                .and_then(|client| future::ok(XmppState { client, data }))
        })
        .map(|_| ())
    }
    fn enter_mucs<F, E>(
        self,
        _stop_future: F,
    ) -> impl Future<Item = Self, Error = std::rc::Rc<config::Account>>
    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... {}", String::from(&muc_presence));
                let account4 = account2.clone();
                use tokio::prelude::Sink;
                client
                    .send(Packet::Stanza(muc_presence))
                    .map_err(|e| {
                        error!("Error on send muc presence: {}", e);
                        account4
                    })
                    .and_then(|client| {
                        data.mucs.insert(muc_jid.0, muc_jid.1);
                        future::ok(XmppState { client, data })
                    })
            })
            .map(|state| XmppConnection {
                account: account3,
                state,
            })
    }
}
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.counter += 1;
                        let id_presence_subscribe =
                            format!("id_presence_subscribe{}", self.state.data.counter);
                        self.state
                            .data
                            .send_queue
                            .push_back(stanzas::make_ask_subscribe(
                                id_presence_subscribe,
                                xmpp_to.clone(),
                            ));
                    } else {
                        warn!(
                            "Not subscribed to {}. Currently in {:?} state",
                            xmpp_to, rdata.1
                        );
                        self.state.data.counter += 1;
                        let id_presence_subscribe =
                            format!("id_presence_subscribe{}", self.state.data.counter);
                        self.state
                            .data
                            .send_queue
                            .push_back(stanzas::make_ask_subscribe(
                                id_presence_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.counter += 1;
                        let id_presence_subscribed =
                            format!("id_presence_subscribed{}", self.state.data.counter);
                        self.state
                            .data
                            .send_queue
                            .push_back(stanzas::make_allow_subscribe(
                                id_presence_subscribed,
                                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,
            })
    }
}
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 std::time::{Duration, Instant};
use super::stanzas;
use super::element_processor;
use crate::config;
#[derive(Debug)]
pub enum XmppCommand {
    /// Send message to someone by jid
    Chat {
        xmpp_to: xmpp_parsers::Jid,
        message: String,
    },
    /// Send message to MUC
    Chatroom { muc_id: String, message: String },
    /// Send ping request to the server to test connection
    Ping,
    /// Check iq requests if some have expired timeouts
    TimeoutCleanup,
}
/// trait of processing iq
/// each function consumes handlers and
/// returns false if connection should be reset
trait IqHandler {
    /// process result
    fn result(
        self: Box<Self>,
        conn: &mut XmppConnection,
        opt_element: Option<xmpp_parsers::Element>,
    ) -> bool;
    /// process error
    fn error(
        self: Box<Self>,
        conn: &mut XmppConnection,
        error: xmpp_parsers::stanza_error::StanzaError,
    ) -> bool;
    /// process tmeout
    fn timeout(self: Box<Self>, conn: &mut XmppConnection) -> bool;
}
struct AddRosterIqHandler {
    jid: xmpp_parsers::Jid,
}
impl IqHandler for AddRosterIqHandler {
    fn result(
        self: Box<Self>,
        conn: &mut XmppConnection,
        opt_element: Option<xmpp_parsers::Element>,
    ) -> bool {
        match opt_element {
            Some(element) => {
                warn!(
                    "Wrong payload when adding {} to roster: {}",
                    self.jid,
                    String::from(&element)
                );
            }
            None => {
                if conn.state.data.roster.contains_key(&self.jid) {
                    info!("Jid {} updated to roster", self.jid);
                } else {
                    info!("Jid {} added in roster", self.jid);
                    conn.state.data.roster.insert(
                        self.jid.clone(),
                        (
                            xmpp_parsers::roster::Subscription::None,
                            xmpp_parsers::roster::Ask::None,
                        ),
                    );
                }
                conn.process_jid(&self.jid);
            }
        }
        true
    }
    fn error(
        self: Box<Self>,
        _conn: &mut XmppConnection,
        _error: xmpp_parsers::stanza_error::StanzaError,
    ) -> bool {
        true
    }
    fn timeout(self: Box<Self>, _conn: &mut XmppConnection) -> bool {
        true // ignore
    }
}
struct PingIqHandler {}
impl IqHandler for PingIqHandler {
    fn result(
        self: Box<Self>,
        _conn: &mut XmppConnection,
        _opt_element: Option<xmpp_parsers::Element>,
    ) -> bool {
        info!("ping successed");
        true
    }
    fn error(
        self: Box<Self>,
        _conn: &mut XmppConnection,
        _error: xmpp_parsers::stanza_error::StanzaError,
    ) -> bool {
        false
    }
    fn timeout(self: Box<Self>, _conn: &mut XmppConnection) -> bool {
        false
    }
}
struct InitRosterIqHandler {}
impl IqHandler for InitRosterIqHandler {
    fn result(
        self: Box<Self>,
        conn: &mut XmppConnection,
        opt_element: Option<xmpp_parsers::Element>,
    ) -> bool {
        if let Some(result) = opt_element {
            use std::convert::TryInto;
            match result.try_into() as Result<xmpp_parsers::roster::Roster, _> {
                Ok(roster) => {
                    conn.state.data.roster_init = true;
                    conn.state.data.roster.clear();
                    info!("Got first roster:");
                    for i in roster.items {
                        info!(" >>> {:?}", i);
                        conn.state
                            .data
                            .roster
                            .insert(i.jid, (i.subscription, i.ask));
                    }
                    true
                }
                Err(e) => {
                    error!("Cann't parse roster: {}", e);
                    false
                }
            }
        } else {
            error!("No roster responded");
            false
        }
    }
    fn error(
        self: Box<Self>,
        _conn: &mut XmppConnection,
        _error: xmpp_parsers::stanza_error::StanzaError,
    ) -> bool {
        false
    }
    fn timeout(self: Box<Self>, _conn: &mut XmppConnection) -> bool {
        false
    }
}
#[derive(Default)]
struct XmppData {
    /// known roster data
    roster: HashMap<
        xmpp_parsers::Jid,
        (
            xmpp_parsers::roster::Subscription,
            xmpp_parsers::roster::Ask,
        ),
    >,
    /// if roster was initialized
    /// ToDo: remove it as it is used only for initialization
    roster_init: bool,
    /// if self-presence accepted
    /// ToDo: remove it as it is used only for initialization
    self_presence: bool,
    /// ids counter
    counter: usize,
    /// 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>,
    /// map from iq's id to handler of this type of iqs
    pending_ids: HashMap<String, (Instant, Box<dyn IqHandler>)>,
}
struct XmppState {
    client: Client,
    data: XmppData,
}
pub struct XmppConnection {
    account: std::rc::Rc<config::Account>,
    state: XmppState,
}
trait IqRequestHandler {
    fn process(
        self: Box<Self>,
        conn: &mut XmppConnection,
        id: String,
        from: Option<xmpp_parsers::Jid>,
    ) -> xmpp_parsers::iq::Iq;
}
struct IqRequestUnknown {
    element: xmpp_parsers::Element,
    type_: &'static str,
}
impl IqRequestHandler for IqRequestUnknown {
    fn process(
        self: Box<Self>,
        conn: &mut XmppConnection,
        id: String,
        from: Option<xmpp_parsers::Jid>,
    ) -> xmpp_parsers::iq::Iq {
        warn!(
            "Unsupported IQ {} request from {:?}: {}",
            self.type_,
            from,
            String::from(&self.element)
        );
        stanzas::make_iq_unsupported_error(id, conn.state.client.jid.clone(), from)
    }
}
struct IqSetRoster {}
impl IqRequestHandler for IqSetRoster {
    fn process(
        self: Box<Self>,
        conn: &mut XmppConnection,
        id: String,
        from: Option<xmpp_parsers::Jid>,
    ) -> xmpp_parsers::iq::Iq {
        info!("Got roster push {} from {:?}", id, from);
        stanzas::make_roster_push_answer(id, conn.state.client.jid.clone(), from)
    }
}
struct IqGetPing {}
impl IqRequestHandler for IqGetPing {
    fn process(
        self: Box<Self>,
        conn: &mut XmppConnection,
        id: String,
        from: Option<xmpp_parsers::Jid>,
    ) -> xmpp_parsers::iq::Iq {
        info!("Got ping {} from {:?}", id, from);
        stanzas::make_pong(id, conn.state.client.jid.clone(), from)
    }
}
struct IqGetVersion {}
impl IqRequestHandler for IqGetVersion {
    fn process(
        self: Box<Self>,
        conn: &mut XmppConnection,
        id: String,
        from: Option<xmpp_parsers::Jid>,
    ) -> xmpp_parsers::iq::Iq {
        info!("Got version query {} from {:?}", id, from);
        stanzas::make_version(id, conn.state.client.jid.clone(), from)
    }
}
struct IqGetDiscoInfo {}
impl IqRequestHandler for IqGetDiscoInfo {
    fn process(
        self: Box<Self>,
        conn: &mut XmppConnection,
        id: String,
        from: Option<xmpp_parsers::Jid>,
    ) -> xmpp_parsers::iq::Iq {
        info!("Got disco query {} from {:?}", id, from);
        stanzas::make_disco_info_result(id, conn.state.client.jid.clone(), from)
    }
}
struct IqGetDiscoItems {}
impl IqRequestHandler for IqGetDiscoItems {
    fn process(
        self: Box<Self>,
        conn: &mut XmppConnection,
        id: String,
        from: Option<xmpp_parsers::Jid>,
    ) -> xmpp_parsers::iq::Iq {
        info!("Got disco items query {} from {:?}", id, from);
        stanzas::make_disco_items_result(id, conn.state.client.jid.clone(), from)
    }
}
lazy_static! {
    static ref INCOMING: element_processor::Processor<XmppConnection, bool, xmpp_parsers::Element> = {
        let mut incoming = element_processor::Processor::new(&|_, e| {
            warn!("Unknown stanza {}", String::from(&e));
            true
        });
        incoming.register(&XmppConnection::incoming_iq_processing);
        incoming.register(&XmppConnection::incoming_presence_processing);
        incoming.register(&XmppConnection::incoming_message_processing);
        incoming
    };
    static ref INCOMING_IQ_SET: element_processor::Processor<XmppConnection, Box<dyn IqRequestHandler>, xmpp_parsers::Element> = {
        let mut iq_set =
            element_processor::Processor::new(&|_conn: &mut XmppConnection, element| {
                Box::new(IqRequestUnknown {
                    element,
                    type_: "set",
                }) as Box<dyn IqRequestHandler>
            });
        iq_set.register(&XmppConnection::incoming_iq_processing_set_roster);
        iq_set
    };
    static ref INCOMING_IQ_GET: element_processor::Processor<XmppConnection, Box<dyn IqRequestHandler>, xmpp_parsers::Element> = {
        let mut iq_get =
            element_processor::Processor::new(&|_conn: &mut XmppConnection, element| {
                Box::new(IqRequestUnknown {
                    element,
                    type_: "get",
                }) as Box<dyn IqRequestHandler>
            });
        iq_get.register(&XmppConnection::incoming_iq_processing_get_ping);
        iq_get.register(&XmppConnection::incoming_iq_processing_get_disco_info);
        iq_get.register(&XmppConnection::incoming_iq_processing_get_disco_items);
        iq_get.register(&XmppConnection::incoming_iq_processing_get_version);
        iq_get
    };
}
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) => INCOMING.process(self, stanza.clone()),
            Event::Online => true,
            e => {
                warn!("Unexpected event {:?}", e);
                false
            }
        }
    }
    /// Process roster push
    /// see RFC 6212 2.1.6. Roster Push
    fn incoming_iq_processing_set_roster(
        &mut self,
        roster: xmpp_parsers::roster::Roster,
    ) -> Box<dyn IqRequestHandler> {
        for i in roster.items {
            if let Some(ref mut rdata) = self.state.data.roster.get_mut(&i.jid) {
                info!("Update {} in roster", i.jid);
                rdata.0 = i.subscription;
                rdata.1 = i.ask;
            } else {
                info!("Add {} to roster", i.jid);
                self.state
                    .data
                    .roster
                    .insert(i.jid.clone(), (i.subscription, i.ask));
            }
            self.process_jid(&i.jid);
        }
        Box::new(IqSetRoster {})
    }
    /// Enforce to answer to IQ "set"
    fn incoming_iq_processing_set(
        &mut self,
        id: String,
        from: Option<xmpp_parsers::Jid>,
        element: minidom::Element,
    ) -> xmpp_parsers::iq::Iq {
        INCOMING_IQ_SET
            .process(self, element)
            .process(self, id, from)
    }
    /// Process ping request
    /// see XEP-0199: XMPP Ping
    fn incoming_iq_processing_get_ping(
        &mut self,
        _ping: xmpp_parsers::ping::Ping,
    ) -> Box<dyn IqRequestHandler> {
        Box::new(IqGetPing {})
    }
    /// Process disco query
    /// see XEP-0030: Service Discovery
    fn incoming_iq_processing_get_disco_info(
        &mut self,
        disco: xmpp_parsers::disco::DiscoInfoQuery,
    ) -> Box<dyn IqRequestHandler> {
        if let Some(ref node) = disco.node {
            warn!("Unsupported node {}", node);
            Box::new(IqRequestUnknown {
                element: disco.into(),
                type_: "get",
            })
        } else {
            Box::new(IqGetDiscoInfo {})
        }
    }
    /// Process disco items query
    /// see XEP-0030: Service Discovery
    fn incoming_iq_processing_get_disco_items(
        &mut self,
        disco: xmpp_parsers::disco::DiscoItemsQuery,
    ) -> Box<dyn IqRequestHandler> {
        if let Some(ref node) = disco.node {
            warn!("Unsupported node {}", node);
            Box::new(IqRequestUnknown {
                element: disco.into(),
                type_: "get",
            })
        } else {
            Box::new(IqGetDiscoItems {})
        }
    }
    /// Process version query
    /// see XEP-0092: Software Version
    fn incoming_iq_processing_get_version(
        &mut self,
        _version: xmpp_parsers::version::VersionQuery,
    ) -> Box<dyn IqRequestHandler> {
        Box::new(IqGetVersion {})
    }
    /// Enforce to answer to IQ "get"
    fn incoming_iq_processing_get(
        &mut self,
        id: String,
        from: Option<xmpp_parsers::Jid>,
        element: minidom::Element,
    ) -> xmpp_parsers::iq::Iq {
        INCOMING_IQ_GET
            .process(self, element)
            .process(self, id, from)
    }
    fn incoming_iq_processing(&mut self, iq: xmpp_parsers::iq::Iq) -> bool {
        match iq.payload {
            xmpp_parsers::iq::IqType::Set(element) => {
                let iq_answer = self.incoming_iq_processing_set(iq.id, iq.from, element);
                self.state.data.send_queue.push_back(iq_answer.into());
            }
            xmpp_parsers::iq::IqType::Error(e) => {
                if let Some((_, handler)) = self.state.data.pending_ids.remove_entry(&iq.id) {
                    return handler.1.error(self, e);
                }
                error!("iq error: {:?}", e);
                return false;
            }
            xmpp_parsers::iq::IqType::Get(element) => {
                let iq_answer = self.incoming_iq_processing_get(iq.id, iq.from, element);
                self.state.data.send_queue.push_back(iq_answer.into());
            }
            xmpp_parsers::iq::IqType::Result(opt_element) => {
                if let Some((_, handler)) = self.state.data.pending_ids.remove_entry(&iq.id) {
                    return handler.1.result(self, opt_element);
                }
                warn!(
                    "Unwanted iq result id {} from {:?}: {:?}",
                    iq.id,
                    iq.from,
                    opt_element.map(|e| String::from(&e))
                );
            }
        }
        true
    }
    fn incoming_presence_processing(&mut self, presence: xmpp_parsers::presence::Presence) -> bool {
        if presence.from.as_ref() == Some(&self.state.client.jid) {
            info!("Self-presence accepted");
            self.state.data.self_presence = true;
        } else {
            warn!("Incoming presence stanza: {:?}", presence);
        }
        true
    }
    fn incoming_message_processing(&mut self, message: xmpp_parsers::message::Message) -> bool {
        for payload in message.payloads.iter() {
            use std::convert::TryInto;
            if let Some(_delay) =
                payload.clone().try_into().ok() as Option<xmpp_parsers::delay::Delay>
            {
                return true; // ignore delayed messages
            }
        }
        warn!("Incoming message stanza: {:?}", message);
        true
    }
    /// 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)| {
                // ToDo: check timeouts if iqs
                let XmppConnection {
                    state: XmppState { client, mut data },
                    account,
                } = xmpp;
                if let Some(send_element) = data.send_queue.pop_front() {
                    use tokio::prelude::Sink;
                    info!("Sending {}", String::from(&send_element));
                    Box::new(
                        client
                            .send(Packet::Stanza(send_element))
                            .select2(stop_future)
                            .then(move |r| match r {
                                Ok(Either::A((client, b))) => {
                                    Box::new(future::ok(future::Loop::Continue((
                                        XmppConnection {
                                            state: XmppState { client, data },
                                            account,
                                        },
                                        b,
                                        stop_condition,
                                    ))))
                                        as Box<dyn Future<Item = _, Error = _>>
                                }
                                Ok(Either::B((t, a))) => Box::new(a.then(|r| match r {
                                    Ok(client) => future::ok(future::Loop::Break((
                                        XmppConnection {
                                            state: XmppState { client, data },
                                            account,
                                        },
                                        Ok(Either::B(t)),
                                    ))),
                                    Err(se) => {
                                        warn!("XMPP sending error: {}", se);
                                        future::err((account, Ok(Either::B(t))))
                                    }
                                })),
                                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: {}", String::from(&s));
                Ok(false)
            }
            _ => {
                error!("Disconnected while online");
                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... {}", String::from(&get_roster));
        data.pending_ids.insert(
            id_init_roster.clone(),
            (
                Instant::now() + Duration::from_secs(60),
                Box::new(InitRosterIqHandler {}),
            ),
        );
        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, _| Ok(conn.state.data.roster_init), stop_future)
                .map_err(|(account, _)| account)
                .and_then(|(conn, r)| match r {
                    Ok(Either::A(_)) => future::ok(conn),
                    Ok(Either::B(_)) => future::err(conn.account),
                    Err(_e) => future::err(conn.account),
                })
            })
    }
    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... {}", String::from(&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, _| Ok(conn.state.data.self_presence),
                    stop_future,
                )
                .map_err(|(account, _)| account)
                .and_then(|(conn, r)| match r {
                    Ok(Either::A(_)) => future::ok(conn),
                    Ok(Either::B(_)) => future::err(conn.account),
                    Err(_e) => future::err(conn.account),
                })
            })
    }
    fn process_jid(&mut self, xmpp_to: &xmpp_parsers::Jid) {
        if let Some(ref mut mailbox) = self.state.data.outgoing_mailbox.get_mut(xmpp_to) {
            if !mailbox.is_empty() {
                if let Some(ref mut rdata) = self.state.data.roster.get_mut(xmpp_to) {
                    info!("Jid {} in roster", xmpp_to);
                    let sub_to = match rdata.0 {
                        xmpp_parsers::roster::Subscription::To => true,
                        xmpp_parsers::roster::Subscription::Both => true,
                        _ => false,
                    };
                    if sub_to {
                        info!("Subscribed to {}", xmpp_to);
                        self.state.data.send_queue.extend(
                            mailbox.drain(..).map(|message| {
                                stanzas::make_chat_message(xmpp_to.clone(), message)
                            }),
                        );
                    } else if rdata.1 == xmpp_parsers::roster::Ask::None {
                        info!("Not subscribed to {}", xmpp_to);
                        self.state
                            .data
                            .send_queue
                            .push_back(stanzas::make_ask_subscribe(xmpp_to.clone()));
                    }
                    let sub_from = match rdata.0 {
                        xmpp_parsers::roster::Subscription::From => true,
                        xmpp_parsers::roster::Subscription::Both => true,
                        _ => false,
                    };
                    if !sub_from {
                        info!("Not subscription from {}", xmpp_to);
                        self.state
                            .data
                            .send_queue
                            .push_back(stanzas::make_allow_subscribe(xmpp_to.clone()));
                    }
                } else {
                    info!("Jid {} not in roster", xmpp_to);
                    self.state.data.counter += 1;
                    let id_add_roster = format!("id_add_roster{}", self.state.data.counter);
                    let add_roster = stanzas::make_add_roster(&id_add_roster, xmpp_to.clone());
                    info!("Adding jid {} to roster id {}", xmpp_to, id_add_roster);
                    self.state.data.pending_ids.insert(
                        id_add_roster,
                        (
                            Instant::now() + Duration::from_secs(60),
                            Box::new(AddRosterIqHandler {
                                jid: xmpp_to.clone(),
                            }),
                        ),
                    );
                    self.state.data.send_queue.push_back(add_roster);
                }
            }
        }
    }
    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);
                self.state.data.pending_ids.insert(
                    id_ping,
                    (
                        Instant::now() + Duration::from_secs(30),
                        Box::new(PingIqHandler {}),
                    ),
                );
            }
            XmppCommand::TimeoutCleanup => {
                let now = Instant::now();
                let timeouted: Vec<String> = self
                    .state
                    .data
                    .pending_ids
                    .iter()
                    .filter_map(|(id, (timeout, _))| {
                        if now >= *timeout {
                            Some(id.to_string())
                        } else {
                            None
                        }
                    })
                    .collect();
                let mut correct = true;
                timeouted.into_iter().for_each(|id| {
                    if let Some((_, handler)) = self.state.data.pending_ids.remove(&id) {
                        correct &= handler.timeout(&mut self);
                    }
                })
            }
        }
    }
    pub fn shutdown(self) -> impl Future<Item = (), Error = failure::Error> {
        info!("Shutdown connection");
        let XmppConnection { account, state } = self;
        stream::iter_ok(
            state
                .data
                .mucs
                .values()
                .map(std::clone::Clone::clone)
                .collect::<Vec<_>>(),
        )
        .fold(state, move |XmppState { client, data }, muc_jid| {
            let muc_presence =
                stanzas::make_muc_presence_leave(account.jid.clone(), muc_jid.clone());
            info!(
                "Sending muc leave presence... {}",
                String::from(&muc_presence)
            );
            use tokio::prelude::Sink;
            client
                .send(Packet::Stanza(muc_presence))
                .map_err(|e| {
                    error!("Error on send muc presence: {}", e);
                    e
                })
                .and_then(|client| future::ok(XmppState { client, data }))
        })
        .map(|_| ())
    }
    fn enter_mucs<F, E>(
        self,
        _stop_future: F,
    ) -> impl Future<Item = Self, Error = std::rc::Rc<config::Account>>
    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... {}", String::from(&muc_presence));
                let account4 = account2.clone();
                use tokio::prelude::Sink;
                client
                    .send(Packet::Stanza(muc_presence))
                    .map_err(|e| {
                        error!("Error on send muc presence: {}", e);
                        account4
                    })
                    .and_then(|client| {
                        data.mucs.insert(muc_jid.0, muc_jid.1);
                        future::ok(XmppState { client, data })
                    })
            })
            .map(|state| XmppConnection {
                account: account3,
                state,
            })
    }
}
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;
/// trait of processing iq
/// each function consumes handlers and
/// returns false if connection should be reset
trait IqHandler {
    /// process result
    fn result(
        self: Box<Self>,
        conn: &mut XmppConnection,
        opt_element: Option<xmpp_parsers::Element>,
    ) -> bool;
    /// process error
    fn error(
        self: Box<Self>,
        conn: &mut XmppConnection,
        error: xmpp_parsers::stanza_error::StanzaError,
    ) -> bool;
    /// process tmeout
    fn timeout(self: Box<Self>, conn: &mut XmppConnection) -> bool;
}
struct AddRosterIqHandler {
    jid: xmpp_parsers::Jid,
}
impl IqHandler for AddRosterIqHandler {
    fn result(
        self: Box<Self>,
        conn: &mut XmppConnection,
        opt_element: Option<xmpp_parsers::Element>,
    ) -> bool {
        match opt_element {
            Some(element) => {
                warn!(
                    "Wrong payload when adding {} to roster: {}",
                    self.jid,
                    String::from(&element)
                );
            }
            None => {
                if conn.state.data.roster.contains_key(&self.jid) {
                    info!("Jid {} updated to roster", self.jid);
                } else {
                    info!("Jid {} added in roster", self.jid);
                    conn.state.data.roster.insert(
                        self.jid.clone(),
                        (
                            xmpp_parsers::roster::Subscription::None,
                            xmpp_parsers::roster::Ask::None,
                        ),
                    );
                }
                conn.process_jid(&self.jid);
            }
        }
        true
    }
    fn error(
        self: Box<Self>,
        _conn: &mut XmppConnection,
        _error: xmpp_parsers::stanza_error::StanzaError,
    ) -> bool {
        true
    }
    fn timeout(self: Box<Self>, _conn: &mut XmppConnection) -> bool {
        true // ignore
    }
}
#[derive(Default)]
struct XmppData {
    /// known roster data
    roster: HashMap<
        xmpp_parsers::Jid,
        (
            xmpp_parsers::roster::Subscription,
            xmpp_parsers::roster::Ask,
        ),
    >,
    /// ids counter
    counter: usize,
    /// 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>,
    /// map from iq's id to handler of this type of iqs
    pending_ids: HashMap<String, Box<dyn IqHandler>>,
}
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 {}", String::from(&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
            }
        }
    }
    /// Enforce to answer to IQ "set"
    fn incoming_iq_processing_set(
        &mut self,
        id: String,
        from: Option<xmpp_parsers::Jid>,
        element: minidom::Element,
    ) -> xmpp_parsers::iq::Iq {
        use std::convert::TryInto;
        if let Some(roster) =
            element.clone().try_into().ok() as Option<xmpp_parsers::roster::Roster>
        {
            // RFC 6212 2.1.6. Roster Push
            for i in roster.items {
                if let Some(ref mut rdata) = self.state.data.roster.get_mut(&i.jid) {
                    info!("Update {} in roster", i.jid);
                    rdata.0 = i.subscription;
                    rdata.1 = i.ask;
                } else {
                    info!("Add {} to roster", i.jid);
                    self.state
                        .data
                        .roster
                        .insert(i.jid.clone(), (i.subscription, i.ask));
                }
                self.process_jid(&i.jid);
            }
            return stanzas::make_roster_push_answer(id, self.state.client.jid.clone(), from);
        }
        warn!(
            "Unsupported IQ set request from {:?}: {}",
            from,
            String::from(&element)
        );
        stanzas::make_iq_unsupported_error(id, self.state.client.jid.clone(), from)
    }
    /// Enforce to answer to IQ "get"
    fn incoming_iq_processing_get(
        &mut self,
        id: String,
        from: Option<xmpp_parsers::Jid>,
        element: minidom::Element,
    ) -> xmpp_parsers::iq::Iq {
        use std::convert::TryInto;
        if let Some(_ping) = element.clone().try_into().ok() as Option<xmpp_parsers::ping::Ping> {
            return stanzas::make_pong(&id, self.state.client.jid.clone(), from);
        }
        warn!(
            "Unsupported IQ get request from {:?}: {}",
            from,
            String::from(&element)
        );
        stanzas::make_iq_unsupported_error(id, self.state.client.jid.clone(), from)
    }
    fn incoming_iq_processing(&mut self, iq: xmpp_parsers::iq::Iq) -> bool {
        match iq.payload {
            xmpp_parsers::iq::IqType::Set(element) => {
                let iq_answer = self.incoming_iq_processing_set(iq.id, iq.from, element);
                self.state.data.send_queue.push_back(iq_answer.into());
            }
            xmpp_parsers::iq::IqType::Error(e) => {
                if let Some((_, handler)) = self.state.data.pending_ids.remove_entry(&iq.id) {
                    return handler.error(self, e);
                }
                error!("iq error: {:?}", e);
                return false;
            }
            xmpp_parsers::iq::IqType::Get(element) => {
                let iq_answer = self.incoming_iq_processing_get(iq.id, iq.from, element);
                self.state.data.send_queue.push_back(iq_answer.into());
            }
            xmpp_parsers::iq::IqType::Result(opt_element) => {
                if let Some((_, handler)) = self.state.data.pending_ids.remove_entry(&iq.id) {
                    return handler.result(self, opt_element);
                }
                warn!(
                    "Unwanted iq result id {} from {:?}: {:?}",
                    iq.id,
                    iq.from,
                    opt_element.map(|e| String::from(&e))
                );
            }
        }
        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 {}", String::from(&send_element));
                    Box::new(
                        client
                            .send(Packet::Stanza(send_element))
                            .select2(stop_future)
                            .then(move |r| match r {
                                Ok(Either::A((client, b))) => {
                                    Box::new(future::ok(future::Loop::Continue((
                                        XmppConnection {
                                            state: XmppState { client, data },
                                            account,
                                        },
                                        b,
                                        stop_condition,
                                    ))))
                                        as Box<dyn Future<Item = _, Error = _>>
                                }
                                Ok(Either::B((t, a))) => Box::new(a.then(|r| match r {
                                    Ok(client) => future::ok(future::Loop::Break((
                                        XmppConnection {
                                            state: XmppState { client, data },
                                            account,
                                        },
                                        Ok(Either::B(t)),
                                    ))),
                                    Err(se) => {
                                        warn!("XMPP sending error: {}", se);
                                        future::err((account, Ok(Either::B(t))))
                                    }
                                })),
                                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: {}", String::from(&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());
                    info!("Adding jid {} to roster id {}", xmpp_to, id_add_roster);
                    self.state.data.pending_ids.insert(
                        id_add_roster,
                        Box::new(AddRosterIqHandler {
                            jid: xmpp_to.clone(),
                        }),
                    );
                    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... {}",
                String::from(&muc_presence)
            );
            use tokio::prelude::Sink;
            client
                .send(Packet::Stanza(muc_presence))
                .map_err(|e| {
                    error!("Error on send muc presence: {}", e);
                    e
                })
                .and_then(|client| future::ok(XmppState { client, data }))
        })
        .map(|_| ())
    }
    fn enter_mucs<F, E>(
        self,
        _stop_future: F,
    ) -> impl Future<Item = Self, Error = std::rc::Rc<config::Account>>
    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... {}", String::from(&muc_presence));
                let account4 = account2.clone();
                use tokio::prelude::Sink;
                client
                    .send(Packet::Stanza(muc_presence))
                    .map_err(|e| {
                        error!("Error on send muc presence: {}", e);
                        account4
                    })
                    .and_then(|client| {
                        data.mucs.insert(muc_jid.0, muc_jid.1);
                        future::ok(XmppState { client, data })
                    })
            })
            .map(|state| XmppConnection {
                account: account3,
                state,
            })
    }
}
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, mut data },
        } = self;
        use tokio::prelude::Sink;
        data.counter += 1;
        let id_presence = format!("id_init_presence{}", data.counter);
        let presence = stanzas::make_init_presence(id_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,
            })
    }
}
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 std::time::{Duration, Instant};
use super::stanzas;
use super::element_processor;
use crate::config;
#[derive(Debug)]
pub enum XmppCommand {
    /// Send message to someone by jid
    Chat {
        xmpp_to: xmpp_parsers::Jid,
        message: String,
    },
    /// Send message to MUC
    Chatroom { muc_id: String, message: String },
    /// Send ping request to the server to test connection
    Ping,
    /// Check iq requests if some have expired timeouts
    TimeoutCleanup,
}
/// trait of processing iq
/// each function consumes handlers and
/// returns false if connection should be reset
trait IqHandler {
    /// process result
    fn result(
        self: Box<Self>,
        conn: &mut XmppConnection,
        opt_element: Option<xmpp_parsers::Element>,
    ) -> bool;
    /// process error
    fn error(
        self: Box<Self>,
        conn: &mut XmppConnection,
        error: xmpp_parsers::stanza_error::StanzaError,
    ) -> bool;
    /// process tmeout
    fn timeout(self: Box<Self>, conn: &mut XmppConnection) -> bool;
}
struct AddRosterIqHandler {
    jid: xmpp_parsers::Jid,
}
impl IqHandler for AddRosterIqHandler {
    fn result(
        self: Box<Self>,
        conn: &mut XmppConnection,
        opt_element: Option<xmpp_parsers::Element>,
    ) -> bool {
        match opt_element {
            Some(element) => {
                warn!(
                    "Wrong payload when adding {} to roster: {}",
                    self.jid,
                    String::from(&element)
                );
            }
            None => {
                if conn.state.data.roster.contains_key(&self.jid) {
                    info!("Jid {} updated to roster", self.jid);
                } else {
                    info!("Jid {} added in roster", self.jid);
                    conn.state.data.roster.insert(
                        self.jid.clone(),
                        (
                            xmpp_parsers::roster::Subscription::None,
                            xmpp_parsers::roster::Ask::None,
                        ),
                    );
                }
                conn.process_jid(&self.jid);
            }
        }
        true
    }
    fn error(
        self: Box<Self>,
        _conn: &mut XmppConnection,
        _error: xmpp_parsers::stanza_error::StanzaError,
    ) -> bool {
        true
    }
    fn timeout(self: Box<Self>, _conn: &mut XmppConnection) -> bool {
        true // ignore
    }
}
struct PingIqHandler {}
impl IqHandler for PingIqHandler {
    fn result(
        self: Box<Self>,
        _conn: &mut XmppConnection,
        _opt_element: Option<xmpp_parsers::Element>,
    ) -> bool {
        info!("ping successed");
        true
    }
    fn error(
        self: Box<Self>,
        _conn: &mut XmppConnection,
        _error: xmpp_parsers::stanza_error::StanzaError,
    ) -> bool {
        false
    }
    fn timeout(self: Box<Self>, _conn: &mut XmppConnection) -> bool {
        false
    }
}
struct InitRosterIqHandler {}
impl IqHandler for InitRosterIqHandler {
    fn result(
        self: Box<Self>,
        conn: &mut XmppConnection,
        opt_element: Option<xmpp_parsers::Element>,
    ) -> bool {
        if let Some(result) = opt_element {
            use std::convert::TryInto;
            match result.try_into() as Result<xmpp_parsers::roster::Roster, _> {
                Ok(roster) => {
                    conn.state.data.roster_init = true;
                    conn.state.data.roster.clear();
                    info!("Got first roster:");
                    for i in roster.items {
                        info!(" >>> {:?}", i);
                        conn.state
                            .data
                            .roster
                            .insert(i.jid, (i.subscription, i.ask));
                    }
                    true
                }
                Err(e) => {
                    error!("Cann't parse roster: {}", e);
                    false
                }
            }
        } else {
            error!("No roster responded");
            false
        }
    }
    fn error(
        self: Box<Self>,
        _conn: &mut XmppConnection,
        _error: xmpp_parsers::stanza_error::StanzaError,
    ) -> bool {
        false
    }
    fn timeout(self: Box<Self>, _conn: &mut XmppConnection) -> bool {
        false
    }
}
#[derive(Default)]
struct XmppData {
    /// known roster data
    roster: HashMap<
        xmpp_parsers::Jid,
        (
            xmpp_parsers::roster::Subscription,
            xmpp_parsers::roster::Ask,
        ),
    >,
    /// if roster was initialized
    /// ToDo: remove it as it is used only for initialization
    roster_init: bool,
    /// if self-presence accepted
    /// ToDo: remove it as it is used only for initialization
    self_presence: bool,
    /// ids counter
    counter: usize,
    /// 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>,
    /// map from iq's id to handler of this type of iqs
    pending_ids: HashMap<String, (Instant, Box<dyn IqHandler>)>,
}
struct XmppState {
    client: Client,
    data: XmppData,
}
pub struct XmppConnection {
    account: std::rc::Rc<config::Account>,
    state: XmppState,
}
trait IqRequestHandler {
    fn process(
        self: Box<Self>,
        conn: &mut XmppConnection,
        id: String,
        from: Option<xmpp_parsers::Jid>,
    ) -> xmpp_parsers::iq::Iq;
}
struct IqRequestUnknown {
    element: xmpp_parsers::Element,
    type_: &'static str,
}
impl IqRequestHandler for IqRequestUnknown {
    fn process(
        self: Box<Self>,
        conn: &mut XmppConnection,
        id: String,
        from: Option<xmpp_parsers::Jid>,
    ) -> xmpp_parsers::iq::Iq {
        warn!(
            "Unsupported IQ {} request from {:?}: {}",
            self.type_,
            from,
            String::from(&self.element)
        );
        stanzas::make_iq_unsupported_error(id, conn.state.client.jid.clone(), from)
    }
}
struct IqSetRoster {}
impl IqRequestHandler for IqSetRoster {
    fn process(
        self: Box<Self>,
        conn: &mut XmppConnection,
        id: String,
        from: Option<xmpp_parsers::Jid>,
    ) -> xmpp_parsers::iq::Iq {
        info!("Got roster push {} from {:?}", id, from);
        stanzas::make_roster_push_answer(id, conn.state.client.jid.clone(), from)
    }
}
struct IqGetPing {}
impl IqRequestHandler for IqGetPing {
    fn process(
        self: Box<Self>,
        conn: &mut XmppConnection,
        id: String,
        from: Option<xmpp_parsers::Jid>,
    ) -> xmpp_parsers::iq::Iq {
        info!("Got ping {} from {:?}", id, from);
        stanzas::make_pong(&id, conn.state.client.jid.clone(), from)
    }
}
lazy_static! {
    static ref INCOMING: element_processor::Processor<XmppConnection, bool, xmpp_parsers::Element> = {
        let mut incoming = element_processor::Processor::new(&|_, e| {
            warn!("Unknown stanza {}", String::from(&e));
            true
        });
        incoming.register(&XmppConnection::incoming_iq_processing);
        incoming.register(&XmppConnection::incoming_presence_processing);
        incoming.register(&XmppConnection::incoming_message_processing);
        incoming
    };
    static ref INCOMING_IQ_SET: element_processor::Processor<XmppConnection, Box<dyn IqRequestHandler>, xmpp_parsers::Element> = {
        let mut iq_set =
            element_processor::Processor::new(&|_conn: &mut XmppConnection, element| {
                Box::new(IqRequestUnknown {
                    element,
                    type_: "set",
                }) as Box<dyn IqRequestHandler>
            });
        iq_set.register(&XmppConnection::incoming_iq_processing_set_roster);
        iq_set
    };
    static ref INCOMING_IQ_GET: element_processor::Processor<XmppConnection, Box<dyn IqRequestHandler>, xmpp_parsers::Element> = {
        let mut iq_get =
            element_processor::Processor::new(&|_conn: &mut XmppConnection, element| {
                Box::new(IqRequestUnknown {
                    element,
                    type_: "get",
                }) as Box<dyn IqRequestHandler>
            });
        iq_get.register(&XmppConnection::incoming_iq_processing_get_ping);
        iq_get
    };
}
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) => INCOMING.process(self, stanza.clone()),
            Event::Online => true,
            e => {
                warn!("Unexpected event {:?}", e);
                false
            }
        }
    }
    /// Process roster push
    /// see RFC 6212 2.1.6. Roster Push
    fn incoming_iq_processing_set_roster(
        &mut self,
        roster: xmpp_parsers::roster::Roster,
    ) -> Box<dyn IqRequestHandler> {
        for i in roster.items {
            if let Some(ref mut rdata) = self.state.data.roster.get_mut(&i.jid) {
                info!("Update {} in roster", i.jid);
                rdata.0 = i.subscription;
                rdata.1 = i.ask;
            } else {
                info!("Add {} to roster", i.jid);
                self.state
                    .data
                    .roster
                    .insert(i.jid.clone(), (i.subscription, i.ask));
            }
            self.process_jid(&i.jid);
        }
        Box::new(IqSetRoster {})
    }
    /// Enforce to answer to IQ "set"
    fn incoming_iq_processing_set(
        &mut self,
        id: String,
        from: Option<xmpp_parsers::Jid>,
        element: minidom::Element,
    ) -> xmpp_parsers::iq::Iq {
        INCOMING_IQ_SET
            .process(self, element)
            .process(self, id, from)
    }
    /// Process ping request
    /// see XEP-0199: XMPP Ping
    fn incoming_iq_processing_get_ping(
        &mut self,
        _ping: xmpp_parsers::ping::Ping,
    ) -> Box<dyn IqRequestHandler> {
        Box::new(IqGetPing {})
    }
    /// Enforce to answer to IQ "get"
    fn incoming_iq_processing_get(
        &mut self,
        id: String,
        from: Option<xmpp_parsers::Jid>,
        element: minidom::Element,
    ) -> xmpp_parsers::iq::Iq {
        INCOMING_IQ_GET
            .process(self, element)
            .process(self, id, from)
    }
    fn incoming_iq_processing(&mut self, iq: xmpp_parsers::iq::Iq) -> bool {
        match iq.payload {
            xmpp_parsers::iq::IqType::Set(element) => {
                let iq_answer = self.incoming_iq_processing_set(iq.id, iq.from, element);
                self.state.data.send_queue.push_back(iq_answer.into());
            }
            xmpp_parsers::iq::IqType::Error(e) => {
                if let Some((_, handler)) = self.state.data.pending_ids.remove_entry(&iq.id) {
                    return handler.1.error(self, e);
                }
                error!("iq error: {:?}", e);
                return false;
            }
            xmpp_parsers::iq::IqType::Get(element) => {
                let iq_answer = self.incoming_iq_processing_get(iq.id, iq.from, element);
                self.state.data.send_queue.push_back(iq_answer.into());
            }
            xmpp_parsers::iq::IqType::Result(opt_element) => {
                if let Some((_, handler)) = self.state.data.pending_ids.remove_entry(&iq.id) {
                    return handler.1.result(self, opt_element);
                }
                warn!(
                    "Unwanted iq result id {} from {:?}: {:?}",
                    iq.id,
                    iq.from,
                    opt_element.map(|e| String::from(&e))
                );
            }
        }
        true
    }
    fn incoming_presence_processing(&mut self, presence: xmpp_parsers::presence::Presence) -> bool {
        if presence.from.as_ref() == Some(&self.state.client.jid) {
            info!("Self-presence accepted");
            self.state.data.self_presence = true;
        } else {
            warn!("Incoming presence stanza: {:?}", presence);
        }
        true
    }
    fn incoming_message_processing(&mut self, message: xmpp_parsers::message::Message) -> bool {
        for payload in message.payloads.iter() {
            use std::convert::TryInto;
            if let Some(_delay) =
                payload.clone().try_into().ok() as Option<xmpp_parsers::delay::Delay>
            {
                return true; // ignore delayed messages
            }
        }
        warn!("Incoming message stanza: {:?}", message);
        true
    }
    /// 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)| {
                // ToDo: check timeouts if iqs
                let XmppConnection {
                    state: XmppState { client, mut data },
                    account,
                } = xmpp;
                if let Some(send_element) = data.send_queue.pop_front() {
                    use tokio::prelude::Sink;
                    info!("Sending {}", String::from(&send_element));
                    Box::new(
                        client
                            .send(Packet::Stanza(send_element))
                            .select2(stop_future)
                            .then(move |r| match r {
                                Ok(Either::A((client, b))) => {
                                    Box::new(future::ok(future::Loop::Continue((
                                        XmppConnection {
                                            state: XmppState { client, data },
                                            account,
                                        },
                                        b,
                                        stop_condition,
                                    ))))
                                        as Box<dyn Future<Item = _, Error = _>>
                                }
                                Ok(Either::B((t, a))) => Box::new(a.then(|r| match r {
                                    Ok(client) => future::ok(future::Loop::Break((
                                        XmppConnection {
                                            state: XmppState { client, data },
                                            account,
                                        },
                                        Ok(Either::B(t)),
                                    ))),
                                    Err(se) => {
                                        warn!("XMPP sending error: {}", se);
                                        future::err((account, Ok(Either::B(t))))
                                    }
                                })),
                                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: {}", String::from(&s));
                Ok(false)
            }
            _ => {
                error!("Disconnected while online");
                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... {}", String::from(&get_roster));
        data.pending_ids.insert(
            id_init_roster.clone(),
            (
                Instant::now() + Duration::from_secs(60),
                Box::new(InitRosterIqHandler {}),
            ),
        );
        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, _| Ok(conn.state.data.roster_init), stop_future)
                .map_err(|(account, _)| account)
                .and_then(|(conn, r)| match r {
                    Ok(Either::A(_)) => future::ok(conn),
                    Ok(Either::B(_)) => future::err(conn.account),
                    Err(_e) => future::err(conn.account),
                })
            })
    }
    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... {}", String::from(&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, _| Ok(conn.state.data.self_presence),
                    stop_future,
                )
                .map_err(|(account, _)| account)
                .and_then(|(conn, r)| match r {
                    Ok(Either::A(_)) => future::ok(conn),
                    Ok(Either::B(_)) => future::err(conn.account),
                    Err(_e) => future::err(conn.account),
                })
            })
    }
    fn process_jid(&mut self, xmpp_to: &xmpp_parsers::Jid) {
        if let Some(ref mut mailbox) = self.state.data.outgoing_mailbox.get_mut(xmpp_to) {
            if !mailbox.is_empty() {
                if let Some(ref mut rdata) = self.state.data.roster.get_mut(xmpp_to) {
                    info!("Jid {} in roster", xmpp_to);
                    let sub_to = match rdata.0 {
                        xmpp_parsers::roster::Subscription::To => true,
                        xmpp_parsers::roster::Subscription::Both => true,
                        _ => false,
                    };
                    if sub_to {
                        info!("Subscribed to {}", xmpp_to);
                        self.state.data.send_queue.extend(
                            mailbox.drain(..).map(|message| {
                                stanzas::make_chat_message(xmpp_to.clone(), message)
                            }),
                        );
                    } else if rdata.1 == xmpp_parsers::roster::Ask::None {
                        info!("Not subscribed to {}", xmpp_to);
                        self.state
                            .data
                            .send_queue
                            .push_back(stanzas::make_ask_subscribe(xmpp_to.clone()));
                    }
                    let sub_from = match rdata.0 {
                        xmpp_parsers::roster::Subscription::From => true,
                        xmpp_parsers::roster::Subscription::Both => true,
                        _ => false,
                    };
                    if !sub_from {
                        info!("Not subscription from {}", xmpp_to);
                        self.state
                            .data
                            .send_queue
                            .push_back(stanzas::make_allow_subscribe(xmpp_to.clone()));
                    }
                } else {
                    info!("Jid {} not in roster", xmpp_to);
                    self.state.data.counter += 1;
                    let id_add_roster = format!("id_add_roster{}", self.state.data.counter);
                    let add_roster = stanzas::make_add_roster(&id_add_roster, xmpp_to.clone());
                    info!("Adding jid {} to roster id {}", xmpp_to, id_add_roster);
                    self.state.data.pending_ids.insert(
                        id_add_roster,
                        (
                            Instant::now() + Duration::from_secs(60),
                            Box::new(AddRosterIqHandler {
                                jid: xmpp_to.clone(),
                            }),
                        ),
                    );
                    self.state.data.send_queue.push_back(add_roster);
                }
            }
        }
    }
    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);
                self.state.data.pending_ids.insert(
                    id_ping,
                    (
                        Instant::now() + Duration::from_secs(30),
                        Box::new(PingIqHandler {}),
                    ),
                );
            }
            XmppCommand::TimeoutCleanup => {
                let now = Instant::now();
                let timeouted: Vec<String> = self
                    .state
                    .data
                    .pending_ids
                    .iter()
                    .filter_map(|(id, (timeout, _))| {
                        if now >= *timeout {
                            Some(id.to_string())
                        } else {
                            None
                        }
                    })
                    .collect();
                let mut correct = true;
                timeouted.into_iter().for_each(|id| {
                    if let Some((_, handler)) = self.state.data.pending_ids.remove(&id) {
                        correct &= handler.timeout(&mut self);
                    }
                })
            }
        }
    }
    pub fn shutdown(self) -> impl Future<Item = (), Error = failure::Error> {
        info!("Shutdown connection");
        let XmppConnection { account, state } = self;
        stream::iter_ok(
            state
                .data
                .mucs
                .values()
                .map(std::clone::Clone::clone)
                .collect::<Vec<_>>(),
        )
        .fold(state, move |XmppState { client, data }, muc_jid| {
            let muc_presence =
                stanzas::make_muc_presence_leave(account.jid.clone(), muc_jid.clone());
            info!(
                "Sending muc leave presence... {}",
                String::from(&muc_presence)
            );
            use tokio::prelude::Sink;
            client
                .send(Packet::Stanza(muc_presence))
                .map_err(|e| {
                    error!("Error on send muc presence: {}", e);
                    e
                })
                .and_then(|client| future::ok(XmppState { client, data }))
        })
        .map(|_| ())
    }
    fn enter_mucs<F, E>(
        self,
        _stop_future: F,
    ) -> impl Future<Item = Self, Error = std::rc::Rc<config::Account>>
    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... {}", String::from(&muc_presence));
                let account4 = account2.clone();
                use tokio::prelude::Sink;
                client
                    .send(Packet::Stanza(muc_presence))
                    .map_err(|e| {
                        error!("Error on send muc presence: {}", e);
                        account4
                    })
                    .and_then(|client| {
                        data.mucs.insert(muc_jid.0, muc_jid.1);
                        future::ok(XmppState { client, data })
                    })
            })
            .map(|state| XmppConnection {
                account: account3,
                state,
            })
    }
}
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()));
                    } else {
                        warn!(
                            "Not subscribed to {}. Currently in {:?} state",
                            xmpp_to, rdata.1
                        );
                        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,
            })
    }
}
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 std::time::{Duration, Instant};
use super::stanzas;
use super::element_processor;
use crate::config;
#[derive(Debug)]
pub enum XmppCommand {
    /// Send message to someone by jid
    Chat {
        xmpp_to: xmpp_parsers::Jid,
        message: String,
    },
    /// Send message to MUC
    Chatroom { muc_id: String, message: String },
    /// Send ping request to the server to test connection
    Ping,
    /// Check iq requests if some have expired timeouts
    TimeoutCleanup,
}
/// trait of processing iq
/// each function consumes handlers and
/// returns false if connection should be reset
trait IqHandler {
    /// process result
    fn result(
        self: Box<Self>,
        conn: &mut XmppConnection,
        opt_element: Option<xmpp_parsers::Element>,
    ) -> bool;
    /// process error
    fn error(
        self: Box<Self>,
        conn: &mut XmppConnection,
        error: xmpp_parsers::stanza_error::StanzaError,
    ) -> bool;
    /// process tmeout
    fn timeout(self: Box<Self>, conn: &mut XmppConnection) -> bool;
}
struct AddRosterIqHandler {
    jid: xmpp_parsers::Jid,
}
impl IqHandler for AddRosterIqHandler {
    fn result(
        self: Box<Self>,
        conn: &mut XmppConnection,
        opt_element: Option<xmpp_parsers::Element>,
    ) -> bool {
        match opt_element {
            Some(element) => {
                warn!(
                    "Wrong payload when adding {} to roster: {}",
                    self.jid,
                    String::from(&element)
                );
            }
            None => {
                if conn.state.data.roster.contains_key(&self.jid) {
                    info!("Jid {} updated to roster", self.jid);
                } else {
                    info!("Jid {} added in roster", self.jid);
                    conn.state.data.roster.insert(
                        self.jid.clone(),
                        (
                            xmpp_parsers::roster::Subscription::None,
                            xmpp_parsers::roster::Ask::None,
                        ),
                    );
                }
                conn.process_jid(&self.jid);
            }
        }
        true
    }
    fn error(
        self: Box<Self>,
        _conn: &mut XmppConnection,
        _error: xmpp_parsers::stanza_error::StanzaError,
    ) -> bool {
        true
    }
    fn timeout(self: Box<Self>, _conn: &mut XmppConnection) -> bool {
        true // ignore
    }
}
struct PingIqHandler {}
impl IqHandler for PingIqHandler {
    fn result(
        self: Box<Self>,
        _conn: &mut XmppConnection,
        _opt_element: Option<xmpp_parsers::Element>,
    ) -> bool {
        info!("ping successed");
        true
    }
    fn error(
        self: Box<Self>,
        _conn: &mut XmppConnection,
        _error: xmpp_parsers::stanza_error::StanzaError,
    ) -> bool {
        false
    }
    fn timeout(self: Box<Self>, _conn: &mut XmppConnection) -> bool {
        false
    }
}
struct InitRosterIqHandler {}
impl IqHandler for InitRosterIqHandler {
    fn result(
        self: Box<Self>,
        conn: &mut XmppConnection,
        opt_element: Option<xmpp_parsers::Element>,
    ) -> bool {
        if let Some(result) = opt_element {
            use std::convert::TryInto;
            match result.try_into() as Result<xmpp_parsers::roster::Roster, _> {
                Ok(roster) => {
                    conn.state.data.roster_init = true;
                    conn.state.data.roster.clear();
                    info!("Got first roster:");
                    for i in roster.items {
                        info!(" >>> {:?}", i);
                        conn.state
                            .data
                            .roster
                            .insert(i.jid, (i.subscription, i.ask));
                    }
                    true
                }
                Err(e) => {
                    error!("Cann't parse roster: {}", e);
                    false
                }
            }
        } else {
            error!("No roster responded");
            false
        }
    }
    fn error(
        self: Box<Self>,
        _conn: &mut XmppConnection,
        _error: xmpp_parsers::stanza_error::StanzaError,
    ) -> bool {
        false
    }
    fn timeout(self: Box<Self>, _conn: &mut XmppConnection) -> bool {
        false
    }
}
#[derive(Default)]
struct XmppData {
    /// known roster data
    roster: HashMap<
        xmpp_parsers::Jid,
        (
            xmpp_parsers::roster::Subscription,
            xmpp_parsers::roster::Ask,
        ),
    >,
    /// if roster was initialized
    /// ToDo: remove it as it is used only for initialization
    roster_init: bool,
    /// if self-presence accepted
    /// ToDo: remove it as it is used only for initialization
    self_presence: bool,
    /// ids counter
    counter: usize,
    /// 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>,
    /// map from iq's id to handler of this type of iqs
    pending_ids: HashMap<String, (Instant, Box<dyn IqHandler>)>,
}
struct XmppState {
    client: Client,
    data: XmppData,
}
pub struct XmppConnection {
    account: std::rc::Rc<config::Account>,
    state: XmppState,
}
trait IqSetHandler {
    fn process(
        self: Box<Self>,
        conn: &mut XmppConnection,
        id: String,
        from: Option<xmpp_parsers::Jid>,
    ) -> xmpp_parsers::iq::Iq;
}
struct IqSetUnknown {
    element: xmpp_parsers::Element,
}
impl IqSetHandler for IqSetUnknown {
    fn process(
        self: Box<Self>,
        conn: &mut XmppConnection,
        id: String,
        from: Option<xmpp_parsers::Jid>,
    ) -> xmpp_parsers::iq::Iq {
        warn!(
            "Unsupported IQ set request from {:?}: {}",
            from,
            String::from(&self.element)
        );
        stanzas::make_iq_unsupported_error(id, conn.state.client.jid.clone(), from)
    }
}
struct IqSetRoster {}
impl IqSetHandler for IqSetRoster {
    fn process(
        self: Box<Self>,
        conn: &mut XmppConnection,
        id: String,
        from: Option<xmpp_parsers::Jid>,
    ) -> xmpp_parsers::iq::Iq {
        info!("Got roster push {} from {:?}", id, from);
        stanzas::make_roster_push_answer(id, conn.state.client.jid.clone(), from)
    }
}
lazy_static! {
    static ref INCOMING: element_processor::Processor<XmppConnection, bool, xmpp_parsers::Element> = {
        let mut incoming = element_processor::Processor::new(&|_, e| {
            warn!("Unknown stanza {}", String::from(&e));
            true
        });
        incoming.register(&XmppConnection::incoming_iq_processing);
        incoming.register(&XmppConnection::incoming_presence_processing);
        incoming.register(&XmppConnection::incoming_message_processing);
        incoming
    };
    static ref INCOMING_IQ_SET: element_processor::Processor<XmppConnection, Box<dyn IqSetHandler>, xmpp_parsers::Element> = {
        let mut iq_set =
            element_processor::Processor::new(&|_conn: &mut XmppConnection, element| {
                Box::new(IqSetUnknown { element }) as Box<dyn IqSetHandler>
            });
        iq_set.register(&XmppConnection::incoming_iq_processing_set_roster);
        iq_set
    };
}
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) => INCOMING.process(self, stanza.clone()),
            Event::Online => true,
            e => {
                warn!("Unexpected event {:?}", e);
                false
            }
        }
    }
    fn incoming_iq_processing_set_roster(
        &mut self,
        roster: xmpp_parsers::roster::Roster,
    ) -> Box<dyn IqSetHandler> {
        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);
        }
        Box::new(IqSetRoster {})
    }
    /// Enforce to answer to IQ "set"
    fn incoming_iq_processing_set(
        &mut self,
        id: String,
        from: Option<xmpp_parsers::Jid>,
        element: minidom::Element,
    ) -> xmpp_parsers::iq::Iq {
        INCOMING_IQ_SET
            .process(self, element)
            .process(self, id, from)
    }
    /// Enforce to answer to IQ "get"
    fn incoming_iq_processing_get(
        &mut self,
        id: String,
        from: Option<xmpp_parsers::Jid>,
        element: minidom::Element,
    ) -> xmpp_parsers::iq::Iq {
        use std::convert::TryInto;
        if let Some(_ping) = element.clone().try_into().ok() as Option<xmpp_parsers::ping::Ping> {
            info!("Got ping {} from {:?}", id, from);
            return stanzas::make_pong(&id, self.state.client.jid.clone(), from);
        }
        warn!(
            "Unsupported IQ get request from {:?}: {}",
            from,
            String::from(&element)
        );
        stanzas::make_iq_unsupported_error(id, self.state.client.jid.clone(), from)
    }
    fn incoming_iq_processing(&mut self, iq: xmpp_parsers::iq::Iq) -> bool {
        match iq.payload {
            xmpp_parsers::iq::IqType::Set(element) => {
                let iq_answer = self.incoming_iq_processing_set(iq.id, iq.from, element);
                self.state.data.send_queue.push_back(iq_answer.into());
            }
            xmpp_parsers::iq::IqType::Error(e) => {
                if let Some((_, handler)) = self.state.data.pending_ids.remove_entry(&iq.id) {
                    return handler.1.error(self, e);
                }
                error!("iq error: {:?}", e);
                return false;
            }
            xmpp_parsers::iq::IqType::Get(element) => {
                let iq_answer = self.incoming_iq_processing_get(iq.id, iq.from, element);
                self.state.data.send_queue.push_back(iq_answer.into());
            }
            xmpp_parsers::iq::IqType::Result(opt_element) => {
                if let Some((_, handler)) = self.state.data.pending_ids.remove_entry(&iq.id) {
                    return handler.1.result(self, opt_element);
                }
                warn!(
                    "Unwanted iq result id {} from {:?}: {:?}",
                    iq.id,
                    iq.from,
                    opt_element.map(|e| String::from(&e))
                );
            }
        }
        true
    }
    fn incoming_presence_processing(&mut self, presence: xmpp_parsers::presence::Presence) -> bool {
        if presence.from.as_ref() == Some(&self.state.client.jid) {
            info!("Self-presence accepted");
            self.state.data.self_presence = true;
        } else {
            warn!("Incoming presence stanza: {:?}", presence);
        }
        true
    }
    fn incoming_message_processing(&mut self, message: xmpp_parsers::message::Message) -> bool {
        for payload in message.payloads.iter() {
            use std::convert::TryInto;
            if let Some(_delay) =
                payload.clone().try_into().ok() as Option<xmpp_parsers::delay::Delay>
            {
                return true; // ignore delayed messages
            }
        }
        warn!("Incoming message stanza: {:?}", message);
        true
    }
    /// 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)| {
                // ToDo: check timeouts if iqs
                let XmppConnection {
                    state: XmppState { client, mut data },
                    account,
                } = xmpp;
                if let Some(send_element) = data.send_queue.pop_front() {
                    use tokio::prelude::Sink;
                    info!("Sending {}", String::from(&send_element));
                    Box::new(
                        client
                            .send(Packet::Stanza(send_element))
                            .select2(stop_future)
                            .then(move |r| match r {
                                Ok(Either::A((client, b))) => {
                                    Box::new(future::ok(future::Loop::Continue((
                                        XmppConnection {
                                            state: XmppState { client, data },
                                            account,
                                        },
                                        b,
                                        stop_condition,
                                    ))))
                                        as Box<dyn Future<Item = _, Error = _>>
                                }
                                Ok(Either::B((t, a))) => Box::new(a.then(|r| match r {
                                    Ok(client) => future::ok(future::Loop::Break((
                                        XmppConnection {
                                            state: XmppState { client, data },
                                            account,
                                        },
                                        Ok(Either::B(t)),
                                    ))),
                                    Err(se) => {
                                        warn!("XMPP sending error: {}", se);
                                        future::err((account, Ok(Either::B(t))))
                                    }
                                })),
                                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: {}", String::from(&s));
                Ok(false)
            }
            _ => {
                error!("Disconnected while online");
                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... {}", String::from(&get_roster));
        data.pending_ids.insert(
            id_init_roster.clone(),
            (
                Instant::now() + Duration::from_secs(60),
                Box::new(InitRosterIqHandler {}),
            ),
        );
        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, _| Ok(conn.state.data.roster_init), stop_future)
                .map_err(|(account, _)| account)
                .and_then(|(conn, r)| match r {
                    Ok(Either::A(_)) => future::ok(conn),
                    Ok(Either::B(_)) => future::err(conn.account),
                    Err(_e) => future::err(conn.account),
                })
            })
    }
    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... {}", String::from(&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, _| Ok(conn.state.data.self_presence),
                    stop_future,
                )
                .map_err(|(account, _)| account)
                .and_then(|(conn, r)| match r {
                    Ok(Either::A(_)) => future::ok(conn),
                    Ok(Either::B(_)) => future::err(conn.account),
                    Err(_e) => future::err(conn.account),
                })
            })
    }
    fn process_jid(&mut self, xmpp_to: &xmpp_parsers::Jid) {
        if let Some(ref mut mailbox) = self.state.data.outgoing_mailbox.get_mut(xmpp_to) {
            if !mailbox.is_empty() {
                if let Some(ref mut rdata) = self.state.data.roster.get_mut(xmpp_to) {
                    info!("Jid {} in roster", xmpp_to);
                    let sub_to = match rdata.0 {
                        xmpp_parsers::roster::Subscription::To => true,
                        xmpp_parsers::roster::Subscription::Both => true,
                        _ => false,
                    };
                    if sub_to {
                        info!("Subscribed to {}", xmpp_to);
                        self.state.data.send_queue.extend(
                            mailbox.drain(..).map(|message| {
                                stanzas::make_chat_message(xmpp_to.clone(), message)
                            }),
                        );
                    } else if rdata.1 == xmpp_parsers::roster::Ask::None {
                        info!("Not subscribed to {}", xmpp_to);
                        self.state
                            .data
                            .send_queue
                            .push_back(stanzas::make_ask_subscribe(xmpp_to.clone()));
                    }
                    let sub_from = match rdata.0 {
                        xmpp_parsers::roster::Subscription::From => true,
                        xmpp_parsers::roster::Subscription::Both => true,
                        _ => false,
                    };
                    if !sub_from {
                        info!("Not subscription from {}", xmpp_to);
                        self.state
                            .data
                            .send_queue
                            .push_back(stanzas::make_allow_subscribe(xmpp_to.clone()));
                    }
                } else {
                    info!("Jid {} not in roster", xmpp_to);
                    self.state.data.counter += 1;
                    let id_add_roster = format!("id_add_roster{}", self.state.data.counter);
                    let add_roster = stanzas::make_add_roster(&id_add_roster, xmpp_to.clone());
                    info!("Adding jid {} to roster id {}", xmpp_to, id_add_roster);
                    self.state.data.pending_ids.insert(
                        id_add_roster,
                        (
                            Instant::now() + Duration::from_secs(60),
                            Box::new(AddRosterIqHandler {
                                jid: xmpp_to.clone(),
                            }),
                        ),
                    );
                    self.state.data.send_queue.push_back(add_roster);
                }
            }
        }
    }
    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);
                self.state.data.pending_ids.insert(
                    id_ping,
                    (
                        Instant::now() + Duration::from_secs(30),
                        Box::new(PingIqHandler {}),
                    ),
                );
            }
            XmppCommand::TimeoutCleanup => {
                let now = Instant::now();
                let timeouted: Vec<String> = self
                    .state
                    .data
                    .pending_ids
                    .iter()
                    .filter_map(|(id, (timeout, _))| {
                        if now >= *timeout {
                            Some(id.to_string())
                        } else {
                            None
                        }
                    })
                    .collect();
                let mut correct = true;
                timeouted.into_iter().for_each(|id| {
                    if let Some((_, handler)) = self.state.data.pending_ids.remove(&id) {
                        correct &= handler.timeout(&mut self);
                    }
                })
            }
        }
    }
    pub fn shutdown(self) -> impl Future<Item = (), Error = failure::Error> {
        info!("Shutdown connection");
        let XmppConnection { account, state } = self;
        stream::iter_ok(
            state
                .data
                .mucs
                .values()
                .map(std::clone::Clone::clone)
                .collect::<Vec<_>>(),
        )
        .fold(state, move |XmppState { client, data }, muc_jid| {
            let muc_presence =
                stanzas::make_muc_presence_leave(account.jid.clone(), muc_jid.clone());
            info!(
                "Sending muc leave presence... {}",
                String::from(&muc_presence)
            );
            use tokio::prelude::Sink;
            client
                .send(Packet::Stanza(muc_presence))
                .map_err(|e| {
                    error!("Error on send muc presence: {}", e);
                    e
                })
                .and_then(|client| future::ok(XmppState { client, data }))
        })
        .map(|_| ())
    }
    fn enter_mucs<F, E>(
        self,
        _stop_future: F,
    ) -> impl Future<Item = Self, Error = std::rc::Rc<config::Account>>
    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... {}", String::from(&muc_presence));
                let account4 = account2.clone();
                use tokio::prelude::Sink;
                client
                    .send(Packet::Stanza(muc_presence))
                    .map_err(|e| {
                        error!("Error on send muc presence: {}", e);
                        account4
                    })
                    .and_then(|client| {
                        data.mucs.insert(muc_jid.0, muc_jid.1);
                        future::ok(XmppState { client, data })
                    })
            })
            .map(|state| XmppConnection {
                account: account3,
                state,
            })
    }
}
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 std::time::{Duration, Instant};
use super::stanzas;
use super::element_processor;
use crate::config;
#[derive(Debug)]
pub enum XmppCommand {
    /// Send message to someone by jid
    Chat {
        xmpp_to: xmpp_parsers::Jid,
        message: String,
    },
    /// Send message to MUC
    Chatroom { muc_id: String, message: String },
    /// Send ping request to the server to test connection
    Ping,
    /// Check iq requests if some have expired timeouts
    TimeoutCleanup,
}
/// trait of processing iq
/// each function consumes handlers and
/// returns false if connection should be reset
trait IqHandler {
    /// process result
    fn result(
        self: Box<Self>,
        conn: &mut XmppConnection,
        opt_element: Option<xmpp_parsers::Element>,
    ) -> bool;
    /// process error
    fn error(
        self: Box<Self>,
        conn: &mut XmppConnection,
        error: xmpp_parsers::stanza_error::StanzaError,
    ) -> bool;
    /// process tmeout
    fn timeout(self: Box<Self>, conn: &mut XmppConnection) -> bool;
}
struct AddRosterIqHandler {
    jid: xmpp_parsers::Jid,
}
impl IqHandler for AddRosterIqHandler {
    fn result(
        self: Box<Self>,
        conn: &mut XmppConnection,
        opt_element: Option<xmpp_parsers::Element>,
    ) -> bool {
        match opt_element {
            Some(element) => {
                warn!(
                    "Wrong payload when adding {} to roster: {}",
                    self.jid,
                    String::from(&element)
                );
            }
            None => {
                if conn.state.data.roster.contains_key(&self.jid) {
                    info!("Jid {} updated to roster", self.jid);
                } else {
                    info!("Jid {} added in roster", self.jid);
                    conn.state.data.roster.insert(
                        self.jid.clone(),
                        (
                            xmpp_parsers::roster::Subscription::None,
                            xmpp_parsers::roster::Ask::None,
                        ),
                    );
                }
                conn.process_jid(&self.jid);
            }
        }
        true
    }
    fn error(
        self: Box<Self>,
        _conn: &mut XmppConnection,
        _error: xmpp_parsers::stanza_error::StanzaError,
    ) -> bool {
        true
    }
    fn timeout(self: Box<Self>, _conn: &mut XmppConnection) -> bool {
        true // ignore
    }
}
struct PingIqHandler {}
impl IqHandler for PingIqHandler {
    fn result(
        self: Box<Self>,
        _conn: &mut XmppConnection,
        _opt_element: Option<xmpp_parsers::Element>,
    ) -> bool {
        info!("ping successed");
        true
    }
    fn error(
        self: Box<Self>,
        _conn: &mut XmppConnection,
        _error: xmpp_parsers::stanza_error::StanzaError,
    ) -> bool {
        false
    }
    fn timeout(self: Box<Self>, _conn: &mut XmppConnection) -> bool {
        false
    }
}
struct InitRosterIqHandler {}
impl IqHandler for InitRosterIqHandler {
    fn result(
        self: Box<Self>,
        conn: &mut XmppConnection,
        opt_element: Option<xmpp_parsers::Element>,
    ) -> bool {
        if let Some(result) = opt_element {
            use std::convert::TryInto;
            match result.try_into() as Result<xmpp_parsers::roster::Roster, _> {
                Ok(roster) => {
                    conn.state.data.roster_init = true;
                    conn.state.data.roster.clear();
                    info!("Got first roster:");
                    for i in roster.items {
                        info!(" >>> {:?}", i);
                        conn.state
                            .data
                            .roster
                            .insert(i.jid, (i.subscription, i.ask));
                    }
                    true
                }
                Err(e) => {
                    error!("Cann't parse roster: {}", e);
                    false
                }
            }
        } else {
            error!("No roster responded");
            false
        }
    }
    fn error(
        self: Box<Self>,
        _conn: &mut XmppConnection,
        _error: xmpp_parsers::stanza_error::StanzaError,
    ) -> bool {
        false
    }
    fn timeout(self: Box<Self>, _conn: &mut XmppConnection) -> bool {
        false
    }
}
#[derive(Default)]
struct XmppData {
    /// known roster data
    roster: HashMap<
        xmpp_parsers::Jid,
        (
            xmpp_parsers::roster::Subscription,
            xmpp_parsers::roster::Ask,
        ),
    >,
    /// if roster was initialized
    /// ToDo: remove it as it is used only for initialization
    roster_init: bool,
    /// if self-presence accepted
    /// ToDo: remove it as it is used only for initialization
    self_presence: bool,
    /// ids counter
    counter: usize,
    /// 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>,
    /// map from iq's id to handler of this type of iqs
    pending_ids: HashMap<String, (Instant, Box<dyn IqHandler>)>,
}
struct XmppState {
    client: Client,
    data: XmppData,
}
pub struct XmppConnection {
    account: std::rc::Rc<config::Account>,
    state: XmppState,
}
trait IqRequestHandler {
    fn process(
        self: Box<Self>,
        conn: &mut XmppConnection,
        id: String,
        from: Option<xmpp_parsers::Jid>,
    ) -> xmpp_parsers::iq::Iq;
}
struct IqRequestUnknown {
    element: xmpp_parsers::Element,
    type_: &'static str,
}
impl IqRequestHandler for IqRequestUnknown {
    fn process(
        self: Box<Self>,
        conn: &mut XmppConnection,
        id: String,
        from: Option<xmpp_parsers::Jid>,
    ) -> xmpp_parsers::iq::Iq {
        warn!(
            "Unsupported IQ {} request from {:?}: {}",
            self.type_,
            from,
            String::from(&self.element)
        );
        stanzas::make_iq_unsupported_error(id, conn.state.client.jid.clone(), from)
    }
}
struct IqSetRoster {}
impl IqRequestHandler for IqSetRoster {
    fn process(
        self: Box<Self>,
        conn: &mut XmppConnection,
        id: String,
        from: Option<xmpp_parsers::Jid>,
    ) -> xmpp_parsers::iq::Iq {
        info!("Got roster push {} from {:?}", id, from);
        stanzas::make_roster_push_answer(id, conn.state.client.jid.clone(), from)
    }
}
struct IqGetPing {}
impl IqRequestHandler for IqGetPing {
    fn process(
        self: Box<Self>,
        conn: &mut XmppConnection,
        id: String,
        from: Option<xmpp_parsers::Jid>,
    ) -> xmpp_parsers::iq::Iq {
        info!("Got ping {} from {:?}", id, from);
        stanzas::make_pong(id, conn.state.client.jid.clone(), from)
    }
}
struct IqGetDiscoInfo {}
impl IqRequestHandler for IqGetDiscoInfo {
    fn process(
        self: Box<Self>,
        conn: &mut XmppConnection,
        id: String,
        from: Option<xmpp_parsers::Jid>,
    ) -> xmpp_parsers::iq::Iq {
        info!("Got disco query {} from {:?}", id, from);
        stanzas::make_disco_info_result(id, conn.state.client.jid.clone(), from)
    }
}
struct IqGetDiscoItems {}
impl IqRequestHandler for IqGetDiscoItems {
    fn process(
        self: Box<Self>,
        conn: &mut XmppConnection,
        id: String,
        from: Option<xmpp_parsers::Jid>,
    ) -> xmpp_parsers::iq::Iq {
        info!("Got disco items query {} from {:?}", id, from);
        stanzas::make_disco_items_result(id, conn.state.client.jid.clone(), from)
    }
}
lazy_static! {
    static ref INCOMING: element_processor::Processor<XmppConnection, bool, xmpp_parsers::Element> = {
        let mut incoming = element_processor::Processor::new(&|_, e| {
            warn!("Unknown stanza {}", String::from(&e));
            true
        });
        incoming.register(&XmppConnection::incoming_iq_processing);
        incoming.register(&XmppConnection::incoming_presence_processing);
        incoming.register(&XmppConnection::incoming_message_processing);
        incoming
    };
    static ref INCOMING_IQ_SET: element_processor::Processor<XmppConnection, Box<dyn IqRequestHandler>, xmpp_parsers::Element> = {
        let mut iq_set =
            element_processor::Processor::new(&|_conn: &mut XmppConnection, element| {
                Box::new(IqRequestUnknown {
                    element,
                    type_: "set",
                }) as Box<dyn IqRequestHandler>
            });
        iq_set.register(&XmppConnection::incoming_iq_processing_set_roster);
        iq_set
    };
    static ref INCOMING_IQ_GET: element_processor::Processor<XmppConnection, Box<dyn IqRequestHandler>, xmpp_parsers::Element> = {
        let mut iq_get =
            element_processor::Processor::new(&|_conn: &mut XmppConnection, element| {
                Box::new(IqRequestUnknown {
                    element,
                    type_: "get",
                }) as Box<dyn IqRequestHandler>
            });
        iq_get.register(&XmppConnection::incoming_iq_processing_get_ping);
        iq_get.register(&XmppConnection::incoming_iq_processing_get_disco_info);
        iq_get.register(&XmppConnection::incoming_iq_processing_get_disco_items);
        iq_get
    };
}
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) => INCOMING.process(self, stanza.clone()),
            Event::Online => true,
            e => {
                warn!("Unexpected event {:?}", e);
                false
            }
        }
    }
    /// Process roster push
    /// see RFC 6212 2.1.6. Roster Push
    fn incoming_iq_processing_set_roster(
        &mut self,
        roster: xmpp_parsers::roster::Roster,
    ) -> Box<dyn IqRequestHandler> {
        for i in roster.items {
            if let Some(ref mut rdata) = self.state.data.roster.get_mut(&i.jid) {
                info!("Update {} in roster", i.jid);
                rdata.0 = i.subscription;
                rdata.1 = i.ask;
            } else {
                info!("Add {} to roster", i.jid);
                self.state
                    .data
                    .roster
                    .insert(i.jid.clone(), (i.subscription, i.ask));
            }
            self.process_jid(&i.jid);
        }
        Box::new(IqSetRoster {})
    }
    /// Enforce to answer to IQ "set"
    fn incoming_iq_processing_set(
        &mut self,
        id: String,
        from: Option<xmpp_parsers::Jid>,
        element: minidom::Element,
    ) -> xmpp_parsers::iq::Iq {
        INCOMING_IQ_SET
            .process(self, element)
            .process(self, id, from)
    }
    /// Process ping request
    /// see XEP-0199: XMPP Ping
    fn incoming_iq_processing_get_ping(
        &mut self,
        _ping: xmpp_parsers::ping::Ping,
    ) -> Box<dyn IqRequestHandler> {
        Box::new(IqGetPing {})
    }
    /// Process disco query
    /// see XEP-0030: Service Discovery
    fn incoming_iq_processing_get_disco_info(
        &mut self,
        disco: xmpp_parsers::disco::DiscoInfoQuery,
    ) -> Box<dyn IqRequestHandler> {
        if let Some(ref node) = disco.node {
            warn!("Unsupported node {}", node);
            Box::new(IqRequestUnknown {
                element: disco.into(),
                type_: "get",
            })
        } else {
            Box::new(IqGetDiscoInfo {})
        }
    }
    /// Process disco items query
    /// see XEP-0030: Service Discovery
    fn incoming_iq_processing_get_disco_items(
        &mut self,
        disco: xmpp_parsers::disco::DiscoItemsQuery,
    ) -> Box<dyn IqRequestHandler> {
        if let Some(ref node) = disco.node {
            warn!("Unsupported node {}", node);
            Box::new(IqRequestUnknown {
                element: disco.into(),
                type_: "get",
            })
        } else {
            Box::new(IqGetDiscoItems {})
        }
    }
    /// Enforce to answer to IQ "get"
    fn incoming_iq_processing_get(
        &mut self,
        id: String,
        from: Option<xmpp_parsers::Jid>,
        element: minidom::Element,
    ) -> xmpp_parsers::iq::Iq {
        INCOMING_IQ_GET
            .process(self, element)
            .process(self, id, from)
    }
    fn incoming_iq_processing(&mut self, iq: xmpp_parsers::iq::Iq) -> bool {
        match iq.payload {
            xmpp_parsers::iq::IqType::Set(element) => {
                let iq_answer = self.incoming_iq_processing_set(iq.id, iq.from, element);
                self.state.data.send_queue.push_back(iq_answer.into());
            }
            xmpp_parsers::iq::IqType::Error(e) => {
                if let Some((_, handler)) = self.state.data.pending_ids.remove_entry(&iq.id) {
                    return handler.1.error(self, e);
                }
                error!("iq error: {:?}", e);
                return false;
            }
            xmpp_parsers::iq::IqType::Get(element) => {
                let iq_answer = self.incoming_iq_processing_get(iq.id, iq.from, element);
                self.state.data.send_queue.push_back(iq_answer.into());
            }
            xmpp_parsers::iq::IqType::Result(opt_element) => {
                if let Some((_, handler)) = self.state.data.pending_ids.remove_entry(&iq.id) {
                    return handler.1.result(self, opt_element);
                }
                warn!(
                    "Unwanted iq result id {} from {:?}: {:?}",
                    iq.id,
                    iq.from,
                    opt_element.map(|e| String::from(&e))
                );
            }
        }
        true
    }
    fn incoming_presence_processing(&mut self, presence: xmpp_parsers::presence::Presence) -> bool {
        if presence.from.as_ref() == Some(&self.state.client.jid) {
            info!("Self-presence accepted");
            self.state.data.self_presence = true;
        } else {
            warn!("Incoming presence stanza: {:?}", presence);
        }
        true
    }
    fn incoming_message_processing(&mut self, message: xmpp_parsers::message::Message) -> bool {
        for payload in message.payloads.iter() {
            use std::convert::TryInto;
            if let Some(_delay) =
                payload.clone().try_into().ok() as Option<xmpp_parsers::delay::Delay>
            {
                return true; // ignore delayed messages
            }
        }
        warn!("Incoming message stanza: {:?}", message);
        true
    }
    /// 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)| {
                // ToDo: check timeouts if iqs
                let XmppConnection {
                    state: XmppState { client, mut data },
                    account,
                } = xmpp;
                if let Some(send_element) = data.send_queue.pop_front() {
                    use tokio::prelude::Sink;
                    info!("Sending {}", String::from(&send_element));
                    Box::new(
                        client
                            .send(Packet::Stanza(send_element))
                            .select2(stop_future)
                            .then(move |r| match r {
                                Ok(Either::A((client, b))) => {
                                    Box::new(future::ok(future::Loop::Continue((
                                        XmppConnection {
                                            state: XmppState { client, data },
                                            account,
                                        },
                                        b,
                                        stop_condition,
                                    ))))
                                        as Box<dyn Future<Item = _, Error = _>>
                                }
                                Ok(Either::B((t, a))) => Box::new(a.then(|r| match r {
                                    Ok(client) => future::ok(future::Loop::Break((
                                        XmppConnection {
                                            state: XmppState { client, data },
                                            account,
                                        },
                                        Ok(Either::B(t)),
                                    ))),
                                    Err(se) => {
                                        warn!("XMPP sending error: {}", se);
                                        future::err((account, Ok(Either::B(t))))
                                    }
                                })),
                                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: {}", String::from(&s));
                Ok(false)
            }
            _ => {
                error!("Disconnected while online");
                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... {}", String::from(&get_roster));
        data.pending_ids.insert(
            id_init_roster.clone(),
            (
                Instant::now() + Duration::from_secs(60),
                Box::new(InitRosterIqHandler {}),
            ),
        );
        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, _| Ok(conn.state.data.roster_init), stop_future)
                .map_err(|(account, _)| account)
                .and_then(|(conn, r)| match r {
                    Ok(Either::A(_)) => future::ok(conn),
                    Ok(Either::B(_)) => future::err(conn.account),
                    Err(_e) => future::err(conn.account),
                })
            })
    }
    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... {}", String::from(&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, _| Ok(conn.state.data.self_presence),
                    stop_future,
                )
                .map_err(|(account, _)| account)
                .and_then(|(conn, r)| match r {
                    Ok(Either::A(_)) => future::ok(conn),
                    Ok(Either::B(_)) => future::err(conn.account),
                    Err(_e) => future::err(conn.account),
                })
            })
    }
    fn process_jid(&mut self, xmpp_to: &xmpp_parsers::Jid) {
        if let Some(ref mut mailbox) = self.state.data.outgoing_mailbox.get_mut(xmpp_to) {
            if !mailbox.is_empty() {
                if let Some(ref mut rdata) = self.state.data.roster.get_mut(xmpp_to) {
                    info!("Jid {} in roster", xmpp_to);
                    let sub_to = match rdata.0 {
                        xmpp_parsers::roster::Subscription::To => true,
                        xmpp_parsers::roster::Subscription::Both => true,
                        _ => false,
                    };
                    if sub_to {
                        info!("Subscribed to {}", xmpp_to);
                        self.state.data.send_queue.extend(
                            mailbox.drain(..).map(|message| {
                                stanzas::make_chat_message(xmpp_to.clone(), message)
                            }),
                        );
                    } else if rdata.1 == xmpp_parsers::roster::Ask::None {
                        info!("Not subscribed to {}", xmpp_to);
                        self.state
                            .data
                            .send_queue
                            .push_back(stanzas::make_ask_subscribe(xmpp_to.clone()));
                    }
                    let sub_from = match rdata.0 {
                        xmpp_parsers::roster::Subscription::From => true,
                        xmpp_parsers::roster::Subscription::Both => true,
                        _ => false,
                    };
                    if !sub_from {
                        info!("Not subscription from {}", xmpp_to);
                        self.state
                            .data
                            .send_queue
                            .push_back(stanzas::make_allow_subscribe(xmpp_to.clone()));
                    }
                } else {
                    info!("Jid {} not in roster", xmpp_to);
                    self.state.data.counter += 1;
                    let id_add_roster = format!("id_add_roster{}", self.state.data.counter);
                    let add_roster = stanzas::make_add_roster(&id_add_roster, xmpp_to.clone());
                    info!("Adding jid {} to roster id {}", xmpp_to, id_add_roster);
                    self.state.data.pending_ids.insert(
                        id_add_roster,
                        (
                            Instant::now() + Duration::from_secs(60),
                            Box::new(AddRosterIqHandler {
                                jid: xmpp_to.clone(),
                            }),
                        ),
                    );
                    self.state.data.send_queue.push_back(add_roster);
                }
            }
        }
    }
    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);
                self.state.data.pending_ids.insert(
                    id_ping,
                    (
                        Instant::now() + Duration::from_secs(30),
                        Box::new(PingIqHandler {}),
                    ),
                );
            }
            XmppCommand::TimeoutCleanup => {
                let now = Instant::now();
                let timeouted: Vec<String> = self
                    .state
                    .data
                    .pending_ids
                    .iter()
                    .filter_map(|(id, (timeout, _))| {
                        if now >= *timeout {
                            Some(id.to_string())
                        } else {
                            None
                        }
                    })
                    .collect();
                let mut correct = true;
                timeouted.into_iter().for_each(|id| {
                    if let Some((_, handler)) = self.state.data.pending_ids.remove(&id) {
                        correct &= handler.timeout(&mut self);
                    }
                })
            }
        }
    }
    pub fn shutdown(self) -> impl Future<Item = (), Error = failure::Error> {
        info!("Shutdown connection");
        let XmppConnection { account, state } = self;
        stream::iter_ok(
            state
                .data
                .mucs
                .values()
                .map(std::clone::Clone::clone)
                .collect::<Vec<_>>(),
        )
        .fold(state, move |XmppState { client, data }, muc_jid| {
            let muc_presence =
                stanzas::make_muc_presence_leave(account.jid.clone(), muc_jid.clone());
            info!(
                "Sending muc leave presence... {}",
                String::from(&muc_presence)
            );
            use tokio::prelude::Sink;
            client
                .send(Packet::Stanza(muc_presence))
                .map_err(|e| {
                    error!("Error on send muc presence: {}", e);
                    e
                })
                .and_then(|client| future::ok(XmppState { client, data }))
        })
        .map(|_| ())
    }
    fn enter_mucs<F, E>(
        self,
        _stop_future: F,
    ) -> impl Future<Item = Self, Error = std::rc::Rc<config::Account>>
    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... {}", String::from(&muc_presence));
                let account4 = account2.clone();
                use tokio::prelude::Sink;
                client
                    .send(Packet::Stanza(muc_presence))
                    .map_err(|e| {
                        error!("Error on send muc presence: {}", e);
                        account4
                    })
                    .and_then(|client| {
                        data.mucs.insert(muc_jid.0, muc_jid.1);
                        future::ok(XmppState { client, data })
                    })
            })
            .map(|state| XmppConnection {
                account: account3,
                state,
            })
    }
}
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,
            })
    }
}
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 std::time::{Duration, Instant};
use super::stanzas;
use super::element_processor;
use crate::config;
#[derive(Debug)]
pub enum XmppCommand {
    /// Send message to someone by jid
    Chat {
        xmpp_to: xmpp_parsers::Jid,
        message: String,
    },
    /// Send message to MUC
    Chatroom { muc_id: String, message: String },
    /// Send ping request to the server to test connection
    Ping,
    /// Check iq requests if some have expired timeouts
    TimeoutCleanup,
}
/// trait of processing iq
/// each function consumes handlers and
/// returns false if connection should be reset
trait IqHandler {
    /// process result
    fn result(
        self: Box<Self>,
        conn: &mut XmppConnection,
        opt_element: Option<xmpp_parsers::Element>,
    ) -> bool;
    /// process error
    fn error(
        self: Box<Self>,
        conn: &mut XmppConnection,
        error: xmpp_parsers::stanza_error::StanzaError,
    ) -> bool;
    /// process tmeout
    fn timeout(self: Box<Self>, conn: &mut XmppConnection) -> bool;
}
struct AddRosterIqHandler {
    jid: xmpp_parsers::Jid,
}
impl IqHandler for AddRosterIqHandler {
    fn result(
        self: Box<Self>,
        conn: &mut XmppConnection,
        opt_element: Option<xmpp_parsers::Element>,
    ) -> bool {
        match opt_element {
            Some(element) => {
                warn!(
                    "Wrong payload when adding {} to roster: {}",
                    self.jid,
                    String::from(&element)
                );
            }
            None => {
                if conn.state.data.roster.contains_key(&self.jid) {
                    info!("Jid {} updated to roster", self.jid);
                } else {
                    info!("Jid {} added in roster", self.jid);
                    conn.state.data.roster.insert(
                        self.jid.clone(),
                        (
                            xmpp_parsers::roster::Subscription::None,
                            xmpp_parsers::roster::Ask::None,
                        ),
                    );
                }
                conn.process_jid(&self.jid);
            }
        }
        true
    }
    fn error(
        self: Box<Self>,
        _conn: &mut XmppConnection,
        _error: xmpp_parsers::stanza_error::StanzaError,
    ) -> bool {
        true
    }
    fn timeout(self: Box<Self>, _conn: &mut XmppConnection) -> bool {
        true // ignore
    }
}
struct PingIqHandler {}
impl IqHandler for PingIqHandler {
    fn result(
        self: Box<Self>,
        _conn: &mut XmppConnection,
        _opt_element: Option<xmpp_parsers::Element>,
    ) -> bool {
        info!("ping successed");
        true
    }
    fn error(
        self: Box<Self>,
        _conn: &mut XmppConnection,
        _error: xmpp_parsers::stanza_error::StanzaError,
    ) -> bool {
        false
    }
    fn timeout(self: Box<Self>, _conn: &mut XmppConnection) -> bool {
        false
    }
}
struct InitRosterIqHandler {}
impl IqHandler for InitRosterIqHandler {
    fn result(
        self: Box<Self>,
        conn: &mut XmppConnection,
        opt_element: Option<xmpp_parsers::Element>,
    ) -> bool {
        if let Some(result) = opt_element {
            use std::convert::TryInto;
            match result.try_into() as Result<xmpp_parsers::roster::Roster, _> {
                Ok(roster) => {
                    conn.state.data.roster_init = true;
                    conn.state.data.roster.clear();
                    info!("Got first roster:");
                    for i in roster.items {
                        info!(" >>> {:?}", i);
                        conn.state
                            .data
                            .roster
                            .insert(i.jid, (i.subscription, i.ask));
                    }
                    true
                }
                Err(e) => {
                    error!("Cann't parse roster: {}", e);
                    false
                }
            }
        } else {
            error!("No roster responded");
            false
        }
    }
    fn error(
        self: Box<Self>,
        _conn: &mut XmppConnection,
        _error: xmpp_parsers::stanza_error::StanzaError,
    ) -> bool {
        false
    }
    fn timeout(self: Box<Self>, _conn: &mut XmppConnection) -> bool {
        false
    }
}
#[derive(Default)]
struct XmppData {
    /// known roster data
    roster: HashMap<
        xmpp_parsers::Jid,
        (
            xmpp_parsers::roster::Subscription,
            xmpp_parsers::roster::Ask,
        ),
    >,
    /// if roster was initialized
    /// ToDo: remove it as it is used only for initialization
    roster_init: bool,
    /// if self-presence accepted
    /// ToDo: remove it as it is used only for initialization
    self_presence: bool,
    /// ids counter
    counter: usize,
    /// 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>,
    /// map from iq's id to handler of this type of iqs
    pending_ids: HashMap<String, (Instant, Box<dyn IqHandler>)>,
}
struct XmppState {
    client: Client,
    data: XmppData,
}
pub struct XmppConnection {
    account: std::rc::Rc<config::Account>,
    state: XmppState,
}
trait IqRequestHandler {
    fn process(
        self: Box<Self>,
        conn: &mut XmppConnection,
        id: String,
        from: Option<xmpp_parsers::Jid>,
    ) -> xmpp_parsers::iq::Iq;
}
struct IqSetUnknown {
    element: xmpp_parsers::Element,
}
impl IqRequestHandler for IqSetUnknown {
    fn process(
        self: Box<Self>,
        conn: &mut XmppConnection,
        id: String,
        from: Option<xmpp_parsers::Jid>,
    ) -> xmpp_parsers::iq::Iq {
        warn!(
            "Unsupported IQ set request from {:?}: {}",
            from,
            String::from(&self.element)
        );
        stanzas::make_iq_unsupported_error(id, conn.state.client.jid.clone(), from)
    }
}
struct IqSetRoster {}
impl IqRequestHandler for IqSetRoster {
    fn process(
        self: Box<Self>,
        conn: &mut XmppConnection,
        id: String,
        from: Option<xmpp_parsers::Jid>,
    ) -> xmpp_parsers::iq::Iq {
        info!("Got roster push {} from {:?}", id, from);
        stanzas::make_roster_push_answer(id, conn.state.client.jid.clone(), from)
    }
}
lazy_static! {
    static ref INCOMING: element_processor::Processor<XmppConnection, bool, xmpp_parsers::Element> = {
        let mut incoming = element_processor::Processor::new(&|_, e| {
            warn!("Unknown stanza {}", String::from(&e));
            true
        });
        incoming.register(&XmppConnection::incoming_iq_processing);
        incoming.register(&XmppConnection::incoming_presence_processing);
        incoming.register(&XmppConnection::incoming_message_processing);
        incoming
    };
    static ref INCOMING_IQ_SET: element_processor::Processor<XmppConnection, Box<dyn IqRequestHandler>, xmpp_parsers::Element> = {
        let mut iq_set =
            element_processor::Processor::new(&|_conn: &mut XmppConnection, element| {
                Box::new(IqSetUnknown { element }) as Box<dyn IqRequestHandler>
            });
        iq_set.register(&XmppConnection::incoming_iq_processing_set_roster);
        iq_set
    };
}
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) => INCOMING.process(self, stanza.clone()),
            Event::Online => true,
            e => {
                warn!("Unexpected event {:?}", e);
                false
            }
        }
    }
    /// Process rosterpush
    /// see RFC 6212 2.1.6. Roster Push
    fn incoming_iq_processing_set_roster(
        &mut self,
        roster: xmpp_parsers::roster::Roster,
    ) -> Box<dyn IqRequestHandler> {
        for i in roster.items {
            if let Some(ref mut rdata) = self.state.data.roster.get_mut(&i.jid) {
                info!("Update {} in roster", i.jid);
                rdata.0 = i.subscription;
                rdata.1 = i.ask;
            } else {
                info!("Add {} to roster", i.jid);
                self.state
                    .data
                    .roster
                    .insert(i.jid.clone(), (i.subscription, i.ask));
            }
            self.process_jid(&i.jid);
        }
        Box::new(IqSetRoster {})
    }
    /// Enforce to answer to IQ "set"
    fn incoming_iq_processing_set(
        &mut self,
        id: String,
        from: Option<xmpp_parsers::Jid>,
        element: minidom::Element,
    ) -> xmpp_parsers::iq::Iq {
        INCOMING_IQ_SET
            .process(self, element)
            .process(self, id, from)
    }
    /// Enforce to answer to IQ "get"
    fn incoming_iq_processing_get(
        &mut self,
        id: String,
        from: Option<xmpp_parsers::Jid>,
        element: minidom::Element,
    ) -> xmpp_parsers::iq::Iq {
        use std::convert::TryInto;
        if let Some(_ping) = element.clone().try_into().ok() as Option<xmpp_parsers::ping::Ping> {
            info!("Got ping {} from {:?}", id, from);
            return stanzas::make_pong(&id, self.state.client.jid.clone(), from);
        }
        warn!(
            "Unsupported IQ get request from {:?}: {}",
            from,
            String::from(&element)
        );
        stanzas::make_iq_unsupported_error(id, self.state.client.jid.clone(), from)
    }
    fn incoming_iq_processing(&mut self, iq: xmpp_parsers::iq::Iq) -> bool {
        match iq.payload {
            xmpp_parsers::iq::IqType::Set(element) => {
                let iq_answer = self.incoming_iq_processing_set(iq.id, iq.from, element);
                self.state.data.send_queue.push_back(iq_answer.into());
            }
            xmpp_parsers::iq::IqType::Error(e) => {
                if let Some((_, handler)) = self.state.data.pending_ids.remove_entry(&iq.id) {
                    return handler.1.error(self, e);
                }
                error!("iq error: {:?}", e);
                return false;
            }
            xmpp_parsers::iq::IqType::Get(element) => {
                let iq_answer = self.incoming_iq_processing_get(iq.id, iq.from, element);
                self.state.data.send_queue.push_back(iq_answer.into());
            }
            xmpp_parsers::iq::IqType::Result(opt_element) => {
                if let Some((_, handler)) = self.state.data.pending_ids.remove_entry(&iq.id) {
                    return handler.1.result(self, opt_element);
                }
                warn!(
                    "Unwanted iq result id {} from {:?}: {:?}",
                    iq.id,
                    iq.from,
                    opt_element.map(|e| String::from(&e))
                );
            }
        }
        true
    }
    fn incoming_presence_processing(&mut self, presence: xmpp_parsers::presence::Presence) -> bool {
        if presence.from.as_ref() == Some(&self.state.client.jid) {
            info!("Self-presence accepted");
            self.state.data.self_presence = true;
        } else {
            warn!("Incoming presence stanza: {:?}", presence);
        }
        true
    }
    fn incoming_message_processing(&mut self, message: xmpp_parsers::message::Message) -> bool {
        for payload in message.payloads.iter() {
            use std::convert::TryInto;
            if let Some(_delay) =
                payload.clone().try_into().ok() as Option<xmpp_parsers::delay::Delay>
            {
                return true; // ignore delayed messages
            }
        }
        warn!("Incoming message stanza: {:?}", message);
        true
    }
    /// 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)| {
                // ToDo: check timeouts if iqs
                let XmppConnection {
                    state: XmppState { client, mut data },
                    account,
                } = xmpp;
                if let Some(send_element) = data.send_queue.pop_front() {
                    use tokio::prelude::Sink;
                    info!("Sending {}", String::from(&send_element));
                    Box::new(
                        client
                            .send(Packet::Stanza(send_element))
                            .select2(stop_future)
                            .then(move |r| match r {
                                Ok(Either::A((client, b))) => {
                                    Box::new(future::ok(future::Loop::Continue((
                                        XmppConnection {
                                            state: XmppState { client, data },
                                            account,
                                        },
                                        b,
                                        stop_condition,
                                    ))))
                                        as Box<dyn Future<Item = _, Error = _>>
                                }
                                Ok(Either::B((t, a))) => Box::new(a.then(|r| match r {
                                    Ok(client) => future::ok(future::Loop::Break((
                                        XmppConnection {
                                            state: XmppState { client, data },
                                            account,
                                        },
                                        Ok(Either::B(t)),
                                    ))),
                                    Err(se) => {
                                        warn!("XMPP sending error: {}", se);
                                        future::err((account, Ok(Either::B(t))))
                                    }
                                })),
                                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: {}", String::from(&s));
                Ok(false)
            }
            _ => {
                error!("Disconnected while online");
                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... {}", String::from(&get_roster));
        data.pending_ids.insert(
            id_init_roster.clone(),
            (
                Instant::now() + Duration::from_secs(60),
                Box::new(InitRosterIqHandler {}),
            ),
        );
        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, _| Ok(conn.state.data.roster_init), stop_future)
                .map_err(|(account, _)| account)
                .and_then(|(conn, r)| match r {
                    Ok(Either::A(_)) => future::ok(conn),
                    Ok(Either::B(_)) => future::err(conn.account),
                    Err(_e) => future::err(conn.account),
                })
            })
    }
    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... {}", String::from(&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, _| Ok(conn.state.data.self_presence),
                    stop_future,
                )
                .map_err(|(account, _)| account)
                .and_then(|(conn, r)| match r {
                    Ok(Either::A(_)) => future::ok(conn),
                    Ok(Either::B(_)) => future::err(conn.account),
                    Err(_e) => future::err(conn.account),
                })
            })
    }
    fn process_jid(&mut self, xmpp_to: &xmpp_parsers::Jid) {
        if let Some(ref mut mailbox) = self.state.data.outgoing_mailbox.get_mut(xmpp_to) {
            if !mailbox.is_empty() {
                if let Some(ref mut rdata) = self.state.data.roster.get_mut(xmpp_to) {
                    info!("Jid {} in roster", xmpp_to);
                    let sub_to = match rdata.0 {
                        xmpp_parsers::roster::Subscription::To => true,
                        xmpp_parsers::roster::Subscription::Both => true,
                        _ => false,
                    };
                    if sub_to {
                        info!("Subscribed to {}", xmpp_to);
                        self.state.data.send_queue.extend(
                            mailbox.drain(..).map(|message| {
                                stanzas::make_chat_message(xmpp_to.clone(), message)
                            }),
                        );
                    } else if rdata.1 == xmpp_parsers::roster::Ask::None {
                        info!("Not subscribed to {}", xmpp_to);
                        self.state
                            .data
                            .send_queue
                            .push_back(stanzas::make_ask_subscribe(xmpp_to.clone()));
                    }
                    let sub_from = match rdata.0 {
                        xmpp_parsers::roster::Subscription::From => true,
                        xmpp_parsers::roster::Subscription::Both => true,
                        _ => false,
                    };
                    if !sub_from {
                        info!("Not subscription from {}", xmpp_to);
                        self.state
                            .data
                            .send_queue
                            .push_back(stanzas::make_allow_subscribe(xmpp_to.clone()));
                    }
                } else {
                    info!("Jid {} not in roster", xmpp_to);
                    self.state.data.counter += 1;
                    let id_add_roster = format!("id_add_roster{}", self.state.data.counter);
                    let add_roster = stanzas::make_add_roster(&id_add_roster, xmpp_to.clone());
                    info!("Adding jid {} to roster id {}", xmpp_to, id_add_roster);
                    self.state.data.pending_ids.insert(
                        id_add_roster,
                        (
                            Instant::now() + Duration::from_secs(60),
                            Box::new(AddRosterIqHandler {
                                jid: xmpp_to.clone(),
                            }),
                        ),
                    );
                    self.state.data.send_queue.push_back(add_roster);
                }
            }
        }
    }
    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);
                self.state.data.pending_ids.insert(
                    id_ping,
                    (
                        Instant::now() + Duration::from_secs(30),
                        Box::new(PingIqHandler {}),
                    ),
                );
            }
            XmppCommand::TimeoutCleanup => {
                let now = Instant::now();
                let timeouted: Vec<String> = self
                    .state
                    .data
                    .pending_ids
                    .iter()
                    .filter_map(|(id, (timeout, _))| {
                        if now >= *timeout {
                            Some(id.to_string())
                        } else {
                            None
                        }
                    })
                    .collect();
                let mut correct = true;
                timeouted.into_iter().for_each(|id| {
                    if let Some((_, handler)) = self.state.data.pending_ids.remove(&id) {
                        correct &= handler.timeout(&mut self);
                    }
                })
            }
        }
    }
    pub fn shutdown(self) -> impl Future<Item = (), Error = failure::Error> {
        info!("Shutdown connection");
        let XmppConnection { account, state } = self;
        stream::iter_ok(
            state
                .data
                .mucs
                .values()
                .map(std::clone::Clone::clone)
                .collect::<Vec<_>>(),
        )
        .fold(state, move |XmppState { client, data }, muc_jid| {
            let muc_presence =
                stanzas::make_muc_presence_leave(account.jid.clone(), muc_jid.clone());
            info!(
                "Sending muc leave presence... {}",
                String::from(&muc_presence)
            );
            use tokio::prelude::Sink;
            client
                .send(Packet::Stanza(muc_presence))
                .map_err(|e| {
                    error!("Error on send muc presence: {}", e);
                    e
                })
                .and_then(|client| future::ok(XmppState { client, data }))
        })
        .map(|_| ())
    }
    fn enter_mucs<F, E>(
        self,
        _stop_future: F,
    ) -> impl Future<Item = Self, Error = std::rc::Rc<config::Account>>
    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... {}", String::from(&muc_presence));
                let account4 = account2.clone();
                use tokio::prelude::Sink;
                client
                    .send(Packet::Stanza(muc_presence))
                    .map_err(|e| {
                        error!("Error on send muc presence: {}", e);
                        account4
                    })
                    .and_then(|client| {
                        data.mucs.insert(muc_jid.0, muc_jid.1);
                        future::ok(XmppState { client, data })
                    })
            })
            .map(|state| XmppConnection {
                account: account3,
                state,
            })
    }
}
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 std::time::{Duration, Instant};
use super::stanzas;
use super::element_processor;
use crate::config;
#[derive(Debug)]
pub enum XmppCommand {
    /// Send message to someone by jid
    Chat {
        xmpp_to: xmpp_parsers::Jid,
        message: String,
    },
    /// Send message to MUC
    Chatroom { muc_id: String, message: String },
    /// Send ping request to the server to test connection
    Ping,
    /// Check iq requests if some have expired timeouts
    TimeoutCleanup,
}
/// trait of processing iq
/// each function consumes handlers and
/// returns false if connection should be reset
trait IqHandler {
    /// process result
    fn result(
        self: Box<Self>,
        conn: &mut XmppConnection,
        opt_element: Option<xmpp_parsers::Element>,
    ) -> bool;
    /// process error
    fn error(
        self: Box<Self>,
        conn: &mut XmppConnection,
        error: xmpp_parsers::stanza_error::StanzaError,
    ) -> bool;
    /// process tmeout
    fn timeout(self: Box<Self>, conn: &mut XmppConnection) -> bool;
}
struct AddRosterIqHandler {
    jid: xmpp_parsers::Jid,
}
impl IqHandler for AddRosterIqHandler {
    fn result(
        self: Box<Self>,
        conn: &mut XmppConnection,
        opt_element: Option<xmpp_parsers::Element>,
    ) -> bool {
        match opt_element {
            Some(element) => {
                warn!(
                    "Wrong payload when adding {} to roster: {}",
                    self.jid,
                    String::from(&element)
                );
            }
            None => {
                if conn.state.data.roster.contains_key(&self.jid) {
                    info!("Jid {} updated to roster", self.jid);
                } else {
                    info!("Jid {} added in roster", self.jid);
                    conn.state.data.roster.insert(
                        self.jid.clone(),
                        (
                            xmpp_parsers::roster::Subscription::None,
                            xmpp_parsers::roster::Ask::None,
                        ),
                    );
                }
                conn.process_jid(&self.jid);
            }
        }
        true
    }
    fn error(
        self: Box<Self>,
        _conn: &mut XmppConnection,
        _error: xmpp_parsers::stanza_error::StanzaError,
    ) -> bool {
        true
    }
    fn timeout(self: Box<Self>, _conn: &mut XmppConnection) -> bool {
        true // ignore
    }
}
struct PingIqHandler {}
impl IqHandler for PingIqHandler {
    fn result(
        self: Box<Self>,
        _conn: &mut XmppConnection,
        _opt_element: Option<xmpp_parsers::Element>,
    ) -> bool {
        info!("ping successed");
        true
    }
    fn error(
        self: Box<Self>,
        _conn: &mut XmppConnection,
        _error: xmpp_parsers::stanza_error::StanzaError,
    ) -> bool {
        false
    }
    fn timeout(self: Box<Self>, _conn: &mut XmppConnection) -> bool {
        false
    }
}
struct InitRosterIqHandler {}
impl IqHandler for InitRosterIqHandler {
    fn result(
        self: Box<Self>,
        conn: &mut XmppConnection,
        opt_element: Option<xmpp_parsers::Element>,
    ) -> bool {
        if let Some(result) = opt_element {
            use std::convert::TryInto;
            match result.try_into() as Result<xmpp_parsers::roster::Roster, _> {
                Ok(roster) => {
                    conn.state.data.roster_init = true;
                    conn.state.data.roster.clear();
                    info!("Got first roster:");
                    for i in roster.items {
                        info!(" >>> {:?}", i);
                        conn.state
                            .data
                            .roster
                            .insert(i.jid, (i.subscription, i.ask));
                    }
                    true
                }
                Err(e) => {
                    error!("Cann't parse roster: {}", e);
                    false
                }
            }
        } else {
            error!("No roster responded");
            false
        }
    }
    fn error(
        self: Box<Self>,
        _conn: &mut XmppConnection,
        _error: xmpp_parsers::stanza_error::StanzaError,
    ) -> bool {
        false
    }
    fn timeout(self: Box<Self>, _conn: &mut XmppConnection) -> bool {
        false
    }
}
#[derive(Default)]
struct XmppData {
    /// known roster data
    roster: HashMap<
        xmpp_parsers::Jid,
        (
            xmpp_parsers::roster::Subscription,
            xmpp_parsers::roster::Ask,
        ),
    >,
    /// if roster was initialized
    /// ToDo: remove it as it is used only for initialization
    roster_init: bool,
    /// if self-presence accepted
    /// ToDo: remove it as it is used only for initialization
    self_presence: bool,
    /// ids counter
    counter: usize,
    /// 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>,
    /// map from iq's id to handler of this type of iqs
    pending_ids: HashMap<String, (Instant, Box<dyn IqHandler>)>,
}
struct XmppState {
    client: Client,
    data: XmppData,
}
pub struct XmppConnection {
    account: std::rc::Rc<config::Account>,
    state: XmppState,
}
trait IqRequestHandler {
    fn process(
        self: Box<Self>,
        conn: &mut XmppConnection,
        id: String,
        from: Option<xmpp_parsers::Jid>,
    ) -> xmpp_parsers::iq::Iq;
}
struct IqRequestUnknown {
    element: xmpp_parsers::Element,
    type_: &'static str,
}
impl IqRequestHandler for IqRequestUnknown {
    fn process(
        self: Box<Self>,
        conn: &mut XmppConnection,
        id: String,
        from: Option<xmpp_parsers::Jid>,
    ) -> xmpp_parsers::iq::Iq {
        warn!(
            "Unsupported IQ {} request from {:?}: {}",
            self.type_,
            from,
            String::from(&self.element)
        );
        stanzas::make_iq_unsupported_error(id, conn.state.client.jid.clone(), from)
    }
}
struct IqSetRoster {}
impl IqRequestHandler for IqSetRoster {
    fn process(
        self: Box<Self>,
        conn: &mut XmppConnection,
        id: String,
        from: Option<xmpp_parsers::Jid>,
    ) -> xmpp_parsers::iq::Iq {
        info!("Got roster push {} from {:?}", id, from);
        stanzas::make_roster_push_answer(id, conn.state.client.jid.clone(), from)
    }
}
struct IqGetPing {}
impl IqRequestHandler for IqGetPing {
    fn process(
        self: Box<Self>,
        conn: &mut XmppConnection,
        id: String,
        from: Option<xmpp_parsers::Jid>,
    ) -> xmpp_parsers::iq::Iq {
        info!("Got ping {} from {:?}", id, from);
        stanzas::make_pong(id, conn.state.client.jid.clone(), from)
    }
}
struct IqGetDiscoInfo {}
impl IqRequestHandler for IqGetDiscoInfo {
    fn process(
        self: Box<Self>,
        conn: &mut XmppConnection,
        id: String,
        from: Option<xmpp_parsers::Jid>,
    ) -> xmpp_parsers::iq::Iq {
        info!("Got disco query {} from {:?}", id, from);
        stanzas::make_disco_info_result(id, conn.state.client.jid.clone(), from)
    }
}
struct IqGetDiscoItems {}
impl IqRequestHandler for IqGetDiscoItems {
    fn process(
        self: Box<Self>,
        conn: &mut XmppConnection,
        id: String,
        from: Option<xmpp_parsers::Jid>,
    ) -> xmpp_parsers::iq::Iq {
        info!("Got disco items query {} from {:?}", id, from);
        stanzas::make_disco_items_result(id, conn.state.client.jid.clone(), from)
    }
}
struct IqGetDiscoCommands {}
impl IqRequestHandler for IqGetDiscoCommands {
    fn process(
        self: Box<Self>,
        conn: &mut XmppConnection,
        id: String,
        from: Option<xmpp_parsers::Jid>,
    ) -> xmpp_parsers::iq::Iq {
        info!("Got disco commands query {} from {:?}", id, from);
        stanzas::make_disco_items_commands(id, conn.state.client.jid.clone(), from)
    }
}
lazy_static! {
    static ref INCOMING: element_processor::Processor<XmppConnection, bool, xmpp_parsers::Element> = {
        let mut incoming = element_processor::Processor::new(&|_, e| {
            warn!("Unknown stanza {}", String::from(&e));
            true
        });
        incoming.register(&XmppConnection::incoming_iq_processing);
        incoming.register(&XmppConnection::incoming_presence_processing);
        incoming.register(&XmppConnection::incoming_message_processing);
        incoming
    };
    static ref INCOMING_IQ_SET: element_processor::Processor<XmppConnection, Box<dyn IqRequestHandler>, xmpp_parsers::Element> = {
        let mut iq_set =
            element_processor::Processor::new(&|_conn: &mut XmppConnection, element| {
                Box::new(IqRequestUnknown {
                    element,
                    type_: "set",
                }) as Box<dyn IqRequestHandler>
            });
        iq_set.register(&XmppConnection::incoming_iq_processing_set_roster);
        iq_set
    };
    static ref INCOMING_IQ_GET: element_processor::Processor<XmppConnection, Box<dyn IqRequestHandler>, xmpp_parsers::Element> = {
        let mut iq_get =
            element_processor::Processor::new(&|_conn: &mut XmppConnection, element| {
                Box::new(IqRequestUnknown {
                    element,
                    type_: "get",
                }) as Box<dyn IqRequestHandler>
            });
        iq_get.register(&XmppConnection::incoming_iq_processing_get_ping);
        iq_get.register(&XmppConnection::incoming_iq_processing_get_disco_info);
        iq_get.register(&XmppConnection::incoming_iq_processing_get_disco_items);
        iq_get
    };
}
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) => INCOMING.process(self, stanza.clone()),
            Event::Online => true,
            e => {
                warn!("Unexpected event {:?}", e);
                false
            }
        }
    }
    /// Process roster push
    /// see RFC 6212 2.1.6. Roster Push
    fn incoming_iq_processing_set_roster(
        &mut self,
        roster: xmpp_parsers::roster::Roster,
    ) -> Box<dyn IqRequestHandler> {
        for i in roster.items {
            if let Some(ref mut rdata) = self.state.data.roster.get_mut(&i.jid) {
                info!("Update {} in roster", i.jid);
                rdata.0 = i.subscription;
                rdata.1 = i.ask;
            } else {
                info!("Add {} to roster", i.jid);
                self.state
                    .data
                    .roster
                    .insert(i.jid.clone(), (i.subscription, i.ask));
            }
            self.process_jid(&i.jid);
        }
        Box::new(IqSetRoster {})
    }
    /// Enforce to answer to IQ "set"
    fn incoming_iq_processing_set(
        &mut self,
        id: String,
        from: Option<xmpp_parsers::Jid>,
        element: minidom::Element,
    ) -> xmpp_parsers::iq::Iq {
        INCOMING_IQ_SET
            .process(self, element)
            .process(self, id, from)
    }
    /// Process ping request
    /// see XEP-0199: XMPP Ping
    fn incoming_iq_processing_get_ping(
        &mut self,
        _ping: xmpp_parsers::ping::Ping,
    ) -> Box<dyn IqRequestHandler> {
        Box::new(IqGetPing {})
    }
    /// Process disco query
    /// see XEP-0030: Service Discovery
    fn incoming_iq_processing_get_disco_info(
        &mut self,
        disco: xmpp_parsers::disco::DiscoInfoQuery,
    ) -> Box<dyn IqRequestHandler> {
        if let Some(ref node) = disco.node {
            warn!("Unsupported node {}", node);
            Box::new(IqRequestUnknown {
                element: disco.into(),
                type_: "get",
            })
        } else {
            Box::new(IqGetDiscoInfo {})
        }
    }
    /// Process disco items query
    /// see XEP-0030: Service Discovery
    fn incoming_iq_processing_get_disco_items(
        &mut self,
        disco: xmpp_parsers::disco::DiscoItemsQuery,
    ) -> Box<dyn IqRequestHandler> {
        match &disco.node {
            Some(node) if node == "http://jabber.org/protocol/commands" => {
                Box::new(IqGetDiscoCommands {})
            }
            Some(node) => {
                warn!("Unsupported node {}", node);
                Box::new(IqRequestUnknown {
                    element: disco.into(),
                    type_: "get",
                })
            }
            None => Box::new(IqGetDiscoItems {}),
        }
    }
    /// Enforce to answer to IQ "get"
    fn incoming_iq_processing_get(
        &mut self,
        id: String,
        from: Option<xmpp_parsers::Jid>,
        element: minidom::Element,
    ) -> xmpp_parsers::iq::Iq {
        INCOMING_IQ_GET
            .process(self, element)
            .process(self, id, from)
    }
    fn incoming_iq_processing(&mut self, iq: xmpp_parsers::iq::Iq) -> bool {
        match iq.payload {
            xmpp_parsers::iq::IqType::Set(element) => {
                let iq_answer = self.incoming_iq_processing_set(iq.id, iq.from, element);
                self.state.data.send_queue.push_back(iq_answer.into());
            }
            xmpp_parsers::iq::IqType::Error(e) => {
                if let Some((_, handler)) = self.state.data.pending_ids.remove_entry(&iq.id) {
                    return handler.1.error(self, e);
                }
                error!("iq error: {:?}", e);
                return false;
            }
            xmpp_parsers::iq::IqType::Get(element) => {
                let iq_answer = self.incoming_iq_processing_get(iq.id, iq.from, element);
                self.state.data.send_queue.push_back(iq_answer.into());
            }
            xmpp_parsers::iq::IqType::Result(opt_element) => {
                if let Some((_, handler)) = self.state.data.pending_ids.remove_entry(&iq.id) {
                    return handler.1.result(self, opt_element);
                }
                warn!(
                    "Unwanted iq result id {} from {:?}: {:?}",
                    iq.id,
                    iq.from,
                    opt_element.map(|e| String::from(&e))
                );
            }
        }
        true
    }
    fn incoming_presence_processing(&mut self, presence: xmpp_parsers::presence::Presence) -> bool {
        if presence.from.as_ref() == Some(&self.state.client.jid) {
            info!("Self-presence accepted");
            self.state.data.self_presence = true;
        } else {
            warn!("Incoming presence stanza: {:?}", presence);
        }
        true
    }
    fn incoming_message_processing(&mut self, message: xmpp_parsers::message::Message) -> bool {
        for payload in message.payloads.iter() {
            use std::convert::TryInto;
            if let Some(_delay) =
                payload.clone().try_into().ok() as Option<xmpp_parsers::delay::Delay>
            {
                return true; // ignore delayed messages
            }
        }
        warn!("Incoming message stanza: {:?}", message);
        true
    }
    /// 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)| {
                // ToDo: check timeouts if iqs
                let XmppConnection {
                    state: XmppState { client, mut data },
                    account,
                } = xmpp;
                if let Some(send_element) = data.send_queue.pop_front() {
                    use tokio::prelude::Sink;
                    info!("Sending {}", String::from(&send_element));
                    Box::new(
                        client
                            .send(Packet::Stanza(send_element))
                            .select2(stop_future)
                            .then(move |r| match r {
                                Ok(Either::A((client, b))) => {
                                    Box::new(future::ok(future::Loop::Continue((
                                        XmppConnection {
                                            state: XmppState { client, data },
                                            account,
                                        },
                                        b,
                                        stop_condition,
                                    ))))
                                        as Box<dyn Future<Item = _, Error = _>>
                                }
                                Ok(Either::B((t, a))) => Box::new(a.then(|r| match r {
                                    Ok(client) => future::ok(future::Loop::Break((
                                        XmppConnection {
                                            state: XmppState { client, data },
                                            account,
                                        },
                                        Ok(Either::B(t)),
                                    ))),
                                    Err(se) => {
                                        warn!("XMPP sending error: {}", se);
                                        future::err((account, Ok(Either::B(t))))
                                    }
                                })),
                                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: {}", String::from(&s));
                Ok(false)
            }
            _ => {
                error!("Disconnected while online");
                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... {}", String::from(&get_roster));
        data.pending_ids.insert(
            id_init_roster.clone(),
            (
                Instant::now() + Duration::from_secs(60),
                Box::new(InitRosterIqHandler {}),
            ),
        );
        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, _| Ok(conn.state.data.roster_init), stop_future)
                .map_err(|(account, _)| account)
                .and_then(|(conn, r)| match r {
                    Ok(Either::A(_)) => future::ok(conn),
                    Ok(Either::B(_)) => future::err(conn.account),
                    Err(_e) => future::err(conn.account),
                })
            })
    }
    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... {}", String::from(&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, _| Ok(conn.state.data.self_presence),
                    stop_future,
                )
                .map_err(|(account, _)| account)
                .and_then(|(conn, r)| match r {
                    Ok(Either::A(_)) => future::ok(conn),
                    Ok(Either::B(_)) => future::err(conn.account),
                    Err(_e) => future::err(conn.account),
                })
            })
    }
    fn process_jid(&mut self, xmpp_to: &xmpp_parsers::Jid) {
        if let Some(ref mut mailbox) = self.state.data.outgoing_mailbox.get_mut(xmpp_to) {
            if !mailbox.is_empty() {
                if let Some(ref mut rdata) = self.state.data.roster.get_mut(xmpp_to) {
                    info!("Jid {} in roster", xmpp_to);
                    let sub_to = match rdata.0 {
                        xmpp_parsers::roster::Subscription::To => true,
                        xmpp_parsers::roster::Subscription::Both => true,
                        _ => false,
                    };
                    if sub_to {
                        info!("Subscribed to {}", xmpp_to);
                        self.state.data.send_queue.extend(
                            mailbox.drain(..).map(|message| {
                                stanzas::make_chat_message(xmpp_to.clone(), message)
                            }),
                        );
                    } else if rdata.1 == xmpp_parsers::roster::Ask::None {
                        info!("Not subscribed to {}", xmpp_to);
                        self.state
                            .data
                            .send_queue
                            .push_back(stanzas::make_ask_subscribe(xmpp_to.clone()));
                    }
                    let sub_from = match rdata.0 {
                        xmpp_parsers::roster::Subscription::From => true,
                        xmpp_parsers::roster::Subscription::Both => true,
                        _ => false,
                    };
                    if !sub_from {
                        info!("Not subscription from {}", xmpp_to);
                        self.state
                            .data
                            .send_queue
                            .push_back(stanzas::make_allow_subscribe(xmpp_to.clone()));
                    }
                } else {
                    info!("Jid {} not in roster", xmpp_to);
                    self.state.data.counter += 1;
                    let id_add_roster = format!("id_add_roster{}", self.state.data.counter);
                    let add_roster = stanzas::make_add_roster(&id_add_roster, xmpp_to.clone());
                    info!("Adding jid {} to roster id {}", xmpp_to, id_add_roster);
                    self.state.data.pending_ids.insert(
                        id_add_roster,
                        (
                            Instant::now() + Duration::from_secs(60),
                            Box::new(AddRosterIqHandler {
                                jid: xmpp_to.clone(),
                            }),
                        ),
                    );
                    self.state.data.send_queue.push_back(add_roster);
                }
            }
        }
    }
    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);
                self.state.data.pending_ids.insert(
                    id_ping,
                    (
                        Instant::now() + Duration::from_secs(30),
                        Box::new(PingIqHandler {}),
                    ),
                );
            }
            XmppCommand::TimeoutCleanup => {
                let now = Instant::now();
                let timeouted: Vec<String> = self
                    .state
                    .data
                    .pending_ids
                    .iter()
                    .filter_map(|(id, (timeout, _))| {
                        if now >= *timeout {
                            Some(id.to_string())
                        } else {
                            None
                        }
                    })
                    .collect();
                let mut correct = true;
                timeouted.into_iter().for_each(|id| {
                    if let Some((_, handler)) = self.state.data.pending_ids.remove(&id) {
                        correct &= handler.timeout(&mut self);
                    }
                })
            }
        }
    }
    pub fn shutdown(self) -> impl Future<Item = (), Error = failure::Error> {
        info!("Shutdown connection");
        let XmppConnection { account, state } = self;
        stream::iter_ok(
            state
                .data
                .mucs
                .values()
                .map(std::clone::Clone::clone)
                .collect::<Vec<_>>(),
        )
        .fold(state, move |XmppState { client, data }, muc_jid| {
            let muc_presence =
                stanzas::make_muc_presence_leave(account.jid.clone(), muc_jid.clone());
            info!(
                "Sending muc leave presence... {}",
                String::from(&muc_presence)
            );
            use tokio::prelude::Sink;
            client
                .send(Packet::Stanza(muc_presence))
                .map_err(|e| {
                    error!("Error on send muc presence: {}", e);
                    e
                })
                .and_then(|client| future::ok(XmppState { client, data }))
        })
        .map(|_| ())
    }
    fn enter_mucs<F, E>(
        self,
        _stop_future: F,
    ) -> impl Future<Item = Self, Error = std::rc::Rc<config::Account>>
    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... {}", String::from(&muc_presence));
                let account4 = account2.clone();
                use tokio::prelude::Sink;
                client
                    .send(Packet::Stanza(muc_presence))
                    .map_err(|e| {
                        error!("Error on send muc presence: {}", e);
                        account4
                    })
                    .and_then(|client| {
                        data.mucs.insert(muc_jid.0, muc_jid.1);
                        future::ok(XmppState { client, data })
                    })
            })
            .map(|state| XmppConnection {
                account: account3,
                state,
            })
    }
}
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 std::time::{Duration, Instant};
use super::stanzas;
use super::element_processor;
use crate::config;
#[derive(Debug)]
pub enum XmppCommand {
    /// Send message to someone by jid
    Chat {
        xmpp_to: xmpp_parsers::Jid,
        message: String,
    },
    /// Send message to MUC
    Chatroom {
        muc_id: String,
        message: String,
    },
    // Send ping request to the server to test connection
    Ping,
    /// Check iq requests if some have expired timeouts
    TimeoutCleanup,
}
/// trait of processing iq
/// each function consumes handlers and
/// returns false if connection should be reset
trait IqHandler {
    /// process result
    fn result(
        self: Box<Self>,
        conn: &mut XmppConnection,
        opt_element: Option<xmpp_parsers::Element>,
    ) -> bool;
    /// process error
    fn error(
        self: Box<Self>,
        conn: &mut XmppConnection,
        error: xmpp_parsers::stanza_error::StanzaError,
    ) -> bool;
    /// process tmeout
    fn timeout(self: Box<Self>, conn: &mut XmppConnection) -> bool;
}
struct AddRosterIqHandler {
    jid: xmpp_parsers::Jid,
}
impl IqHandler for AddRosterIqHandler {
    fn result(
        self: Box<Self>,
        conn: &mut XmppConnection,
        opt_element: Option<xmpp_parsers::Element>,
    ) -> bool {
        match opt_element {
            Some(element) => {
                warn!(
                    "Wrong payload when adding {} to roster: {}",
                    self.jid,
                    String::from(&element)
                );
            }
            None => {
                if conn.state.data.roster.contains_key(&self.jid) {
                    info!("Jid {} updated to roster", self.jid);
                } else {
                    info!("Jid {} added in roster", self.jid);
                    conn.state.data.roster.insert(
                        self.jid.clone(),
                        (
                            xmpp_parsers::roster::Subscription::None,
                            xmpp_parsers::roster::Ask::None,
                        ),
                    );
                }
                conn.process_jid(&self.jid);
            }
        }
        true
    }
    fn error(
        self: Box<Self>,
        _conn: &mut XmppConnection,
        _error: xmpp_parsers::stanza_error::StanzaError,
    ) -> bool {
        true
    }
    fn timeout(self: Box<Self>, _conn: &mut XmppConnection) -> bool {
        true // ignore
    }
}
struct PingIqHandler {}
impl IqHandler for PingIqHandler {
    fn result(
        self: Box<Self>,
        _conn: &mut XmppConnection,
        _opt_element: Option<xmpp_parsers::Element>,
    ) -> bool {
        true // ignore
    }
    fn error(
        self: Box<Self>,
        _conn: &mut XmppConnection,
        _error: xmpp_parsers::stanza_error::StanzaError,
    ) -> bool {
        false
    }
    fn timeout(self: Box<Self>, _conn: &mut XmppConnection) -> bool {
        false
    }
}
struct InitRosterIqHandler {}
impl IqHandler for InitRosterIqHandler {
    fn result(
        self: Box<Self>,
        conn: &mut XmppConnection,
        opt_element: Option<xmpp_parsers::Element>,
    ) -> bool {
        if let Some(result) = opt_element {
            use std::convert::TryInto;
            match result.try_into() as Result<xmpp_parsers::roster::Roster, _> {
                Ok(roster) => {
                    conn.state.data.roster_init = true;
                    conn.state.data.roster.clear();
                    info!("Got first roster:");
                    for i in roster.items {
                        info!(" >>> {:?}", i);
                        conn.state
                            .data
                            .roster
                            .insert(i.jid, (i.subscription, i.ask));
                    }
                    true
                }
                Err(e) => {
                    error!("Cann't parse roster: {}", e);
                    false
                }
            }
        } else {
            error!("No roster responded");
            false
        }
    }
    fn error(
        self: Box<Self>,
        _conn: &mut XmppConnection,
        _error: xmpp_parsers::stanza_error::StanzaError,
    ) -> bool {
        false
    }
    fn timeout(self: Box<Self>, _conn: &mut XmppConnection) -> bool {
        false
    }
}
/// data for awaiting iq answer
struct IqWait {
    /// time of sending iq
    sent: Instant,
    /// timeout
    timeout: Duration,
    /// handler for iq processing
    handler: Box<dyn IqHandler>,
}
impl IqWait {
    pub fn new<T: IqHandler + 'static>(timeout_secs: u64, handler: T) -> IqWait {
        IqWait {
            sent: Instant::now(),
            timeout: Duration::from_secs(timeout_secs),
            handler: Box::new(handler),
        }
    }
}
#[derive(Default)]
struct XmppData {
    /// known roster data
    roster: HashMap<
        xmpp_parsers::Jid,
        (
            xmpp_parsers::roster::Subscription,
            xmpp_parsers::roster::Ask,
        ),
    >,
    /// if roster was initialized
    /// ToDo: remove it as it used only for initialization
    roster_init: bool,
    /// ids counter
    counter: usize,
    /// 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>,
    /// map from iq's id to handler of this type of iqs
    pending_ids: HashMap<String, IqWait>,
}
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 {}", String::from(&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
            }
        }
    }
    /// Enforce to answer to IQ "set"
    fn incoming_iq_processing_set(
        &mut self,
        id: String,
        from: Option<xmpp_parsers::Jid>,
        element: minidom::Element,
    ) -> xmpp_parsers::iq::Iq {
        use std::convert::TryInto;
        if let Some(roster) =
            element.clone().try_into().ok() as Option<xmpp_parsers::roster::Roster>
        {
            // RFC 6212 2.1.6. Roster Push
            for i in roster.items {
                if let Some(ref mut rdata) = self.state.data.roster.get_mut(&i.jid) {
                    info!("Update {} in roster", i.jid);
                    rdata.0 = i.subscription;
                    rdata.1 = i.ask;
                } else {
                    info!("Add {} to roster", i.jid);
                    self.state
                        .data
                        .roster
                        .insert(i.jid.clone(), (i.subscription, i.ask));
                }
                self.process_jid(&i.jid);
            }
            return stanzas::make_roster_push_answer(id, self.state.client.jid.clone(), from);
        }
        warn!(
            "Unsupported IQ set request from {:?}: {}",
            from,
            String::from(&element)
        );
        stanzas::make_iq_unsupported_error(id, self.state.client.jid.clone(), from)
    }
    /// Enforce to answer to IQ "get"
    fn incoming_iq_processing_get(
        &mut self,
        id: String,
        from: Option<xmpp_parsers::Jid>,
        element: minidom::Element,
    ) -> xmpp_parsers::iq::Iq {
        use std::convert::TryInto;
        if let Some(_ping) = element.clone().try_into().ok() as Option<xmpp_parsers::ping::Ping> {
            return stanzas::make_pong(&id, self.state.client.jid.clone(), from);
        }
        warn!(
            "Unsupported IQ get request from {:?}: {}",
            from,
            String::from(&element)
        );
        stanzas::make_iq_unsupported_error(id, self.state.client.jid.clone(), from)
    }
    fn incoming_iq_processing(&mut self, iq: xmpp_parsers::iq::Iq) -> bool {
        match iq.payload {
            xmpp_parsers::iq::IqType::Set(element) => {
                let iq_answer = self.incoming_iq_processing_set(iq.id, iq.from, element);
                self.state.data.send_queue.push_back(iq_answer.into());
            }
            xmpp_parsers::iq::IqType::Error(e) => {
                if let Some((_, data)) = self.state.data.pending_ids.remove_entry(&iq.id) {
                    return data.handler.error(self, e);
                }
                error!("iq error: {:?}", e);
                return false;
            }
            xmpp_parsers::iq::IqType::Get(element) => {
                let iq_answer = self.incoming_iq_processing_get(iq.id, iq.from, element);
                self.state.data.send_queue.push_back(iq_answer.into());
            }
            xmpp_parsers::iq::IqType::Result(opt_element) => {
                if let Some((_, data)) = self.state.data.pending_ids.remove_entry(&iq.id) {
                    let now = Instant::now();
                    if data.sent + data.timeout > now {
                        info!(
                            "Timeout for {} was {:?} expected {:?}",
                            iq.id,
                            now - data.sent,
                            data.timeout
                        );
                        return data.handler.result(self, opt_element);
                    } else {
                        warn!(
                            "Timeout for {} was {:?} expected {:?}",
                            iq.id,
                            now - data.sent,
                            data.timeout
                        );
                        return data.handler.timeout(self);
                    }
                }
                warn!(
                    "Unwanted iq result id {} from {:?}: {:?}",
                    iq.id,
                    iq.from,
                    opt_element.map(|e| String::from(&e))
                );
            }
        }
        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 {}", String::from(&send_element));
                    Box::new(
                        client
                            .send(Packet::Stanza(send_element))
                            .select2(stop_future)
                            .then(move |r| match r {
                                Ok(Either::A((client, b))) => {
                                    Box::new(future::ok(future::Loop::Continue((
                                        XmppConnection {
                                            state: XmppState { client, data },
                                            account,
                                        },
                                        b,
                                        stop_condition,
                                    ))))
                                        as Box<dyn Future<Item = _, Error = _>>
                                }
                                Ok(Either::B((t, a))) => Box::new(a.then(|r| match r {
                                    Ok(client) => future::ok(future::Loop::Break((
                                        XmppConnection {
                                            state: XmppState { client, data },
                                            account,
                                        },
                                        Ok(Either::B(t)),
                                    ))),
                                    Err(se) => {
                                        warn!("XMPP sending error: {}", se);
                                        future::err((account, Ok(Either::B(t))))
                                    }
                                })),
                                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: {}", String::from(&s));
                Ok(false)
            }
            _ => {
                error!("Disconnected while online");
                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... {}", String::from(&get_roster));
        data.pending_ids.insert(
            id_init_roster.clone(),
            IqWait::new(60, InitRosterIqHandler {}),
        );
        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, _| Ok(conn.state.data.roster_init), stop_future)
                .map_err(|(account, _)| account)
                .and_then(|(conn, r)| match r {
                    Ok(Either::A(_)) => future::ok(conn),
                    Ok(Either::B(_)) => future::err(conn.account),
                    Err(_e) => future::err(conn.account),
                })
            })
    }
    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... {}", String::from(&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());
                    info!("Adding jid {} to roster id {}", xmpp_to, id_add_roster);
                    self.state.data.pending_ids.insert(
                        id_add_roster,
                        IqWait::new(
                            60,
                            AddRosterIqHandler {
                                jid: xmpp_to.clone(),
                            },
                        ),
                    );
                    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);
                self.state
                    .data
                    .pending_ids
                    .insert(id_ping, IqWait::new(30, PingIqHandler {}));
            }
            XmppCommand::TimeoutCleanup => {
                let now = Instant::now();
                let timeouted: Vec<String> = self
                    .state
                    .data
                    .pending_ids
                    .iter()
                    .filter_map(|(id, data)| {
                        if now >= data.sent + data.timeout {
                            warn!(
                                "Timeout for {} was {:?} expected {:?}",
                                id,
                                now - data.sent,
                                data.timeout
                            );
                            Some(id.to_string())
                        } else {
                            None
                        }
                    })
                    .collect();
                let mut correct = true;
                timeouted.into_iter().for_each(|id| {
                    if let Some(data) = self.state.data.pending_ids.remove(&id) {
                        correct &= data.handler.timeout(&mut self);
                    }
                })
            }
        }
    }
    pub fn shutdown(self) -> impl Future<Item = (), Error = failure::Error> {
        info!("Shutdown connection");
        let XmppConnection { account, state } = self;
        stream::iter_ok(
            state
                .data
                .mucs
                .values()
                .map(std::clone::Clone::clone)
                .collect::<Vec<_>>(),
        )
        .fold(state, move |XmppState { client, data }, muc_jid| {
            let muc_presence =
                stanzas::make_muc_presence_leave(account.jid.clone(), muc_jid.clone());
            info!(
                "Sending muc leave presence... {}",
                String::from(&muc_presence)
            );
            use tokio::prelude::Sink;
            client
                .send(Packet::Stanza(muc_presence))
                .map_err(|e| {
                    error!("Error on send muc presence: {}", e);
                    e
                })
                .and_then(|client| future::ok(XmppState { client, data }))
        })
        .map(|_| ())
    }
    fn enter_mucs<F, E>(
        self,
        _stop_future: F,
    ) -> impl Future<Item = Self, Error = std::rc::Rc<config::Account>>
    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... {}", String::from(&muc_presence));
                let account4 = account2.clone();
                use tokio::prelude::Sink;
                client
                    .send(Packet::Stanza(muc_presence))
                    .map_err(|e| {
                        error!("Error on send muc presence: {}", e);
                        account4
                    })
                    .and_then(|client| {
                        data.mucs.insert(muc_jid.0, muc_jid.1);
                        future::ok(XmppState { client, data })
                    })
            })
            .map(|state| XmppConnection {
                account: account3,
                state,
            })
    }
}
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 std::time::{Duration, Instant};
use super::stanzas;
use super::element_processor;
use crate::config;
#[derive(Debug)]
pub enum XmppCommand {
    /// Send message to someone by jid
    Chat {
        xmpp_to: xmpp_parsers::Jid,
        message: String,
    },
    /// Send message to MUC
    Chatroom { muc_id: String, message: String },
    /// Send ping request to the server to test connection
    Ping,
    /// Check iq requests if some have expired timeouts
    TimeoutCleanup,
}
/// trait of processing iq
/// each function consumes handlers and
/// returns false if connection should be reset
trait IqHandler {
    /// process result
    fn result(
        self: Box<Self>,
        conn: &mut XmppConnection,
        opt_element: Option<xmpp_parsers::Element>,
    ) -> bool;
    /// process error
    fn error(
        self: Box<Self>,
        conn: &mut XmppConnection,
        error: xmpp_parsers::stanza_error::StanzaError,
    ) -> bool;
    /// process tmeout
    fn timeout(self: Box<Self>, conn: &mut XmppConnection) -> bool;
}
struct AddRosterIqHandler {
    jid: xmpp_parsers::Jid,
}
impl IqHandler for AddRosterIqHandler {
    fn result(
        self: Box<Self>,
        conn: &mut XmppConnection,
        opt_element: Option<xmpp_parsers::Element>,
    ) -> bool {
        match opt_element {
            Some(element) => {
                warn!(
                    "Wrong payload when adding {} to roster: {}",
                    self.jid,
                    String::from(&element)
                );
            }
            None => {
                if conn.state.data.roster.contains_key(&self.jid) {
                    info!("Jid {} updated to roster", self.jid);
                } else {
                    info!("Jid {} added in roster", self.jid);
                    conn.state.data.roster.insert(
                        self.jid.clone(),
                        (
                            xmpp_parsers::roster::Subscription::None,
                            xmpp_parsers::roster::Ask::None,
                        ),
                    );
                }
                conn.process_jid(&self.jid);
            }
        }
        true
    }
    fn error(
        self: Box<Self>,
        _conn: &mut XmppConnection,
        _error: xmpp_parsers::stanza_error::StanzaError,
    ) -> bool {
        true
    }
    fn timeout(self: Box<Self>, _conn: &mut XmppConnection) -> bool {
        true // ignore
    }
}
struct PingIqHandler {}
impl IqHandler for PingIqHandler {
    fn result(
        self: Box<Self>,
        _conn: &mut XmppConnection,
        _opt_element: Option<xmpp_parsers::Element>,
    ) -> bool {
        info!("ping successed");
        true
    }
    fn error(
        self: Box<Self>,
        _conn: &mut XmppConnection,
        _error: xmpp_parsers::stanza_error::StanzaError,
    ) -> bool {
        false
    }
    fn timeout(self: Box<Self>, _conn: &mut XmppConnection) -> bool {
        false
    }
}
struct InitRosterIqHandler {}
impl IqHandler for InitRosterIqHandler {
    fn result(
        self: Box<Self>,
        conn: &mut XmppConnection,
        opt_element: Option<xmpp_parsers::Element>,
    ) -> bool {
        if let Some(result) = opt_element {
            use std::convert::TryInto;
            match result.try_into() as Result<xmpp_parsers::roster::Roster, _> {
                Ok(roster) => {
                    conn.state.data.roster_init = true;
                    conn.state.data.roster.clear();
                    info!("Got first roster:");
                    for i in roster.items {
                        info!(" >>> {:?}", i);
                        conn.state
                            .data
                            .roster
                            .insert(i.jid, (i.subscription, i.ask));
                    }
                    true
                }
                Err(e) => {
                    error!("Cann't parse roster: {}", e);
                    false
                }
            }
        } else {
            error!("No roster responded");
            false
        }
    }
    fn error(
        self: Box<Self>,
        _conn: &mut XmppConnection,
        _error: xmpp_parsers::stanza_error::StanzaError,
    ) -> bool {
        false
    }
    fn timeout(self: Box<Self>, _conn: &mut XmppConnection) -> bool {
        false
    }
}
#[derive(Default)]
struct XmppData {
    /// known roster data
    roster: HashMap<
        xmpp_parsers::Jid,
        (
            xmpp_parsers::roster::Subscription,
            xmpp_parsers::roster::Ask,
        ),
    >,
    /// if roster was initialized
    /// ToDo: remove it as it is used only for initialization
    roster_init: bool,
    /// if self-presence accepted
    /// ToDo: remove it as it is used only for initialization
    self_presence: bool,
    /// ids counter
    counter: usize,
    /// 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>,
    /// map from iq's id to handler of this type of iqs
    pending_ids: HashMap<String, (Instant, Box<dyn IqHandler>)>,
}
struct XmppState {
    client: Client,
    data: XmppData,
}
pub struct XmppConnection {
    account: std::rc::Rc<config::Account>,
    state: XmppState,
}
trait IqRequestHandler {
    fn process(
        self: Box<Self>,
        conn: &mut XmppConnection,
        id: String,
        from: Option<xmpp_parsers::Jid>,
    ) -> xmpp_parsers::iq::Iq;
}
struct IqRequestUnknown {
    element: xmpp_parsers::Element,
    type_: &'static str,
}
impl IqRequestHandler for IqRequestUnknown {
    fn process(
        self: Box<Self>,
        conn: &mut XmppConnection,
        id: String,
        from: Option<xmpp_parsers::Jid>,
    ) -> xmpp_parsers::iq::Iq {
        warn!(
            "Unsupported IQ {} request from {:?}: {}",
            self.type_,
            from,
            String::from(&self.element)
        );
        stanzas::make_iq_unsupported_error(id, conn.state.client.jid.clone(), from)
    }
}
struct IqSetRoster {}
impl IqRequestHandler for IqSetRoster {
    fn process(
        self: Box<Self>,
        conn: &mut XmppConnection,
        id: String,
        from: Option<xmpp_parsers::Jid>,
    ) -> xmpp_parsers::iq::Iq {
        info!("Got roster push {} from {:?}", id, from);
        stanzas::make_roster_push_answer(id, conn.state.client.jid.clone(), from)
    }
}
struct IqGetPing {}
impl IqRequestHandler for IqGetPing {
    fn process(
        self: Box<Self>,
        conn: &mut XmppConnection,
        id: String,
        from: Option<xmpp_parsers::Jid>,
    ) -> xmpp_parsers::iq::Iq {
        info!("Got ping {} from {:?}", id, from);
        stanzas::make_pong(id, conn.state.client.jid.clone(), from)
    }
}
struct IqGetDiscoInfo {}
impl IqRequestHandler for IqGetDiscoInfo {
    fn process(
        self: Box<Self>,
        conn: &mut XmppConnection,
        id: String,
        from: Option<xmpp_parsers::Jid>,
    ) -> xmpp_parsers::iq::Iq {
        info!("Got disco query {} from {:?}", id, from);
        stanzas::make_disco_info_result(id, conn.state.client.jid.clone(), from)
    }
}
lazy_static! {
    static ref INCOMING: element_processor::Processor<XmppConnection, bool, xmpp_parsers::Element> = {
        let mut incoming = element_processor::Processor::new(&|_, e| {
            warn!("Unknown stanza {}", String::from(&e));
            true
        });
        incoming.register(&XmppConnection::incoming_iq_processing);
        incoming.register(&XmppConnection::incoming_presence_processing);
        incoming.register(&XmppConnection::incoming_message_processing);
        incoming
    };
    static ref INCOMING_IQ_SET: element_processor::Processor<XmppConnection, Box<dyn IqRequestHandler>, xmpp_parsers::Element> = {
        let mut iq_set =
            element_processor::Processor::new(&|_conn: &mut XmppConnection, element| {
                Box::new(IqRequestUnknown {
                    element,
                    type_: "set",
                }) as Box<dyn IqRequestHandler>
            });
        iq_set.register(&XmppConnection::incoming_iq_processing_set_roster);
        iq_set
    };
    static ref INCOMING_IQ_GET: element_processor::Processor<XmppConnection, Box<dyn IqRequestHandler>, xmpp_parsers::Element> = {
        let mut iq_get =
            element_processor::Processor::new(&|_conn: &mut XmppConnection, element| {
                Box::new(IqRequestUnknown {
                    element,
                    type_: "get",
                }) as Box<dyn IqRequestHandler>
            });
        iq_get.register(&XmppConnection::incoming_iq_processing_get_ping);
        iq_get.register(&XmppConnection::incoming_iq_processing_get_disco_info);
        iq_get
    };
}
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) => INCOMING.process(self, stanza.clone()),
            Event::Online => true,
            e => {
                warn!("Unexpected event {:?}", e);
                false
            }
        }
    }
    /// Process roster push
    /// see RFC 6212 2.1.6. Roster Push
    fn incoming_iq_processing_set_roster(
        &mut self,
        roster: xmpp_parsers::roster::Roster,
    ) -> Box<dyn IqRequestHandler> {
        for i in roster.items {
            if let Some(ref mut rdata) = self.state.data.roster.get_mut(&i.jid) {
                info!("Update {} in roster", i.jid);
                rdata.0 = i.subscription;
                rdata.1 = i.ask;
            } else {
                info!("Add {} to roster", i.jid);
                self.state
                    .data
                    .roster
                    .insert(i.jid.clone(), (i.subscription, i.ask));
            }
            self.process_jid(&i.jid);
        }
        Box::new(IqSetRoster {})
    }
    /// Enforce to answer to IQ "set"
    fn incoming_iq_processing_set(
        &mut self,
        id: String,
        from: Option<xmpp_parsers::Jid>,
        element: minidom::Element,
    ) -> xmpp_parsers::iq::Iq {
        INCOMING_IQ_SET
            .process(self, element)
            .process(self, id, from)
    }
    /// Process ping request
    /// see XEP-0199: XMPP Ping
    fn incoming_iq_processing_get_ping(
        &mut self,
        _ping: xmpp_parsers::ping::Ping,
    ) -> Box<dyn IqRequestHandler> {
        Box::new(IqGetPing {})
    }
    /// Process disco query
    /// see XEP-0030: Service Discovery
    fn incoming_iq_processing_get_disco_info(
        &mut self,
        disco: xmpp_parsers::disco::DiscoInfoQuery,
    ) -> Box<dyn IqRequestHandler> {
        if let Some(ref node) = disco.node {
            warn!("Unsupported node {}", node);
            Box::new(IqRequestUnknown {
                element: disco.into(),
                type_: "get",
            })
        } else {
            Box::new(IqGetDiscoInfo {})
        }
    }
    /// Enforce to answer to IQ "get"
    fn incoming_iq_processing_get(
        &mut self,
        id: String,
        from: Option<xmpp_parsers::Jid>,
        element: minidom::Element,
    ) -> xmpp_parsers::iq::Iq {
        INCOMING_IQ_GET
            .process(self, element)
            .process(self, id, from)
    }
    fn incoming_iq_processing(&mut self, iq: xmpp_parsers::iq::Iq) -> bool {
        match iq.payload {
            xmpp_parsers::iq::IqType::Set(element) => {
                let iq_answer = self.incoming_iq_processing_set(iq.id, iq.from, element);
                self.state.data.send_queue.push_back(iq_answer.into());
            }
            xmpp_parsers::iq::IqType::Error(e) => {
                if let Some((_, handler)) = self.state.data.pending_ids.remove_entry(&iq.id) {
                    return handler.1.error(self, e);
                }
                error!("iq error: {:?}", e);
                return false;
            }
            xmpp_parsers::iq::IqType::Get(element) => {
                let iq_answer = self.incoming_iq_processing_get(iq.id, iq.from, element);
                self.state.data.send_queue.push_back(iq_answer.into());
            }
            xmpp_parsers::iq::IqType::Result(opt_element) => {
                if let Some((_, handler)) = self.state.data.pending_ids.remove_entry(&iq.id) {
                    return handler.1.result(self, opt_element);
                }
                warn!(
                    "Unwanted iq result id {} from {:?}: {:?}",
                    iq.id,
                    iq.from,
                    opt_element.map(|e| String::from(&e))
                );
            }
        }
        true
    }
    fn incoming_presence_processing(&mut self, presence: xmpp_parsers::presence::Presence) -> bool {
        if presence.from.as_ref() == Some(&self.state.client.jid) {
            info!("Self-presence accepted");
            self.state.data.self_presence = true;
        } else {
            warn!("Incoming presence stanza: {:?}", presence);
        }
        true
    }
    fn incoming_message_processing(&mut self, message: xmpp_parsers::message::Message) -> bool {
        for payload in message.payloads.iter() {
            use std::convert::TryInto;
            if let Some(_delay) =
                payload.clone().try_into().ok() as Option<xmpp_parsers::delay::Delay>
            {
                return true; // ignore delayed messages
            }
        }
        warn!("Incoming message stanza: {:?}", message);
        true
    }
    /// 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)| {
                // ToDo: check timeouts if iqs
                let XmppConnection {
                    state: XmppState { client, mut data },
                    account,
                } = xmpp;
                if let Some(send_element) = data.send_queue.pop_front() {
                    use tokio::prelude::Sink;
                    info!("Sending {}", String::from(&send_element));
                    Box::new(
                        client
                            .send(Packet::Stanza(send_element))
                            .select2(stop_future)
                            .then(move |r| match r {
                                Ok(Either::A((client, b))) => {
                                    Box::new(future::ok(future::Loop::Continue((
                                        XmppConnection {
                                            state: XmppState { client, data },
                                            account,
                                        },
                                        b,
                                        stop_condition,
                                    ))))
                                        as Box<dyn Future<Item = _, Error = _>>
                                }
                                Ok(Either::B((t, a))) => Box::new(a.then(|r| match r {
                                    Ok(client) => future::ok(future::Loop::Break((
                                        XmppConnection {
                                            state: XmppState { client, data },
                                            account,
                                        },
                                        Ok(Either::B(t)),
                                    ))),
                                    Err(se) => {
                                        warn!("XMPP sending error: {}", se);
                                        future::err((account, Ok(Either::B(t))))
                                    }
                                })),
                                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: {}", String::from(&s));
                Ok(false)
            }
            _ => {
                error!("Disconnected while online");
                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... {}", String::from(&get_roster));
        data.pending_ids.insert(
            id_init_roster.clone(),
            (
                Instant::now() + Duration::from_secs(60),
                Box::new(InitRosterIqHandler {}),
            ),
        );
        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, _| Ok(conn.state.data.roster_init), stop_future)
                .map_err(|(account, _)| account)
                .and_then(|(conn, r)| match r {
                    Ok(Either::A(_)) => future::ok(conn),
                    Ok(Either::B(_)) => future::err(conn.account),
                    Err(_e) => future::err(conn.account),
                })
            })
    }
    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... {}", String::from(&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, _| Ok(conn.state.data.self_presence),
                    stop_future,
                )
                .map_err(|(account, _)| account)
                .and_then(|(conn, r)| match r {
                    Ok(Either::A(_)) => future::ok(conn),
                    Ok(Either::B(_)) => future::err(conn.account),
                    Err(_e) => future::err(conn.account),
                })
            })
    }
    fn process_jid(&mut self, xmpp_to: &xmpp_parsers::Jid) {
        if let Some(ref mut mailbox) = self.state.data.outgoing_mailbox.get_mut(xmpp_to) {
            if !mailbox.is_empty() {
                if let Some(ref mut rdata) = self.state.data.roster.get_mut(xmpp_to) {
                    info!("Jid {} in roster", xmpp_to);
                    let sub_to = match rdata.0 {
                        xmpp_parsers::roster::Subscription::To => true,
                        xmpp_parsers::roster::Subscription::Both => true,
                        _ => false,
                    };
                    if sub_to {
                        info!("Subscribed to {}", xmpp_to);
                        self.state.data.send_queue.extend(
                            mailbox.drain(..).map(|message| {
                                stanzas::make_chat_message(xmpp_to.clone(), message)
                            }),
                        );
                    } else if rdata.1 == xmpp_parsers::roster::Ask::None {
                        info!("Not subscribed to {}", xmpp_to);
                        self.state
                            .data
                            .send_queue
                            .push_back(stanzas::make_ask_subscribe(xmpp_to.clone()));
                    }
                    let sub_from = match rdata.0 {
                        xmpp_parsers::roster::Subscription::From => true,
                        xmpp_parsers::roster::Subscription::Both => true,
                        _ => false,
                    };
                    if !sub_from {
                        info!("Not subscription from {}", xmpp_to);
                        self.state
                            .data
                            .send_queue
                            .push_back(stanzas::make_allow_subscribe(xmpp_to.clone()));
                    }
                } else {
                    info!("Jid {} not in roster", xmpp_to);
                    self.state.data.counter += 1;
                    let id_add_roster = format!("id_add_roster{}", self.state.data.counter);
                    let add_roster = stanzas::make_add_roster(&id_add_roster, xmpp_to.clone());
                    info!("Adding jid {} to roster id {}", xmpp_to, id_add_roster);
                    self.state.data.pending_ids.insert(
                        id_add_roster,
                        (
                            Instant::now() + Duration::from_secs(60),
                            Box::new(AddRosterIqHandler {
                                jid: xmpp_to.clone(),
                            }),
                        ),
                    );
                    self.state.data.send_queue.push_back(add_roster);
                }
            }
        }
    }
    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);
                self.state.data.pending_ids.insert(
                    id_ping,
                    (
                        Instant::now() + Duration::from_secs(30),
                        Box::new(PingIqHandler {}),
                    ),
                );
            }
            XmppCommand::TimeoutCleanup => {
                let now = Instant::now();
                let timeouted: Vec<String> = self
                    .state
                    .data
                    .pending_ids
                    .iter()
                    .filter_map(|(id, (timeout, _))| {
                        if now >= *timeout {
                            Some(id.to_string())
                        } else {
                            None
                        }
                    })
                    .collect();
                let mut correct = true;
                timeouted.into_iter().for_each(|id| {
                    if let Some((_, handler)) = self.state.data.pending_ids.remove(&id) {
                        correct &= handler.timeout(&mut self);
                    }
                })
            }
        }
    }
    pub fn shutdown(self) -> impl Future<Item = (), Error = failure::Error> {
        info!("Shutdown connection");
        let XmppConnection { account, state } = self;
        stream::iter_ok(
            state
                .data
                .mucs
                .values()
                .map(std::clone::Clone::clone)
                .collect::<Vec<_>>(),
        )
        .fold(state, move |XmppState { client, data }, muc_jid| {
            let muc_presence =
                stanzas::make_muc_presence_leave(account.jid.clone(), muc_jid.clone());
            info!(
                "Sending muc leave presence... {}",
                String::from(&muc_presence)
            );
            use tokio::prelude::Sink;
            client
                .send(Packet::Stanza(muc_presence))
                .map_err(|e| {
                    error!("Error on send muc presence: {}", e);
                    e
                })
                .and_then(|client| future::ok(XmppState { client, data }))
        })
        .map(|_| ())
    }
    fn enter_mucs<F, E>(
        self,
        _stop_future: F,
    ) -> impl Future<Item = Self, Error = std::rc::Rc<config::Account>>
    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... {}", String::from(&muc_presence));
                let account4 = account2.clone();
                use tokio::prelude::Sink;
                client
                    .send(Packet::Stanza(muc_presence))
                    .map_err(|e| {
                        error!("Error on send muc presence: {}", e);
                        account4
                    })
                    .and_then(|client| {
                        data.mucs.insert(muc_jid.0, muc_jid.1);
                        future::ok(XmppState { client, data })
                    })
            })
            .map(|state| XmppConnection {
                account: account3,
                state,
            })
    }
}
use futures_util::future::Either;
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);
                }
            }
        }
    }
    /// return false if connection should be broken
    pub fn process_command(mut self, cmd: XmppCommand) -> MaybeXmppConnection {
        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);
            }
        }
        self.into()
    }
    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,
            })
    }
}
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 std::time::{Duration, Instant};
use super::stanzas;
use super::element_processor;
use crate::config;
#[derive(Debug)]
pub enum XmppCommand {
    /// Send message to someone by jid
    Chat {
        xmpp_to: xmpp_parsers::Jid,
        message: String,
    },
    /// Send message to MUC
    Chatroom { muc_id: String, message: String },
    /// Send ping request to the server to test connection
    Ping,
    /// Check iq requests if some have expired timeouts
    TimeoutCleanup,
}
/// trait of processing iq
/// each function consumes handlers and
/// returns false if connection should be reset
trait IqHandler {
    /// process result
    fn result(
        self: Box<Self>,
        conn: &mut XmppConnection,
        opt_element: Option<xmpp_parsers::Element>,
    ) -> bool;
    /// process error
    fn error(
        self: Box<Self>,
        conn: &mut XmppConnection,
        error: xmpp_parsers::stanza_error::StanzaError,
    ) -> bool;
    /// process tmeout
    fn timeout(self: Box<Self>, conn: &mut XmppConnection) -> bool;
}
struct AddRosterIqHandler {
    jid: xmpp_parsers::Jid,
}
impl IqHandler for AddRosterIqHandler {
    fn result(
        self: Box<Self>,
        conn: &mut XmppConnection,
        opt_element: Option<xmpp_parsers::Element>,
    ) -> bool {
        match opt_element {
            Some(element) => {
                warn!(
                    "Wrong payload when adding {} to roster: {}",
                    self.jid,
                    String::from(&element)
                );
            }
            None => {
                if conn.state.data.roster.contains_key(&self.jid) {
                    info!("Jid {} updated to roster", self.jid);
                } else {
                    info!("Jid {} added in roster", self.jid);
                    conn.state.data.roster.insert(
                        self.jid.clone(),
                        (
                            xmpp_parsers::roster::Subscription::None,
                            xmpp_parsers::roster::Ask::None,
                        ),
                    );
                }
                conn.process_jid(&self.jid);
            }
        }
        true
    }
    fn error(
        self: Box<Self>,
        _conn: &mut XmppConnection,
        _error: xmpp_parsers::stanza_error::StanzaError,
    ) -> bool {
        true
    }
    fn timeout(self: Box<Self>, _conn: &mut XmppConnection) -> bool {
        true // ignore
    }
}
struct PingIqHandler {}
impl IqHandler for PingIqHandler {
    fn result(
        self: Box<Self>,
        _conn: &mut XmppConnection,
        _opt_element: Option<xmpp_parsers::Element>,
    ) -> bool {
        info!("ping successed");
        true
    }
    fn error(
        self: Box<Self>,
        _conn: &mut XmppConnection,
        _error: xmpp_parsers::stanza_error::StanzaError,
    ) -> bool {
        false
    }
    fn timeout(self: Box<Self>, _conn: &mut XmppConnection) -> bool {
        false
    }
}
struct InitRosterIqHandler {}
impl IqHandler for InitRosterIqHandler {
    fn result(
        self: Box<Self>,
        conn: &mut XmppConnection,
        opt_element: Option<xmpp_parsers::Element>,
    ) -> bool {
        if let Some(result) = opt_element {
            use std::convert::TryInto;
            match result.try_into() as Result<xmpp_parsers::roster::Roster, _> {
                Ok(roster) => {
                    conn.state.data.roster_init = true;
                    conn.state.data.roster.clear();
                    info!("Got first roster:");
                    for i in roster.items {
                        info!(" >>> {:?}", i);
                        conn.state
                            .data
                            .roster
                            .insert(i.jid, (i.subscription, i.ask));
                    }
                    true
                }
                Err(e) => {
                    error!("Cann't parse roster: {}", e);
                    false
                }
            }
        } else {
            error!("No roster responded");
            false
        }
    }
    fn error(
        self: Box<Self>,
        _conn: &mut XmppConnection,
        _error: xmpp_parsers::stanza_error::StanzaError,
    ) -> bool {
        false
    }
    fn timeout(self: Box<Self>, _conn: &mut XmppConnection) -> bool {
        false
    }
}
#[derive(Default)]
struct XmppData {
    /// known roster data
    roster: HashMap<
        xmpp_parsers::Jid,
        (
            xmpp_parsers::roster::Subscription,
            xmpp_parsers::roster::Ask,
        ),
    >,
    /// if roster was initialized
    /// ToDo: remove it as it is used only for initialization
    roster_init: bool,
    /// if self-presence accepted
    /// ToDo: remove it as it is used only for initialization
    self_presence: bool,
    /// ids counter
    counter: usize,
    /// 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>,
    /// map from iq's id to handler of this type of iqs
    pending_ids: HashMap<String, (Instant, Box<dyn IqHandler>)>,
}
struct XmppState {
    client: Client,
    data: XmppData,
}
pub struct XmppConnection {
    account: std::rc::Rc<config::Account>,
    state: XmppState,
}
lazy_static! {
    static ref INCOMING: element_processor::Processor<XmppConnection, bool, xmpp_parsers::Element> = {
        let mut incoming = element_processor::Processor::new(&|_, e| {
            warn!("Unknown stanza {}", String::from(&e));
            true
        });
        incoming.register(&XmppConnection::incoming_iq_processing);
        incoming.register(&XmppConnection::incoming_presence_processing);
        incoming.register(&XmppConnection::incoming_message_processing);
        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) => INCOMING.process(self, stanza.clone()),
            Event::Online => true,
            e => {
                warn!("Unexpected event {:?}", e);
                false
            }
        }
    }
    /// Enforce to answer to IQ "set"
    fn incoming_iq_processing_set(
        &mut self,
        id: String,
        from: Option<xmpp_parsers::Jid>,
        element: minidom::Element,
    ) -> xmpp_parsers::iq::Iq {
        use std::convert::TryInto;
        if let Some(roster) =
            element.clone().try_into().ok() as Option<xmpp_parsers::roster::Roster>
        {
            // RFC 6212 2.1.6. Roster Push
            info!("Got roster push {} from {:?}", id, from);
            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);
            }
            return stanzas::make_roster_push_answer(id, self.state.client.jid.clone(), from);
        }
        warn!(
            "Unsupported IQ set request from {:?}: {}",
            from,
            String::from(&element)
        );
        stanzas::make_iq_unsupported_error(id, self.state.client.jid.clone(), from)
    }
    /// Enforce to answer to IQ "get"
    fn incoming_iq_processing_get(
        &mut self,
        id: String,
        from: Option<xmpp_parsers::Jid>,
        element: minidom::Element,
    ) -> xmpp_parsers::iq::Iq {
        use std::convert::TryInto;
        if let Some(_ping) = element.clone().try_into().ok() as Option<xmpp_parsers::ping::Ping> {
            info!("Got ping {} from {:?}", id, from);
            return stanzas::make_pong(&id, self.state.client.jid.clone(), from);
        }
        warn!(
            "Unsupported IQ get request from {:?}: {}",
            from,
            String::from(&element)
        );
        stanzas::make_iq_unsupported_error(id, self.state.client.jid.clone(), from)
    }
    fn incoming_iq_processing(&mut self, iq: xmpp_parsers::iq::Iq) -> bool {
        match iq.payload {
            xmpp_parsers::iq::IqType::Set(element) => {
                let iq_answer = self.incoming_iq_processing_set(iq.id, iq.from, element);
                self.state.data.send_queue.push_back(iq_answer.into());
            }
            xmpp_parsers::iq::IqType::Error(e) => {
                if let Some((_, handler)) = self.state.data.pending_ids.remove_entry(&iq.id) {
                    return handler.1.error(self, e);
                }
                error!("iq error: {:?}", e);
                return false;
            }
            xmpp_parsers::iq::IqType::Get(element) => {
                let iq_answer = self.incoming_iq_processing_get(iq.id, iq.from, element);
                self.state.data.send_queue.push_back(iq_answer.into());
            }
            xmpp_parsers::iq::IqType::Result(opt_element) => {
                if let Some((_, handler)) = self.state.data.pending_ids.remove_entry(&iq.id) {
                    return handler.1.result(self, opt_element);
                }
                warn!(
                    "Unwanted iq result id {} from {:?}: {:?}",
                    iq.id,
                    iq.from,
                    opt_element.map(|e| String::from(&e))
                );
            }
        }
        true
    }
    fn incoming_presence_processing(&mut self, presence: xmpp_parsers::presence::Presence) -> bool {
        if presence.from.as_ref() == Some(&self.state.client.jid) {
            info!("Self-presence accepted");
            self.state.data.self_presence = true;
        } else {
            warn!("Incoming presence stanza: {:?}", presence);
        }
        true
    }
    fn incoming_message_processing(&mut self, message: xmpp_parsers::message::Message) -> bool {
        for payload in message.payloads.iter() {
            use std::convert::TryInto;
            if let Some(_delay) =
                payload.clone().try_into().ok() as Option<xmpp_parsers::delay::Delay>
            {
                return true; // ignore delayed messages
            }
        }
        warn!("Incoming message stanza: {:?}", message);
        true
    }
    /// 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)| {
                // ToDo: check timeouts if iqs
                let XmppConnection {
                    state: XmppState { client, mut data },
                    account,
                } = xmpp;
                if let Some(send_element) = data.send_queue.pop_front() {
                    use tokio::prelude::Sink;
                    info!("Sending {}", String::from(&send_element));
                    Box::new(
                        client
                            .send(Packet::Stanza(send_element))
                            .select2(stop_future)
                            .then(move |r| match r {
                                Ok(Either::A((client, b))) => {
                                    Box::new(future::ok(future::Loop::Continue((
                                        XmppConnection {
                                            state: XmppState { client, data },
                                            account,
                                        },
                                        b,
                                        stop_condition,
                                    ))))
                                        as Box<dyn Future<Item = _, Error = _>>
                                }
                                Ok(Either::B((t, a))) => Box::new(a.then(|r| match r {
                                    Ok(client) => future::ok(future::Loop::Break((
                                        XmppConnection {
                                            state: XmppState { client, data },
                                            account,
                                        },
                                        Ok(Either::B(t)),
                                    ))),
                                    Err(se) => {
                                        warn!("XMPP sending error: {}", se);
                                        future::err((account, Ok(Either::B(t))))
                                    }
                                })),
                                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: {}", String::from(&s));
                Ok(false)
            }
            _ => {
                error!("Disconnected while online");
                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... {}", String::from(&get_roster));
        data.pending_ids.insert(
            id_init_roster.clone(),
            (
                Instant::now() + Duration::from_secs(60),
                Box::new(InitRosterIqHandler {}),
            ),
        );
        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, _| Ok(conn.state.data.roster_init), stop_future)
                .map_err(|(account, _)| account)
                .and_then(|(conn, r)| match r {
                    Ok(Either::A(_)) => future::ok(conn),
                    Ok(Either::B(_)) => future::err(conn.account),
                    Err(_e) => future::err(conn.account),
                })
            })
    }
    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... {}", String::from(&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, _| Ok(conn.state.data.self_presence),
                    stop_future,
                )
                .map_err(|(account, _)| account)
                .and_then(|(conn, r)| match r {
                    Ok(Either::A(_)) => future::ok(conn),
                    Ok(Either::B(_)) => future::err(conn.account),
                    Err(_e) => future::err(conn.account),
                })
            })
    }
    fn process_jid(&mut self, xmpp_to: &xmpp_parsers::Jid) {
        if let Some(ref mut mailbox) = self.state.data.outgoing_mailbox.get_mut(xmpp_to) {
            if !mailbox.is_empty() {
                if let Some(ref mut rdata) = self.state.data.roster.get_mut(xmpp_to) {
                    info!("Jid {} in roster", xmpp_to);
                    let sub_to = match rdata.0 {
                        xmpp_parsers::roster::Subscription::To => true,
                        xmpp_parsers::roster::Subscription::Both => true,
                        _ => false,
                    };
                    if sub_to {
                        info!("Subscribed to {}", xmpp_to);
                        self.state.data.send_queue.extend(
                            mailbox.drain(..).map(|message| {
                                stanzas::make_chat_message(xmpp_to.clone(), message)
                            }),
                        );
                    } else if rdata.1 == xmpp_parsers::roster::Ask::None {
                        info!("Not subscribed to {}", xmpp_to);
                        self.state
                            .data
                            .send_queue
                            .push_back(stanzas::make_ask_subscribe(xmpp_to.clone()));
                    }
                    let sub_from = match rdata.0 {
                        xmpp_parsers::roster::Subscription::From => true,
                        xmpp_parsers::roster::Subscription::Both => true,
                        _ => false,
                    };
                    if !sub_from {
                        info!("Not subscription from {}", xmpp_to);
                        self.state
                            .data
                            .send_queue
                            .push_back(stanzas::make_allow_subscribe(xmpp_to.clone()));
                    }
                } else {
                    info!("Jid {} not in roster", xmpp_to);
                    self.state.data.counter += 1;
                    let id_add_roster = format!("id_add_roster{}", self.state.data.counter);
                    let add_roster = stanzas::make_add_roster(&id_add_roster, xmpp_to.clone());
                    info!("Adding jid {} to roster id {}", xmpp_to, id_add_roster);
                    self.state.data.pending_ids.insert(
                        id_add_roster,
                        (
                            Instant::now() + Duration::from_secs(60),
                            Box::new(AddRosterIqHandler {
                                jid: xmpp_to.clone(),
                            }),
                        ),
                    );
                    self.state.data.send_queue.push_back(add_roster);
                }
            }
        }
    }
    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);
                self.state.data.pending_ids.insert(
                    id_ping,
                    (
                        Instant::now() + Duration::from_secs(30),
                        Box::new(PingIqHandler {}),
                    ),
                );
            }
            XmppCommand::TimeoutCleanup => {
                let now = Instant::now();
                let timeouted: Vec<String> = self
                    .state
                    .data
                    .pending_ids
                    .iter()
                    .filter_map(|(id, (timeout, _))| {
                        if now >= *timeout {
                            Some(id.to_string())
                        } else {
                            None
                        }
                    })
                    .collect();
                let mut correct = true;
                timeouted.into_iter().for_each(|id| {
                    if let Some((_, handler)) = self.state.data.pending_ids.remove(&id) {
                        correct &= handler.timeout(&mut self);
                    }
                })
            }
        }
    }
    pub fn shutdown(self) -> impl Future<Item = (), Error = failure::Error> {
        info!("Shutdown connection");
        let XmppConnection { account, state } = self;
        stream::iter_ok(
            state
                .data
                .mucs
                .values()
                .map(std::clone::Clone::clone)
                .collect::<Vec<_>>(),
        )
        .fold(state, move |XmppState { client, data }, muc_jid| {
            let muc_presence =
                stanzas::make_muc_presence_leave(account.jid.clone(), muc_jid.clone());
            info!(
                "Sending muc leave presence... {}",
                String::from(&muc_presence)
            );
            use tokio::prelude::Sink;
            client
                .send(Packet::Stanza(muc_presence))
                .map_err(|e| {
                    error!("Error on send muc presence: {}", e);
                    e
                })
                .and_then(|client| future::ok(XmppState { client, data }))
        })
        .map(|_| ())
    }
    fn enter_mucs<F, E>(
        self,
        _stop_future: F,
    ) -> impl Future<Item = Self, Error = std::rc::Rc<config::Account>>
    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... {}", String::from(&muc_presence));
                let account4 = account2.clone();
                use tokio::prelude::Sink;
                client
                    .send(Packet::Stanza(muc_presence))
                    .map_err(|e| {
                        error!("Error on send muc presence: {}", e);
                        account4
                    })
                    .and_then(|client| {
                        data.mucs.insert(muc_jid.0, muc_jid.1);
                        future::ok(XmppState { client, data })
                    })
            })
            .map(|state| XmppConnection {
                account: account3,
                state,
            })
    }
}
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 std::time::{Duration, Instant};
use super::XmppCommand;
use super::stanzas;
use super::element_processor;
use crate::config;
/// trait of processing iq
/// each function consumes handlers and
/// returns false if connection should be reset
trait IqHandler {
    /// process result
    fn result(
        self: Box<Self>,
        conn: &mut XmppConnection,
        opt_element: Option<xmpp_parsers::Element>,
    ) -> bool;
    /// process error
    fn error(
        self: Box<Self>,
        conn: &mut XmppConnection,
        error: xmpp_parsers::stanza_error::StanzaError,
    ) -> bool;
    /// process tmeout
    fn timeout(self: Box<Self>, conn: &mut XmppConnection) -> bool;
}
struct AddRosterIqHandler {
    jid: xmpp_parsers::Jid,
}
impl IqHandler for AddRosterIqHandler {
    fn result(
        self: Box<Self>,
        conn: &mut XmppConnection,
        opt_element: Option<xmpp_parsers::Element>,
    ) -> bool {
        match opt_element {
            Some(element) => {
                warn!(
                    "Wrong payload when adding {} to roster: {}",
                    self.jid,
                    String::from(&element)
                );
            }
            None => {
                if conn.state.data.roster.contains_key(&self.jid) {
                    info!("Jid {} updated to roster", self.jid);
                } else {
                    info!("Jid {} added in roster", self.jid);
                    conn.state.data.roster.insert(
                        self.jid.clone(),
                        (
                            xmpp_parsers::roster::Subscription::None,
                            xmpp_parsers::roster::Ask::None,
                        ),
                    );
                }
                conn.process_jid(&self.jid);
            }
        }
        true
    }
    fn error(
        self: Box<Self>,
        _conn: &mut XmppConnection,
        _error: xmpp_parsers::stanza_error::StanzaError,
    ) -> bool {
        true
    }
    fn timeout(self: Box<Self>, _conn: &mut XmppConnection) -> bool {
        true // ignore
    }
}
struct PingIqHandler {}
impl IqHandler for PingIqHandler {
    fn result(
        self: Box<Self>,
        _conn: &mut XmppConnection,
        _opt_element: Option<xmpp_parsers::Element>,
    ) -> bool {
        true // ignore
    }
    fn error(
        self: Box<Self>,
        _conn: &mut XmppConnection,
        _error: xmpp_parsers::stanza_error::StanzaError,
    ) -> bool {
        false
    }
    fn timeout(self: Box<Self>, _conn: &mut XmppConnection) -> bool {
        false
    }
}
struct InitRosterIqHandler {}
impl IqHandler for InitRosterIqHandler {
    fn result(
        self: Box<Self>,
        conn: &mut XmppConnection,
        opt_element: Option<xmpp_parsers::Element>,
    ) -> bool {
        if let Some(result) = opt_element {
            use std::convert::TryInto;
            match result.try_into() as Result<xmpp_parsers::roster::Roster, _> {
                Ok(roster) => {
                    conn.state.data.roster_init = true;
                    conn.state.data.roster.clear();
                    info!("Got first roster:");
                    for i in roster.items {
                        info!(" >>> {:?}", i);
                        conn.state
                            .data
                            .roster
                            .insert(i.jid, (i.subscription, i.ask));
                    }
                    true
                }
                Err(e) => {
                    error!("Cann't parse roster: {}", e);
                    false
                }
            }
        } else {
            error!("No roster responded");
            false
        }
    }
    fn error(
        self: Box<Self>,
        _conn: &mut XmppConnection,
        _error: xmpp_parsers::stanza_error::StanzaError,
    ) -> bool {
        false
    }
    fn timeout(self: Box<Self>, _conn: &mut XmppConnection) -> bool {
        false
    }
}
#[derive(Default)]
struct XmppData {
    /// known roster data
    roster: HashMap<
        xmpp_parsers::Jid,
        (
            xmpp_parsers::roster::Subscription,
            xmpp_parsers::roster::Ask,
        ),
    >,
    /// if roster was initialized
    /// ToDo: remove it as it used only for initialization
    roster_init: bool,
    /// ids counter
    counter: usize,
    /// 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>,
    /// map from iq's id to handler of this type of iqs
    pending_ids: HashMap<String, (Instant, Box<dyn IqHandler>)>,
}
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 {}", String::from(&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
            }
        }
    }
    /// Enforce to answer to IQ "set"
    fn incoming_iq_processing_set(
        &mut self,
        id: String,
        from: Option<xmpp_parsers::Jid>,
        element: minidom::Element,
    ) -> xmpp_parsers::iq::Iq {
        use std::convert::TryInto;
        if let Some(roster) =
            element.clone().try_into().ok() as Option<xmpp_parsers::roster::Roster>
        {
            // RFC 6212 2.1.6. Roster Push
            for i in roster.items {
                if let Some(ref mut rdata) = self.state.data.roster.get_mut(&i.jid) {
                    info!("Update {} in roster", i.jid);
                    rdata.0 = i.subscription;
                    rdata.1 = i.ask;
                } else {
                    info!("Add {} to roster", i.jid);
                    self.state
                        .data
                        .roster
                        .insert(i.jid.clone(), (i.subscription, i.ask));
                }
                self.process_jid(&i.jid);
            }
            return stanzas::make_roster_push_answer(id, self.state.client.jid.clone(), from);
        }
        warn!(
            "Unsupported IQ set request from {:?}: {}",
            from,
            String::from(&element)
        );
        stanzas::make_iq_unsupported_error(id, self.state.client.jid.clone(), from)
    }
    /// Enforce to answer to IQ "get"
    fn incoming_iq_processing_get(
        &mut self,
        id: String,
        from: Option<xmpp_parsers::Jid>,
        element: minidom::Element,
    ) -> xmpp_parsers::iq::Iq {
        use std::convert::TryInto;
        if let Some(_ping) = element.clone().try_into().ok() as Option<xmpp_parsers::ping::Ping> {
            return stanzas::make_pong(&id, self.state.client.jid.clone(), from);
        }
        warn!(
            "Unsupported IQ get request from {:?}: {}",
            from,
            String::from(&element)
        );
        stanzas::make_iq_unsupported_error(id, self.state.client.jid.clone(), from)
    }
    fn incoming_iq_processing(&mut self, iq: xmpp_parsers::iq::Iq) -> bool {
        match iq.payload {
            xmpp_parsers::iq::IqType::Set(element) => {
                let iq_answer = self.incoming_iq_processing_set(iq.id, iq.from, element);
                self.state.data.send_queue.push_back(iq_answer.into());
            }
            xmpp_parsers::iq::IqType::Error(e) => {
                if let Some((_, handler)) = self.state.data.pending_ids.remove_entry(&iq.id) {
                    return handler.1.error(self, e);
                }
                error!("iq error: {:?}", e);
                return false;
            }
            xmpp_parsers::iq::IqType::Get(element) => {
                let iq_answer = self.incoming_iq_processing_get(iq.id, iq.from, element);
                self.state.data.send_queue.push_back(iq_answer.into());
            }
            xmpp_parsers::iq::IqType::Result(opt_element) => {
                if let Some((_, handler)) = self.state.data.pending_ids.remove_entry(&iq.id) {
                    return handler.1.result(self, opt_element);
                }
                warn!(
                    "Unwanted iq result id {} from {:?}: {:?}",
                    iq.id,
                    iq.from,
                    opt_element.map(|e| String::from(&e))
                );
            }
        }
        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)| {
                // ToDo: check timeouts if iqs
                let XmppConnection {
                    state: XmppState { client, mut data },
                    account,
                } = xmpp;
                if let Some(send_element) = data.send_queue.pop_front() {
                    use tokio::prelude::Sink;
                    info!("Sending {}", String::from(&send_element));
                    Box::new(
                        client
                            .send(Packet::Stanza(send_element))
                            .select2(stop_future)
                            .then(move |r| match r {
                                Ok(Either::A((client, b))) => {
                                    Box::new(future::ok(future::Loop::Continue((
                                        XmppConnection {
                                            state: XmppState { client, data },
                                            account,
                                        },
                                        b,
                                        stop_condition,
                                    ))))
                                        as Box<dyn Future<Item = _, Error = _>>
                                }
                                Ok(Either::B((t, a))) => Box::new(a.then(|r| match r {
                                    Ok(client) => future::ok(future::Loop::Break((
                                        XmppConnection {
                                            state: XmppState { client, data },
                                            account,
                                        },
                                        Ok(Either::B(t)),
                                    ))),
                                    Err(se) => {
                                        warn!("XMPP sending error: {}", se);
                                        future::err((account, Ok(Either::B(t))))
                                    }
                                })),
                                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: {}", String::from(&s));
                Ok(false)
            }
            _ => {
                error!("Disconnected while online");
                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... {}", String::from(&get_roster));
        data.pending_ids.insert(
            id_init_roster.clone(),
            (
                Instant::now() + Duration::from_secs(60),
                Box::new(InitRosterIqHandler {}),
            ),
        );
        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, _| Ok(conn.state.data.roster_init), stop_future)
                .map_err(|(account, _)| account)
                .and_then(|(conn, r)| match r {
                    Ok(Either::A(_)) => future::ok(conn),
                    Ok(Either::B(_)) => future::err(conn.account),
                    Err(_e) => future::err(conn.account),
                })
            })
    }
    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... {}", String::from(&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());
                    info!("Adding jid {} to roster id {}", xmpp_to, id_add_roster);
                    self.state.data.pending_ids.insert(
                        id_add_roster,
                        (
                            Instant::now() + Duration::from_secs(60),
                            Box::new(AddRosterIqHandler {
                                jid: xmpp_to.clone(),
                            }),
                        ),
                    );
                    self.state.data.send_queue.push_back(add_roster);
                }
            }
        }
    }
    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);
                self.state.data.pending_ids.insert(
                    id_ping,
                    (
                        Instant::now() + Duration::from_secs(30),
                        Box::new(PingIqHandler {}),
                    ),
                );
            }
        }
    }
    pub fn shutdown(self) -> impl Future<Item = (), Error = failure::Error> {
        info!("Shutdown connection");
        let XmppConnection { account, state } = self;
        stream::iter_ok(
            state
                .data
                .mucs
                .values()
                .map(std::clone::Clone::clone)
                .collect::<Vec<_>>(),
        )
        .fold(state, move |XmppState { client, data }, muc_jid| {
            let muc_presence =
                stanzas::make_muc_presence_leave(account.jid.clone(), muc_jid.clone());
            info!(
                "Sending muc leave presence... {}",
                String::from(&muc_presence)
            );
            use tokio::prelude::Sink;
            client
                .send(Packet::Stanza(muc_presence))
                .map_err(|e| {
                    error!("Error on send muc presence: {}", e);
                    e
                })
                .and_then(|client| future::ok(XmppState { client, data }))
        })
        .map(|_| ())
    }
    fn enter_mucs<F, E>(
        self,
        _stop_future: F,
    ) -> impl Future<Item = Self, Error = std::rc::Rc<config::Account>>
    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... {}", String::from(&muc_presence));
                let account4 = account2.clone();
                use tokio::prelude::Sink;
                client
                    .send(Packet::Stanza(muc_presence))
                    .map_err(|e| {
                        error!("Error on send muc presence: {}", e);
                        account4
                    })
                    .and_then(|client| {
                        data.mucs.insert(muc_jid.0, muc_jid.1);
                        future::ok(XmppState { client, data })
                    })
            })
            .map(|state| XmppConnection {
                account: account3,
                state,
            })
    }
}
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;
/// trait of processing iq
/// each function consumes handlers and
/// returns false if connection should be reset
trait IqHandler {
    /// process result
    fn result(
        self: Box<Self>,
        conn: &mut XmppConnection,
        opt_element: Option<xmpp_parsers::Element>,
    ) -> bool;
    /// process error
    fn error(
        self: Box<Self>,
        conn: &mut XmppConnection,
        error: xmpp_parsers::stanza_error::StanzaError,
    ) -> bool;
    /// process tmeout
    fn timeout(self: Box<Self>, conn: &mut XmppConnection) -> bool;
}
struct AddRosterIqHandler {
    jid: xmpp_parsers::Jid,
}
impl IqHandler for AddRosterIqHandler {
    fn result(
        self: Box<Self>,
        conn: &mut XmppConnection,
        opt_element: Option<xmpp_parsers::Element>,
    ) -> bool {
        match opt_element {
            Some(element) => {
                warn!(
                    "Wrong payload when adding {} to roster: {}",
                    self.jid,
                    String::from(&element)
                );
            }
            None => {
                if conn.state.data.roster.contains_key(&self.jid) {
                    info!("Jid {} updated to roster", self.jid);
                } else {
                    info!("Jid {} added in roster", self.jid);
                    conn.state.data.roster.insert(
                        self.jid.clone(),
                        (
                            xmpp_parsers::roster::Subscription::None,
                            xmpp_parsers::roster::Ask::None,
                        ),
                    );
                }
                conn.process_jid(&self.jid);
            }
        }
        true
    }
    fn error(
        self: Box<Self>,
        _conn: &mut XmppConnection,
        _error: xmpp_parsers::stanza_error::StanzaError,
    ) -> bool {
        true
    }
    fn timeout(self: Box<Self>, _conn: &mut XmppConnection) -> bool {
        true // ignore
    }
}
struct PingIqHandler {}
impl IqHandler for PingIqHandler {
    fn result(
        self: Box<Self>,
        _conn: &mut XmppConnection,
        _opt_element: Option<xmpp_parsers::Element>,
    ) -> bool {
        true // ignore
    }
    fn error(
        self: Box<Self>,
        _conn: &mut XmppConnection,
        _error: xmpp_parsers::stanza_error::StanzaError,
    ) -> bool {
        false
    }
    fn timeout(self: Box<Self>, _conn: &mut XmppConnection) -> bool {
        false
    }
}
#[derive(Default)]
struct XmppData {
    /// known roster data
    roster: HashMap<
        xmpp_parsers::Jid,
        (
            xmpp_parsers::roster::Subscription,
            xmpp_parsers::roster::Ask,
        ),
    >,
    /// ids counter
    counter: usize,
    /// 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>,
    /// map from iq's id to handler of this type of iqs
    pending_ids: HashMap<String, Box<dyn IqHandler>>,
}
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 {}", String::from(&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
            }
        }
    }
    /// Enforce to answer to IQ "set"
    fn incoming_iq_processing_set(
        &mut self,
        id: String,
        from: Option<xmpp_parsers::Jid>,
        element: minidom::Element,
    ) -> xmpp_parsers::iq::Iq {
        use std::convert::TryInto;
        if let Some(roster) =
            element.clone().try_into().ok() as Option<xmpp_parsers::roster::Roster>
        {
            // RFC 6212 2.1.6. Roster Push
            for i in roster.items {
                if let Some(ref mut rdata) = self.state.data.roster.get_mut(&i.jid) {
                    info!("Update {} in roster", i.jid);
                    rdata.0 = i.subscription;
                    rdata.1 = i.ask;
                } else {
                    info!("Add {} to roster", i.jid);
                    self.state
                        .data
                        .roster
                        .insert(i.jid.clone(), (i.subscription, i.ask));
                }
                self.process_jid(&i.jid);
            }
            return stanzas::make_roster_push_answer(id, self.state.client.jid.clone(), from);
        }
        warn!(
            "Unsupported IQ set request from {:?}: {}",
            from,
            String::from(&element)
        );
        stanzas::make_iq_unsupported_error(id, self.state.client.jid.clone(), from)
    }
    /// Enforce to answer to IQ "get"
    fn incoming_iq_processing_get(
        &mut self,
        id: String,
        from: Option<xmpp_parsers::Jid>,
        element: minidom::Element,
    ) -> xmpp_parsers::iq::Iq {
        use std::convert::TryInto;
        if let Some(_ping) = element.clone().try_into().ok() as Option<xmpp_parsers::ping::Ping> {
            return stanzas::make_pong(&id, self.state.client.jid.clone(), from);
        }
        warn!(
            "Unsupported IQ get request from {:?}: {}",
            from,
            String::from(&element)
        );
        stanzas::make_iq_unsupported_error(id, self.state.client.jid.clone(), from)
    }
    fn incoming_iq_processing(&mut self, iq: xmpp_parsers::iq::Iq) -> bool {
        match iq.payload {
            xmpp_parsers::iq::IqType::Set(element) => {
                let iq_answer = self.incoming_iq_processing_set(iq.id, iq.from, element);
                self.state.data.send_queue.push_back(iq_answer.into());
            }
            xmpp_parsers::iq::IqType::Error(e) => {
                if let Some((_, handler)) = self.state.data.pending_ids.remove_entry(&iq.id) {
                    return handler.error(self, e);
                }
                error!("iq error: {:?}", e);
                return false;
            }
            xmpp_parsers::iq::IqType::Get(element) => {
                let iq_answer = self.incoming_iq_processing_get(iq.id, iq.from, element);
                self.state.data.send_queue.push_back(iq_answer.into());
            }
            xmpp_parsers::iq::IqType::Result(opt_element) => {
                if let Some((_, handler)) = self.state.data.pending_ids.remove_entry(&iq.id) {
                    return handler.result(self, opt_element);
                }
                warn!(
                    "Unwanted iq result id {} from {:?}: {:?}",
                    iq.id,
                    iq.from,
                    opt_element.map(|e| String::from(&e))
                );
            }
        }
        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 {}", String::from(&send_element));
                    Box::new(
                        client
                            .send(Packet::Stanza(send_element))
                            .select2(stop_future)
                            .then(move |r| match r {
                                Ok(Either::A((client, b))) => {
                                    Box::new(future::ok(future::Loop::Continue((
                                        XmppConnection {
                                            state: XmppState { client, data },
                                            account,
                                        },
                                        b,
                                        stop_condition,
                                    ))))
                                        as Box<dyn Future<Item = _, Error = _>>
                                }
                                Ok(Either::B((t, a))) => Box::new(a.then(|r| match r {
                                    Ok(client) => future::ok(future::Loop::Break((
                                        XmppConnection {
                                            state: XmppState { client, data },
                                            account,
                                        },
                                        Ok(Either::B(t)),
                                    ))),
                                    Err(se) => {
                                        warn!("XMPP sending error: {}", se);
                                        future::err((account, Ok(Either::B(t))))
                                    }
                                })),
                                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: {}", String::from(&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());
                    info!("Adding jid {} to roster id {}", xmpp_to, id_add_roster);
                    self.state.data.pending_ids.insert(
                        id_add_roster,
                        Box::new(AddRosterIqHandler {
                            jid: xmpp_to.clone(),
                        }),
                    );
                    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);
                self.state
                    .data
                    .pending_ids
                    .insert(id_ping, Box::new(PingIqHandler {}));
            }
        }
    }
    pub fn shutdown(self) -> impl Future<Item = (), Error = failure::Error> {
        info!("Shutdown connection");
        let XmppConnection { account, state } = self;
        stream::iter_ok(
            state
                .data
                .mucs
                .values()
                .map(std::clone::Clone::clone)
                .collect::<Vec<_>>(),
        )
        .fold(state, move |XmppState { client, data }, muc_jid| {
            let muc_presence =
                stanzas::make_muc_presence_leave(account.jid.clone(), muc_jid.clone());
            info!(
                "Sending muc leave presence... {}",
                String::from(&muc_presence)
            );
            use tokio::prelude::Sink;
            client
                .send(Packet::Stanza(muc_presence))
                .map_err(|e| {
                    error!("Error on send muc presence: {}", e);
                    e
                })
                .and_then(|client| future::ok(XmppState { client, data }))
        })
        .map(|_| ())
    }
    fn enter_mucs<F, E>(
        self,
        _stop_future: F,
    ) -> impl Future<Item = Self, Error = std::rc::Rc<config::Account>>
    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... {}", String::from(&muc_presence));
                let account4 = account2.clone();
                use tokio::prelude::Sink;
                client
                    .send(Packet::Stanza(muc_presence))
                    .map_err(|e| {
                        error!("Error on send muc presence: {}", e);
                        account4
                    })
                    .and_then(|client| {
                        data.mucs.insert(muc_jid.0, muc_jid.1);
                        future::ok(XmppState { client, data })
                    })
            })
            .map(|state| XmppConnection {
                account: account3,
                state,
            })
    }
}
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 std::time::{Duration, Instant};
use super::stanzas;
use super::element_processor;
use crate::config;
#[derive(Debug)]
pub enum XmppCommand {
    /// Send message to someone by jid
    Chat {
        xmpp_to: xmpp_parsers::Jid,
        message: String,
    },
    /// Send message to MUC
    Chatroom { muc_id: String, message: String },
    /// Send ping request to the server to test connection
    Ping,
    /// Check iq requests if some have expired timeouts
    TimeoutCleanup,
}
/// trait of processing iq
/// each function consumes handlers and
/// returns false if connection should be reset
trait IqHandler {
    /// process result
    fn result(
        self: Box<Self>,
        conn: &mut XmppConnection,
        opt_element: Option<xmpp_parsers::Element>,
    ) -> bool;
    /// process error
    fn error(
        self: Box<Self>,
        conn: &mut XmppConnection,
        error: xmpp_parsers::stanza_error::StanzaError,
    ) -> bool;
    /// process tmeout
    fn timeout(self: Box<Self>, conn: &mut XmppConnection) -> bool;
}
struct AddRosterIqHandler {
    jid: xmpp_parsers::Jid,
}
impl IqHandler for AddRosterIqHandler {
    fn result(
        self: Box<Self>,
        conn: &mut XmppConnection,
        opt_element: Option<xmpp_parsers::Element>,
    ) -> bool {
        match opt_element {
            Some(element) => {
                warn!(
                    "Wrong payload when adding {} to roster: {}",
                    self.jid,
                    String::from(&element)
                );
            }
            None => {
                if conn.state.data.roster.contains_key(&self.jid) {
                    info!("Jid {} updated to roster", self.jid);
                } else {
                    info!("Jid {} added in roster", self.jid);
                    conn.state.data.roster.insert(
                        self.jid.clone(),
                        (
                            xmpp_parsers::roster::Subscription::None,
                            xmpp_parsers::roster::Ask::None,
                        ),
                    );
                }
                conn.process_jid(&self.jid);
            }
        }
        true
    }
    fn error(
        self: Box<Self>,
        _conn: &mut XmppConnection,
        _error: xmpp_parsers::stanza_error::StanzaError,
    ) -> bool {
        true
    }
    fn timeout(self: Box<Self>, _conn: &mut XmppConnection) -> bool {
        true // ignore
    }
}
struct PingIqHandler {}
impl IqHandler for PingIqHandler {
    fn result(
        self: Box<Self>,
        _conn: &mut XmppConnection,
        _opt_element: Option<xmpp_parsers::Element>,
    ) -> bool {
        info!("ping successed");
        true
    }
    fn error(
        self: Box<Self>,
        _conn: &mut XmppConnection,
        _error: xmpp_parsers::stanza_error::StanzaError,
    ) -> bool {
        false
    }
    fn timeout(self: Box<Self>, _conn: &mut XmppConnection) -> bool {
        false
    }
}
struct InitRosterIqHandler {}
impl IqHandler for InitRosterIqHandler {
    fn result(
        self: Box<Self>,
        conn: &mut XmppConnection,
        opt_element: Option<xmpp_parsers::Element>,
    ) -> bool {
        if let Some(result) = opt_element {
            use std::convert::TryInto;
            match result.try_into() as Result<xmpp_parsers::roster::Roster, _> {
                Ok(roster) => {
                    conn.state.data.roster_init = true;
                    conn.state.data.roster.clear();
                    info!("Got first roster:");
                    for i in roster.items {
                        info!(" >>> {:?}", i);
                        conn.state
                            .data
                            .roster
                            .insert(i.jid, (i.subscription, i.ask));
                    }
                    true
                }
                Err(e) => {
                    error!("Cann't parse roster: {}", e);
                    false
                }
            }
        } else {
            error!("No roster responded");
            false
        }
    }
    fn error(
        self: Box<Self>,
        _conn: &mut XmppConnection,
        _error: xmpp_parsers::stanza_error::StanzaError,
    ) -> bool {
        false
    }
    fn timeout(self: Box<Self>, _conn: &mut XmppConnection) -> bool {
        false
    }
}
#[derive(Default)]
struct XmppData {
    /// known roster data
    roster: HashMap<
        xmpp_parsers::Jid,
        (
            xmpp_parsers::roster::Subscription,
            xmpp_parsers::roster::Ask,
        ),
    >,
    /// if roster was initialized
    /// ToDo: remove it as it is used only for initialization
    roster_init: bool,
    /// if self-presence accepted
    /// ToDo: remove it as it is used only for initialization
    self_presence: bool,
    /// ids counter
    counter: usize,
    /// 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>,
    /// map from iq's id to handler of this type of iqs
    pending_ids: HashMap<String, (Instant, Box<dyn IqHandler>)>,
}
struct XmppState {
    client: Client,
    data: XmppData,
}
pub struct XmppConnection {
    account: std::rc::Rc<config::Account>,
    state: XmppState,
}
trait IqRequestHandler {
    fn process(
        self: Box<Self>,
        conn: &mut XmppConnection,
        id: String,
        from: Option<xmpp_parsers::Jid>,
    ) -> xmpp_parsers::iq::Iq;
}
struct IqRequestUnknown {
    element: xmpp_parsers::Element,
    type_: &'static str,
}
impl IqRequestHandler for IqRequestUnknown {
    fn process(
        self: Box<Self>,
        conn: &mut XmppConnection,
        id: String,
        from: Option<xmpp_parsers::Jid>,
    ) -> xmpp_parsers::iq::Iq {
        warn!(
            "Unsupported IQ {} request from {:?}: {}",
            self.type_,
            from,
            String::from(&self.element)
        );
        stanzas::make_iq_unsupported_error(id, conn.state.client.jid.clone(), from)
    }
}
struct IqSetRoster {}
impl IqRequestHandler for IqSetRoster {
    fn process(
        self: Box<Self>,
        conn: &mut XmppConnection,
        id: String,
        from: Option<xmpp_parsers::Jid>,
    ) -> xmpp_parsers::iq::Iq {
        info!("Got roster push {} from {:?}", id, from);
        stanzas::make_roster_push_answer(id, conn.state.client.jid.clone(), from)
    }
}
struct IqGetPing {}
impl IqRequestHandler for IqGetPing {
    fn process(
        self: Box<Self>,
        conn: &mut XmppConnection,
        id: String,
        from: Option<xmpp_parsers::Jid>,
    ) -> xmpp_parsers::iq::Iq {
        info!("Got ping {} from {:?}", id, from);
        stanzas::make_pong(id, conn.state.client.jid.clone(), from)
    }
}
struct IqGetVersion {}
impl IqRequestHandler for IqGetVersion {
    fn process(
        self: Box<Self>,
        conn: &mut XmppConnection,
        id: String,
        from: Option<xmpp_parsers::Jid>,
    ) -> xmpp_parsers::iq::Iq {
        info!("Got version query {} from {:?}", id, from);
        stanzas::make_version(id, conn.state.client.jid.clone(), from)
    }
}
struct IqGetDiscoInfo {}
impl IqRequestHandler for IqGetDiscoInfo {
    fn process(
        self: Box<Self>,
        conn: &mut XmppConnection,
        id: String,
        from: Option<xmpp_parsers::Jid>,
    ) -> xmpp_parsers::iq::Iq {
        info!("Got disco query {} from {:?}", id, from);
        stanzas::make_disco_info_result(id, conn.state.client.jid.clone(), from)
    }
}
struct IqGetDiscoItems {}
impl IqRequestHandler for IqGetDiscoItems {
    fn process(
        self: Box<Self>,
        conn: &mut XmppConnection,
        id: String,
        from: Option<xmpp_parsers::Jid>,
    ) -> xmpp_parsers::iq::Iq {
        info!("Got disco items query {} from {:?}", id, from);
        stanzas::make_disco_items_result(id, conn.state.client.jid.clone(), from)
    }
}
lazy_static! {
    static ref INCOMING: element_processor::Processor<XmppConnection, bool, xmpp_parsers::Element> = {
        let mut incoming = element_processor::Processor::new(&|_, e| {
            warn!("Unknown stanza {}", String::from(&e));
            true
        });
        incoming.register(&XmppConnection::incoming_iq_processing);
        incoming.register(&XmppConnection::incoming_presence_processing);
        incoming.register(&XmppConnection::incoming_message_processing);
        incoming
    };
    static ref INCOMING_IQ_SET: element_processor::Processor<XmppConnection, Box<dyn IqRequestHandler>, xmpp_parsers::Element> = {
        let mut iq_set =
            element_processor::Processor::new(&|_conn: &mut XmppConnection, element| {
                Box::new(IqRequestUnknown {
                    element,
                    type_: "set",
                }) as Box<dyn IqRequestHandler>
            });
        iq_set.register(&XmppConnection::incoming_iq_processing_set_roster);
        iq_set
    };
    static ref INCOMING_IQ_GET: element_processor::Processor<XmppConnection, Box<dyn IqRequestHandler>, xmpp_parsers::Element> = {
        let mut iq_get =
            element_processor::Processor::new(&|_conn: &mut XmppConnection, element| {
                Box::new(IqRequestUnknown {
                    element,
                    type_: "get",
                }) as Box<dyn IqRequestHandler>
            });
        iq_get.register(&XmppConnection::incoming_iq_processing_get_ping);
        iq_get.register(&XmppConnection::incoming_iq_processing_get_disco_info);
        iq_get.register(&XmppConnection::incoming_iq_processing_get_disco_items);
        iq_get.register(&XmppConnection::incoming_iq_processing_get_version);
        iq_get
    };
}
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) => INCOMING.process(self, stanza.clone()),
            Event::Online => true,
            e => {
                warn!("Unexpected event {:?}", e);
                false
            }
        }
    }
    /// Process roster push
    /// see RFC 6212 2.1.6. Roster Push
    fn incoming_iq_processing_set_roster(
        &mut self,
        roster: xmpp_parsers::roster::Roster,
    ) -> Box<dyn IqRequestHandler> {
        for i in roster.items {
            if let Some(ref mut rdata) = self.state.data.roster.get_mut(&i.jid) {
                info!("Update {} in roster", i.jid);
                rdata.0 = i.subscription;
                rdata.1 = i.ask;
            } else {
                info!("Add {} to roster", i.jid);
                self.state
                    .data
                    .roster
                    .insert(i.jid.clone(), (i.subscription, i.ask));
            }
            self.process_jid(&i.jid);
        }
        Box::new(IqSetRoster {})
    }
    /// Enforce to answer to IQ "set"
    fn incoming_iq_processing_set(
        &mut self,
        id: String,
        from: Option<xmpp_parsers::Jid>,
        element: minidom::Element,
    ) -> xmpp_parsers::iq::Iq {
        INCOMING_IQ_SET
            .process(self, element)
            .process(self, id, from)
    }
    /// Process ping request
    /// see XEP-0199: XMPP Ping
    fn incoming_iq_processing_get_ping(
        &mut self,
        _ping: xmpp_parsers::ping::Ping,
    ) -> Box<dyn IqRequestHandler> {
        Box::new(IqGetPing {})
    }
    /// Process disco query
    /// see XEP-0030: Service Discovery
    fn incoming_iq_processing_get_disco_info(
        &mut self,
        disco: xmpp_parsers::disco::DiscoInfoQuery,
    ) -> Box<dyn IqRequestHandler> {
        if let Some(ref node) = disco.node {
            warn!("Unsupported node {}", node);
            Box::new(IqRequestUnknown {
                element: disco.into(),
                type_: "get",
            })
        } else {
            Box::new(IqGetDiscoInfo {})
        }
    }
    /// Process disco items query
    /// see XEP-0030: Service Discovery
    fn incoming_iq_processing_get_disco_items(
        &mut self,
        disco: xmpp_parsers::disco::DiscoItemsQuery,
    ) -> Box<dyn IqRequestHandler> {
        if let Some(ref node) = disco.node {
            warn!("Unsupported node {}", node);
            Box::new(IqRequestUnknown {
                element: disco.into(),
                type_: "get",
            })
        } else {
            Box::new(IqGetDiscoItems {})
        }
    }
    /// Process version query
    /// see XEP-0092: Software Version
    fn incoming_iq_processing_get_version(
        &mut self,
        _version: xmpp_parsers::version::VersionQuery,
    ) -> Box<dyn IqRequestHandler> {
        Box::new(IqGetVersion {})
    }
    /// Enforce to answer to IQ "get"
    fn incoming_iq_processing_get(
        &mut self,
        id: String,
        from: Option<xmpp_parsers::Jid>,
        element: minidom::Element,
    ) -> xmpp_parsers::iq::Iq {
        INCOMING_IQ_GET
            .process(self, element)
            .process(self, id, from)
    }
    fn incoming_iq_processing(&mut self, iq: xmpp_parsers::iq::Iq) -> bool {
        match iq.payload {
            xmpp_parsers::iq::IqType::Set(element) => {
                let iq_answer = self.incoming_iq_processing_set(iq.id, iq.from, element);
                self.state.data.send_queue.push_back(iq_answer.into());
            }
            xmpp_parsers::iq::IqType::Error(e) => {
                if let Some((_, handler)) = self.state.data.pending_ids.remove_entry(&iq.id) {
                    return handler.1.error(self, e);
                }
                error!("iq error: {:?}", e);
                return false;
            }
            xmpp_parsers::iq::IqType::Get(element) => {
                let iq_answer = self.incoming_iq_processing_get(iq.id, iq.from, element);
                self.state.data.send_queue.push_back(iq_answer.into());
            }
            xmpp_parsers::iq::IqType::Result(opt_element) => {
                if let Some((_, handler)) = self.state.data.pending_ids.remove_entry(&iq.id) {
                    return handler.1.result(self, opt_element);
                }
                warn!(
                    "Unwanted iq result id {} from {:?}: {:?}",
                    iq.id,
                    iq.from,
                    opt_element.map(|e| String::from(&e))
                );
            }
        }
        true
    }
    fn incoming_presence_processing(&mut self, presence: xmpp_parsers::presence::Presence) -> bool {
        if presence.from.as_ref() == Some(&self.state.client.jid) {
            info!("Self-presence accepted");
            self.state.data.self_presence = true;
        } else {
            warn!("Incoming presence stanza: {:?}", presence);
        }
        true
    }
    fn incoming_message_processing(&mut self, message: xmpp_parsers::message::Message) -> bool {
        for payload in message.payloads.iter() {
            use std::convert::TryInto;
            if let Some(_delay) =
                payload.clone().try_into().ok() as Option<xmpp_parsers::delay::Delay>
            {
                return true; // ignore delayed messages
            }
        }
        warn!("Incoming message stanza: {:?}", message);
        true
    }
    /// 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)| {
                // ToDo: check timeouts if iqs
                let XmppConnection {
                    state: XmppState { client, mut data },
                    account,
                } = xmpp;
                if let Some(send_element) = data.send_queue.pop_front() {
                    use tokio::prelude::Sink;
                    info!("Sending {}", String::from(&send_element));
                    Box::new(
                        client
                            .send(Packet::Stanza(send_element))
                            .select2(stop_future)
                            .then(move |r| match r {
                                Ok(Either::A((client, b))) => {
                                    Box::new(future::ok(future::Loop::Continue((
                                        XmppConnection {
                                            state: XmppState { client, data },
                                            account,
                                        },
                                        b,
                                        stop_condition,
                                    ))))
                                        as Box<dyn Future<Item = _, Error = _>>
                                }
                                Ok(Either::B((t, a))) => Box::new(a.then(|r| match r {
                                    Ok(client) => future::ok(future::Loop::Break((
                                        XmppConnection {
                                            state: XmppState { client, data },
                                            account,
                                        },
                                        Ok(Either::B(t)),
                                    ))),
                                    Err(se) => {
                                        warn!("XMPP sending error: {}", se);
                                        future::err((account, Ok(Either::B(t))))
                                    }
                                })),
                                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: {}", String::from(&s));
                Ok(false)
            }
            _ => {
                error!("Disconnected while online");
                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... {}", String::from(&get_roster));
        data.pending_ids.insert(
            id_init_roster.clone(),
            (
                Instant::now() + Duration::from_secs(60),
                Box::new(InitRosterIqHandler {}),
            ),
        );
        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, _| Ok(conn.state.data.roster_init), stop_future)
                .map_err(|(account, _)| account)
                .and_then(|(conn, r)| match r {
                    Ok(Either::A(_)) => future::ok(conn),
                    Ok(Either::B(_)) => future::err(conn.account),
                    Err(_e) => future::err(conn.account),
                })
            })
    }
    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... {}", String::from(&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, _| Ok(conn.state.data.self_presence),
                    stop_future,
                )
                .map_err(|(account, _)| account)
                .and_then(|(conn, r)| match r {
                    Ok(Either::A(_)) => future::ok(conn),
                    Ok(Either::B(_)) => future::err(conn.account),
                    Err(_e) => future::err(conn.account),
                })
            })
    }
    fn process_jid(&mut self, xmpp_to: &xmpp_parsers::Jid) {
        if let Some(ref mut mailbox) = self.state.data.outgoing_mailbox.get_mut(xmpp_to) {
            if !mailbox.is_empty() {
                if let Some(ref mut rdata) = self.state.data.roster.get_mut(xmpp_to) {
                    info!("Jid {} in roster", xmpp_to);
                    let sub_to = match rdata.0 {
                        xmpp_parsers::roster::Subscription::To => true,
                        xmpp_parsers::roster::Subscription::Both => true,
                        _ => false,
                    };
                    if sub_to {
                        info!("Subscribed to {}", xmpp_to);
                        self.state.data.send_queue.extend(
                            mailbox.drain(..).map(|message| {
                                stanzas::make_chat_message(xmpp_to.clone(), message)
                            }),
                        );
                    } else if rdata.1 == xmpp_parsers::roster::Ask::None {
                        info!("Not subscribed to {}", xmpp_to);
                        self.state
                            .data
                            .send_queue
                            .push_back(stanzas::make_ask_subscribe(xmpp_to.clone()));
                    }
                    let sub_from = match rdata.0 {
                        xmpp_parsers::roster::Subscription::From => true,
                        xmpp_parsers::roster::Subscription::Both => true,
                        _ => false,
                    };
                    if !sub_from {
                        info!("Not subscription from {}", xmpp_to);
                        self.state
                            .data
                            .send_queue
                            .push_back(stanzas::make_allow_subscribe(xmpp_to.clone()));
                    }
                } else {
                    info!("Jid {} not in roster", xmpp_to);
                    self.state.data.counter += 1;
                    let id_add_roster = format!("id_add_roster{}", self.state.data.counter);
                    let add_roster = stanzas::make_add_roster(&id_add_roster, xmpp_to.clone());
                    info!("Adding jid {} to roster id {}", xmpp_to, id_add_roster);
                    self.state.data.pending_ids.insert(
                        id_add_roster,
                        (
                            Instant::now() + Duration::from_secs(60),
                            Box::new(AddRosterIqHandler {
                                jid: xmpp_to.clone(),
                            }),
                        ),
                    );
                    self.state.data.send_queue.push_back(add_roster);
                }
            }
        }
    }
    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);
                self.state.data.pending_ids.insert(
                    id_ping,
                    (
                        Instant::now() + Duration::from_secs(30),
                        Box::new(PingIqHandler {}),
                    ),
                );
            }
            XmppCommand::TimeoutCleanup => {
                let now = Instant::now();
                let timeouted: Vec<String> = self
                    .state
                    .data
                    .pending_ids
                    .iter()
                    .filter_map(|(id, (timeout, _))| {
                        if now >= *timeout {
                            Some(id.to_string())
                        } else {
                            None
                        }
                    })
                    .collect();
                let mut correct = true;
                timeouted.into_iter().for_each(|id| {
                    if let Some((_, handler)) = self.state.data.pending_ids.remove(&id) {
                        correct &= handler.timeout(&mut self);
                    }
                })
            }
        }
    }
    pub fn shutdown(self) -> impl Future<Item = (), Error = failure::Error> {
        info!("Shutdown connection");
        let XmppConnection { account, state } = self;
        stream::iter_ok(
            state
                .data
                .mucs
                .values()
                .map(std::clone::Clone::clone)
                .collect::<Vec<_>>(),
        )
        .fold(state, move |XmppState { client, data }, muc_jid| {
            let muc_presence =
                stanzas::make_muc_presence_leave(account.jid.clone(), muc_jid.clone());
            info!(
                "Sending muc leave presence... {}",
                String::from(&muc_presence)
            );
            use tokio::prelude::Sink;
            client
                .send(Packet::Stanza(muc_presence))
                .map_err(|e| {
                    error!("Error on send muc presence: {}", e);
                    e
                })
                .and_then(|client| future::ok(XmppState { client, data }))
        })
        .map(|_| ())
    }
    fn enter_mucs<F, E>(
        self,
        _stop_future: F,
    ) -> impl Future<Item = Self, Error = std::rc::Rc<config::Account>>
    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... {}", String::from(&muc_presence));
                let account4 = account2.clone();
                use tokio::prelude::Sink;
                client
                    .send(Packet::Stanza(muc_presence))
                    .map_err(|e| {
                        error!("Error on send muc presence: {}", e);
                        account4
                    })
                    .and_then(|client| {
                        data.mucs.insert(muc_jid.0, muc_jid.1);
                        future::ok(XmppState { client, data })
                    })
            })
            .map(|state| XmppConnection {
                account: account3,
                state,
            })
    }
}
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 std::time::{Duration, Instant};
use super::stanzas;
use super::element_processor;
use crate::config;
#[derive(Debug)]
pub enum XmppCommand {
    /// Send message to someone by jid
    Chat {
        xmpp_to: xmpp_parsers::Jid,
        message: String,
    },
    /// Send message to MUC
    Chatroom { muc_id: String, message: String },
    /// Send ping request to the server to test connection
    Ping,
    /// Check iq requests if some have expired timeouts
    TimeoutCleanup,
}
/// trait of processing iq
/// each function consumes handlers and
/// returns false if connection should be reset
trait IqHandler {
    /// process result
    fn result(
        self: Box<Self>,
        conn: &mut XmppConnection,
        opt_element: Option<xmpp_parsers::Element>,
    ) -> bool;
    /// process error
    fn error(
        self: Box<Self>,
        conn: &mut XmppConnection,
        error: xmpp_parsers::stanza_error::StanzaError,
    ) -> bool;
    /// process tmeout
    fn timeout(self: Box<Self>, conn: &mut XmppConnection) -> bool;
}
struct AddRosterIqHandler {
    jid: xmpp_parsers::Jid,
}
impl IqHandler for AddRosterIqHandler {
    fn result(
        self: Box<Self>,
        conn: &mut XmppConnection,
        opt_element: Option<xmpp_parsers::Element>,
    ) -> bool {
        match opt_element {
            Some(element) => {
                warn!(
                    "Wrong payload when adding {} to roster: {}",
                    self.jid,
                    String::from(&element)
                );
            }
            None => {
                if conn.state.data.roster.contains_key(&self.jid) {
                    info!("Jid {} updated to roster", self.jid);
                } else {
                    info!("Jid {} added in roster", self.jid);
                    conn.state.data.roster.insert(
                        self.jid.clone(),
                        (
                            xmpp_parsers::roster::Subscription::None,
                            xmpp_parsers::roster::Ask::None,
                        ),
                    );
                }
                conn.process_jid(&self.jid);
            }
        }
        true
    }
    fn error(
        self: Box<Self>,
        _conn: &mut XmppConnection,
        _error: xmpp_parsers::stanza_error::StanzaError,
    ) -> bool {
        true
    }
    fn timeout(self: Box<Self>, _conn: &mut XmppConnection) -> bool {
        true // ignore
    }
}
struct PingIqHandler {}
impl IqHandler for PingIqHandler {
    fn result(
        self: Box<Self>,
        _conn: &mut XmppConnection,
        _opt_element: Option<xmpp_parsers::Element>,
    ) -> bool {
        info!("ping successed");
        true
    }
    fn error(
        self: Box<Self>,
        _conn: &mut XmppConnection,
        _error: xmpp_parsers::stanza_error::StanzaError,
    ) -> bool {
        false
    }
    fn timeout(self: Box<Self>, _conn: &mut XmppConnection) -> bool {
        false
    }
}
struct InitRosterIqHandler {}
impl IqHandler for InitRosterIqHandler {
    fn result(
        self: Box<Self>,
        conn: &mut XmppConnection,
        opt_element: Option<xmpp_parsers::Element>,
    ) -> bool {
        if let Some(result) = opt_element {
            use std::convert::TryInto;
            match result.try_into() as Result<xmpp_parsers::roster::Roster, _> {
                Ok(roster) => {
                    conn.state.data.roster_init = true;
                    conn.state.data.roster.clear();
                    info!("Got first roster:");
                    for i in roster.items {
                        info!(" >>> {:?}", i);
                        conn.state
                            .data
                            .roster
                            .insert(i.jid, (i.subscription, i.ask));
                    }
                    true
                }
                Err(e) => {
                    error!("Cann't parse roster: {}", e);
                    false
                }
            }
        } else {
            error!("No roster responded");
            false
        }
    }
    fn error(
        self: Box<Self>,
        _conn: &mut XmppConnection,
        _error: xmpp_parsers::stanza_error::StanzaError,
    ) -> bool {
        false
    }
    fn timeout(self: Box<Self>, _conn: &mut XmppConnection) -> bool {
        false
    }
}
#[derive(Default)]
struct XmppData {
    /// known roster data
    roster: HashMap<
        xmpp_parsers::Jid,
        (
            xmpp_parsers::roster::Subscription,
            xmpp_parsers::roster::Ask,
        ),
    >,
    /// if roster was initialized
    /// ToDo: remove it as it is used only for initialization
    roster_init: bool,
    /// if self-presence accepted
    /// ToDo: remove it as it is used only for initialization
    self_presence: bool,
    /// ids counter
    counter: usize,
    /// 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>,
    /// map from iq's id to handler of this type of iqs
    pending_ids: HashMap<String, (Instant, Box<dyn IqHandler>)>,
}
struct XmppState {
    client: Client,
    data: XmppData,
}
pub struct XmppConnection {
    account: std::rc::Rc<config::Account>,
    state: XmppState,
}
trait IqRequestHandler {
    fn process(
        self: Box<Self>,
        conn: &mut XmppConnection,
        id: String,
        from: Option<xmpp_parsers::Jid>,
    ) -> xmpp_parsers::iq::Iq;
}
struct IqRequestUnknown {
    element: xmpp_parsers::Element,
    type_: &'static str,
}
impl IqRequestHandler for IqRequestUnknown {
    fn process(
        self: Box<Self>,
        conn: &mut XmppConnection,
        id: String,
        from: Option<xmpp_parsers::Jid>,
    ) -> xmpp_parsers::iq::Iq {
        warn!(
            "Unsupported IQ {} request from {:?}: {}",
            self.type_,
            from,
            String::from(&self.element)
        );
        stanzas::make_iq_unsupported_error(id, conn.state.client.jid.clone(), from)
    }
}
struct IqSetRoster {}
impl IqRequestHandler for IqSetRoster {
    fn process(
        self: Box<Self>,
        conn: &mut XmppConnection,
        id: String,
        from: Option<xmpp_parsers::Jid>,
    ) -> xmpp_parsers::iq::Iq {
        info!("Got roster push {} from {:?}", id, from);
        stanzas::make_roster_push_answer(id, conn.state.client.jid.clone(), from)
    }
}
struct IqGetPing {}
impl IqRequestHandler for IqGetPing {
    fn process(
        self: Box<Self>,
        conn: &mut XmppConnection,
        id: String,
        from: Option<xmpp_parsers::Jid>,
    ) -> xmpp_parsers::iq::Iq {
        info!("Got ping {} from {:?}", id, from);
        stanzas::make_pong(id, conn.state.client.jid.clone(), from)
    }
}
struct IqGetVersion {}
impl IqRequestHandler for IqGetVersion {
    fn process(
        self: Box<Self>,
        conn: &mut XmppConnection,
        id: String,
        from: Option<xmpp_parsers::Jid>,
    ) -> xmpp_parsers::iq::Iq {
        info!("Got version query {} from {:?}", id, from);
        stanzas::make_version(id, conn.state.client.jid.clone(), from)
    }
}
struct IqGetDiscoInfo {}
impl IqRequestHandler for IqGetDiscoInfo {
    fn process(
        self: Box<Self>,
        conn: &mut XmppConnection,
        id: String,
        from: Option<xmpp_parsers::Jid>,
    ) -> xmpp_parsers::iq::Iq {
        info!("Got disco query {} from {:?}", id, from);
        stanzas::make_disco_info_result(id, conn.state.client.jid.clone(), from)
    }
}
struct IqGetDiscoItems {}
impl IqRequestHandler for IqGetDiscoItems {
    fn process(
        self: Box<Self>,
        conn: &mut XmppConnection,
        id: String,
        from: Option<xmpp_parsers::Jid>,
    ) -> xmpp_parsers::iq::Iq {
        info!("Got disco items query {} from {:?}", id, from);
        stanzas::make_disco_items_result(id, conn.state.client.jid.clone(), from)
    }
}
lazy_static! {
    static ref INCOMING: element_processor::Processor<XmppConnection, bool, xmpp_parsers::Element> = {
        let mut incoming = element_processor::Processor::new(&|_, e| {
            warn!("Unknown stanza {}", String::from(&e));
            true
        });
        incoming.register(&XmppConnection::incoming_iq_processing);
        incoming.register(&XmppConnection::incoming_presence_processing);
        incoming.register(&XmppConnection::incoming_message_processing);
        incoming
    };
    static ref INCOMING_IQ_SET: element_processor::Processor<XmppConnection, Box<dyn IqRequestHandler>, xmpp_parsers::Element> = {
        let mut iq_set =
            element_processor::Processor::new(&|_conn: &mut XmppConnection, element| {
                Box::new(IqRequestUnknown {
                    element,
                    type_: "set",
                }) as Box<dyn IqRequestHandler>
            });
        iq_set.register(&XmppConnection::incoming_iq_processing_set_roster);
        iq_set
    };
    static ref INCOMING_IQ_GET: element_processor::Processor<XmppConnection, Box<dyn IqRequestHandler>, xmpp_parsers::Element> = {
        let mut iq_get =
            element_processor::Processor::new(&|_conn: &mut XmppConnection, element| {
                Box::new(IqRequestUnknown {
                    element,
                    type_: "get",
                }) as Box<dyn IqRequestHandler>
            });
        iq_get.register(&XmppConnection::incoming_iq_processing_get_ping);
        iq_get.register(&XmppConnection::incoming_iq_processing_get_disco_info);
        iq_get.register(&XmppConnection::incoming_iq_processing_get_disco_items);
        iq_get.register(&XmppConnection::incoming_iq_processing_get_version);
        iq_get
    };
}
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) => INCOMING.process(self, stanza.clone()),
            Event::Online => true,
            e => {
                warn!("Unexpected event {:?}", e);
                false
            }
        }
    }
    /// Process roster push
    /// see RFC 6212 2.1.6. Roster Push
    fn incoming_iq_processing_set_roster(
        &mut self,
        roster: xmpp_parsers::roster::Roster,
    ) -> Box<dyn IqRequestHandler> {
        for i in roster.items {
            if let Some(ref mut rdata) = self.state.data.roster.get_mut(&i.jid) {
                info!("Update {} in roster", i.jid);
                rdata.0 = i.subscription;
                rdata.1 = i.ask;
            } else {
                info!("Add {} to roster", i.jid);
                self.state
                    .data
                    .roster
                    .insert(i.jid.clone(), (i.subscription, i.ask));
            }
            self.process_jid(&i.jid);
        }
        Box::new(IqSetRoster {})
    }
    /// Enforce to answer to IQ "set"
    fn incoming_iq_processing_set(
        &mut self,
        id: String,
        from: Option<xmpp_parsers::Jid>,
        element: minidom::Element,
    ) -> xmpp_parsers::iq::Iq {
        INCOMING_IQ_SET
            .process(self, element)
            .process(self, id, from)
    }
    /// Process ping request
    /// see XEP-0199: XMPP Ping
    fn incoming_iq_processing_get_ping(
        &mut self,
        _ping: xmpp_parsers::ping::Ping,
    ) -> Box<dyn IqRequestHandler> {
        Box::new(IqGetPing {})
    }
    /// Process disco query
    /// see XEP-0030: Service Discovery
    fn incoming_iq_processing_get_disco_info(
        &mut self,
        disco: xmpp_parsers::disco::DiscoInfoQuery,
    ) -> Box<dyn IqRequestHandler> {
        if let Some(ref node) = disco.node {
            warn!("Unsupported node {}", node);
            Box::new(IqRequestUnknown {
                element: disco.into(),
                type_: "get",
            })
        } else {
            Box::new(IqGetDiscoInfo {})
        }
    }
    /// Process disco items query
    /// see XEP-0030: Service Discovery
    fn incoming_iq_processing_get_disco_items(
        &mut self,
        disco: xmpp_parsers::disco::DiscoItemsQuery,
    ) -> Box<dyn IqRequestHandler> {
        if let Some(ref node) = disco.node {
            warn!("Unsupported node {}", node);
            Box::new(IqRequestUnknown {
                element: disco.into(),
                type_: "get",
            })
        } else {
            Box::new(IqGetDiscoItems {})
        }
    }
    /// Process version query
    /// see XEP-0092: Software Version
    fn incoming_iq_processing_get_version(
        &mut self,
        _version: xmpp_parsers::version::VersionQuery,
    ) -> Box<dyn IqRequestHandler> {
        Box::new(IqGetVersion {})
    }
    /// Enforce to answer to IQ "get"
    fn incoming_iq_processing_get(
        &mut self,
        id: String,
        from: Option<xmpp_parsers::Jid>,
        element: minidom::Element,
    ) -> xmpp_parsers::iq::Iq {
        INCOMING_IQ_GET
            .process(self, element)
            .process(self, id, from)
    }
    fn incoming_iq_processing(&mut self, iq: xmpp_parsers::iq::Iq) -> bool {
        match iq.payload {
            xmpp_parsers::iq::IqType::Set(element) => {
                let iq_answer = self.incoming_iq_processing_set(iq.id, iq.from, element);
                self.state.data.send_queue.push_back(iq_answer.into());
            }
            xmpp_parsers::iq::IqType::Error(e) => {
                if let Some((_, handler)) = self.state.data.pending_ids.remove_entry(&iq.id) {
                    return handler.1.error(self, e);
                }
                error!("iq error: {:?}", e);
                return false;
            }
            xmpp_parsers::iq::IqType::Get(element) => {
                let iq_answer = self.incoming_iq_processing_get(iq.id, iq.from, element);
                self.state.data.send_queue.push_back(iq_answer.into());
            }
            xmpp_parsers::iq::IqType::Result(opt_element) => {
                if let Some((_, handler)) = self.state.data.pending_ids.remove_entry(&iq.id) {
                    return handler.1.result(self, opt_element);
                }
                warn!(
                    "Unwanted iq result id {} from {:?}: {:?}",
                    iq.id,
                    iq.from,
                    opt_element.map(|e| String::from(&e))
                );
            }
        }
        true
    }
    fn incoming_presence_processing(&mut self, presence: xmpp_parsers::presence::Presence) -> bool {
        if presence.from.as_ref() == Some(&self.state.client.jid) {
            info!("Self-presence accepted");
            self.state.data.self_presence = true;
        } else {
            warn!("Incoming presence stanza: {:?}", presence);
        }
        true
    }
    fn incoming_message_processing(&mut self, message: xmpp_parsers::message::Message) -> bool {
        for payload in message.payloads.iter() {
            use std::convert::TryInto;
            if let Some(_delay) =
                payload.clone().try_into().ok() as Option<xmpp_parsers::delay::Delay>
            {
                return true; // ignore delayed messages
            }
        }
        warn!("Incoming message stanza: {:?}", message);
        true
    }
    /// 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)| {
                // ToDo: check timeouts if iqs
                let XmppConnection {
                    state: XmppState { client, mut data },
                    account,
                } = xmpp;
                if let Some(send_element) = data.send_queue.pop_front() {
                    use tokio::prelude::Sink;
                    info!("Sending {}", String::from(&send_element));
                    Box::new(
                        client
                            .send(Packet::Stanza(send_element))
                            .select2(stop_future)
                            .then(move |r| match r {
                                Ok(Either::A((client, b))) => {
                                    Box::new(future::ok(future::Loop::Continue((
                                        XmppConnection {
                                            state: XmppState { client, data },
                                            account,
                                        },
                                        b,
                                        stop_condition,
                                    ))))
                                        as Box<dyn Future<Item = _, Error = _>>
                                }
                                Ok(Either::B((t, a))) => Box::new(a.then(|r| match r {
                                    Ok(client) => future::ok(future::Loop::Break((
                                        XmppConnection {
                                            state: XmppState { client, data },
                                            account,
                                        },
                                        Ok(Either::B(t)),
                                    ))),
                                    Err(se) => {
                                        warn!("XMPP sending error: {}", se);
                                        future::err((account, Ok(Either::B(t))))
                                    }
                                })),
                                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: {}", String::from(&s));
                Ok(false)
            }
            _ => {
                error!("Disconnected while online");
                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... {}", String::from(&get_roster));
        data.pending_ids.insert(
            id_init_roster.clone(),
            (
                Instant::now() + Duration::from_secs(60),
                Box::new(InitRosterIqHandler {}),
            ),
        );
        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, _| Ok(conn.state.data.roster_init), stop_future)
                .map_err(|(account, _)| account)
                .and_then(|(conn, r)| match r {
                    Ok(Either::A(_)) => future::ok(conn),
                    Ok(Either::B(_)) => future::err(conn.account),
                    Err(_e) => future::err(conn.account),
                })
            })
    }
    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... {}", String::from(&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, _| Ok(conn.state.data.self_presence),
                    stop_future,
                )
                .map_err(|(account, _)| account)
                .and_then(|(conn, r)| match r {
                    Ok(Either::A(_)) => future::ok(conn),
                    Ok(Either::B(_)) => future::err(conn.account),
                    Err(_e) => future::err(conn.account),
                })
            })
    }
    fn process_jid(&mut self, xmpp_to: &xmpp_parsers::Jid) {
        if let Some(ref mut mailbox) = self.state.data.outgoing_mailbox.get_mut(xmpp_to) {
            if !mailbox.is_empty() {
                if let Some(ref mut rdata) = self.state.data.roster.get_mut(xmpp_to) {
                    info!("Jid {} in roster", xmpp_to);
                    let sub_to = match rdata.0 {
                        xmpp_parsers::roster::Subscription::To => true,
                        xmpp_parsers::roster::Subscription::Both => true,
                        _ => false,
                    };
                    if sub_to {
                        info!("Subscribed to {}", xmpp_to);
                        self.state.data.send_queue.extend(
                            mailbox.drain(..).map(|message| {
                                stanzas::make_chat_message(xmpp_to.clone(), message)
                            }),
                        );
                    } else if rdata.1 == xmpp_parsers::roster::Ask::None {
                        info!("Not subscribed to {}", xmpp_to);
                        self.state
                            .data
                            .send_queue
                            .push_back(stanzas::make_ask_subscribe(xmpp_to.clone()));
                    }
                    let sub_from = match rdata.0 {
                        xmpp_parsers::roster::Subscription::From => true,
                        xmpp_parsers::roster::Subscription::Both => true,
                        _ => false,
                    };
                    if !sub_from {
                        info!("Not subscription from {}", xmpp_to);
                        self.state
                            .data
                            .send_queue
                            .push_back(stanzas::make_allow_subscribe(xmpp_to.clone()));
                    }
                } else {
                    info!("Jid {} not in roster", xmpp_to);
                    self.state.data.counter += 1;
                    let id_add_roster = format!("id_add_roster{}", self.state.data.counter);
                    let add_roster = stanzas::make_add_roster(&id_add_roster, xmpp_to.clone());
                    info!("Adding jid {} to roster id {}", xmpp_to, id_add_roster);
                    self.state.data.pending_ids.insert(
                        id_add_roster,
                        (
                            Instant::now() + Duration::from_secs(60),
                            Box::new(AddRosterIqHandler {
                                jid: xmpp_to.clone(),
                            }),
                        ),
                    );
                    self.state.data.send_queue.push_back(add_roster);
                }
            }
        }
    }
    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);
                self.state.data.pending_ids.insert(
                    id_ping,
                    (
                        Instant::now() + Duration::from_secs(30),
                        Box::new(PingIqHandler {}),
                    ),
                );
            }
            XmppCommand::TimeoutCleanup => {
                let now = Instant::now();
                let timeouted: Vec<String> = self
                    .state
                    .data
                    .pending_ids
                    .iter()
                    .filter_map(|(id, (timeout, _))| {
                        if now >= *timeout {
                            Some(id.to_string())
                        } else {
                            None
                        }
                    })
                    .collect();
                let mut correct = true;
                timeouted.into_iter().for_each(|id| {
                    if let Some((_, handler)) = self.state.data.pending_ids.remove(&id) {
                        correct &= handler.timeout(&mut self);
                    }
                })
            }
        }
    }
    pub fn shutdown(self) -> impl Future<Item = (), Error = failure::Error> {
        info!("Shutdown connection");
        let XmppConnection { account, state } = self;
        stream::iter_ok(
            state
                .data
                .mucs
                .values()
                .map(std::clone::Clone::clone)
                .collect::<Vec<_>>(),
        )
        .fold(state, move |XmppState { client, data }, muc_jid| {
            let muc_presence =
                stanzas::make_muc_presence_leave(account.jid.clone(), muc_jid.clone());
            info!(
                "Sending muc leave presence... {}",
                String::from(&muc_presence)
            );
            use tokio::prelude::Sink;
            client
                .send(Packet::Stanza(muc_presence))
                .map_err(|e| {
                    error!("Error on send muc presence: {}", e);
                    e
                })
                .and_then(|client| future::ok(XmppState { client, data }))
        })
        .map(|_| ())
    }
    fn enter_mucs<F, E>(
        self,
        _stop_future: F,
    ) -> impl Future<Item = Self, Error = std::rc::Rc<config::Account>>
    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... {}", String::from(&muc_presence));
                let account4 = account2.clone();
                use tokio::prelude::Sink;
                client
                    .send(Packet::Stanza(muc_presence))
                    .map_err(|e| {
                        error!("Error on send muc presence: {}", e);
                        account4
                    })
                    .and_then(|client| {
                        data.mucs.insert(muc_jid.0, muc_jid.1);
                        future::ok(XmppState { client, data })
                    })
            })
            .map(|state| XmppConnection {
                account: account3,
                state,
            })
    }
}
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,
            })
    }
}
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;
/// trait of processing iq
/// each function consumes handlers and
/// returns false if connection should be reset
trait IqHandler {
    /// process result
    fn result(
        self: Box<Self>,
        conn: &mut XmppConnection,
        opt_element: Option<xmpp_parsers::Element>,
    ) -> bool;
    /// process error
    fn error(
        self: Box<Self>,
        conn: &mut XmppConnection,
        error: xmpp_parsers::stanza_error::StanzaError,
    ) -> bool;
    /// process tmeout
    fn timeout(self: Box<Self>, conn: &mut XmppConnection) -> bool;
}
struct AddRosterIqHandler {
    jid: xmpp_parsers::Jid,
}
impl IqHandler for AddRosterIqHandler {
    fn result(
        self: Box<Self>,
        conn: &mut XmppConnection,
        opt_element: Option<xmpp_parsers::Element>,
    ) -> bool {
        match opt_element {
            Some(element) => {
                warn!(
                    "Wrong payload when adding {} to roster: {}",
                    self.jid,
                    String::from(&element)
                );
            }
            None => {
                if conn.state.data.roster.contains_key(&self.jid) {
                    info!("Jid {} updated to roster", self.jid);
                } else {
                    info!("Jid {} added in roster", self.jid);
                    conn.state.data.roster.insert(
                        self.jid.clone(),
                        (
                            xmpp_parsers::roster::Subscription::None,
                            xmpp_parsers::roster::Ask::None,
                        ),
                    );
                }
                conn.process_jid(&self.jid);
            }
        }
        true
    }
    fn error(
        self: Box<Self>,
        _conn: &mut XmppConnection,
        _error: xmpp_parsers::stanza_error::StanzaError,
    ) -> bool {
        true
    }
    fn timeout(self: Box<Self>, _conn: &mut XmppConnection) -> bool {
        true // ignore
    }
}
struct PingIqHandler {}
impl IqHandler for PingIqHandler {
    fn result(
        self: Box<Self>,
        _conn: &mut XmppConnection,
        _opt_element: Option<xmpp_parsers::Element>,
    ) -> bool {
        info!("ping successed");
        true
    }
    fn error(
        self: Box<Self>,
        _conn: &mut XmppConnection,
        _error: xmpp_parsers::stanza_error::StanzaError,
    ) -> bool {
        false
    }
    fn timeout(self: Box<Self>, _conn: &mut XmppConnection) -> bool {
        false
    }
}
struct InitRosterIqHandler {}
impl IqHandler for InitRosterIqHandler {
    fn result(
        self: Box<Self>,
        conn: &mut XmppConnection,
        opt_element: Option<xmpp_parsers::Element>,
    ) -> bool {
        if let Some(result) = opt_element {
            use std::convert::TryInto;
            match result.try_into() as Result<xmpp_parsers::roster::Roster, _> {
                Ok(roster) => {
                    conn.state.data.roster_init = true;
                    conn.state.data.roster.clear();
                    info!("Got first roster:");
                    for i in roster.items {
                        info!(" >>> {:?}", i);
                        conn.state
                            .data
                            .roster
                            .insert(i.jid, (i.subscription, i.ask));
                    }
                    true
                }
                Err(e) => {
                    error!("Cann't parse roster: {}", e);
                    false
                }
            }
        } else {
            error!("No roster responded");
            false
        }
    }
    fn error(
        self: Box<Self>,
        _conn: &mut XmppConnection,
        _error: xmpp_parsers::stanza_error::StanzaError,
    ) -> bool {
        false
    }
    fn timeout(self: Box<Self>, _conn: &mut XmppConnection) -> bool {
        false
    }
}
#[derive(Default)]
struct XmppData {
    /// known roster data
    roster: HashMap<
        xmpp_parsers::Jid,
        (
            xmpp_parsers::roster::Subscription,
            xmpp_parsers::roster::Ask,
        ),
    >,
    /// if roster was initialized
    /// ToDo: remove it as it is used only for initialization
    roster_init: bool,
    /// if self-presence accepted
    /// ToDo: remove it as it is used only for initialization
    self_presence: bool,
    /// ids counter
    counter: usize,
    /// 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>,
    /// map from iq's id to handler of this type of iqs
    pending_ids: HashMap<String, Box<dyn IqHandler>>,
}
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 {}", String::from(&e));
            true
        });
        incoming.register(&XmppConnection::incoming_iq_processing);
        incoming.register(&XmppConnection::incoming_presence_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
            }
        }
    }
    /// Enforce to answer to IQ "set"
    fn incoming_iq_processing_set(
        &mut self,
        id: String,
        from: Option<xmpp_parsers::Jid>,
        element: minidom::Element,
    ) -> xmpp_parsers::iq::Iq {
        use std::convert::TryInto;
        if let Some(roster) =
            element.clone().try_into().ok() as Option<xmpp_parsers::roster::Roster>
        {
            // RFC 6212 2.1.6. Roster Push
            info!("Got roster push {} from {:?}", id, from);
            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);
            }
            return stanzas::make_roster_push_answer(id, self.state.client.jid.clone(), from);
        }
        warn!(
            "Unsupported IQ set request from {:?}: {}",
            from,
            String::from(&element)
        );
        stanzas::make_iq_unsupported_error(id, self.state.client.jid.clone(), from)
    }
    /// Enforce to answer to IQ "get"
    fn incoming_iq_processing_get(
        &mut self,
        id: String,
        from: Option<xmpp_parsers::Jid>,
        element: minidom::Element,
    ) -> xmpp_parsers::iq::Iq {
        use std::convert::TryInto;
        if let Some(_ping) = element.clone().try_into().ok() as Option<xmpp_parsers::ping::Ping> {
            info!("Got ping {} from {:?}", id, from);
            return stanzas::make_pong(&id, self.state.client.jid.clone(), from);
        }
        warn!(
            "Unsupported IQ get request from {:?}: {}",
            from,
            String::from(&element)
        );
        stanzas::make_iq_unsupported_error(id, self.state.client.jid.clone(), from)
    }
    fn incoming_iq_processing(&mut self, iq: xmpp_parsers::iq::Iq) -> bool {
        match iq.payload {
            xmpp_parsers::iq::IqType::Set(element) => {
                let iq_answer = self.incoming_iq_processing_set(iq.id, iq.from, element);
                self.state.data.send_queue.push_back(iq_answer.into());
            }
            xmpp_parsers::iq::IqType::Error(e) => {
                if let Some((_, handler)) = self.state.data.pending_ids.remove_entry(&iq.id) {
                    return handler.error(self, e);
                }
                error!("iq error: {:?}", e);
                return false;
            }
            xmpp_parsers::iq::IqType::Get(element) => {
                let iq_answer = self.incoming_iq_processing_get(iq.id, iq.from, element);
                self.state.data.send_queue.push_back(iq_answer.into());
            }
            xmpp_parsers::iq::IqType::Result(opt_element) => {
                if let Some((_, handler)) = self.state.data.pending_ids.remove_entry(&iq.id) {
                    return handler.result(self, opt_element);
                }
                warn!(
                    "Unwanted iq result id {} from {:?}: {:?}",
                    iq.id,
                    iq.from,
                    opt_element.map(|e| String::from(&e))
                );
            }
        }
        true
    }
    fn incoming_presence_processing(&mut self, presence: xmpp_parsers::presence::Presence) -> bool {
        if presence.from.as_ref() == Some(&self.state.client.jid) {
            info!("Self-presence accepted");
            self.state.data.self_presence = true;
        } else {
            warn!("Incoming presence stanza: {:?}", presence);
        }
        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 {}", String::from(&send_element));
                    Box::new(
                        client
                            .send(Packet::Stanza(send_element))
                            .select2(stop_future)
                            .then(move |r| match r {
                                Ok(Either::A((client, b))) => {
                                    Box::new(future::ok(future::Loop::Continue((
                                        XmppConnection {
                                            state: XmppState { client, data },
                                            account,
                                        },
                                        b,
                                        stop_condition,
                                    ))))
                                        as Box<dyn Future<Item = _, Error = _>>
                                }
                                Ok(Either::B((t, a))) => Box::new(a.then(|r| match r {
                                    Ok(client) => future::ok(future::Loop::Break((
                                        XmppConnection {
                                            state: XmppState { client, data },
                                            account,
                                        },
                                        Ok(Either::B(t)),
                                    ))),
                                    Err(se) => {
                                        warn!("XMPP sending error: {}", se);
                                        future::err((account, Ok(Either::B(t))))
                                    }
                                })),
                                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: {}", String::from(&s));
                Ok(false)
            }
            _ => {
                error!("Disconnected while online");
                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... {}", String::from(&get_roster));
        data.pending_ids
            .insert(id_init_roster.clone(), Box::new(InitRosterIqHandler {}));
        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, _| Ok(conn.state.data.roster_init), stop_future)
                .map_err(|(account, _)| account)
                .and_then(|(conn, r)| match r {
                    Ok(Either::A(_)) => future::ok(conn),
                    Ok(Either::B(_)) => future::err(conn.account),
                    Err(_e) => future::err(conn.account),
                })
            })
    }
    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... {}", String::from(&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, _| Ok(conn.state.data.self_presence),
                    stop_future,
                )
                .map_err(|(account, _)| account)
                .and_then(|(conn, r)| match r {
                    Ok(Either::A(_)) => future::ok(conn),
                    Ok(Either::B(_)) => future::err(conn.account),
                    Err(_e) => future::err(conn.account),
                })
            })
    }
    fn process_jid(&mut self, xmpp_to: &xmpp_parsers::Jid) {
        if let Some(ref mut mailbox) = self.state.data.outgoing_mailbox.get_mut(xmpp_to) {
            if !mailbox.is_empty() {
                if let Some(ref mut rdata) = self.state.data.roster.get_mut(xmpp_to) {
                    info!("Jid {} in roster", xmpp_to);
                    let sub_to = match rdata.0 {
                        xmpp_parsers::roster::Subscription::To => true,
                        xmpp_parsers::roster::Subscription::Both => true,
                        _ => false,
                    };
                    if sub_to {
                        info!("Subscribed to {}", xmpp_to);
                        self.state.data.send_queue.extend(
                            mailbox.drain(..).map(|message| {
                                stanzas::make_chat_message(xmpp_to.clone(), message)
                            }),
                        );
                    } else if rdata.1 == xmpp_parsers::roster::Ask::None {
                        info!("Not subscribed to {}", xmpp_to);
                        self.state
                            .data
                            .send_queue
                            .push_back(stanzas::make_ask_subscribe(xmpp_to.clone()));
                    }
                    let sub_from = match rdata.0 {
                        xmpp_parsers::roster::Subscription::From => true,
                        xmpp_parsers::roster::Subscription::Both => true,
                        _ => false,
                    };
                    if !sub_from {
                        info!("Not subscription from {}", xmpp_to);
                        self.state
                            .data
                            .send_queue
                            .push_back(stanzas::make_allow_subscribe(xmpp_to.clone()));
                    }
                } else {
                    info!("Jid {} not in roster", xmpp_to);
                    self.state.data.counter += 1;
                    let id_add_roster = format!("id_add_roster{}", self.state.data.counter);
                    let add_roster = stanzas::make_add_roster(&id_add_roster, xmpp_to.clone());
                    info!("Adding jid {} to roster id {}", xmpp_to, id_add_roster);
                    self.state.data.pending_ids.insert(
                        id_add_roster,
                        Box::new(AddRosterIqHandler {
                            jid: xmpp_to.clone(),
                        }),
                    );
                    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);
                self.state
                    .data
                    .pending_ids
                    .insert(id_ping, Box::new(PingIqHandler {}));
            }
        }
    }
    pub fn shutdown(self) -> impl Future<Item = (), Error = failure::Error> {
        info!("Shutdown connection");
        let XmppConnection { account, state } = self;
        stream::iter_ok(
            state
                .data
                .mucs
                .values()
                .map(std::clone::Clone::clone)
                .collect::<Vec<_>>(),
        )
        .fold(state, move |XmppState { client, data }, muc_jid| {
            let muc_presence =
                stanzas::make_muc_presence_leave(account.jid.clone(), muc_jid.clone());
            info!(
                "Sending muc leave presence... {}",
                String::from(&muc_presence)
            );
            use tokio::prelude::Sink;
            client
                .send(Packet::Stanza(muc_presence))
                .map_err(|e| {
                    error!("Error on send muc presence: {}", e);
                    e
                })
                .and_then(|client| future::ok(XmppState { client, data }))
        })
        .map(|_| ())
    }
    fn enter_mucs<F, E>(
        self,
        _stop_future: F,
    ) -> impl Future<Item = Self, Error = std::rc::Rc<config::Account>>
    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... {}", String::from(&muc_presence));
                let account4 = account2.clone();
                use tokio::prelude::Sink;
                client
                    .send(Packet::Stanza(muc_presence))
                    .map_err(|e| {
                        error!("Error on send muc presence: {}", e);
                        account4
                    })
                    .and_then(|client| {
                        data.mucs.insert(muc_jid.0, muc_jid.1);
                        future::ok(XmppState { client, data })
                    })
            })
            .map(|state| XmppConnection {
                account: account3,
                state,
            })
    }
}
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,
            })
    }
}
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,
            })
    }
}
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 std::time::{Duration, Instant};
use super::stanzas;
use super::element_processor;
use crate::config;
#[derive(Debug)]
pub enum XmppCommand {
    /// Send message to someone by jid
    Chat {
        xmpp_to: xmpp_parsers::Jid,
        message: String,
    },
    /// Send message to MUC
    Chatroom { muc_id: String, message: String },
    /// Send ping request to the server to test connection
    Ping,
    /// Check iq requests if some have expired timeouts
    TimeoutCleanup,
}
/// trait of processing iq
/// each function consumes handlers and
/// returns false if connection should be reset
trait IqHandler {
    /// process result
    fn result(
        self: Box<Self>,
        conn: &mut XmppConnection,
        opt_element: Option<xmpp_parsers::Element>,
    ) -> bool;
    /// process error
    fn error(
        self: Box<Self>,
        conn: &mut XmppConnection,
        error: xmpp_parsers::stanza_error::StanzaError,
    ) -> bool;
    /// process tmeout
    fn timeout(self: Box<Self>, conn: &mut XmppConnection) -> bool;
}
struct AddRosterIqHandler {
    jid: xmpp_parsers::Jid,
}
impl IqHandler for AddRosterIqHandler {
    fn result(
        self: Box<Self>,
        conn: &mut XmppConnection,
        opt_element: Option<xmpp_parsers::Element>,
    ) -> bool {
        match opt_element {
            Some(element) => {
                warn!(
                    "Wrong payload when adding {} to roster: {}",
                    self.jid,
                    String::from(&element)
                );
            }
            None => {
                if conn.state.data.roster.contains_key(&self.jid) {
                    info!("Jid {} updated to roster", self.jid);
                } else {
                    info!("Jid {} added in roster", self.jid);
                    conn.state.data.roster.insert(
                        self.jid.clone(),
                        (
                            xmpp_parsers::roster::Subscription::None,
                            xmpp_parsers::roster::Ask::None,
                        ),
                    );
                }
                conn.process_jid(&self.jid);
            }
        }
        true
    }
    fn error(
        self: Box<Self>,
        _conn: &mut XmppConnection,
        _error: xmpp_parsers::stanza_error::StanzaError,
    ) -> bool {
        true
    }
    fn timeout(self: Box<Self>, _conn: &mut XmppConnection) -> bool {
        true // ignore
    }
}
struct PingIqHandler {}
impl IqHandler for PingIqHandler {
    fn result(
        self: Box<Self>,
        _conn: &mut XmppConnection,
        _opt_element: Option<xmpp_parsers::Element>,
    ) -> bool {
        info!("ping successed");
        true
    }
    fn error(
        self: Box<Self>,
        _conn: &mut XmppConnection,
        _error: xmpp_parsers::stanza_error::StanzaError,
    ) -> bool {
        false
    }
    fn timeout(self: Box<Self>, _conn: &mut XmppConnection) -> bool {
        false
    }
}
struct InitRosterIqHandler {}
impl IqHandler for InitRosterIqHandler {
    fn result(
        self: Box<Self>,
        conn: &mut XmppConnection,
        opt_element: Option<xmpp_parsers::Element>,
    ) -> bool {
        if let Some(result) = opt_element {
            use std::convert::TryInto;
            match result.try_into() as Result<xmpp_parsers::roster::Roster, _> {
                Ok(roster) => {
                    conn.state.data.roster_init = true;
                    conn.state.data.roster.clear();
                    info!("Got first roster:");
                    for i in roster.items {
                        info!(" >>> {:?}", i);
                        conn.state
                            .data
                            .roster
                            .insert(i.jid, (i.subscription, i.ask));
                    }
                    true
                }
                Err(e) => {
                    error!("Cann't parse roster: {}", e);
                    false
                }
            }
        } else {
            error!("No roster responded");
            false
        }
    }
    fn error(
        self: Box<Self>,
        _conn: &mut XmppConnection,
        _error: xmpp_parsers::stanza_error::StanzaError,
    ) -> bool {
        false
    }
    fn timeout(self: Box<Self>, _conn: &mut XmppConnection) -> bool {
        false
    }
}
#[derive(Default)]
struct XmppData {
    /// known roster data
    roster: HashMap<
        xmpp_parsers::Jid,
        (
            xmpp_parsers::roster::Subscription,
            xmpp_parsers::roster::Ask,
        ),
    >,
    /// if roster was initialized
    /// ToDo: remove it as it is used only for initialization
    roster_init: bool,
    /// if self-presence accepted
    /// ToDo: remove it as it is used only for initialization
    self_presence: bool,
    /// ids counter
    counter: usize,
    /// 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>,
    /// map from iq's id to handler of this type of iqs
    pending_ids: HashMap<String, (Instant, Box<dyn IqHandler>)>,
}
struct XmppState {
    client: Client,
    data: XmppData,
}
pub struct XmppConnection {
    account: std::rc::Rc<config::Account>,
    state: XmppState,
}
trait IqRequestHandler {
    fn process(
        self: Box<Self>,
        conn: &mut XmppConnection,
        id: String,
        from: Option<xmpp_parsers::Jid>,
    ) -> xmpp_parsers::iq::Iq;
}
struct IqRequestUnknown {
    element: xmpp_parsers::Element,
    type_: &'static str,
}
impl IqRequestHandler for IqRequestUnknown {
    fn process(
        self: Box<Self>,
        conn: &mut XmppConnection,
        id: String,
        from: Option<xmpp_parsers::Jid>,
    ) -> xmpp_parsers::iq::Iq {
        warn!(
            "Unsupported IQ {} request from {:?}: {}",
            self.type_,
            from,
            String::from(&self.element)
        );
        stanzas::make_iq_unsupported_error(id, conn.state.client.jid.clone(), from)
    }
}
struct IqSetRoster {}
impl IqRequestHandler for IqSetRoster {
    fn process(
        self: Box<Self>,
        conn: &mut XmppConnection,
        id: String,
        from: Option<xmpp_parsers::Jid>,
    ) -> xmpp_parsers::iq::Iq {
        info!("Got roster push {} from {:?}", id, from);
        stanzas::make_roster_push_answer(id, conn.state.client.jid.clone(), from)
    }
}
struct IqGetPing {}
impl IqRequestHandler for IqGetPing {
    fn process(
        self: Box<Self>,
        conn: &mut XmppConnection,
        id: String,
        from: Option<xmpp_parsers::Jid>,
    ) -> xmpp_parsers::iq::Iq {
        info!("Got ping {} from {:?}", id, from);
        stanzas::make_pong(id, conn.state.client.jid.clone(), from)
    }
}
struct IqGetDiscoInfo {}
impl IqRequestHandler for IqGetDiscoInfo {
    fn process(
        self: Box<Self>,
        conn: &mut XmppConnection,
        id: String,
        from: Option<xmpp_parsers::Jid>,
    ) -> xmpp_parsers::iq::Iq {
        info!("Got disco query {} from {:?}", id, from);
        stanzas::make_disco_info_result(id, conn.state.client.jid.clone(), from)
    }
}
struct IqGetDiscoItems {}
impl IqRequestHandler for IqGetDiscoItems {
    fn process(
        self: Box<Self>,
        conn: &mut XmppConnection,
        id: String,
        from: Option<xmpp_parsers::Jid>,
    ) -> xmpp_parsers::iq::Iq {
        info!("Got disco items query {} from {:?}", id, from);
        stanzas::make_disco_items_result(id, conn.state.client.jid.clone(), from)
    }
}
struct IqGetDiscoCommands {}
impl IqRequestHandler for IqGetDiscoCommands {
    fn process(
        self: Box<Self>,
        conn: &mut XmppConnection,
        id: String,
        from: Option<xmpp_parsers::Jid>,
    ) -> xmpp_parsers::iq::Iq {
        info!("Got disco commands query {} from {:?}", id, from);
        stanzas::make_disco_items_commands(id, conn.state.client.jid.clone(), from)
    }
}
lazy_static! {
    static ref INCOMING: element_processor::Processor<XmppConnection, bool, xmpp_parsers::Element> = {
        let mut incoming = element_processor::Processor::new(&|_, e| {
            warn!("Unknown stanza {}", String::from(&e));
            true
        });
        incoming.register(&XmppConnection::incoming_iq_processing);
        incoming.register(&XmppConnection::incoming_presence_processing);
        incoming.register(&XmppConnection::incoming_message_processing);
        incoming
    };
    static ref INCOMING_IQ_SET: element_processor::Processor<XmppConnection, Box<dyn IqRequestHandler>, xmpp_parsers::Element> = {
        let mut iq_set =
            element_processor::Processor::new(&|_conn: &mut XmppConnection, element| {
                Box::new(IqRequestUnknown {
                    element,
                    type_: "set",
                }) as Box<dyn IqRequestHandler>
            });
        iq_set.register(&XmppConnection::incoming_iq_processing_set_roster);
        iq_set
    };
    static ref INCOMING_IQ_GET: element_processor::Processor<XmppConnection, Box<dyn IqRequestHandler>, xmpp_parsers::Element> = {
        let mut iq_get =
            element_processor::Processor::new(&|_conn: &mut XmppConnection, element| {
                Box::new(IqRequestUnknown {
                    element,
                    type_: "get",
                }) as Box<dyn IqRequestHandler>
            });
        iq_get.register(&XmppConnection::incoming_iq_processing_get_ping);
        iq_get.register(&XmppConnection::incoming_iq_processing_get_disco_info);
        iq_get.register(&XmppConnection::incoming_iq_processing_get_disco_items);
        iq_get
    };
}
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) => INCOMING.process(self, stanza.clone()),
            Event::Online => true,
            e => {
                warn!("Unexpected event {:?}", e);
                false
            }
        }
    }
    /// Process roster push
    /// see RFC 6212 2.1.6. Roster Push
    fn incoming_iq_processing_set_roster(
        &mut self,
        roster: xmpp_parsers::roster::Roster,
    ) -> Box<dyn IqRequestHandler> {
        for i in roster.items {
            if let Some(ref mut rdata) = self.state.data.roster.get_mut(&i.jid) {
                info!("Update {} in roster", i.jid);
                rdata.0 = i.subscription;
                rdata.1 = i.ask;
            } else {
                info!("Add {} to roster", i.jid);
                self.state
                    .data
                    .roster
                    .insert(i.jid.clone(), (i.subscription, i.ask));
            }
            self.process_jid(&i.jid);
        }
        Box::new(IqSetRoster {})
    }
    /// Enforce to answer to IQ "set"
    fn incoming_iq_processing_set(
        &mut self,
        id: String,
        from: Option<xmpp_parsers::Jid>,
        element: minidom::Element,
    ) -> xmpp_parsers::iq::Iq {
        INCOMING_IQ_SET
            .process(self, element)
            .process(self, id, from)
    }
    /// Process ping request
    /// see XEP-0199: XMPP Ping
    fn incoming_iq_processing_get_ping(
        &mut self,
        _ping: xmpp_parsers::ping::Ping,
    ) -> Box<dyn IqRequestHandler> {
        Box::new(IqGetPing {})
    }
    /// Process disco query
    /// see XEP-0030: Service Discovery
    fn incoming_iq_processing_get_disco_info(
        &mut self,
        disco: xmpp_parsers::disco::DiscoInfoQuery,
    ) -> Box<dyn IqRequestHandler> {
        if let Some(ref node) = disco.node {
            warn!("Unsupported node {}", node);
            Box::new(IqRequestUnknown {
                element: disco.into(),
                type_: "get",
            })
        } else {
            Box::new(IqGetDiscoInfo {})
        }
    }
    /// Process disco items query
    /// see XEP-0030: Service Discovery
    fn incoming_iq_processing_get_disco_items(
        &mut self,
        disco: xmpp_parsers::disco::DiscoItemsQuery,
    ) -> Box<dyn IqRequestHandler> {
        match &disco.node {
            Some(node) if node == "http://jabber.org/protocol/commands" => {
                Box::new(IqGetDiscoCommands {})
            }
            Some(node) => {
                warn!("Unsupported node {}", node);
                Box::new(IqRequestUnknown {
                    element: disco.into(),
                    type_: "get",
                })
            }
            None => Box::new(IqGetDiscoItems {}),
        }
    }
    /// Enforce to answer to IQ "get"
    fn incoming_iq_processing_get(
        &mut self,
        id: String,
        from: Option<xmpp_parsers::Jid>,
        element: minidom::Element,
    ) -> xmpp_parsers::iq::Iq {
        INCOMING_IQ_GET
            .process(self, element)
            .process(self, id, from)
    }
    fn incoming_iq_processing(&mut self, iq: xmpp_parsers::iq::Iq) -> bool {
        match iq.payload {
            xmpp_parsers::iq::IqType::Set(element) => {
                let iq_answer = self.incoming_iq_processing_set(iq.id, iq.from, element);
                self.state.data.send_queue.push_back(iq_answer.into());
            }
            xmpp_parsers::iq::IqType::Error(e) => {
                if let Some((_, handler)) = self.state.data.pending_ids.remove_entry(&iq.id) {
                    return handler.1.error(self, e);
                }
                error!("iq error: {:?}", e);
                return false;
            }
            xmpp_parsers::iq::IqType::Get(element) => {
                let iq_answer = self.incoming_iq_processing_get(iq.id, iq.from, element);
                self.state.data.send_queue.push_back(iq_answer.into());
            }
            xmpp_parsers::iq::IqType::Result(opt_element) => {
                if let Some((_, handler)) = self.state.data.pending_ids.remove_entry(&iq.id) {
                    return handler.1.result(self, opt_element);
                }
                warn!(
                    "Unwanted iq result id {} from {:?}: {:?}",
                    iq.id,
                    iq.from,
                    opt_element.map(|e| String::from(&e))
                );
            }
        }
        true
    }
    fn incoming_presence_processing(&mut self, presence: xmpp_parsers::presence::Presence) -> bool {
        if presence.from.as_ref() == Some(&self.state.client.jid) {
            info!("Self-presence accepted");
            self.state.data.self_presence = true;
        } else {
            warn!("Incoming presence stanza: {:?}", presence);
        }
        true
    }
    fn incoming_message_processing(&mut self, message: xmpp_parsers::message::Message) -> bool {
        for payload in message.payloads.iter() {
            use std::convert::TryInto;
            if let Some(_delay) =
                payload.clone().try_into().ok() as Option<xmpp_parsers::delay::Delay>
            {
                return true; // ignore delayed messages
            }
        }
        warn!("Incoming message stanza: {:?}", message);
        true
    }
    /// 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)| {
                // ToDo: check timeouts if iqs
                let XmppConnection {
                    state: XmppState { client, mut data },
                    account,
                } = xmpp;
                if let Some(send_element) = data.send_queue.pop_front() {
                    use tokio::prelude::Sink;
                    info!("Sending {}", String::from(&send_element));
                    Box::new(
                        client
                            .send(Packet::Stanza(send_element))
                            .select2(stop_future)
                            .then(move |r| match r {
                                Ok(Either::A((client, b))) => {
                                    Box::new(future::ok(future::Loop::Continue((
                                        XmppConnection {
                                            state: XmppState { client, data },
                                            account,
                                        },
                                        b,
                                        stop_condition,
                                    ))))
                                        as Box<dyn Future<Item = _, Error = _>>
                                }
                                Ok(Either::B((t, a))) => Box::new(a.then(|r| match r {
                                    Ok(client) => future::ok(future::Loop::Break((
                                        XmppConnection {
                                            state: XmppState { client, data },
                                            account,
                                        },
                                        Ok(Either::B(t)),
                                    ))),
                                    Err(se) => {
                                        warn!("XMPP sending error: {}", se);
                                        future::err((account, Ok(Either::B(t))))
                                    }
                                })),
                                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: {}", String::from(&s));
                Ok(false)
            }
            _ => {
                error!("Disconnected while online");
                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... {}", String::from(&get_roster));
        data.pending_ids.insert(
            id_init_roster.clone(),
            (
                Instant::now() + Duration::from_secs(60),
                Box::new(InitRosterIqHandler {}),
            ),
        );
        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, _| Ok(conn.state.data.roster_init), stop_future)
                .map_err(|(account, _)| account)
                .and_then(|(conn, r)| match r {
                    Ok(Either::A(_)) => future::ok(conn),
                    Ok(Either::B(_)) => future::err(conn.account),
                    Err(_e) => future::err(conn.account),
                })
            })
    }
    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... {}", String::from(&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, _| Ok(conn.state.data.self_presence),
                    stop_future,
                )
                .map_err(|(account, _)| account)
                .and_then(|(conn, r)| match r {
                    Ok(Either::A(_)) => future::ok(conn),
                    Ok(Either::B(_)) => future::err(conn.account),
                    Err(_e) => future::err(conn.account),
                })
            })
    }
    fn process_jid(&mut self, xmpp_to: &xmpp_parsers::Jid) {
        if let Some(ref mut mailbox) = self.state.data.outgoing_mailbox.get_mut(xmpp_to) {
            if !mailbox.is_empty() {
                if let Some(ref mut rdata) = self.state.data.roster.get_mut(xmpp_to) {
                    info!("Jid {} in roster", xmpp_to);
                    let sub_to = match rdata.0 {
                        xmpp_parsers::roster::Subscription::To => true,
                        xmpp_parsers::roster::Subscription::Both => true,
                        _ => false,
                    };
                    if sub_to {
                        info!("Subscribed to {}", xmpp_to);
                        self.state.data.send_queue.extend(
                            mailbox.drain(..).map(|message| {
                                stanzas::make_chat_message(xmpp_to.clone(), message)
                            }),
                        );
                    } else if rdata.1 == xmpp_parsers::roster::Ask::None {
                        info!("Not subscribed to {}", xmpp_to);
                        self.state
                            .data
                            .send_queue
                            .push_back(stanzas::make_ask_subscribe(xmpp_to.clone()));
                    }
                    let sub_from = match rdata.0 {
                        xmpp_parsers::roster::Subscription::From => true,
                        xmpp_parsers::roster::Subscription::Both => true,
                        _ => false,
                    };
                    if !sub_from {
                        info!("Not subscription from {}", xmpp_to);
                        self.state
                            .data
                            .send_queue
                            .push_back(stanzas::make_allow_subscribe(xmpp_to.clone()));
                    }
                } else {
                    info!("Jid {} not in roster", xmpp_to);
                    self.state.data.counter += 1;
                    let id_add_roster = format!("id_add_roster{}", self.state.data.counter);
                    let add_roster = stanzas::make_add_roster(&id_add_roster, xmpp_to.clone());
                    info!("Adding jid {} to roster id {}", xmpp_to, id_add_roster);
                    self.state.data.pending_ids.insert(
                        id_add_roster,
                        (
                            Instant::now() + Duration::from_secs(60),
                            Box::new(AddRosterIqHandler {
                                jid: xmpp_to.clone(),
                            }),
                        ),
                    );
                    self.state.data.send_queue.push_back(add_roster);
                }
            }
        }
    }
    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);
                self.state.data.pending_ids.insert(
                    id_ping,
                    (
                        Instant::now() + Duration::from_secs(30),
                        Box::new(PingIqHandler {}),
                    ),
                );
            }
            XmppCommand::TimeoutCleanup => {
                let now = Instant::now();
                let timeouted: Vec<String> = self
                    .state
                    .data
                    .pending_ids
                    .iter()
                    .filter_map(|(id, (timeout, _))| {
                        if now >= *timeout {
                            Some(id.to_string())
                        } else {
                            None
                        }
                    })
                    .collect();
                let mut correct = true;
                timeouted.into_iter().for_each(|id| {
                    if let Some((_, handler)) = self.state.data.pending_ids.remove(&id) {
                        correct &= handler.timeout(&mut self);
                    }
                })
            }
        }
    }
    pub fn shutdown(self) -> impl Future<Item = (), Error = failure::Error> {
        info!("Shutdown connection");
        let XmppConnection { account, state } = self;
        stream::iter_ok(
            state
                .data
                .mucs
                .values()
                .map(std::clone::Clone::clone)
                .collect::<Vec<_>>(),
        )
        .fold(state, move |XmppState { client, data }, muc_jid| {
            let muc_presence =
                stanzas::make_muc_presence_leave(account.jid.clone(), muc_jid.clone());
            info!(
                "Sending muc leave presence... {}",
                String::from(&muc_presence)
            );
            use tokio::prelude::Sink;
            client
                .send(Packet::Stanza(muc_presence))
                .map_err(|e| {
                    error!("Error on send muc presence: {}", e);
                    e
                })
                .and_then(|client| future::ok(XmppState { client, data }))
        })
        .map(|_| ())
    }
    fn enter_mucs<F, E>(
        self,
        _stop_future: F,
    ) -> impl Future<Item = Self, Error = std::rc::Rc<config::Account>>
    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... {}", String::from(&muc_presence));
                let account4 = account2.clone();
                use tokio::prelude::Sink;
                client
                    .send(Packet::Stanza(muc_presence))
                    .map_err(|e| {
                        error!("Error on send muc presence: {}", e);
                        account4
                    })
                    .and_then(|client| {
                        data.mucs.insert(muc_jid.0, muc_jid.1);
                        future::ok(XmppState { client, data })
                    })
            })
            .map(|state| XmppConnection {
                account: account3,
                state,
            })
    }
}
use tokio_xmpp::{Client, Event, Packet};
use tokio::prelude::future::{self, Either};
use tokio::prelude::stream;
use tokio::prelude::{Future, Stream};
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 std::time::{Duration, Instant};
use super::XmppCommand;
use super::stanzas;
use super::element_processor;
use crate::config;
/// trait of processing iq
/// each function consumes handlers and
/// returns false if connection should be reset
trait IqHandler {
    /// process result
    fn result(
        self: Box<Self>,
        conn: &mut XmppConnection,
        opt_element: Option<xmpp_parsers::Element>,
    ) -> bool;
    /// process error
    fn error(
        self: Box<Self>,
        conn: &mut XmppConnection,
        error: xmpp_parsers::stanza_error::StanzaError,
    ) -> bool;
    /// process tmeout
    fn timeout(self: Box<Self>, conn: &mut XmppConnection) -> bool;
}
struct AddRosterIqHandler {
    jid: xmpp_parsers::Jid,
}
impl IqHandler for AddRosterIqHandler {
    fn result(
        self: Box<Self>,
        conn: &mut XmppConnection,
        opt_element: Option<xmpp_parsers::Element>,
    ) -> bool {
        match opt_element {
            Some(element) => {
                warn!(
                    "Wrong payload when adding {} to roster: {}",
                    self.jid,
                    String::from(&element)
                );
            }
            None => {
                if conn.state.data.roster.contains_key(&self.jid) {
                    info!("Jid {} updated to roster", self.jid);
                } else {
                    info!("Jid {} added in roster", self.jid);
                    conn.state.data.roster.insert(
                        self.jid.clone(),
                        (
                            xmpp_parsers::roster::Subscription::None,
                            xmpp_parsers::roster::Ask::None,
                        ),
                    );
                }
                conn.process_jid(&self.jid);
            }
        }
        true
    }
    fn error(
        self: Box<Self>,
        _conn: &mut XmppConnection,
        _error: xmpp_parsers::stanza_error::StanzaError,
    ) -> bool {
        true
    }
    fn timeout(self: Box<Self>, _conn: &mut XmppConnection) -> bool {
        true // ignore
    }
}
struct PingIqHandler {}
impl IqHandler for PingIqHandler {
    fn result(
        self: Box<Self>,
        _conn: &mut XmppConnection,
        _opt_element: Option<xmpp_parsers::Element>,
    ) -> bool {
        true // ignore
    }
    fn error(
        self: Box<Self>,
        _conn: &mut XmppConnection,
        _error: xmpp_parsers::stanza_error::StanzaError,
    ) -> bool {
        false
    }
    fn timeout(self: Box<Self>, _conn: &mut XmppConnection) -> bool {
        false
    }
}
struct InitRosterIqHandler {}
impl IqHandler for InitRosterIqHandler {
    fn result(
        self: Box<Self>,
        conn: &mut XmppConnection,
        opt_element: Option<xmpp_parsers::Element>,
    ) -> bool {
        if let Some(result) = opt_element {
            use std::convert::TryInto;
            match result.try_into() as Result<xmpp_parsers::roster::Roster, _> {
                Ok(roster) => {
                    conn.state.data.roster_init = true;
                    conn.state.data.roster.clear();
                    info!("Got first roster:");
                    for i in roster.items {
                        info!(" >>> {:?}", i);
                        conn.state
                            .data
                            .roster
                            .insert(i.jid, (i.subscription, i.ask));
                    }
                    true
                }
                Err(e) => {
                    error!("Cann't parse roster: {}", e);
                    false
                }
            }
        } else {
            error!("No roster responded");
            false
        }
    }
    fn error(
        self: Box<Self>,
        _conn: &mut XmppConnection,
        _error: xmpp_parsers::stanza_error::StanzaError,
    ) -> bool {
        false
    }
    fn timeout(self: Box<Self>, _conn: &mut XmppConnection) -> bool {
        false
    }
}
#[derive(Default)]
struct XmppData {
    /// known roster data
    roster: HashMap<
        xmpp_parsers::Jid,
        (
            xmpp_parsers::roster::Subscription,
            xmpp_parsers::roster::Ask,
        ),
    >,
    /// if roster was initialized
    /// ToDo: remove it as it used only for initialization
    roster_init: bool,
    /// ids counter
    counter: usize,
    /// 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>,
    /// map from iq's id to handler of this type of iqs
    pending_ids: HashMap<String, (Instant, Box<dyn IqHandler>)>,
}
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 {}", String::from(&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
            }
        }
    }
    /// Enforce to answer to IQ "set"
    fn incoming_iq_processing_set(
        &mut self,
        id: String,
        from: Option<xmpp_parsers::Jid>,
        element: minidom::Element,
    ) -> xmpp_parsers::iq::Iq {
        use std::convert::TryInto;
        if let Some(roster) =
            element.clone().try_into().ok() as Option<xmpp_parsers::roster::Roster>
        {
            // RFC 6212 2.1.6. Roster Push
            for i in roster.items {
                if let Some(ref mut rdata) = self.state.data.roster.get_mut(&i.jid) {
                    info!("Update {} in roster", i.jid);
                    rdata.0 = i.subscription;
                    rdata.1 = i.ask;
                } else {
                    info!("Add {} to roster", i.jid);
                    self.state
                        .data
                        .roster
                        .insert(i.jid.clone(), (i.subscription, i.ask));
                }
                self.process_jid(&i.jid);
            }
            return stanzas::make_roster_push_answer(id, self.state.client.jid.clone(), from);
        }
        warn!(
            "Unsupported IQ set request from {:?}: {}",
            from,
            String::from(&element)
        );
        stanzas::make_iq_unsupported_error(id, self.state.client.jid.clone(), from)
    }
    /// Enforce to answer to IQ "get"
    fn incoming_iq_processing_get(
        &mut self,
        id: String,
        from: Option<xmpp_parsers::Jid>,
        element: minidom::Element,
    ) -> xmpp_parsers::iq::Iq {
        use std::convert::TryInto;
        if let Some(_ping) = element.clone().try_into().ok() as Option<xmpp_parsers::ping::Ping> {
            return stanzas::make_pong(&id, self.state.client.jid.clone(), from);
        }
        warn!(
            "Unsupported IQ get request from {:?}: {}",
            from,
            String::from(&element)
        );
        stanzas::make_iq_unsupported_error(id, self.state.client.jid.clone(), from)
    }
    fn incoming_iq_processing(&mut self, iq: xmpp_parsers::iq::Iq) -> bool {
        match iq.payload {
            xmpp_parsers::iq::IqType::Set(element) => {
                let iq_answer = self.incoming_iq_processing_set(iq.id, iq.from, element);
                self.state.data.send_queue.push_back(iq_answer.into());
            }
            xmpp_parsers::iq::IqType::Error(e) => {
                if let Some((_, handler)) = self.state.data.pending_ids.remove_entry(&iq.id) {
                    return handler.1.error(self, e);
                }
                error!("iq error: {:?}", e);
                return false;
            }
            xmpp_parsers::iq::IqType::Get(element) => {
                let iq_answer = self.incoming_iq_processing_get(iq.id, iq.from, element);
                self.state.data.send_queue.push_back(iq_answer.into());
            }
            xmpp_parsers::iq::IqType::Result(opt_element) => {
                if let Some((_, handler)) = self.state.data.pending_ids.remove_entry(&iq.id) {
                    return handler.1.result(self, opt_element);
                }
                warn!(
                    "Unwanted iq result id {} from {:?}: {:?}",
                    iq.id,
                    iq.from,
                    opt_element.map(|e| String::from(&e))
                );
            }
        }
        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)| {
                // ToDo: check timeouts if iqs
                let XmppConnection {
                    state: XmppState { client, mut data },
                    account,
                } = xmpp;
                if let Some(send_element) = data.send_queue.pop_front() {
                    use tokio::prelude::Sink;
                    info!("Sending {}", String::from(&send_element));
                    Box::new(
                        client
                            .send(Packet::Stanza(send_element))
                            .select2(stop_future)
                            .then(move |r| match r {
                                Ok(Either::A((client, b))) => {
                                    Box::new(future::ok(future::Loop::Continue((
                                        XmppConnection {
                                            state: XmppState { client, data },
                                            account,
                                        },
                                        b,
                                        stop_condition,
                                    ))))
                                        as Box<dyn Future<Item = _, Error = _>>
                                }
                                Ok(Either::B((t, a))) => Box::new(a.then(|r| match r {
                                    Ok(client) => future::ok(future::Loop::Break((
                                        XmppConnection {
                                            state: XmppState { client, data },
                                            account,
                                        },
                                        Ok(Either::B(t)),
                                    ))),
                                    Err(se) => {
                                        warn!("XMPP sending error: {}", se);
                                        future::err((account, Ok(Either::B(t))))
                                    }
                                })),
                                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: {}", String::from(&s));
                Ok(false)
            }
            _ => {
                error!("Disconnected while online");
                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... {}", String::from(&get_roster));
        data.pending_ids.insert(
            id_init_roster.clone(),
            (
                Instant::now() + Duration::from_secs(60),
                Box::new(InitRosterIqHandler {}),
            ),
        );
        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, _| Ok(conn.state.data.roster_init), stop_future)
                .map_err(|(account, _)| account)
                .and_then(|(conn, r)| match r {
                    Ok(Either::A(_)) => future::ok(conn),
                    Ok(Either::B(_)) => future::err(conn.account),
                    Err(_e) => future::err(conn.account),
                })
            })
    }
    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... {}", String::from(&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());
                    info!("Adding jid {} to roster id {}", xmpp_to, id_add_roster);
                    self.state.data.pending_ids.insert(
                        id_add_roster,
                        (
                            Instant::now() + Duration::from_secs(60),
                            Box::new(AddRosterIqHandler {
                                jid: xmpp_to.clone(),
                            }),
                        ),
                    );
                    self.state.data.send_queue.push_back(add_roster);
                }
            }
        }
    }
    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);
                self.state.data.pending_ids.insert(
                    id_ping,
                    (
                        Instant::now() + Duration::from_secs(30),
                        Box::new(PingIqHandler {}),
                    ),
                );
            }
        }
    }
    pub fn shutdown(self) -> impl Future<Item = (), Error = failure::Error> {
        info!("Shutdown connection");
        let XmppConnection { account, state } = self;
        stream::iter_ok(
            state
                .data
                .mucs
                .values()
                .map(std::clone::Clone::clone)
                .collect::<Vec<_>>(),
        )
        .fold(state, move |XmppState { client, data }, muc_jid| {
            let muc_presence =
                stanzas::make_muc_presence_leave(account.jid.clone(), muc_jid.clone());
            info!(
                "Sending muc leave presence... {}",
                String::from(&muc_presence)
            );
            use tokio::prelude::Sink;
            client
                .send(Packet::Stanza(muc_presence))
                .map_err(|e| {
                    error!("Error on send muc presence: {}", e);
                    e
                })
                .and_then(|client| future::ok(XmppState { client, data }))
        })
        .map(|_| ())
    }
    fn enter_mucs<F, E>(
        self,
        _stop_future: F,
    ) -> impl Future<Item = Self, Error = std::rc::Rc<config::Account>>
    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... {}", String::from(&muc_presence));
                let account4 = account2.clone();
                use tokio::prelude::Sink;
                client
                    .send(Packet::Stanza(muc_presence))
                    .map_err(|e| {
                        error!("Error on send muc presence: {}", e);
                        account4
                    })
                    .and_then(|client| {
                        data.mucs.insert(muc_jid.0, muc_jid.1);
                        future::ok(XmppState { client, data })
                    })
            })
            .map(|state| XmppConnection {
                account: account3,
                state,
            })
    }
}
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;
/// trait of processing iq
/// each function consumes handlers and
/// returns false if connection should be reset
trait IqHandler {
    /// process result
    fn result(
        self: Box<Self>,
        conn: &mut XmppConnection,
        opt_element: Option<xmpp_parsers::Element>,
    ) -> bool;
    /// process error
    fn error(
        self: Box<Self>,
        conn: &mut XmppConnection,
        error: xmpp_parsers::stanza_error::StanzaError,
    ) -> bool;
    /// process tmeout
    fn timeout(self: Box<Self>, conn: &mut XmppConnection) -> bool;
}
struct AddRosterIqHandler {
    jid: xmpp_parsers::Jid,
}
impl IqHandler for AddRosterIqHandler {
    fn result(
        self: Box<Self>,
        conn: &mut XmppConnection,
        opt_element: Option<xmpp_parsers::Element>,
    ) -> bool {
        match opt_element {
            Some(element) => {
                warn!(
                    "Wrong payload when adding {} to roster: {}",
                    self.jid,
                    String::from(&element)
                );
            }
            None => {
                if conn.state.data.roster.contains_key(&self.jid) {
                    info!("Jid {} updated to roster", self.jid);
                } else {
                    info!("Jid {} added in roster", self.jid);
                    conn.state.data.roster.insert(
                        self.jid.clone(),
                        (
                            xmpp_parsers::roster::Subscription::None,
                            xmpp_parsers::roster::Ask::None,
                        ),
                    );
                }
                conn.process_jid(&self.jid);
            }
        }
        true
    }
    fn error(
        self: Box<Self>,
        _conn: &mut XmppConnection,
        _error: xmpp_parsers::stanza_error::StanzaError,
    ) -> bool {
        true
    }
    fn timeout(self: Box<Self>, _conn: &mut XmppConnection) -> bool {
        true // ignore
    }
}
struct PingIqHandler {}
impl IqHandler for PingIqHandler {
    fn result(
        self: Box<Self>,
        _conn: &mut XmppConnection,
        _opt_element: Option<xmpp_parsers::Element>,
    ) -> bool {
        info!("ping successed");
        true
    }
    fn error(
        self: Box<Self>,
        _conn: &mut XmppConnection,
        _error: xmpp_parsers::stanza_error::StanzaError,
    ) -> bool {
        false
    }
    fn timeout(self: Box<Self>, _conn: &mut XmppConnection) -> bool {
        false
    }
}
struct InitRosterIqHandler {}
impl IqHandler for InitRosterIqHandler {
    fn result(
        self: Box<Self>,
        conn: &mut XmppConnection,
        opt_element: Option<xmpp_parsers::Element>,
    ) -> bool {
        if let Some(result) = opt_element {
            use std::convert::TryInto;
            match result.try_into() as Result<xmpp_parsers::roster::Roster, _> {
                Ok(roster) => {
                    conn.state.data.roster_init = true;
                    conn.state.data.roster.clear();
                    info!("Got first roster:");
                    for i in roster.items {
                        info!(" >>> {:?}", i);
                        conn.state
                            .data
                            .roster
                            .insert(i.jid, (i.subscription, i.ask));
                    }
                    true
                }
                Err(e) => {
                    error!("Cann't parse roster: {}", e);
                    false
                }
            }
        } else {
            error!("No roster responded");
            false
        }
    }
    fn error(
        self: Box<Self>,
        _conn: &mut XmppConnection,
        _error: xmpp_parsers::stanza_error::StanzaError,
    ) -> bool {
        false
    }
    fn timeout(self: Box<Self>, _conn: &mut XmppConnection) -> bool {
        false
    }
}
#[derive(Default)]
struct XmppData {
    /// known roster data
    roster: HashMap<
        xmpp_parsers::Jid,
        (
            xmpp_parsers::roster::Subscription,
            xmpp_parsers::roster::Ask,
        ),
    >,
    /// if roster was initialized
    /// ToDo: remove it as it is used only for initialization
    roster_init: bool,
    /// if self-presence accepted
    /// ToDo: remove it as it is used only for initialization
    self_presence: bool,
    /// ids counter
    counter: usize,
    /// 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>,
    /// map from iq's id to handler of this type of iqs
    pending_ids: HashMap<String, Box<dyn IqHandler>>,
}
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 {}", String::from(&e));
            true
        });
        incoming.register(&XmppConnection::incoming_iq_processing);
        incoming.register(&XmppConnection::incoming_presence_processing);
        incoming.register(&XmppConnection::incoming_message_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
            }
        }
    }
    /// Enforce to answer to IQ "set"
    fn incoming_iq_processing_set(
        &mut self,
        id: String,
        from: Option<xmpp_parsers::Jid>,
        element: minidom::Element,
    ) -> xmpp_parsers::iq::Iq {
        use std::convert::TryInto;
        if let Some(roster) =
            element.clone().try_into().ok() as Option<xmpp_parsers::roster::Roster>
        {
            // RFC 6212 2.1.6. Roster Push
            info!("Got roster push {} from {:?}", id, from);
            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);
            }
            return stanzas::make_roster_push_answer(id, self.state.client.jid.clone(), from);
        }
        warn!(
            "Unsupported IQ set request from {:?}: {}",
            from,
            String::from(&element)
        );
        stanzas::make_iq_unsupported_error(id, self.state.client.jid.clone(), from)
    }
    /// Enforce to answer to IQ "get"
    fn incoming_iq_processing_get(
        &mut self,
        id: String,
        from: Option<xmpp_parsers::Jid>,
        element: minidom::Element,
    ) -> xmpp_parsers::iq::Iq {
        use std::convert::TryInto;
        if let Some(_ping) = element.clone().try_into().ok() as Option<xmpp_parsers::ping::Ping> {
            info!("Got ping {} from {:?}", id, from);
            return stanzas::make_pong(&id, self.state.client.jid.clone(), from);
        }
        warn!(
            "Unsupported IQ get request from {:?}: {}",
            from,
            String::from(&element)
        );
        stanzas::make_iq_unsupported_error(id, self.state.client.jid.clone(), from)
    }
    fn incoming_iq_processing(&mut self, iq: xmpp_parsers::iq::Iq) -> bool {
        match iq.payload {
            xmpp_parsers::iq::IqType::Set(element) => {
                let iq_answer = self.incoming_iq_processing_set(iq.id, iq.from, element);
                self.state.data.send_queue.push_back(iq_answer.into());
            }
            xmpp_parsers::iq::IqType::Error(e) => {
                if let Some((_, handler)) = self.state.data.pending_ids.remove_entry(&iq.id) {
                    return handler.error(self, e);
                }
                error!("iq error: {:?}", e);
                return false;
            }
            xmpp_parsers::iq::IqType::Get(element) => {
                let iq_answer = self.incoming_iq_processing_get(iq.id, iq.from, element);
                self.state.data.send_queue.push_back(iq_answer.into());
            }
            xmpp_parsers::iq::IqType::Result(opt_element) => {
                if let Some((_, handler)) = self.state.data.pending_ids.remove_entry(&iq.id) {
                    return handler.result(self, opt_element);
                }
                warn!(
                    "Unwanted iq result id {} from {:?}: {:?}",
                    iq.id,
                    iq.from,
                    opt_element.map(|e| String::from(&e))
                );
            }
        }
        true
    }
    fn incoming_presence_processing(&mut self, presence: xmpp_parsers::presence::Presence) -> bool {
        if presence.from.as_ref() == Some(&self.state.client.jid) {
            info!("Self-presence accepted");
            self.state.data.self_presence = true;
        } else {
            warn!("Incoming presence stanza: {:?}", presence);
        }
        true
    }
    fn incoming_message_processing(&mut self, message: xmpp_parsers::message::Message) -> bool {
        for payload in message.payloads.iter() {
            use std::convert::TryInto;
            if let Some(_delay) =
                payload.clone().try_into().ok() as Option<xmpp_parsers::delay::Delay>
            {
                return true; // ignore delayed messages
            }
        }
        warn!("Incoming message stanza: {:?}", message);
        true
    }
    /// 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 {}", String::from(&send_element));
                    Box::new(
                        client
                            .send(Packet::Stanza(send_element))
                            .select2(stop_future)
                            .then(move |r| match r {
                                Ok(Either::A((client, b))) => {
                                    Box::new(future::ok(future::Loop::Continue((
                                        XmppConnection {
                                            state: XmppState { client, data },
                                            account,
                                        },
                                        b,
                                        stop_condition,
                                    ))))
                                        as Box<dyn Future<Item = _, Error = _>>
                                }
                                Ok(Either::B((t, a))) => Box::new(a.then(|r| match r {
                                    Ok(client) => future::ok(future::Loop::Break((
                                        XmppConnection {
                                            state: XmppState { client, data },
                                            account,
                                        },
                                        Ok(Either::B(t)),
                                    ))),
                                    Err(se) => {
                                        warn!("XMPP sending error: {}", se);
                                        future::err((account, Ok(Either::B(t))))
                                    }
                                })),
                                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: {}", String::from(&s));
                Ok(false)
            }
            _ => {
                error!("Disconnected while online");
                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... {}", String::from(&get_roster));
        data.pending_ids
            .insert(id_init_roster.clone(), Box::new(InitRosterIqHandler {}));
        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, _| Ok(conn.state.data.roster_init), stop_future)
                .map_err(|(account, _)| account)
                .and_then(|(conn, r)| match r {
                    Ok(Either::A(_)) => future::ok(conn),
                    Ok(Either::B(_)) => future::err(conn.account),
                    Err(_e) => future::err(conn.account),
                })
            })
    }
    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... {}", String::from(&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, _| Ok(conn.state.data.self_presence),
                    stop_future,
                )
                .map_err(|(account, _)| account)
                .and_then(|(conn, r)| match r {
                    Ok(Either::A(_)) => future::ok(conn),
                    Ok(Either::B(_)) => future::err(conn.account),
                    Err(_e) => future::err(conn.account),
                })
            })
    }
    fn process_jid(&mut self, xmpp_to: &xmpp_parsers::Jid) {
        if let Some(ref mut mailbox) = self.state.data.outgoing_mailbox.get_mut(xmpp_to) {
            if !mailbox.is_empty() {
                if let Some(ref mut rdata) = self.state.data.roster.get_mut(xmpp_to) {
                    info!("Jid {} in roster", xmpp_to);
                    let sub_to = match rdata.0 {
                        xmpp_parsers::roster::Subscription::To => true,
                        xmpp_parsers::roster::Subscription::Both => true,
                        _ => false,
                    };
                    if sub_to {
                        info!("Subscribed to {}", xmpp_to);
                        self.state.data.send_queue.extend(
                            mailbox.drain(..).map(|message| {
                                stanzas::make_chat_message(xmpp_to.clone(), message)
                            }),
                        );
                    } else if rdata.1 == xmpp_parsers::roster::Ask::None {
                        info!("Not subscribed to {}", xmpp_to);
                        self.state
                            .data
                            .send_queue
                            .push_back(stanzas::make_ask_subscribe(xmpp_to.clone()));
                    }
                    let sub_from = match rdata.0 {
                        xmpp_parsers::roster::Subscription::From => true,
                        xmpp_parsers::roster::Subscription::Both => true,
                        _ => false,
                    };
                    if !sub_from {
                        info!("Not subscription from {}", xmpp_to);
                        self.state
                            .data
                            .send_queue
                            .push_back(stanzas::make_allow_subscribe(xmpp_to.clone()));
                    }
                } else {
                    info!("Jid {} not in roster", xmpp_to);
                    self.state.data.counter += 1;
                    let id_add_roster = format!("id_add_roster{}", self.state.data.counter);
                    let add_roster = stanzas::make_add_roster(&id_add_roster, xmpp_to.clone());
                    info!("Adding jid {} to roster id {}", xmpp_to, id_add_roster);
                    self.state.data.pending_ids.insert(
                        id_add_roster,
                        Box::new(AddRosterIqHandler {
                            jid: xmpp_to.clone(),
                        }),
                    );
                    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);
                self.state
                    .data
                    .pending_ids
                    .insert(id_ping, Box::new(PingIqHandler {}));
            }
        }
    }
    pub fn shutdown(self) -> impl Future<Item = (), Error = failure::Error> {
        info!("Shutdown connection");
        let XmppConnection { account, state } = self;
        stream::iter_ok(
            state
                .data
                .mucs
                .values()
                .map(std::clone::Clone::clone)
                .collect::<Vec<_>>(),
        )
        .fold(state, move |XmppState { client, data }, muc_jid| {
            let muc_presence =
                stanzas::make_muc_presence_leave(account.jid.clone(), muc_jid.clone());
            info!(
                "Sending muc leave presence... {}",
                String::from(&muc_presence)
            );
            use tokio::prelude::Sink;
            client
                .send(Packet::Stanza(muc_presence))
                .map_err(|e| {
                    error!("Error on send muc presence: {}", e);
                    e
                })
                .and_then(|client| future::ok(XmppState { client, data }))
        })
        .map(|_| ())
    }
    fn enter_mucs<F, E>(
        self,
        _stop_future: F,
    ) -> impl Future<Item = Self, Error = std::rc::Rc<config::Account>>
    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... {}", String::from(&muc_presence));
                let account4 = account2.clone();
                use tokio::prelude::Sink;
                client
                    .send(Packet::Stanza(muc_presence))
                    .map_err(|e| {
                        error!("Error on send muc presence: {}", e);
                        account4
                    })
                    .and_then(|client| {
                        data.mucs.insert(muc_jid.0, muc_jid.1);
                        future::ok(XmppState { client, data })
                    })
            })
            .map(|state| XmppConnection {
                account: account3,
                state,
            })
    }
}
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 std::time::{Duration, Instant};
use super::stanzas;
use super::element_processor;
use crate::config;
#[derive(Debug)]
pub enum XmppCommand {
    /// Send message to someone by jid
    Chat {
        xmpp_to: xmpp_parsers::Jid,
        message: String,
    },
    /// Send message to MUC
    Chatroom {
        muc_id: String,
        message: String,
    },
    /// Send ping request to the server to test connection
    Ping,
    /// Check iq requests if some have expired timeouts
    TimeoutCleanup,
}
/// trait of processing iq
/// each function consumes handlers and
/// returns false if connection should be reset
trait IqHandler {
    /// process result
    fn result(
        self: Box<Self>,
        conn: &mut XmppConnection,
        opt_element: Option<xmpp_parsers::Element>,
    ) -> bool;
    /// process error
    fn error(
        self: Box<Self>,
        conn: &mut XmppConnection,
        error: xmpp_parsers::stanza_error::StanzaError,
    ) -> bool;
    /// process tmeout
    fn timeout(self: Box<Self>, conn: &mut XmppConnection) -> bool;
}
struct AddRosterIqHandler {
    jid: xmpp_parsers::Jid,
}
impl IqHandler for AddRosterIqHandler {
    fn result(
        self: Box<Self>,
        conn: &mut XmppConnection,
        opt_element: Option<xmpp_parsers::Element>,
    ) -> bool {
        match opt_element {
            Some(element) => {
                warn!(
                    "Wrong payload when adding {} to roster: {}",
                    self.jid,
                    String::from(&element)
                );
            }
            None => {
                if conn.state.data.roster.contains_key(&self.jid) {
                    info!("Jid {} updated to roster", self.jid);
                } else {
                    info!("Jid {} added in roster", self.jid);
                    conn.state.data.roster.insert(
                        self.jid.clone(),
                        (
                            xmpp_parsers::roster::Subscription::None,
                            xmpp_parsers::roster::Ask::None,
                        ),
                    );
                }
                conn.process_jid(&self.jid);
            }
        }
        true
    }
    fn error(
        self: Box<Self>,
        _conn: &mut XmppConnection,
        _error: xmpp_parsers::stanza_error::StanzaError,
    ) -> bool {
        true
    }
    fn timeout(self: Box<Self>, _conn: &mut XmppConnection) -> bool {
        true // ignore
    }
}
struct PingIqHandler {}
impl IqHandler for PingIqHandler {
    fn result(
        self: Box<Self>,
        _conn: &mut XmppConnection,
        _opt_element: Option<xmpp_parsers::Element>,
    ) -> bool {
        true // ignore
    }
    fn error(
        self: Box<Self>,
        _conn: &mut XmppConnection,
        _error: xmpp_parsers::stanza_error::StanzaError,
    ) -> bool {
        false
    }
    fn timeout(self: Box<Self>, _conn: &mut XmppConnection) -> bool {
        false
    }
}
struct InitRosterIqHandler {}
impl IqHandler for InitRosterIqHandler {
    fn result(
        self: Box<Self>,
        conn: &mut XmppConnection,
        opt_element: Option<xmpp_parsers::Element>,
    ) -> bool {
        if let Some(result) = opt_element {
            use std::convert::TryInto;
            match result.try_into() as Result<xmpp_parsers::roster::Roster, _> {
                Ok(roster) => {
                    conn.state.data.roster_init = true;
                    conn.state.data.roster.clear();
                    info!("Got first roster:");
                    for i in roster.items {
                        info!(" >>> {:?}", i);
                        conn.state
                            .data
                            .roster
                            .insert(i.jid, (i.subscription, i.ask));
                    }
                    true
                }
                Err(e) => {
                    error!("Cann't parse roster: {}", e);
                    false
                }
            }
        } else {
            error!("No roster responded");
            false
        }
    }
    fn error(
        self: Box<Self>,
        _conn: &mut XmppConnection,
        _error: xmpp_parsers::stanza_error::StanzaError,
    ) -> bool {
        false
    }
    fn timeout(self: Box<Self>, _conn: &mut XmppConnection) -> bool {
        false
    }
}
#[derive(Default)]
struct XmppData {
    /// known roster data
    roster: HashMap<
        xmpp_parsers::Jid,
        (
            xmpp_parsers::roster::Subscription,
            xmpp_parsers::roster::Ask,
        ),
    >,
    /// if roster was initialized
    /// ToDo: remove it as it used only for initialization
    roster_init: bool,
    /// ids counter
    counter: usize,
    /// 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>,
    /// map from iq's id to handler of this type of iqs
    pending_ids: HashMap<String, (Instant, Box<dyn IqHandler>)>,
}
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 {}", String::from(&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
            }
        }
    }
    /// Enforce to answer to IQ "set"
    fn incoming_iq_processing_set(
        &mut self,
        id: String,
        from: Option<xmpp_parsers::Jid>,
        element: minidom::Element,
    ) -> xmpp_parsers::iq::Iq {
        use std::convert::TryInto;
        if let Some(roster) =
            element.clone().try_into().ok() as Option<xmpp_parsers::roster::Roster>
        {
            // RFC 6212 2.1.6. Roster Push
            for i in roster.items {
                if let Some(ref mut rdata) = self.state.data.roster.get_mut(&i.jid) {
                    info!("Update {} in roster", i.jid);
                    rdata.0 = i.subscription;
                    rdata.1 = i.ask;
                } else {
                    info!("Add {} to roster", i.jid);
                    self.state
                        .data
                        .roster
                        .insert(i.jid.clone(), (i.subscription, i.ask));
                }
                self.process_jid(&i.jid);
            }
            return stanzas::make_roster_push_answer(id, self.state.client.jid.clone(), from);
        }
        warn!(
            "Unsupported IQ set request from {:?}: {}",
            from,
            String::from(&element)
        );
        stanzas::make_iq_unsupported_error(id, self.state.client.jid.clone(), from)
    }
    /// Enforce to answer to IQ "get"
    fn incoming_iq_processing_get(
        &mut self,
        id: String,
        from: Option<xmpp_parsers::Jid>,
        element: minidom::Element,
    ) -> xmpp_parsers::iq::Iq {
        use std::convert::TryInto;
        if let Some(_ping) = element.clone().try_into().ok() as Option<xmpp_parsers::ping::Ping> {
            return stanzas::make_pong(&id, self.state.client.jid.clone(), from);
        }
        warn!(
            "Unsupported IQ get request from {:?}: {}",
            from,
            String::from(&element)
        );
        stanzas::make_iq_unsupported_error(id, self.state.client.jid.clone(), from)
    }
    fn incoming_iq_processing(&mut self, iq: xmpp_parsers::iq::Iq) -> bool {
        match iq.payload {
            xmpp_parsers::iq::IqType::Set(element) => {
                let iq_answer = self.incoming_iq_processing_set(iq.id, iq.from, element);
                self.state.data.send_queue.push_back(iq_answer.into());
            }
            xmpp_parsers::iq::IqType::Error(e) => {
                if let Some((_, handler)) = self.state.data.pending_ids.remove_entry(&iq.id) {
                    return handler.1.error(self, e);
                }
                error!("iq error: {:?}", e);
                return false;
            }
            xmpp_parsers::iq::IqType::Get(element) => {
                let iq_answer = self.incoming_iq_processing_get(iq.id, iq.from, element);
                self.state.data.send_queue.push_back(iq_answer.into());
            }
            xmpp_parsers::iq::IqType::Result(opt_element) => {
                if let Some((_, handler)) = self.state.data.pending_ids.remove_entry(&iq.id) {
                    return handler.1.result(self, opt_element);
                }
                warn!(
                    "Unwanted iq result id {} from {:?}: {:?}",
                    iq.id,
                    iq.from,
                    opt_element.map(|e| String::from(&e))
                );
            }
        }
        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)| {
                // ToDo: check timeouts if iqs
                let XmppConnection {
                    state: XmppState { client, mut data },
                    account,
                } = xmpp;
                if let Some(send_element) = data.send_queue.pop_front() {
                    use tokio::prelude::Sink;
                    info!("Sending {}", String::from(&send_element));
                    Box::new(
                        client
                            .send(Packet::Stanza(send_element))
                            .select2(stop_future)
                            .then(move |r| match r {
                                Ok(Either::A((client, b))) => {
                                    Box::new(future::ok(future::Loop::Continue((
                                        XmppConnection {
                                            state: XmppState { client, data },
                                            account,
                                        },
                                        b,
                                        stop_condition,
                                    ))))
                                        as Box<dyn Future<Item = _, Error = _>>
                                }
                                Ok(Either::B((t, a))) => Box::new(a.then(|r| match r {
                                    Ok(client) => future::ok(future::Loop::Break((
                                        XmppConnection {
                                            state: XmppState { client, data },
                                            account,
                                        },
                                        Ok(Either::B(t)),
                                    ))),
                                    Err(se) => {
                                        warn!("XMPP sending error: {}", se);
                                        future::err((account, Ok(Either::B(t))))
                                    }
                                })),
                                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: {}", String::from(&s));
                Ok(false)
            }
            _ => {
                error!("Disconnected while online");
                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... {}", String::from(&get_roster));
        data.pending_ids.insert(
            id_init_roster.clone(),
            (
                Instant::now() + Duration::from_secs(60),
                Box::new(InitRosterIqHandler {}),
            ),
        );
        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, _| Ok(conn.state.data.roster_init), stop_future)
                .map_err(|(account, _)| account)
                .and_then(|(conn, r)| match r {
                    Ok(Either::A(_)) => future::ok(conn),
                    Ok(Either::B(_)) => future::err(conn.account),
                    Err(_e) => future::err(conn.account),
                })
            })
    }
    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... {}", String::from(&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());
                    info!("Adding jid {} to roster id {}", xmpp_to, id_add_roster);
                    self.state.data.pending_ids.insert(
                        id_add_roster,
                        (
                            Instant::now() + Duration::from_secs(60),
                            Box::new(AddRosterIqHandler {
                                jid: xmpp_to.clone(),
                            }),
                        ),
                    );
                    self.state.data.send_queue.push_back(add_roster);
                }
            }
        }
    }
    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);
                self.state.data.pending_ids.insert(
                    id_ping,
                    (
                        Instant::now() + Duration::from_secs(30),
                        Box::new(PingIqHandler {}),
                    ),
                );
            }
            XmppCommand::TimeoutCleanup => {
                let now = Instant::now();
                let timeouted: Vec<String> = self
                    .state
                    .data
                    .pending_ids
                    .iter()
                    .filter_map(|(id, (timeout, _))| {
                        if now >= *timeout {
                            Some(id.to_string())
                        } else {
                            None
                        }
                    })
                    .collect();
                let mut correct = true;
                timeouted.into_iter().for_each(|id| {
                    if let Some((_, handler)) = self.state.data.pending_ids.remove(&id) {
                        correct &= handler.timeout(&mut self);
                    }
                })
            }
        }
    }
    pub fn shutdown(self) -> impl Future<Item = (), Error = failure::Error> {
        info!("Shutdown connection");
        let XmppConnection { account, state } = self;
        stream::iter_ok(
            state
                .data
                .mucs
                .values()
                .map(std::clone::Clone::clone)
                .collect::<Vec<_>>(),
        )
        .fold(state, move |XmppState { client, data }, muc_jid| {
            let muc_presence =
                stanzas::make_muc_presence_leave(account.jid.clone(), muc_jid.clone());
            info!(
                "Sending muc leave presence... {}",
                String::from(&muc_presence)
            );
            use tokio::prelude::Sink;
            client
                .send(Packet::Stanza(muc_presence))
                .map_err(|e| {
                    error!("Error on send muc presence: {}", e);
                    e
                })
                .and_then(|client| future::ok(XmppState { client, data }))
        })
        .map(|_| ())
    }
    fn enter_mucs<F, E>(
        self,
        _stop_future: F,
    ) -> impl Future<Item = Self, Error = std::rc::Rc<config::Account>>
    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... {}", String::from(&muc_presence));
                let account4 = account2.clone();
                use tokio::prelude::Sink;
                client
                    .send(Packet::Stanza(muc_presence))
                    .map_err(|e| {
                        error!("Error on send muc presence: {}", e);
                        account4
                    })
                    .and_then(|client| {
                        data.mucs.insert(muc_jid.0, muc_jid.1);
                        future::ok(XmppState { client, data })
                    })
            })
            .map(|state| XmppConnection {
                account: account3,
                state,
            })
    }
}

File deletion: mod.rs

BF:BFD[80.7] → [80.8:16]

BF:BFD[80.16] → [80.17:17]

B:BD[80.62] → [80.62:90]

∅:BD[93.32902] → [80.197:198]

∅:BD[98.39135] → [80.197:198]

∅:BD[2.649] → [80.197:198]

∅:BD[49.230] → [80.197:198]

∅:BD[21.25176] → [80.197:198]

∅:BD[62.39414] → [80.197:198]

∅:BD[46.29842] → [80.197:198]

∅:BD[23.294] → [80.197:198]

∅:BD[29.2404] → [80.197:198]

∅:BD[43.973] → [80.197:198]

∅:BD[59.34252] → [80.197:198]

B:BD[80.197] → [80.197:198]

B:BD[80.210] → [15.420:434]

B:BD[45.34] → [45.34:106]

B:BD[80.211] → [109.0:33]

B:BD[15.478] → [110.0:27]

B:BD[20.31] → [20.31:74]

B:BD[80.349] → [111.78:182]

B:BD[15.527] → [112.86:111]

B:BD[15.527] → [113.149:174]

B:BD[15.527] → [83.510:535]

B:BD[80.515] → [114.401:403]

B:BD[80.516] → [114.404:431]

B:BD[80.554] → [31.183:282]

B:BD[80.690] → [31.283:337]

B:BD[80.745] → [112.210:315]

B:BD[80.961] → [31.501:1016]

B:BD[80.1477] → [31.1017:1167]

B:BD[36.2359] → [31.1168:1359]

B:BD[115.2890] → [115.2890:2997]

B:BD[115.2998] → [31.1360:2085]

B:BD[115.3996] → [31.2086:2179]

B:BD[115.4531] → [31.2180:2379]

B:BD[115.5000] → [31.2380:2511]

B:BD[115.5539] → [31.2512:2678]

B:BD[115.5595] → [31.2679:2690]

B:BD[80.3355] → [20.862:864]

B:BD[80.3356] → [15.650:745]

B:BD[15.784] → [15.784:785]

B:BD[15.2608] → [15.2608:2657]

B:BD[15.2743] → [15.2743:2785]

B:BD[15.2785] → [15.2785:2823]

B:BD[15.2947] → [15.2947:3069]

B:BD[15.3254] → [15.3254:3319]

B:BD[80.3740] → [15.3471:3550]

B:BD[37.10352] → [112.3308:3485]

B:BD[37.10716] → [112.3486:3524]

B:BD[37.10756] → [112.3525:5862]

B:BD[37.12136] → [22.2983:2984]

B:BD[22.3119] → [22.3119:3125]

B:BD[16.60] → [40.3976:4055]

B:BD[59.37511] → [59.37511:37512]

B:BD[59.37745] → [59.37745:37746]

B:BD[59.40647] → [59.40647:40648]

B:BD[62.56501] → [62.56501:56502]

B:BD[62.60584] → [62.60584:60585]

B:BD[62.60585] → [62.60585:67188]

B:BD[80.3876] → [80.3876:3891]

B:BD[80.3917] → [80.3917:3920]

B:BD[16.133] → [31.5773:5851]

∅:BD[2.980] → [80.4136:4137]

B:BD[80.4136] → [80.4136:4137]

∅:BD[21.25210] → [80.4161:4176]

∅:BD[16.239] → [80.4161:4176]

B:BD[80.4161] → [80.4161:4176]

∅:BD[21.25232] → [80.4213:4243]

∅:BD[16.257] → [80.4213:4243]

B:BD[80.4213] → [80.4213:4243]

∅:BD[27.60] → [80.4305:4311]

∅:BD[26.464] → [80.4305:4311]

∅:BD[21.25265] → [80.4305:4311]

∅:BD[25.380] → [80.4305:4311]

∅:BD[58.39218] → [80.4305:4311]

∅:BD[59.40933] → [80.4305:4311]

B:BD[80.4305] → [80.4305:4311]

B:BD[32.4342] → [32.4342:4398]

B:BD[80.4355] → [25.381:433]

B:BD[37.12380] → [116.4598:4663]

B:BD[80.4355] → [16.258:310]

B:BD[80.4355] → [78.0:53]

B:BD[32.4342] → [115.8565:8651]

B:BD[80.4355] → [26.465:518]

∅:BD[117.53] → [80.4355:4357]

∅:BD[26.518] → [80.4355:4357]

∅:BD[78.53] → [80.4355:4357]

∅:BD[21.25383] → [80.4355:4357]

∅:BD[16.310] → [80.4355:4357]

∅:BD[116.4663] → [80.4355:4357]

∅:BD[25.433] → [80.4355:4357]

∅:BD[58.39399] → [80.4355:4357]

∅:BD[59.41030] → [80.4355:4357]

B:BD[80.4355] → [80.4355:4357]

∅:BD[21.25417] → [59.41154:41155]

∅:BD[58.39431] → [59.41154:41155]

B:BD[59.41154] → [59.41154:41155]

B:BD[80.4617] → [80.4617:4692]

B:BD[89.5994] → [82.9040:9637]

B:BD[89.6591] → [82.9638:10187]

B:BD[89.7177] → [82.10188:10264]

B:BD[89.7290] → [82.10265:10343]

B:BD[118.9168] → [82.10344:10444]

B:BD[89.7522] → [82.10445:10505]

B:BD[55.26438] → [29.24698:24721]

B:BD[54.6451] → [79.1728:1944]

B:BD[55.26491] → [29.24722:24938]

B:BD[30.10549] → [17.39523:39739]

B:BD[54.6451] → [22.3645:3861]

B:BD[81.10245] → [81.10245:10252]

B:BD[54.6451] → [54.6451:6957]

B:BD[54.6451] → [39.2329:2538]

B:BD[38.7372] → [38.7372:7379]

B:BD[30.10542] → [30.10542:10549]

B:BD[38.7379] → [30.10333:10542]

B:BD[39.2545] → [38.7163:7372]

B:BD[39.2538] → [39.2538:2545]

B:BD[89.8144] → [89.8144:8862]

B:BD[89.8886] → [89.8886:8916]

B:BD[89.8862] → [82.10506:10530]

B:BD[89.8862] → [42.9150:9173]

B:BD[89.8862] → [89.8862:8886]

B:BD[89.8862] → [119.8497:8520]

B:BD[55.26438] → [49.11253:11277]

B:BD[89.8144] → [54.6171:6444]

B:BD[54.6444] → [54.6444:6451]

B:BD[55.26438] → [55.26438:26461]

B:BD[55.26461] → [55.26461:26491]

B:BD[89.8144] → [55.26348:26438]

B:BD[89.7522] → [42.9098:9149]

B:BD[89.7522] → [89.7522:7582]

B:BD[89.7582] → [89.7582:8118]

B:BD[89.7522] → [119.8445:8496]

B:BD[118.9168] → [42.9007:9097]

B:BD[118.9168] → [89.7399:7499]

B:BD[89.7499] → [89.7499:7522]

B:BD[118.9168] → [120.5176:5939]

B:BD[118.9168] → [119.8354:8444]

B:BD[118.9168] → [118.9168:9312]

B:BD[118.9142] → [118.9142:9168]

B:BD[89.7290] → [42.8938:9006]

B:BD[89.7290] → [89.7290:7368]

B:BD[89.7368] → [89.7368:7398]

B:BD[89.7290] → [119.8285:8353]

B:BD[89.7177] → [89.7177:7253]

B:BD[89.7253] → [89.7253:7290]

B:BD[89.6591] → [42.8647:8937]

B:BD[89.6591] → [89.6591:6670]

B:BD[89.7141] → [89.7141:7177]

B:BD[89.6670] → [89.6670:7141]

B:BD[89.6591] → [88.4234:4312]

B:BD[89.6591] → [119.7994:8284]

B:BD[55.23809] → [85.34857:34908]

B:BD[29.23805] → [29.23805:23949]

B:BD[55.24532] → [85.34909:34969]

B:BD[29.24241] → [85.34970:35025]

B:BD[55.24858] → [49.10866:10942]

B:BD[55.24895] → [79.1379:1455]

B:BD[55.24993] → [55.24993:25019]

B:BD[39.2257] → [29.24374:24574]

B:BD[55.25132] → [29.24575:24626]

B:BD[55.26249] → [79.1657:1727]

B:BD[55.26249] → [70.246:314]

B:BD[55.26249] → [29.24627:24697]

B:BD[55.26249] → [46.57669:57737]

B:BD[55.26249] → [47.7433:7501]

B:BD[55.26249] → [22.3574:3644]

B:BD[55.26249] → [48.8733:8801]

B:BD[55.26249] → [30.10262:10332]

B:BD[55.26249] → [49.11184:11252]

B:BD[55.26249] → [52.2714:2782]

B:BD[55.26249] → [38.7092:7162]

B:BD[55.26249] → [17.39452:39522]

B:BD[55.26249] → [55.26249:26317]

B:BD[55.26317] → [55.26317:26347]

B:BD[55.26249] → [39.2258:2328]

B:BD[55.25132] → [49.11123:11183]

B:BD[55.25183] → [55.25183:26249]

B:BD[55.25132] → [55.25132:25183]

B:BD[39.2257] → [46.57578:57668]

B:BD[39.2257] → [47.7342:7432]

B:BD[39.2257] → [30.10061:10261]

B:BD[39.2257] → [49.11022:11122]

B:BD[39.2257] → [52.2623:2713]

B:BD[39.2257] → [38.6891:7091]

B:BD[39.2257] → [17.39251:39451]

B:BD[55.25109] → [55.25109:25132]

B:BD[39.2231] → [39.2231:2257]

B:BD[55.25019] → [79.1456:1656]

B:BD[55.25019] → [70.155:245]

B:BD[55.25019] → [22.3373:3573]

B:BD[55.25019] → [48.8642:8732]

B:BD[55.25019] → [55.25019:25109]

B:BD[55.25019] → [39.2057:2231]

B:BD[55.24895] → [70.86:154]

B:BD[55.24895] → [29.24297:24373]

B:BD[55.24895] → [46.57509:57577]

B:BD[55.24895] → [47.7273:7341]

B:BD[55.24895] → [22.3296:3372]

B:BD[55.24895] → [48.8573:8641]

B:BD[55.24895] → [30.9984:10060]

B:BD[55.24895] → [49.10943:11021]

B:BD[55.24895] → [52.2554:2622]

B:BD[55.24895] → [38.6814:6890]

B:BD[55.24895] → [17.39174:39250]

B:BD[55.24895] → [55.24895:24963]

B:BD[55.24963] → [55.24963:24993]

B:BD[55.24895] → [39.1980:2056]

B:BD[29.24241] → [29.24241:24296]

B:BD[29.24241] → [65.29655:29724]

B:BD[55.24532] → [29.24006:24066]

B:BD[55.24822] → [55.24822:24858]

B:BD[55.24858] → [55.24858:24895]

B:BD[29.24066] → [29.24066:24241]

B:BD[55.24532] → [49.10315:10865]

B:BD[55.24532] → [55.24532:24822]

B:BD[55.24419] → [55.24419:24532]

B:BD[29.23949] → [29.23949:24005]

B:BD[29.23805] → [46.57423:57508]

B:BD[29.23805] → [17.39029:39173]

B:BD[121.7143] → [121.7143:7225]

B:BD[121.7302] → [121.7302:7335]

B:BD[89.6478] → [89.6478:6591]

B:BD[121.7335] → [121.7335:7416]

B:BD[31.7170] → [31.7170:7219]

B:BD[80.6342] → [40.4056:4095]

B:BD[80.6627] → [25.955:1649]

B:BD[80.6627] → [28.483:559]

B:BD[78.255] → [78.255:493]

B:BD[78.510] → [78.510:664]

B:BD[78.664] → [78.664:681]

B:BD[78.510] → [27.571:639]

B:BD[78.493] → [78.493:510]

B:BD[78.255] → [27.332:570]

B:BD[80.6627] → [78.54:125]

B:BD[78.125] → [78.125:255]

B:BD[80.6627] → [26.893:900]

B:BD[26.969] → [26.969:1354]

B:BD[26.1422] → [26.1422:1439]

B:BD[26.1354] → [31.7427:7495]

B:BD[26.1354] → [33.7324:7392]

B:BD[26.1354] → [115.9473:9510]

B:BD[26.1354] → [26.1354:1422]

B:BD[26.1354] → [34.7174:7242]

B:BD[26.1354] → [35.9935:9972]

B:BD[26.1354] → [36.6876:6913]

B:BD[26.1354] → [37.13305:13342]

B:BD[26.900] → [31.7357:7426]

B:BD[26.900] → [111.5157:5226]

B:BD[26.900] → [45.4420:4494]

B:BD[26.900] → [109.649:723]

B:BD[26.900] → [33.7254:7323]

B:BD[26.900] → [26.900:969]

B:BD[26.900] → [81.9739:10245]

B:BD[26.900] → [35.9860:9934]

B:BD[26.900] → [37.13230:13304]

B:BD[80.6627] → [80.6627:6644]

B:BD[80.6782] → [80.6782:6873]

B:BD[80.6907] → [80.6907:7379]

B:BD[80.6873] → [80.6873:6907]

B:BD[80.6644] → [16.311:425]

B:BD[80.6644] → [80.6644:6782]

B:BD[80.6342] → [31.7220:7356]

B:BD[80.6342] → [112.6241:6303]

B:BD[80.6342] → [25.724:954]

B:BD[80.6342] → [116.4664:4726]

B:BD[80.6342] → [33.7117:7253]

B:BD[80.6342] → [115.9410:9472]

B:BD[80.6342] → [84.3887:3926]

B:BD[80.6342] → [26.756:892]

B:BD[80.6342] → [83.10615:10654]

B:BD[80.6342] → [34.7037:7173]

B:BD[80.6342] → [27.195:331]

B:BD[80.6342] → [81.9699:9738]

B:BD[80.6342] → [35.9797:9859]

B:BD[80.6342] → [36.6813:6875]

B:BD[80.6342] → [37.13190:13229]

B:BD[80.6572] → [80.6572:6627]

B:BD[80.6342] → [80.6342:6572]

B:BD[37.13156] → [121.7417:8180]

B:BD[37.13156] → [114.6784:8876]

B:BD[37.13156] → [118.8540:9142]

B:BD[31.7170] → [37.13157:13189]

B:BD[80.6240] → [80.6240:6342]

B:BD[121.7335] → [89.6301:6478]

B:BD[121.7335] → [120.5094:5175]

B:BD[121.7335] → [118.6697:8539]

B:BD[121.7225] → [121.7225:7302]

B:BD[121.7225] → [89.6217:6300]

B:BD[121.7225] → [120.5016:5093]

B:BD[121.7225] → [118.6613:6696]

B:BD[89.5994] → [42.8036:8646]

B:BD[55.23809] → [29.23336:23387]

B:BD[29.23387] → [29.23387:23805]

B:BD[58.40205] → [58.40205:40349]

∅:BD[21.25523] → [58.40577:40578]

B:BD[58.40577] → [58.40577:40578]

B:BD[58.40881] → [58.40881:40957]

B:BD[58.41013] → [58.41013:41213]

B:BD[58.42353] → [58.42353:42423]

B:BD[58.42622] → [58.42622:42838]

B:BD[58.42838] → [58.42838:42845]

B:BD[58.42622] → [60.43395:43601]

∅:BD[21.26651] → [60.43601:43611]

B:BD[60.43601] → [60.43601:43611]

B:BD[60.43611] → [21.26652:26658]

B:BD[58.42423] → [58.42423:42622]

B:BD[58.42353] → [62.67435:67503]

B:BD[58.42353] → [60.43324:43394]

B:BD[58.41213] → [58.41213:42353]

B:BD[58.41013] → [62.67344:67434]

B:BD[58.41013] → [60.43123:43323]

B:BD[58.40957] → [58.40957:41013]

B:BD[58.40881] → [62.67275:67343]

B:BD[58.40881] → [60.43046:43122]

B:BD[58.40578] → [58.40578:40881]

B:BD[58.40578] → [21.25524:25834]

∅:BD[2.1046] → [21.25899:26288]

∅:BD[23.357] → [21.25899:26288]

B:BD[21.25899] → [21.25899:26288]

∅:BD[2.1112] → [21.26353:26651]

∅:BD[23.421] → [21.26353:26651]

B:BD[21.26353] → [21.26353:26651]

B:BD[21.26288] → [23.358:421]

B:BD[21.26288] → [21.26288:26353]

B:BD[21.26288] → [2.1047:1112]

B:BD[21.25834] → [23.295:357]

B:BD[21.25834] → [21.25834:25899]

B:BD[21.25834] → [2.981:1046]

B:BD[58.40349] → [58.40349:40577]

B:BD[58.40205] → [62.67189:67274]

B:BD[89.8118] → [89.8118:8144]

B:BD[89.5994] → [89.5994:6216]

B:BD[55.23809] → [65.29607:29654]

B:BD[55.23809] → [49.9717:10314]

B:BD[58.40205] → [60.42901:43045]

B:BD[89.5994] → [119.7383:7993]

B:BD[55.23809] → [55.23809:24278]

B:BD[55.24363] → [55.24363:24419]

B:BD[55.24278] → [79.1234:1378]

B:BD[55.24278] → [70.0:85]

B:BD[55.24278] → [47.7187:7272]

B:BD[55.24278] → [22.3151:3295]

B:BD[55.24278] → [48.8487:8572]

B:BD[55.24278] → [30.9839:9983]

B:BD[55.24278] → [52.2468:2553]

B:BD[55.24278] → [38.6669:6813]

B:BD[55.24278] → [55.24278:24363]

B:BD[55.24278] → [39.1835:1979]

B:BD[37.13130] → [37.13130:13156]

∅:BD[39.2545] → [80.7379:7381]

∅:BD[81.10252] → [80.7379:7381]

∅:BD[17.39739] → [80.7379:7381]

∅:BD[38.7379] → [80.7379:7381]

∅:BD[26.1439] → [80.7379:7381]

∅:BD[30.10549] → [80.7379:7381]

∅:BD[78.681] → [80.7379:7381]

∅:BD[21.26658] → [80.7379:7381]

∅:BD[22.3861] → [80.7379:7381]

∅:BD[25.1649] → [80.7379:7381]

∅:BD[58.42845] → [80.7379:7381]

∅:BD[79.1944] → [80.7379:7381]

∅:BD[59.43921] → [80.7379:7381]

B:BD[80.7379] → [80.7379:7381]

B:BD[80.4761] → [80.4761:4955]

B:BD[26.675] → [31.6089:6145]

B:BD[80.5146] → [31.6146:6841]

B:BD[34.6261] → [31.6842:7148]

B:BD[31.7148] → [31.7148:7170]

B:BD[33.7045] → [33.7045:7067]

B:BD[33.7067] → [33.7067:7116]

B:BD[33.7067] → [34.6987:7036]

B:BD[33.7067] → [35.9764:9796]

B:BD[34.6261] → [34.6261:6986]

B:BD[34.6261] → [36.6780:6812]

B:BD[80.5146] → [33.6043:6333]

B:BD[80.6191] → [33.6334:7045]

B:BD[80.6191] → [115.9377:9409]

B:BD[80.6191] → [80.6191:6240]

B:BD[80.5146] → [115.8803:9376]

B:BD[80.5146] → [34.5942:6239]

B:BD[34.6239] → [34.6239:6261]

B:BD[80.5146] → [35.9190:9763]

B:BD[80.5146] → [36.6206:6779]

B:BD[80.5146] → [37.12583:12779]

B:BD[37.12857] → [37.12857:13049]

B:BD[37.13049] → [81.9617:9698]

B:BD[37.13049] → [37.13049:13130]

B:BD[37.13049] → [117.54:118]

B:BD[37.12779] → [112.6155:6240]

B:BD[37.12779] → [83.10536:10614]

B:BD[37.12779] → [37.12779:12857]

B:BD[80.5146] → [80.5146:5285]

B:BD[80.5372] → [80.5372:5743]

B:BD[80.5776] → [80.5776:6018]

B:BD[80.6105] → [80.6105:6169]

B:BD[80.6169] → [80.6169:6191]

B:BD[80.6018] → [111.5069:5156]

B:BD[80.6018] → [45.4325:4419]

B:BD[80.6018] → [32.4521:4608]

B:BD[80.6018] → [20.3417:3511]

B:BD[80.6018] → [80.6018:6105]

B:BD[80.5743] → [111.5035:5068]

B:BD[80.5743] → [45.4284:4324]

B:BD[80.5743] → [32.4487:4520]

B:BD[80.5743] → [20.3376:3416]

B:BD[80.5743] → [80.5743:5776]

B:BD[80.5285] → [111.4947:5034]

B:BD[80.5285] → [45.4189:4283]

B:BD[80.5285] → [32.4399:4486]

B:BD[80.5285] → [20.3281:3375]

B:BD[80.5285] → [80.5285:5372]

B:BD[27.194] → [28.379:482]

B:BD[26.675] → [33.5986:6042]

B:BD[26.675] → [115.8721:8802]

B:BD[26.675] → [26.675:731]

B:BD[26.731] → [26.731:755]

B:BD[26.675] → [34.5885:5941]

B:BD[26.675] → [35.9108:9189]

B:BD[26.675] → [36.6124:6205]

B:BD[26.675] → [37.12501:12582]

B:BD[80.5120] → [80.5120:5146]

B:BD[80.5051] → [80.5051:5120]

B:BD[80.4955] → [25.558:723]

B:BD[80.4955] → [26.595:675]

B:BD[80.4955] → [27.137:194]

B:BD[80.4955] → [80.4955:5051]

B:BD[80.4692] → [59.41292:43921]

B:BD[80.4692] → [31.6019:6088]

B:BD[80.4692] → [121.6396:7143]

B:BD[80.4692] → [58.39537:40205]

B:BD[80.4692] → [33.5916:5985]

B:BD[80.4692] → [89.5795:5994]

B:BD[80.4692] → [120.4268:5015]

B:BD[80.4692] → [115.8652:8720]

B:BD[80.4692] → [34.5815:5884]

B:BD[80.4692] → [114.6004:6783]

B:BD[80.4692] → [54.5150:6170]

B:BD[80.4692] → [35.9039:9107]

B:BD[80.4692] → [118.6191:6612]

B:BD[80.4692] → [36.6055:6123]

B:BD[80.4692] → [55.23610:23809]

B:BD[80.4692] → [37.12432:12500]

B:BD[80.4692] → [80.4692:4761]

B:BD[59.41155] → [59.41155:41200]

B:BD[80.4527] → [59.41201:41291]

B:BD[80.4527] → [121.6305:6395]

B:BD[80.4527] → [112.6050:6154]

B:BD[80.4527] → [89.5690:5794]

B:BD[80.4527] → [120.4177:4267]

B:BD[80.4527] → [83.10445:10535]

B:BD[80.4527] → [114.5899:6003]

B:BD[80.4527] → [54.5059:5149]

B:BD[80.4527] → [118.6086:6190]

B:BD[80.4527] → [55.23505:23609]

B:BD[80.4527] → [80.4527:4617]

B:BD[59.41155] → [58.39432:39536]

B:BD[59.41155] → [21.25418:25523]

B:BD[80.4526] → [80.4526:4527]

B:BD[80.4480] → [80.4480:4481]

B:BD[80.4481] → [111.4901:4946]

B:BD[80.4481] → [45.4138:4188]

B:BD[80.4481] → [109.598:648]

B:BD[80.4481] → [80.4481:4526]

B:BD[80.4357] → [59.41031:41154]

B:BD[80.4357] → [31.5897:6018]

B:BD[80.4357] → [121.6254:6304]

B:BD[80.4357] → [58.39400:39431]

B:BD[80.4357] → [25.434:557]

B:BD[80.4357] → [33.5794:5915]

B:BD[80.4357] → [89.5658:5689]

B:BD[80.4357] → [21.25384:25417]

B:BD[80.4357] → [120.4126:4176]

B:BD[80.4357] → [26.519:594]

B:BD[80.4357] → [34.5738:5814]

B:BD[80.4357] → [27.61:136]

B:BD[80.4357] → [114.5867:5898]

B:BD[80.4357] → [54.5008:5058]

B:BD[80.4357] → [35.8988:9038]

B:BD[80.4357] → [118.6054:6085]

B:BD[80.4357] → [55.23473:23504]

B:BD[80.4357] → [37.12381:12431]

B:BD[80.4357] → [80.4357:4480]

B:BD[37.12380] → [117.0:53]

B:BD[80.4311] → [59.40934:41030]

B:BD[80.4311] → [31.5852:5896]

B:BD[80.4311] → [32.4301:4342]

B:BD[80.4311] → [58.39219:39399]

B:BD[80.4311] → [33.5749:5793]

B:BD[80.4311] → [21.25266:25383]

B:BD[80.4311] → [34.5693:5737]

B:BD[80.4311] → [35.8860:8987]

B:BD[80.4311] → [36.5927:6054]

B:BD[80.4311] → [37.12253:12380]

B:BD[80.4311] → [80.4311:4355]

B:BD[80.4243] → [59.40871:40933]

B:BD[80.4243] → [58.39158:39218]

B:BD[80.4243] → [25.318:380]

B:BD[80.4243] → [21.25233:25265]

B:BD[80.4243] → [26.404:464]

B:BD[80.4243] → [27.0:60]

B:BD[80.4243] → [80.4243:4305]

B:BD[80.4176] → [16.240:257]

B:BD[80.4176] → [21.25211:25232]

B:BD[80.4176] → [80.4176:4213]

B:BD[80.4137] → [16.212:239]

B:BD[80.4137] → [21.25177:25210]

B:BD[80.4137] → [80.4137:4161]

B:BD[16.133] → [111.4822:4900]

B:BD[16.133] → [45.4054:4137]

B:BD[16.133] → [16.133:211]

B:BD[16.133] → [109.514:597]

B:BD[16.133] → [33.5670:5748]

B:BD[16.133] → [35.8776:8859]

B:BD[16.133] → [37.12169:12252]

B:BD[80.4058] → [80.4058:4136]

B:BD[80.4038] → [80.4038:4058]

B:BD[80.3920] → [59.40743:40870]

B:BD[80.3920] → [121.6121:6253]

B:BD[80.3920] → [112.5896:6049]

B:BD[80.3920] → [58.39004:39157]

B:BD[80.3920] → [16.104:133]

B:BD[80.3920] → [89.5504:5657]

B:BD[80.3920] → [120.3993:4125]

B:BD[80.3920] → [83.10312:10444]

B:BD[80.3920] → [114.5713:5866]

B:BD[80.3920] → [54.4875:5007]

B:BD[80.3920] → [118.5900:6053]

B:BD[80.3920] → [55.23319:23472]

B:BD[80.3920] → [80.3920:4038]

B:BD[80.3891] → [59.40716:40742]

B:BD[80.3891] → [31.5746:5772]

B:BD[80.3891] → [111.4795:4821]

B:BD[80.3891] → [45.4022:4053]

B:BD[80.3891] → [58.38972:39003]

B:BD[80.3891] → [109.482:513]

B:BD[80.3891] → [33.5643:5669]

B:BD[80.3891] → [35.8744:8775]

B:BD[80.3891] → [37.12137:12168]

B:BD[80.3891] → [80.3891:3917]

B:BD[62.56502] → [62.56502:60584]

B:BD[62.56502] → [60.42862:42900]

B:BD[62.56502] → [98.66827:67690]

B:BD[16.86] → [16.86:103]

B:BD[59.40648] → [59.40648:40715]

B:BD[59.40648] → [58.38939:38971]

B:BD[59.40648] → [62.55915:56501]

B:BD[59.40648] → [60.42798:42861]

B:BD[59.40648] → [98.66757:66826]

B:BD[59.37746] → [59.37746:40647]

B:BD[59.37746] → [58.38900:38938]

B:BD[59.37746] → [62.47643:55914]

B:BD[59.37512] → [59.37512:37745]

B:BD[59.37512] → [58.38836:38899]

B:BD[59.37512] → [62.40249:47642]

B:BD[80.3817] → [59.36005:37511]

B:BD[80.3817] → [121.6095:6120]

B:BD[80.3817] → [112.5863:5895]

B:BD[80.3817] → [16.61:86]

B:BD[80.3817] → [89.5471:5503]

B:BD[80.3817] → [120.3967:3992]

B:BD[80.3817] → [83.10286:10311]

B:BD[80.3817] → [114.5680:5712]

B:BD[80.3817] → [54.4849:4874]

B:BD[80.3817] → [118.5867:5899]

B:BD[80.3817] → [55.23286:23318]

B:BD[80.3817] → [80.3817:3876]

B:BD[16.60] → [41.0:52]

B:BD[16.60] → [31.5721:5745]

B:BD[16.60] → [42.7947:8035]

B:BD[16.60] → [43.13785:13871]

B:BD[80.3816] → [80.3816:3817]

B:BD[43.13871] → [43.13871:13873]

B:BD[29.23323] → [29.23323:23333]

B:BD[29.23333] → [29.23333:23335]

B:BD[16.60] → [29.23150:23323]

B:BD[16.60] → [44.0:24]

B:BD[16.60] → [45.3997:4021]

B:BD[16.60] → [25.265:317]

B:BD[16.60] → [22.3126:3150]

B:BD[80.3792] → [16.43:60]

B:BD[48.8484] → [48.8484:8486]

B:BD[71.4005] → [6.1923:1994]

B:BD[6.1994] → [39.1824:1834]

B:BD[71.4005] → [38.6587:6658]

B:BD[38.6658] → [30.9828:9838]

B:BD[38.6658] → [38.6658:6668]

B:BD[16.60] → [48.8398:8484]

B:BD[16.60] → [72.5301:5403]

B:BD[16.60] → [49.9692:9716]

B:BD[16.60] → [50.0:52]

B:BD[16.60] → [51.0:77]

B:BD[16.60] → [26.379:403]

B:BD[29.23323] → [17.39018:39028]

B:BD[16.60] → [53.3545:3569]

B:BD[16.60] → [54.4824:4848]

B:BD[16.60] → [35.8719:8743]

B:BD[16.60] → [55.23197:23285]

B:BD[16.60] → [71.3903:4005]

B:BD[80.3792] → [80.3792:3816]

B:BD[22.2984] → [22.2984:3119]

B:BD[80.3789] → [80.3789:3792]

B:BD[22.2984] → [48.6995:8397]

B:BD[37.12136] → [89.4552:4553]

B:BD[89.4692] → [89.4692:4722]

B:BD[89.4786] → [89.4786:4838]

B:BD[82.7275] → [82.7275:8037]

B:BD[82.8037] → [82.8037:8070]

B:BD[89.4940] → [82.8071:8206]

B:BD[88.3248] → [82.8207:8312]

B:BD[88.3445] → [82.8313:8357]

B:BD[88.3552] → [82.8358:8396]

B:BD[88.3591] → [82.8397:9039]

B:BD[89.5464] → [90.685:710]

B:BD[88.3591] → [42.7884:7946]

B:BD[88.3591] → [88.3591:4233]

B:BD[88.3591] → [119.7320:7382]

B:BD[88.3552] → [88.3552:3590]

B:BD[89.5454] → [89.5454:5464]

B:BD[89.5464] → [89.5464:5470]

B:BD[88.3590] → [88.3590:3591]

B:BD[88.3445] → [42.7730:7883]

B:BD[88.3445] → [88.3445:3489]

B:BD[88.3489] → [88.3489:3552]

B:BD[88.3445] → [119.7166:7319]

B:BD[88.3248] → [42.7602:7729]

B:BD[88.3248] → [88.3248:3353]

B:BD[88.3353] → [88.3353:3445]

B:BD[88.3248] → [119.7038:7165]

B:BD[89.4940] → [89.4940:5454]

B:BD[89.4940] → [88.3112:3247]

B:BD[88.3247] → [88.3247:3248]

B:BD[89.4867] → [89.4867:4940]

B:BD[89.4838] → [82.7130:7275]

B:BD[89.4838] → [89.4838:4867]

B:BD[89.4838] → [88.3032:3111]

B:BD[89.4722] → [82.7045:7129]

B:BD[89.4722] → [90.608:684]

B:BD[89.4722] → [89.4722:4786]

B:BD[89.4722] → [88.2967:3031]

B:BD[89.4591] → [89.4591:4618]

B:BD[89.4618] → [89.4618:4692]

B:BD[89.4591] → [88.2940:2966]

B:BD[89.4553] → [82.6906:7044]

B:BD[89.4553] → [42.7547:7601]

B:BD[89.4553] → [89.4553:4591]

B:BD[89.4553] → [119.6983:7037]

B:BD[37.10756] → [116.2260:2485]

B:BD[116.2504] → [116.2504:4597]

B:BD[116.2504] → [81.9601:9616]

B:BD[116.2485] → [116.2485:2504]

B:BD[37.12130] → [37.12130:12136]

B:BD[37.10756] → [83.8797:8851]

B:BD[83.8885] → [83.8885:9157]

B:BD[83.9206] → [83.9206:10285]

B:BD[83.9157] → [122.3191:3248]

B:BD[83.9157] → [113.1118:1153]

B:BD[83.9157] → [83.9157:9206]

B:BD[83.8851] → [122.3175:3190]

B:BD[83.8851] → [83.8851:8885]

B:BD[37.10756] → [81.8129:8183]

B:BD[123.6667] → [43.11466:11510]

B:BD[81.8315] → [121.5595:5620]

B:BD[81.8426] → [124.722:777]

B:BD[81.8658] → [29.16957:17484]

B:BD[81.9105] → [121.5679:5794]

B:BD[81.9320] → [121.5795:6094]

B:BD[114.5440] → [114.5440:5679]

B:BD[114.5440] → [118.5598:5631]

B:BD[118.5704] → [118.5704:5808]

B:BD[123.7369] → [123.7369:7504]

B:BD[118.5833] → [118.5833:5866]

B:BD[118.5808] → [124.778:854]

B:BD[118.5808] → [118.5808:5833]

B:BD[118.5808] → [123.7298:7369]

B:BD[118.5676] → [118.5676:5704]

B:BD[118.5676] → [123.7270:7297]

B:BD[118.5631] → [118.5631:5676]

B:BD[81.9320] → [81.9320:9600]

B:BD[81.9320] → [55.21325:21624]

B:BD[54.4585] → [54.4585:4823]

B:BD[81.9320] → [114.5425:5440]

B:BD[118.5325] → [118.5325:5597]

B:BD[81.9320] → [118.5310:5325]

B:BD[54.4585] → [55.21625:21632]

B:BD[55.21686] → [55.21686:21716]

B:BD[43.12185] → [43.12185:12238]

B:BD[43.12344] → [43.12344:12358]

B:BD[6.755] → [39.511:831]

B:BD[55.23196] → [43.12359:12365]

B:BD[43.12365] → [79.241:801]

B:BD[43.12366] → [79.802:1233]

B:BD[43.12655] → [43.12655:12737]

B:BD[43.13299] → [43.13299:13300]

B:BD[43.13345] → [43.13345:13346]

B:BD[52.2263] → [52.2263:2368]

B:BD[52.2368] → [52.2368:2467]

B:BD[52.2368] → [38.5021:5042]

B:BD[38.5048] → [38.5048:5049]

B:BD[38.5049] → [30.8836:9827]

B:BD[38.5049] → [38.5049:6586]

B:BD[52.2234] → [52.2234:2263]

B:BD[52.2234] → [38.4998:5020]

B:BD[43.13346] → [43.13346:13784]

B:BD[43.13346] → [6.1320:1922]

B:BD[43.13346] → [52.2029:2234]

B:BD[43.13300] → [43.13300:13345]

B:BD[43.13300] → [6.1270:1319]

B:BD[43.13300] → [52.1983:2028]

B:BD[43.13300] → [38.4926:4997]

B:BD[43.13234] → [43.13234:13299]

B:BD[43.13233] → [43.13233:13234]

B:BD[43.13234] → [6.1200:1269]

B:BD[43.13234] → [52.1917:1982]

B:BD[52.1445] → [52.1445:1492]

B:BD[52.1613] → [52.1613:1792]

B:BD[52.1823] → [52.1823:1916]

B:BD[52.1823] → [38.4837:4925]

B:BD[52.1792] → [52.1792:1823]

B:BD[52.1613] → [38.4770:4836]

B:BD[52.1492] → [52.1492:1613]

B:BD[52.1445] → [38.4707:4769]

B:BD[43.12737] → [43.12737:13233]

B:BD[43.12737] → [6.756:1199]

B:BD[43.12737] → [52.1420:1445]

B:BD[43.12601] → [43.12601:12655]

B:BD[43.12366] → [43.12366:12601]

B:BD[43.12366] → [38.4594:4706]

B:BD[43.12365] → [43.12365:12366]

B:BD[55.23196] → [29.20614:23149]

B:BD[55.23196] → [49.9666:9691]

B:BD[38.5042] → [38.5042:5048]

B:BD[55.23196] → [39.832:1823]

B:BD[43.12358] → [6.330:755]

B:BD[43.12358] → [38.4273:4593]

B:BD[71.3902] → [38.3847:4272]

B:BD[38.4272] → [30.8515:8835]

B:BD[43.12238] → [43.12238:12344]

B:BD[43.12238] → [71.3706:3902]

B:BD[53.2920] → [53.2920:2972]

B:BD[53.2972] → [43.11596:12185]

B:BD[53.2972] → [53.2972:3045]

B:BD[55.22688] → [72.4710:5197]

B:BD[55.23124] → [72.5198:5300]

B:BD[55.23124] → [53.3482:3544]

B:BD[55.23124] → [55.23124:23186]

B:BD[55.22688] → [53.3046:3481]

B:BD[55.23123] → [55.23123:23124]

B:BD[55.22688] → [55.22688:23123]

B:BD[55.23186] → [55.23186:23196]

B:BD[55.22687] → [55.22687:22688]

B:BD[55.21800] → [55.21800:21852]

B:BD[55.22614] → [55.22614:22687]

B:BD[55.21852] → [48.6232:6994]

B:BD[55.21852] → [55.21852:22614]

B:BD[55.21716] → [43.11511:11595]

B:BD[55.21716] → [29.19529:20613]

B:BD[55.21716] → [22.2918:2982]

B:BD[55.21716] → [48.6147:6231]

B:BD[55.21716] → [72.3468:4709]

B:BD[55.21716] → [49.9464:9665]

B:BD[55.21716] → [53.2856:2920]

B:BD[55.21716] → [55.21716:21800]

B:BD[55.21716] → [71.3629:3705]

B:BD[71.2916] → [94.182:204]

B:BD[71.2938] → [71.2938:3628]

B:BD[71.2916] → [71.2916:2938]

B:BD[94.204] → [94.204:762]

B:BD[55.21632] → [29.17485:19528]

B:BD[55.21632] → [49.9324:9463]

B:BD[55.21632] → [55.21632:21686]

B:BD[55.21632] → [71.1639:2916]

B:BD[81.9320] → [123.6970:7269]

B:BD[81.9105] → [114.5336:5424]

B:BD[81.9320] → [54.4570:4585]

B:BD[81.9105] → [81.9105:9220]

B:BD[81.9220] → [81.9220:9320]

B:BD[81.9105] → [54.4481:4569]

B:BD[81.9105] → [118.5221:5309]

B:BD[81.9105] → [55.21209:21324]

B:BD[81.9105] → [123.6854:6969]

B:BD[81.8658] → [30.7987:8514]

B:BD[81.8658] → [49.8939:9323]

B:BD[81.8658] → [81.8658:9042]

B:BD[81.9042] → [81.9042:9105]

B:BD[81.8658] → [54.3957:4480]

B:BD[81.8658] → [55.20824:21208]

B:BD[81.8426] → [121.5621:5678]

B:BD[81.8426] → [89.4496:4551]

B:BD[81.8426] → [120.3909:3966]

B:BD[81.8426] → [114.5286:5335]

B:BD[81.8426] → [81.8426:8483]

B:BD[81.8483] → [81.8483:8658]

B:BD[81.8426] → [54.3921:3956]

B:BD[81.8426] → [118.5171:5220]

B:BD[81.8426] → [55.20768:20823]

B:BD[81.8426] → [123.6694:6853]

B:BD[81.8315] → [114.5216:5285]

B:BD[81.8340] → [81.8340:8426]

B:BD[81.8315] → [81.8315:8340]

B:BD[81.8315] → [54.3851:3920]

B:BD[81.8315] → [118.5101:5170]

B:BD[81.8315] → [55.20742:20767]

B:BD[81.8315] → [123.6668:6693]

B:BD[123.6667] → [29.16912:16956]

B:BD[123.6667] → [49.8910:8938]

B:BD[81.8198] → [81.8198:8226]

B:BD[81.8226] → [81.8226:8315]

B:BD[81.8183] → [121.5579:5594]

B:BD[81.8183] → [114.5181:5215]

B:BD[81.8183] → [81.8183:8198]

B:BD[81.8183] → [118.5066:5100]

B:BD[81.8183] → [123.6652:6667]

B:BD[37.10756] → [55.20687:20740]

B:BD[55.20740] → [55.20740:20741]

B:BD[37.10756] → [37.10756:12130]

B:BD[37.10716] → [116.2221:2259]

B:BD[37.10716] → [54.3812:3850]

B:BD[37.10352] → [83.7061:7279]

B:BD[122.2915] → [122.2915:2964]

B:BD[83.7528] → [122.2983:2998]

B:BD[83.7838] → [122.2999:3056]

B:BD[55.19318] → [29.16472:16523]

B:BD[83.8525] → [29.16524:16691]

B:BD[55.19750] → [43.11419:11465]

B:BD[55.20084] → [29.16739:16911]

B:BD[81.7942] → [121.5377:5460]

B:BD[81.8011] → [121.5461:5578]

B:BD[81.8011] → [114.5126:5180]

B:BD[81.8011] → [81.8011:8128]

B:BD[81.8011] → [54.3729:3811]

B:BD[81.8011] → [118.5011:5065]

B:BD[81.8011] → [55.20571:20686]

B:BD[81.8011] → [123.6432:6482]

B:BD[123.6633] → [123.6633:6651]

B:BD[123.6482] → [124.674:721]

B:BD[37.10624] → [37.10624:10716]

B:BD[37.10716] → [37.10716:10756]

B:BD[123.6482] → [89.4448:4495]

B:BD[123.6482] → [120.3859:3908]

B:BD[123.6482] → [123.6482:6633]

B:BD[81.7942] → [81.7942:8005]

B:BD[81.8005] → [81.8005:8011]

B:BD[83.8525] → [81.7794:7942]

B:BD[81.7942] → [54.3665:3728]

B:BD[81.7942] → [118.4947:5010]

B:BD[81.7942] → [55.20487:20570]

B:BD[81.7942] → [123.6348:6431]

B:BD[55.20084] → [49.8828:8909]

B:BD[55.20084] → [55.20084:20165]

B:BD[55.20165] → [55.20165:20486]

B:BD[55.20084] → [71.1466:1638]

B:BD[55.19750] → [29.16692:16738]

B:BD[55.19750] → [49.8797:8827]

B:BD[55.19750] → [55.19750:19780]

B:BD[55.19780] → [55.19780:20084]

B:BD[83.8525] → [116.2043:2220]

B:BD[83.8525] → [49.8730:8796]

B:BD[83.8525] → [83.8525:8742]

B:BD[122.3107] → [122.3107:3156]

B:BD[122.3156] → [122.3156:3174]

B:BD[122.3107] → [113.1090:1117]

B:BD[83.8742] → [122.3057:3107]

B:BD[83.8742] → [83.8742:8796]

B:BD[83.8524] → [83.8524:8525]

B:BD[55.19641] → [55.19641:19750]

B:BD[55.19589] → [55.19589:19641]

B:BD[83.8525] → [55.19422:19589]

B:BD[55.19318] → [49.8682:8729]

B:BD[83.8518] → [83.8518:8524]

B:BD[55.19318] → [55.19318:19369]

B:BD[55.19369] → [55.19369:19421]

B:BD[83.8524] → [55.19052:19318]

B:BD[83.7838] → [113.1054:1089]

B:BD[83.7838] → [83.7838:7887]

B:BD[83.7887] → [83.7887:8518]

B:BD[83.7528] → [83.7528:7562]

B:BD[83.7562] → [83.7562:7838]

B:BD[122.2964] → [122.2964:2982]

B:BD[122.2915] → [113.1026:1053]

B:BD[83.7333] → [83.7333:7528]

B:BD[83.7279] → [122.2865:2915]

B:BD[83.7279] → [83.7279:7333]

B:BD[37.10352] → [37.10352:10624]

B:BD[80.3789] → [37.10351:10352]

B:BD[80.3740] → [80.3740:3773]

B:BD[80.3773] → [80.3773:3783]

B:BD[80.3663] → [80.3663:3740]

B:BD[15.3319] → [15.3319:3470]

B:BD[15.3254] → [109.411:481]

B:BD[15.3069] → [15.3069:3254]

B:BD[20.2872] → [110.1598:1691]

B:BD[15.2947] → [25.142:264]

B:BD[15.2947] → [28.210:378]

B:BD[33.5234] → [33.5234:5260]

B:BD[35.8497] → [84.3846:3886]

B:BD[35.8497] → [35.8497:8536]

B:BD[35.8536] → [35.8536:8718]

B:BD[33.5260] → [33.5260:5642]

B:BD[33.5260] → [35.8376:8497]

B:BD[20.2872] → [20.2872:2965]

B:BD[20.2965] → [20.2965:3280]

B:BD[15.2947] → [26.210:378]

B:BD[80.3783] → [80.3783:3789]

B:BD[15.2823] → [15.2823:2947]

B:BD[15.2823] → [111.3935:4794]

B:BD[15.2823] → [45.3415:3996]

B:BD[15.2823] → [32.3436:4300]

B:BD[15.2823] → [33.4783:5234]

B:BD[15.2823] → [115.7983:8564]

B:BD[15.2823] → [20.2699:2872]

B:BD[15.2785] → [45.3287:3414]

B:BD[15.2785] → [115.7855:7982]

B:BD[15.2785] → [20.2571:2698]

B:BD[15.2657] → [15.2657:2743]

B:BD[15.2657] → [111.3848:3934]

B:BD[15.2657] → [45.3188:3286]

B:BD[15.2657] → [110.1499:1597]

B:BD[15.2657] → [32.3349:3435]

B:BD[15.2657] → [33.4696:4782]

B:BD[15.2657] → [115.7756:7854]

B:BD[15.2657] → [20.2472:2570]

B:BD[20.1108] → [110.1090:1130]

B:BD[20.1126] → [110.1131:1182]

B:BD[20.1333] → [110.1183:1342]

B:BD[20.1746] → [110.1343:1413]

B:BD[20.2387] → [110.1414:1498]

B:BD[20.2387] → [20.2387:2471]

B:BD[20.1746] → [20.1746:1816]

B:BD[20.1816] → [20.1816:2387]

B:BD[20.1333] → [20.1333:1472]

B:BD[20.1472] → [20.1472:1746]

B:BD[20.1126] → [20.1126:1158]

B:BD[20.1158] → [20.1158:1333]

B:BD[15.846] → [16.0:42]

B:BD[15.1072] → [15.1072:1101]

B:BD[15.1484] → [15.1484:1560]

B:BD[15.1560] → [15.1560:2608]

B:BD[15.1484] → [25.65:141]

B:BD[15.1484] → [28.100:209]

B:BD[15.1484] → [26.100:209]

B:BD[15.1101] → [15.1101:1484]

B:BD[15.1072] → [25.35:64]

B:BD[15.1072] → [28.49:99]

B:BD[15.1072] → [26.49:99]

B:BD[35.7265] → [34.3316:3354]

B:BD[35.7343] → [40.3790:3844]

B:BD[36.5257] → [40.3845:3934]

B:BD[36.5584] → [31.5338:5554]

B:BD[31.5571] → [31.5571:5710]

B:BD[31.5720] → [37.8978:10350]

B:BD[31.5710] → [31.5710:5720]

B:BD[31.5571] → [37.8912:8977]

B:BD[31.5554] → [31.5554:5571]

B:BD[36.5584] → [112.3095:3261]

B:BD[37.8841] → [112.3262:3307]

B:BD[37.8841] → [83.6898:7060]

B:BD[37.8841] → [81.6388:6475]

B:BD[81.6551] → [81.6551:6717]

B:BD[81.6747] → [114.4393:4426]

B:BD[123.5676] → [125.130:181]

B:BD[81.6905] → [125.182:389]

B:BD[81.7065] → [121.4977:4992]

B:BD[81.7201] → [121.4993:5018]

B:BD[81.7312] → [124.618:673]

B:BD[81.7416] → [90.435:607]

B:BD[116.2016] → [81.7778:7793]

B:BD[81.7416] → [88.2858:2939]

B:BD[81.7416] → [81.7416:7497]

B:BD[37.8841] → [116.1997:2016]

B:BD[116.2016] → [116.2016:2042]

B:BD[81.7497] → [121.5077:5376]

B:BD[81.7497] → [114.4637:5125]

B:BD[81.7497] → [81.7497:7777]

B:BD[81.7497] → [118.4458:4946]

B:BD[81.7497] → [123.6048:6347]

B:BD[81.7312] → [121.5019:5076]

B:BD[81.7312] → [89.4392:4447]

B:BD[81.7312] → [120.3801:3858]

B:BD[81.7312] → [114.4587:4636]

B:BD[81.7312] → [81.7312:7369]

B:BD[81.7369] → [81.7369:7416]

B:BD[81.7312] → [118.4408:4457]

B:BD[81.7312] → [123.5888:6047]

B:BD[81.7201] → [114.4517:4586]

B:BD[81.7201] → [81.7201:7226]

B:BD[81.7226] → [81.7226:7312]

B:BD[81.7201] → [118.4338:4407]

B:BD[81.7201] → [123.5862:5887]

B:BD[81.7065] → [114.4482:4516]

B:BD[81.7065] → [81.7065:7080]

B:BD[81.7080] → [81.7080:7201]

B:BD[81.7065] → [118.4303:4337]

B:BD[81.7065] → [123.5846:5861]

B:BD[81.6905] → [90.279:306]

B:BD[90.366] → [90.366:434]

B:BD[81.6971] → [81.6971:7065]

B:BD[90.434] → [88.2805:2857]

B:BD[90.306] → [90.306:366]

B:BD[90.306] → [88.2732:2804]

B:BD[81.6905] → [120.3734:3800]

B:BD[81.6905] → [81.6905:6971]

B:BD[81.6870] → [81.6870:6905]

B:BD[123.5676] → [124.570:617]

B:BD[81.6753] → [121.4859:4976]

B:BD[123.5676] → [90.227:278]

B:BD[123.5676] → [89.4344:4391]

B:BD[123.5676] → [120.3684:3733]

B:BD[81.6753] → [114.4427:4481]

B:BD[81.6753] → [81.6753:6870]

B:BD[81.6753] → [118.4248:4302]

B:BD[123.5676] → [123.5676:5827]

B:BD[123.5827] → [123.5827:5845]

B:BD[81.6753] → [123.5626:5676]

B:BD[81.6747] → [81.6747:6753]

B:BD[81.6717] → [121.4798:4858]

B:BD[81.6717] → [81.6717:6747]

B:BD[81.6717] → [118.4184:4247]

B:BD[81.6717] → [123.5565:5625]

B:BD[81.6475] → [121.4721:4797]

B:BD[81.6475] → [114.4327:4392]

B:BD[81.6475] → [81.6475:6551]

B:BD[81.6475] → [118.4118:4183]

B:BD[81.6475] → [123.5488:5564]

B:BD[37.8841] → [37.8841:8911]

B:BD[36.5584] → [116.1830:1996]

B:BD[36.5584] → [83.6803:6897]

B:BD[36.5584] → [36.5584:5705]

B:BD[36.5744] → [36.5744:5926]

B:BD[36.5705] → [40.3935:3975]

B:BD[36.5705] → [36.5705:5744]

B:BD[36.5558] → [36.5558:5584]

B:BD[37.8819] → [37.8819:8841]

B:BD[36.5584] → [37.8725:8819]

B:BD[35.7343] → [84.3791:3845]

B:BD[35.7343] → [34.3355:5692]

B:BD[35.7343] → [35.7343:8375]

B:BD[35.7265] → [35.7265:7303]

B:BD[35.7343] → [36.4615:5257]

B:BD[36.5257] → [36.5257:5558]

B:BD[35.7303] → [35.7303:7343]

B:BD[15.785] → [15.785:846]

B:BD[15.846] → [15.846:1072]

B:BD[15.785] → [111.1928:3847]

B:BD[15.785] → [45.1650:3187]

B:BD[15.785] → [32.1429:3348]

B:BD[15.785] → [33.2776:4695]

B:BD[15.785] → [115.6218:7755]

B:BD[15.785] → [20.1013:1108]

B:BD[20.1108] → [20.1108:1126]

B:BD[15.785] → [35.7208:7265]

B:BD[20.942] → [111.1843:1927]

B:BD[20.942] → [45.1587:1649]

B:BD[20.942] → [110.1061:1089]

B:BD[115.6155] → [33.2691:2775]

B:BD[115.6155] → [115.6155:6217]

B:BD[20.942] → [20.942:978]

B:BD[20.978] → [20.978:1012]

B:BD[115.6155] → [35.7145:7173]

B:BD[35.7173] → [35.7173:7207]

B:BD[80.3492] → [80.3492:3538]

B:BD[80.3538] → [15.746:784]

B:BD[80.3538] → [80.3538:3663]

B:BD[15.745] → [32.1285:1428]

B:BD[15.745] → [109.351:410]

B:BD[15.745] → [115.6101:6155]

B:BD[15.745] → [20.888:942]

B:BD[98.53125] → [63.43515:43840]

B:BD[98.53351] → [63.43841:43932]

B:BD[98.53563] → [63.43933:44017]

B:BD[98.54191] → [63.44018:44057]

B:BD[98.54389] → [63.44058:44145]

B:BD[98.54560] → [63.44146:44230]

B:BD[98.55168] → [63.44231:44270]

B:BD[98.55343] → [98.55343:55344]

∅:BD[77.36032] → [98.55930:55931]

B:BD[98.55930] → [98.55930:55931]

B:BD[98.56072] → [63.44271:44306]

B:BD[98.56207] → [63.44307:45881]

B:BD[98.57309] → [98.57309:57358]

B:BD[98.57396] → [63.45882:46071]

B:BD[98.57672] → [63.46072:46143]

B:BD[98.57900] → [63.46144:46232]

B:BD[98.60162] → [98.60162:60651]

B:BD[98.61178] → [98.61178:66756]

B:BD[98.60651] → [63.46233:46617]

B:BD[98.60651] → [98.60651:61178]

B:BD[98.57900] → [98.57900:57934]

B:BD[98.57934] → [98.57934:60161]

B:BD[98.57672] → [98.57672:57845]

B:BD[98.57845] → [98.57845:57900]

B:BD[98.57396] → [98.57396:57608]

B:BD[98.57608] → [98.57608:57672]

B:BD[98.57358] → [98.57358:57396]

B:BD[98.56207] → [98.56207:57267]

B:BD[98.57267] → [98.57267:57309]

B:BD[98.60161] → [98.60161:60162]

B:BD[98.56072] → [98.56072:56111]

B:BD[98.56111] → [98.56111:56207]

B:BD[98.55931] → [64.29708:29910]

B:BD[98.55931] → [77.36033:36071]

B:BD[98.55931] → [98.55931:56072]

B:BD[98.55931] → [74.37136:37174]

B:BD[74.37174] → [2.650:980]

B:BD[98.55344] → [77.35969:36032]

B:BD[98.55344] → [98.55344:55930]

B:BD[98.55168] → [98.55168:55206]

B:BD[98.55206] → [98.55206:55343]

B:BD[98.54560] → [98.54560:54635]

B:BD[98.54635] → [98.54635:55168]

B:BD[98.54389] → [98.54389:54466]

B:BD[98.54466] → [98.54466:54560]

B:BD[98.54191] → [98.54191:54229]

B:BD[98.54229] → [98.54229:54389]

B:BD[98.53563] → [98.53563:53638]

B:BD[98.53638] → [98.53638:54191]

B:BD[98.53351] → [98.53351:53432]

B:BD[98.53432] → [98.53432:53563]

B:BD[80.3356] → [31.2691:2924]

B:BD[84.3694] → [40.747:2496]

B:BD[40.2542] → [40.2542:2591]

B:BD[40.2687] → [40.2687:2813]

B:BD[40.2851] → [40.2851:3693]

B:BD[36.4614] → [40.3694:3789]

B:BD[40.2851] → [31.4886:5337]

B:BD[84.3694] → [36.4397:4614]

B:BD[40.2851] → [37.8506:8724]

B:BD[40.2813] → [40.2813:2851]

B:BD[40.2645] → [40.2645:2687]

B:BD[40.2687] → [37.8407:8505]

B:BD[40.2591] → [40.2591:2645]

B:BD[40.2591] → [31.4799:4885]

B:BD[40.2542] → [37.8353:8406]

B:BD[40.2496] → [40.2496:2542]

B:BD[84.3694] → [31.2925:4798]

B:BD[35.7144] → [84.3695:3790]

B:BD[84.3694] → [34.3138:3233]

B:BD[34.3233] → [34.3233:3315]

B:BD[84.3694] → [37.7231:8352]

B:BD[80.3356] → [20.865:887]

B:BD[98.53306] → [98.53306:53351]

B:BD[98.53125] → [98.53125:53306]

B:BD[98.53029] → [98.53029:53125]

B:BD[80.3356] → [98.52106:53029]

B:BD[80.3356] → [35.6319:6432]

B:BD[126.1664] → [126.1664:1690]

B:BD[126.1784] → [126.1784:1806]

B:BD[84.3687] → [84.3687:3693]

B:BD[84.3693] → [84.3693:3694]

B:BD[84.748] → [84.748:1095]

B:BD[35.6926] → [35.6926:6927]

B:BD[84.1230] → [84.1230:1697]

B:BD[84.3184] → [84.3184:3687]

B:BD[84.1697] → [126.2043:2124]

B:BD[84.1697] → [84.1697:3184]

B:BD[35.6927] → [126.1976:2042]

B:BD[35.6927] → [84.1163:1230]

B:BD[35.6927] → [35.6927:7144]

B:BD[84.1095] → [84.1095:1162]

B:BD[126.1806] → [126.1806:1975]

B:BD[126.1806] → [34.3092:3137]

B:BD[126.1690] → [126.1690:1784]

B:BD[126.1690] → [34.2925:3091]

B:BD[35.6506] → [35.6506:6926]

B:BD[84.748] → [126.48:1664]

B:BD[35.6926] → [84.747:748]

B:BD[36.3982] → [36.3982:4396]

B:BD[35.6432] → [40.673:746]

B:BD[35.6432] → [84.673:746]

B:BD[35.6432] → [34.1939:2924]

B:BD[35.6432] → [35.6432:6506]

B:BD[35.6432] → [36.3908:3982]

B:BD[80.3356] → [99.29447:29460]

B:BD[46.51399] → [46.51399:51400]

B:BD[46.51550] → [46.51550:51551]

B:BD[46.55877] → [46.55877:57422]

B:BD[46.55846] → [46.55846:55877]

B:BD[46.52424] → [46.52424:55846]

B:BD[46.52040] → [46.52040:52424]

B:BD[46.55877] → [17.38026:39017]

B:BD[46.55846] → [17.37705:38025]

B:BD[46.52040] → [17.37177:37704]

B:BD[46.51551] → [46.51551:52040]

B:BD[46.51551] → [93.54524:56289]

B:BD[93.56290] → [59.34646:35606]

B:BD[93.58160] → [59.35607:36004]

B:BD[93.58160] → [85.34818:34856]

B:BD[93.58160] → [93.58160:62001]

B:BD[93.56290] → [65.29543:29606]

B:BD[93.58159] → [93.58159:58160]

B:BD[93.56290] → [93.56290:58159]

B:BD[46.51400] → [86.33387:33450]

B:BD[46.51400] → [46.51400:51550]

B:BD[46.51400] → [93.37873:54523]

B:BD[46.34864] → [46.34864:35003]

B:BD[46.35170] → [46.35170:36361]

B:BD[46.36398] → [46.36398:36573]

B:BD[46.36638] → [17.31420:31699]

B:BD[46.36686] → [46.36686:37646]

B:BD[46.37680] → [46.37680:37738]

B:BD[46.37794] → [17.33702:33745]

B:BD[46.37816] → [17.33746:33952]

B:BD[46.37834] → [46.37834:37867]

B:BD[46.37881] → [46.37881:37928]

B:BD[46.37998] → [46.37998:38040]

B:BD[55.16485] → [29.14799:14898]

B:BD[55.16604] → [29.14899:14938]

B:BD[55.16735] → [92.1809:2869]

B:BD[55.18146] → [92.2870:3131]

B:BD[55.18412] → [29.16050:16262]

B:BD[47.7025] → [29.16263:16436]

B:BD[30.7951] → [49.8521:8592]

B:BD[55.18791] → [92.3306:3340]

B:BD[81.4363] → [81.4363:4377]

B:BD[81.4377] → [81.4377:4387]

B:BD[81.5538] → [82.6634:6905]

B:BD[81.4690] → [125.57:129]

B:BD[81.5538] → [124.479:569]

B:BD[81.4859] → [121.4093:4212]

B:BD[81.4394] → [121.4015:4092]

B:BD[81.4690] → [90.176:226]

B:BD[81.4394] → [90.76:175]

B:BD[81.5538] → [89.4253:4343]

B:BD[81.5333] → [89.4186:4252]

B:BD[81.5333] → [120.3535:3683]

B:BD[81.4690] → [120.3485:3534]

B:BD[81.5333] → [88.2583:2731]

B:BD[81.4690] → [88.2510:2582]

B:BD[81.4394] → [88.2432:2509]

B:BD[81.4859] → [114.3993:4077]

B:BD[81.4394] → [114.3903:3992]

B:BD[81.5637] → [81.5637:5865]

B:BD[81.5907] → [121.4213:4399]

B:BD[121.4441] → [118.3869:3967]

B:BD[81.5945] → [81.5945:6134]

B:BD[81.6168] → [121.4442:4597]

B:BD[121.4631] → [118.3968:4051]

B:BD[116.1453] → [116.1453:1479]

B:BD[81.6299] → [121.4632:4720]

B:BD[81.6299] → [114.4261:4326]

B:BD[81.6299] → [81.6299:6387]

B:BD[81.6299] → [118.4052:4117]

B:BD[81.6299] → [123.5399:5487]

B:BD[116.1479] → [116.1479:1829]

B:BD[116.1479] → [81.6270:6299]

B:BD[121.4631] → [123.5209:5398]

B:BD[121.4597] → [121.4597:4631]

B:BD[81.6168] → [81.6168:6269]

B:BD[81.6168] → [114.4177:4260]

B:BD[81.6134] → [81.6134:6168]

B:BD[121.4441] → [123.4980:5208]

B:BD[121.4399] → [121.4399:4441]

B:BD[81.5907] → [81.5907:5945]

B:BD[81.5907] → [114.4078:4176]

B:BD[81.5865] → [81.5865:5907]

B:BD[81.5538] → [81.5538:5637]

B:BD[81.5399] → [81.5399:5538]

B:BD[81.5333] → [81.5333:5399]

B:BD[81.4978] → [81.4978:5333]

B:BD[81.4859] → [81.4859:4978]

B:BD[81.4739] → [81.4739:4859]

B:BD[81.4690] → [81.4690:4739]

B:BD[81.4471] → [81.4471:4690]

B:BD[81.4394] → [81.4394:4471]

B:BD[81.4859] → [118.3784:3868]

B:BD[81.4394] → [118.3694:3783]

B:BD[81.4859] → [123.4860:4979]

B:BD[81.4394] → [123.4782:4859]

B:BD[81.4387] → [81.4387:4394]

B:BD[81.4377] → [55.18958:19051]

B:BD[55.18791] → [29.16437:16471]

B:BD[55.18791] → [47.7098:7186]

B:BD[55.18791] → [30.7952:7986]

B:BD[55.18791] → [49.8593:8681]

B:BD[55.18879] → [55.18879:18957]

B:BD[55.18791] → [55.18791:18879]

B:BD[55.18665] → [47.7026:7097]

B:BD[55.18665] → [30.7778:7921]

B:BD[30.7921] → [30.7921:7951]

B:BD[55.18736] → [55.18736:18791]

B:BD[47.7025] → [49.8331:8520]

B:BD[55.18665] → [55.18665:18736]

B:BD[55.18412] → [30.7565:7777]

B:BD[55.18412] → [55.18412:18446]

B:BD[47.6991] → [47.6991:7025]

B:BD[55.18635] → [55.18635:18665]

B:BD[55.18446] → [92.3132:3305]

B:BD[55.18446] → [47.6836:6991]

B:BD[55.18446] → [55.18446:18635]

B:BD[55.18146] → [29.16000:16049]

B:BD[55.18146] → [47.6607:6835]

B:BD[55.18146] → [30.7515:7564]

B:BD[55.18146] → [55.18146:18374]

B:BD[55.18374] → [55.18374:18412]

B:BD[55.16735] → [29.14939:15999]

B:BD[55.16735] → [47.5260:6606]

B:BD[55.16735] → [30.6454:7514]

B:BD[55.16735] → [49.6937:8330]

B:BD[55.16735] → [55.16735:16781]

B:BD[55.16853] → [55.16853:17734]

B:BD[43.11324] → [43.11324:11418]

B:BD[55.18104] → [55.18104:18146]

B:BD[48.6052] → [48.6052:6146]

B:BD[48.6052] → [72.3366:3467]

B:BD[55.18005] → [55.18005:18104]

B:BD[43.11324] → [71.1372:1465]

B:BD[55.17734] → [43.11147:11324]

B:BD[55.17734] → [22.2827:2917]

B:BD[55.17734] → [48.5875:6052]

B:BD[55.17734] → [53.2765:2855]

B:BD[55.17734] → [55.17734:18005]

B:BD[55.16781] → [55.16781:16853]

B:BD[55.16781] → [71.1321:1371]

B:BD[55.16604] → [30.6414:6453]

B:BD[55.16604] → [49.6901:6936]

B:BD[55.16604] → [55.16604:16639]

B:BD[55.16639] → [55.16639:16735]

B:BD[55.16485] → [46.39007:42308]

B:BD[46.42376] → [46.42376:42551]

B:BD[46.43844] → [46.43844:43940]

B:BD[46.44265] → [46.44265:44310]

B:BD[46.44401] → [46.44401:44532]

B:BD[46.44616] → [46.44616:45169]

B:BD[46.45208] → [46.45208:45368]

B:BD[46.45455] → [46.45455:45549]

B:BD[46.45633] → [46.45633:46166]

B:BD[46.46205] → [46.46205:47071]

B:BD[46.47106] → [46.47106:47202]

B:BD[46.48548] → [46.48548:48590]

B:BD[46.48818] → [46.48818:48856]

B:BD[46.49045] → [46.49045:49109]

B:BD[46.49180] → [46.49180:49235]

B:BD[46.49323] → [46.49323:51399]

B:BD[46.49235] → [46.49235:49323]

B:BD[46.49235] → [17.37142:37176]

B:BD[46.49109] → [46.49109:49180]

B:BD[46.49109] → [17.36968:37141]

B:BD[46.48856] → [46.48856:49045]

B:BD[46.48856] → [17.36755:36967]

B:BD[46.48590] → [46.48590:48818]

B:BD[46.48590] → [17.36705:36754]

B:BD[46.47202] → [46.47202:48548]

B:BD[46.47202] → [17.35644:36704]

B:BD[46.47071] → [46.47071:47106]

B:BD[46.47071] → [17.35604:35643]

B:BD[46.46166] → [46.46166:46205]

B:BD[46.46166] → [17.35565:35603]

B:BD[46.45549] → [46.45549:45633]

B:BD[46.45549] → [17.35489:35564]

B:BD[46.45368] → [46.45368:45455]

B:BD[46.45368] → [17.35411:35488]

B:BD[46.45169] → [46.45169:45208]

B:BD[46.45169] → [17.35372:35410]

B:BD[46.44532] → [46.44532:44616]

B:BD[46.44532] → [17.35296:35371]

B:BD[46.44310] → [46.44310:44401]

B:BD[46.44310] → [17.35214:35295]

B:BD[46.43940] → [46.43940:44265]

B:BD[46.43940] → [17.35032:35213]

B:BD[46.42551] → [46.42551:43844]

B:BD[46.42551] → [17.34107:35031]

B:BD[46.42308] → [46.42308:42376]

B:BD[46.42308] → [17.34034:34106]

B:BD[55.16485] → [49.6823:6900]

B:BD[55.16485] → [99.29461:29524]

B:BD[55.16485] → [55.16485:16562]

B:BD[55.16562] → [55.16562:16604]

B:BD[55.16484] → [55.16484:16485]

B:BD[55.16485] → [71.1221:1320]

B:BD[46.38040] → [46.38040:39006]

B:BD[46.37998] → [17.34011:34033]

B:BD[46.37928] → [46.37928:37998]

B:BD[46.37881] → [17.33975:34010]

B:BD[46.37867] → [46.37867:37881]

B:BD[46.37834] → [17.33953:33974]

B:BD[46.37738] → [46.37738:37794]

B:BD[46.37794] → [46.37794:37816]

B:BD[46.37816] → [46.37816:37834]

B:BD[46.37680] → [17.32887:33701]

B:BD[46.37646] → [46.37646:37680]

B:BD[46.36686] → [17.31700:32886]

B:BD[46.36573] → [46.36573:36638]

B:BD[46.36638] → [46.36638:36686]

B:BD[46.36398] → [17.31005:31419]

B:BD[46.36361] → [46.36361:36398]

B:BD[46.35170] → [17.30480:31004]

B:BD[46.35003] → [46.35003:35170]

B:BD[46.34864] → [17.30375:30479]

B:BD[93.56289] → [93.56289:56290]

B:BD[99.29460] → [59.34300:34645]

B:BD[99.29460] → [46.29887:34864]

B:BD[99.29460] → [62.39459:40248]

B:BD[99.29460] → [93.32947:37872]

B:BD[80.3356] → [37.6624:6691]

B:BD[37.6737] → [112.2109:3094]

B:BD[37.6737] → [116.844:1453]

B:BD[37.6737] → [83.4692:6307]

B:BD[83.6307] → [113.940:1025]

B:BD[83.6307] → [83.6307:6802]

B:BD[81.4011] → [81.4011:4339]

B:BD[81.4339] → [121.3990:4014]

B:BD[81.4339] → [114.3840:3902]

B:BD[81.4339] → [81.4339:4363]

B:BD[81.4339] → [54.3602:3664]

B:BD[81.4339] → [118.3631:3693]

B:BD[81.4339] → [55.16430:16484]

B:BD[81.4339] → [123.4757:4781]

B:BD[37.6737] → [37.6737:7230]

B:BD[37.6691] → [121.3852:3989]

B:BD[37.6691] → [114.3720:3839]

B:BD[37.6691] → [81.3874:4011]

B:BD[37.6691] → [54.3481:3601]

B:BD[37.6691] → [118.3511:3630]

B:BD[37.6691] → [55.16292:16429]

B:BD[37.6691] → [37.6691:6737]

B:BD[37.6691] → [123.4619:4756]

B:BD[80.3356] → [80.3356:3438]

B:BD[80.3438] → [80.3438:3492]

B:BD[115.5595] → [33.2679:2690]

B:BD[115.5595] → [115.5595:5605]

B:BD[80.1874] → [45.1143:1145]

B:BD[80.1875] → [45.1146:1168]

B:BD[80.1988] → [45.1169:1267]

B:BD[111.773] → [111.773:963]

B:BD[111.1174] → [111.1174:1235]

B:BD[111.1404] → [111.1404:1492]

B:BD[80.3237] → [80.3237:3304]

B:BD[80.3304] → [111.1797:1842]

B:BD[80.3304] → [110.865:1060]

B:BD[80.3304] → [127.3900:3945]

B:BD[80.3304] → [128.833:1027]

B:BD[80.3304] → [80.3304:3349]

B:BD[111.1492] → [111.1492:1796]

B:BD[111.1404] → [45.1504:1586]

B:BD[111.1235] → [111.1235:1404]

B:BD[111.1174] → [45.1456:1503]

B:BD[111.963] → [111.963:1174]

B:BD[111.773] → [45.1268:1455]

B:BD[128.533] → [128.533:555]

B:BD[128.736] → [128.736:758]

B:BD[127.2767] → [129.1273:1761]

B:BD[127.2767] → [32.642:860]

B:BD[127.2899] → [32.861:1051]

B:BD[127.3180] → [32.1052:1133]

B:BD[127.3297] → [32.1134:1195]

B:BD[127.3513] → [32.1196:1284]

B:BD[127.3513] → [127.3513:3595]

B:BD[127.3595] → [127.3595:3899]

B:BD[127.3513] → [115.6018:6100]

B:BD[127.3297] → [127.3297:3344]

B:BD[127.3344] → [127.3344:3513]

B:BD[127.3297] → [115.5970:6017]

B:BD[127.3180] → [127.3180:3256]

B:BD[127.3256] → [127.3256:3297]

B:BD[127.3180] → [115.5893:5969]

B:BD[127.2899] → [127.2899:3086]

B:BD[127.3086] → [127.3086:3180]

B:BD[127.2899] → [115.5705:5892]

B:BD[127.2767] → [127.2767:2865]

B:BD[127.2865] → [127.2865:2899]

B:BD[127.2654] → [127.2654:2767]

B:BD[127.2767] → [115.5606:5704]

B:BD[128.758] → [127.2064:2654]

B:BD[128.758] → [128.758:832]

B:BD[128.555] → [127.1616:2063]

B:BD[128.555] → [128.555:736]

B:BD[80.1988] → [128.0:533]

B:BD[80.1988] → [80.1988:2003]

B:BD[80.2085] → [15.528:575]

B:BD[111.739] → [111.739:773]

B:BD[20.728] → [110.120:864]

B:BD[80.2498] → [109.269:350]

B:BD[80.2615] → [20.806:861]

B:BD[80.2615] → [80.2615:2676]

B:BD[80.2676] → [80.2676:3237]

B:BD[80.2498] → [20.729:805]

B:BD[80.2498] → [80.2498:2574]

B:BD[80.2574] → [80.2574:2615]

B:BD[80.2180] → [80.2180:2498]

B:BD[15.575] → [15.575:649]

B:BD[15.575] → [111.665:739]

B:BD[15.575] → [20.644:728]

B:BD[80.2085] → [80.2085:2180]

B:BD[80.2003] → [111.582:664]

B:BD[80.2003] → [110.95:119]

B:BD[80.2003] → [80.2003:2085]

B:BD[45.1168] → [127.0:1615]

B:BD[80.1875] → [80.1875:1988]

B:BD[115.5595] → [35.6308:6318]

B:BD[115.5595] → [37.6613:6623]

B:BD[80.3349] → [80.3349:3355]

B:BD[80.3355] → [80.3355:3356]

B:BD[80.1868] → [80.1868:1874]

B:BD[80.1874] → [80.1874:1875]

B:BD[115.5539] → [122.2823:2864]

B:BD[115.5539] → [33.2512:2678]

B:BD[115.5580] → [115.5580:5595]

B:BD[115.5539] → [115.5539:5580]

B:BD[115.5539] → [83.4668:4691]

B:BD[115.5000] → [33.2380:2511]

B:BD[115.5000] → [115.5000:5349]

B:BD[115.5389] → [115.5389:5454]

B:BD[115.5513] → [115.5513:5539]

B:BD[115.5454] → [129.1206:1272]

B:BD[115.5454] → [115.5454:5513]

B:BD[115.5349] → [129.1158:1205]

B:BD[115.5349] → [115.5349:5389]

B:BD[115.5000] → [83.4049:4667]

B:BD[115.5000] → [35.5780:5802]

B:BD[35.5891] → [35.5891:6129]

B:BD[35.6176] → [35.6176:6241]

B:BD[35.6241] → [34.1879:1938]

B:BD[35.6241] → [35.6241:6307]

B:BD[35.6241] → [36.3841:3907]

B:BD[35.6129] → [34.1838:1878]

B:BD[35.6129] → [35.6129:6176]

B:BD[35.6129] → [36.3793:3840]

B:BD[35.5802] → [34.1648:1837]

B:BD[35.5802] → [35.5802:5891]

B:BD[35.5802] → [36.3703:3792]

B:BD[115.5000] → [37.6083:6242]

B:BD[37.6305] → [37.6305:6366]

B:BD[37.6481] → [37.6481:6546]

B:BD[37.6546] → [112.2049:2108]

B:BD[37.6546] → [37.6546:6612]

B:BD[37.6366] → [112.1941:2048]

B:BD[37.6366] → [37.6366:6481]

B:BD[37.6242] → [112.1878:1940]

B:BD[37.6242] → [37.6242:6305]

B:BD[115.4531] → [122.2059:2248]

B:BD[122.2270] → [113.719:808]

B:BD[122.2318] → [122.2318:2381]

B:BD[122.2442] → [122.2442:2644]

B:BD[122.2691] → [122.2691:2756]

B:BD[122.2756] → [122.2756:2822]

B:BD[122.2756] → [116.784:843]

B:BD[122.2644] → [122.2644:2691]

B:BD[122.2442] → [113.872:939]

B:BD[113.939] → [116.743:783]

B:BD[122.2442] → [81.3671:3873]

B:BD[122.2381] → [122.2381:2442]

B:BD[122.2318] → [113.809:871]

B:BD[122.2318] → [81.3607:3670]

B:BD[122.2270] → [81.3417:3606]

B:BD[122.2248] → [122.2248:2270]

B:BD[122.2270] → [122.2270:2318]

B:BD[115.4531] → [33.2180:2379]

B:BD[115.4531] → [115.4531:4974]

B:BD[115.4974] → [115.4974:5000]

B:BD[115.4531] → [83.3869:4048]

B:BD[115.4531] → [114.3696:3719]

B:BD[115.4531] → [35.5336:5779]

B:BD[115.4531] → [37.5637:5706]

B:BD[37.5769] → [37.5769:5830]

B:BD[37.5898] → [37.5898:6082]

B:BD[37.5830] → [112.1810:1877]

B:BD[37.5830] → [37.5830:5898]

B:BD[37.5706] → [112.1747:1809]

B:BD[37.5706] → [37.5706:5769]

B:BD[115.3996] → [33.2086:2179]

B:BD[115.3996] → [115.3996:4085]

B:BD[115.4373] → [115.4373:4505]

B:BD[115.4505] → [115.4505:4531]

B:BD[115.4085] → [129.655:1157]

B:BD[115.4085] → [115.4085:4373]

B:BD[115.3996] → [35.4612:4701]

B:BD[35.5203] → [35.5203:5335]

B:BD[35.4771] → [35.4771:5203]

B:BD[36.3270] → [36.3270:3702]

B:BD[35.4701] → [40.603:672]

B:BD[35.4701] → [84.603:672]

B:BD[35.4701] → [34.1359:1647]

B:BD[35.4701] → [35.4701:4771]

B:BD[35.4701] → [36.3200:3270]

B:BD[115.2998] → [33.1360:2085]

B:BD[115.2998] → [115.2998:3238]

B:BD[115.3359] → [115.3359:3415]

B:BD[115.3460] → [115.3460:3955]

B:BD[115.3955] → [115.3955:3996]

B:BD[115.3415] → [129.552:654]

B:BD[115.3415] → [115.3415:3460]

B:BD[115.3238] → [129.369:551]

B:BD[115.3238] → [115.3238:3359]

B:BD[115.2998] → [35.3376:3427]

B:BD[35.3535] → [35.3535:3776]

B:BD[35.3958] → [35.3958:4014]

B:BD[36.3130] → [40.534:602]

B:BD[35.4047] → [84.534:602]

B:BD[35.4116] → [35.4116:4611]

B:BD[35.4047] → [35.4047:4116]

B:BD[36.3130] → [36.3130:3199]

B:BD[35.4014] → [34.1313:1358]

B:BD[35.4014] → [35.4014:4047]

B:BD[35.4014] → [36.3097:3130]

B:BD[35.3776] → [34.1191:1312]

B:BD[35.3776] → [35.3776:3958]

B:BD[35.3776] → [36.2914:3096]

B:BD[35.3427] → [34.1138:1190]

B:BD[35.3427] → [35.3427:3535]

B:BD[35.3427] → [36.2805:2913]

B:BD[115.2998] → [37.3737:3788]

B:BD[123.783] → [89.1136:1150]

B:BD[88.1135] → [82.713:772]

B:BD[88.1465] → [82.773:1504]

B:BD[88.1788] → [82.1505:3317]

B:BD[88.2050] → [82.3318:3605]

B:BD[88.2201] → [82.3606:3639]

B:BD[88.2248] → [82.3640:3687]

B:BD[88.2365] → [82.3688:3730]

B:BD[88.2365] → [88.2365:2407]

B:BD[88.2407] → [88.2407:2431]

B:BD[37.3983] → [121.1027:1178]

B:BD[37.4137] → [121.1179:1300]

B:BD[37.4335] → [121.1301:1457]

B:BD[37.4612] → [121.1458:2169]

B:BD[114.2096] → [121.2170:2573]

B:BD[114.2966] → [121.2574:3851]

B:BD[122.1409] → [122.1409:1478]

B:BD[83.3311] → [122.1479:1548]

B:BD[122.1611] → [122.1611:1672]

B:BD[122.1874] → [122.1874:2058]

B:BD[122.1672] → [122.1672:1874]

B:BD[122.1672] → [113.651:718]

B:BD[122.1672] → [81.3214:3416]

B:BD[122.1548] → [122.1548:1611]

B:BD[122.1548] → [113.588:650]

B:BD[122.1548] → [81.3150:3213]

B:BD[112.1615] → [112.1615:1652]

B:BD[37.5504] → [37.5504:5534]

B:BD[37.5534] → [37.5534:5636]

B:BD[112.1652] → [112.1652:1746]

B:BD[112.1652] → [83.3795:3868]

B:BD[83.3311] → [83.3311:3794]

B:BD[83.3311] → [114.3077:3695]

B:BD[114.2966] → [114.2966:3076]

B:BD[83.3285] → [83.3285:3311]

B:BD[114.2966] → [118.3487:3510]

B:BD[114.2096] → [114.2096:2179]

B:BD[81.3059] → [114.2180:2290]

B:BD[83.3285] → [122.1376:1409]

B:BD[114.2940] → [114.2940:2966]

B:BD[83.3285] → [114.2291:2940]

B:BD[81.3059] → [81.3059:3149]

B:BD[81.3025] → [81.3025:3059]

B:BD[83.3255] → [83.3255:3285]

B:BD[114.2096] → [118.1731:1848]

B:BD[118.1958] → [118.1958:2014]

B:BD[123.3363] → [124.335:406]

B:BD[123.3644] → [89.3320:3402]

B:BD[123.3759] → [89.3403:3610]

B:BD[118.2868] → [89.3611:4185]

B:BD[118.2868] → [120.2207:3484]

B:BD[118.2868] → [118.2868:3223]

B:BD[118.3262] → [118.3262:3486]

B:BD[118.3262] → [123.4346:4618]

B:BD[118.3223] → [118.3223:3262]

B:BD[118.2842] → [118.2842:2868]

B:BD[123.4145] → [124.407:478]

B:BD[123.4145] → [123.4145:4345]

B:BD[118.2868] → [123.3937:4145]

B:BD[118.2663] → [118.2663:2773]

B:BD[118.2773] → [118.2773:2842]

B:BD[118.2773] → [123.3857:3936]

B:BD[123.3759] → [123.3759:3856]

B:BD[123.3644] → [120.2044:2206]

B:BD[123.3726] → [123.3726:3759]

B:BD[123.3644] → [123.3644:3726]

B:BD[123.3609] → [123.3609:3644]

B:BD[118.2368] → [118.2368:2407]

B:BD[118.2407] → [118.2407:2663]

B:BD[118.2407] → [123.3564:3609]

B:BD[123.3363] → [123.3363:3563]

B:BD[118.2014] → [118.2014:2368]

B:BD[118.2014] → [123.3156:3363]

B:BD[118.1885] → [118.1885:1958]

B:BD[118.1885] → [123.3072:3155]

B:BD[118.1848] → [118.1848:1885]

B:BD[37.4612] → [122.308:534]

B:BD[122.708] → [122.708:777]

B:BD[122.907] → [122.907:1295]

B:BD[83.3145] → [122.1296:1375]

B:BD[83.3145] → [83.3145:3255]

B:BD[122.907] → [116.454:742]

B:BD[83.3111] → [83.3111:3145]

B:BD[122.907] → [81.2637:3025]

B:BD[122.777] → [122.777:907]

B:BD[122.708] → [113.540:587]

B:BD[122.708] → [81.2567:2636]

B:BD[122.534] → [122.534:708]

B:BD[37.4612] → [112.1139:1277]

B:BD[37.4866] → [112.1278:1457]

B:BD[37.5003] → [112.1458:1615]

B:BD[37.5003] → [37.5003:5504]

B:BD[37.4866] → [37.4866:4945]

B:BD[37.4945] → [37.4945:5003]

B:BD[37.4612] → [113.401:539]

B:BD[37.4612] → [83.1876:3111]

B:BD[37.4612] → [114.944:1639]

B:BD[114.1639] → [114.1639:2096]

B:BD[37.4612] → [81.2340:2566]

B:BD[37.4612] → [54.1334:2033]

B:BD[42.5708] → [42.5708:6443]

B:BD[42.6477] → [42.6477:7546]

B:BD[42.6477] → [43.7166:8168]

B:BD[55.11795] → [43.8169:9027]

B:BD[55.12288] → [43.9028:9096]

B:BD[55.12531] → [43.9097:10390]

B:BD[55.13920] → [43.10391:10716]

B:BD[55.14290] → [43.10717:10808]

B:BD[55.14512] → [43.10809:10893]

B:BD[55.15149] → [43.10894:10933]

B:BD[55.15348] → [43.10934:11021]

B:BD[55.15529] → [43.11022:11106]

B:BD[55.16146] → [43.11107:11146]

B:BD[55.16146] → [47.5220:5259]

B:BD[55.16146] → [30.6375:6413]

B:BD[55.16146] → [38.3808:3846]

B:BD[55.16146] → [53.2726:2764]

B:BD[55.16146] → [55.16146:16185]

B:BD[55.16185] → [55.16185:16291]

B:BD[55.15529] → [47.5135:5219]

B:BD[55.15529] → [30.6299:6374]

B:BD[55.15529] → [38.3732:3807]

B:BD[55.15529] → [53.2650:2725]

B:BD[55.15529] → [55.15529:15613]

B:BD[55.15613] → [55.15613:16146]

B:BD[55.15348] → [47.5047:5134]

B:BD[55.15348] → [30.6221:6298]

B:BD[55.15348] → [38.3654:3731]

B:BD[55.15348] → [53.2572:2649]

B:BD[55.15348] → [55.15348:15435]

B:BD[55.15435] → [55.15435:15529]

B:BD[55.15149] → [47.5007:5046]

B:BD[55.15149] → [30.6182:6220]

B:BD[55.15149] → [38.3615:3653]

B:BD[55.15149] → [53.2533:2571]

B:BD[55.15149] → [55.15149:15188]

B:BD[55.15188] → [55.15188:15348]

B:BD[55.14512] → [47.4922:5006]

B:BD[55.14512] → [30.6106:6181]

B:BD[55.14512] → [38.3539:3614]

B:BD[55.14512] → [53.2457:2532]

B:BD[55.14512] → [55.14512:14596]

B:BD[55.14596] → [55.14596:15149]

B:BD[55.14290] → [47.4830:4921]

B:BD[55.14290] → [30.6024:6105]

B:BD[55.14290] → [38.3457:3538]

B:BD[55.14290] → [53.2375:2456]

B:BD[55.14290] → [55.14290:14381]

B:BD[55.14381] → [55.14381:14512]

B:BD[55.13920] → [47.4504:4829]

B:BD[55.13920] → [30.5842:6023]

B:BD[55.13920] → [38.3275:3456]

B:BD[55.13920] → [53.2193:2374]

B:BD[55.13920] → [55.13920:14245]

B:BD[55.14245] → [55.14245:14290]

B:BD[55.12531] → [47.3210:4503]

B:BD[55.12531] → [30.4917:5841]

B:BD[55.12531] → [38.2350:3274]

B:BD[55.12531] → [53.1268:2192]

B:BD[55.12531] → [55.12531:13824]

B:BD[55.13824] → [55.13824:13920]

B:BD[55.12288] → [47.3141:3209]

B:BD[55.12288] → [30.4844:4916]

B:BD[55.12288] → [38.2277:2349]

B:BD[55.12288] → [53.1195:1267]

B:BD[55.12288] → [55.12288:12356]

B:BD[55.12356] → [55.12356:12531]

B:BD[55.11795] → [55.11795:11918]

B:BD[55.11918] → [55.11918:12288]

B:BD[42.6477] → [54.2180:2259]

B:BD[54.2289] → [54.2289:3480]

B:BD[54.2289] → [55.11116:11761]

B:BD[54.2259] → [54.2259:2289]

B:BD[55.11761] → [55.11761:11795]

B:BD[42.6477] → [55.10875:11115]

B:BD[42.6443] → [42.6443:6477]

B:BD[42.5708] → [54.2034:2179]

B:BD[37.4612] → [118.1035:1147]

B:BD[118.1224] → [118.1224:1264]

B:BD[118.1386] → [118.1386:1515]

B:BD[118.1595] → [118.1595:1730]

B:BD[118.1595] → [123.2013:3071]

B:BD[118.1515] → [118.1515:1595]

B:BD[118.1386] → [123.1713:1773]

B:BD[123.1773] → [124.263:334]

B:BD[123.1773] → [123.1773:2012]

B:BD[118.1264] → [118.1264:1386]

B:BD[118.1224] → [123.1667:1712]

B:BD[118.1147] → [118.1147:1224]

B:BD[37.4612] → [55.9168:9205]

B:BD[55.9264] → [55.9264:9319]

B:BD[55.9498] → [43.6340:7165]

B:BD[55.9498] → [55.9498:10874]

B:BD[55.9319] → [29.8042:14798]

B:BD[55.9319] → [49.3751:6822]

B:BD[55.9319] → [55.9319:9498]

B:BD[55.9205] → [29.7982:8041]

B:BD[55.9205] → [49.3695:3750]

B:BD[55.9205] → [55.9205:9264]

B:BD[37.4612] → [37.4612:4752]

B:BD[37.4752] → [37.4752:4866]

B:BD[37.4612] → [123.1352:1389]

B:BD[123.1588] → [123.1588:1643]

B:BD[89.2575] → [89.2575:2614]

B:BD[89.2744] → [89.2744:2820]

B:BD[89.2857] → [89.2857:2970]

B:BD[42.5674] → [42.5674:5708]

B:BD[119.2979] → [130.172:244]

B:BD[119.3222] → [130.245:1169]

B:BD[119.4611] → [130.1170:1351]

B:BD[119.4981] → [130.1352:1433]

B:BD[119.5203] → [130.1434:1509]

B:BD[119.5840] → [130.1510:1548]

B:BD[119.6039] → [130.1549:1626]

B:BD[119.6220] → [130.1627:1702]

B:BD[119.6837] → [130.1703:1741]

B:BD[119.6837] → [119.6837:6876]

B:BD[119.6876] → [119.6876:6982]

B:BD[119.6220] → [119.6220:6304]

B:BD[119.6304] → [119.6304:6837]

B:BD[119.6039] → [119.6039:6126]

B:BD[119.6126] → [119.6126:6220]

B:BD[119.5840] → [119.5840:5879]

B:BD[119.5879] → [119.5879:6039]

B:BD[119.5203] → [119.5203:5287]

B:BD[119.5287] → [119.5287:5840]

B:BD[119.4981] → [119.4981:5072]

B:BD[119.5072] → [119.5072:5203]

B:BD[119.4611] → [119.4611:4936]

B:BD[119.4936] → [119.4936:4981]

B:BD[119.3222] → [119.3222:4515]

B:BD[119.4515] → [119.4515:4611]

B:BD[119.2979] → [119.2979:3047]

B:BD[119.3047] → [119.3047:3222]

B:BD[89.2970] → [82.5248:6633]

B:BD[89.2970] → [42.2371:5674]

B:BD[89.2970] → [89.2970:3319]

B:BD[89.2970] → [119.1807:2979]

B:BD[89.2820] → [82.5210:5247]

B:BD[89.2820] → [42.1485:2370]

B:BD[89.2820] → [89.2820:2857]

B:BD[89.2820] → [119.921:1806]

B:BD[89.2614] → [82.5079:5209]

B:BD[89.2614] → [42.1356:1484]

B:BD[89.2614] → [89.2614:2744]

B:BD[89.2614] → [119.792:920]

B:BD[123.1643] → [82.3787:5078]

B:BD[123.1643] → [42.737:1355]

B:BD[123.1643] → [89.1284:2575]

B:BD[123.1643] → [120.930:2043]

B:BD[123.1643] → [119.173:791]

B:BD[123.1643] → [123.1643:1666]

B:BD[123.1389] → [82.3731:3786]

B:BD[123.1389] → [124.207:262]

B:BD[123.1389] → [42.677:736]

B:BD[123.1389] → [89.1228:1283]

B:BD[123.1389] → [120.872:929]

B:BD[123.1389] → [119.113:172]

B:BD[123.1389] → [123.1389:1588]

B:BD[37.4335] → [54.1191:1333]

B:BD[37.4335] → [118.893:1034]

B:BD[37.4335] → [55.9011:9167]

B:BD[37.4335] → [37.4335:4375]

B:BD[37.4476] → [37.4476:4612]

B:BD[37.4375] → [112.1093:1138]

B:BD[37.4375] → [116.408:453]

B:BD[37.4375] → [83.1774:1875]

B:BD[37.4375] → [114.842:943]

B:BD[37.4375] → [81.2283:2339]

B:BD[37.4375] → [37.4375:4476]

B:BD[37.4335] → [123.1195:1351]

B:BD[37.4137] → [112.971:1092]

B:BD[37.4137] → [116.286:407]

B:BD[37.4137] → [83.1591:1773]

B:BD[37.4137] → [114.659:841]

B:BD[37.4137] → [54.1008:1190]

B:BD[37.4137] → [118.710:892]

B:BD[37.4137] → [55.8889:9010]

B:BD[37.4137] → [37.4137:4319]

B:BD[37.4319] → [37.4319:4335]

B:BD[37.4137] → [123.1073:1194]

B:BD[37.3983] → [114.622:658]

B:BD[37.3983] → [81.2131:2282]

B:BD[37.3983] → [54.971:1007]

B:BD[37.3983] → [118.673:709]

B:BD[37.3983] → [55.8737:8888]

B:BD[37.4019] → [37.4019:4137]

B:BD[37.3983] → [37.3983:4019]

B:BD[37.3983] → [123.921:1072]

B:BD[88.2365] → [130.149:171]

B:BD[88.2248] → [88.2248:2295]

B:BD[88.2295] → [88.2295:2365]

B:BD[88.2248] → [130.113:148]

B:BD[88.2201] → [88.2201:2234]

B:BD[88.2234] → [88.2234:2248]

B:BD[88.2201] → [130.91:112]

B:BD[88.2050] → [88.2050:2135]

B:BD[88.2135] → [88.2135:2201]

B:BD[88.1788] → [88.1788:1980]

B:BD[88.1980] → [88.1980:2050]

B:BD[81.2124] → [121.1001:1026]

B:BD[123.894] → [89.1151:1227]

B:BD[123.894] → [120.342:548]

B:BD[120.641] → [120.641:871]

B:BD[120.548] → [120.548:641]

B:BD[120.548] → [131.19:626]

B:BD[88.1195] → [88.1195:1465]

B:BD[88.1465] → [88.1465:1788]

B:BD[88.1135] → [88.1135:1195]

B:BD[81.2124] → [123.895:920]

B:BD[123.894] → [88.792:1135]

B:BD[123.783] → [88.773:791]

B:BD[81.2124] → [81.2124:2130]

B:BD[81.2073] → [81.2073:2124]

B:BD[123.783] → [131.0:18]

B:BD[55.4545] → [55.4545:4606]

B:BD[49.3369] → [29.5325:5391]

B:BD[55.8553] → [43.6249:6296]

B:BD[55.8670] → [43.6297:6339]

B:BD[55.8726] → [29.7936:7967]

B:BD[55.8736] → [29.7968:7981]

B:BD[55.8670] → [29.5428:7935]

B:BD[55.8726] → [55.8726:8736]

B:BD[55.8670] → [47.3098:3140]

B:BD[55.8670] → [30.4821:4843]

B:BD[55.8670] → [49.3652:3694]

B:BD[55.8670] → [38.2254:2276]

B:BD[55.8670] → [53.1172:1194]

B:BD[55.8670] → [55.8670:8712]

B:BD[55.8712] → [55.8712:8726]

B:BD[55.8553] → [29.5392:5427]

B:BD[55.8553] → [47.3050:3097]

B:BD[55.8553] → [30.4785:4820]

B:BD[55.8553] → [49.3604:3651]

B:BD[55.8553] → [38.2218:2253]

B:BD[55.8553] → [53.1136:1171]

B:BD[55.8553] → [55.8553:8600]

B:BD[55.8600] → [55.8600:8670]

B:BD[49.3369] → [49.3369:3437]

B:BD[55.4712] → [30.1290:1814]

B:BD[43.3903] → [92.1069:1483]

B:BD[55.5978] → [92.1484:1763]

B:BD[55.6026] → [47.1996:2956]

B:BD[43.6184] → [47.2957:3015]

B:BD[55.8466] → [30.4512:4555]

B:BD[55.8488] → [30.4556:4762]

B:BD[55.8506] → [43.6215:6248]

B:BD[55.8506] → [47.3016:3049]

B:BD[55.8506] → [30.4763:4784]

B:BD[55.8506] → [38.2196:2217]

B:BD[55.8506] → [53.1114:1135]

B:BD[55.8506] → [55.8506:8539]

B:BD[55.8539] → [55.8539:8553]

B:BD[55.8488] → [38.1989:2195]

B:BD[55.8488] → [53.907:1113]

B:BD[55.8466] → [52.1187:1376]

B:BD[38.1666] → [92.1764:1808]

B:BD[55.8466] → [55.8466:8488]

B:BD[55.8488] → [55.8488:8506]

B:BD[38.1666] → [38.1666:1709]

B:BD[38.1709] → [38.1709:1988]

B:BD[52.1376] → [52.1376:1419]

B:BD[52.1376] → [38.1364:1666]

B:BD[55.8440] → [55.8440:8466]

B:BD[43.6184] → [30.3697:4511]

B:BD[43.6184] → [71.1162:1220]

B:BD[55.6026] → [30.2510:3696]

B:BD[43.6184] → [43.6184:6214]

B:BD[55.6026] → [52.0:1186]

B:BD[55.6026] → [55.6026:6271]

B:BD[43.4435] → [43.4435:5885]

B:BD[55.8153] → [43.5927:6068]

B:BD[43.6150] → [43.6150:6184]

B:BD[43.6068] → [43.6068:6150]

B:BD[43.6068] → [71.1072:1161]

B:BD[55.8153] → [22.2741:2826]

B:BD[55.8153] → [48.5587:5728]

B:BD[48.5810] → [48.5810:5874]

B:BD[48.5728] → [48.5728:5810]

B:BD[48.5728] → [72.3276:3365]

B:BD[55.8153] → [53.821:906]

B:BD[55.8153] → [55.8153:8440]

B:BD[43.5885] → [43.5885:5926]

B:BD[48.4095] → [48.4095:4156]

B:BD[48.4788] → [48.4788:4870]

B:BD[48.5069] → [48.5069:5118]

B:BD[48.5118] → [48.5118:5586]

B:BD[48.5069] → [72.3180:3275]

B:BD[48.4870] → [48.4870:5069]

B:BD[48.4788] → [72.3097:3179]

B:BD[48.4156] → [48.4156:4788]

B:BD[48.4095] → [72.2982:3096]

B:BD[55.8083] → [55.8083:8153]

B:BD[43.4435] → [71.1018:1071]

B:BD[55.6271] → [43.4114:4435]

B:BD[55.6271] → [22.2548:2740]

B:BD[55.6271] → [48.3774:4095]

B:BD[55.6271] → [53.628:820]

B:BD[55.6271] → [55.6271:8083]

B:BD[55.5978] → [30.2230:2509]

B:BD[55.5948] → [55.5948:5978]

B:BD[55.5978] → [55.5978:6026]

B:BD[43.3903] → [43.3903:4078]

B:BD[43.4078] → [43.4078:4113]

B:BD[43.3903] → [47.1820:1995]

B:BD[43.3903] → [30.1815:2229]

B:BD[55.4712] → [49.3438:3603]

B:BD[55.4712] → [55.4712:4751]

B:BD[38.1309] → [92.686:1068]

B:BD[43.3866] → [43.3866:3903]

B:BD[38.1309] → [38.1309:1363]

B:BD[55.5147] → [53.557:627]

B:BD[43.3475] → [43.3475:3516]

B:BD[43.3516] → [43.3516:3583]

B:BD[43.3727] → [43.3727:3800]

B:BD[43.3800] → [43.3800:3866]

B:BD[43.3800] → [71.961:1017]

B:BD[43.3583] → [43.3583:3727]

B:BD[43.3583] → [71.659:960]

B:BD[43.3516] → [71.584:658]

B:BD[53.627] → [43.3316:3475]

B:BD[55.5147] → [55.5147:5217]

B:BD[48.3142] → [48.3142:3201]

B:BD[48.3242] → [72.2599:2673]

B:BD[48.3354] → [48.3354:3453]

B:BD[48.3453] → [48.3453:3773]

B:BD[48.3354] → [72.2674:2981]

B:BD[48.3201] → [48.3201:3242]

B:BD[48.3242] → [48.3242:3354]

B:BD[48.3142] → [72.2463:2598]

B:BD[55.5217] → [48.3042:3142]

B:BD[55.5217] → [55.5217:5948]

B:BD[55.4947] → [55.4947:5147]

B:BD[55.5147] → [71.428:583]

B:BD[55.4842] → [55.4842:4888]

B:BD[55.4888] → [43.3256:3315]

B:BD[55.4888] → [22.2487:2547]

B:BD[55.4888] → [48.2982:3041]

B:BD[55.4888] → [53.496:556]

B:BD[55.4888] → [55.4888:4947]

B:BD[55.4888] → [71.379:427]

B:BD[55.4751] → [43.3164:3255]

B:BD[55.4751] → [47.667:1819]

B:BD[55.4751] → [38.1210:1309]

B:BD[55.4751] → [53.396:495]

B:BD[55.4751] → [55.4751:4842]

B:BD[55.4606] → [49.3307:3369]

B:BD[55.4606] → [55.4606:4712]

B:BD[37.3896] → [37.3896:3983]

B:BD[123.783] → [123.783:797]

B:BD[123.797] → [123.797:894]

B:BD[37.3788] → [82.573:712]

B:BD[37.3788] → [121.865:1000]

B:BD[37.3788] → [43.3024:3163]

B:BD[37.3788] → [29.5220:5324]

B:BD[37.3788] → [112.917:970]

B:BD[37.3788] → [116.232:285]

B:BD[37.3788] → [47.527:666]

B:BD[37.3788] → [30.1185:1289]

B:BD[37.3788] → [49.3171:3306]

B:BD[37.3788] → [83.1482:1590]

B:BD[37.3788] → [38.1105:1209]

B:BD[37.3788] → [130.0:90]

B:BD[37.3788] → [81.2022:2073]

B:BD[37.3788] → [53.291:395]

B:BD[37.3788] → [54.868:970]

B:BD[37.3788] → [118.621:672]

B:BD[37.3788] → [55.4406:4545]

B:BD[37.3788] → [37.3788:3896]

B:BD[37.3788] → [123.759:783]

B:BD[115.2997] → [115.2997:2998]

B:BD[80.1868] → [115.2884:2890]

B:BD[115.2890] → [35.3373:3375]

B:BD[115.2890] → [37.3734:3736]

B:BD[36.2359] → [36.2359:2804]

B:BD[36.2359] → [37.3288:3733]

B:BD[80.1477] → [43.1389:1593]

B:BD[81.1066] → [43.1594:2005]

B:BD[37.3162] → [43.2006:3023]

B:BD[36.2319] → [36.2319:2359]

B:BD[80.1858] → [80.1858:1868]

B:BD[37.3162] → [29.4202:5219]

B:BD[37.3162] → [22.2456:2486]

B:BD[37.3162] → [48.1964:2981]

B:BD[37.3162] → [72.2432:2462]

B:BD[37.3162] → [49.3140:3170]

B:BD[37.3162] → [55.3468:4405]

B:BD[37.3162] → [37.3162:3192]

B:BD[37.3192] → [37.3192:3287]

B:BD[81.1066] → [29.3790:4201]

B:BD[37.2275] → [112.378:435]

B:BD[123.208] → [124.118:206]

B:BD[112.589] → [112.589:720]

B:BD[37.3042] → [112.826:916]

B:BD[37.3128] → [37.3128:3162]

B:BD[37.3042] → [37.3042:3090]

B:BD[37.3090] → [37.3090:3128]

B:BD[37.2842] → [37.2842:3042]

B:BD[112.720] → [112.720:825]

B:BD[112.589] → [116.100:231]

B:BD[112.589] → [83.1073:1481]

B:BD[81.1403] → [114.558:621]

B:BD[81.1468] → [121.494:864]

B:BD[81.1468] → [81.1468:1838]

B:BD[81.1838] → [81.1838:2021]

B:BD[81.1468] → [54.776:867]

B:BD[81.1468] → [123.388:758]

B:BD[112.589] → [81.1306:1403]

B:BD[81.1403] → [81.1403:1468]

B:BD[81.1403] → [54.712:775]

B:BD[81.1403] → [118.557:620]

B:BD[112.494] → [112.494:589]

B:BD[123.208] → [89.1047:1135]

B:BD[123.208] → [120.269:341]

B:BD[123.208] → [123.208:340]

B:BD[123.340] → [123.340:387]

B:BD[112.435] → [121.255:493]

B:BD[112.435] → [122.69:307]

B:BD[112.435] → [112.435:494]

B:BD[112.435] → [113.341:400]

B:BD[112.435] → [83.999:1072]

B:BD[112.435] → [114.484:557]

B:BD[112.435] → [81.1067:1305]

B:BD[112.435] → [54.652:711]

B:BD[112.435] → [118.483:556]

B:BD[112.435] → [123.89:208]

B:BD[81.1066] → [22.790:2455]

B:BD[81.1066] → [48.1552:1963]

B:BD[81.1066] → [72.766:2431]

B:BD[81.1066] → [49.1474:3139]

B:BD[81.1066] → [55.3056:3467]

B:BD[37.2275] → [37.2275:2842]

B:BD[80.1477] → [29.3585:3789]

B:BD[80.1477] → [22.637:789]

B:BD[80.1477] → [33.1017:1167]

B:BD[32.466] → [32.466:641]

B:BD[32.466] → [33.1168:1359]

B:BD[32.466] → [115.2438:2883]

B:BD[32.466] → [35.2927:3372]

B:BD[80.1842] → [80.1842:1858]

B:BD[80.1477] → [48.1347:1551]

B:BD[80.1477] → [72.613:765]

B:BD[80.1477] → [115.1392:1714]

B:BD[115.1764] → [115.1764:2437]

B:BD[115.1714] → [129.143:368]

B:BD[32.426] → [32.426:466]

B:BD[115.1714] → [115.1714:1764]

B:BD[80.1477] → [49.1321:1473]

B:BD[80.1477] → [34.679:1137]

B:BD[80.1477] → [81.913:989]

B:BD[81.1065] → [81.1065:1066]

B:BD[81.989] → [81.989:1065]

B:BD[80.1477] → [35.1619:1695]

B:BD[35.1695] → [84.273:349]

B:BD[35.2243] → [84.350:533]

B:BD[35.2243] → [35.2243:2334]

B:BD[35.2334] → [35.2334:2926]

B:BD[35.1695] → [35.1695:2243]

B:BD[80.1477] → [36.1089:1636]

B:BD[36.1727] → [36.1727:2319]

B:BD[36.1636] → [40.350:533]

B:BD[36.1636] → [36.1636:1727]

B:BD[80.1477] → [55.2919:3055]

B:BD[80.1477] → [37.2011:2164]

B:BD[37.2164] → [37.2164:2275]

B:BD[80.1477] → [80.1477:1522]

B:BD[80.1576] → [20.582:643]

B:BD[80.1627] → [80.1627:1842]

B:BD[80.1576] → [80.1576:1627]

B:BD[80.1522] → [111.476:581]

B:BD[80.1522] → [45.745:1142]

B:BD[80.1522] → [110.48:94]

B:BD[80.1522] → [32.321:426]

B:BD[80.1522] → [80.1522:1576]

B:BD[80.961] → [33.501:1016]

B:BD[80.961] → [115.770:820]

B:BD[115.820] → [129.46:75]

B:BD[115.850] → [129.76:142]

B:BD[80.1476] → [80.1476:1477]

B:BD[115.850] → [115.850:911]

B:BD[115.911] → [115.911:1391]

B:BD[115.820] → [115.820:850]

B:BD[80.961] → [34.163:678]

B:BD[80.961] → [35.963:1618]

B:BD[80.961] → [36.356:1088]

B:BD[36.1088] → [40.273:349]

B:BD[80.961] → [37.1355:1405]

B:BD[37.1434] → [37.1434:1464]

B:BD[37.1530] → [37.1530:1591]

B:BD[37.1826] → [42.599:676]

B:BD[37.2010] → [83.845:998]

B:BD[72.424] → [72.424:501]

B:BD[72.501] → [72.501:612]

B:BD[72.424] → [53.217:290]

B:BD[37.1826] → [54.578:651]

B:BD[37.1826] → [37.1826:1899]

B:BD[37.1899] → [37.1899:2010]

B:BD[37.1591] → [43.1198:1388]

B:BD[37.1591] → [29.3394:3584]

B:BD[37.1591] → [22.217:636]

B:BD[37.1591] → [48.1156:1346]

B:BD[37.1591] → [72.189:424]

B:BD[37.1591] → [49.901:1320]

B:BD[37.1591] → [55.2728:2918]

B:BD[37.1591] → [37.1591:1826]

B:BD[37.1464] → [112.316:377]

B:BD[37.1464] → [116.38:99]

B:BD[37.1464] → [83.778:844]

B:BD[37.1464] → [81.846:912]

B:BD[37.1464] → [37.1464:1530]

B:BD[37.1405] → [83.748:777]

B:BD[37.1405] → [81.816:845]

B:BD[37.1405] → [37.1405:1434]

B:BD[80.961] → [80.961:1476]

B:BD[80.944] → [80.944:961]

B:BD[80.745] → [113.235:340]

B:BD[80.745] → [83.642:747]

B:BD[80.745] → [81.710:815]

B:BD[81.815] → [42.542:598]

B:BD[80.745] → [54.420:577]

B:BD[80.745] → [55.2566:2671]

B:BD[55.2671] → [43.1141:1197]

B:BD[55.2671] → [29.3337:3393]

B:BD[55.2671] → [22.164:216]

B:BD[55.2671] → [48.1099:1155]

B:BD[55.2671] → [49.848:900]

B:BD[55.2671] → [53.164:216]

B:BD[55.2671] → [55.2671:2727]

B:BD[80.745] → [37.1194:1302]

B:BD[37.1302] → [37.1302:1354]

B:BD[80.745] → [80.745:782]

B:BD[35.910] → [34.110:162]

B:BD[35.910] → [35.910:962]

B:BD[35.910] → [36.303:355]

B:BD[80.831] → [80.831:944]

B:BD[80.782] → [31.338:500]

B:BD[80.782] → [111.313:475]

B:BD[80.782] → [45.624:744]

B:BD[80.782] → [32.153:320]

B:BD[80.782] → [109.214:268]

B:BD[80.782] → [33.338:500]

B:BD[80.782] → [115.649:769]

B:BD[80.782] → [20.461:581]

B:BD[80.782] → [35.842:910]

B:BD[80.782] → [80.782:831]

B:BD[80.690] → [111.258:312]

B:BD[80.690] → [45.564:623]

B:BD[80.690] → [112.150:209]

B:BD[80.690] → [109.154:213]

B:BD[80.690] → [33.283:337]

B:BD[80.690] → [113.175:234]

B:BD[80.690] → [83.582:641]

B:BD[80.690] → [81.650:709]

B:BD[80.690] → [54.360:419]

B:BD[80.690] → [35.782:841]

B:BD[80.690] → [55.2506:2565]

B:BD[80.690] → [37.1133:1193]

B:BD[80.690] → [80.690:744]

B:BD[80.744] → [80.744:745]

B:BD[80.554] → [121.208:254]

B:BD[37.1011] → [112.112:149]

B:BD[80.653] → [80.653:690]

B:BD[37.1011] → [116.0:37]

B:BD[37.1011] → [83.536:581]

B:BD[37.1011] → [81.604:649]

B:BD[37.1011] → [37.1011:1056]

B:BD[37.1056] → [37.1056:1132]

B:BD[80.554] → [33.183:282]

B:BD[80.554] → [89.995:1046]

B:BD[80.554] → [120.222:268]

B:BD[80.554] → [115.354:535]

B:BD[115.572] → [115.572:648]

B:BD[115.535] → [129.0:45]

B:BD[115.535] → [115.535:572]

B:BD[80.554] → [34.0:109]

B:BD[80.554] → [114.432:483]

B:BD[80.554] → [54.313:359]

B:BD[80.554] → [35.479:781]

B:BD[80.554] → [118.431:482]

B:BD[80.554] → [36.0:302]

B:BD[80.554] → [55.2454:2505]

B:BD[37.876] → [37.876:1011]

B:BD[80.554] → [37.830:876]

B:BD[80.554] → [80.554:579]

B:BD[80.579] → [111.183:257]

B:BD[80.579] → [45.479:563]

B:BD[80.579] → [32.78:152]

B:BD[80.579] → [20.376:460]

B:BD[80.579] → [80.579:653]

B:BD[15.527] → [81.578:603]

B:BD[15.527] → [37.803:829]

B:BD[80.515] → [80.515:516]

B:BD[80.516] → [80.516:554]

B:BD[80.499] → [80.499:515]

B:BD[45.356] → [45.356:359]

B:BD[80.453] → [15.479:527]

B:BD[45.359] → [45.359:478]

B:BD[45.359] → [33.78:182]

B:BD[45.359] → [35.359:478]

B:BD[80.349] → [45.127:356]

B:BD[80.349] → [109.34:153]

B:BD[20.143] → [20.143:375]

B:BD[35.126] → [35.126:128]

B:BD[35.129] → [31.78:182]

B:BD[35.129] → [114.233:372]

B:BD[37.802] → [114.373:400]

B:BD[35.129] → [35.129:358]

B:BD[35.129] → [118.403:430]

B:BD[35.129] → [37.683:772]

B:BD[37.772] → [37.772:802]

B:BD[35.128] → [35.128:129]

B:BD[37.448] → [37.448:627]

B:BD[81.577] → [114.0:19]

B:BD[114.132] → [114.132:162]

B:BD[89.748] → [89.748:764]

B:BD[89.766] → [89.766:767]

B:BD[118.203] → [89.967:994]

B:BD[118.200] → [89.964:966]

B:BD[118.203] → [118.203:399]

B:BD[37.682] → [118.400:402]

B:BD[118.202] → [118.202:203]

B:BD[118.200] → [118.200:202]

B:BD[89.767] → [89.767:963]

B:BD[89.767] → [55.2426:2453]

B:BD[89.764] → [89.764:766]

B:BD[89.764] → [55.2423:2425]

B:BD[114.207] → [114.207:232]

B:BD[118.159] → [118.159:200]

B:BD[114.162] → [121.159:207]

B:BD[114.162] → [89.678:748]

B:BD[114.162] → [120.173:221]

B:BD[114.162] → [114.162:207]

B:BD[114.162] → [54.239:312]

B:BD[114.162] → [118.114:159]

B:BD[114.162] → [55.2112:2422]

B:BD[114.19] → [121.69:158]

B:BD[114.19] → [89.564:677]

B:BD[114.19] → [120.83:172]

B:BD[114.19] → [114.19:132]

B:BD[114.19] → [54.149:238]

B:BD[114.19] → [118.0:113]

B:BD[114.19] → [55.1998:2111]

B:BD[37.666] → [37.666:682]

B:BD[37.627] → [112.48:85]

B:BD[37.627] → [113.111:148]

B:BD[37.627] → [83.472:509]

B:BD[37.627] → [81.540:577]

B:BD[37.627] → [54.111:148]

B:BD[37.627] → [55.1960:1997]

B:BD[37.627] → [37.627:666]

B:BD[80.349] → [80.349:453]

B:BD[80.474] → [80.474:499]

B:BD[80.453] → [80.453:474]

B:BD[80.346] → [80.346:349]

B:BD[20.74] → [31.0:77]

B:BD[20.74] → [111.0:77]

B:BD[20.74] → [45.107:126]

B:BD[20.74] → [110.28:47]

B:BD[20.74] → [32.0:77]

B:BD[20.74] → [112.28:47]

B:BD[20.74] → [33.0:77]

B:BD[20.74] → [113.91:110]

B:BD[20.74] → [115.102:353]

B:BD[20.74] → [20.74:143]

B:BD[20.74] → [83.449:471]

B:BD[20.74] → [81.517:539]

B:BD[20.74] → [54.91:110]

B:BD[20.74] → [35.107:126]

B:BD[20.74] → [55.1937:1959]

B:BD[20.74] → [37.428:448]

B:BD[20.3] → [20.3:31]

B:BD[115.72] → [115.72:73]

B:BD[35.106] → [113.62:90]

B:BD[35.106] → [83.424:448]

B:BD[35.106] → [81.492:516]

B:BD[35.106] → [54.62:90]

B:BD[35.105] → [35.105:106]

B:BD[35.106] → [55.1912:1936]

B:BD[115.73] → [115.73:101]

B:BD[115.73] → [35.0:105]

B:BD[45.34] → [115.0:72]

B:BD[37.320] → [37.320:321]

B:BD[124.72] → [125.0:56]

B:BD[124.95] → [124.95:96]

B:BD[81.393] → [124.97:117]

B:BD[55.1274] → [29.2449:3031]

B:BD[55.1848] → [49.491:524]

B:BD[55.1848] → [55.1848:1851]

B:BD[49.679] → [29.3122:3336]

B:BD[49.679] → [49.679:795]

B:BD[49.795] → [49.795:847]

B:BD[55.1851] → [49.612:679]

B:BD[55.1851] → [55.1851:1880]

B:BD[37.397] → [112.0:27]

B:BD[37.397] → [113.34:61]

B:BD[37.397] → [83.393:423]

B:BD[37.397] → [81.461:491]

B:BD[37.397] → [54.34:61]

B:BD[37.397] → [55.1881:1911]

B:BD[37.425] → [37.425:427]

B:BD[37.397] → [37.397:425]

B:BD[49.524] → [29.3032:3121]

B:BD[49.524] → [49.524:611]

B:BD[55.1274] → [49.434:490]

B:BD[81.431] → [81.431:460]

B:BD[81.430] → [81.430:431]

B:BD[81.431] → [54.0:33]

B:BD[55.1274] → [55.1274:1300]

B:BD[55.1391] → [55.1391:1431]

B:BD[55.1542] → [43.1066:1140]

B:BD[71.378] → [6.257:329]

B:BD[71.378] → [38.1032:1104]

B:BD[55.1684] → [55.1684:1786]

B:BD[55.1786] → [55.1786:1848]

B:BD[55.1684] → [71.290:378]

B:BD[55.1542] → [22.98:163]

B:BD[55.1542] → [48.1024:1098]

B:BD[55.1542] → [53.98:163]

B:BD[55.1616] → [55.1616:1684]

B:BD[55.1542] → [55.1542:1616]

B:BD[55.1431] → [55.1431:1542]

B:BD[55.1431] → [71.164:289]

B:BD[55.1300] → [43.974:1065]

B:BD[55.1300] → [22.62:97]

B:BD[55.1300] → [48.932:1023]

B:BD[55.1300] → [72.0:188]

B:BD[55.1300] → [53.62:97]

B:BD[55.1300] → [55.1300:1391]

B:BD[55.1300] → [71.0:163]

B:BD[81.431] → [55.1237:1274]

B:BD[81.393] → [121.33:68]

B:BD[81.393] → [89.543:563]

B:BD[81.393] → [120.47:82]

B:BD[81.393] → [81.393:428]

B:BD[81.428] → [81.428:430]

B:BD[81.393] → [123.33:88]

B:BD[124.72] → [124.72:93]

B:BD[124.93] → [124.93:95]

B:BD[83.360] → [122.33:68]

B:BD[89.484] → [89.484:519]

B:BD[89.540] → [89.540:542]

B:BD[89.519] → [90.55:75]

B:BD[88.605] → [42.399:541]

B:BD[88.605] → [88.605:670]

B:BD[88.670] → [88.670:772]

B:BD[88.670] → [119.44:112]

B:BD[90.75] → [88.494:605]

B:BD[89.519] → [89.519:540]

B:BD[89.519] → [88.473:493]

B:BD[120.46] → [89.446:484]

B:BD[88.472] → [82.490:572]

B:BD[88.472] → [42.307:398]

B:BD[89.484] → [88.446:472]

B:BD[37.354] → [37.354:397]

B:BD[37.321] → [124.0:72]

B:BD[37.321] → [113.0:33]

B:BD[37.321] → [120.0:46]

B:BD[37.321] → [83.321:360]

B:BD[83.360] → [83.360:392]

B:BD[37.321] → [81.354:393]

B:BD[37.321] → [37.321:354]

B:BD[80.211] → [80.211:239]

B:BD[80.346] → [20.0:3]

B:BD[80.269] → [80.269:346]

B:BD[80.239] → [15.435:478]

B:BD[80.239] → [80.239:269]

B:BD[80.210] → [80.210:211]

B:BD[15.434] → [45.0:34]

B:BD[15.434] → [126.0:47]

B:BD[15.434] → [49.263:296]

B:BD[49.297] → [59.34287:34299]

B:BD[49.297] → [86.33363:33386]

B:BD[49.297] → [58.38812:38835]

B:BD[49.297] → [46.29843:29886]

B:BD[49.297] → [62.39415:39458]

B:BD[49.297] → [65.29519:29542]

B:BD[49.297] → [49.297:377]

B:BD[49.400] → [49.400:433]

B:BD[49.377] → [49.377:400]

B:BD[49.297] → [60.42774:42797]

B:BD[98.39877] → [98.39877:40332]

B:BD[98.44627] → [63.39499:39638]

B:BD[98.44792] → [102.38896:39001]

B:BD[98.45092] → [102.39002:39526]

B:BD[102.39563] → [102.39563:39977]

B:BD[102.40042] → [102.40042:40094]

B:BD[102.40337] → [102.40337:41523]

B:BD[102.41557] → [102.41557:42371]

B:BD[98.46965] → [102.42402:42445]

B:BD[98.47037] → [102.42446:42652]

B:BD[98.47055] → [102.42653:42674]

B:BD[98.47069] → [102.42675:42710]

B:BD[102.42780] → [102.42780:42802]

B:BD[98.47210] → [98.47210:47591]

B:BD[98.47601] → [98.47601:47614]

B:BD[98.51858] → [63.42152:42220]

B:BD[98.52105] → [63.42221:43514]

B:BD[98.51858] → [98.51858:51930]

B:BD[98.51930] → [98.51930:52105]

B:BD[98.47614] → [98.47614:51858]

B:BD[98.47591] → [98.47591:47601]

B:BD[102.42780] → [63.42109:42151]

B:BD[102.42710] → [102.42710:42780]

B:BD[98.47196] → [98.47196:47210]

B:BD[98.47069] → [63.42061:42108]

B:BD[98.47069] → [98.47069:47196]

B:BD[98.47055] → [63.42027:42060]

B:BD[98.46965] → [98.46965:47015]

B:BD[98.47015] → [98.47015:47037]

B:BD[98.47037] → [98.47037:47055]

B:BD[98.47055] → [98.47055:47069]

B:BD[98.46939] → [98.46939:46965]

B:BD[102.42371] → [102.42371:42401]

B:BD[102.41557] → [63.41968:42026]

B:BD[102.41523] → [102.41523:41557]

B:BD[102.40289] → [102.40289:40337]

B:BD[98.46679] → [102.40095:40289]

B:BD[102.40337] → [63.41007:41967]

B:BD[98.46679] → [98.46679:46939]

B:BD[98.46646] → [98.46646:46679]

B:BD[102.39977] → [102.39977:40042]

B:BD[102.39563] → [63.40831:41006]

B:BD[102.39526] → [102.39526:39563]

B:BD[98.45092] → [63.39639:40830]

B:BD[98.45092] → [98.45092:46646]

B:BD[98.44792] → [98.44792:45091]

B:BD[98.45091] → [98.45091:45092]

B:BD[98.44627] → [98.44627:44731]

B:BD[98.44731] → [98.44731:44792]

B:BD[98.40332] → [98.40332:44627]

B:BD[60.42797] → [98.39195:39877]

B:BD[49.297] → [93.32903:32946]

B:BD[15.434] → [83.273:320]

B:BD[15.434] → [81.306:353]

B:BD[15.434] → [37.273:320]

B:BD[26.48] → [121.0:32]

B:BD[26.48] → [122.0:32]

B:BD[49.296] → [49.296:297]

B:BD[26.48] → [81.273:305]

B:BD[26.48] → [55.1192:1193]

B:BD[55.1193] → [29.2405:2448]

B:BD[55.1193] → [49.231:262]

B:BD[55.1193] → [55.1193:1236]

B:BD[26.48] → [123.0:1]

B:BD[123.1] → [82.458:489]

B:BD[123.1] → [42.263:306]

B:BD[123.1] → [119.0:43]

B:BD[123.1] → [123.1:32]

B:BD[80.198] → [59.34253:34286]

B:BD[80.198] → [58.38792:38811]

B:BD[58.38811] → [98.39136:39137]

∅:BD[77.35968] → [98.39180:39194]

B:BD[98.39180] → [98.39180:39194]

B:BD[98.39137] → [77.35945:35968]

B:BD[98.39137] → [98.39137:39180]

B:BD[80.198] → [25.22:34]

B:BD[80.198] → [28.29:48]

B:BD[80.198] → [26.29:48]

B:BD[80.198] → [80.198:210]

B:BD[80.128] → [80.128:163]

B:BD[80.164] → [43.932:973]

B:BD[80.164] → [29.2363:2404]

B:BD[80.164] → [49.197:230]

B:BD[80.164] → [80.164:197]

B:BD[80.163] → [80.163:164]

B:BD[80.90] → [59.34214:34252]

B:BD[80.90] → [46.29762:29842]

B:BD[80.90] → [62.39334:39414]

B:BD[80.90] → [98.39055:39135]

B:BD[80.90] → [93.32822:32902]

B:BD[80.90] → [80.90:128]

B:BD[80.17] → [59.34169:34213]

B:BD[80.17] → [86.33310:33362]

B:BD[80.17] → [58.38739:38791]

B:BD[80.17] → [46.29717:29761]

B:BD[80.17] → [62.39289:39333]

B:BD[80.17] → [21.25111:25146]

B:BD[21.25146] → [23.271:294]

B:BD[21.25146] → [21.25146:25176]

B:BD[21.25146] → [2.619:649]

B:BD[80.17] → [65.29466:29518]

B:BD[80.17] → [77.35892:35944]

B:BD[80.17] → [60.42721:42773]

B:BD[80.17] → [98.39010:39054]

B:BD[80.17] → [99.29394:29446]

B:BD[80.17] → [93.32777:32821]

B:BD[80.17] → [80.18:62]

use tokio::prelude::stream;
mod stanzas;
    account: std::rc::Rc<config::Account>,
    inner: Option<Client>,
}
pub struct MaybeXmppConnection {
    inner: Option<Client>,
    account: std::rc::Rc<config::Account>,
impl XmppConnection {
    fn new(account: config::Account) -> XmppConnection {
        XmppConnection {
            inner: None,
            inner: None,
            state: None,
}
impl MaybeXmppConnection {
    /// Error shoud be !
    fn connect<E: 'static>(self) -> impl Future<Item = Self, Error = E> {
        let XmppConnection { account, inner } = self;
        if let Some(inner) = inner {
            Box::new(future::ok(XmppConnection { account, inner }))
            Box::new(future::loop_fn(account, |account| {
                info!("xmpp initialization...");
                let mut res_client = Client::new(&account.jid, &account.password);
                while let Err(e) = res_client {
                    error!("Cann't init xmpp client: {}", e);
                    res_client = Client::new(&account.jid, &account.password);
                }
                let client = res_client.expect("Cann't init xmpp client");
                info!("xmpp initialized");
                // future to wait for online
                Self::online(client.split(), account)
                    .and_then(Self::self_presence)
                        Ok(conn) => future::ok(future::Loop::Break(conn)),
                        Err(acc) => future::ok(future::Loop::Continue(acc)),
                    })
            }))
}
impl XmppConnection {
    /// base XMPP processing
    fn xmpp_processing(&mut self, _event: &Event) {}
    /// get connection and wait for online status and set presence
    /// returns error if something went wrong
    fn online(
        (sink, stream): (stream::SplitSink<Client>, stream::SplitStream<Client>),
        account: std::rc::Rc<config::Account>,
    ) -> impl Future<Item = Self, Error = std::rc::Rc<config::Account>> {
        Box::new(future::loop_fn(
            (sink, stream, account),
            |(sink, stream, account)| {
                stream.into_future().then(|r| match r {
                    Ok((event, stream)) => match event {
                        Some(Event::Online) => {
                            info!("Online");
                            future::ok(future::Loop::Break(XmppConnection {
                                inner: Some((sink, stream)),
                            }))
                        Some(Event::Stanza(s)) => {
                            info!("xmpp stanza: {:?}", s);
                            future::ok(future::Loop::Continue((sink, stream, account)))
                        _ => {
                            warn!("Disconnected");
                            future::err(account)
                    },
                    Err((e, _)) => {
                        error!("xmpp receive error: {}", e);
                        future::err(account)
        ))
}
    fn self_presence(self) -> impl Future<Item = Self, Error = std::rc::Rc<config::Account>> {
                                        } else {
                                        }
                                    }
                        }).map_err(|e| format!("waiting self-presence: {}", e)),
                    ).then(|r| match r {
                        Ok(inner) => future::ok(XmppConnection {
            Box::new(future::err(account)) as Box<Future<Item = _, Error = _>>
    fn self_presence(self) -> impl Future<Item = Self, Error = std::rc::Rc<config::Account>> {
        let XmppConnection { account, inner } = self;
        let client = inner;
        info!("Sending presence...");
        Box::new(
            client
                .send(presence)
                .map_err(|e| {
                    error!("Error on send self-presence: {}", e);
                    "Cann't send self-presence".to_owned()
                })
                .and_then(move |client| {
                    future::loop_fn((account2.clone(), client), |(account, client)| {
                        client
                            .into_future()
                            .map_err(|(e, _)| {
                                error!("Error on reading self-presence: {}", e);
                                "Cann't read self-presence".to_owned()
                            })
                            .and_then(|(event, client)| match event {
                                Some(event) => {
                                    if let tokio_xmpp::Event::Stanza(e) = event {
                                        info!("Get stanza: {:?}", e);
                                        if e.name() == "presence"
                                            && e.attr("from").map_or(false, |f| f == account.jid)
                                            && e.attr("to").map_or(false, |f| f == account.jid)
                                        {
                                            info!("Self presence");
                                            future::ok(future::Loop::Break(client))
                                        } else {
                                            future::ok(future::Loop::Continue((account, client)))
                                        }
                                    } else {
                                        future::err("Got wrong event".to_owned())
                                    }
                                }
                                None => future::err("Got closed stream".to_owned()),
                            })
                    })
                    .map_err(|e| format!("waiting self-presence: {}", e))
                })
                .then(|r| match r {
                    Err(e) => {
                        error!("Self-presence waiting error: {}", e);
                        future::err(account)
                    }
                    Ok(inner) => future::ok(XmppConnection { account, inner }),
                }),
        )
    }
pub struct XmppCommand {
    pub xmpp_to: jid::Jid,
    pub message: String,
}
    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 {
                            if s.name() == "presence"
                                && s.attr("from").map_or(false, |f| f == conn.account.jid)
                                && s.attr("to").map_or(false, |f| f == conn.account.jid)
                            {
                                Ok(true)
                            } else {
                                Ok(false)
                            }
                        } 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()));
                    }
                } else {
                    info!("Jid {} not in roster", xmpp_to);
                    self.state.data.counter += 1;
                    let id_add_roster = format!("id_add_roster{}", self.state.data.counter);
                    let add_roster = stanzas::make_add_roster(&id_add_roster, xmpp_to.clone());
                    self.state
                        .data
                        .pending_add_roster_ids
                        .insert(id_add_roster, xmpp_to.clone());
                    info!("Adding jid to roster... {:?}", add_roster);
                    self.state.data.send_queue.push_back(add_roster);
                }
            }
        }
    }
    fn process_command(&mut self, cmd: XmppCommand) {
        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);
                }
            }
        }
    }
    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,
            })
    }
}
#[derive(Debug)]
pub enum XmppCommand {
    Chat {
        xmpp_to: xmpp_parsers::Jid,
        message: String,
    },
    Chatroom {
        muc_id: String,
        message: String,
    },
}
    signal: F,
}
    fn new(cmd_recv: S, signal: F, conn: XmppConnection) -> XmppState<F, S> {
    signal: F,
    account: config::Account,
where
    <F as hyper::rt::Future>::Error: std::fmt::Display,
    S: stream::Stream<Item = XmppCommand> + 'static
    S: stream::Stream<Item = XmppCommand, Error = ()> + 'static,
    S: stream::Stream<Item = XmppCommand> + 'static
    S: stream::Stream<Item = XmppCommand> + 'static,
    <F as hyper::rt::Future>::Error: std::fmt::Display + Into<failure::Error> + Send,
    S: stream::Stream<Item = XmppCommand> + 'static,
{
            cmd_recv,
            signal,
            conn,
        } = s;
                    Ok((conn, r)) => match r {
                        Ok(Either::A(f)) => Box::new(if let Some(cmd_recv) = f.into_inner() {
                            future::ok(future::Loop::Continue(XmppProcessState {
                                cmd_recv,
                                signal,
                                conn: conn.into(),
                            }))
                        } else {
                            future::err(format_err!("Command receiver is gone"))
                        })
                            as Box<dyn Future<Item = _, Error = _>>,
                                Box::new(conn.process_command(cmd).then(|r| {
                                    future::ok(future::Loop::Continue(XmppProcessState {
                                        cmd_recv,
                                        signal,
                                        conn: match r {
                                            Ok(conn) => conn.into(),
                                            Err(account) => account.into(),
                                        },
                                    }))
                                    as Box<dyn Future<Item = _, Error = _>>
                                Box::new(future::ok(future::Loop::Break(())))
                        Err(_) => Box::new(future::err(format_err!("Command receiver is broken"))),
                    Err((account, r)) => Box::new(match r {
                    },
    .and_then(|opt_conn| {
        if let Some(conn) = opt_conn {
            Box::new(conn.shutdown()) as Box<dyn Future<Item = (), Error = _>>
        } else {
            Box::new(future::ok(()))
        }
    })
    })
    .and_then(|opt_conn| {
        if let Some(conn) = opt_conn {
            Box::new(conn.shutdown()) as Box<dyn Future<Item = (), Error = _>>
        } else {
            Box::new(future::ok(()))
        }
    .and_then(|opt_conn| {
        if let Some(conn) = opt_conn {
            Box::new(conn.shutdown()) as Box<dyn Future<Item = (), Error = _>>
        } else {
            Box::new(future::ok(()))
        }
    })
    .and_then(|opt_conn| {
        if let Some(conn) = opt_conn {
            Box::new(conn.shutdown()) as Box<dyn Future<Item = (), Error = _>>
        } else {
            Box::new(future::ok(()))
        }
    })
    })
    .and_then(|(opt_cmd_recv, _conn): (Option<S>, MaybeXmppConnection)| {
        if let Some(cmd_recv) = opt_cmd_recv {
            // process left commands
            info!("Stop accepting commands");
            Box::new(
                cmd_recv
                    .for_each(|_cmd| future::ok(()))
                    .map_err(|_| format_err!("cmd receiver last error")),
            ) as Box<Future<Item = (), Error = failure::Error>>
        } else {
            Box::new(future::ok(()))
        }
    .and_then(|opt_conn| {
        if let Some(conn) = opt_conn {
            Box::new(conn.shutdown()) as Box<dyn Future<Item = (), Error = _>>
        } else {
            Box::new(future::ok(()))
        }
    })
    })
    .and_then(|opt_conn| {
        if let Some(conn) = opt_conn {
            Box::new(conn.shutdown()) as Box<dyn Future<Item = (), Error = _>>
        } else {
            Box::new(future::ok(()))
        }
    .and_then(|opt_conn| {
        if let Some(conn) = opt_conn {
            Box::new(conn.shutdown()) as Box<dyn Future<Item = (), Error = _>>
        } else {
            Box::new(future::ok(()))
        }
    })
                        Ok(Either::B((cmd, cmd_recv))) => {
                            if let Some(_cmd) = cmd {
                                error!("Xmpp connection broken while get command");
                                future::ok(future::Loop::Continue(XmppProcessState {
                                    cmd_recv,
                                    signal,
                                    conn: account.into(),
                                }))
                            } else {
                                future::ok(future::Loop::Break(()))
                            }
                        }
                        Err(_) => future::err(format_err!("Command receiver is broken")),
                })
        })
                    }),
                    },
                    }),
                    },
                    }),
                    }
                    Err(e) => {
                        // got cmd error, its bad
                        error!("Cmd error: {}", e);
                        future::err(format_err!("Cmd error"))
                    }
                }
            })
    })
                    },
                })
        })
                        Err(_) => future::err(format_err!("Command receiver is broken")),
                    Err((account, r)) => match r {
                    Err((account, r)) => Box::new(match r {
                        Ok(Either::A(f)) => {
                            if let Some(cmd_recv) = f.into_inner() {
                                future::ok(future::Loop::Continue(XmppProcessState {
                                    cmd_recv,
                                    signal,
                                    conn: account.into(),
                                }))
                            } else {
                                future::err(format_err!("Command receiver is gone"))
                            }
                    Err((account, r)) => match r {
                        Err(_) => future::err(format_err!("Command receiver is broken")),
                        Err(_) => Box::new(future::err(format_err!("Command receiver is broken"))),
                    },
                    }
                    Err(e) => {
                        // got cmd error, its bad
                        error!("Cmd error: {}", e);
                        future::err(e)
                    }
                }
            })
    })
    .and_then(|(opt_cmd_recv, _conn): (Option<S>, MaybeXmppConnection)| {
        if let Some(cmd_recv) = opt_cmd_recv {
            // process left commands
            info!("Stop accepting commands");
            Box::new(
                cmd_recv
                    .for_each(|_cmd| future::ok(()))
                    .map_err(|_| format_err!("cmd receiver last error")),
            ) as Box<Future<Item = (), Error = failure::Error>>
        } else {
            Box::new(future::ok(()))
        }
                        Err(_) => future::err(format_err!("Command receiver is broken")),
                        Err(_) => future::err(format_err!("Command receiver is broken")),
                    }),
                })
        })
                        }
                                future::ok(future::Loop::Break(()))
                                Box::new(future::ok(future::Loop::Break(())))
                            }
                                future::ok(future::Loop::Break(()))
                                    as Box<dyn Future<Item = _, Error = _>>
                            } else {
                                conn.process_command(cmd);
                                future::ok(future::Loop::Continue(XmppProcessState {
                                    cmd_recv,
                                    signal,
                                    conn: conn.into(),
                                Box::new(conn.process_command(&cmd).then(|r| {
                                }))
                                    future::ok(future::Loop::Continue(XmppProcessState {
                                        cmd_recv,
                                        signal,
                                        conn: match r {
                                            Ok(conn) => conn.into(),
                                            Err(account) => account.into(),
                                        },
                                    }))
                                Box::new(conn.process_command(cmd).then(|r| {
                                conn.process_command(cmd);
                                future::ok(future::Loop::Continue(XmppProcessState {
                                    cmd_recv,
                                    signal,
                                    conn: conn.into(),
                    Ok((mut conn, r)) => match r {
                                error!("Command receiver is gone");
                                future::ok(future::Loop::Break(Some(conn)))
                                conn.process_command(cmd);
                                    conn: conn.into(),
                                    as Box<dyn Future<Item = _, Error = _>>
                                future::ok(future::Loop::Break(Some(conn)))
                        }
                        Err(_) => {
                            error!("Command receiver is broken");
                            future::ok(future::Loop::Break(Some(conn)))
                        }
                    Err((account, r)) => match r {
                                future::ok(future::Loop::Break(None))
                                future::ok(future::Loop::Break(()))
                                future::ok(future::Loop::Break(None))
                                future::ok(future::Loop::Break(()))
                                future::ok(future::Loop::Break(()))
                                future::ok(future::Loop::Break(None))
                                future::ok(future::Loop::Break(()))
                                future::ok(future::Loop::Break(None))
                                future::ok(future::Loop::Break(()))
                                future::ok(future::Loop::Break(()))
                                future::ok(future::Loop::Break(None))
                                future::ok(future::Loop::Break(None))
                                future::ok(future::Loop::Break(()))
                            }
                                future::ok(future::Loop::Break(None))
                    Err((account, r)) => Box::new(match r {
                        Ok(Either::A(f)) => {
                            if let Some(cmd_recv) = f.into_inner() {
                                future::ok(future::Loop::Continue(XmppProcessState {
                                    cmd_recv,
                                    signal,
                                    conn: account.into(),
                                }))
                            } else {
                                future::err(format_err!("Command receiver is gone"))
                            }
                        }
                        Ok(Either::B((cmd, cmd_recv))) => {
                            if let Some(_cmd) = cmd {
                                error!("Xmpp connection broken while get command");
                                future::ok(future::Loop::Continue(XmppProcessState {
                                    cmd_recv,
                                    signal,
                                    conn: account.into(),
                                }))
                            } else {
                    Err((account, r)) => match r {
                        Err(_) => future::err(format_err!("Command receiver is broken")),
                        Err(_) => future::err(format_err!("Command receiver is broken")),
                        Err(_) => {
                            error!("Command receiver is broken");
                            future::ok(future::Loop::Break(Some(conn)))
                        }
                        Err(_) => Box::new(future::err(format_err!("Command receiver is broken"))),
                        Err(_) => future::err(format_err!("Command receiver is broken")),
                        Err(_) => {
                            error!("Command receiver is broken");
                            future::ok(future::Loop::Break(Some(conn)))
                        }
                        Err(_) => {
                            error!("Command receiver is broken");
                            future::ok(future::Loop::Break(Some(conn)))
                        }
                    },
                        }
                        Err(_) => {
                            error!("Command receiver is broken");
                            future::ok(future::Loop::Break(Some(conn)))
                        }
                        Err(_) => future::err(format_err!("Command receiver is broken")),
                        Err(_) => {
                            error!("Command receiver is broken");
                            future::ok(future::Loop::Break(Some(conn)))
                        }
                        Err(_) => future::err(format_err!("Command receiver is broken")),
                        Err(_) => future::err(format_err!("Command receiver is broken")),
                        Err(_) => {
                            error!("Command receiver is broken");
                            future::ok(future::Loop::Break(Some(conn)))
                                future::ok(future::Loop::Break(()))
                                future::ok(future::Loop::Break(Some(conn)))
                                future::ok(future::Loop::Break(()))
                                future::ok(future::Loop::Break(()))
                                future::ok(future::Loop::Break(Some(conn)))
                                future::ok(future::Loop::Break(()))
                                future::ok(future::Loop::Break(Some(conn)))
                                Box::new(future::ok(future::Loop::Break(())))
                                future::ok(future::Loop::Break(()))
                                future::ok(future::Loop::Break(Some(conn)))
                                future::ok(future::Loop::Break(Some(conn)))
                                future::ok(future::Loop::Break(()))
                            }
                                future::ok(future::Loop::Break(Some(conn)))
                                    conn: conn.into(),
                                    conn: conn.process_command(cmd),
                                conn.process_command(cmd);
                                }))
                            } else {
                                future::ok(future::Loop::Continue(XmppProcessState {
                                    cmd_recv,
                                    signal,
                                Box::new(conn.process_command(&cmd).then(|r| {
                                    future::ok(future::Loop::Continue(XmppProcessState {
                                        cmd_recv,
                                        signal,
                                        conn: match r {
                                            Ok(conn) => conn.into(),
                                            Err(account) => account.into(),
                                        },
                                    }))
                                conn.process_command(cmd);
                                future::ok(future::Loop::Continue(XmppProcessState {
                                    cmd_recv,
                                    signal,
                                    conn: conn.into(),
                        Ok(Either::B((cmd, cmd_recv))) => {
                            if let Some(cmd) = cmd {
                            }
                        }
                                future::err(format_err!("Command receiver is gone"))
                                error!("Command receiver is gone");
                                future::ok(future::Loop::Break(Some(conn)))
                                cmd_recv,
                                signal,
                        } else {
                        Ok(Either::B((cmd, cmd_recv))) => {
                            if let Some(cmd) = cmd {
                            future::ok(future::Loop::Break((None, conn.into())))
                    Err(Either::B((e, _a))) => {
                        future::err(e)
    }).and_then(
        |(opt_cmd_recv, _conn): (Option<S>, XmppConnection)| {
            if let Some(cmd_recv) = opt_cmd_recv {
                // process left commands
                info!("Stop accepting commands");
                Box::new(cmd_recv.for_each(|_cmd| future::ok(())).map_err(|_| {
                    tokio::io::Error::new(tokio::io::ErrorKind::Other, "cmd receiver last error")
                })) as Box<Future<Item = (), Error = tokio::io::Error>>
            } else {
                Box::new(future::err(tokio::io::Error::new(
                    tokio::io::ErrorKind::Other,
                    "cmd receiver gone",
                )))
            }
        },
    )
    })
    .and_then(|(opt_cmd_recv, _conn): (Option<S>, XmppConnection)| {
            Box::new(cmd_recv.for_each(|_cmd| future::ok(())).map_err(|_| {
                tokio::io::Error::new(tokio::io::ErrorKind::Other, "cmd receiver last error")
            })) as Box<Future<Item = (), Error = tokio::io::Error>>
            Box::new(future::err(tokio::io::Error::new(
                tokio::io::ErrorKind::Other,
                "cmd receiver gone",
            )))
        }
    })
            Box::new(future::err(format_err!("cmd receiver gone")))
        } else {
            Box::new(
                cmd_recv
                    .for_each(|_cmd| future::ok(()))
                    .map_err(|_| format_err!("cmd receiver last error")),
            ) as Box<Future<Item = (), Error = failure::Error>>
    }).and_then(|(opt_cmd_recv, _conn): (Option<S>, XmppConnection)| {
        if let Some(cmd_recv) = opt_cmd_recv {
            // process left commands
            info!("Stop accepting commands");
    })
        if let Some(cmd_recv) = opt_cmd_recv {
            // process left commands
            info!("Stop accepting commands");
            Box::new(
                cmd_recv
                    .for_each(|_cmd| future::ok(()))
                    .map_err(|_| format_err!("cmd receiver last error")),
            ) as Box<Future<Item = (), Error = failure::Error>>
        } else {
        }
    })
            Box::new(future::err(format_err!("cmd receiver gone")))
            Box::new(future::err(format_err!("cmd receiver gone")))
            Box::new(future::ok(()))
            Box::new(future::err(format_err!("cmd receiver gone")))
            Box::new(future::err(format_err!("cmd receiver gone")))
            Box::new(future::ok(()))
            Box::new(future::ok(()))
            Box::new(future::ok(()))
    .and_then(|(opt_cmd_recv, _conn): (Option<S>, XmppConnection)| {
    .and_then(|(opt_cmd_recv, _conn): (Option<S>, XmppConnection)| {
    .and_then(|(opt_cmd_recv, _conn): (Option<S>, MaybeXmppConnection)| {
    .and_then(|(opt_cmd_recv, _conn): (Option<S>, MaybeXmppConnection)| {
    .and_then(|(opt_cmd_recv, _conn): (Option<S>, XmppConnection)| {
    .and_then(|(opt_cmd_recv, _conn): (Option<S>, XmppConnection)| {
    .and_then(|(opt_cmd_recv, _conn): (Option<S>, MaybeXmppConnection)| {
        if let Some(cmd_recv) = opt_cmd_recv {
            // process left commands
            info!("Stop accepting commands");
            Box::new(
                cmd_recv
                    .for_each(|_cmd| future::ok(()))
                    .map_err(|_| format_err!("cmd receiver last error")),
            ) as Box<Future<Item = (), Error = failure::Error>>
        } else {
            Box::new(future::ok(()))
        }
    .and_then(|(opt_cmd_recv, _conn): (Option<S>, MaybeXmppConnection)| {
    .and_then(|(opt_cmd_recv, _conn): (Option<S>, MaybeXmppConnection)| {
    }).and_then(
                // process left commands
                info!("Stop accepting commands");
                Box::new(cmd_recv.for_each(|_cmd| future::ok(())).map_err(|_| {
                    tokio::io::Error::new(tokio::io::ErrorKind::Other, "cmd receiver last error")
                })) as Box<Future<Item = (), Error = tokio::io::Error>>
            } else {
                Box::new(future::err(tokio::io::Error::new(
                    tokio::io::ErrorKind::Other,
                    "cmd receiver gone",
                )))
            }
        },
    )
                cmd_recv.close();
        |(opt_cmd_recv, _conn): (Option<S>, XmppConnection)| {
            if let Some(cmd_recv) = opt_cmd_recv {
        |(opt_cmd_recv, _conn): (Option<Receiver<XmppCommand>>, XmppConnection)| {
            if let Some(mut cmd_recv) = opt_cmd_recv {
                        Box::new(future::err(format_err!("Cmd error")))
                            as Box<Future<Item = _, Error = _>>
                        future::err(format_err!("Cmd error"))
                        Box::new(future::err(tokio::io::Error::new(
                            tokio::io::ErrorKind::Other,
                            "Cmd error",
                        ))) as Box<Future<Item = _, Error = _>>
                        future::err(format_err!("Cmd error"))
                        Box::new(future::err(format_err!("Cmd error")))
                            as Box<Future<Item = _, Error = _>>
                        future::err(format_err!("Cmd error"))
                        future::err(e)
                        Box::new(future::err(format_err!("Cmd error")))
                            as Box<Future<Item = _, Error = _>>
                        future::err(e)
                        Box::new(future::err(format_err!("Cmd error")))
                            as Box<Future<Item = _, Error = _>>
                        Box::new(future::err(format_err!("Cmd error")))
                            as Box<Future<Item = _, Error = _>>
                        future::err(e)
                        future::err(format_err!("Cmd error"))
                        future::err(format_err!("Cmd error"))
                        future::err(e)
                    }
                }
            })
                        Box::new(future::err(tokio::io::Error::new(
                            tokio::io::ErrorKind::Other,
                            "Cmd error",
                        ))) as Box<Future<Item = _, Error = _>>
                    }
                    Err(e) => {
                        // got cmd error, its bad
                        error!("Cmd error: {}", e);
                        future::err(e)
                    }
                }
            })
    })
    .and_then(|(opt_cmd_recv, _conn): (Option<S>, MaybeXmppConnection)| {
        if let Some(cmd_recv) = opt_cmd_recv {
            // process left commands
            info!("Stop accepting commands");
            Box::new(
                cmd_recv
                    .for_each(|_cmd| future::ok(()))
                    .map_err(|_| format_err!("cmd receiver last error")),
            ) as Box<Future<Item = (), Error = failure::Error>>
        } else {
            Box::new(future::ok(()))
        }
                        Ok(Either::B((cmd, cmd_recv))) => {
                            if let Some(_cmd) = cmd {
                                info!("Got command");
                                future::ok(future::Loop::Continue(XmppProcessState {
                                    cmd_recv,
                                    signal,
                                    conn: conn.into(),
                                }))
                            } else {
                                future::ok(future::Loop::Break(()))
                            }
                        }
                        Err(_) => future::err(format_err!("Command receiver is broken")),
                    },
                    Err((account, r)) => match r {
                        Ok(Either::A(f)) => {
                            if let Some(cmd_recv) = f.into_inner() {
                                future::ok(future::Loop::Continue(XmppProcessState {
                                    cmd_recv,
                                    signal,
                                    conn: account.into(),
                                }))
                            } else {
                                future::err(format_err!("Command receiver is gone"))
                            }
                        }
                        Ok(Either::B((cmd, cmd_recv))) => {
                            if let Some(_cmd) = cmd {
                                error!("Xmpp connection broken while get command");
                                future::ok(future::Loop::Continue(XmppProcessState {
                                    cmd_recv,
                                    signal,
                                    conn: account.into(),
                                }))
                            } else {
                                future::ok(future::Loop::Break(()))
                            }
                        }
                        Err(_) => future::err(format_err!("Command receiver is broken")),
                    },
                })
        })
                        Ok(Either::B((cmd, cmd_recv))) => {
                            if let Some(_cmd) = cmd {
                                error!("Xmpp connection broken while get command");
                                future::ok(future::Loop::Continue(XmppProcessState {
                                    cmd_recv,
                                    signal,
                                    conn: account.into(),
                                }))
                            } else {
                                future::ok(future::Loop::Break(()))
                            }
                    Err(e) => {
                        // got cmd error, its bad
                        error!("Cmd error: {}", e);
                            future::err(format_err!("Command receiver is gone"))
                        })
                            as Box<dyn Future<Item = _, Error = _>>,
                            future::ok(future::Loop::Break((None, conn.into())))
                            future::err(format_err!("Command receiver is gone"))
                        })
                            as Box<dyn Future<Item = _, Error = _>>,
                        Ok(Either::B((cmd, cmd_recv))) => {
                            if let Some(cmd) = cmd {
                                Box::new(conn.process_command(&cmd).then(|r| {
                                    future::ok(future::Loop::Continue(XmppProcessState {
                                        cmd_recv,
                                        signal,
                                        conn: match r {
                                            Ok(conn) => conn.into(),
                                            Err(account) => account.into(),
                                        },
                                    }))
                                }))
                                    as Box<dyn Future<Item = _, Error = _>>
                            } else {
                                Box::new(future::ok(future::Loop::Break(())))
                            }
                        }
                        Err(_) => Box::new(future::err(format_err!("Command receiver is broken"))),
                    },
                    Err((account, r)) => Box::new(match r {
                        Ok(Either::A(f)) => {
                            if let Some(cmd_recv) = f.into_inner() {
                                future::ok(future::Loop::Continue(XmppProcessState {
                                    cmd_recv,
                                    signal,
                                    conn: account.into(),
                                }))
                            } else {
                                future::err(format_err!("Command receiver is gone"))
                            }
                                conn.into(),
                            )))
                                conn: conn.into(),
                            }))
                                conn.into(),
                            )))
                                conn: conn.into(),
                            }))
                    Ok((mut conn, r)) => match r {
                        Ok(Either::A(f)) => {
                            if let Some(cmd_recv) = f.into_inner() {
                                future::ok(future::Loop::Continue(XmppProcessState {
                                    cmd_recv,
                                    signal,
                                    conn: conn.into(),
                                }))
                            } else {
                                future::err(format_err!("Command receiver is gone"))
                            }
                        }
                    Ok((mut conn, r)) => match r {
                        Ok(Either::A(f)) => {
                            if let Some(cmd_recv) = f.into_inner() {
                                future::ok(future::Loop::Continue(XmppProcessState {
                                    cmd_recv,
                                    signal,
                                    conn: conn.into(),
                                }))
                            } else {
                                error!("Command receiver is gone");
                                future::ok(future::Loop::Break(Some(conn)))
                                future::ok(future::Loop::Break(Some(conn)))
                        Err(_) => {
                            error!("Command receiver is broken");
                            future::ok(future::Loop::Break(Some(conn)))
                        }
                                future::ok(future::Loop::Break(None))
    })
    .and_then(|opt_conn| {
        if let Some(conn) = opt_conn {
            Box::new(conn.shutdown()) as Box<dyn Future<Item = (), Error = _>>
        } else {
            Box::new(future::ok(()))
        }
    })
    })
    .and_then(|opt_conn| {
        if let Some(conn) = opt_conn {
            Box::new(conn.shutdown()) as Box<dyn Future<Item = (), Error = _>>
        } else {
            Box::new(future::ok(()))
        }
    }
                            }
                        }
                        Err(_) => future::err(format_err!("Command receiver is broken")),
                    },
                })
        })
                                future::ok(future::Loop::Break(()))
                                future::ok(future::Loop::Break(None))
                    },
                    Err((account, r)) => match r {
                        Ok(Either::A(f)) => {
                            if let Some(cmd_recv) = f.into_inner() {
                                future::ok(future::Loop::Continue(XmppProcessState {
                                    cmd_recv,
                                    signal,
                                    conn: account.into(),
                                }))
                            } else {
                                future::err(format_err!("Command receiver is gone"))
                            }
                        }
                        Ok(Either::B((cmd, cmd_recv))) => {
                            if let Some(_cmd) = cmd {
                                error!("Xmpp connection broken while get command");
                                future::ok(future::Loop::Continue(XmppProcessState {
                                    cmd_recv,
                                    signal,
                                    conn: account.into(),
                                }))
                            } else {
                        Err(_) => future::err(format_err!("Command receiver is broken")),
                        Err(_) => {
                            error!("Command receiver is broken");
                            future::ok(future::Loop::Break(Some(conn)))
                        }
                            }
                        }
                                future::ok(future::Loop::Break(()))
                                future::ok(future::Loop::Break(Some(conn)))
                                future::ok(future::Loop::Continue(XmppProcessState {
                                    cmd_recv,
                                    signal,
                                    conn: conn.into(),
                                }))
                            } else {
    loop {
        match maybe_conn.connect(signal.clone()).await {
            Ok(conn) => match conn.processing(|_, _| Ok(false), recv_future, false).await {
                (Ok(conn), Either::Left(f)) => {
                    maybe_conn = conn.into();
                    recv_future = f;
                }
                (Ok(conn), Either::Right(Some(cmd))) => {
                    info!("Get command: {:?}", cmd);
                    maybe_conn = conn.process_command(cmd);
                    recv_future = cmd_recv.next();
                }
                (Err(acc), Either::Left(f)) => {
                    maybe_conn = acc.into();
                    recv_future = f;
                }
                (Err(acc), Either::Right(Some(cmd))) => {
                    warn!("Get command for broken connection: {:?}", cmd);
                    maybe_conn = acc.into();
                    recv_future = cmd_recv.next();
                }
            },
            Err(e) => break Err(e),
                (Err(_), Either::Right(None)) => break Ok(()),
                (Err(acc), Either::Right(None)) => break Ok(()),
                (Err(acc), Either::Right(None)) => break Ok(()),
                (Ok(_), Either::Right(None)) => break Ok(()),
                (Ok(conn), Either::Right(None)) => break Ok(()),
                (Ok(conn), Either::Right(None)) => break Ok(()),
                            }
                        }
                        Ok(Either::B((cmd, cmd_recv))) => {
                            if let Some(cmd) = cmd {
                                conn.process_command(cmd);
                                future::err(format_err!("Command receiver is gone"))
                        }
                    Ok((conn, r)) => match r {
                        Ok(Either::A(f)) => Box::new(if let Some(cmd_recv) = f.into_inner() {
                            future::ok(future::Loop::Continue(XmppProcessState {
                    Ok((conn, r)) => match r {
                    Ok((conn, r)) => match r {
                        Ok(Either::A(f)) => Box::new(if let Some(cmd_recv) = f.into_inner() {
                            future::ok(future::Loop::Continue(XmppProcessState {
                                cmd_recv,
                                signal,
                                conn: conn.into(),
                            }))
                        } else {
                            future::err(format_err!("Command receiver is gone"))
                        })
                            as Box<dyn Future<Item = _, Error = _>>,
                                error!("Command receiver is gone");
                                future::ok(future::Loop::Break(Some(conn)))
                    Ok((mut conn, r)) => match r {
                        Ok(Either::A(f)) => {
                            if let Some(cmd_recv) = f.into_inner() {
                                future::ok(future::Loop::Continue(XmppProcessState {
                                    cmd_recv,
                                    signal,
                                    conn: conn.into(),
                                }))
                            } else {
                                future::err(format_err!("Command receiver is gone"))
                            }
                        }
                    Ok((mut conn, r)) => match r {
                        Ok(Either::A(f)) => {
                            if let Some(cmd_recv) = f.into_inner() {
                                future::ok(future::Loop::Continue(XmppProcessState {
                                    cmd_recv,
                                    signal,
                                    conn: conn.into(),
                                }))
                            } else {
                            }
                        }
                                error!("Command receiver is gone");
                                future::ok(future::Loop::Break(Some(conn)))
                                future::err(format_err!("Command receiver is gone"))
                                future::err(format_err!("Command receiver is gone"))
                                error!("Command receiver is gone");
                                future::ok(future::Loop::Break(Some(conn)))
                                future::err(format_err!("Command receiver is gone"))
                                error!("Command receiver is gone");
                                future::ok(future::Loop::Break(Some(conn)))
                                future::err(format_err!("Command receiver is gone"))
                                error!("Command receiver is gone");
                                future::ok(future::Loop::Break(Some(conn)))
                                future::err(format_err!("Command receiver is gone"))
                                error!("Command receiver is gone");
                                future::ok(future::Loop::Break(Some(conn)))
                        }
}
                info!("xmpp connected!");
                cmd_recv
                    .into_future()
                    .map_err(|_| {
                        error!("Got error on recv cmd");
                    .map(|f| (f, conn))
            }))
                    Ok(Either::A((_x, b))) => {
                        info!("Got signal");
                        // got signal, breaks
                        Box::new(b.map(|b| future::Loop::Break((Some((b.0).1), b.1))))
                            as Box<Future<Item = _, Error = _>>
                    }
                    Ok(Either::B((x, a))) => {
                        info!("Got cmd");
                        // got cmd, continue
                        Box::new(future::ok(future::Loop::Continue(XmppState::new(
                            (x.0).1,
                            a,
                            x.1,
                        )))) as Box<Future<Item = _, Error = _>>
                    Err(Either::A((e, b))) => {
                        // got signal error, breaks
                        error!("Signal error: {}", e);
                        Box::new(b.map(|b| future::Loop::Break((Some((b.0).1), b.1))))
                            as Box<Future<Item = _, Error = _>>
                    }
                    }
                    Err(Either::B((e, _a))) => {
                    Err(Either::B((e, _a))) => {
                    Err(e) => {
                    Ok(Either::B((x, a))) => {
                        info!("Got cmd");
                        // got cmd, continue
                        Box::new(future::ok(future::Loop::Continue(XmppState::new(
                            (x.0).1,
                            a,
                            x.1.into(),
                        )))) as Box<Future<Item = _, Error = _>>
                    }
                    Err(Either::A((e, b))) => {
                        // got signal error, breaks
                        error!("Signal error: {}", e);
                        Box::new(b.map(|b| future::Loop::Break((Some((b.0).1), b.1.into()))))
                            as Box<Future<Item = _, Error = _>>
                    Err(e) => {
                    Ok(Either::A((_x, b))) => {
                        info!("Got signal");
                        // got signal, breaks
                        Box::new(b.map(|b| future::Loop::Break((Some((b.0).1), b.1))))
                            as Box<Future<Item = _, Error = _>>
                    Ok(Either::B((x, a))) => {
                        info!("Got cmd");
                        // got cmd, continue
                        Box::new(future::ok(future::Loop::Continue(XmppState::new(
                            (x.0).1,
                            a,
                            x.1,
                        )))) as Box<Future<Item = _, Error = _>>
                    }
                    Err(Either::A((e, b))) => {
                        // got signal error, breaks
                        error!("Signal error: {}", e);
                        Box::new(b.map(|b| future::Loop::Break((Some((b.0).1), b.1))))
                            as Box<Future<Item = _, Error = _>>
                    Err(e) => {
                    Err(Either::B((e, _a))) => {
                    Ok((cmd, cmd_recv, conn)) => {
                        if let Some(_cmd) = cmd {
                            info!("Got cmd");
                            // got cmd, continue
                            future::ok(future::Loop::Continue(XmppState::new(
                                cmd_recv,
                                signal,
                                conn.into(),
                            )))
                        } else {
                            future::ok(future::Loop::Break((None, conn.into())))
                        }
                    Ok(Either::A((_x, b))) => {
                        info!("Got signal");
                        // got signal, breaks
                        Box::new(b.map(|b| future::Loop::Break((Some((b.0).1), b.1.into()))))
                            as Box<Future<Item = _, Error = _>>
                    }
                    Ok((cmd, cmd_recv, conn)) => {
                        if let Some(_cmd) = cmd {
                            info!("Got cmd");
                            // got cmd, continue
                            future::ok(future::Loop::Continue(XmppState::new(
                                cmd_recv,
                                signal,
                                conn.into(),
                            )))
                        } else {
                            future::ok(future::Loop::Break((None, conn.into())))
                        }
                    Ok((cmd, cmd_recv, conn)) => {
                        if let Some(_cmd) = cmd {
                            info!("Got cmd");
                            // got cmd, continue
                            future::ok(future::Loop::Continue(XmppState::new(
                                cmd_recv,
                                signal,
                                conn.into(),
                            )))
                        } else {
                            future::ok(future::Loop::Break((None, conn.into())))
                        }
                    Ok((cmd, cmd_recv, conn)) => {
                        if let Some(_cmd) = cmd {
                            info!("Got cmd");
                            // got cmd, continue
                                cmd_recv,
                                signal,
                                conn.into(),
                            )))
                        } else {
                            future::ok(future::Loop::Break((None, conn.into())))
                            future::ok(future::Loop::Break((None, conn.into())))
                            future::ok(future::Loop::Break(()))
                            future::ok(future::Loop::Continue(XmppProcessState::new(
                            future::ok(future::Loop::Continue(XmppState::new(
                            future::ok(future::Loop::Continue(XmppState::new(
                    Ok(Either::A((_x, b))) => {
                        info!("Got signal");
                        // got signal, breaks
                            as Box<Future<Item = _, Error = _>>
                    }
                    Ok(Either::B((x, a))) => {
                        info!("Got cmd");
                        // got cmd, continue
                        Box::new(future::ok(future::Loop::Continue(XmppState::new(
                            (x.0).1,
                            a,
                        )))) as Box<Future<Item = _, Error = _>>
                    }
                    Err(Either::A((e, b))) => {
                        // got signal error, breaks
                        error!("Signal error: {}", e);
                            as Box<Future<Item = _, Error = _>>
                    }
                        Box::new(b.map(|b| future::Loop::Break((Some((b.0).1), b.1))))
                        Box::new(b.map(|b| future::Loop::Break((Some((b.0).1), b.1.into()))))
                        Box::new(b.map(|b| future::Loop::Break((Some((b.0).1), b.1))))
                        Box::new(b.map(|b| future::Loop::Break((Some((b.0).1), b.1.into()))))
                        Box::new(b.map(|b| future::Loop::Break((Some((b.0).1), b.1))))
                            x.1,
                            x.1.into(),
                            x.1,
                            x.1.into(),
                            x.1,
                        Box::new(b.map(|b| future::Loop::Break((Some((b.0).1), b.1))))
                        Box::new(b.map(|b| future::Loop::Break((Some((b.0).1), b.1.into()))))
                        Box::new(b.map(|b| future::Loop::Break((Some((b.0).1), b.1))))
                        Box::new(b.map(|b| future::Loop::Break((Some((b.0).1), b.1.into()))))
                        Box::new(b.map(|b| future::Loop::Break((Some((b.0).1), b.1))))
                    })
                    .map(|f| (f, conn))
            }))
            .then(|r| {
                    .map(|f| (f, conn))
            }))
                    .map(|(cmd, cmd_recv)| (cmd, cmd_recv, conn))
            })
                    .map(|f| (f, conn))
            }))
            .then(|r| {
                    .map(|f| (f, conn))
            }))
                    .map(|(cmd, cmd_recv)| (cmd, cmd_recv, conn))
            })
                    .map(|(cmd, cmd_recv)| (cmd, cmd_recv, conn))
            })
                    .map(|(cmd, cmd_recv)| (cmd, cmd_recv, conn))
            })
                match r {
                    }).map(|f| (f, conn))
            })).then(|r| {
                        tokio::io::Error::new(tokio::io::ErrorKind::Other, "Receive cmd error")
                    }).map(|f| (f, conn))
            })).then(|r| {
                        format_err!("Receive cmd error")
                    })
                        format_err!("Receive cmd error")
                        tokio::io::Error::new(tokio::io::ErrorKind::Other, "Receive cmd error")
        signal
            .select2(conn.connect().and_then(|conn| {
                info!("xmpp connected!");
                cmd_recv
                    .into_future()
                    .map_err(|_| {
                        error!("Got error on recv cmd");
                        tokio::io::Error::new(tokio::io::ErrorKind::Other, "Receive cmd error")
                    }).map(|f| (f, conn))
            })).then(|r| {
                match r {
                    Ok(Either::A((_x, b))) => {
                        info!("Got signal");
                        // got signal, breaks
                        Box::new(b.map(|b| future::Loop::Break((Some((b.0).1), b.1))))
                            as Box<Future<Item = _, Error = _>>
                    }
                    Ok(Either::B((x, a))) => {
                        info!("Got cmd");
                        // got cmd, continue
                        Box::new(future::ok(future::Loop::Continue(XmppState::new(
                            (x.0).1,
                            a,
                            x.1,
                        )))) as Box<Future<Item = _, Error = _>>
                    }
                    Err(Either::A((e, b))) => {
                        // got signal error, breaks
                        error!("Signal error: {}", e);
                        Box::new(b.map(|b| future::Loop::Break((Some((b.0).1), b.1))))
                            as Box<Future<Item = _, Error = _>>
                    }
                    Err(Either::B((e, _a))) => {
                        // got cmd error, its bad
                        error!("Cmd error: {}", e);
                        Box::new(future::err(tokio::io::Error::new(
                            tokio::io::ErrorKind::Other,
                            "Cmd error",
                        ))) as Box<Future<Item = _, Error = _>>
                    }
                }
            })
    }).and_then(
        |(opt_cmd_recv, _conn): (Option<S>, XmppConnection)| {
            if let Some(cmd_recv) = opt_cmd_recv {
                // process left commands
                info!("Stop accepting commands");
                Box::new(cmd_recv.for_each(|_cmd| future::ok(())).map_err(|_| {
                    tokio::io::Error::new(tokio::io::ErrorKind::Other, "cmd receiver last error")
                })) as Box<Future<Item = (), Error = tokio::io::Error>>
            } else {
                Box::new(future::err(tokio::io::Error::new(
                    tokio::io::ErrorKind::Other,
                    "cmd receiver gone",
                )))
            }
        },
    )
        signal
            .select2(conn.connect().and_then(|conn| {
        conn.connect(signal.clone())
            .and_then(|conn| {
                info!("xmpp connected!");
                cmd_recv
                    .into_future()
                    .map_err(|_| {
                        error!("Got error on recv cmd");
                        format_err!("Receive cmd error")
                    })
                    .map(|(cmd, cmd_recv)| (cmd, cmd_recv, conn))
            })
            .then(|r| {
                match r {
                    Ok((cmd, cmd_recv, conn)) => {
                        if let Some(_cmd) = cmd {
                            info!("Got cmd");
                            // got cmd, continue
                            future::ok(future::Loop::Continue(XmppState::new(
        conn.connect(signal.clone()).and_then(|conn| {
            info!("xmpp connected!");
            conn.processing(|_, _| Ok(false), cmd_recv.into_future())
                .then(|r| match r {
                    Ok((mut conn, r)) => match r {
                        Ok(Either::A(f)) => {
                            if let Some(cmd_recv) = f.into_inner() {
                                future::ok(future::Loop::Continue(XmppProcessState {
                                    cmd_recv,
                                    signal,
                                    conn: conn.into(),
                                }))
                            } else {
        signal
            .select2(conn.connect().and_then(|conn| {
        conn.connect(signal.clone()).and_then(|conn| {
            info!("xmpp connected!");
            conn.processing(|_, _| Ok(false), cmd_recv.into_future())
                .then(|r| match r {
        conn.connect(signal.clone())
            .and_then(|conn| {
                info!("xmpp connected!");
                cmd_recv
                    .into_future()
                    .map_err(|_| {
                        error!("Got error on recv cmd");
                        format_err!("Receive cmd error")
                    })
                    .map(|(cmd, cmd_recv)| (cmd, cmd_recv, conn))
            })
            .then(|r| {
                match r {
                    Ok((cmd, cmd_recv, conn)) => {
                        if let Some(_cmd) = cmd {
                            info!("Got cmd");
                            // got cmd, continue
                            future::ok(future::Loop::Continue(XmppState::new(
        conn.connect(signal.clone())
            .and_then(|conn| {
        signal
            .select2(conn.connect().and_then(|conn| {
        conn.connect(signal.clone()).and_then(|conn| {
            info!("xmpp connected!");
            conn.processing(|_, _| Ok(false), cmd_recv.into_future())
                .then(|r| match r {
                    Ok((conn, r)) => match r {
                        Ok(Either::A(f)) => {
                            if let Some(cmd_recv) = f.into_inner() {
                                future::ok(future::Loop::Continue(XmppProcessState {
                                    cmd_recv,
                                    signal,
                                    conn: conn.into(),
                                }))
                            } else {
                                future::err(format_err!("Command receiver is gone"))
                            }
        conn.connect(signal.clone())
            .and_then(|conn| {
                info!("xmpp connected!");
                cmd_recv
                    .into_future()
                    .map_err(|_| {
                        error!("Got error on recv cmd");
                        format_err!("Receive cmd error")
                    })
                    .map(|(cmd, cmd_recv)| (cmd, cmd_recv, conn))
            })
            .then(|r| {
                match r {
                    Ok((cmd, cmd_recv, conn)) => {
                        if let Some(_cmd) = cmd {
                            info!("Got cmd");
                            // got cmd, continue
                            future::ok(future::Loop::Continue(XmppState::new(
                                cmd_recv,
                                signal,
                                conn.into(),
                            )))
                        } else {
                            future::ok(future::Loop::Break((None, conn.into())))
        conn.connect(signal.clone())
            .and_then(|conn| {
        conn.connect(signal.clone()).and_then(|conn| {
            info!("xmpp connected!");
            conn.processing(|_, _| Ok(false), cmd_recv.into_future())
                .then(|r| match r {
                    Ok((conn, r)) => match r {
                        Ok(Either::A(f)) => Box::new(if let Some(cmd_recv) = f.into_inner() {
                            future::ok(future::Loop::Continue(XmppProcessState {
        conn.connect(signal.clone())
            .and_then(|conn| {
        conn.connect(signal.clone()).and_then(|conn| {
            info!("xmpp connected!");
            conn.processing(|_, _| Ok(false), cmd_recv.into_future())
                .then(|r| match r {
        conn.connect(signal.clone())
            .and_then(|conn| {
        signal
            .select2(conn.connect().and_then(|conn| {
    let conn = XmppConnection::new(account);
    future::loop_fn(XmppState::new(cmd_recv, signal, conn), |s| {
        let XmppState {
    future::loop_fn(XmppState::new(cmd_recv, signal, conn), |s| {
        let XmppState {
    future::loop_fn(XmppProcessState::new(cmd_recv, signal, conn), |s| {
        let XmppProcessState {
    future::loop_fn(XmppProcessState::new(cmd_recv, signal, conn), |s| {
        let XmppProcessState {
    future::loop_fn(XmppState::new(cmd_recv, signal, conn), |s| {
        let XmppState {
    future::loop_fn(XmppState::new(cmd_recv, signal, conn), |s| {
        let XmppState {
    future::loop_fn(XmppProcessState::new(cmd_recv, signal, conn), |s| {
        let XmppProcessState {
    future::loop_fn(XmppState::new(cmd_recv, signal, conn), |s| {
        let XmppState {
    future::loop_fn(XmppProcessState::new(cmd_recv, signal, conn), |s| {
        let XmppProcessState {
    future::loop_fn(XmppProcessState::new(cmd_recv, signal, conn), |s| {
        let XmppProcessState {
    future::loop_fn(XmppState::new(cmd_recv, signal, conn), |s| {
        let XmppState {
    future::loop_fn(XmppProcessState::new(cmd_recv, signal, conn), |s| {
        let XmppProcessState {
    let mut maybe_conn: MaybeXmppConnection = account.into();
    let mut recv_future = cmd_recv.next();
    let conn = XmppConnection::new(account);
    let conn = MaybeXmppConnection::new(account);
    let conn = MaybeXmppConnection::new(account);
    let conn = XmppConnection::new(account);
    let signal = signal
        .map_err(|_| tokio::io::Error::new(tokio::io::ErrorKind::Other, "Wrong shutdown signal"));
    let signal = signal.map_err(|_| format_err!("Wrong shutdown signal"));
    let conn = XmppConnection::new(account);
    let conn = MaybeXmppConnection::new(account);
    let conn = account.into();
    let signal = signal
        .map_err(|_| tokio::io::Error::new(tokio::io::ErrorKind::Other, "Wrong shutdown signal"));
    let signal = signal.map_err(|_| format_err!("Wrong shutdown signal"));
    let conn = XmppConnection::new(account);
    let conn = account.into();
    use futures_util::StreamExt;
    let conn = MaybeXmppConnection::new(account);
    let signal = signal.map_err(|_| format_err!("Wrong shutdown signal"));
    let signal = signal.map_err(|_| format_err!("Wrong shutdown signal"));
    let signal = signal.map_err(|_| format_err!("Wrong shutdown signal"));
    let conn = account.into();
    let conn = MaybeXmppConnection::new(account);
    let conn = MaybeXmppConnection::new(account);
    let conn = account.into();
    let conn = account.into();
    let conn = MaybeXmppConnection::new(account);
    let signal = signal
        .map_err(|_| tokio::io::Error::new(tokio::io::ErrorKind::Other, "Wrong shutdown signal"));
    S: stream::Stream<Item = XmppCommand> + 'static,
    F: future::Future<Item = ()> + 'static,
    S: stream::Stream<Item = XmppCommand> + 'static
    F: future::Future<Item = ()> + 'static,
    F: future::Future + Clone + 'static,
    F: future::Future + Clone + 'static,
    <F as hyper::rt::Future>::Error: std::fmt::Display + Into<failure::Error> + Send,
    S: stream::Stream<Item = XmppCommand> + 'static,
    F: future::Future<Item = ()> + 'static,
    F: std::future::Future<Output = ()> + Clone + 'static,
    S: tokio::stream::Stream<Item = XmppCommand> + Unpin,
    F: future::Future<Item = ()> + 'static,
    F: future::Future + Clone + 'static,
    <F as hyper::rt::Future>::Error: std::fmt::Display + Into<failure::Error> + Send,
    F: future::Future + Clone + 'static,
    <F as hyper::rt::Future>::Error: std::fmt::Display + Into<failure::Error> + Send,
    F: future::Future + Clone + 'static,
    <F as hyper::rt::Future>::Error: std::fmt::Display + Into<failure::Error> + Send,
    F: future::Future<Item = ()> + 'static,
) -> impl future::Future<Item = (), Error = tokio::io::Error>
) -> impl future::Future<Item = (), Error = failure::Error>
) -> impl future::Future<Item = (), Error = tokio::io::Error>
) -> Result<(), failure::Error>
) -> impl future::Future<Item = (), Error = failure::Error>
) -> impl future::Future<Item = (), Error = failure::Error>
) -> impl future::Future<Item = (), Error = tokio::io::Error>
    cmd_recv: S,
    mut cmd_recv: S,
    cmd_recv: Receiver<XmppCommand>,
pub fn xmpp_process<F, S>(
pub async fn xmpp_process<F, S>(
pub fn xmpp_process<F>(
    fn new(cmd_recv: S, signal: F, conn: XmppConnection) -> XmppState<F, S> {
    fn new(cmd_recv: S, signal: F, conn: MaybeXmppConnection) -> XmppState<F, S> {
    fn new(cmd_recv: S, signal: F, conn: XmppConnection) -> XmppState<F, S> {
    fn new(cmd_recv: S, signal: F, conn: MaybeXmppConnection) -> XmppState<F, S> {
    fn new(cmd_recv: S, signal: F, conn: XmppConnection) -> XmppState<F, S> {
    fn new(cmd_recv: S, signal: F, conn: MaybeXmppConnection) -> XmppState<F, S> {
    fn new(cmd_recv: S, signal: F, conn: MaybeXmppConnection) -> XmppState<F, S> {
            cmd_recv,
            signal,
            conn,
        }
    }
}
        XmppState {
impl<F, S> XmppState<F, S> {
    fn new(cmd_recv: S, signal: F, conn: XmppConnection) -> XmppState<F, S> {
        XmppState {
impl<F, S> XmppState<F, S> {
    fn new(cmd_recv: S, signal: F, conn: MaybeXmppConnection) -> XmppState<F, S> {
        XmppState {
impl<F, S> XmppProcessState<F, S> {
    fn new(cmd_recv: S, signal: F, conn: MaybeXmppConnection) -> XmppProcessState<F, S> {
        XmppProcessState {
impl<F, S> XmppProcessState<F, S> {
    fn new(cmd_recv: S, signal: F, conn: MaybeXmppConnection) -> XmppProcessState<F, S> {
        XmppProcessState {
impl<F, S> XmppState<F, S> {
impl<F, S> XmppProcessState<F, S> {
    fn new(cmd_recv: S, signal: F, conn: MaybeXmppConnection) -> XmppProcessState<F, S> {
        XmppProcessState {
impl<F, S> XmppState<F, S> {
    fn new(cmd_recv: S, signal: F, conn: MaybeXmppConnection) -> XmppState<F, S> {
        XmppState {
impl<F, S> XmppState<F, S> {
    fn new(cmd_recv: S, signal: F, conn: MaybeXmppConnection) -> XmppState<F, S> {
        XmppState {
impl<F, S> XmppProcessState<F, S> {
    fn new(cmd_recv: S, signal: F, conn: MaybeXmppConnection) -> XmppProcessState<F, S> {
        XmppProcessState {
impl<F, S> XmppState<F, S> {
    fn new(cmd_recv: S, signal: F, conn: MaybeXmppConnection) -> XmppState<F, S> {
        XmppState {
impl<F, S> XmppProcessState<F, S> {
    fn new(cmd_recv: S, signal: F, conn: MaybeXmppConnection) -> XmppProcessState<F, S> {
        XmppProcessState {
impl<F, S> XmppProcessState<F, S> {
    fn new(cmd_recv: S, signal: F, conn: MaybeXmppConnection) -> XmppProcessState<F, S> {
        XmppProcessState {
impl<F> XmppState<F> {
    fn new(cmd_recv: Receiver<XmppCommand>, signal: F, conn: XmppConnection) -> XmppState<F> {
    conn: XmppConnection,
    conn: XmppConnection,
    conn: XmppConnection,
    conn: MaybeXmppConnection,
    conn: MaybeXmppConnection,
    conn: MaybeXmppConnection,
    conn: XmppConnection,
    conn: MaybeXmppConnection,
    conn: MaybeXmppConnection,
    conn: XmppConnection,
    fn process_initial_roster(&mut self, event: Event, id_init_roster: &str) -> Result<bool, ()> {
        if let Event::Stanza(s) = event {
            use try_from::TryInto;
            match s.try_into() as Result<xmpp_parsers::iq::Iq, _> {
                Ok(iq) => {
                    if let Some(id) = iq.id {
                        if 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)
                        }
                    } else {
                        error!("Iq stanza without id");
                        Err(())
                    }
                }
                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),
                })
            })
    }
pub use xmpp_connection::XmppCommand;
                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,
            })
    }
}
#[derive(Debug)]
pub enum XmppCommand {
    Chat {
        xmpp_to: xmpp_parsers::Jid,
        message: String,
    },
    Chatroom {
        muc_id: String,
        message: String,
    },
    Ping,
}
    cmd_recv: S,
#[derive(Debug)]
pub struct XmppCommand;
struct XmppState<F, S> {
struct XmppProcessState<F, S> {
    /// 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(())
            }
        }
    }
mod xmpp_connection;
use xmpp_connection::MaybeXmppConnection;
                info!("Sending muc presence... {:?}", muc_presence);
            let presence = stanzas::make_presence(&account);
            info!("Sending presence...");
            Box::new(
                sink.send(presence)
                    .map_err(|e| {
                        error!("Error on send self-presence: {}", e);
                        "Cann't send self-presence".to_owned()
                    }).join(
                        future::loop_fn((account.clone(), stream), |(account, stream)| {
                            stream
                                .into_future()
                                .map_err(|(e, _)| {
                                    error!("Error on reading self-presence: {}", e);
                                    "Cann't read self-presence".to_owned()
                                }).and_then(|(event, stream)| match event {
                                    Some(event) => {
                                        if let tokio_xmpp::Event::Stanza(e) = event {
                                            info!("Get stanza: {:?}", e);
                                            if e.name() == "presence"
                                                && e.attr("from")
                                                    .map_or(false, |f| f == account.jid)
                                                && e.attr("to").map_or(false, |f| f == account.jid)
                                            {
                                                info!("Self presence");
                                                future::ok(future::Loop::Break(stream))
                                            } else {
                                                future::ok(future::Loop::Continue((
                                                    account, stream,
                                                )))
                                            }
                                        } else {
                                            future::err("Got wrong event".to_owned())
                                        }
                                    }
                                    None => future::err("Got closed stream".to_owned()),
                                })
                        }).map_err(|e| format!("waiting self-presence: {}", e)),
                    ).then(|r| match r {
                        Err(e) => {
                            error!("Self-presence waiting error: {}", e);
                            future::err(account)
                        }
                        Ok(inner) => future::ok(XmppConnection {
                            account,
                            inner: Some(inner),
                        }),
                    }),
            )
        } else {
            warn!("Don't gen connection on self-presence");
            Box::new(future::err(account)) as Box<Future<Item = _, Error = _>>
        }
    }
}
pub use xmpp_connection::XmppCommand;
    /// 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
    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 xmpp = XmppConnection {
                                            state: XmppState { client, data },
                                            account,
                                        };
                                        Box::new(xmpp.xmpp_processing(&event).then(|r| match r {
                                            Ok(mut xmpp) => {
                                                match stop_condition(&mut xmpp, event) {
                                                    Ok(true) => future::ok(future::Loop::Break((
                                                        xmpp,
                                                        Ok(Either::A(b)),
                                                    ))),
                                                    Ok(false) => {
                                                        future::ok(future::Loop::Continue((
                                                            xmpp,
                                                            b,
                                                            stop_condition,
                                                        )))
                                                    }
                                                    Err(_e) => future::err((
                                                        xmpp.account,
                                                        Ok(Either::A(b)),
                                                    )),
                                                }
                                            }
                                            Err(account) => {
                                                future::err((account, Ok(Either::A(b))))
                                            }
                                        }))
                                            as Box<dyn Future<Item = _, Error = _>>
                                    } else {
                                        Box::new(future::err((account, Ok(Either::A(b)))))
                                    }
                                }
                                Ok(Either::B((t, a))) => {
                                    Box::new(if let Some(client) = a.into_inner() {
                                        future::ok(future::Loop::Break((
                                            XmppConnection {
                                                state: XmppState { client, data },
                                                account,
                                            },
                                            Ok(Either::B(t)),
                                        )))
                                    } else {
                                        future::err((account, Ok(Either::B(t))))
                                    })
                                }
                                Err(Either::A((e, b))) => {
                                    warn!("XMPP error: {}", e.0);
                                    Box::new(future::err((account, Ok(Either::A(b)))))
                                }
                                Err(Either::B((e, a))) => {
                                    Box::new(if let Some(client) = a.into_inner() {
                                        future::ok(future::Loop::Break((
                                            XmppConnection {
                                                state: XmppState { client, data },
                                                account,
                                            },
                                            Err(e),
                                        )))
                                    } else {
                                        future::err((account, Err(e)))
                                    })
                                }
                            }),
                    )
                }
            },
        )
    }
    fn self_presence(self) -> impl Future<Item = Self, Error = std::rc::Rc<config::Account>> {
        let XmppConnection { account, inner } = self;
        if let Some((sink, stream)) = inner {
            use tokio::prelude::Sink;
mod xmpp_connection;
use xmpp_connection::MaybeXmppConnection;
struct XmppConnection {
    account: std::rc::Rc<config::Account>,
    state: 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
    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
    fn xmpp_processing(
        mut self,
        event: &Event,
    ) -> impl Future<Item = Self, Error = std::rc::Rc<config::Account>> {
        match event {
            Event::Stanza(stanza) => {
                info!("Incoming xmpp event: {:?}", stanza);
                let stanza = stanza.clone();
                use try_from::TryInto;
                if let Some(iq) = stanza.try_into().ok() as Option<xmpp_parsers::iq::Iq> {
                    if let Some(id) = iq.id {
                        if let Some((_, jid)) =
                            self.state.data.pending_add_roster_ids.remove_entry(&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
                                );
                            }
                        }
                    }
                    if let xmpp_parsers::iq::IqType::Set(element) = iq.payload {
                        if let Some(roster) =
                            element.try_into().ok() as Option<xmpp_parsers::roster::Roster>
                        {
                            for i in roster.items {
                                if let Some(ref mut rdata) = self.state.data.roster.get_mut(&i.jid)
                                {
                                    info!("Update {} in roster", i.jid);
                                    rdata.0 = i.subscription;
                                    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);
                            }
                        }
                    }
                }
                future::ok(self)
            }
            Event::Online => future::ok(self),
            e => {
                warn!("Unexpected event {:?}", e);
                future::err(self.account)
            }
        }
    }
    /// get connection and wait for online status and set presence
    /// returns error if something went wrong
    fn online(
        (sink, stream): (stream::SplitSink<Client>, stream::SplitStream<Client>),
        account: std::rc::Rc<config::Account>,
    ) -> impl Future<Item = Self, Error = std::rc::Rc<config::Account>> {
        Box::new(future::loop_fn(
            (sink, stream, account),
            |(sink, stream, account)| {
                stream.into_future().then(|r| match r {
                    Ok((event, stream)) => match event {
                        Some(Event::Online) => {
                            info!("Online");
                            future::ok(future::Loop::Break(XmppConnection {
                                account,
                                inner: Some((sink, stream)),
                            }))
                        }
                        Some(Event::Stanza(s)) => {
                            info!("xmpp stanza: {:?}", s);
                            future::ok(future::Loop::Continue((sink, stream, account)))
                        }
                        _ => {
                            warn!("Disconnected");
                            future::err(account)
                        }
                    },
                    Err((e, _)) => {
                        error!("xmpp receive error: {}", e);
                        future::err(account)
                    }
                })
            },
        ))
    }
struct XmppState<F, S> {
struct XmppProcessState<F, S> {
struct XmppState<F, S> {
struct XmppProcessState<F, S> {
struct XmppState<F, S> {
struct XmppState<F, S> {
struct XmppProcessState<F, S> {
struct XmppState<F, S> {
struct XmppProcessState<F, S> {
struct XmppProcessState<F, S> {
struct XmppState<F> {
    cmd_recv: Receiver<XmppCommand>,
pub struct XmppCommand {
    pub xmpp_to: String,
}
pub struct XmppCommand;
pub struct XmppCommand {
    pub xmpp_to: xmpp_parsers::Jid,
    pub message: String,
}
pub struct XmppCommand {
    pub xmpp_to: xmpp_parsers::Jid,
    pub message: String,
}
    Ping,
}
pub enum XmppCommand {
    Chat {
        xmpp_to: xmpp_parsers::Jid,
        message: String,
    },
    Chatroom {
        muc_id: String,
        message: String,
    },
pub struct XmppCommand;
pub struct XmppCommand;
pub struct XmppCommand {
    pub xmpp_to: String,
}
pub struct XmppCommand;
#[derive(Debug)]
}
    Chatroom {
        muc_id: String,
        message: String,
    },
    Ping,
    Chatroom {
        muc_id: String,
        message: String,
    },
    Ping,
    Ping,
pub struct XmppCommand {
    pub xmpp_to: xmpp_parsers::Jid,
    pub message: String,
pub enum XmppCommand {
    Chat {
        xmpp_to: xmpp_parsers::Jid,
        message: String,
    },
pub struct XmppCommand;
pub struct XmppCommand {
    pub xmpp_to: String,
}
pub struct XmppCommand {
    pub xmpp_to: String,
    pub message: String,
}
pub struct XmppCommand;
    Ping,
pub struct XmppCommand;
pub struct XmppCommand;
pub struct XmppCommand;
pub struct XmppCommand {
    pub xmpp_to: xmpp_parsers::Jid,
    pub message: String,
}
pub enum XmppCommand {
    Chat {
        xmpp_to: xmpp_parsers::Jid,
        message: String,
    },
pub struct XmppCommand;
    fn shutdown(self) -> impl Future<Item = (), Error = failure::Error> {
        info!("Shutdown connection");
        future::ok(())
}
    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
                .values()
                .map(std::clone::Clone::clone)
                .collect::<Vec<_>>(),
        )
        .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);
            info!("Sending muc presence... {:?}", muc_presence);
            let account4 = account2.clone();
            use tokio::prelude::Sink;
            client
                .send(muc_presence)
                .map_err(|e| {
                    error!("Error on send muc presence: {}", e);
                    account4
                })
                .and_then(|client| future::ok(XmppState { client, data }))
        })
        .map(|state| XmppConnection {
            account: account3,
            state,
        })
        info!("Got command");
            info!("Jid {} in roster", cmd.xmpp_to);
            let sub_to = match rdata.0 {
                xmpp_parsers::roster::Subscription::To => true,
                xmpp_parsers::roster::Subscription::Both => true,
                _ => false,
            };
            if sub_to {
                info!("Subscribed to {}", cmd.xmpp_to);
                self.state
                    .data
                    .send_queue
                    .push_back(stanzas::make_chat_message(cmd.xmpp_to, cmd.message));
            } else {
                info!("Not subscribed to {}", cmd.xmpp_to);
                rdata.1.push(cmd.message);
                self.state
                    .data
                    .send_queue
                    .push_back(stanzas::make_ask_subscribe(cmd.xmpp_to));
            }
<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
            let XmppConnection {
                account,
                state: XmppState { client, mut data },
            } = self;
            data.counter += 1;
            let id_add_roster = format!("id_add_roster{}", data.counter);
            let account2 = account.clone();
            use tokio::prelude::Sink;
            Box::new(
                client
                    .send(add_roster)
                    .map_err(|e| {
                        error!("Error on send adding to roster: {}", e);
                        account2
                    })
                    .and_then(move |client| {
                        data.pending_add_roster_ids
                            .insert(id_add_roster, (cmd.xmpp_to, cmd.message));
                        future::ok(XmppConnection {
                            account,
                            state: XmppState { client, data },
                        })
                    }),
            )
        future::ok(self)
            self.state.data.send_queue.push_back(add_roster);
            Box::new(
                client
                    .send(add_roster)
                    .map_err(|e| {
                        error!("Error on send adding to roster: {}", e);
                        account2
                    })
                    .and_then(move |client| {
                        data.pending_add_roster_ids
                            .insert(id_add_roster, (cmd.xmpp_to, cmd.message));
                        future::ok(XmppConnection {
                            account,
                            state: XmppState { client, data },
                        })
                    }),
            )
            self.state.data.send_queue.push_back(add_roster);
            use tokio::prelude::Sink;
        }
    }
            self.state
                .data
                .pending_add_roster_ids
                .insert(id_add_roster, (cmd.xmpp_to, cmd.message));
            let account2 = account.clone();
            info!("Adding jid to roster... {:?}", add_roster);
            self.state
                .data
                .pending_add_roster_ids
                .insert(id_add_roster, (cmd.xmpp_to, cmd.message));
            self.state.data.counter += 1;
            let id_add_roster = format!("id_add_roster{}", self.state.data.counter);
            data.counter += 1;
            let id_add_roster = format!("id_add_roster{}", data.counter);
            let add_roster = stanzas::make_add_roster(&id_add_roster, cmd.xmpp_to.clone());
            self.state.data.counter += 1;
            let id_add_roster = format!("id_add_roster{}", self.state.data.counter);
            let XmppConnection {
                account,
                state: XmppState { client, mut data },
            } = self;
            data.counter += 1;
            let id_add_roster = format!("id{}", data.counter);
            let add_roster = stanzas::make_add_roster(&id_add_roster, cmd.xmpp_to.clone());
            info!("Add jid to roster... {:?}", add_roster);
            future::ok(XmppConnection {
                account,
                state: XmppState { client, data },
            })
            let XmppConnection {
                account,
                state: XmppState { client, mut data },
            } = self;
        } else {
            info!("Jid {} not in roster", cmd.xmpp_to);
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
            Box::new(future::ok(self)) as Box<dyn Future<Item = _, Error = _>>
================================
            future::ok(self)
            Box::new(future::ok(self)) as Box<dyn Future<Item = _, Error = _>>
        if let Some(ref mut rdata) = self.state.data.roster.get_mut(&cmd.xmpp_to) {
        if let Some(_jid_data) = self.state.data.roster.get(&cmd.xmpp_to) {
        if self.state.data.roster.get(&cmd.xmpp_to).is_some() {
        if self.state.data.roster.get(&cmd.xmpp_to).is_some() {
        cmd: &XmppCommand,
    ) -> impl Future<Item = Self, Error = std::rc::Rc<config::Account>> {
        cmd: XmppCommand,
    fn process_command(
        self,
        cmd: XmppCommand,
    ) -> impl Future<Item = Self, Error = std::rc::Rc<config::Account>> {
    fn process_command(&mut self, cmd: XmppCommand) {
    fn process_command(
        self,
    fn process_command(&mut self, cmd: XmppCommand) {
        Box::new(
            client
                .send(presence)
                .map_err(|e| {
                    error!("Error on send self-presence: {}", e);
                    "Cann't send self-presence".to_owned()
                .and_then(move |client| {
                    future::loop_fn((account2.clone(), client), |(account, client)| {
                        client
                            .into_future()
                            .map_err(|(e, _)| {
                                error!("Error on reading self-presence: {}", e);
                                "Cann't read self-presence".to_owned()
                            })
                            .and_then(|(event, client)| match event {
                                Some(event) => {
                                    if let tokio_xmpp::Event::Stanza(e) = event {
                                        info!("Get stanza: {:?}", e);
                                        if e.name() == "presence"
                                            && e.attr("from").map_or(false, |f| f == account.jid)
                                            && e.attr("to").map_or(false, |f| f == account.jid)
                                        {
                                            info!("Self presence");
                                            future::ok(future::Loop::Break(client))
                                        } else {
                                            future::ok(future::Loop::Continue((account, client)))
                                        }
                                    } else {
                                        future::err("Got wrong event".to_owned())
                                    }
                                }
                                None => future::err("Got closed stream".to_owned()),
                            })
                    })
                    .map_err(|e| format!("waiting self-presence: {}", e))
                })
                .then(|r| match r {
                    Err(e) => {
                        error!("Self-presence waiting error: {}", e);
                        future::err(account)
                    }
                    Ok(inner) => future::ok(XmppConnection { account, inner }),
                }),
        )
            })
                })
    }
        info!("Sending presence... {:?}", presence);
            .send(presence)
            .map_err(|e| {
                error!("Error on send self-presence: {}", e);
                (account2, Err(failure::SyncFailure::new(e).into()))
            })
            .and_then(move |client| {
                XmppConnection {
                    account,
                }
                .processing(
                    move |conn, event| {
                        if let Event::Stanza(s) = event {
                            if s.name() == "presence"
                                && s.attr("from").map_or(false, |f| f == conn.account.jid)
                                && s.attr("to").map_or(false, |f| f == conn.account.jid)
                            {
                                Ok(true)
                            } else {
                                Ok(false)
                            }
                        } else {
                            Err(format_err!("Wrong event while waiting self-presence"))
                        }
                    },
                    stop_future,
                )
            })
            .then(|r| match r {
                Err((account, _e)) => {
                    error!("Cann't wait self-presence");
                    future::err(account)
                }
                Ok((conn, _)) => future::ok(conn),
            })
                    state: XmppState { client, roster },
                    inner: client,
                    state: XmppState { client },
        client
        state
            .client
        info!("Sending presence... {:?}", presence);
            .send(Packet::Stanza(presence))
                account2
                    state: XmppState { client, data },
                            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)
                                }
                            error!("Wrong event while waiting self-presence");
                            Err(())
                .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),
                })
            .then(|r| match r {
                Err((account, _e)) => {
                    error!("Cann't wait self-presence");
                    future::err(account)
                }
                Ok((conn, _)) => future::ok(conn),
================================
    ) -> impl Future<Item = Self, Error = std::rc::Rc<config::Account>> {
        info!("Got command");
            info!("Jid {} in roster", cmd.xmpp_to);
        } else {
            info!("Jid {} not in roster", cmd.xmpp_to);
        }
<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
        if let Some(_jid_data) = self.state.data.roster.get(&cmd.xmpp_to) {
        future::ok(self)
        if let Some(_jid_data) = self.state.roster.get(&cmd.xmpp_to) {
        _cmd: &XmppCommand,
        cmd: &XmppCommand,
    }
    fn process_command(
        self,
                .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),
                .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),
                })
            .then(|r| match r {
                Err((account, e)) => {
                    error!("Cann't wait self-presence");
                    future::err(account)
                }
                Ok((conn, _)) => future::ok(conn),
            })
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
            .then(|r| match r {
                Err((account, _e)) => {
                    error!("Cann't wait self-presence");
                    future::err(account)
                }
                Ok((conn, _)) => future::ok(conn),
            })
    }
        info!("Got command");
                self.state
                    .data
            }
            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);
            }
    }
    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(|_| ())
    }
        let account2 = account.clone();
        let account3 = account.clone();
                })
                .and_then(|client| future::ok(XmppState { client, data }))
        })
        .map(|state| XmppConnection {
            account: account3,
            state,
        })
        .map(|_| ())
    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,
            })
                    account4
                    e
            use tokio::prelude::Sink;
            client
                .send(Packet::Stanza(muc_presence))
                .map_err(|e| {
                    error!("Error on send muc presence: {}", e);
                    account4
                })
                .and_then(|client| future::ok(XmppState { client, data }))
        })
        .map(|state| XmppConnection {
            account: account3,
            state,
        })
                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,
            })
            use tokio::prelude::Sink;
            client
                .send(Packet::Stanza(muc_presence))
                .map_err(|e| {
                    error!("Error on send muc presence: {}", e);
            let account4 = account2.clone();
                let account4 = account2.clone();
            let account4 = account2.clone();
            info!("Sending muc leave presence... {:?}", muc_presence);
            info!("Sending muc presence... {:?}", muc_presence);
                info!("Sending muc presence... {:?}", muc_presence);
            info!("Sending muc presence... {:?}", muc_presence);
            account
                .chatrooms
        .fold(state, move |XmppState { client, mut data }, muc_jid| {
            data.counter += 1;
            let id_muc_presence = format!("id_muc_presence{}", data.counter);
                stanzas::make_muc_presence(&id_muc_presence, account2.jid.clone(), muc_jid);
                stanzas::make_muc_presence_leave(account.jid.clone(), muc_jid.clone());
            let muc_presence =
        .fold(state, move |XmppState { client, data }, muc_jid| {
                .values()
                .map(std::clone::Clone::clone)
                .collect::<Vec<_>>(),
        )
            state
                .data
                .mucs
        stream::iter_ok(
            account
                .chatrooms
                .values()
                .map(std::clone::Clone::clone)
                .collect::<Vec<_>>(),
        )
        .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);
        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(),
                );
        stream::iter_ok(
        let XmppConnection { account, state } = self;
    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,
    {
    fn shutdown(self) -> impl Future<Item = (), Error = failure::Error> {
        info!("Shutdown connection");
    }
    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,
            })
        future::ok(self)
    }
    }
    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(|_| ())
            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);
            }
            }
            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);
                    .send_queue
                    .push_back(stanzas::make_ask_subscribe(cmd.xmpp_to));
                    .outgoing_mailbox
                    .entry(xmpp_to.clone())
                    .or_default()
                    .push(message);
                self.process_jid(&xmpp_to);
            info!("Jid {} in roster", cmd.xmpp_to);
            let sub_to = match rdata.0 {
                xmpp_parsers::roster::Subscription::To => true,
                xmpp_parsers::roster::Subscription::Both => true,
                _ => false,
            };
            if sub_to {
                info!("Subscribed to {}", cmd.xmpp_to);
                self.state
                    .data
                    .send_queue
                    .push_back(stanzas::make_chat_message(cmd.xmpp_to, cmd.message));
            } else {
                info!("Not subscribed to {}", cmd.xmpp_to);
                rdata.1.push(cmd.message);
        } else {
            info!("Jid {} not in roster", cmd.xmpp_to);
                    self.state.data.counter += 1;
                    let id_add_roster = format!("id_add_roster{}", self.state.data.counter);
                    let add_roster = stanzas::make_add_roster(&id_add_roster, xmpp_to.clone());
                    self.state
                        .data
                        .pending_add_roster_ids
                        .insert(id_add_roster, (xmpp_to, message));
                    info!("Adding jid to roster... {:?}", add_roster);
                    self.state.data.send_queue.push_back(add_roster);
                }
            }
            self.state.data.send_queue.push_back(add_roster);
            self.state.data.send_queue.push_back(add_roster);
            self.state.data.counter += 1;
            let id_add_roster = format!("id_add_roster{}", self.state.data.counter);
            let add_roster = stanzas::make_add_roster(&id_add_roster, cmd.xmpp_to.clone());
            self.state
                .data
                .pending_add_roster_ids
                .insert(id_add_roster, (cmd.xmpp_to, cmd.message));
            info!("Adding jid to roster... {:?}", add_roster);
            self.state.data.counter += 1;
            let id_add_roster = format!("id_add_roster{}", self.state.data.counter);
            let add_roster = stanzas::make_add_roster(&id_add_roster, cmd.xmpp_to.clone());
            self.state
                .data
                .pending_add_roster_ids
                .insert(id_add_roster, (cmd.xmpp_to, cmd.message));
            info!("Adding jid to roster... {:?}", add_roster);
        }
            info!("Jid {} in roster", cmd.xmpp_to);
        } else {
            info!("Jid {} not in roster", cmd.xmpp_to);
            let sub_to = match rdata.0 {
                xmpp_parsers::roster::Subscription::To => true,
                xmpp_parsers::roster::Subscription::Both => true,
                _ => false,
            };
            if sub_to {
                info!("Subscribed to {}", cmd.xmpp_to);
                self.state
                    .data
                    .send_queue
                    .push_back(stanzas::make_chat_message(cmd.xmpp_to, cmd.message));
            } else {
                info!("Not subscribed to {}", cmd.xmpp_to);
                rdata.1.push(cmd.message);
                self.state
                    .data
                    .send_queue
                    .push_back(stanzas::make_ask_subscribe(cmd.xmpp_to));
            }
            let sub_to = match rdata.0 {
                xmpp_parsers::roster::Subscription::To => true,
                xmpp_parsers::roster::Subscription::Both => true,
                _ => false,
            };
            if sub_to {
                info!("Subscribed to {}", cmd.xmpp_to);
                self.state
                    .data
                    .send_queue
                    .push_back(stanzas::make_chat_message(cmd.xmpp_to, cmd.message));
            } else {
                info!("Not subscribed to {}", cmd.xmpp_to);
                rdata.1.push(cmd.message);
                self.state
                    .data
                    .send_queue
                    .push_back(stanzas::make_ask_subscribe(cmd.xmpp_to));
            }
        if let Some(ref mut rdata) = self.state.data.roster.get_mut(&cmd.xmpp_to) {
        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);
            }
        if self.state.data.roster.get(&cmd.xmpp_to).is_some() {
        if let Some(ref mut rdata) = self.state.data.roster.get_mut(&cmd.xmpp_to) {
        match cmd {
            XmppCommand::Chat { xmpp_to, message } => {
                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
                            .push_back(stanzas::make_chat_message(xmpp_to, message));
                    } else if rdata.1 == xmpp_parsers::roster::Ask::None {
                        info!("Not subscribed to {}", xmpp_to);
                        rdata.2.push(message);
                        self.state
                            .data
                            .send_queue
                            .push_back(stanzas::make_ask_subscribe(xmpp_to));
                    }
                } else {
                    info!("Jid {} not in roster", xmpp_to);
        if let Some(_jid_data) = self.state.data.roster.get(&cmd.xmpp_to) {
            info!("Jid {} in roster", cmd.xmpp_to);
        } else {
            info!("Jid {} not in roster", cmd.xmpp_to);
        if self.state.data.roster.get(&cmd.xmpp_to).is_some() {
        if let Some(ref mut rdata) = self.state.data.roster.get_mut(&cmd.xmpp_to) {
        match cmd {
            XmppCommand::Chat { xmpp_to, message } => {
                    }
                } 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);
                }
            }
        }
    }
                    }
                    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()));
    fn process_jid(&mut self, xmpp_to: &xmpp_parsers::Jid) {
        if let Some(ref mut mailbox) = self.state.data.outgoing_mailbox.get_mut(xmpp_to) {
            if !mailbox.is_empty() {
                if let Some(ref mut rdata) = self.state.data.roster.get_mut(xmpp_to) {
                    info!("Jid {} in roster", xmpp_to);
                    let sub_to = match rdata.0 {
                        xmpp_parsers::roster::Subscription::To => true,
                        xmpp_parsers::roster::Subscription::Both => true,
                        _ => false,
                    };
                    if sub_to {
                        info!("Subscribed to {}", xmpp_to);
                        self.state.data.send_queue.extend(
                            mailbox.drain(..).map(|message| {
                                stanzas::make_chat_message(xmpp_to.clone(), message)
                            }),
                        );
                    } else if rdata.1 == xmpp_parsers::roster::Ask::None {
                        info!("Not subscribed to {}", xmpp_to);
                        self.state
                            .data
                            .send_queue
                            .push_back(stanzas::make_ask_subscribe(xmpp_to.clone()));
                    }
                } else {
                    info!("Jid {} not in roster", xmpp_to);
                    self.state.data.counter += 1;
                    let id_add_roster = format!("id_add_roster{}", self.state.data.counter);
                    let add_roster = stanzas::make_add_roster(&id_add_roster, xmpp_to.clone());
                    self.state
                        .data
                        .pending_add_roster_ids
                        .insert(id_add_roster, xmpp_to.clone());
                    info!("Adding jid to roster... {:?}", add_roster);
                    self.state.data.send_queue.push_back(add_roster);
                }
            }
        }
    }
    fn process_command(&mut self, cmd: XmppCommand) {
    fn process_command(
        self,
        cmd: &XmppCommand,
    ) -> impl Future<Item = Self, Error = std::rc::Rc<config::Account>> {
    fn process_command(&mut self, cmd: XmppCommand) {
    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()));
                .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),
                })
                            Err(format_err!("Wrong event while waiting self-presence"))
            })
                            error!("Wrong event while waiting self-presence");
                            Err(())
                        }
                    },
                    stop_future,
                )
                            Err(format_err!("Wrong event while waiting self-presence"))
                            Err(format_err!("Wrong event while waiting self-presence"))
                            error!("Wrong event while waiting self-presence");
                            Err(())
                            error!("Wrong event while waiting self-presence");
                            Err(())
                            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)
                                }
                            if s.name() == "presence"
                                && s.attr("from").map_or(false, |f| f == conn.account.jid)
                                && s.attr("to").map_or(false, |f| f == conn.account.jid)
                            {
                                Ok(true)
                            } else {
                                Ok(false)
                            if s.name() == "presence"
                                && s.attr("from").map_or(false, |f| f == conn.account.jid)
                                && s.attr("to").map_or(false, |f| f == conn.account.jid)
                            {
                                Ok(true)
                            } else {
                                Ok(false)
                            }
                        } else {
                            use try_from::TryInto;
                            match s.try_into() as Result<xmpp_parsers::presence::Presence, _> {
                                Ok(presence) => {
                                    Ok(presence.from.as_ref() == Some(&conn.state.client.jid))
                                }
                                Err(e) => {
                                    warn!("Not a self-presence: {}", e);
                                    Ok(false)
                                }
                            if s.name() == "presence"
                                && s.attr("from").map_or(false, |f| f == conn.account.jid)
                                && s.attr("to").map_or(false, |f| f == conn.account.jid)
                            {
                                Ok(true)
                            } else {
                                Ok(false)
                    state: XmppState { client, roster },
                    state: XmppState { client, data },
                    state: XmppState { client, roster },
                    state: XmppState { client },
                    state: XmppState { client, roster },
                    account,
                }
                .processing(
                    move |conn, event| {
                        if let Event::Stanza(s) = event {
                    inner: client,
                    state: XmppState { client },
                    state: XmppState { client, data },
                    state: XmppState {
                        client,
                        roster,
                        counter,
                    },
                (account2, Err(failure::SyncFailure::new(e).into()))
            })
            .and_then(move |client| {
                XmppConnection {
                account2
                (account2, Err(failure::SyncFailure::new(e).into()))
                (account2, Err(failure::SyncFailure::new(e).into()))
                account2
                account2
            .send(Packet::Stanza(presence))
            .send(presence)
            .send(presence)
            .map_err(|e| {
                error!("Error on send self-presence: {}", e);
        client
        state
            .client
        client
        state
            .client
        client
        info!("Sending presence... {:?}", presence);
        info!("Sending presence... {:?}", presence);
        client
            .send(presence)
            .map_err(|e| {
                error!("Error on send self-presence: {}", e);
                (account2, Err(failure::SyncFailure::new(e).into()))
            })
            .and_then(move |client| {
                XmppConnection { client, account }.processing(
                    move |conn, event| {
                        if let Event::Stanza(s) = event {
                            if s.name() == "presence"
                                && s.attr("from").map_or(false, |f| f == conn.account.jid)
                                && s.attr("to").map_or(false, |f| f == conn.account.jid)
                            {
                                Ok(true)
                            } else {
                                Ok(false)
                            }
                        } else {
                            Err(format_err!("Wrong event while waiting self-presence"))
                        }
                    },
                    stop_future,
                )
            })
            .then(|r| match r {
                Err((account, _e)) => {
                    error!("Cann't wait self-presence");
                    future::err(account)
                }
                Ok((conn, _)) => future::ok(conn),
            })
        info!("Sending presence...");
        info!("Sending presence...");
    fn initial_roster<F, E>(
        self,
        stop_future: F,
    ) -> impl Future<Item = Self, Error = std::rc::Rc<config::Account>>
    where
        F: Future<Error = E>,
        E: Into<failure::Error>,
    {
            state: XmppState { client, roster },
        client
                    state: XmppState { client, roster },
            state: XmppState { client, mut data },
        data.counter += 1;
        let id_init_roster = format!("id_init_roster{}", data.counter);
        let get_roster = stanzas::make_get_roster(&id_init_roster);
            .send(Packet::Stanza(get_roster))
                .processing(
                    move |conn, event| conn.process_initial_roster(event, &id_init_roster),
                    stop_future,
                )
        F: Future<Error = E> + 'static,
        E: Into<failure::Error> + 'static,
        let XmppConnection {
            account,
            state: XmppState { client, roster },
        } = self;
        let XmppConnection { account, state } = self;
        let XmppConnection {
            account,
            state: XmppState { client, roster },
        } = self;
        let XmppConnection { account, inner } = self;
        let client = inner;
        let XmppConnection { account, state } = self;
        let XmppConnection {
            account,
            state: XmppState { client, data },
        } = self;
        let XmppConnection {
            account,
        } = self;
            state: XmppState { client, data },
        use tokio::prelude::Sink;
        let presence = stanzas::make_presence(&account);
        let account2 = account.clone();
            state: XmppState { client, data },
            state: XmppState { client, roster },
            state:
                XmppState {
                    client,
                    roster,
                    counter,
                },
        F: Future<Error = E>,
        E: Into<failure::Error>,
    {
    fn self_presence<F, E>(
        self,
        stop_future: F,
    ) -> impl Future<Item = Self, Error = std::rc::Rc<config::Account>>
    where
        F: Future<Error = E>,
        E: Into<failure::Error>,
        F: Future<Error = E>,
        E: Into<failure::Error>,
        F: Future<Error = E> + 'static,
        E: Into<failure::Error> + 'static,
        F: Future<Error = E> + 'static,
        E: Into<failure::Error> + 'static,
                .processing(XmppConnection::process_initial_roster, stop_future)
                .processing(XmppConnection::process_initial_roster, stop_future)
                .map_err(|(account, _)| account)
                .and_then(|(conn, r)| match r {
                    Ok(Either::A(_)) => future::ok(conn),
                    Ok(Either::B(_)) => future::err(conn.account),
                    Err(_e) => future::err(conn.account),
                })
            })
    }
                .processing(
                    move |conn, event| conn.process_initial_roster(event, &id_init_roster),
                    stop_future,
                )
            .send(Packet::Stanza(get_roster))
            .send(get_roster)
            .send(get_roster)
            .map_err(move |e| {
                error!("Error on querying roster: {}", e);
                account2
            })
            .and_then(move |client| {
                XmppConnection {
                    state: XmppState { client, data },
                    account,
                }
    fn self_presence(self) -> impl Future<Item = Self, Error = std::rc::Rc<config::Account>> {
        let XmppConnection { account, inner } = self;
        let client = inner;
        let get_roster = stanzas::make_get_roster(ID_GET_ROSTER);
    fn self_presence<F, E>(
        self,
        stop_future: F,
    ) -> impl Future<Item = Self, Error = std::rc::Rc<config::Account>>
    where
        F: Future<Error = E>,
        E: Into<failure::Error>,
    {
            state: XmppState { client, roster },
        } = self;
            inner: client,
        let XmppConnection {
            account,
        let XmppConnection { account, state } = self;
        let account2 = account.clone();
        info!("Quering roster... {:?}", get_roster);
        client
        data.id_init_roster = Some(id_init_roster);
        data.counter += 1;
        let id_init_roster = format!("id_init_roster{}", data.counter);
        let get_roster = stanzas::make_get_roster(&id_init_roster);
            state: XmppState { client, data },
    }
            state: XmppState { client, mut data },
        } = self;
        use tokio::prelude::Sink;
    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,
                    inner: client,
                    state: XmppState { client },
                    account,
                }
                .processing(XmppConnection::process_initial_roster, stop_future)
            })
            .then(|r| match r {
                Err((account, e)) => {
                    error!(
                        "Cann't wait roster: {}",
                        e.err().map_or_else(
                            || std::borrow::Cow::Borrowed("None"),
                            |e| e.to_string().into()
                        )
                    );
                    future::err(account)
                }
                Ok((conn, _)) => future::ok(conn),
            })
        state
            .client
            .send(get_roster)
            .map_err(move |e| {
                error!("Error on querying roster: {}", e);
                (account2, Err(failure::SyncFailure::new(e).into()))
            })
            .and_then(move |client| {
                XmppConnection {
        } = self;
            inner: client,
        use tokio::prelude::Sink;
        let get_roster = stanzas::make_get_roster(ID_GET_ROSTER);
        let account2 = account.clone();
        info!("Quering roster... {:?}", get_roster);
        let XmppConnection {
            account,
        let XmppConnection { account, state } = self;
    fn self_presence<F, E>(
        self,
        stop_future: F,
    ) -> impl Future<Item = Self, Error = std::rc::Rc<config::Account>>
    where
        F: Future<Error = E>,
        E: Into<failure::Error>,
    {
        let XmppConnection { account, client } = self;
            future::err(account)
        }
        } else {
            warn!("Don't gen connection on self-presence");
                            account,
                            inner: Some(inner),
                        }),
                    }),
            )
                        Ok(inner) => future::ok(MaybeXmppConnection {
                        Err(e) => {
                            error!("Self-presence waiting error: {}", e);
                            future::err(account)
                        }
                    .map_err(|e| format!("waiting self-presence: {}", e))
                })
                        }).map_err(|e| format!("waiting self-presence: {}", e)),
                    ).then(|r| match r {
                        })
                        .map_err(|e| format!("waiting self-presence: {}", e)),
                    )
                    .then(|r| match r {
                        }
                Err((account, _e)) => {
                Err((account, e)) => {
                    error!("Cann't wait self-presence");
                    future::err(account)
                }
                Ok((conn, _)) => future::ok(conn),
            })
                        Ok(inner) => future::ok(XmppConnection {
                            account,
                            inner: Some(inner),
                        }),
                    }),
            )
        } else {
            warn!("Don't gen connection on self-presence");
            Box::new(future::err(account)) as Box<Future<Item = _, Error = _>>
        }
                    },
                    stop_future,
                )
            })
            .then(|r| match r {
                    .map_err(|e| format!("waiting self-presence: {}", e)),
                )
                .then(|r| match r {
                    Err(e) => {
                        error!("Self-presence waiting error: {}", e);
                        future::err(account)
                    }
                    Ok(inner) => future::ok(XmppConnection { account, inner }),
                }),
        )
                        })
                        .map_err(|e| format!("waiting self-presence: {}", e)),
                    )
                    .then(|r| match r {
    }
                                    None => future::err("Got closed stream".to_owned()),
                                })
                                    None => future::err("Got closed stream".to_owned()),
                                })
                        })
                        .map_err(|e| format!("waiting self-presence: {}", e)),
                    )
                    .then(|r| match r {
                        Err(e) => {
                            error!("Self-presence waiting error: {}", e);
                            future::err(account)
                        }
                        Ok(inner) => future::ok(XmppConnection {
                            account,
                            inner: Some(inner),
                        }),
                    }),
            )
        } else {
            warn!("Don't gen connection on self-presence");
            Box::new(future::err(account)) as Box<Future<Item = _, Error = _>>
        }
                                }
                                None => future::err("Got closed stream".to_owned()),
                            })
                    })
                    .map_err(|e| format!("waiting self-presence: {}", e))
                })
                .then(|r| match r {
                    Err(e) => {
                        error!("Self-presence waiting error: {}", e);
                        future::err(account)
                    }
                    Ok(inner) => future::ok(XmppConnection { account, inner }),
                }),
        )
                                    None => future::err("Got closed stream".to_owned()),
                                })
                        })
                        .map_err(|e| format!("waiting self-presence: {}", e)),
                    )
                    .then(|r| match r {
                        Err(e) => {
                            error!("Self-presence waiting error: {}", e);
                            future::err(account)
                        }
                        Ok(inner) => future::ok(MaybeXmppConnection {
                            account,
                            inner: Some(inner),
                        }),
                    }),
            )
        } else {
            warn!("Don't gen connection on self-presence");
            Box::new(future::err(account)) as Box<Future<Item = _, Error = _>>
        }
                                    None => future::err("Got closed stream".to_owned()),
                                })
                        })
                        .map_err(|e| format!("waiting self-presence: {}", e)),
                    )
                    .then(|r| match r {
                        Err(e) => {
                            error!("Self-presence waiting error: {}", e);
                            future::err(account)
                                }
                                None => future::err("Got closed stream".to_owned()),
                            })
                    })
                    .map_err(|e| format!("waiting self-presence: {}", e))
                })
                .then(|r| match r {
                    Err(e) => {
                        error!("Self-presence waiting error: {}", e);
                        future::err(account)
                    }
                    Ok(inner) => future::ok(XmppConnection { account, inner }),
                }),
        )
                                }
                                None => future::err("Got closed stream".to_owned()),
                            })
                    })
                                    } else {
                                        future::err("Got wrong event".to_owned())
                                    } else {
                                        future::err("Got wrong event".to_owned())
                                    } else {
                                        future::err("Got wrong event".to_owned())
                                            future::err("Got wrong event".to_owned())
                                            future::err("Got wrong event".to_owned())
                                            future::ok(future::Loop::Continue((account, client)))
                                            future::ok(future::Loop::Continue((account, client)))
                                            future::err("Got wrong event".to_owned())
                                            future::err("Got wrong event".to_owned())
                                            future::ok(future::Loop::Continue((account, client)))
                                            future::ok(future::Loop::Continue((account, stream)))
        let account2 = account.clone();
            client
                .send(presence)
                .and_then(move |client| {
                    future::loop_fn((account2.clone(), client), |(account, client)| {
                        client
                            .and_then(|(event, client)| match event {
                                            future::ok(future::Loop::Break(client))
                                            future::ok(future::Loop::Break(stream))
                            .and_then(|(event, stream)| match event {
                                Some(event) => {
                                    if let tokio_xmpp::Event::Stanza(e) = event {
                                        info!("Get stanza: {:?}", e);
                                        if e.name() == "presence"
                                            && e.attr("from").map_or(false, |f| f == account.jid)
                                            && e.attr("to").map_or(false, |f| f == account.jid)
                                        {
                                            info!("Self presence");
                .join(
                    future::loop_fn((account.clone(), stream), |(account, stream)| {
                        stream
                            .into_future()
                            .map_err(|(e, _)| {
                                error!("Error on reading self-presence: {}", e);
                                "Cann't read self-presence".to_owned()
                            })
            sink.send(presence)
                .map_err(|e| {
                    error!("Error on send self-presence: {}", e);
                    "Cann't send self-presence".to_owned()
                })
            info!("Sending presence...");
                    }).join(
                                }).and_then(|(event, stream)| match event {
                                    Some(event) => {
                                        if let tokio_xmpp::Event::Stanza(e) = event {
                                            info!("Get stanza: {:?}", e);
                                            if e.name() == "presence"
                                                && e.attr("from")
                                                    .map_or(false, |f| f == account.jid)
                                                && e.attr("to").map_or(false, |f| f == account.jid)
                                            {
                                                info!("Self presence");
                                                future::ok(future::Loop::Break(stream))
                                            } else {
                                                future::ok(future::Loop::Continue((
                                                    account, stream,
                                                )))
                                            }
                                }).and_then(|(event, stream)| match event {
                                })
                                .and_then(|(event, stream)| match event {
                                })
                                .and_then(|(event, stream)| match event {
                        future::loop_fn((account.clone(), stream), |(account, stream)| {
                            stream
                                .into_future()
                                .map_err(|(e, _)| {
                                    error!("Error on reading self-presence: {}", e);
                                    "Cann't read self-presence".to_owned()
                    }).join(
                    })
                    .join(
                    })
                    .join(
        info!("Sending presence...");
        info!("Sending presence... {:?}", presence);
                                && s.attr("to").map_or(false, |f| f == conn.account.jid)
                        Ok(inner) => future::ok(XmppConnection {
                            account,
                            inner: Some(inner),
                        }),
                    }),
            )
            warn!("Don't gen connection on self-presence");
            Box::new(future::err(account)) as Box<Future<Item = _, Error = _>>
    }
    fn initial_roster<F, E>(
        self,
        stop_future: F,
    ) -> impl Future<Item = Self, Error = std::rc::Rc<config::Account>>
    where
        F: Future<Error = E>,
        E: Into<failure::Error>,
    {
        let XmppConnection { account, client } = self;
        use tokio::prelude::Sink;
        let get_roster = stanzas::make_get_roster(ID_GET_ROSTER);
        let account2 = account.clone();
        info!("Quering roster... {:?}", get_roster);
        client
            .send(get_roster)
            .map_err(move |e| {
                error!("Error on querying roster: {}", e);
                (account2, Err(failure::SyncFailure::new(e).into()))
            })
            .and_then(move |client| {
                XmppConnection { client, account }
                    .processing(XmppConnection::process_initial_roster, stop_future)
            })
            .then(|r| match r {
                Err((account, e)) => {
                    error!(
                        "Cann't wait roster: {}",
                        e.err().map_or_else(
                            || std::borrow::Cow::Borrowed("None"),
                            |e| e.to_string().into()
                        )
                    );
                    future::err(account)
                }
                Ok((conn, _)) => future::ok(conn),
            })
        }
            Err(format_err!("Wrong event while waiting roster"))
        } else {
                    },
                    Err((e, _)) => {
                        error!("xmpp receive error: {}", e);
                        future::err(account)
                })
            },
        ))
                }
                Err(_e) => Ok(false),
            }
        } else {
            Err(format_err!("Wrong event while waiting roster"))
        }
                }
                Err(_e) => Ok(false),
            }
        } else {
        }
    }
    fn initial_roster<F, E>(
        self,
        stop_future: F,
    ) -> impl Future<Item = Self, Error = std::rc::Rc<config::Account>>
    where
        E: Into<failure::Error>,
            state: XmppState { client, mut data },
        data.counter += 1;
        let id_init_roster = format!("id{}", data.counter);
        let get_roster = stanzas::make_get_roster(&id_init_roster);
        data.id_init_roster = Some(id_init_roster);
        client
                account2
                    state: XmppState { client, data },
                .processing(
                    move |conn, event| conn.process_initial_roster(event, &id_init_roster),
                    stop_future,
                )
            })
                .processing(XmppConnection::process_initial_roster, stop_future)
                .processing(XmppConnection::process_initial_roster, stop_future)
                })
            },
        ))
                .map_err(|(account, _)| account)
                .and_then(|(conn, r)| match r {
                    Ok(Either::A(_)) => future::ok(conn),
                    Ok(Either::B(_)) => future::err(conn.account),
                    Err(_e) => future::err(conn.account),
                })
            })
            .then(|r| match r {
                Err((account, e)) => {
                    error!(
                        "Cann't wait roster: {}",
                        e.err().map_or_else(
                            || std::borrow::Cow::Borrowed("None"),
                            |e| e.to_string().into()
                        )
                    );
                    future::err(account)
                }
                Ok((conn, _)) => future::ok(conn),
                .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),
            })
            .then(|r| match r {
                Err((account, e)) => {
                    error!(
                        "Cann't wait roster: {}",
                        e.err().map_or_else(
                            || std::borrow::Cow::Borrowed("None"),
                            |e| e.to_string().into()
                        )
                    );
                    future::err(account)
                }
                Ok((conn, _)) => future::ok(conn),
                .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),
                })
                    state: XmppState { client, roster },
                    state: XmppState { client, data },
                    state: XmppState { client, roster },
                    state: XmppState { client },
                    state: XmppState { client, roster },
                    account,
                }
                    state: XmppState { client },
                    state: XmppState {
                        client,
                        roster,
                        counter,
                    },
                (account2, Err(failure::SyncFailure::new(e).into()))
                account2
            })
            .and_then(move |client| {
                XmppConnection {
                (account2, Err(failure::SyncFailure::new(e).into()))
                account2
        state
            .client
        client
            .send(get_roster)
            .map_err(move |e| {
                error!("Error on querying roster: {}", e);
        state
            .client
        client
        data.counter += 1;
        let get_roster = stanzas::make_get_roster(&id_init_roster);
        let account2 = account.clone();
        info!("Quering roster... {:?}", get_roster);
        data.id_init_roster = Some(id_init_roster);
        let id_init_roster = format!("id{}", data.counter);
        let id_init_roster = format!("id_init_roster{}", data.counter);
        let get_roster = stanzas::make_get_roster(ID_GET_ROSTER);
        let get_roster = stanzas::make_get_roster(ID_GET_ROSTER);
        use tokio::prelude::Sink;
            state: XmppState { client, data },
        let XmppConnection {
            account,
            state: XmppState { client, roster },
        } = self;
            state: XmppState { client, mut data },
            state: XmppState { client, data },
            state: XmppState { client, roster },
        let XmppConnection { account, state } = self;
        let XmppConnection {
            account,
            state: XmppState { client, roster },
        } = self;
        let XmppConnection { account, state } = self;
            state:
                XmppState {
                    client,
                    roster,
                    counter,
                },
        } = self;
        let XmppConnection {
            account,
    {
        F: Future<Error = E> + 'static,
        E: 'static,
        F: Future<Error = E>,
        F: Future<Error = E>,
        E: Into<failure::Error>,
        F: Future<Error = E> + 'static,
        E: 'static,
            error!("Wrong event while waiting roster");
            Err(())
            Err(format_err!("Wrong event while waiting roster"))
            error!("Wrong event while waiting roster");
            Err(())
            Err(format_err!("Wrong event while waiting roster"))
            error!("Wrong event while waiting roster");
            Err(())
                }
                Err(_e) => Ok(false),
            }
                    },
                    Err((e, _)) => {
                        error!("xmpp receive error: {}", e);
                        future::err(account)
                    } else {
                        Err(format_err!("Iq stanza without id"))
                    },
                    stop_future,
                )
            })
            .then(|r| match r {
                    error!("Cann't wait self-presence");
                    future::err(account)
                }
                Ok((conn, _)) => future::ok(conn),
            })
                Err((account, _e)) => {
                Err((account, e)) => {
                        }
                    }
                    } else {
                        Err(format_err!("Iq stanza without id"))
        info!("Sending presence... {:?}", presence);
        Box::new(
            client
                .send(presence)
                .map_err(|e| {
                    error!("Error on send self-presence: {}", e);
                    "Cann't send self-presence".to_owned()
                })
                .and_then(move |client| {
                    future::loop_fn((account2.clone(), client), |(account, client)| {
                        client
                            .into_future()
                            .map_err(|(e, _)| {
                                error!("Error on reading self-presence: {}", e);
                                "Cann't read self-presence".to_owned()
                            })
                            .and_then(|(event, client)| match event {
                                Some(event) => {
                                    if let tokio_xmpp::Event::Stanza(e) = event {
                                        info!("Get stanza: {:?}", e);
                                        if e.name() == "presence"
                                            && e.attr("from").map_or(false, |f| f == account.jid)
                                            && e.attr("to").map_or(false, |f| f == account.jid)
                                        {
                                            info!("Self presence");
                                            future::ok(future::Loop::Break(client))
                                        } else {
                                            future::ok(future::Loop::Continue((account, client)))
                                        }
                                    } else {
                                        future::err("Got wrong event".to_owned())
                                    }
                                }
                                None => future::err("Got closed stream".to_owned()),
                            })
                    })
                    .map_err(|e| format!("waiting self-presence: {}", e))
                })
                .then(|r| match r {
                    Err(e) => {
                        error!("Self-presence waiting error: {}", e);
                        future::err(account)
                    }
                    Ok(inner) => future::ok(XmppConnection { account, inner }),
                }),
        )
        client
            .send(presence)
            .map_err(|e| {
                error!("Error on send self-presence: {}", e);
                (account2, Err(failure::SyncFailure::new(e).into()))
            })
            .and_then(move |client| {
                XmppConnection {
                    inner: client,
                    account,
                }
                .processing(
                    move |conn, event| {
                        if let Event::Stanza(s) = event {
                            if s.name() == "presence"
                                && s.attr("from").map_or(false, |f| f == conn.account.jid)
                                && s.attr("to").map_or(false, |f| f == conn.account.jid)
                            {
                                Ok(true)
                            } else {
                                Ok(false)
                            }
                        } else {
                            Err(format_err!("Wrong event while waiting self-presence"))
        info!("Sending presence...");
        client
            .send(presence)
            .map_err(|e| {
                error!("Error on send self-presence: {}", e);
                (account2, Err(failure::SyncFailure::new(e).into()))
            })
            .and_then(move |client| {
                XmppConnection {
                    inner: client,
                    account,
                }
                .processing(
                    move |conn, event| {
                        if let Event::Stanza(s) = event {
                            if s.name() == "presence"
                                && s.attr("from").map_or(false, |f| f == conn.account.jid)
                            {
                                Ok(true)
                            } else {
                                Ok(false)
                            }
                        } else {
                            Err(format_err!("Wrong event while waiting self-presence"))
        let account2 = account.clone();
            let presence = stanzas::make_presence(&account);
            Box::new(
                sink.send(presence)
                    .map_err(|e| {
                        error!("Error on send self-presence: {}", e);
                        "Cann't send self-presence".to_owned()
            let presence = stanzas::make_presence(&account);
            info!("Sending presence...");
            Box::new(
                sink.send(presence)
                    .map_err(|e| {
                        error!("Error on send self-presence: {}", e);
                        "Cann't send self-presence".to_owned()
                    })
                    .join(
                        future::loop_fn((account.clone(), stream), |(account, stream)| {
                            stream
                                .into_future()
                                .map_err(|(e, _)| {
                                    error!("Error on reading self-presence: {}", e);
                                    "Cann't read self-presence".to_owned()
                                })
                                .and_then(|(event, stream)| match event {
                                    Some(event) => {
                                        if let tokio_xmpp::Event::Stanza(e) = event {
                                            info!("Get stanza: {:?}", e);
                                            if e.name() == "presence"
                                                && e.attr("from")
                                                    .map_or(false, |f| f == account.jid)
                                                && e.attr("to").map_or(false, |f| f == account.jid)
                                            {
                                                info!("Self presence");
                                                future::ok(future::Loop::Break(stream))
                                            } else {
                                                future::ok(future::Loop::Continue((
                                                    account, stream,
                                                )))
                                            }
        let presence = stanzas::make_presence(&account);
        info!("Sending presence...");
        let account2 = account.clone();
        Box::new(
            client
                .send(presence)
                .map_err(|e| {
                    error!("Error on send self-presence: {}", e);
                    "Cann't send self-presence".to_owned()
                })
                .and_then(move |client| {
                    future::loop_fn((account2.clone(), client), |(account, client)| {
                        client
                            .into_future()
                            .map_err(|(e, _)| {
                                error!("Error on reading self-presence: {}", e);
                                "Cann't read self-presence".to_owned()
                            })
                            .and_then(|(event, client)| match event {
                                Some(event) => {
                                    if let tokio_xmpp::Event::Stanza(e) = event {
                                        info!("Get stanza: {:?}", e);
                                        if e.name() == "presence"
                                            && e.attr("from").map_or(false, |f| f == account.jid)
                                            && e.attr("to").map_or(false, |f| f == account.jid)
                                        {
                                            info!("Self presence");
                                            future::ok(future::Loop::Break(client))
            let presence = stanzas::make_presence(&account);
            info!("Sending presence...");
            Box::new(
                sink.send(presence)
                    .map_err(|e| {
                        error!("Error on send self-presence: {}", e);
                        "Cann't send self-presence".to_owned()
                    })
                    .join(
                        future::loop_fn((account.clone(), stream), |(account, stream)| {
                            stream
                                .into_future()
                                .map_err(|(e, _)| {
                                    error!("Error on reading self-presence: {}", e);
                                    "Cann't read self-presence".to_owned()
                                })
                                .and_then(|(event, stream)| match event {
                                    Some(event) => {
                                        if let tokio_xmpp::Event::Stanza(e) = event {
                                            info!("Get stanza: {:?}", e);
                                            if e.name() == "presence"
                                                && e.attr("from")
                                                    .map_or(false, |f| f == account.jid)
                                                && e.attr("to").map_or(false, |f| f == account.jid)
                                            {
                                                info!("Self presence");
                                                future::ok(future::Loop::Break(stream))
                                            } else {
                                                future::ok(future::Loop::Continue((
                                                    account, stream,
                                                )))
                                            }
            let presence = stanzas::make_presence(&account);
            info!("Sending presence...");
            Box::new(
                sink.send(presence)
                    .map_err(|e| {
                        error!("Error on send self-presence: {}", e);
                        "Cann't send self-presence".to_owned()
                    })
                    .join(
                        future::loop_fn((account.clone(), stream), |(account, stream)| {
                            stream
                                .into_future()
                                .map_err(|(e, _)| {
                                    error!("Error on reading self-presence: {}", e);
                                    "Cann't read self-presence".to_owned()
                                })
                                .and_then(|(event, stream)| match event {
                                    Some(event) => {
                                        if let tokio_xmpp::Event::Stanza(e) = event {
                                            info!("Get stanza: {:?}", e);
                                            if e.name() == "presence"
                                                && e.attr("from")
                                                    .map_or(false, |f| f == account.jid)
                                                && e.attr("to").map_or(false, |f| f == account.jid)
                                            {
                                                info!("Self presence");
                                                future::ok(future::Loop::Break(stream))
                                            } else {
                                                future::ok(future::Loop::Continue((
                                                    account, stream,
                                                )))
                                            }
        let presence = stanzas::make_presence(&account);
        info!("Sending presence...");
        let account2 = account.clone();
        Box::new(
            client
                .send(presence)
                .map_err(|e| {
                    error!("Error on send self-presence: {}", e);
                    "Cann't send self-presence".to_owned()
                })
                .and_then(move |client| {
                    future::loop_fn((account2.clone(), client), |(account, client)| {
                        client
                            .into_future()
                            .map_err(|(e, _)| {
                                error!("Error on reading self-presence: {}", e);
                                "Cann't read self-presence".to_owned()
                            })
                            .and_then(|(event, client)| match event {
                                Some(event) => {
                                    if let tokio_xmpp::Event::Stanza(e) = event {
                                        info!("Get stanza: {:?}", e);
                                        if e.name() == "presence"
                                            && e.attr("from").map_or(false, |f| f == account.jid)
                                            && e.attr("to").map_or(false, |f| f == account.jid)
                                        {
                                            info!("Self presence");
                                            future::ok(future::Loop::Break(client))
        let presence = stanzas::make_presence(&account);
        info!("Sending presence...");
        Box::new(
        let presence = stanzas::make_presence(&account);
        if let Some((sink, stream)) = inner {
            use tokio::prelude::Sink;
        let client = inner;
        use tokio::prelude::Sink;
        let client = inner;
        if let Some((sink, stream)) = inner {
            use tokio::prelude::Sink;
        let client = inner;
        use tokio::prelude::Sink;
        let (sink, stream) = inner;
        use tokio::prelude::Sink;
        let client = inner;
        use tokio::prelude::Sink;
        if let Some((sink, stream)) = inner {
            use tokio::prelude::Sink;
            future::ok(XmppConnection {
                account,
                inner: Some((sink, stream)),
            })
        let MaybeXmppConnection { account, inner } = self;
        if let Some((sink, stream)) = inner {
            use tokio::prelude::Sink;
        let MaybeXmppConnection { account, inner } = self;
        let XmppConnection { account, inner } = self;
        let XmppConnection { account, inner } = self;
                                            Err(account) => {
                                                future::err((account, Ok(Either::A(b))))
                                            }
                                        }))
                                            as Box<dyn Future<Item = _, Error = _>>
                                        Box::new(future::err((account, Ok(Either::A(b)))))
                                    Box::new(if let Some(client) = a.into_inner() {
                                    })
                                    Box::new(future::err((account, Ok(Either::A(b)))))
                                    Box::new(if let Some(client) = a.into_inner() {
                                    })
            use try_from::TryInto;
                    if let Some(id) = iq.id {
                        if 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(())
                                        Ok(true)
                                }
                                _ => {
                                    error!("Unknown result of roster");
                                    Err(())
                        } else {
                            Ok(false)
                        error!("Iq stanza without id");
                        Err(())
        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 {
                            }
                        } 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()));
                    }
                } else {
                    info!("Jid {} not in roster", xmpp_to);
                    self.state.data.counter += 1;
                    let id_add_roster = format!("id_add_roster{}", self.state.data.counter);
                    let add_roster = stanzas::make_add_roster(&id_add_roster, xmpp_to.clone());
                    self.state
                        .data
                        .pending_add_roster_ids
                        .insert(id_add_roster, xmpp_to.clone());
                    info!("Adding jid to roster... {:?}", add_roster);
                    self.state.data.send_queue.push_back(add_roster);
                }
            }
        }
    }
    fn process_command(&mut self, cmd: XmppCommand) {
        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);
            }
        }
    }
    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(),
                );
                            if s.name() == "presence"
                                && s.attr("from").map_or(false, |f| f == conn.account.jid)
                                && s.attr("to").map_or(false, |f| f == conn.account.jid)
                            {
                                Ok(true)
                            } else {
                                Ok(false)
                            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)
                                }
                        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);
                            _ => {
                                error!("Unknown result of roster");
                                Err(())
                            }
                        }
                    } else {
                                    Err(e) => {
                                        error!("Cann't parse roster: {}", e);
                                        Err(())
                                    }
                                }
                            }
                                    }
                    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));
                                        }
            use std::convert::TryInto;
            match s.try_into() as Result<xmpp_parsers::iq::Iq, _> {
                Ok(iq) => {
#[derive(Debug)]
pub enum XmppCommand {
    Chat {
        xmpp_to: xmpp_parsers::Jid,
        message: String,
    },
    Chatroom {
        muc_id: String,
        message: String,
    },
    Ping,
}
pub use xmpp_connection::XmppCommand;
    fn process_initial_roster(&mut self, event: Event, id_init_roster: &str) -> Result<bool, ()> {
        if let Event::Stanza(s) = event {
pub use xmpp_connection::XmppCommand;
struct XmppProcessState<F, S> {
    cmd_recv: S,
    signal: F,
    conn: MaybeXmppConnection,
}
impl<F, S> XmppProcessState<F, S> {
    fn new(cmd_recv: S, signal: F, conn: MaybeXmppConnection) -> XmppProcessState<F, S> {
        XmppProcessState {
            cmd_recv,
            signal,
            conn,
        }
    }
}
mod xmpp_connection;
use xmpp_connection::MaybeXmppConnection;
    /// 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(())
            }
        }
    }
                                    }
                                }
                            }),
                    )
                }
            },
        )
    }
                                    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)))
                                    future::err((account, Ok(Either::A(b))))
                                }
                                Err(Either::B((e, a))) => {
                                    }
                                }
                                Err(Either::A((e, b))) => {
                                    warn!("XMPP error: {}", e.0);
                                    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))))
                                        future::err((account, Ok(Either::A(b))))
                                    }
                                }
                                Ok(Either::B((t, a))) => {
    fn self_presence(self) -> impl Future<Item = Self, Error = std::rc::Rc<config::Account>> {
        let XmppConnection { account, inner } = self;
        if let Some((sink, stream)) = inner {
            use tokio::prelude::Sink;
    fn initial_roster<F, E>(
        self,
        stop_future: F,
    ) -> impl Future<Item = Self, Error = std::rc::Rc<config::Account>>
    where
        F: Future<Error = E>,
        E: Into<failure::Error>,
    {
        let XmppConnection {
            account,
            inner: client,
        } = self;
        use tokio::prelude::Sink;
        let id_get_roster: String = "id_get_roster0".to_string();
        let get_roster = stanzas::make_get_roster(&id_get_roster);
        let account2 = account.clone();
        info!("Quering roster... {:?}", get_roster);
        client
            .send(get_roster)
            .map_err(move |e| {
                error!("Error on querying roster: {}", e);
                (account2, Err(failure::SyncFailure::new(e).into()))
            })
            .and_then(move |client| {
                XmppConnection {
                    inner: client,
                    account,
                }
                .processing(
                    move |_conn, event| {
                        if let Event::Stanza(s) = event {
                            use try_from::TryInto;
                            match s.try_into() as Result<xmpp_parsers::iq::Iq, _> {
                                Ok(iq) => {
                                    if let Some(id) = iq.id {
                                        if id == id_get_roster {
                                            match iq.payload {
                                                xmpp_parsers::iq::IqType::Error(_e) => {
                                                    Err(format_err!("Get error instead of roster"))
                                                }
                                                _ => Ok(true),
                                        } else {
                                    } else {
                                        Err(format_err!("Iq stanza without id"))
                                }
                                Err(_e) => Ok(false),
                            }
                        } else {
                            Err(format_err!("Wrong event while waiting roster"))
                        }
                    },
                    stop_future,
                )
            })
            .then(|r| match r {
                Err((account, e)) => {
                    error!(
                        "Cann't wait roster: {}",
                        e.err().map_or_else(
                            || std::borrow::Cow::Borrowed("None"),
                            |e| e.to_string().into()
                        )
                    );
                    future::err(account)
                }
                Ok((conn, _)) => future::ok(conn),
            })
    }
        let XmppConnection {
            account,
            inner: client,
        } = self;
                                    None => future::err("Got closed stream".to_owned()),
                                })
                        })
                        .map_err(|e| format!("waiting self-presence: {}", e)),
                    )
                    .then(|r| match r {
                        Err(e) => {
                            error!("Self-presence waiting error: {}", e);
                            future::err(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>,
        E: Into<failure::Error>,
    {
                                }
                                _ => Err(format_err!("Unknown result of roster")),
                            }
                        } else {
                            Ok(false)
                                    }
                                        }
                                        Err(e) => Err(format_err!("Cann't parse roster: {}", e)),
                                            Ok(false)
                                            future::err("Got wrong event".to_owned())
                                            Ok(true)
                                            }
            let presence = stanzas::make_presence(&account);
            info!("Sending presence...");
            Box::new(
                sink.send(presence)
                    .map_err(|e| {
                        error!("Error on send self-presence: {}", e);
                        "Cann't send self-presence".to_owned()
                    })
                    .join(
                        future::loop_fn((account.clone(), stream), |(account, stream)| {
                            stream
                                .into_future()
                                .map_err(|(e, _)| {
                                    error!("Error on reading self-presence: {}", e);
                                    "Cann't read self-presence".to_owned()
                                })
                                .and_then(|(event, stream)| match event {
                                    Some(event) => {
                                        if let tokio_xmpp::Event::Stanza(e) = event {
                                            info!("Get stanza: {:?}", e);
                                            if e.name() == "presence"
                                                && e.attr("from")
                                                    .map_or(false, |f| f == account.jid)
                                                && e.attr("to").map_or(false, |f| f == account.jid)
                                            {
                                                info!("Self presence");
                                                future::ok(future::Loop::Break(stream))
                                            } else {
                                                future::ok(future::Loop::Continue((
                                                    account, stream,
                                                )))
        let XmppConnection {
            account,
            inner: client,
        } = self;
    fn self_presence(self) -> impl Future<Item = Self, Error = std::rc::Rc<config::Account>> {
        let XmppConnection { account, inner } = self;
        let client = inner;
    fn process_initial_roster(&mut self, event: Event) -> Result<bool, failure::Error> {
        if let Event::Stanza(s) = event {
            use try_from::TryInto;
            match s.try_into() as Result<xmpp_parsers::iq::Iq, _> {
                Ok(iq) => {
                    if let Some(id) = iq.id {
                        if id == ID_GET_ROSTER {
                            match iq.payload {
                                xmpp_parsers::iq::IqType::Error(_e) => {
                                    Err(format_err!("Get error instead of roster"))
                                }
                                xmpp_parsers::iq::IqType::Result(Some(result)) => {
                                    match result.try_into()
                                        as Result<xmpp_parsers::roster::Roster, _>
                                    {
                                        Ok(roster) => {
                                            info!("Got roster:");
                                            for i in roster.items {
                                                info!(" >>> {:?}", i);
impl XmppConnection {
                                    } else {
                                        } else {
                                            future::err((xmpp.account, Ok(Either::A(b))))
                                        }
                                                }
                                            }
                                        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))))
    /// get connection and wait for online status and set presence
    /// returns error if something went wrong
                        }
                    }
    }
    fn initial_roster<F, E>(
        self,
        stop_future: F,
    ) -> impl Future<Item = Self, Error = std::rc::Rc<config::Account>>
    where
        F: Future<Error = E>,
        E: Into<failure::Error>,
    {
        let XmppConnection {
            account,
            inner: client,
        } = self;
        use tokio::prelude::Sink;
        let account2 = account.clone();
        info!("Quering roster... {:?}", get_roster);
        client
            .send(get_roster)
            .map_err(move |e| {
                error!("Error on querying roster: {}", e);
                (account2, Err(failure::SyncFailure::new(e).into()))
            })
            .and_then(move |client| {
                XmppConnection {
                    inner: client,
                    account,
                }
            })
            .then(|r| match r {
                Err((account, e)) => {
                    error!(
                        "Cann't wait roster: {}",
                        e.err().map_or_else(
                            || std::borrow::Cow::Borrowed("None"),
                            |e| e.to_string().into()
                        )
                    );
                    future::err(account)
                }
                Ok((conn, _)) => future::ok(conn),
            })
                .processing(XmppConnection::process_initial_roster, stop_future)
                .processing(
                    move |_conn, event| {
                        if let Event::Stanza(s) = event {
                            use try_from::TryInto;
                            match s.try_into() as Result<xmpp_parsers::iq::Iq, _> {
                                Ok(iq) => {
                                    if let Some(id) = iq.id {
                                        if id == id_get_roster {
                                            match iq.payload {
                                                xmpp_parsers::iq::IqType::Error(_e) => {
                                                    Err(format_err!("Get error instead of roster"))
                                                }
                                                _ => Ok(true),
                                            }
                                        } else {
                                            Ok(false)
                                        }
                                    } else {
                                        Err(format_err!("Iq stanza without id"))
                                    }
                                }
                                Err(_e) => Ok(false),
                            }
                        } else {
                            Err(format_err!("Wrong event while waiting roster"))
                        }
                    },
                    stop_future,
                )
        let get_roster = stanzas::make_get_roster(ID_GET_ROSTER);
        let get_roster = stanzas::make_get_roster(&id_get_roster);
    fn self_presence<F, E>(
        self,
        stop_future: F,
    ) -> impl Future<Item = Self, Error = std::rc::Rc<config::Account>>
    where
        F: Future<Error = E>,
        E: Into<failure::Error>,
    {
        let id_get_roster: String = "id_get_roster0".to_string();
                }
                Err(_e) => Ok(false),
            }
        } else {
            Err(format_err!("Wrong event while waiting roster"))
        }
    }
                })
            },
        ))
                    } else {
                        Err(format_err!("Iq stanza without id"))
                    },
                    Err((e, _)) => {
                        error!("xmpp receive error: {}", e);
                        future::err(account)
        match event {
            Event::Online => {
                info!("Online!");
                Ok(true)
            }
            Event::Stanza(s) => {
                warn!("Stanza before online: {:?}", s);
                Ok(false)
            }
            _ => {
                error!("Disconnected while online");
                Err(format_err!("Disconnected while online"))
            }
        }
    }
    fn process_initial_roster(&mut self, event: Event) -> Result<bool, failure::Error> {
        if let Event::Stanza(s) = event {
            use try_from::TryInto;
            match s.try_into() as Result<xmpp_parsers::iq::Iq, _> {
                Ok(iq) => {
                    if let Some(id) = iq.id {
                        if id == ID_GET_ROSTER {
                            match iq.payload {
                                xmpp_parsers::iq::IqType::Error(_e) => {
                                    Err(format_err!("Get error instead of roster"))
                                }
                                xmpp_parsers::iq::IqType::Result(Some(result)) => {
                                    match result.try_into()
                                        as Result<xmpp_parsers::roster::Roster, _>
                                    {
                                        Ok(roster) => {
                                            info!("Got roster:");
                                            for i in roster.items {
                                                info!(" >>> {:?}", i);
                                            }
                                            Ok(true)
                                        }
                                        Err(e) => Err(format_err!("Cann't parse roster: {}", e)),
                                    }
                                }
                                _ => Err(format_err!("Unknown result of roster")),
                            }
                        } else {
                            Ok(false)
        match event {
            Event::Online => {
                info!("Online!");
                Ok(true)
            }
            Event::Stanza(s) => {
                warn!("Stanza before online: {:?}", s);
                Ok(false)
            }
            _ => {
                error!("Disconnected while online");
                Err(format_err!("Disconnected while online"))
            }
        }
    fn online(&mut self, event: Event) -> Result<bool, failure::Error> {
    fn online(&mut self, event: Event) -> Result<bool, failure::Error> {
    fn online(self) -> impl Future<Item = XmppConnection, Error = std::rc::Rc<config::Account>> {
        Box::new(future::loop_fn(
            (self.inner, self.account),
            |(client, account)| {
                client.into_future().then(|r| match r {
                    Ok((event, client)) => match event {
                        Some(Event::Online) => {
                            info!("Online");
                            future::ok(future::Loop::Break(XmppConnection {
                                account,
                                inner: client,
                            }))
                        }
                        Some(Event::Stanza(s)) => {
                            info!("xmpp stanza: {:?}", s);
                            future::ok(future::Loop::Continue((client, account)))
                        }
                        _ => {
                            warn!("Disconnected");
                            future::err(account)
    fn online(&mut self, event: &Event) -> Result<bool, failure::Error> {
    fn online(&mut self, event: &Event) -> Result<bool, failure::Error> {
mod stanzas;
    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,
            })
    }
}
            }
        }
    }
                            }
                        } 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()));
                    }
                } else {
                    info!("Jid {} not in roster", xmpp_to);
                    self.state.data.counter += 1;
                    let id_add_roster = format!("id_add_roster{}", self.state.data.counter);
                    let add_roster = stanzas::make_add_roster(&id_add_roster, xmpp_to.clone());
                    self.state
                        .data
                        .pending_add_roster_ids
                        .insert(id_add_roster, xmpp_to.clone());
                    info!("Adding jid to roster... {:?}", add_roster);
                    self.state.data.send_queue.push_back(add_roster);
                }
            }
        }
    }
    fn process_command(&mut self, cmd: XmppCommand) {
        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);
                }
                            if s.name() == "presence"
                                && s.attr("from").map_or(false, |f| f == conn.account.jid)
                                && s.attr("to").map_or(false, |f| f == conn.account.jid)
                            {
                                Ok(true)
                            } else {
                                Ok(false)
    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(|_| ())
    }
            }
            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);
                            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)
                                }
        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 {
        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),
                })
            })
    }
    /// connects if nothing connected
    /// Error shoud be !
    fn connect<E: 'static>(self) -> impl Future<Item = Self, Error = E> {
        info!("xmpp connection...");
        let XmppConnection { account, inner } = self;
        if let Some(inner) = inner {
            Box::new(future::ok(XmppConnection {
                account,
                inner: Some(inner),
            })) as Box<Future<Item = _, Error = E>>
        } else {
            Box::new(future::loop_fn(account, |account| {
                info!("xmpp initialization...");
                let mut res_client = Client::new(&account.jid, &account.password);
                while let Err(e) = res_client {
                    error!("Cann't init xmpp client: {}", e);
                    res_client = Client::new(&account.jid, &account.password);
                }
                let client = res_client.expect("Cann't init xmpp client");
                info!("xmpp initialized");
                // future to wait for online
                Self::online(client.split(), account)
                    .and_then(Self::self_presence)
                    .then(|r| match r {
                        Ok(conn) => future::ok(future::Loop::Break(conn)),
                        Err(acc) => future::ok(future::Loop::Continue(acc)),
                    })
            }))
        }
    }
pub use xmpp_connection::XmppCommand;
                    self.state.data.send_queue.push_back(add_roster);
                }
            }
        }
    }
    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);
            }
        }
    }
    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,
            })
    }
}
mod xmpp_connection;
use xmpp_connection::MaybeXmppConnection;
    fn process_jid(&mut self, xmpp_to: &xmpp_parsers::Jid) {
        if let Some(ref mut mailbox) = self.state.data.outgoing_mailbox.get_mut(xmpp_to) {
            if !mailbox.is_empty() {
                if let Some(ref mut rdata) = self.state.data.roster.get_mut(xmpp_to) {
                    info!("Jid {} in roster", xmpp_to);
                    let sub_to = match rdata.0 {
                        xmpp_parsers::roster::Subscription::To => true,
                        xmpp_parsers::roster::Subscription::Both => true,
                        _ => false,
                    };
                    if sub_to {
                        info!("Subscribed to {}", xmpp_to);
                        self.state.data.send_queue.extend(
                            mailbox.drain(..).map(|message| {
                                stanzas::make_chat_message(xmpp_to.clone(), message)
                            }),
                        );
                    } else if rdata.1 == xmpp_parsers::roster::Ask::None {
                        info!("Not subscribed to {}", xmpp_to);
                        self.state
                            .data
                            .send_queue
                            .push_back(stanzas::make_ask_subscribe(xmpp_to.clone()));
                    }
                } else {
                    info!("Jid {} not in roster", xmpp_to);
                    self.state.data.counter += 1;
                    let id_add_roster = format!("id_add_roster{}", self.state.data.counter);
                    let add_roster = stanzas::make_add_roster(&id_add_roster, xmpp_to.clone());
                    self.state
                        .data
                        .pending_add_roster_ids
                        .insert(id_add_roster, xmpp_to.clone());
                    info!("Adding jid to roster... {:?}", add_roster);
mod xmpp_connection;
use xmpp_connection::MaybeXmppConnection;
        let presence = stanzas::make_presence(&account);
        let account2 = account.clone();
        info!("Sending presence... {:?}", presence);
impl XmppConnection {
    /// base XMPP processing
    /// Returns false on error to disconnect
    fn xmpp_processing(&mut self, event: &Event) -> bool {
        match event {
            Event::Stanza(stanza) => {
                info!("Incoming xmpp event: {:?}", stanza);
                let stanza = stanza.clone();
                use std::convert::TryInto;
                if let Some(iq) = stanza.clone().try_into().ok() as Option<xmpp_parsers::iq::Iq> {
                    if let Some((_, jid)) =
                        self.state.data.pending_add_roster_ids.remove_entry(&iq.id)
                    {
                        if let xmpp_parsers::iq::IqType::Result(None) = iq.payload {
                            if self.state.data.roster.contains_key(&jid) {
                                info!("Jid {} updated to roster", jid);
                            } else {
                                info!("Jid {} added in roster", jid);
                                self.state.data.roster.insert(
                                    jid.clone(),
                                    (
                                        xmpp_parsers::roster::Subscription::None,
                                        xmpp_parsers::roster::Ask::None,
                                    ),
                                );
                            }
                            self.process_jid(&jid);
                        } else {
                            warn!(
                                "Wrong payload when adding {} to roster: {:?}",
                                jid, iq.payload
                            );
                        }
                    }
                    match iq.payload {
                        xmpp_parsers::iq::IqType::Set(element) => {
                            if let Some(roster) =
                                element.try_into().ok() as Option<xmpp_parsers::roster::Roster>
                            {
                                for i in roster.items {
                                    if let Some(ref mut rdata) =
                                        self.state.data.roster.get_mut(&i.jid)
                                    {
                                        info!("Update {} in roster", i.jid);
                                        rdata.0 = i.subscription;
                                        rdata.1 = i.ask;
                                    } else {
                                        info!("Add {} to roster", i.jid);
                                        self.state
                                            .data
                                            .roster
                                            .insert(i.jid.clone(), (i.subscription, i.ask));
                                    }
                                    self.process_jid(&i.jid);
                                }
                            }
                        }
                        xmpp_parsers::iq::IqType::Error(e) => {
                            error!("iq error: {:?}", e);
                            return false;
                        }
                        xmpp_parsers::iq::IqType::Get(element) => {
                            if let Some(_ping) =
                                element.try_into().ok() as Option<xmpp_parsers::ping::Ping>
                            {
                                let pong = stanzas::make_pong(
                                    &iq.id,
                                    self.state.client.jid.clone(),
                                    iq.from,
                                );
                                self.state.data.send_queue.push_back(pong);
                            }
                        }
                        _ => (), // ignore
                    }
                } else if let Some(_presence) =
                    stanza.try_into().ok() as Option<xmpp_parsers::presence::Presence>
                {
                    // to do something with presence
                }
                true
            }
            Event::Online => true,
            e => {
                warn!("Unexpected event {:?}", e);
                false
            }
        }
    }
    /// 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
    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;
    fn xmpp_processing(
        mut self,
        event: &Event,
    ) -> impl Future<Item = Self, Error = std::rc::Rc<config::Account>> {
                use try_from::TryInto;
                if let Some(iq) = stanza.try_into().ok() as Option<xmpp_parsers::iq::Iq> {
                    if let Some(id) = iq.id {
                        if let Some((_, jid)) =
                            self.state.data.pending_add_roster_ids.remove_entry(&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);
                                warn!(
                                    "Wrong payload when adding {} to roster: {:?}",
                                    jid, iq.payload
                            self.process_jid(&jid);
                        } else {
                            warn!(
                                "Wrong payload when adding {} to roster: {:?}",
                                jid, iq.payload
                            );
                    if let xmpp_parsers::iq::IqType::Set(element) = iq.payload {
                        if let Some(roster) =
                            element.try_into().ok() as Option<xmpp_parsers::roster::Roster>
                        {
                            for i in roster.items {
                                if let Some(ref mut rdata) = self.state.data.roster.get_mut(&i.jid)
                                {
                                    info!("Update {} in roster", i.jid);
                                    rdata.0 = i.subscription;
                                    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);
                        _ => (), // ignore
                } else if let Some(_presence) =
                    stanza.try_into().ok() as Option<xmpp_parsers::presence::Presence>
                {
                    // to do something with presence
                future::ok(self)
            Event::Online => future::ok(self),
                future::err(self.account)
    fn process_initial_roster(&mut self, event: Event, id_init_roster: &str) -> Result<bool, ()> {
            use std::convert::TryInto;
                    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(())
                                    Err(e) => {
                                        error!("Cann't parse roster: {}", e);
                                        Err(())
                                    }
                            }
                            _ => {
                                error!("Unknown result of roster");
                                Err(())
                        } else {
                            Ok(false)
                        Ok(false)
            }
        }
                                                self.state
                                                    .data
                                                    .roster
                                                    .insert(i.jid, (i.subscription, vec![]));
                        if Some(id) == self.state.data.id_init_roster {
                                                self.state.data.roster.insert(i.jid, ());
                                    error!("Get error instead of roster");
                                    Err(())
    fn process_initial_roster(&mut self, event: Event) -> Result<bool, ()> {
                        if id == id_init_roster {
    fn process_initial_roster(&mut self, event: Event, id_init_roster: &str) -> Result<bool, ()> {
                                                self.state.data.roster.insert(i.jid, ());
                                            info!("Got roster:");
                                            self.state.data.roster.clear();
                                            info!("Got first roster:");
                        if id == ID_GET_ROSTER {
                                            self.state.data.roster.clear();
                                            info!("Got first roster:");
                        if Some(id) == self.state.data.id_init_roster {
    fn process_initial_roster(&mut self, event: Event) -> Result<bool, ()> {
                                    Err(format_err!("Get error instead of roster"))
    fn process_initial_roster(&mut self, event: Event) -> Result<bool, failure::Error> {
                                        }
                                        Err(e) => {
                                            error!("Cann't parse roster: {}", e);
                                            Err(())
                                        Err(e) => {
                                            error!("Cann't parse roster: {}", e);
                                            Err(())
                                        Err(e) => Err(format_err!("Cann't parse roster: {}", e)),
                                }
                                _ => {
                                    error!("Unknown result of roster");
                                    Err(())
                                _ => {
                                    error!("Unknown result of roster");
                                    Err(())
                                _ => Err(format_err!("Unknown result of roster")),
                        }
                        error!("Iq stanza without id");
                        Err(())
                        Err(format_err!("Iq stanza without id"))
                        error!("Iq stanza without id");
                        Err(())
                        Err(format_err!("Iq stanza without id"))
                        error!("Iq stanza without id");
                        Err(())
                        Some(Event::Stanza(s)) => {
                            info!("xmpp stanza: {:?}", s);
                            future::ok(future::Loop::Continue((client, account)))
                        }
                        _ => {
                            warn!("Disconnected");
                            future::err(account)
                    } else {
                                _ => {
                                    error!("Unknown result of roster");
                                    Err(())
                                }
                                }
                            }
                        } else {
                            Ok(false)
                                _ => Err(format_err!("Unknown result of roster")),
                                }
                                        Err(e) => {
                                            error!("Cann't parse roster: {}", e);
                                            Err(())
                                        }
                                        }
                                    }
                                        Err(e) => Err(format_err!("Cann't parse roster: {}", e)),
                                        }
                                            }
                                            Ok(true)
                                            for i in roster.items {
                                                info!(" >>> {:?}", i);
                                            info!("Got roster:");
                                }
                                xmpp_parsers::iq::IqType::Result(Some(result)) => {
                                    match result.try_into()
                                        as Result<xmpp_parsers::roster::Roster, _>
                                    {
                                        Ok(roster) => {
                                    error!("Get error instead of roster");
                                    Err(())
                            match iq.payload {
                                xmpp_parsers::iq::IqType::Error(_e) => {
                        if id == ID_GET_ROSTER {
        if let Event::Stanza(s) = event {
            use try_from::TryInto;
            match s.try_into() as Result<xmpp_parsers::iq::Iq, _> {
                Ok(iq) => {
                    if let Some(id) = iq.id {
    fn process_initial_roster(&mut self, event: Event) -> Result<bool, ()> {
                                    Err(format_err!("Get error instead of roster"))
    fn process_initial_roster(&mut self, event: Event) -> Result<bool, failure::Error> {
                                    error!("Get error instead of roster");
                                    Err(())
    fn process_initial_roster(&mut self, event: Event) -> Result<bool, ()> {
    }
        } else {
            error!("Wrong event while waiting roster");
            Err(())
                        Ok(false)
                        error!("Iq stanza without id");
                        Err(())
                        Ok(false)
                        error!("Iq stanza without id");
                        Err(())
                    }
                }
                Err(_e) => Ok(false),
                        error!("Iq stanza without id");
                        Err(())
                        } else {
                            Ok(false)
                            _ => {
                                error!("Unknown result of roster");
                                Err(())
                            }
                        }
                    } else {
                                _ => {
                                    error!("Unknown result of roster");
                                    Err(())
                                }
                        } else {
                            Ok(false)
                                    Err(e) => {
                                        error!("Cann't parse roster: {}", e);
                                        Err(())
                                    }
                                }
                                }
                            }
                            }
                            _ => {
                                error!("Unknown result of roster");
                                Err(())
                                _ => {
                                    error!("Unknown result of roster");
                                    Err(())
                                _ => {
                                    error!("Unknown result of roster");
                                    Err(())
                                }
                                        Ok(true)
                                        Err(e) => {
                                            error!("Cann't parse roster: {}", e);
                                            Err(())
                                        }
                                        Ok(true)
                                        Err(e) => {
                                            error!("Cann't parse roster: {}", e);
                                            Err(())
                                        }
                                    }
                    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));
                    if let Some(id) = iq.id {
                        if 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)
                    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));
                    if let Some(id) = iq.id {
                        if id == ID_GET_ROSTER {
                            match iq.payload {
                                xmpp_parsers::iq::IqType::Error(_e) => {
                                    error!("Get error instead of roster");
                                    Err(())
                                }
                                xmpp_parsers::iq::IqType::Result(Some(result)) => {
                                    match result.try_into()
                                        as Result<xmpp_parsers::roster::Roster, _>
                                    {
                                        Ok(roster) => {
                                            self.state.data.roster.clear();
                                            info!("Got first roster:");
                                            for i in roster.items {
                                                info!(" >>> {:?}", i);
                                                self.state.data.roster.insert(i.jid, ());
                                            }
                                            Ok(true)
                                        }
                                        Err(e) => {
                                            error!("Cann't parse roster: {}", e);
                                            Err(())
                    if let Some(id) = iq.id {
                            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);
                                                    .insert(i.jid, (i.subscription, vec![]));
                                        }
                                                    .insert(i.jid, (i.subscription, vec![]));
                                                    .insert(i.jid, (i.subscription, i.ask, vec![]));
                                            }
                                            Ok(true)
                                                    .insert(i.jid, (i.subscription, i.ask));
                                                self.state
                                                    .data
                                                    .roster
                                                self.state.data.roster.insert(i.jid, ());
                                                self.state
                                                    .data
                                                    .roster
                                                self.state.data.roster.insert(i.jid, ());
                                                self.state
                                                    .data
                                                    .roster
                                                    .insert(i.jid, (i.subscription, vec![]));
                        if Some(id) == self.state.data.id_init_roster {
                        if id == id_init_roster {
            use std::convert::TryInto;
            use try_from::TryInto;
            use try_from::TryInto;
            match s.try_into() as Result<xmpp_parsers::iq::Iq, _> {
                Ok(iq) => {
                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 {
                                            state: XmppState { client, data },
                                            account,
                                        };
                                                }
                                            }
                                    } else {
                                    }
                                }
                                Ok(Either::B((t, a))) => {
                                        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);
                                }
                                Err(Either::B((e, a))) => {
                                        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 {
            match s.try_into() as Result<xmpp_parsers::iq::Iq, _> {
                Ok(iq) => {
                                        }
                                    }
                                }
                            }
                        }
                    } else {
                    }
                }
                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;
                        error!("Iq stanza without id");
                        Err(())
                        Ok(false)
                        } else {
                            Ok(false)
                            _ => {
                                error!("Unknown result of roster");
                                Err(())
                            }
                                }
                                _ => {
                                    error!("Unknown result of roster");
                                    Err(())
                                    Err(e) => {
                                        error!("Cann't parse roster: {}", e);
                                        Err(())
                                    }
                                        Err(e) => {
                                            error!("Cann't parse roster: {}", e);
                                            Err(())
                                        }
                                        Ok(true)
                    if let Some(id) = iq.id {
                        if 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)
                    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));
            use try_from::TryInto;
            use std::convert::TryInto;
                                    })
                                    }
                                    Box::new(if let Some(client) = a.into_inner() {
                                    if let Some(client) = a.into_inner() {
                                    Box::new(future::err((account, Ok(Either::A(b)))))
                                    future::err((account, Ok(Either::A(b))))
                                    })
                                    }
                                    Box::new(if let Some(client) = a.into_inner() {
                                    if let Some(client) = a.into_inner() {
                                        Box::new(future::err((account, Ok(Either::A(b)))))
                                        future::err((account, Ok(Either::A(b))))
                                            Err(account) => {
                                                future::err((account, Ok(Either::A(b))))
                                            }
                                        }))
                                            as Box<dyn Future<Item = _, Error = _>>
                                        } else {
                                            future::err((xmpp.account, Ok(Either::A(b))))
                                        }
                                        Box::new(xmpp.xmpp_processing(&event).then(|r| match r {
                                            Ok(mut xmpp) => {
                                                match stop_condition(&mut xmpp, event) {
                                                    Ok(true) => future::ok(future::Loop::Break((
                                                        xmpp,
                                                        Ok(Either::A(b)),
                                                    ))),
                                                    Ok(false) => {
                                                        future::ok(future::Loop::Continue((
                                                            xmpp,
                                                            b,
                                                            stop_condition,
                                                        )))
                                                    }
                                                    Err(_e) => future::err((
                                                        xmpp.account,
                                                        Ok(Either::A(b)),
                                                    )),
                                        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))))
                                        let xmpp = XmppConnection {
                                        let mut xmpp = XmppConnection {
    fn process_initial_roster(&mut self, event: Event) -> Result<bool, ()> {
mod xmpp_connection;
use xmpp_connection::MaybeXmppConnection;
    fn process_initial_roster(&mut self, event: Event) -> Result<bool, ()> {
        if let Event::Stanza(s) = event {
    fn process_initial_roster(&mut self, event: Event, id_init_roster: &str) -> Result<bool, ()> {
            }
        }
    }
    /// 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
    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;
                false
            e => {
                warn!("Unexpected event {:?}", e);
            Event::Online => true,
            }
                true
                            }
                        }
                    }
                }
                            }
                        }
                        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);
                                }
                    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);
                                );
                            }
                        }
                    }
                                info!("Jid {} added in roster", jid);
                                self.state.data.roster.insert(
                                    jid.clone(),
                                    (
                                        xmpp_parsers::roster::Subscription::None,
                                        xmpp_parsers::roster::Ask::None,
                                    ),
                            } else {
                use std::convert::TryInto;
                if let Some(iq) = stanza.clone().try_into().ok() as Option<xmpp_parsers::iq::Iq> {
                    if let Some((_, jid)) =
                        self.state.data.pending_add_roster_ids.remove_entry(&iq.id)
                    {
                        if let xmpp_parsers::iq::IqType::Result(None) = iq.payload {
                            if self.state.data.roster.contains_key(&jid) {
                                info!("Jid {} updated to roster", jid);
        match event {
            Event::Stanza(stanza) => {
                info!("Incoming xmpp event: {:?}", stanza);
                let stanza = stanza.clone();
    /// Returns false on error to disconnect
    fn xmpp_processing(&mut self, event: &Event) -> bool {
pub struct XmppConnection {
    account: std::rc::Rc<config::Account>,
    inner: Option<(stream::SplitSink<Client>, stream::SplitStream<Client>)>,
}
impl XmppConnection {
    fn new(account: config::Account) -> XmppConnection {
        XmppConnection {
            account: std::rc::Rc::new(account),
            inner: None,
        }
    }
#[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,
}
struct MaybeXmppConnection {
    account: std::rc::Rc<config::Account>,
    state: Option<XmppState>,
}
struct XmppConnection {
    account: std::rc::Rc<config::Account>,
    state: 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
    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
#[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,
}
struct MaybeXmppConnection {
    account: std::rc::Rc<config::Account>,
    state: Option<XmppState>,
}
#[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,
}
struct MaybeXmppConnection {
    account: std::rc::Rc<config::Account>,
    state: Option<XmppState>,
}
struct XmppConnection {
    account: std::rc::Rc<config::Account>,
    state: 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
    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"))
                        }
                    }),
            )
        }
    }
}
    /// get connection and wait for online status and set presence
    fn online(self) -> impl Future<Item = XmppConnection, Error = std::rc::Rc<config::Account>> {
        Box::new(future::loop_fn(
            (self.inner, self.account),
            |(client, account)| {
                client.into_future().then(|r| match r {
                    Ok((event, client)) => match event {
                        Some(Event::Online) => {
                            info!("Online");
                            future::ok(future::Loop::Break(XmppConnection {
                                account,
                                inner: client,
                            }))
                        }
                        Some(Event::Stanza(s)) => {
                            info!("xmpp stanza: {:?}", s);
                            future::ok(future::Loop::Continue((client, account)))
                        }
                        _ => {
                            warn!("Disconnected");
                            future::err(account)
    fn online(self) -> impl Future<Item = XmppConnection, Error = std::rc::Rc<config::Account>> {
        Box::new(future::loop_fn(
            (self.inner, self.account),
            |(client, account)| {
                client.into_future().then(|r| match r {
                    Ok((event, client)) => match event {
                        Some(Event::Online) => {
                            info!("Online");
                            future::ok(future::Loop::Break(XmppConnection {
                                account,
                                inner: client,
                            }))
    fn online(&mut self, event: Event) -> Result<bool, failure::Error> {
        match event {
            Event::Online => {
                info!("Online!");
                Ok(true)
            }
            Event::Stanza(s) => {
                warn!("Stanza before online: {:?}", s);
                Ok(false)
            }
            _ => {
                error!("Disconnected while online");
                Err(format_err!("Disconnected while online"))
            }
        }
    }
    fn process_initial_roster(&mut self, event: Event) -> Result<bool, failure::Error> {
        if let Event::Stanza(s) = event {
            use try_from::TryInto;
            match s.try_into() as Result<xmpp_parsers::iq::Iq, _> {
                Ok(iq) => {
                    if let Some(id) = iq.id {
                        if id == ID_GET_ROSTER {
                            match iq.payload {
                                xmpp_parsers::iq::IqType::Error(_e) => {
                                    Err(format_err!("Get error instead of roster"))
                                }
                                xmpp_parsers::iq::IqType::Result(Some(result)) => {
                                    match result.try_into()
                                        as Result<xmpp_parsers::roster::Roster, _>
                                    {
                                        Ok(roster) => {
                                            info!("Got roster:");
                                            for i in roster.items {
                                                info!(" >>> {:?}", i);
                                                self.state.roster.insert(i.jid, ());
                                            }
                                            Ok(true)
                                        }
                                        Err(e) => Err(format_err!("Cann't parse roster: {}", e)),
                                    }
                                }
                                _ => Err(format_err!("Unknown result of roster")),
                            }
                        } else {
                            Ok(false)
        match event {
            Event::Online => {
                info!("Online!");
                Ok(true)
            }
            Event::Stanza(s) => {
                warn!("Stanza before online: {:?}", s);
                Ok(false)
            }
            _ => {
                error!("Disconnected while online");
                Err(())
                Err(format_err!("Disconnected while online"))
                Err(())
                Err(format_err!("Disconnected while online"))
                Err(format_err!("Disconnected while online"))
                Err(())
            }
        }
    }
                Err(())
    fn online(&mut self, event: Event) -> Result<bool, failure::Error> {
        match event {
            Event::Online => {
                info!("Online!");
                Ok(true)
            }
            Event::Stanza(s) => {
                warn!("Stanza before online: {:?}", s);
                Ok(false)
            }
            _ => {
                error!("Disconnected while online");
                Err(format_err!("Disconnected while online"))
            }
        }
    }
    /// returns error if something went wrong and xmpp connection is broken
    fn online(&mut self, event: Event) -> Result<bool, ()> {
    /// returns error if something went wrong
    fn online(&mut self, event: Event) -> Result<bool, failure::Error> {
    /// returns error if something went wrong and xmpp connection is broken
    fn online(&mut self, event: Event) -> Result<bool, ()> {
    /// returns error if something went wrong
    fn online(&mut self, event: &Event) -> Result<bool, failure::Error> {
    /// returns error if something went wrong
    fn online(&mut self, event: Event) -> Result<bool, failure::Error> {
    /// returns error if something went wrong and xmpp connection is broken
    fn online(&mut self, event: Event) -> Result<bool, ()> {
    /// returns error if something went wrong
    /// returns error if something went wrong and xmpp connection is broken
    fn online(&mut self, event: Event) -> Result<bool, ()> {
    fn self_presence(self) -> impl Future<Item = Self, Error = config::Account> {
        let XmppConnection { account, inner } = self;
        ))
        )
}
impl XmppConnection {
    fn online(self) -> impl Future<Item = XmppConnection, Error = std::rc::Rc<config::Account>> {
            (sink, stream, account),
            |(sink, stream, account)| {
                stream.into_future().then(|r| match r {
                    Ok((event, stream)) => match event {
                                inner: Some((sink, stream)),
                            future::ok(future::Loop::Continue((sink, stream, account)))
                        future::err(account)
                    }
                })
            },
        ))
                },
                Err((e, _)) => {
                    error!("xmpp receive error: {}", e);
                    future::err(account)
                }
            })
        }))
                })
            },
        ))
                },
                Err((e, _)) => {
                    error!("xmpp receive error: {}", e);
                    future::err(account)
                }
            })
        })
                })
            },
        ))
                        }
                        _ => {
                            warn!("Disconnected");
                            future::err(account)
                        }
                    },
                    Err((e, _)) => {
                        error!("xmpp receive error: {}", e);
                            future::ok(future::Loop::Continue((client, account)))
                            }))
                        }
                        Some(Event::Stanza(s)) => {
                            info!("xmpp stanza: {:?}", s);
                                inner: client,
                        Some(Event::Online) => {
                            info!("Online");
                            future::ok(future::Loop::Break(XmppConnection {
                                account,
            (self.inner, self.account),
            |(client, account)| {
                client.into_future().then(|r| match r {
                    Ok((event, client)) => match event {
                    }
                    }
    fn online(&mut self, event: &Event) -> Result<bool, failure::Error> {
        match event {
            Event::Online => {
                info!("Online!");
                Ok(true)
            }
            Event::Stanza(s) => {
                warn!("Stanza before online: {:?}", s);
                Ok(false)
            }
            _ => {
                error!("Disconnected while online");
                Err(format_err!("Disconnected while online"))
            }
        }
    fn online(
        (sink, stream): (stream::SplitSink<Client>, stream::SplitStream<Client>),
        account: std::rc::Rc<config::Account>,
    ) -> impl Future<Item = Self, Error = std::rc::Rc<config::Account>> {
            (sink, stream, account),
            |(sink, stream, account)| {
                stream.into_future().then(|r| match r {
                    Ok((event, stream)) => match event {
                            future::ok(future::Loop::Break(MaybeXmppConnection {
                                inner: Some((sink, stream)),
                            future::ok(future::Loop::Continue((sink, stream, account)))
                            future::ok(future::Loop::Continue((client, account)))
                        }
                        _ => {
                            warn!("Disconnected");
                            future::err(account)
                        }
                    },
                    Err((e, _)) => {
                        error!("xmpp receive error: {}", e);
                            future::ok(future::Loop::Continue((client, account)))
                                inner: client,
                            }))
                        }
                        Some(Event::Stanza(s)) => {
                            info!("xmpp stanza: {:?}", s);
                                inner: client,
                            future::ok(future::Loop::Break(XmppConnection {
                                account,
                            future::ok(future::Loop::Break(XmppConnection {
            (self.inner, self.account),
            |(client, account)| {
                client.into_future().then(|r| match r {
                    Ok((event, client)) => match event {
                        Some(Event::Online) => {
                            info!("Online");
            (self.inner, self.account),
            |(client, account)| {
                client.into_future().then(|r| match r {
                    Ok((event, client)) => match event {
    fn online(self) -> impl Future<Item = XmppConnection, Error = std::rc::Rc<config::Account>> {
        Box::new(future::loop_fn(
    /// get connection and wait for online status and set presence
    /// returns error if something went wrong
    fn online(self) -> impl Future<Item = XmppConnection, Error = std::rc::Rc<config::Account>> {
                    Err(Either::A((_e, b))) => future::err((account, Ok(Either::A(b)))),
                    Err(Either::B((e, a))) => {
                        if let Some(inner) = a.into_inner() {
                            future::ok(future::Loop::Break((
                                XmppConnection { inner, account },
                                Err(e),
                            )))
                        } else {
                            future::err((account, Err(e)))
                        }
                    }
                })
            },
        )
    }
                    _ => {
                        warn!("Disconnected");
                    Ok(Either::B((t, a))) => {
                        if let Some(inner) = a.into_inner() {
                            future::ok(future::Loop::Break((
                                XmppConnection { inner, account },
                                Ok(Either::B(t)),
                            )))
                        } else {
                            future::err((account, Ok(Either::B(t))))
                        }
                    Some(Event::Stanza(s)) => {
                        info!("xmpp stanza: {:?}", s);
                        future::ok(future::Loop::Continue((client, account)))
    fn online(self) -> impl Future<Item = Self, Error = std::rc::Rc<config::Account>> {
        future::loop_fn((self.inner, self.account), |(client, account)| {
            client.into_future().then(|r| match r {
                Ok((event, client)) => match event {
                    Some(Event::Online) => {
                        info!("Online");
                        future::ok(future::Loop::Break(XmppConnection {
                            account,
                            inner: client,
                        }))
    fn online(
        account: std::rc::Rc<config::Account>,
        Box::new(future::loop_fn(
        Box::new(future::loop_fn((client, account), |(client, account)| {
            client.into_future().then(|r| match r {
                Ok((event, client)) => match event {
                    Some(Event::Online) => {
                        info!("Online");
                        future::ok(future::Loop::Break(XmppConnection {
                            account,
                            inner: client,
                        }))
                    }
                    Some(Event::Stanza(s)) => {
                        info!("xmpp stanza: {:?}", s);
                        future::ok(future::Loop::Continue((client, account)))
                    }
                    _ => {
                        warn!("Disconnected");
                            future::ok(future::Loop::Break(MaybeXmppConnection {
                                inner: (sink, stream),
                                inner: Some((sink, stream)),
                            }))
                        }
                        Some(Event::Stanza(s)) => {
                            info!("xmpp stanza: {:?}", s);
                            future::ok(future::Loop::Continue((sink, stream, account)))
                        }
                        _ => {
                            warn!("Disconnected");
                            future::err(account)
                        }
                    },
                    Err((e, _)) => {
                        error!("xmpp receive error: {}", e);
                            future::ok(future::Loop::Break(XmppConnection {
                            future::ok(future::Loop::Break(XmppConnection {
                                account,
        Box::new(future::loop_fn(
            (sink, stream, account),
            |(sink, stream, account)| {
                stream.into_future().then(|r| match r {
                    Ok((event, stream)) => match event {
                        Some(Event::Online) => {
                            info!("Online");
    ) -> impl Future<Item = Self, Error = std::rc::Rc<config::Account>> {
    ) -> impl Future<Item = Self, Error = std::rc::Rc<config::Account>> {
    ) -> impl Future<Item = XmppConnection, Error = std::rc::Rc<config::Account>> {
        account: config::Account,
    ) -> impl Future<Item = Self, Error = config::Account> {
        (sink, stream): (stream::SplitSink<Client>, stream::SplitStream<Client>),
        client: Client,
        (sink, stream): (stream::SplitSink<Client>, stream::SplitStream<Client>),
    /// base XMPP processing
    fn xmpp_processing(&mut self, event: &Event) {}
    /// process event from xmpp stream
    /// returns from future when condition met
    /// or stop future was resolved
    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>,
        S: FnMut(&mut Self, &Event) -> bool,
    {
        future::loop_fn(
            (self, stop_future, stop_condition),
            |(xmpp, stop_future, mut stop_condition)| {
                let XmppConnection { inner, account } = xmpp;
                inner.into_future().select2(stop_future).then(|r| match r {
                    Ok(Either::A(((event, client), b))) => {
                        if let Some(event) = event {
                            let mut xmpp = XmppConnection {
                                inner: client,
                                account,
                            };
                            xmpp.xmpp_processing(&event);
                            if stop_condition(&mut xmpp, &event) {
                                future::ok(future::Loop::Break((xmpp, Ok(Either::A(b)))))
                            } else {
                                future::ok(future::Loop::Continue((xmpp, b, stop_condition)))
                            }
                        } else {
                            future::err((account, Ok(Either::A(b))))
                        }
    /// get connection and wait for online status and set presence
    /// returns error if something went wrong
        )
        )
    }
    }
                    }
                })
                    },
                    Err((e, _)) => {
                        error!("xmpp receive error: {}", e);
                        future::err(account)
            },
                    }
                })
                    })
                        _ => {
                            warn!("Disconnected");
                            future::err(account)
                    }
                    Err(Either::A((_e, b))) => future::err((account, Ok(Either::A(b)))),
                    Err(Either::B((e, a))) => {
                        if let Some(inner) = a.into_inner() {
                            future::ok(future::Loop::Break((
                                XmppConnection { inner, account },
                            )))
                        } else {
                        }
                            future::err((account, Err(e.into())))
                            future::err((account, Err(e)))
                                Err(e.into()),
                                Err(e),
                        Err(Either::B((e, a))) => {
                            if let Some(client) = a.into_inner() {
                                future::ok(future::Loop::Break((
                                    XmppConnection {
                                        state: XmppState { client },
                                        account,
                                    },
                                    Err(e.into()),
                                )))
                            } else {
                                future::err((account, Err(e.into())))
                            }
                    }
                    Err(Either::B((e, a))) => {
                        if let Some(inner) = a.into_inner() {
                            future::ok(future::Loop::Break((
                                XmppConnection { inner, account },
                            )))
                        } else {
                            future::err((account, Err(e)))
                            future::err((account, Err(e.into())))
                            future::err((account, Err(e.into())))
                                Err(e),
                                Err(e.into()),
                                Err(e.into()),
                    Err(Either::A((e, b))) => {
                        warn!("XMPP error: {}", e.0);
                        future::err((account, Ok(Either::A(b))))
                    }
                    Err(Either::A((_e, b))) => future::err((account, Ok(Either::A(b)))),
                    Err(Either::A((_e, b))) => future::err((account, Ok(Either::A(b)))),
                    }
                    Err(Either::A((_e, b))) => future::err((account, Ok(Either::A(b)))),
                    Err(Either::B((e, a))) => {
                            future::ok(future::Loop::Break((
                            )))
                        } else {
                            future::err((account, Err(e)))
                            future::err((account, Err(e.into())))
                                XmppConnection { inner, account },
                                Err(e),
                                XmppConnection { client, account },
                                Err(e.into()),
                        if let Some(inner) = a.into_inner() {
                        if let Some(client) = a.into_inner() {
                    }
                    Err(Either::A((e, b))) => {
                        warn!("XMPP error: {}", e.0);
                        future::err((account, Ok(Either::A(b))))
                    Err(Either::A((_e, b))) => future::err((account, Ok(Either::A(b)))),
                        if let Some(client) = a.into_inner() {
                                XmppConnection {
                                    state: XmppState { client, roster },
                                    account,
                                },
                            )))
                        } else {
                            future::err((account, Err(e.into())))
                            future::err((account, Err(e)))
                                Err(e.into()),
                                XmppConnection { inner, account },
                                Err(e),
                                XmppConnection {
                                    state: XmppState { client, roster },
                                    account,
                                },
                            future::ok(future::Loop::Break((
                        if let Some(inner) = a.into_inner() {
                        if let Some(client) = a.into_inner() {
                    Err(Either::A((e, b))) => {
                        warn!("XMPP error: {}", e.0);
                        future::err((account, Ok(Either::A(b))))
                    }
                    }
                    Err(Either::B((e, a))) => {
                        Some(Event::Stanza(s)) => {
                            info!("xmpp stanza: {:?}", s);
                            future::ok(future::Loop::Continue((sink, stream, account)))
                    }
                    Ok(Either::B((t, a))) => {
                        if let Some(inner) = a.into_inner() {
                            future::ok(future::Loop::Break((
                                XmppConnection { inner, account },
                                Ok(Either::B(t)),
                            )))
                        } else {
                            future::err((account, Ok(Either::B(t))))
                        }
                        Err(Either::A((e, b))) => {
                            warn!("XMPP error: {}", e.0);
                            future::err((account, Ok(Either::A(b))))
                    })
                    }
                    Ok(Either::B((t, a))) => {
                        if let Some(inner) = a.into_inner() {
                            future::ok(future::Loop::Break((
                                XmppConnection { inner, account },
                                Ok(Either::B(t)),
                            )))
                        } else {
                            future::err((account, Ok(Either::B(t))))
                    }
                    Ok(Either::B((t, a))) => {
                            future::ok(future::Loop::Break((
                                Ok(Either::B(t)),
                            )))
                        } else {
                            future::err((account, Ok(Either::B(t))))
                                XmppConnection { inner, account },
                                XmppConnection { client, account },
                        if let Some(inner) = a.into_inner() {
                        if let Some(client) = a.into_inner() {
                                inner: Some((sink, stream)),
                            }))
                            };
                            xmpp.xmpp_processing(&event);
                            }
                        } else {
                            future::err((account, Ok(Either::A(b))))
                        }
                            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, Err(e))),
                            if stop_condition(&mut xmpp, &event) {
                                future::ok(future::Loop::Break((xmpp, Ok(Either::A(b)))))
                            } else {
                                future::ok(future::Loop::Continue((xmpp, b, stop_condition)))
                            };
                            xmpp.xmpp_processing(&event);
                            }
                        } else {
                            future::err((account, Ok(Either::A(b))))
                                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, Err(e))),
                                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, Err(e))),
                            match stop_condition(&mut xmpp, event) {
                            match stop_condition(&mut xmpp, event) {
                            if stop_condition(&mut xmpp, &event) {
                                future::ok(future::Loop::Break((xmpp, Ok(Either::A(b)))))
                            } else {
                                future::ok(future::Loop::Continue((xmpp, b, stop_condition)))
                            match stop_condition(&mut xmpp, &event) {
                            match stop_condition(&mut xmpp, &event) {
    /// get connection and wait for online status and set presence
    /// returns error if something went wrong
    fn online(
        (sink, stream): (stream::SplitSink<Client>, stream::SplitStream<Client>),
        account: std::rc::Rc<config::Account>,
    ) -> impl Future<Item = Self, Error = std::rc::Rc<config::Account>> {
        Box::new(future::loop_fn(
            (sink, stream, account),
            |(sink, stream, account)| {
                stream.into_future().then(|r| match r {
                    Ok((event, stream)) => match event {
                        Some(Event::Online) => {
                            info!("Online");
                            future::ok(future::Loop::Break(XmppConnection {
    /// process event from xmpp stream
    /// returns from future when condition met
    /// or stop future was resolved
    fn processing<S, F, T, E>(
        self,
        stop_condition: S,
        stop_future: F,
    ) -> impl Future<
    >
    where
        F: Future<Item = T, Error = E>,
    {
        future::loop_fn(
            (self, stop_future, stop_condition),
            |(xmpp, stop_future, mut stop_condition)| {
                let XmppConnection { inner, account } = xmpp;
                inner.into_future().select2(stop_future).then(|r| match r {
                    Ok(Either::A(((event, client), b))) => {
                        if let Some(event) = event {
                            let mut xmpp = XmppConnection {
                                inner: client,
                                account,
        E: Into<failure::Error>,
        S: FnMut(&mut Self, &Event) -> Result<bool, failure::Error>,
        S: FnMut(&mut Self, &Event) -> bool,
        Item = (Self, Result<Either<F, T>, failure::Error>),
        Error = (
            std::rc::Rc<config::Account>,
            Result<Either<F, T>, failure::Error>,
        ),
        Item = (Self, Result<Either<F, T>, E>),
        Error = (std::rc::Rc<config::Account>, Result<Either<F, T>, E>),
impl XmppConnection {
    /// base XMPP processing
    /// process event from xmpp stream
    /// returns from future when condition met
    /// or stop future was resolved
    fn processing<S, F, T, E>(
        self,
        stop_condition: S,
        stop_future: F,
    ) -> impl Future<
    >
    where
        F: Future<Item = T, Error = E>,
        S: FnMut(&mut Self, Event) -> Result<bool, failure::Error>,
        S: FnMut(&mut Self, Event) -> Result<bool, failure::Error>,
    {
        future::loop_fn(
            (self, stop_future, stop_condition),
            |(xmpp, stop_future, mut stop_condition)| {
                let XmppConnection { inner, account } = xmpp;
                inner.into_future().select2(stop_future).then(|r| match r {
                    Ok(Either::A(((event, client), b))) => {
                        if let Some(event) = event {
                            let mut xmpp = XmppConnection {
                                inner: client,
        S: FnMut(&mut Self, &Event) -> Result<bool, failure::Error>,
        S: FnMut(&mut Self, &Event) -> Result<bool, failure::Error>,
        S: FnMut(&mut Self, &Event) -> bool,
        E: Into<failure::Error>,
        E: Into<failure::Error>,
        Item = (Self, Result<Either<F, T>, E>),
        Error = (std::rc::Rc<config::Account>, Result<Either<F, T>, E>),
        Item = (Self, Result<Either<F, T>, failure::Error>),
        Error = (
            std::rc::Rc<config::Account>,
            Result<Either<F, T>, failure::Error>,
        ),
        Item = (Self, Result<Either<F, T>, failure::Error>),
        Error = (
            std::rc::Rc<config::Account>,
            Result<Either<F, T>, failure::Error>,
        ),
    fn xmpp_processing(&mut self, event: &Event) {}
    fn xmpp_processing(&mut self, event: &Event) {
        info!("Incoming xmpp event: {:?}", event);
    }
    fn xmpp_processing(&mut self, event: &Event) {
        info!("Incoming xmpp event: {:?}", event);
    }
impl XmppConnection {
    /// base XMPP processing
        self,
                        if let Some((_, (jid, message))) =
                                if let Some(ref mut rdata) = self.state.data.roster.get_mut(&jid) {
                                    rdata.1.push(message);
                                } else {
                                    self.state.data.roster.insert(
                                        jid,
                                        (xmpp_parsers::roster::Subscription::None, vec![message]),
                                    );
                                }
                            } else {
                                warn!(
                                    "Wrong payload when adding {} to roster: {:?}",
                                    jid, iq.payload
                                );
                            for i in roster.items {
                                if let Some(ref mut rdata) = self.state.data.roster.get_mut(&i.jid)
                                {
                                    info!("Update {} in roster", i.jid);
                                    rdata.0 = i.subscription;
                                    if !rdata.1.is_empty() {
                                        let sub_to = match rdata.0 {
                                            xmpp_parsers::roster::Subscription::To => true,
                                            xmpp_parsers::roster::Subscription::Both => true,
                                            _ => false,
                                        };
                                        if sub_to {
                                            info!("Subscribed to {}", i.jid);
                                            let jid = i.jid.clone();
                                            self.state.data.send_queue.extend(
                                                rdata.1.drain(..).map(|message| {
                                                    stanzas::make_chat_message(jid.clone(), message)
                                                }),
                                            )
                                        } else {
                                            info!("Not subscribed to {}", i.jid);
                                            self.state
                                                .data
                                                .send_queue
                                                .push_back(stanzas::make_ask_subscribe(i.jid));
                                        }
                                    }
                                } else {
                                    self.state
                                        .data
                                        .roster
                                        .insert(i.jid, (i.subscription, vec![]));
                                }
                            }
                future::ok(self)
            Event::Online => future::ok(self),
                future::err(self.account)
                future::err(self.account)
            }
        }
    /// or stop future was resolved.
    /// Return item if connection was preserved or error otherwise.
    /// Second part is a state of stop_future
        Item = (Self, Result<Either<F, T>, E>),
        Error = (std::rc::Rc<config::Account>, Result<Either<F, T>, E>),
        F: Future<Item = T, Error = E> + 'static,
        S: FnMut(&mut Self, Event) -> Result<bool, ()> + 'static,
        T: 'static,
        E: 'static,
                let XmppConnection {
                    state: XmppState { client, roster },
                    account,
                } = xmpp;
                client.into_future().select2(stop_future).then(|r| match r {
                    Ok(Either::A(((event, client), b))) => {
                        if let Some(event) = event {
                            let xmpp = XmppConnection {
                                state: XmppState { client, roster },
                                account,
                            };
                            Box::new(xmpp.xmpp_processing(&event).then(|r| match r {
                                Ok(mut xmpp) => match stop_condition(&mut xmpp, event) {
                                    Err(_e) => future::err((xmpp.account, Ok(Either::A(b)))),
                                },
                                Err(account) => future::err((account, Ok(Either::A(b)))),
                            })) as Box<dyn Future<Item = _, Error = _>>
                        } else {
                            Box::new(future::err((account, Ok(Either::A(b)))))
                    }
                    Ok(Either::B((t, a))) => Box::new(if let Some(client) = a.into_inner() {
                        future::ok(future::Loop::Break((
                            XmppConnection {
                                state: XmppState { client, roster },
                                account,
                            },
                            Ok(Either::B(t)),
                        )))
                    } else {
                        future::err((account, Ok(Either::B(t))))
                    }),
                    Err(Either::A((e, b))) => {
                        warn!("XMPP error: {}", e.0);
                        Box::new(future::err((account, Ok(Either::A(b)))))
                    }
                    Err(Either::B((e, a))) => Box::new(if let Some(client) = a.into_inner() {
                        future::ok(future::Loop::Break((
                            XmppConnection {
                                state: XmppState { client, roster },
                                account,
                            },
                            Err(e),
                        )))
                    } else {
                        future::err((account, Err(e)))
                    }),
                })
                            future::err((account, Ok(Either::A(b))))
                    }
                    Ok(Either::B((t, a))) => {
                            future::ok(future::Loop::Break((
                                Ok(Either::B(t)),
                            )))
                        } else {
                            future::err((account, Ok(Either::B(t))))
                                XmppConnection {
                                    state: XmppState { client, roster },
                                    account,
                                },
                                XmppConnection { inner, account },
                                XmppConnection {
                                    state: XmppState { client, roster },
                                    account,
                                },
                        if let Some(client) = a.into_inner() {
                        if let Some(inner) = a.into_inner() {
                        if let Some(client) = a.into_inner() {
                            } else {
                            }
                        } else {
                            future::err((account, Ok(Either::A(b))))
                                future::ok(future::Loop::Continue((xmpp, b, stop_condition)))
                                future::err((account, Ok(Either::B(t))))
                        Ok(Either::B((t, a))) => {
                            if let Some(client) = a.into_inner() {
                                future::ok(future::Loop::Break((
                                    XmppConnection {
                                        state: XmppState { client },
                                        account,
                                    },
                                    Ok(Either::B(t)),
                                )))
                        Err(Either::B((e, a))) => {
                            if let Some(client) = a.into_inner() {
                                future::ok(future::Loop::Break((
                                    XmppConnection {
                                        state: XmppState { client },
                                        account,
                                    },
                                    Err(e.into()),
                                )))
                            } else {
                                future::err((account, Err(e.into())))
                            }
                        Err(Either::A((e, b))) => {
                            warn!("XMPP error: {}", e.0);
                        }
                    })
                                    Err(e) => future::err((xmpp.account, Err(e))),
                            } else {
                                future::err((account, Ok(Either::A(b))))
                        } else {
                        }
                        }
                        Ok(Either::B((t, a))) => {
                            if let Some(client) = a.into_inner() {
                                future::ok(future::Loop::Break((
                                    XmppConnection {
                                        state: XmppState { client },
                                        account,
                                    },
                                    Ok(Either::B(t)),
                                )))
                            } else {
                                future::err((account, Ok(Either::B(t))))
                            }
                                Err(_e) => future::err((xmpp.account, Ok(Either::A(b)))),
                                }
                            }
                                    Err(e) => future::err((xmpp.account, Err(e))),
                                }
                            }
                        }
                                    state: XmppState { client, data },
                                Ok(Either::B(t)),
                            )))
                            future::err((account, Ok(Either::B(t))))
                        }),
                        Err(Either::A((e, b))) => {
                            warn!("XMPP error: {}", e.0);
                        Err(Either::B((e, a))) => Box::new(if let Some(client) = a.into_inner() {
                            future::ok(future::Loop::Break((
                                XmppConnection {
                                    state: XmppState { client, data },
                                    account,
                                },
                                Err(e),
                            )))
                        } else {
                            future::err((account, Err(e)))
                        }),
                    })
                    }
                    Ok(Either::B((t, a))) => Box::new(if let Some(client) = a.into_inner() {
                        future::ok(future::Loop::Break((
                            XmppConnection {
                                state: XmppState { client, roster },
                                account,
                            },
                            Ok(Either::B(t)),
                        )))
                    } else {
                        future::err((account, Ok(Either::B(t))))
                    }),
                    Err(Either::A((e, b))) => {
                        warn!("XMPP error: {}", e.0);
                        Box::new(future::err((account, Ok(Either::A(b)))))
                    }
                    Err(Either::B((e, a))) => Box::new(if let Some(client) = a.into_inner() {
                        future::ok(future::Loop::Break((
                            XmppConnection {
                                state: XmppState { client, roster },
                                account,
                            },
                            Err(e),
                        )))
                    } else {
                        future::err((account, Err(e)))
                    }),
                })
                        Err(Either::B((e, a))) => {
                            if let Some(client) = a.into_inner() {
                                future::ok(future::Loop::Break((
                                    XmppConnection {
                                        state: XmppState { client },
                                        account,
                                    Err(e.into()),
                                )))
                            } else {
                                future::err((account, Err(e.into())))
                            }
                                    account,
                                },
                                Err(e),
                            )))
                        } else {
                            future::err((account, Err(e)))
                        }),
                                    },
                        }
                                    state: XmppState { client, data },
                                    state: XmppState {
                                        client,
                                        roster,
                                        counter,
                        Err(Either::B((e, a))) => Box::new(if let Some(client) = a.into_inner() {
                            future::ok(future::Loop::Break((
                                XmppConnection {
                        Err(Either::A((e, b))) => {
                            warn!("XMPP error: {}", e.0);
                            future::err((account, Ok(Either::A(b))))
                            Box::new(future::err((account, Ok(Either::A(b)))))
                            future::err((account, Ok(Either::B(t))))
                        }),
                                Err(account) => future::err((account, Ok(Either::A(b)))),
                            })) as Box<dyn Future<Item = _, Error = _>>
                        } else {
                                Ok(Either::B(t)),
                            )))
                                },
                                    },
                                    Ok(Either::B(t)),
                                )))
                            } else {
                                future::err((account, Ok(Either::B(t))))
                            }
                        }
                                    account,
                                    state: XmppState {
                                        client,
                                        roster,
                                        counter,
                        Ok(Either::B((t, a))) => {
                            if let Some(client) = a.into_inner() {
                                future::ok(future::Loop::Break((
                                    XmppConnection {
                                        state: XmppState { client },
                                        account,
                        Ok(Either::B((t, a))) => Box::new(if let Some(client) = a.into_inner() {
                            future::ok(future::Loop::Break((
                                XmppConnection {
                                future::err((account, Ok(Either::A(b))))
                                Box::new(future::err((account, Ok(Either::A(b)))))
                            } else {
                let XmppConnection {
                    state: XmppState { client, roster },
                    account,
                } = xmpp;
                client.into_future().select2(stop_future).then(|r| match r {
                                state: XmppState { client, roster },
                            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, Err(e))),
                            } else {
                                future::err((account, Ok(Either::A(b))))
                            if stop_condition(&mut xmpp, &event) {
                                future::ok(future::Loop::Break((xmpp, Ok(Either::A(b)))))
                            } else {
                                future::ok(future::Loop::Continue((xmpp, b, stop_condition)))
                                }
                            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)))
                                account,
                            };
                            xmpp.xmpp_processing(&event);
                                inner: client,
                                state: XmppState { client, roster },
                    Ok(Either::A(((event, client), b))) => {
                        if let Some(event) = event {
                            let mut xmpp = XmppConnection {
                let XmppConnection { inner, account } = xmpp;
                inner.into_future().select2(stop_future).then(|r| match r {
                            let mut xmpp = XmppConnection {
                                inner: client,
                                account,
                            };
                            if stop_condition(&mut xmpp, &event) {
                                future::ok(future::Loop::Break((xmpp, Ok(Either::A(b)))))
                            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, Err(e))),
                            let mut xmpp = XmppConnection { client, account };
                            xmpp.xmpp_processing(&event);
                let XmppConnection { inner, account } = xmpp;
                inner.into_future().select2(stop_future).then(|r| match r {
                let XmppConnection { state, account } = xmpp;
                state
                    .client
                    .into_future()
                    .select2(stop_future)
                    .then(|r| match r {
                        Ok(Either::A(((event, client), b))) => {
                            if let Some(event) = event {
                                let mut xmpp = XmppConnection {
                                    state: XmppState { client },
                                    account,
                                };
                                xmpp.xmpp_processing(&event);
                                match stop_condition(&mut xmpp, event) {
                                    Ok(true) => {
                                        future::ok(future::Loop::Break((xmpp, Ok(Either::A(b)))))
                                    }
                                    Ok(false) => future::ok(future::Loop::Continue((
                                        xmpp,
                                        b,
                                        stop_condition,
                                    ))),
                                    Err(e) => future::err((xmpp.account, Err(e))),
                let XmppConnection { state, account } = xmpp;
                state
                    .client
                    .into_future()
                    .select2(stop_future)
                    .then(|r| match r {
                        Ok(Either::A(((event, client), b))) => {
                            if let Some(event) = event {
                                let mut xmpp = XmppConnection {
                                    state: XmppState { client },
                                    account,
                                };
                                xmpp.xmpp_processing(&event);
                                match stop_condition(&mut xmpp, event) {
                                    Ok(true) => {
                                        future::ok(future::Loop::Break((xmpp, Ok(Either::A(b)))))
                                    }
                                    Ok(false) => future::ok(future::Loop::Continue((
                                        xmpp,
                                        b,
                                        stop_condition,
                                    ))),
                let XmppConnection {
                    state: XmppState { client, roster },
                    account,
                } = xmpp;
                client.into_future().select2(stop_future).then(|r| match r {
                let XmppConnection { inner, account } = xmpp;
                inner.into_future().select2(stop_future).then(|r| match r {
                    Ok(Either::A(((event, client), b))) => {
                        if let Some(event) = event {
                            let mut xmpp = XmppConnection {
                                inner: client,
                                account,
                            };
                            xmpp.xmpp_processing(&event);
                            match stop_condition(&mut xmpp, &event) {
                                Ok(true) => {
                                    future::ok(future::Loop::Break((xmpp, Ok(Either::A(b)))))
                                Ok(Either::B((t, a))) => {
                                    Box::new(if let Some(client) = a.into_inner() {
                                        future::ok(future::Loop::Break((
                                            XmppConnection {
                                                state: XmppState { client, data },
                                                account,
                                            },
                                            Ok(Either::B(t)),
                                        )))
                                    } else {
                                        future::err((account, Ok(Either::B(t))))
                                    })
                                Err(Either::A((e, b))) => {
                                    warn!("XMPP error: {}", e.0);
                                    Box::new(future::err((account, Ok(Either::A(b)))))
                                }
                                Err(Either::B((e, a))) => {
                                    Box::new(if let Some(client) = a.into_inner() {
                                        future::ok(future::Loop::Break((
                                            XmppConnection {
                                                state: XmppState { client, data },
                                                account,
                                            },
                                            Err(e),
                                        )))
                                    } else {
                                        future::err((account, Err(e)))
                                    })
                                }
                            }),
                    )
                }
                                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 = _>>
                                        let xmpp = XmppConnection {
                                        Box::new(xmpp.xmpp_processing(&event).then(|r| match r {
                                            Ok(mut xmpp) => {
                                                match stop_condition(&mut xmpp, event) {
                                                    Ok(true) => future::ok(future::Loop::Break((
                                                        xmpp,
                                                        Ok(Either::A(b)),
                                                    ))),
                                                    Ok(false) => {
                                                        future::ok(future::Loop::Continue((
                                                            xmpp,
                                                            b,
                                                            stop_condition,
                                                        )))
                                                    }
                                                    Err(_e) => future::err((
                                                        xmpp.account,
                                                        Ok(Either::A(b)),
                                                    )),
                                            Err(account) => {
                                                future::err((account, Ok(Either::A(b))))
                                            }
                                        }))
                                            as Box<dyn Future<Item = _, Error = _>>
                                        Box::new(future::err((account, Ok(Either::A(b)))))
                                    Box::new(if let Some(client) = a.into_inner() {
                                    })
                                    Box::new(future::err((account, Ok(Either::A(b)))))
                                    Box::new(if let Some(client) = a.into_inner() {
                                    })
                                    })
                                    }
                                    }
                                    }
                                    })
                                }
                            }),
                    )
                }
                                    Box::new(if let Some(client) = a.into_inner() {
                                    if let Some(client) = a.into_inner() {
                                    if let Some(client) = a.into_inner() {
                                    if let Some(client) = a.into_inner() {
                                    Box::new(if let Some(client) = a.into_inner() {
                                        future::ok(future::Loop::Break((
                                            XmppConnection {
                                                state: XmppState { client, data },
                                                account,
                                            },
                                            Err(e),
                                        )))
                                    } else {
                                        future::err((account, Err(e)))
                                    Box::new(future::err((account, Ok(Either::A(b)))))
                                    future::err((account, Ok(Either::A(b))))
                                    future::err((account, Ok(Either::A(b))))
                                    future::err((account, Ok(Either::A(b))))
                                    Box::new(future::err((account, Ok(Either::A(b)))))
                                }
                                Err(Either::B((e, a))) => {
                                    })
                                    }
                                    }
                                    }
                                    })
                                }
                                Err(Either::A((e, b))) => {
                                    warn!("XMPP error: {}", e.0);
                                    Box::new(if let Some(client) = a.into_inner() {
                                    if let Some(client) = a.into_inner() {
                                    if let Some(client) = a.into_inner() {
                                    if let Some(client) = a.into_inner() {
                                    Box::new(if let Some(client) = a.into_inner() {
                                        future::ok(future::Loop::Break((
                                            XmppConnection {
                                                state: XmppState { client, data },
                                                account,
                                            },
                                            Ok(Either::B(t)),
                                        )))
                                    } else {
                                        future::err((account, Ok(Either::B(t))))
                                        Box::new(future::err((account, Ok(Either::A(b)))))
                                        future::err((account, Ok(Either::A(b))))
                                        future::err((account, Ok(Either::A(b))))
                                        future::err((account, Ok(Either::A(b))))
                                        Box::new(future::err((account, Ok(Either::A(b)))))
                                    }
                                }
                                Ok(Either::B((t, a))) => {
                                            Err(account) => {
                                                future::err((account, Ok(Either::A(b))))
                                            }
                                        }))
                                            as Box<dyn Future<Item = _, Error = _>>
                                        } else {
                                            future::err((xmpp.account, Ok(Either::A(b))))
                                        }
                                        } else {
                                            future::err((xmpp.account, Ok(Either::A(b))))
                                        }
                                        } else {
                                            future::err((xmpp.account, Ok(Either::A(b))))
                                        }
                                            Err(account) => {
                                                future::err((account, Ok(Either::A(b))))
                                            }
                                        }))
                                            as Box<dyn Future<Item = _, Error = _>>
                                    } else {
                                        Box::new(xmpp.xmpp_processing(&event).then(|r| match r {
                                            Ok(mut xmpp) => {
                                                match stop_condition(&mut xmpp, event) {
                                                    Ok(true) => future::ok(future::Loop::Break((
                                                        xmpp,
                                                        Ok(Either::A(b)),
                                                    ))),
                                                    Ok(false) => {
                                                        future::ok(future::Loop::Continue((
                                                            xmpp,
                                                            b,
                                                            stop_condition,
                                                        )))
                                                    }
                                                    Err(_e) => future::err((
                                                        xmpp.account,
                                                        Ok(Either::A(b)),
                                                    )),
                                        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))))
                                        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))))
                                        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))))
                                        Box::new(xmpp.xmpp_processing(&event).then(|r| match r {
                                            Ok(mut xmpp) => {
                                                match stop_condition(&mut xmpp, event) {
                                                    Ok(true) => future::ok(future::Loop::Break((
                                                        xmpp,
                                                        Ok(Either::A(b)),
                                                    ))),
                                                    Ok(false) => {
                                                        future::ok(future::Loop::Continue((
                                                            xmpp,
                                                            b,
                                                            stop_condition,
                                                        )))
                                                    }
                                                    Err(_e) => future::err((
                                                        xmpp.account,
                                                        Ok(Either::A(b)),
                                                    )),
                                                }
                                            }
                                        let xmpp = XmppConnection {
                                        let mut xmpp = XmppConnection {
                                        let mut xmpp = XmppConnection {
                                        let mut xmpp = XmppConnection {
                                        let xmpp = XmppConnection {
                                            state: XmppState { client, data },
                                            account,
                                        };
                            })),
                        },
                    )) 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 {
                                Err(e) => future::err((xmpp.account, Err(e))),
                        } else {
                            future::err((account, Ok(Either::A(b))))
                        }
                    }
                    Ok(Either::B((t, a))) => {
                        if let Some(inner) = a.into_inner() {
                            future::ok(future::Loop::Break((
                                XmppConnection { inner, account },
                                Ok(Either::B(t)),
                            )))
                        } else {
                            future::err((account, Ok(Either::B(t))))
                        }
                    }
                    Err(Either::A((_e, b))) => future::err((account, Ok(Either::A(b)))),
                    Err(Either::B((e, a))) => {
                        if let Some(inner) = a.into_inner() {
                            future::ok(future::Loop::Break((
                                XmppConnection { inner, account },
                                Err(e.into()),
                            )))
                        } else {
                            future::err((account, Err(e.into())))
                        }
                    }
                })
                            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)))
                            }
                                }
                            })),
                            Err(Either::A((e, b))) => {
                                warn!("XMPP sending error: {}", e);
                                Box::new(future::err((account, Ok(Either::A(b)))))
                                }
                                Ok(false) => {
                                    future::ok(future::Loop::Continue((xmpp, b, stop_condition)))
                let XmppConnection { state, account } = xmpp;
                state
                    .client
                    .then(|r| match r {
                                let mut xmpp = XmppConnection {
                                    state: XmppState { client },
                                xmpp.xmpp_processing(&event);
                                match stop_condition(&mut xmpp, event) {
                                Box::new(xmpp.xmpp_processing(&event).then(|r| match r {
                                    Ok(mut xmpp) => match stop_condition(&mut xmpp, event) {
                                        Ok(true) => future::ok(future::Loop::Break((
                                            xmpp,
                                            Ok(Either::A(b)),
                                        ))),
                                        Ok(false) => future::ok(future::Loop::Continue((
                                            xmpp,
                                            b,
                                            stop_condition,
                                        ))),
                                        Err(_e) => future::err((xmpp.account, Ok(Either::A(b)))),
                                    },
                                    Err(account) => future::err((account, Ok(Either::A(b)))),
                                }))
                                    as Box<dyn Future<Item = _, Error = _>>
                                    account,
                                };
                                let xmpp = XmppConnection {
                                    state: XmppState { client, data },
                                    state: XmppState {
                                        client,
                                        roster,
                                        counter,
                                    },
                        Ok(Either::A(((event, client), b))) => {
                            if let Some(event) = event {
                    .then(move |r| match r {
                    .into_future()
                    .select2(stop_future)
                let XmppConnection {
                    account,
                } = xmpp;
                    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 = _>>
                    Box::new(client.send(send_element).select2(stop_future).then(
                        move |r| match r {
                            Ok(Either::A((client, b))) => {
                                Box::new(future::ok(future::Loop::Continue((
                                    XmppConnection {
                                        state: XmppState { client, data },
                                        account,
                                    },
                                    b,
                                    stop_condition,
                                ))))
                                    as Box<dyn Future<Item = _, Error = _>>
                            }
                            Ok(Either::B((t, a))) => Box::new(a.then(|r| match r {
                                Ok(client) => future::ok(future::Loop::Break((
                                    XmppConnection {
                                        state: XmppState { client, data },
                                        account,
                                    },
                                    Ok(Either::B(t)),
                                ))),
                                Err(se) => {
                                    warn!("XMPP sending error: {}", se);
                                    future::err((account, Ok(Either::B(t))))
                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)))
                                    }
                                }
                            }),
                    )
                }
                client
                    .into_future()
                    .select2(stop_future)
                    .then(move |r| match r {
                        Ok(Either::A(((event, client), b))) => {
                            if let Some(event) = event {
                                let xmpp = XmppConnection {
                                    state: XmppState { client, data },
                                    account,
                                };
                                Box::new(xmpp.xmpp_processing(&event).then(|r| match r {
                                    Ok(mut xmpp) => match stop_condition(&mut xmpp, event) {
                                        Ok(true) => future::ok(future::Loop::Break((
                                            xmpp,
                                            Ok(Either::A(b)),
                                        ))),
                                        Ok(false) => future::ok(future::Loop::Continue((
                                            xmpp,
                                            b,
                                            stop_condition,
                                        ))),
                                        Err(_e) => future::err((xmpp.account, Ok(Either::A(b)))),
                                    },
                                    Err(account) => future::err((account, Ok(Either::A(b)))),
                                }))
                                    as Box<dyn Future<Item = _, Error = _>>
                            } else {
                                Box::new(future::err((account, Ok(Either::A(b)))))
                            }
                        }
                        Ok(Either::B((t, a))) => Box::new(if let Some(client) = a.into_inner() {
                            future::ok(future::Loop::Break((
                                XmppConnection {
                                    state: XmppState { client, data },
                                    account,
                                },
                                Ok(Either::B(t)),
                            )))
                        } else {
                            future::err((account, Ok(Either::B(t))))
                        }),
                        Err(Either::A((e, b))) => {
                            warn!("XMPP error: {}", e.0);
                            Box::new(future::err((account, Ok(Either::A(b)))))
                        }
                        Err(Either::B((e, a))) => Box::new(if let Some(client) = a.into_inner() {
                            future::ok(future::Loop::Break((
                                XmppConnection {
                                    state: XmppState { client, data },
                                    account,
                                },
                                Err(e),
                            )))
                        } else {
                            future::err((account, Err(e)))
                        }),
                    })
                if let Some(send_element) = data.send_queue.pop_front() {
                    use tokio::prelude::Sink;
                    info!("Sending {:?}", send_element);
                    state: XmppState { client, mut data },
                    state: XmppState { client, data },
                    state: XmppState { client, mut data },
                let XmppConnection { client, account } = xmpp;
                client.into_future().select2(stop_future).then(|r| match r {
                    Ok(Either::A(((event, client), b))) => {
                        if let Some(event) = event {
                let XmppConnection {
                    account,
                } = xmpp;
                                    },
                                    as Box<dyn Future<Item = _, Error = _>>
                                Box::new(future::err((account, Ok(Either::A(b)))))
                            }
                                }
                                        let mut xmpp = XmppConnection {
                                        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))))
                                        }
                                        future::err((account, Ok(Either::A(b))))
                                    if let Some(client) = a.into_inner() {
                                    }
                                    future::err((account, Ok(Either::A(b))))
                                    if let Some(client) = a.into_inner() {
                                    }
                                    })
                                }
                            }),
                    )
                }
                                    Box::new(if let Some(client) = a.into_inner() {
                                        future::ok(future::Loop::Break((
                                            XmppConnection {
                                                state: XmppState { client, data },
                                                account,
                                            },
                                            Err(e),
                                        )))
                                    } else {
                                        future::err((account, Err(e)))
                                    Box::new(future::err((account, Ok(Either::A(b)))))
                                }
                                Err(Either::B((e, a))) => {
                                    })
                                }
                                Err(Either::A((e, b))) => {
                                    warn!("XMPP error: {}", e.0);
                                    Box::new(if let Some(client) = a.into_inner() {
                                        future::ok(future::Loop::Break((
                                            XmppConnection {
                                                state: XmppState { client, data },
                                                account,
                                            },
                                            Ok(Either::B(t)),
                                        )))
                                    } else {
                                        future::err((account, Ok(Either::B(t))))
                                        Box::new(future::err((account, Ok(Either::A(b)))))
                                    }
                                }
                                Ok(Either::B((t, a))) => {
                                            Err(account) => {
                                                future::err((account, Ok(Either::A(b))))
                                            }
                                        }))
                                            as Box<dyn Future<Item = _, Error = _>>
                                    } else {
                                        Box::new(xmpp.xmpp_processing(&event).then(|r| match r {
                                            Ok(mut xmpp) => {
                                                match stop_condition(&mut xmpp, event) {
                                                    Ok(true) => future::ok(future::Loop::Break((
                                                        xmpp,
                                                        Ok(Either::A(b)),
                                                    ))),
                                                    Ok(false) => {
                                                        future::ok(future::Loop::Continue((
                                                            xmpp,
                                                            b,
                                                            stop_condition,
                                                        )))
                                                    }
                                                    Err(_e) => future::err((
                                                        xmpp.account,
                                                        Ok(Either::A(b)),
                                                    )),
                                                }
                                            }
                                        let xmpp = XmppConnection {
                                            state: XmppState { client, data },
                                            account,
                                        };
                        }
                        Ok(Either::B((t, a))) => Box::new(if let Some(client) = a.into_inner() {
                            future::ok(future::Loop::Break((
                                XmppConnection {
                                    state: XmppState { client, data },
                                    account,
                                },
                                Ok(Either::B(t)),
                            )))
                        } else {
                            future::err((account, Ok(Either::B(t))))
                        }),
                        Err(Either::A((e, b))) => {
                            warn!("XMPP error: {}", e.0);
                            Box::new(future::err((account, Ok(Either::A(b)))))
                        }
                        Err(Either::B((e, a))) => Box::new(if let Some(client) = a.into_inner() {
                            future::ok(future::Loop::Break((
                                XmppConnection {
                                    state: XmppState { client, data },
                                    account,
                                },
                                Err(e),
                            )))
                        } else {
                            future::err((account, Err(e)))
                        }),
                    })
                            Err(Either::B((e, a))) => Box::new(a.then(|r| match r {
                                Ok(client) => future::ok(future::Loop::Break((
                                    XmppConnection {
                                        state: XmppState { client, data },
                                        account,
                                    },
                                    Err(e),
                                ))),
                                Err(se) => {
                                    warn!("XMPP sending error: {}", se);
                                    future::err((account, Err(e)))
                                }
                            })),
                        },
                    )) as Box<dyn Future<Item = _, Error = _>>
                } else {
                    Box::new(
                        client
                            .into_future()
                            .select2(stop_future)
                            .then(move |r| match r {
                                Ok(Either::A(((event, client), b))) => {
                                    if let Some(event) = event {
                                        let xmpp = XmppConnection {
                                            state: XmppState { client, data },
                                            account,
                                        };
                                        Box::new(xmpp.xmpp_processing(&event).then(|r| match r {
                                            Ok(mut xmpp) => {
                                                match stop_condition(&mut xmpp, event) {
                                                    Ok(true) => future::ok(future::Loop::Break((
                                                        xmpp,
                                                        Ok(Either::A(b)),
                                                    ))),
                                                    Ok(false) => {
                                                        future::ok(future::Loop::Continue((
                                                            xmpp,
                                                            b,
                                                            stop_condition,
                                                        )))
                                                    }
                                                    Err(_e) => future::err((
                                                        xmpp.account,
                                                        Ok(Either::A(b)),
                                                    )),
                                                }
                                            }
                                            Err(account) => {
                                                future::err((account, Ok(Either::A(b))))
                                            }
                                        }))
                                            as Box<dyn Future<Item = _, Error = _>>
                                    } else {
                                        Box::new(future::err((account, Ok(Either::A(b)))))
                                    }
                        }
                        Ok(Either::B((t, a))) => Box::new(if let Some(client) = a.into_inner() {
                            future::ok(future::Loop::Break((
                                XmppConnection {
                                    state: XmppState { client, data },
                                    account,
                            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 {
                            } else {
                            }
                            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);
                            } else {
                            }
                            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);
                                    Err(account) => future::err((account, Ok(Either::A(b)))),
                                }))
                                    b,
                                    stop_condition,
                                ))))
                                    Err(account) => future::err((account, Ok(Either::A(b)))),
                                }))
                                    b,
                                    stop_condition,
                                ))))
                client
                    .into_future()
                    .select2(stop_future)
                    .then(move |r| match r {
                        Ok(Either::A(((event, client), b))) => {
                            if let Some(event) = event {
                                let xmpp = XmppConnection {
                                    state: XmppState { client, data },
                                    account,
                                };
                                Box::new(xmpp.xmpp_processing(&event).then(|r| match r {
                                    Ok(mut xmpp) => match stop_condition(&mut xmpp, event) {
                                        Ok(true) => future::ok(future::Loop::Break((
                                            xmpp,
                                            Ok(Either::A(b)),
                                        ))),
                                        Ok(false) => future::ok(future::Loop::Continue((
                                            xmpp,
                                            b,
                                            stop_condition,
                                        ))),
                                        Err(_e) => future::err((xmpp.account, Ok(Either::A(b)))),
                if let Some(send_element) = data.send_queue.pop_front() {
                    use tokio::prelude::Sink;
                    info!("Sending {:?}", send_element);
                    Box::new(client.send(send_element).select2(stop_future).then(
                        move |r| match r {
                            Ok(Either::A((client, b))) => {
                                Box::new(future::ok(future::Loop::Continue((
                                    XmppConnection {
                                        state: XmppState { client, data },
                                        account,
                client
                    .into_future()
                    .select2(stop_future)
                    .then(move |r| match r {
                        Ok(Either::A(((event, client), b))) => {
                            if let Some(event) = event {
                                let xmpp = XmppConnection {
                                    state: XmppState { client, data },
                                    account,
                                };
                                Box::new(xmpp.xmpp_processing(&event).then(|r| match r {
                                    Ok(mut xmpp) => match stop_condition(&mut xmpp, event) {
                                        Ok(true) => future::ok(future::Loop::Break((
                                            xmpp,
                                            Ok(Either::A(b)),
                                        ))),
                                        Ok(false) => future::ok(future::Loop::Continue((
                                            xmpp,
                                            b,
                                            stop_condition,
                                        ))),
                                        Err(_e) => future::err((xmpp.account, Ok(Either::A(b)))),
                client.into_future().select2(stop_future).then(|r| match r {
                    Ok(Either::A(((event, client), b))) => {
                        if let Some(event) = event {
                            let xmpp = XmppConnection {
                                state: XmppState { client, roster },
                                account,
                            };
                            Box::new(xmpp.xmpp_processing(&event).then(|r| match r {
                                Ok(mut xmpp) => match stop_condition(&mut xmpp, event) {
                                    Ok(true) => {
                                        future::ok(future::Loop::Break((xmpp, Ok(Either::A(b)))))
                                    }
                                    Ok(false) => future::ok(future::Loop::Continue((
                                        xmpp,
                                        b,
                                        stop_condition,
                                    ))),
                                    Err(_e) => future::err((xmpp.account, Ok(Either::A(b)))),
                if let Some(send_element) = data.send_queue.pop_front() {
                    use tokio::prelude::Sink;
                    info!("Sending {:?}", send_element);
                    Box::new(client.send(send_element).select2(stop_future).then(
                        move |r| match r {
                            Ok(Either::A((client, b))) => {
                                Box::new(future::ok(future::Loop::Continue((
                                    XmppConnection {
                                        state: XmppState { client, data },
                                        account,
                client
                    state: XmppState { client, data },
                    state: XmppState { client, data },
                    state: XmppState { client, mut data },
                    state: XmppState { client, data },
                    state: XmppState { client, roster },
                    state: XmppState { client, mut data },
                    state:
                        XmppState {
                            client,
                            roster,
                            counter,
                        },
        F: Future<Item = T, Error = E>,
        E: Into<failure::Error>,
        S: FnMut(&mut Self, &Event) -> Result<bool, failure::Error>,
        F: Future<Item = T, Error = E>,
        E: Into<failure::Error>,
        S: FnMut(&mut Self, Event) -> Result<bool, failure::Error>,
        F: Future<Item = T, Error = E> + 'static,
        S: FnMut(&mut Self, Event) -> Result<bool, ()> + 'static,
        T: 'static,
        E: 'static,
        F: Future<Item = T, Error = E>,
    {
        future::loop_fn(
            (self, stop_future, stop_condition),
            |(xmpp, stop_future, mut stop_condition)| {
        S: FnMut(&mut Self, &Event) -> bool,
        S: FnMut(&mut Self, &Event) -> bool,
        E: Into<failure::Error>,
        S: FnMut(&mut Self, Event) -> Result<bool, failure::Error>,
        E: Into<failure::Error>,
        S: FnMut(&mut Self, Event) -> Result<bool, failure::Error>,
        S: FnMut(&mut Self, Event) -> Result<bool, ()>,
        E: Into<failure::Error>,
        S: FnMut(&mut Self, Event) -> Result<bool, failure::Error>,
        F: Future<Item = T, Error = E> + 'static,
        S: FnMut(&mut Self, Event) -> Result<bool, ()> + 'static,
        T: 'static,
        E: 'static,
        Item = (Self, Result<Either<F, T>, E>),
        Error = (std::rc::Rc<config::Account>, Result<Either<F, T>, E>),
        Item = (Self, Result<Either<F, T>, E>),
        Error = (std::rc::Rc<config::Account>, Result<Either<F, T>, E>),
        Item = (Self, Result<Either<F, T>, failure::Error>),
        Error = (
            std::rc::Rc<config::Account>,
            Result<Either<F, T>, failure::Error>,
        ),
        Item = (Self, Result<Either<F, T>, failure::Error>),
        Error = (
            std::rc::Rc<config::Account>,
            Result<Either<F, T>, failure::Error>,
        ),
        Item = (Self, Result<Either<F, T>, failure::Error>),
        Error = (
            std::rc::Rc<config::Account>,
            Result<Either<F, T>, failure::Error>,
        ),
        Item = (Self, Result<Either<F, T>, failure::Error>),
        Error = (
            std::rc::Rc<config::Account>,
            Result<Either<F, T>, failure::Error>,
        ),
        Item = (Self, Result<Either<F, T>, E>),
        Error = (std::rc::Rc<config::Account>, Result<Either<F, T>, E>),
        Item = (Self, Result<Either<F, T>, failure::Error>),
        Error = (
            std::rc::Rc<config::Account>,
            Result<Either<F, T>, failure::Error>,
        ),
    >
    where
        Item = (Self, Result<Either<F, T>, E>),
        Error = (std::rc::Rc<config::Account>, Result<Either<F, T>, E>),
    /// or stop future was resolved
    /// or stop future was resolved.
    /// Return item if connection was preserved or error otherwise.
    /// Second part is a state of stop_future
    /// or stop future was resolved
    /// or stop future was resolved
    /// or stop future was resolved.
    /// Return item if connection was preserved or error otherwise.
    /// Second part is a state of stop_future
    fn processing<S, F, T, E>(
        self,
        stop_condition: S,
        stop_future: F,
    ) -> impl Future<
    /// or stop future was resolved
    /// or stop future was resolved.
    /// Return item if connection was preserved or error otherwise.
    /// Second part is a state of stop_future
                false
            Event::Online => future::ok(self),
            e => {
                warn!("Unexpected event {:?}", e);
            Event::Online => true,
                future::ok(self)
            }
                true
                                    (i.jid, ())
                                }));
                        }
                    }
                }
                            self.state
                                .data
                                .roster
                                .extend(roster.items.into_iter().map(|i| {
                                    info!("Add {} to roster", i.jid);
        future::ok(self)
        info!("Incoming xmpp event: {:?}", event);
        future::ok(self)
        match event {
            Event::Stanza(stanza) => {
                info!("Incoming xmpp event: {:?}", stanza);
                let stanza = stanza.clone();
                use try_from::TryInto;
                future::ok(self)
            }
            Event::Online => future::ok(self),
            e => {
                warn!("Unexpected event {:?}", e);
                future::err(self.account)
            }
        }
                if let Some(_iq) = stanza.try_into().ok() as Option<xmpp_parsers::iq::Iq> {}
                if let Some(iq) = stanza.try_into().ok() as Option<xmpp_parsers::iq::Iq> {
                    if let xmpp_parsers::iq::IqType::Set(element) = iq.payload {
                        if let Some(roster) =
                            element.try_into().ok() as Option<xmpp_parsers::roster::Roster>
                        {
                            self.state
                                .data
                                .roster
                                .extend(roster.items.into_iter().map(|i| (i.jid, ())));
                        }
                    }
                }
                            self.state.data.pending_add_roster_ids.remove_entry(&id)
                        {
                            if let xmpp_parsers::iq::IqType::Result(None) = iq.payload {
                                info!("Jid {} added to roster", jid);
                            }
                        }
                    }
                    if let xmpp_parsers::iq::IqType::Set(element) = iq.payload {
                        if let Some(roster) =
                            element.try_into().ok() as Option<xmpp_parsers::roster::Roster>
                        {
                        if let Some((_, (jid, _message))) =
        future::ok(self)
        match event {
            Event::Stanza(stanza) => {
                info!("Incoming xmpp event: {:?}", stanza);
                let stanza = stanza.clone();
                use try_from::TryInto;
                if let Some(iq) = stanza.try_into().ok() as Option<xmpp_parsers::iq::Iq> {
                    if let Some(id) = iq.id {
        mut self,
    }
        info!("Incoming xmpp event: {:?}", event);
        mut self,
        match event {
            Event::Stanza(stanza) => {
                processors.incoming.process(self, stanza.clone())
            Event::Online => future::ok(self),
                future::err(self.account)
            _ => (), // ignore
        true
                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);
                }
        }
                future::err(self.account)
                false
                future::err(self.account)
                false
                false
                future::err(self.account)
            }
            Event::Online => true,
            Event::Online => future::ok(self),
            Event::Online => true,
            Event::Online => future::ok(self),
            Event::Online => true,
            Event::Online => true,
            Event::Online => future::ok(self),
            e => {
                warn!("Unexpected event {:?}", e);
                processors.incoming.process(self, stanza.clone());
                use std::convert::TryInto;
                if let Some(iq) = stanza.clone().try_into().ok() as Option<xmpp_parsers::iq::Iq> {
                    if let Some((_, jid)) =
                        self.state.data.pending_add_roster_ids.remove_entry(&iq.id)
                    {
                        if let xmpp_parsers::iq::IqType::Result(None) = iq.payload {
                            if self.state.data.roster.contains_key(&jid) {
                                info!("Jid {} updated to roster", jid);
                                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
                            );
                    if let xmpp_parsers::iq::IqType::Set(element) = iq.payload {
                        if let Some(roster) =
                            element.try_into().ok() as Option<xmpp_parsers::roster::Roster>
                        {
                            for i in roster.items {
                                if let Some(ref mut rdata) = self.state.data.roster.get_mut(&i.jid)
                                {
                                    info!("Update {} in roster", i.jid);
                                    rdata.0 = i.subscription;
                                    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);
                        _ => (), // ignore
                } else if let Some(_presence) =
                    stanza.try_into().ok() as Option<xmpp_parsers::presence::Presence>
                {
                    // to do something with presence
                future::ok(self)
                future::ok(self)
                true
                true
                true
                future::ok(self)
            }
                } else if let Some(_presence) =
                    stanza.try_into().ok() as Option<xmpp_parsers::presence::Presence>
                {
                    // to do something with presence
                } else if let Some(_presence) =
                    stanza.try_into().ok() as Option<xmpp_parsers::presence::Presence>
                {
                    // to do something with presence
                        xmpp_parsers::iq::IqType::Error(e) => {
                            error!("iq error: {:?}", e);
                            return false;
                        }
                                    &iq.id,
                    }
                }
                                    iq.id,
                                    self.state.client.jid.clone(),
                                    iq.from,
                                );
                                self.state.data.send_queue.push_back(pong);
                            }
                        }
                        _ => (), // ignore
                        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(
                        }
                            }
                        }
                        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);
                                self.process_jid(&i.jid);
                    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);
                            }
                    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);
                    if let xmpp_parsers::iq::IqType::Set(element) = iq.payload {
                        if let Some(roster) =
                            element.try_into().ok() as Option<xmpp_parsers::roster::Roster>
                        {
                                    if !rdata.1.is_empty() {
                                        let sub_to = match rdata.0 {
                                            xmpp_parsers::roster::Subscription::To => true,
                                            xmpp_parsers::roster::Subscription::Both => true,
                                            _ => false,
                                        };
                                        if sub_to {
                                            info!("Subscribed to {}", i.jid);
                                            let jid = i.jid.clone();
                                            self.state.data.send_queue.extend(
                                                rdata.1.drain(..).map(|message| {
                                                    stanzas::make_chat_message(jid.clone(), message)
                                                }),
                                            )
                                        } else {
                                            info!("Not subscribed to {}", i.jid);
                                            self.state
                                                .data
                                                .send_queue
                                                .push_back(stanzas::make_ask_subscribe(i.jid));
                                        }
                                    }
                                    self.state
                                        .data
                                        .roster
                                }
                                        .insert(i.jid, (i.subscription, vec![]));
                                        .insert(i.jid.clone(), (i.subscription, i.ask));
                                    (i.jid, ())
                                }));
                                    self.state
                                        .data
                                        .roster
                                }
                            }
                                        .insert(i.jid, (i.subscription, vec![]));
                                        .insert(i.jid, (i.subscription, i.ask, vec![]));
                                    (i.jid, ())
                                }));
                                    self.state
                                        .data
                                        .roster
                                        .insert(i.jid, (i.subscription, vec![]));
                                }
                            }
                                } else {
                                    if !rdata.1.is_empty() {
                                                rdata.1.drain(..).map(|message| {
                                        } else {
                                            info!("Not subscribed to {}", i.jid);
                                            self.state
                                                .data
                                                .send_queue
                                                .push_back(stanzas::make_ask_subscribe(i.jid));
                                        }
                                    }
                                } else {
                                        } else if rdata.1 == xmpp_parsers::roster::Ask::None {
                                                    stanzas::make_chat_message(jid.clone(), message)
                                                }),
                                            )
                                                rdata.2.drain(..).map(|message| {
                                        let sub_to = match rdata.0 {
                                            xmpp_parsers::roster::Subscription::To => true,
                                            xmpp_parsers::roster::Subscription::Both => true,
                                            _ => false,
                                        };
                                        if sub_to {
                                            info!("Subscribed to {}", i.jid);
                                            let jid = i.jid.clone();
                                            self.state.data.send_queue.extend(
                                    rdata.1 = i.ask;
                                    if !rdata.2.is_empty() {
                                    info!("Add {} to roster", i.jid);
                                    rdata.1 = i.ask;
                            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;
                            self.state
                                .data
                                .roster
                                .extend(roster.items.into_iter().map(|i| {
                            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;
                            self.state
                                .data
                                .roster
                                .extend(roster.items.into_iter().map(|i| {
                            for i in roster.items {
                                if let Some(ref mut rdata) = self.state.data.roster.get_mut(&i.jid)
                                {
                                    info!("Update {} in roster", i.jid);
                                    rdata.0 = i.subscription;
                                    if !rdata.1.is_empty() {
                                        let sub_to = match rdata.0 {
                                            xmpp_parsers::roster::Subscription::To => true,
                                            xmpp_parsers::roster::Subscription::Both => true,
                                            _ => false,
                                        };
                                        if sub_to {
                                            info!("Subscribed to {}", i.jid);
                                            let jid = i.jid.clone();
                                            self.state.data.send_queue.extend(
                                                rdata.1.drain(..).map(|message| {
                                                    stanzas::make_chat_message(jid.clone(), message)
                                                }),
                                            )
                                        } else {
                                            info!("Not subscribed to {}", i.jid);
                                            self.state
                                                .data
                                                .send_queue
                                                .push_back(stanzas::make_ask_subscribe(i.jid));
                                        }
                                    }
                                } else {
                            self.process_jid(&jid);
                        } else {
                            warn!(
                                "Wrong payload when adding {} to roster: {:?}",
                                jid, iq.payload
                            );
                            }
                        }
                    }
                                warn!(
                                    "Wrong payload when adding {} to roster: {:?}",
                                    jid, iq.payload
                                );
                                warn!(
                                    "Wrong payload when adding {} to roster: {:?}",
                                    jid, iq.payload
                                info!("Jid {} added in roster", jid);
                                self.state.data.roster.insert(
                                    jid.clone(),
                                    (
                                        xmpp_parsers::roster::Subscription::None,
                                        xmpp_parsers::roster::Ask::None,
                                    ),
                use try_from::TryInto;
                if let Some(_iq) = stanza.try_into().ok() as Option<xmpp_parsers::iq::Iq> {}
                future::ok(self)
                use try_from::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 {
                    if let Some(id) = iq.id.clone() {
                                info!("Jid {} added to roster", jid);
                                } else {
                                    self.state.data.roster.insert(
                                    );
                                }
                            // to do send message or subscription
                                self.process_jid(&jid);
                                        jid,
                                        (xmpp_parsers::roster::Subscription::None, vec![message]),
                                        jid.clone(),
                                        (
                                            xmpp_parsers::roster::Subscription::None,
                                            xmpp_parsers::roster::Ask::None,
                                        ),
                                    info!("Jid {} added in roster", jid);
                                if let Some(ref mut rdata) = self.state.data.roster.get_mut(&jid) {
                                    rdata.1.push(message);
                                info!("Jid {} added to roster", jid);
                                    rdata.1.push(message);
                                    info!("Jid {} added in roster", jid);
                                        (xmpp_parsers::roster::Subscription::None, vec![message]),
                                    );
                                }
                            } else {
                                warn!(
                                    "Wrong payload when adding {} to roster: {:?}",
                                    jid, iq.payload
                                );
                                        (
                                            xmpp_parsers::roster::Subscription::None,
                                            xmpp_parsers::roster::Ask::None,
                                            vec![message],
                                        ),
                                } else {
                                    self.state.data.roster.insert(
                                        jid,
                                    info!("Jid {} updated to roster", jid);
                                    rdata.2.push(message);
                                if let Some(ref mut rdata) = self.state.data.roster.get_mut(&jid) {
                                if let Some(ref mut rdata) = self.state.data.roster.get_mut(&jid) {
                                    rdata.1.push(message);
                                } else {
                                    self.state.data.roster.insert(
                                        jid,
                                        (xmpp_parsers::roster::Subscription::None, vec![message]),
                                    );
                                }
                            } else {
                                warn!(
                                    "Wrong payload when adding {} to roster: {:?}",
                                    jid, iq.payload
                                );
                            self.state.data.pending_add_roster_ids.remove_entry(&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);
                    if let Some(id) = iq.id {
                        if let Some((_, (jid, message))) =
                        if let Some((_, (jid, _message))) =
                        if let Some((_, (jid, message))) =
                        if let Some((_, (jid, _message))) =
                        if let Some((_, (jid, message))) =
                        if let Some((_, jid)) =
                if let Some(iq) = stanza.try_into().ok() as Option<xmpp_parsers::iq::Iq> {
                if let Some(iq) = stanza.try_into().ok() as Option<xmpp_parsers::iq::Iq> {
                    if let Some(id) = iq.id {
                        if let Some((_, jid)) =
                            self.state.data.pending_add_roster_ids.remove_entry(&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);
                if let Some(iq) = stanza.clone().try_into().ok() as Option<xmpp_parsers::iq::Iq> {
                if let Some(iq) = stanza.clone().try_into().ok() as Option<xmpp_parsers::iq::Iq> {
                if let Some(iq) = stanza.try_into().ok() as Option<xmpp_parsers::iq::Iq> {
                let processors = XmppElementProcessor::new();
                info!("Incoming xmpp event: {:?}", stanza);
                let stanza = stanza.clone();
    /// process event from xmpp stream
    /// returns from future when condition met
        self,
        event: &Event,
    ) -> impl Future<Item = Self, Error = std::rc::Rc<config::Account>> {
    fn xmpp_processing(
        mut self,
        event: &Event,
    ) -> impl Future<Item = Self, Error = std::rc::Rc<config::Account>> {
    fn xmpp_processing(
        self,
        event: &Event,
    ) -> impl Future<Item = Self, Error = std::rc::Rc<config::Account>> {
    fn xmpp_processing(
        mut self,
        event: &Event,
    ) -> impl Future<Item = Self, Error = std::rc::Rc<config::Account>> {
    /// Returns false on error to disconnect
    fn xmpp_processing(&mut self, event: &Event) -> bool {
    fn xmpp_processing(&mut self, _event: &Event) {}
    fn xmpp_processing(&mut self, _event: &Event) {}
    fn xmpp_processing(
        mut self,
        event: &Event,
    ) -> impl Future<Item = Self, Error = std::rc::Rc<config::Account>> {
    /// Returns false on error to disconnect
    fn xmpp_processing(&mut self, event: &Event) -> bool {
    fn xmpp_processing(
        self,
        event: &Event,
    ) -> impl Future<Item = Self, Error = std::rc::Rc<config::Account>> {
    fn xmpp_processing(&mut self, event: &Event) {
        info!("Incoming xmpp event: {:?}", event);
    }
    /// Returns false on error to disconnect
    fn xmpp_processing(&mut self, event: &Event) -> bool {
    /// Returns false on error
    fn xmpp_processing(&mut self, event: &Event) -> bool {
    fn xmpp_processing(&mut self, event: &Event) {
    /// Returns false on error to disconnect
    fn xmpp_processing(&mut self, event: &Event) -> bool {
    fn xmpp_processing(&mut self, event: &Event) {
        info!("Incoming xmpp event: {:?}", event);
    fn xmpp_processing(&mut self, event: &Event) {
    fn xmpp_processing(
        mut self,
        event: &Event,
    ) -> impl Future<Item = Self, Error = std::rc::Rc<config::Account>> {
    fn xmpp_processing(&mut self, event: &Event) {
        info!("Incoming xmpp event: {:?}", event);
    }
    fn xmpp_processing(
    }
}
}
                        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"))
                        }
                    }),
            )
                        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"))
                        }
                    }),
            )
                            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)),
                                }),
                            )
                    .then(|r| match r {
        }
                                .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)),
                                }),
                            )
                            }
                                .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)),
                                }),
                            )
                            }
                            }
                                .processing(XmppConnection::online, stop_future.clone())
                                .map_err(|(acc, _)| acc)
                                .and_then(|(conn, r)| match r {
                                    Ok(Either::A(_)) => future::ok(conn),
                                    Ok(Either::B(_)) => future::err(conn.account),
                                    Err(_e) => future::err(conn.account),
                                })
                                .and_then(|conn| conn.initial_roster(stop_future2))
                                .and_then(|conn| conn.self_presence(stop_future3))
                                .then(|r| match r {
                                    Ok(conn) => future::ok(future::Loop::Break(conn)),
                                    Err(acc) => future::ok(future::Loop::Continue(acc)),
                                }),
                            )
                            }
                        })
                        .map_err(|_: ()| ()),
                    )
                            // future to wait for online
                            Box::new(
                                XmppConnection {
                                    state: XmppState {
                                        client,
                                        data: std::default::Default::default(),
                                    },
                                    account,
                                        XmppConnection {
                                                data: std::default::Default::default(),
                                        .online()
                                        .and_then(XmppConnection::self_presence)
                                            },
                                        ),
                                }
                                            }),
                                    )
                                                Ok(conn) => future::ok(future::Loop::Break(conn)),
                                                Err(acc) => future::ok(future::Loop::Continue(acc)),
                                        .then(
                                            |r| match r {
                                        .online()
                                        .and_then(XmppConnection::self_presence)
                                        .processing(XmppConnection::online, stop_future.clone())
                                        .map(|(conn, _)| conn)
                                        .map_err(|(acc, _)| acc)
                                        .and_then(|conn| conn.initial_roster(stop_future2))
                                        .and_then(|conn| conn.self_presence(stop_future3))
                                        .map(|(conn, _)| conn)
                                        .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, 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.self_presence(stop_future2))
                                        .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),
                                        })
                                        .processing(XmppConnection::online, stop_future.clone())
                                        .map_err(|(acc, _)| acc)
                                        .map(|(conn, _)| conn)
                                        .map(|(conn, _)| conn)
                                            account,
                                        }
                                                data: std::default::Default::default(),
                                                roster: HashMap::new(),
                                                roster: HashMap::new(),
                                                counter: 0,
                                            },
                                            state: XmppState {
                                                client,
                                                roster: HashMap::new(),
                                            },
                                            state: XmppState {
                                                client,
                                                roster: HashMap::new(),
                                            },
                                            inner: client,
                                            inner: client,
                                            state: XmppState { client },
                                            state: XmppState { client },
                                            state: XmppState {
                                                client,
                                                roster: HashMap::new(),
                                            },
                                            inner: client,
                                            state: XmppState { client },
                                            state: XmppState {
                                                client,
                                    // future to wait for online
                                    Box::new(
                                        XmppConnection {
                                            state: XmppState {
                                                client,
                                                data: std::default::Default::default(),
                                            },
                                            account,
                                        }
                                        .processing(XmppConnection::online, stop_future.clone())
                                        .map_err(|(acc, _)| acc)
                                        .and_then(|(conn, r)| match r {
                                            Ok(Either::A(_)) => future::ok(conn),
                                            Ok(Either::B(_)) => future::err(conn.account),
                                            Err(_e) => future::err(conn.account),
                                        })
                                        .and_then(|conn| conn.initial_roster(stop_future2))
                                        .and_then(|conn| conn.self_presence(stop_future3))
                                        .then(
                                            |r| match r {
                                                Ok(conn) => future::ok(future::Loop::Break(conn)),
                                                Err(acc) => future::ok(future::Loop::Continue(acc)),
                                            },
                                        ),
                                    )
                            // future to wait for online
                            Box::new(
                                XmppConnection {
                                    state: XmppState {
                                        client,
                                        data: std::default::Default::default(),
                                    },
                                    account,
                                    // future to wait for online
                                    Box::new(
                                        XmppConnection {
                                            state: XmppState {
                                                client,
                                                data: std::default::Default::default(),
                                            },
                                            account,
                                        }
                                        .processing(XmppConnection::online, stop_future.clone())
                                        .map_err(|(acc, _)| acc)
                                        .and_then(|(conn, r)| match r {
                                            Ok(Either::A(_)) => future::ok(conn),
                                            Ok(Either::B(_)) => future::err(conn.account),
                                            Err(_e) => future::err(conn.account),
                                        })
                                        .and_then(|conn| conn.initial_roster(stop_future2))
                                        .and_then(|conn| conn.self_presence(stop_future3))
                                        .then(
                                            |r| match r {
                                                Ok(conn) => future::ok(future::Loop::Break(conn)),
                                                Err(acc) => future::ok(future::Loop::Continue(acc)),
                                            },
                                        ),
                                    )
                                    // future to wait for online
                                    Box::new(
                                        XmppConnection {
                                            state: XmppState {
                                                client,
                                                data: std::default::Default::default(),
                                            },
                                            account,
                                        }
                                        .processing(XmppConnection::online, stop_future.clone())
                                        .map_err(|(acc, _)| acc)
                                        .and_then(|(conn, r)| match r {
                                            Ok(Either::A(_)) => future::ok(conn),
                                            Ok(Either::B(_)) => future::err(conn.account),
                                            Err(_e) => future::err(conn.account),
                                        })
                                        .and_then(|conn| conn.initial_roster(stop_future2))
                                        .and_then(|conn| conn.self_presence(stop_future3))
                                        .then(
                                            |r| match r {
                                                Ok(conn) => future::ok(future::Loop::Break(conn)),
                                                Err(acc) => future::ok(future::Loop::Continue(acc)),
                                            },
                                        ),
                                    )
                            // future to wait for online
                            Box::new(
                                XmppConnection {
                                    state: XmppState {
                                        client,
                                        data: std::default::Default::default(),
                                    },
                                    account,
                                        XmppConnection { client, account }
                                            .processing(XmppConnection::online, stop_future.clone())
                                            .map(|(conn, _)| conn)
                                            .map_err(|(acc, _)| acc)
                                            .and_then(|conn| conn.initial_roster(stop_future2))
                                            .and_then(|conn| conn.self_presence(stop_future3))
                                            .then(|r| match r {
                            let stop_future2 = stop_future.clone();
                            let stop_future3 = stop_future.clone();
                            let stop_future4 = stop_future.clone();
                                    let stop_future2 = stop_future.clone();
                                    let stop_future3 = stop_future.clone();
                // future to wait for online
                Self::online(client.split(), account)
                    .and_then(Self::self_presence)
                        Ok(conn) => future::ok(future::Loop::Break(conn)),
                        Err(acc) => future::ok(future::Loop::Continue(acc)),
                    })
                        Ok(conn) => future::ok(future::Loop::Break(conn)),
                        Err(acc) => future::ok(future::Loop::Continue(acc)),
                    })
            }))
                        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"))
                        }
                    }),
            )
                        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"))
                        }
                    }),
            )
            }))
                            let stop_future2 = stop_future.clone();
                            let stop_future3 = stop_future.clone();
                            let stop_future4 = stop_future.clone();
                                    let stop_future2 = stop_future.clone();
                                    let stop_future3 = stop_future.clone();
                                    // future to wait for online
                                    Box::new(
                                        XmppConnection {
                                            inner: client,
                                            account,
                                        }
                                        .and_then(XmppConnection::self_presence)
                                        .then(
                                            |r| match r {
                                                Ok(conn) => future::ok(future::Loop::Break(conn)),
                                                Err(acc) => future::ok(future::Loop::Continue(acc)),
                                            },
                                        ),
                                    )
                                }
                            }
                        })
                        .map_err(|_: ()| ()),
                    )
                                        .processing(XmppConnection::online, stop_future.clone())
                                        .map(|(xmpp, _)| xmpp)
                                        .map_err(|(acc, _)| acc)
                    .then(|r| match r {
                                        .online()
                                    let stop_future2 = stop_future.clone();
                                    let stop_future3 = stop_future.clone();
                // future to wait for online
                XmppConnection {
                    inner: client,
                    account,
                }
                .online()
                .and_then(XmppConnection::self_presence)
                .then(|r| match r {
                    Ok(conn) => future::ok(future::Loop::Break(conn)),
                    Err(acc) => future::ok(future::Loop::Continue(acc)),
                })
            }))
                                    let stop_future2 = stop_future.clone();
                                    let stop_future3 = stop_future.clone();
                                    let stop_future2 = stop_future.clone();
                                    let stop_future3 = stop_future.clone();
                                        .and_then(|conn| conn.initial_roster(stop_future2))
                                        .and_then(|conn| conn.self_presence(stop_future3))
                                        .and_then(|conn| conn.self_presence(stop_future2))
                                        .then(
                                            |r| match r {
                                                Ok(conn) => future::ok(future::Loop::Break(conn)),
                                                Err(acc) => future::ok(future::Loop::Continue(acc)),
                                            },
                                        ),
                                    )
                                }
                            }
                        })
                        .map_err(|_: ()| ()),
                    )
                                    // future to wait for online
                                    Box::new(
                                        XmppConnection {
                                            inner: client,
                                            account,
                                        }
                                        .processing(XmppConnection::online, stop_future.clone())
                                        .map(|(conn, _)| conn)
                                        .map_err(|(acc, _)| acc)
                                    // future to wait for online
                                    Box::new(
                                        XmppConnection {
                                            inner: client,
                                            account,
                                        }
                                        .processing(XmppConnection::online, stop_future.clone())
                                        .map(|(conn, _)| conn)
                                        .map_err(|(acc, _)| acc)
                                        .then(
                                            |r| match r {
                                                Ok(conn) => future::ok(future::Loop::Break(conn)),
                                                Err(acc) => future::ok(future::Loop::Continue(acc)),
                                            },
                                        ),
                                    )
                                }
                            }
                        })
                        .map_err(|_: ()| ()),
                    )
                                        .and_then(|conn| conn.initial_roster(stop_future2))
                                        .and_then(|conn| conn.self_presence(stop_future3))
                                        .and_then(|conn| conn.self_presence(stop_future2))
                            let stop_future2 = stop_future.clone();
                            let stop_future3 = stop_future.clone();
                                    let stop_future2 = stop_future.clone();
                                    let stop_future3 = stop_future.clone();
                                    // future to wait for online
                                    Box::new(
                // future to wait for online
                    .and_then(XmppConnection::self_presence)
                    .then(|r| match r {
                        Ok(conn) => future::ok(future::Loop::Break(conn)),
                        Err(acc) => future::ok(future::Loop::Continue(acc)),
                    })
                    .and_then(Self::self_presence)
                Self::online(client.split(), account)
                    .and_then(Self::self_presence)
                XmppConnection {
                    inner: client,
                    account,
                }
                .online()
                .and_then(XmppConnection::self_presence)
                .then(|r| match r {
                    Ok(conn) => future::ok(future::Loop::Break(conn)),
                    Err(acc) => future::ok(future::Loop::Continue(acc)),
                })
                Self::online(client, account)
                Self::online(client.split(), account)
                    .and_then(Self::self_presence)
                Self::online(client.split(), account)
            Box::new(future::loop_fn(account, |account| {
                info!("xmpp initialization...");
                let mut res_client = Client::new(&account.jid, &account.password);
                while let Err(e) = res_client {
                    error!("Cann't init xmpp client: {}", e);
                    res_client = Client::new(&account.jid, &account.password);
                }
                let client = res_client.expect("Cann't init xmpp client");
                info!("xmpp initialized");
            Box::new(
                stop_future
                    .clone()
                        future::loop_fn(account, move |account| {
                        future::loop_fn(account, |account| {
                            info!("xmpp initialization...");
                            let res_client = Client::new(&account.jid, &account.password);
                            match res_client {
                                Err(_e) => Box::new(future::ok(future::Loop::Continue(account)))
                                    as Box<Future<Item = _, Error = _>>,
                                Ok(client) => {
                                    info!("xmpp initialized");
                    .select2(
            Box::new(future::loop_fn(account, |account| {
                info!("xmpp initialization...");
                let mut res_client = Client::new(&account.jid, &account.password);
                while let Err(e) = res_client {
                    error!("Cann't init xmpp client: {}", e);
                    res_client = Client::new(&account.jid, &account.password);
                }
                let client = res_client.expect("Cann't init xmpp client");
                info!("xmpp initialized");
            Box::new(
                stop_future
                    .clone()
                    .select2(
                        future::loop_fn(account, move |account| {
                            info!("xmpp initialization...");
                            let res_client = Client::new(&account.jid, &account.password);
                            match res_client {
                                Err(_e) => Box::new(future::ok(future::Loop::Continue(account)))
                                    as Box<Future<Item = _, Error = _>>,
                                Ok(client) => {
                                    info!("xmpp initialized");
            Box::new(
                stop_future
                    .clone()
                    .select2(
                        future::loop_fn(account, move |account| {
                            info!("xmpp initialization...");
                            let res_client = Client::new(&account.jid, &account.password);
                            match res_client {
                                Err(_e) => Box::new(future::ok(future::Loop::Continue(account)))
                                    as Box<Future<Item = _, Error = _>>,
                                Ok(client) => {
                                    info!("xmpp initialized");
                                    let stop_future2 = stop_future.clone();
                                    let stop_future3 = stop_future.clone();
            Box::new(
                stop_future
                    .select2(
                            info!("xmpp initialization...");
                                    as Box<dyn Future<Item = _, Error = _>>,
                                    let stop_future2 = stop_future.clone();
                                    let stop_future3 = stop_future.clone();
                                    as Box<dyn Future<Item = _, Error = _>>,
                                Ok(client) => {
                                    info!("xmpp initialized");
                                    as Box<Future<Item = _, Error = _>>,
                                    as Box<Future<Item = _, Error = _>>,
                                    as Box<Future<Item = _, Error = _>>,
                                Ok(client) => {
                                    info!("xmpp initialized");
                            let client =
                                Client::new_with_jid(account.jid.clone(), &account.password);
                            info!("xmpp initialized");
                            let client =
                                Client::new_with_jid(account.jid.clone(), &account.password);
                            info!("xmpp initialized");
                            let res_client = Client::new(&account.jid, &account.password);
                            match res_client {
                                Err(_e) => Box::new(future::ok(future::Loop::Continue(account)))
                                    as Box<Future<Item = _, Error = _>>,
                                Ok(client) => {
                                    info!("xmpp initialized");
                            let client =
                                Client::new_with_jid(account.jid.clone(), &account.password);
                            info!("xmpp initialized");
                            let res_client = Client::new(&account.jid, &account.password);
                            match res_client {
                                Err(_e) => Box::new(future::ok(future::Loop::Continue(account)))
                            let res_client = Client::new(&account.jid, &account.password);
                            match res_client {
                                Err(_e) => Box::new(future::ok(future::Loop::Continue(account)))
                                    as Box<Future<Item = _, Error = _>>,
                                Ok(client) => {
                                    info!("xmpp initialized");
                            let client =
                                Client::new_with_jid(account.jid.clone(), &account.password);
                            info!("xmpp initialized");
                            let res_client = Client::new(&account.jid, &account.password);
                            match res_client {
                                Err(_e) => Box::new(future::ok(future::Loop::Continue(account)))
                        future::loop_fn(account, |account| {
                        future::loop_fn(account, |account| {
                        future::loop_fn(account, move |account| {
                        future::loop_fn(account, move |account| {
                        future::loop_fn(account, move |account| {
                    .clone()
                    .clone()
                    .clone()
            Box::new(future::loop_fn(account, |account| {
                info!("xmpp initialization...");
                let mut res_client = Client::new(&account.jid, &account.password);
                while let Err(e) = res_client {
                    error!("Cann't init xmpp client: {}", e);
                    res_client = Client::new(&account.jid, &account.password);
                }
                let client = res_client.expect("Cann't init xmpp client");
                info!("xmpp initialized");
        } else {
        if let Some(inner) = inner {
            Box::new(future::ok(XmppConnection { account, inner }))
        if let Some(state) = state {
            Box::new(future::ok(XmppConnection { account, state }))
        if let Some(state) = state {
            Box::new(future::ok(XmppConnection { account, state }))
                as Box<dyn Future<Item = _, Error = _>>
        if let Some(inner) = inner {
            Box::new(future::ok(XmppConnection { account, inner }))
                as Box<Future<Item = _, Error = _>>
        if let Some(state) = state {
            Box::new(future::ok(XmppConnection { account, state }))
                as Box<dyn Future<Item = _, Error = _>>
                as Box<dyn Future<Item = _, Error = _>>
                as Box<Future<Item = _, Error = _>>
                as Box<dyn Future<Item = _, Error = _>>
                as Box<Future<Item = _, Error = _>>
                as Box<Future<Item = _, Error = _>>
                as Box<dyn Future<Item = _, Error = _>>
        if let Some(client) = client {
            Box::new(future::ok(XmppConnection { account, client }))
                as Box<Future<Item = _, Error = _>>
        if let Some(inner) = inner {
                as Box<Future<Item = _, Error = E>>
                as Box<Future<Item = _, Error = _>>
                as Box<Future<Item = _, Error = _>>
                account,
                inner: Some(inner),
            })) as Box<Future<Item = _, Error = E>>
            Box::new(future::ok(XmppConnection {
                account,
                inner: Some(inner),
            })) as Box<Future<Item = _, Error = E>>
            Box::new(future::ok(XmppConnection {
                account,
                inner: Some(inner),
            })) as Box<Future<Item = _, Error = E>>
            Box::new(future::ok(XmppConnection { account, inner }))
                as Box<Future<Item = _, Error = E>>
            Box::new(future::ok(MaybeXmppConnection {
                account,
                inner: Some(inner),
            })) as Box<Future<Item = _, Error = E>>
            Box::new(future::ok(MaybeXmppConnection {
            Box::new(future::ok(XmppConnection {
                account,
                inner: Some(inner),
            })) as Box<Future<Item = _, Error = E>>
            Box::new(future::ok(XmppConnection { account, inner }))
                as Box<Future<Item = _, Error = _>>
            Box::new(future::ok(XmppConnection { account, inner }))
                as Box<Future<Item = _, Error = E>>
            Box::new(future::ok(XmppConnection { account, inner }))
            Box::new(future::ok(XmppConnection {
        let XmppConnection { account, inner } = self;
        let MaybeXmppConnection { account, inner } = self;
        let MaybeXmppConnection { account, inner } = self;
        let MaybeXmppConnection { account, inner } = self;
        let XmppConnection { account, inner } = self;
        let MaybeXmppConnection { account, inner } = self;
        let MaybeXmppConnection { account, state } = self;
        let MaybeXmppConnection { account, state } = self;
        let MaybeXmppConnection { account, inner } = self;
        let MaybeXmppConnection { account, inner } = self;
        let MaybeXmppConnection { account, state } = self;
        let MaybeXmppConnection { account, client } = self;
        let XmppConnection { account, inner } = self;
    /// don't connect if stop_future resolved
        F: future::Future + 'static,
        info!("xmpp connection...");
        F: future::Future + 'static,
        F: future::Future + Clone + 'static,
        F: future::Future + Clone + 'static,
        F: future::Future + Clone + 'static,
        <F as hyper::rt::Future>::Error: Into<failure::Error> + Send,
    {
    /// Error shoud be !
    fn connect<E: 'static>(self) -> impl Future<Item = Self, Error = E> {
    /// don't connect only if stop_future resolved
    /// don't connect if stop_future resolved
    /// don't connect if stop_future resolved
    fn connect<F>(
        self,
        stop_future: F,
    ) -> impl Future<Item = XmppConnection, Error = failure::Error>
    where
        <F as hyper::rt::Future>::Error: Into<failure::Error> + Send,
    {
        F: future::Future + Clone + 'static,
        F: future::Future + 'static,
    /// Error shoud be !
    fn connect<E: 'static>(self) -> impl Future<Item = XmppConnection, Error = E> {
    /// don't connect only if stop_future resolved
    /// don't connect if stop_future resolved
    /// don't connect if stop_future resolved
    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,
    {
    /// don't connect only if stop_future resolved
    /// don't connect if stop_future resolved
    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,
    {
    /// don't connect only if stop_future resolved
    fn connect<F>(
        self,
        stop_future: F,
    ) -> impl Future<Item = XmppConnection, Error = failure::Error>
    where
    /// don't connect if stop_future resolved
    /// Error shoud be !
    fn connect<E: 'static>(self) -> impl Future<Item = Self, Error = E> {
    fn connect<E: 'static>(self) -> impl Future<Item = XmppConnection, Error = E> {
    fn connect<E: 'static>(self) -> impl Future<Item = Self, Error = E> {
    fn connect<E: 'static>(self) -> impl Future<Item = XmppConnection, Error = E> {
    fn connect<E: 'static>(self) -> impl Future<Item = Self, Error = E> {
            state: None,
            client: None,
    /// connects if nothing connected
        }
    }
}
            account: std::rc::Rc::new(account),
impl MaybeXmppConnection {
    fn new(account: config::Account) -> MaybeXmppConnection {
        MaybeXmppConnection {
impl XmppConnection {
    fn new(account: config::Account) -> XmppConnection {
        XmppConnection {
impl MaybeXmppConnection {
    fn new(account: config::Account) -> MaybeXmppConnection {
        MaybeXmppConnection {
impl From<XmppConnection> for MaybeXmppConnection {
    fn from(from: XmppConnection) -> MaybeXmppConnection {
        MaybeXmppConnection {
            account: from.account,
            inner: Some(from.inner),
        }
    }
impl MaybeXmppConnection {
    fn new(account: config::Account) -> MaybeXmppConnection {
        MaybeXmppConnection {
}
impl From<XmppConnection> for MaybeXmppConnection {
    fn from(from: XmppConnection) -> MaybeXmppConnection {
        MaybeXmppConnection {
            account: from.account,
            inner: Some(from.inner),
        }
    }
}
impl XmppConnection {
    fn new(account: config::Account) -> XmppConnection {
        XmppConnection {
impl From<std::rc::Rc<config::Account>> for MaybeXmppConnection {
    fn from(from: std::rc::Rc<config::Account>) -> MaybeXmppConnection {
            account: from,
impl From<XmppConnection> for MaybeXmppConnection {
    fn from(from: XmppConnection) -> MaybeXmppConnection {
        MaybeXmppConnection {
            account: from.account,
            inner: Some(from.inner),
        }
    }
impl MaybeXmppConnection {
impl MaybeXmppConnection {
    fn new(account: config::Account) -> MaybeXmppConnection {
        MaybeXmppConnection {
}
impl From<XmppConnection> for MaybeXmppConnection {
    fn from(from: XmppConnection) -> MaybeXmppConnection {
        MaybeXmppConnection {
            account: from.account,
        }
    }
}
        MaybeXmppConnection {
        }
    }
impl MaybeXmppConnection {
}
impl From<std::rc::Rc<config::Account>> for MaybeXmppConnection {
    fn from(from: std::rc::Rc<config::Account>) -> MaybeXmppConnection {
        MaybeXmppConnection {
            account: from,
}
}
impl From<std::rc::Rc<config::Account>> for MaybeXmppConnection {
    fn from(from: std::rc::Rc<config::Account>) -> MaybeXmppConnection {
        MaybeXmppConnection {
            account: from,
impl MaybeXmppConnection {
}
}
            state: None,
            state: None,
        }
    }
            account: std::rc::Rc::new(account),
            account: std::rc::Rc::new(from),
            state: None,
            account: std::rc::Rc::new(account),
            account: std::rc::Rc::new(from),
            account: std::rc::Rc::new(account),
            inner: None,
            account: std::rc::Rc::new(from),
            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 {
    fn new(account: config::Account) -> MaybeXmppConnection {
impl From<config::Account> for MaybeXmppConnection {
    fn from(from: config::Account) -> MaybeXmppConnection {
impl MaybeXmppConnection {
    fn new(account: config::Account) -> MaybeXmppConnection {
impl From<config::Account> for MaybeXmppConnection {
    fn from(from: config::Account) -> MaybeXmppConnection {
impl MaybeXmppConnection {
    fn new(account: config::Account) -> MaybeXmppConnection {
impl From<config::Account> for MaybeXmppConnection {
    fn from(from: config::Account) -> MaybeXmppConnection {
impl From<config::Account> for MaybeXmppConnection {
    fn from(from: config::Account) -> MaybeXmppConnection {
        }
    }
            inner: Some(from.inner),
            inner: Some(from.inner),
            state: Some(from.state),
            state: Some(from.state),
            inner: Some(from.inner),
            state: Some(from.state),
            client: Some(from.client),
impl XmppConnection {
    fn new(account: config::Account) -> XmppConnection {
        XmppConnection {
            inner: None,
            account,
}
    inner: Option<(stream::SplitSink<Client>, stream::SplitStream<Client>)>,
    inner: Option<(stream::SplitSink<Client>, stream::SplitStream<Client>)>,
    inner: Client,
    inner: Client,
    inner: Option<(stream::SplitSink<Client>, stream::SplitStream<Client>)>,
    inner: Client,
    inner: Option<(stream::SplitSink<Client>, stream::SplitStream<Client>)>,
    inner: Client,
    inner: Client,
}
impl From<XmppConnection> for MaybeXmppConnection {
    fn from(from: XmppConnection) -> MaybeXmppConnection {
        MaybeXmppConnection {
            account: from.account,
            inner: Some(from.inner),
        }
    }
    inner: (stream::SplitSink<Client>, stream::SplitStream<Client>),
    state: XmppState,
    state: XmppState,
    inner: Client,
    inner: Client,
    state: XmppState,
    client: Client,
pub struct XmppConnection {
pub struct XmppConnection {
struct XmppConnection {
struct XmppConnection {
pub struct XmppConnection {
struct XmppConnection {
pub struct XmppConnection {
pub struct MaybeXmppConnection {
    account: std::rc::Rc<config::Account>,
    inner: Option<Client>,
}
    account: std::rc::Rc<config::Account>,
    inner: Option<Client>,
}
    counter: usize,
    id_init_roster: Option<String>,
    data: 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 XmppElementProcessor {
}
        let mut incoming = element_processor::Processor::new(&|_, e| {
            warn!("Unknown stanza {:#?}", e);
            true
        });
        incoming.register(&XmppConnection::incoming_iq_processing);
        let mut incoming =
            element_processor::Processor::new(&|_, e| warn!("Unknown stanza {:#?}", e));
        XmppElementProcessor { incoming }
    }
}
impl XmppElementProcessor {
    fn new() -> XmppElementProcessor {
struct MaybeXmppConnection {
    inner: Option<Client>,
    inner: Option<Client>,
    state: Option<XmppState>,
    state: Option<XmppState>,
    inner: Option<Client>,
    state: Option<XmppState>,
}
    client: Option<Client>,
    incoming: element_processor::Processor<XmppConnection, bool, xmpp_parsers::Element>,
    incoming: element_processor::Processor<XmppConnection, (), xmpp_parsers::Element>,
    roster: HashMap<jid::Jid, ()>,
    _counter: usize,
struct MaybeXmppConnection {
pub struct MaybeXmppConnection {
    /// known roster data
    /// ids counter
    counter: usize,
    pending_add_roster_ids: HashMap<String, (xmpp_parsers::Jid, String)>,
    /// muc id to muc jid
    mucs: HashMap<String, xmpp_parsers::Jid>,
    /// muc id to muc jid
    mucs: HashMap<String, xmpp_parsers::Jid>,
================================
    id_init_roster: Option<String>,
<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
}
struct XmppState {
    client: Client,
    data: XmppData,
    /// outgoing mailbox
    outgoing_mailbox: HashMap<xmpp_parsers::Jid, Vec<String>>,
    pending_add_roster_ids: HashMap<String, (jid::Jid, String)>,
    pending_add_roster_ids: HashMap<String, (xmpp_parsers::Jid, String)>,
    pending_add_roster_ids: HashMap<String, (jid::Jid, String)>,
    /// stanzas to send
    send_queue: VecDeque<minidom::Element>,
    pending_add_roster_ids: HashMap<String, (xmpp_parsers::Jid, String)>,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
    /// map from id of adding item to roster and jid of item and message text
    /// map from id of adding item to roster and jid of item
    pending_add_roster_ids: HashMap<String, xmpp_parsers::Jid>,
    roster: HashMap<xmpp_parsers::Jid, (xmpp_parsers::roster::Subscription, Vec<String>)>,
    roster: HashMap<jid::Jid, ()>,
    roster: HashMap<xmpp_parsers::Jid, (xmpp_parsers::roster::Subscription, Vec<String>)>,
    roster: HashMap<
        xmpp_parsers::Jid,
        (
            xmpp_parsers::roster::Subscription,
            xmpp_parsers::roster::Ask,
            Vec<String>,
        ),
    >,
    roster: HashMap<jid::Jid, ()>,
    roster: HashMap<xmpp_parsers::Jid, (xmpp_parsers::roster::Subscription, Vec<String>)>,
    roster: HashMap<
        xmpp_parsers::Jid,
        (
            xmpp_parsers::roster::Subscription,
            xmpp_parsers::roster::Ask,
        ),
    >,
#[derive(Default)]
struct XmppData {
    roster: HashMap<jid::Jid, ()>,
    data: XmppData,
    roster: HashMap<jid::Jid, ()>,
    roster: HashMap<jid::Jid, ()>,
}
    roster: HashMap<jid::Jid, ()>,
    counter: usize,
    _counter: usize,
}
    roster: HashMap<jid::Jid, ()>,
    roster: HashMap<jid::Jid, ()>,
}
    counter: usize,
    pending_add_roster_ids: HashMap<String, (xmpp_parsers::Jid, String)>,
    /// stanzas to send
    send_queue: VecDeque<minidom::Element>,
    pending_add_roster_ids: HashMap<String, (jid::Jid, String)>,
================================
    id_init_roster: Option<String>,
<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
    /// stanzas to send
    send_queue: VecDeque<minidom::Element>,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
    /// map from id of adding item to roster and jid of item and message text
    _counter: usize,
    /// ids counter
#[derive(Default)]
struct XmppData {
    roster: HashMap<jid::Jid, (xmpp_parsers::roster::Subscription, Vec<String>)>,
    roster: HashMap<xmpp_parsers::Jid, (xmpp_parsers::roster::Subscription, Vec<String>)>,
    /// known roster data
    account: std::rc::Rc<config::Account>,
#[derive(Default)]
struct XmppData {
    roster: HashMap<jid::Jid, ()>,
pub struct MaybeXmppConnection {
const ID_GET_ROSTER: &str = "id_get_roster0";
struct XmppState {
    client: Client,
}
struct MaybeXmppConnection {
struct XmppState {
    client: Client,
pub struct MaybeXmppConnection {
pub struct XmppConnection {
}
    inner: Option<(stream::SplitSink<Client>, stream::SplitStream<Client>)>,
    account: std::rc::Rc<config::Account>,
    account: config::Account,
pub struct MaybeXmppConnection {
const ID_GET_ROSTER: &str = "id_get_roster0";
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
use config;
mod element_processor;
mod element_processor;
use std::collections::{HashMap, VecDeque};
use std::collections::{HashMap, VecDeque};
mod element_processor;
const ID_GET_ROSTER: &str = "id_get_roster0";
================================
<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
mod element_processor;
mod element_processor;
}
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 }
    }
    fn xmpp_processing(
        mut self,
        event: &Event,
    ) -> impl Future<Item = Self, Error = std::rc::Rc<config::Account>> {
                info!("Incoming xmpp event: {:?}", stanza);
                let stanza = stanza.clone();
                use std::convert::TryInto;
                if let Some(iq) = stanza.clone().try_into().ok() as Option<xmpp_parsers::iq::Iq> {
                    if let Some((_, jid)) =
                        self.state.data.pending_add_roster_ids.remove_entry(&iq.id)
                    {
                        if let xmpp_parsers::iq::IqType::Result(None) = iq.payload {
                            if self.state.data.roster.contains_key(&jid) {
                                info!("Jid {} updated to roster", jid);
                                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);
                    match iq.payload {
                        xmpp_parsers::iq::IqType::Set(element) => {
                            if let Some(roster) =
                                element.try_into().ok() as Option<xmpp_parsers::roster::Roster>
                            {
                                for i in roster.items {
                                    if let Some(ref mut rdata) =
                                        self.state.data.roster.get_mut(&i.jid)
                                    {
                                        info!("Update {} in roster", i.jid);
                                        rdata.0 = i.subscription;
                                        rdata.1 = i.ask;
                                    } else {
                                        info!("Add {} to roster", i.jid);
                                        self.state
                                            .data
                                            .roster
                                            .insert(i.jid.clone(), (i.subscription, i.ask));
                                    }
                                    self.process_jid(&i.jid);
                            }
                        }
                        xmpp_parsers::iq::IqType::Error(e) => {
                            error!("iq error: {:?}", e);
                            return false;
                        }
                        xmpp_parsers::iq::IqType::Get(element) => {
                            if let Some(_ping) =
                                element.try_into().ok() as Option<xmpp_parsers::ping::Ping>
                            {
                                let pong = stanzas::make_pong(
                                    &iq.id,
                                    self.state.client.jid.clone(),
                                    iq.from,
                                );
                                self.state.data.send_queue.push_back(pong);
                        _ => (), // ignore
                } else if let Some(_presence) =
                    stanza.try_into().ok() as Option<xmpp_parsers::presence::Presence>
                {
                    // to do something with presence
                true
            Event::Online => true,
                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
                                        let xmpp = XmppConnection {
                                        Box::new(xmpp.xmpp_processing(&event).then(|r| match r {
                                            Ok(mut xmpp) => {
                                                match stop_condition(&mut xmpp, event) {
                                                    Ok(true) => future::ok(future::Loop::Break((
                                                        xmpp,
                                                        Ok(Either::A(b)),
                                                    ))),
                                                    Ok(false) => {
                                                        future::ok(future::Loop::Continue((
                                                            xmpp,
                                                            b,
                                                            stop_condition,
                                                        )))
                                                    }
                                                    Err(_e) => future::err((
                                                        xmpp.account,
                                                        Ok(Either::A(b)),
                                                    )),
                                        let mut xmpp = XmppConnection {
                                            state: XmppState { client, data },
                                            account,
                                        };
    }
    /// 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
    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 {
        }
                future::err(self.account)
            e => {
                warn!("Unexpected event {:?}", e);
            }
            Event::Online => future::ok(self),
            xmpp_parsers::iq::IqType::Error(e) => {
                error!("iq error: {:?}", e);
                return false;
                future::ok(self)
                        self.process_jid(&i.jid);
                    }
                }
            }
                        }
                            }
                                self.process_jid(&i.jid);
                                }
                        }
                    }
                            warn!(
                                "Wrong payload when adding {} to roster: {:?}",
                                jid, iq.payload
                            );
                    if let xmpp_parsers::iq::IqType::Set(element) = iq.payload {
                        if let Some(roster) =
                            element.try_into().ok() as Option<xmpp_parsers::roster::Roster>
                        {
                            for i in roster.items {
                                if let Some(ref mut rdata) = self.state.data.roster.get_mut(&i.jid)
                                {
                                    info!("Update {} in roster", i.jid);
                                    rdata.0 = i.subscription;
                                    rdata.1 = i.ask;
                                } else {
                                    info!("Add {} to roster", i.jid);
                                    self.state
                                        .data
                                        .roster
                                        .insert(i.jid.clone(), (i.subscription, i.ask));
                            info!("Add {} to roster", i.jid);
                            self.state
                                .data
                                .roster
                                .insert(i.jid.clone(), (i.subscription, i.ask));
                        } else {
                                );
                            }
                                warn!(
                                    "Wrong payload when adding {} to roster: {:?}",
                                    jid, iq.payload
                            } else {
                use try_from::TryInto;
                if let Some(iq) = stanza.try_into().ok() as Option<xmpp_parsers::iq::Iq> {
                    if let Some(id) = iq.id {
                        if let Some((_, jid)) =
                            self.state.data.pending_add_roster_ids.remove_entry(&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);
    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;
                let processors = XmppElementProcessor::new();
                processors.incoming.process(self, stanza.clone())
            }
            Event::Online => true,
            e => {
                warn!("Unexpected event {:?}", e);
                false
            }
        }
    }
    /// Returns false on error to disconnect
    fn xmpp_processing(&mut self, event: &Event) -> bool {
        match event {
            Event::Stanza(stanza) => {
}
struct MaybeXmppConnection {
    account: std::rc::Rc<config::Account>,
    state: Option<XmppState>,
}
struct XmppConnection {
    account: std::rc::Rc<config::Account>,
    state: 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
    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
#[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,
use std::collections::{HashMap, VecDeque};
const ID_GET_ROSTER: &str = "id_get_roster0";
const ID_GET_ROSTER: &str = "id_get_roster0";
const ID_GET_ROSTER: &str = "id_get_roster0";
use std::collections::HashMap;
use std::collections::HashMap;
use std::collections::HashMap;
use std::collections::{HashMap, VecDeque};
use std::collections::HashMap;
use std::collections::{HashMap, VecDeque};
use std::collections::HashMap;
use std::collections::{HashMap, VecDeque};
use std::collections::{HashMap, VecDeque};
use std::collections::HashMap;
use tokio_xmpp::{Client, Event};
use crate::config;
mod stanzas;
mod element_processor;
use std::collections::{HashMap, VecDeque};
use config;
use crate::config;
use crate::config;
use config;
use tokio_channel::mpsc::Receiver;
use tokio_xmpp::{Client, Event, Packet};
use tokio_xmpp::{Client, Event, Packet};
use tokio_xmpp::{Client, Event};
use tokio_xmpp::{Client, Event};
use tokio::prelude::{Future, Stream};
use tokio::prelude::{Future, Stream};
use tokio_xmpp::{Client, Event, Packet};
use tokio::prelude::{Future, Stream};
use tokio_xmpp::{Client, Event, Packet};
use tokio::prelude::{Future, Stream};
use tokio_xmpp::{Client, Event, Packet};
use tokio::prelude::{Future, Stream};
use tokio_xmpp::{Client, Event, Packet};
use tokio::prelude::{Future, Stream};
use tokio::prelude::future::{self, Either};
use tokio::prelude::future::{self, Either, Future};
use tokio::prelude::future::{self, Either, Future};
use tokio::prelude::future::{self, Either};
use tokio::prelude::future::{self, Either};
use futures_util::future::Either;
use log::{info, warn};
use log::{error, info, warn};
use log::{error, info, warn};
use tokio::prelude::future::{self, Either, Future};
use tokio::prelude::future::{self, Either, Future};
use tokio::prelude::future::{self, Either, Future};
use tokio::prelude::future::{self, Either};
use tokio::prelude::future::{self, Either, Future};
use tokio::prelude::future::{self, Either};
use tokio::prelude::future::{self, Either};

File deletion: xmpp.rs, xmpp.rs, xmpp.rs, xmpp.rs

BF:BFD[10.6] → [14.0:9]

FD:BFD[10.6] → [14.0:9]

BF:BFD[14.9] → [14.10:10]

BF:BFD[10.6] → [14.0:9]

FD:BFD[10.6] → [14.0:9]

FD:BFD[14.9] → [14.10:10]

B:BD[13.44] → [12.0:28]

B:BD[13.117] → [132.0:1]

B:BD[56.29] → [56.29:68]

B:BD[56.91] → [56.91:116]

B:BD[56.199] → [56.199:275]

B:BD[13.118] → [56.317:380]

B:BD[56.445] → [56.445:499]

B:BD[56.536] → [56.536:600]

B:BD[56.643] → [56.643:652]

B:BD[13.217] → [56.653:679]

B:BD[14.40] → [13.220:243]

B:BD[13.364] → [56.866:899]

B:BD[13.440] → [56.900:935]

B:BD[14.140] → [12.3217:3261]

B:BD[14.176] → [13.503:627]

B:BD[56.987] → [56.987:1222]

B:BD[56.1613] → [12.3305:3350]

B:BD[56.1879] → [12.3351:3393]

B:BD[56.2523] → [56.2523:2573]

B:BD[56.2623] → [12.3444:3496]

B:BD[13.1609] → [56.2876:3612]

B:BD[13.1623] → [56.3613:3630]

B:BD[13.1623] → [13.1623:1634]

B:BD[13.1634] → [133.228:875]

B:BD[14.276] → [14.276:278]

B:BD[13.1634] → [13.1634:1641]

B:BD[13.1591] → [13.1591:1609]

B:BD[13.1609] → [13.1609:1623]

B:BD[56.2573] → [56.2573:2623]

B:BD[56.2623] → [56.2623:2875]

B:BD[56.2523] → [12.3394:3443]

B:BD[56.1222] → [56.1222:1613]

B:BD[56.1613] → [56.1613:1879]

B:BD[56.1879] → [56.1879:2523]

B:BD[56.1222] → [12.3262:3304]

B:BD[13.771] → [133.0:44]

B:BD[13.858] → [133.45:113]

B:BD[13.1113] → [133.114:158]

B:BD[13.1257] → [133.159:227]

B:BD[13.1257] → [13.1257:1313]

B:BD[13.1313] → [13.1313:1591]

B:BD[13.1113] → [13.1113:1158]

B:BD[13.1158] → [13.1158:1257]

B:BD[13.858] → [13.858:914]

B:BD[13.914] → [13.914:1113]

B:BD[13.771] → [13.771:816]

B:BD[13.816] → [13.816:858]

B:BD[13.627] → [56.936:987]

B:BD[13.627] → [13.627:771]

B:BD[13.627] → [57.389:434]

B:BD[14.176] → [14.176:276]

B:BD[14.140] → [14.140:174]

B:BD[14.174] → [14.174:176]

B:BD[13.440] → [57.358:388]

B:BD[13.364] → [12.3192:3216]

B:BD[13.440] → [13.440:502]

B:BD[13.364] → [13.364:388]

B:BD[13.388] → [13.388:440]

B:BD[13.355] → [13.355:364]

B:BD[13.243] → [56.680:865]

B:BD[13.243] → [13.243:355]

B:BD[14.40] → [14.40:134]

B:BD[14.134] → [14.134:140]

B:BD[56.632] → [56.632:643]

B:BD[13.118] → [13.118:217]

B:BD[13.217] → [13.217:219]

B:BD[56.600] → [56.600:632]

B:BD[56.536] → [132.585:624]

B:BD[56.536] → [57.336:357]

B:BD[56.499] → [56.499:536]

B:BD[12.252] → [12.252:581]

B:BD[12.1084] → [12.1084:2255]

B:BD[12.2596] → [12.2596:2775]

B:BD[12.3092] → [12.3092:3191]

B:BD[134.556] → [135.237:488]

B:BD[135.559] → [135.559:1728]

B:BD[135.1728] → [136.383:497]

B:BD[135.488] → [135.488:559]

B:BD[135.488] → [136.321:382]

B:BD[132.443] → [132.443:584]

B:BD[12.3191] → [134.530:556]

B:BD[12.2775] → [12.2775:3092]

B:BD[12.2775] → [134.432:529]

B:BD[12.2255] → [12.2255:2596]

B:BD[12.2255] → [134.330:431]

B:BD[12.1084] → [135.0:236]

B:BD[12.1084] → [136.0:320]

B:BD[12.581] → [12.581:1084]

B:BD[12.252] → [134.0:329]

B:BD[56.445] → [132.54:159]

B:BD[132.205] → [132.205:268]

B:BD[132.370] → [132.370:429]

B:BD[132.429] → [132.429:443]

B:BD[132.370] → [57.260:335]

B:BD[132.268] → [132.268:370]

B:BD[132.205] → [57.180:259]

B:BD[132.159] → [132.159:205]

B:BD[56.445] → [57.125:179]

B:BD[56.380] → [56.380:445]

B:BD[56.380] → [12.141:252]

B:BD[13.117] → [13.117:118]

B:BD[56.275] → [56.275:316]

B:BD[56.174] → [56.174:199]

B:BD[56.199] → [57.103:124]

B:BD[56.116] → [56.116:174]

B:BD[56.116] → [57.45:102]

B:BD[56.68] → [56.68:91]

B:BD[56.68] → [132.26:53]

B:BD[56.29] → [57.14:44]

B:BD[57.44] → [12.63:140]

B:BD[132.25] → [57.0:13]

B:BD[132.1] → [12.29:62]

B:BD[132.1] → [132.1:25]

B:BD[14.39] → [14.39:40]

B:BD[14.10] → [13.0:44]

B:BD[13.44] → [13.44:117]

B:BD[13.117] → [56.0:29]

B:BD[14.10] → [14.11:39]

use tokio::prelude::stream;
    jid: String,
    password: String,
}
impl XmppConnection {
            jid: jid.to_owned(),
            password: password.to_owned(),
    /// connects if nothing connected
    /// Error shoud be !
        let inner = self.inner.unwrap_or_else(|| ());
            jid: self.jid,
            password: self.password,
    }
}
    conn: XmppConnection,
impl<F> XmppState<F> {
pub fn xmpp_process<F: 'static>(
    jid: &str,
    password: &str,
    F: future::Future<Item = ()> + 'static,
    let signal = signal
        .map_err(|_| tokio::io::Error::new(tokio::io::ErrorKind::Other, "Wrong shutdown signal"));
    future::loop_fn(XmppState::new(cmd_recv, signal, conn), |s| {
        let XmppState {
            cmd_recv,
            signal,
            conn,
        } = s;
        signal
            .select2(conn.connect().and_then(|conn| {
                        info!("Got signal");
                        info!("Got cmd");
                    Err(Either::B((_e, _a))) => {
                        error!("Cmd error: {}", e);
            })
    }).and_then(
        |(opt_cmd_recv, _conn): (Option<Receiver<XmppCommand>>, XmppConnection)| {
            if let Some(mut cmd_recv) = opt_cmd_recv {
                // process left commands
                info!("Stop accepting commands");
                cmd_recv.close();
                Box::new(cmd_recv.for_each(|_cmd| future::ok(())).map_err(|_| {
                    tokio::io::Error::new(tokio::io::ErrorKind::Other, "cmd receiver last error")
                })) as Box<Future<Item = (), Error = tokio::io::Error>>
            } else {
                Box::new(future::err(tokio::io::Error::new(
                    tokio::io::ErrorKind::Other,
                    "cmd receiver gone",
                )))
        },
    )
        })
    }).and_then(|opt_cmd_recv: Option<Receiver<XmppCommand>>| {
        if let Some(mut cmd_recv) = opt_cmd_recv {
            // process left commands
            info!("Stop accepting commands");
            cmd_recv.close();
            Box::new(cmd_recv.for_each(|_cmd| future::ok(())).map_err(|_| {
                tokio::io::Error::new(tokio::io::ErrorKind::Other, "cmd receiver last error")
            })) as Box<Future<Item = (), Error = tokio::io::Error>>
        } else {
            Box::new(future::err(tokio::io::Error::new(
                tokio::io::ErrorKind::Other,
                "cmd receiver gone",
            )))
        }
}
    })
                }
            }
                        // got cmd error, its bad
                        Box::new(future::err(tokio::io::Error::new(
                            tokio::io::ErrorKind::Other,
                            "Cmd error",
                        ))) as Box<Future<Item = _, Error = _>>
                    }
                    Err(Either::B((e, _a))) => {
                cmd_recv
                    .into_future()
                    .map_err(|_| {
                        error!("Got error on recv cmd");
                        tokio::io::Error::new(tokio::io::ErrorKind::Other, "Receive cmd error")
                    }).map(|f| (f, conn))
            })).then(|r| {
                match r {
                    Ok(Either::A((_x, b))) => {
                        // got signal, breaks
                        Box::new(b.map(|b| future::Loop::Break((Some((b.0).1), b.1))))
                            as Box<Future<Item = _, Error = _>>
                    }
                    Ok(Either::B((x, a))) => {
                        // got cmd, continue
                        Box::new(future::ok(future::Loop::Continue(XmppState::new(
                            (x.0).1,
                            a,
                            x.1,
                        )))) as Box<Future<Item = _, Error = _>>
                    }
                    Err(Either::A((e, b))) => {
                        // got signal error, breaks
                        error!("Signal error: {}", e);
                        Box::new(b.map(|b| future::Loop::Break((Some((b.0).1), b.1))))
                            as Box<Future<Item = _, Error = _>>
                    }
                info!("xmpp connected!");
                Ok(Either::A((_x, b))) => {
                    future::ok(future::Loop::Break(b.into_inner()))
                Err(Either::A((e, b))) => {
                    future::ok(future::Loop::Break(b.into_inner()))
                    future::ok(future::Loop::Break(()))
                }
                Err(Either::B((_e, _a))) => {
                    // got cmd error, its bad
                    future::err(tokio::io::Error::new(
                        tokio::io::ErrorKind::Other,
                        "Cmd error",
                    ))
                Err(Either::A((e, _b))) => {
                    // got signal error, breaks
                    error!("Signal error: {}", e);
                    future::ok(future::Loop::Break(()))
                }
                Ok(Either::B((x, a))) => {
                    // got cmd, continue
                    future::ok(future::Loop::Continue(XmppState::new(x.1, a)))
                }
                Ok(Either::A((_x, _b))) => {
                    // got signal, breaks
    let conn = XmppConnection::new(jid, password);
    future::loop_fn(XmppState::new(cmd_recv, signal), |s| {
        s.signal.select2(s.cmd_recv.into_future()).then(|r| {
            match r {
    let conn = XmppConnection::new(account);
    signal.map_err(|_| tokio::io::Error::new(tokio::io::ErrorKind::Other, "Wrong shutdown signal"))
    F: future::Future<Item = ()>,
{
    account: config::Account,
pub fn xmpp_process<F>(
) -> impl future::Future<Item = (), Error = tokio::io::Error>
pub fn xmpp_process<F>(
    signal: F,
    cmd_recv: Receiver<XmppCommand>,
    }
}
    fn new(cmd_recv: Receiver<XmppCommand>, signal: F, conn: XmppConnection) -> XmppState<F> {
        XmppState {
            cmd_recv,
            signal,
            conn,
        }
    fn new(cmd_recv: Receiver<XmppCommand>, signal: F) -> XmppState<F> {
        XmppState { cmd_recv, signal }
pub fn xmpp_process<F>(signal: F) -> impl future::Future<Item = (), Error = tokio::io::Error>
where
        })
pub struct XmppCommand;
struct XmppState<F> {
    cmd_recv: Receiver<XmppCommand>,
    signal: F,
}
            inner: Some(inner),
            jid,
            password,
            account,
        future::ok(XmppConnection {
        future::loop_fn(self, |XmppConnection { account, inner }| {
            if let Some(inner) = inner {
                Box::new(future::ok(future::Loop::Break(XmppConnection {
                    account,
                    inner: Some(inner),
                }))) as Box<Future<Item = _, Error = E>>
            } else {
                let (sink, stream) = client.split();
                Box::new(future::loop_fn(
                    (sink, stream, account),
                    |(sink, stream, account)| {
                        stream.into_future().then(|r| match r {
                            Ok((event, stream)) => match event {
                                Some(Event::Online) => {
                                    info!("Online");
                                    future::ok(future::Loop::Break(future::Loop::Break(
                                        XmppConnection {
                                            account,
                                            inner: Some((sink, stream)),
                                        },
                                    )))
                                }
                                Some(Event::Stanza(s)) => {
                                    info!("xmpp stanza: {:?}", s);
                                    future::ok(future::Loop::Continue((sink, stream, account)))
                                }
                                _ => {
                                    warn!("Disconnected");
                                }
                            },
                            Err((e, _)) => {
                                error!("xmpp receive error: {}", e);
                            }
                        })
                    },
                ))
    }
    /// get connection and wait for online status and set presence
    /// returns error if something went wrong
    fn online(
        (sink, stream): (stream::SplitSink<Client>, stream::SplitStream<Client>),
        account: config::Account,
        Box::new(future::loop_fn(
            (sink, stream, account),
            |(sink, stream, account)| {
                stream.into_future().then(|r| match r {
                    Ok((event, stream)) => match event {
                        Some(Event::Online) => {
                            info!("Online");
                            future::ok(future::Loop::Break(XmppConnection {
                                account,
                                inner: Some((sink, stream)),
                            }))
                        }
                        Some(Event::Stanza(s)) => {
                            info!("xmpp stanza: {:?}", s);
                            future::ok(future::Loop::Continue((sink, stream, account)))
                        }
                        _ => {
                            warn!("Disconnected");
                            future::err(account)
                        }
                    },
                    Err((e, _)) => {
                        error!("xmpp receive error: {}", e);
                        future::err(account)
                    }
                })
            },
        ))
    }
    fn self_presence(self) -> impl Future<Item = Self, Error = config::Account> {
        future::ok(self)
    ) -> impl Future<Item = XmppConnection, Error = config::Account> {
    ) -> impl Future<Item = Self, Error = config::Account> {
            let client = res_client.expect("Cann't init xmpp client");
            info!("xmpp initialized");
            client
        });
            }))
        }
                                future::ok(future::Loop::Break(future::Loop::Continue(
                                    XmppConnection {
                                        account,
                                        inner: None,
                                    },
                                )))
                                future::ok(future::Loop::Break(future::Loop::Continue(account)))
                                    future::ok(future::Loop::Break(future::Loop::Continue(
                                        XmppConnection {
                                            account,
                                            inner: None,
                                        },
                                    )))
                                    future::ok(future::Loop::Break(future::Loop::Continue(account)))
                Self::online(client.split(), account).then(|r| match r {
                    Ok(conn) => future::ok(future::Loop::Break(conn)),
                    Err(acc) => future::ok(future::Loop::Continue(acc)),
                })
                Self::online(client.split(), account)
                    .and_then(Self::self_presence)
                    .then(|r| match r {
                        Ok(conn) => future::ok(future::Loop::Break(conn)),
                        Err(acc) => future::ok(future::Loop::Continue(acc)),
                    })
                info!("xmpp initialization...");
                let mut res_client = Client::new(&account.jid, &account.password);
                while let Err(e) = res_client {
                    error!("Cann't init xmpp client: {}", e);
                    res_client = Client::new(&account.jid, &account.password);
                }
                let client = res_client.expect("Cann't init xmpp client");
                info!("xmpp initialized");
                // future to wait for online
        let XmppConnection { account, inner } = self;
        if let Some(inner) = inner {
            Box::new(future::ok(XmppConnection {
                account,
                inner: Some(inner),
            })) as Box<Future<Item = _, Error = E>>
        } else {
            Box::new(future::loop_fn(account, |account| {
        let XmppConnection {
            jid,
            password,
            inner,
        } = self;
            let mut res_client = Client::new(&jid, &password);
                res_client = Client::new(&jid, &password);
            }
                res_client = Client::new(&account.jid, &account.password);
            while let Err(e) = res_client {
                error!("Cann't init xmpp client: {}", e);
            let mut res_client = Client::new(&account.jid, &account.password);
        let inner = inner.unwrap_or_else(|| {
        let XmppConnection { account, inner } = self;
    fn connect<E>(self) -> impl Future<Item = Self, Error = E> {
    fn connect<E: 'static>(self) -> impl Future<Item = Self, Error = E> {
        info!("xmpp connection...");
            inner: None,
        }
    }
        XmppConnection {
            account,
    fn new(jid: &str, password: &str) -> XmppConnection {
    fn new(account: config::Account) -> XmppConnection {
    inner: Option<()>,
    inner: Option<Client>,
    account: config::Account,
    inner: Option<(stream::SplitSink<Client>, stream::SplitStream<Client>)>,
use config;
use tokio_xmpp::{Client, Event};
use tokio_xmpp::Client;
use tokio::prelude::future::{self, Either};
use tokio::prelude::{Future, Stream};
use tokio_channel::mpsc::Receiver;
pub struct XmppConnection {
use tokio::prelude::future;

File deletion: README.md

BF:BFD[1.0] → [10.64:75]

BF:BFD[10.75] → [10.76:76]

B:BD[58.54279] → [58.54279:54280]

B:BD[58.54302] → [58.54302:54303]

B:BD[96.39647] → [62.69492:69525]

B:BD[96.39648] → [62.69526:69553]

∅:BD[21.36089] → [58.54303:54382]

∅:BD[96.39683] → [58.54303:54382]

B:BD[58.54303] → [58.54303:54382]

∅:BD[98.68870] → [58.54411:54476]

∅:BD[21.36118] → [58.54411:54476]

∅:BD[96.39712] → [58.54411:54476]

B:BD[58.54411] → [58.54411:54476]

∅:BD[74.43793] → [58.54476:54480]

B:BD[58.54476] → [58.54476:54480]

∅:BD[74.43885] → [58.54480:54481]

B:BD[58.54480] → [58.54480:54481]

B:BD[58.54480] → [74.43794:43885]

B:BD[58.54476] → [74.43667:43793]

B:BD[58.54382] → [58.54382:54411]

B:BD[58.54382] → [96.39684:39712]

B:BD[58.54382] → [21.36090:36118]

B:BD[58.54382] → [98.68841:68870]

B:BD[58.54303] → [96.39620:39647]

B:BD[96.39647] → [96.39647:39648]

B:BD[96.39648] → [96.39648:39683]

B:BD[96.39485] → [96.39485:39486]

B:BD[96.39537] → [96.39537:39619]

B:BD[96.39486] → [62.69417:69491]

B:BD[96.39486] → [96.39486:39537]

B:BD[96.39486] → [60.47400:47526]

B:BD[58.54280] → [58.54280:54302]

B:BD[58.54280] → [62.69385:69416]

B:BD[58.54280] → [96.39454:39485]

B:BD[47.8397] → [47.8397:8398]

B:BD[38.14705] → [38.14705:14706]

B:BD[38.14706] → [47.8424:8543]

B:BD[38.14785] → [47.8544:8572]

B:BD[38.14785] → [30.13094:13123]

B:BD[38.14785] → [38.14785:14814]

B:BD[38.14814] → [38.14814:14884]

B:BD[38.14706] → [38.14706:14785]

B:BD[47.8398] → [47.8398:8423]

B:BD[47.8398] → [30.13071:13093]

∅:BD[98.68817] → [96.39360:39361]

∅:BD[60.47399] → [96.39360:39361]

∅:BD[21.36053] → [96.39360:39361]

B:BD[96.39360] → [96.39360:39361]

∅:BD[98.68840] → [96.39394:39395]

∅:BD[21.36066] → [96.39394:39395]

∅:BD[62.69332] → [96.39394:39395]

B:BD[96.39394] → [96.39394:39395]

B:BD[96.39453] → [95.39700:39759]

B:BD[96.39395] → [62.69333:69384]

B:BD[96.39395] → [96.39395:39453]

B:BD[96.39395] → [21.36067:36089]

B:BD[96.39361] → [62.69301:69332]

B:BD[96.39361] → [96.39361:39394]

B:BD[96.39361] → [21.36054:36066]

B:BD[96.39361] → [98.68818:68840]

B:BD[96.39360] → [60.47247:47399]

B:BD[38.14682] → [38.14682:14683]

B:BD[38.14683] → [47.8304:8397]

B:BD[38.14683] → [38.14683:14705]

B:BD[10.76] → [29.35511:35736]

B:BD[10.76] → [7.308:334]

B:BD[10.76] → [58.54256:54279]

B:BD[10.76] → [4.156:182]

B:BD[10.76] → [47.8201:8303]

B:BD[10.76] → [96.39248:39360]

B:BD[10.76] → [21.35376:36053]

B:BD[10.76] → [6.7421:7646]

B:BD[10.76] → [30.13047:13070]

B:BD[10.76] → [98.68794:68817]

B:BD[10.76] → [38.14659:14682]

B:BD[10.76] → [17.52395:52620]


#### XEP-0203: Delayed Delivery
Ignores delayed messages.
```
curl http://localhost:8083/ -H "X-XMPP-To: some@domain.org" -d "Test"
```
```
curl http://localhost:8083/ -H "X-XMPP-Muc: smac" -d "Test"
```
curl http://localhost:8083/ -H "X-XMPP-Muc: smac" -H "X-XMPP-Presence: chat" -d "Test"
```
```
### Setting status
```
curl http://localhost:8083/ -H "X-XMPP-Presence: chat" -d "Test"
```
### Setting status to MUC
#### Sending messages to MUC
### Sending messages to MUC
### Sending messages to MUC
#### Sending messages to MUC
Answers to incoming pings.
## HTTP API
### Sending messages
#### XEP-0199: XMPP Ping
Sends ping each `account.ping` seconds to XMPP server.
Ansers empty commands list. (Awaiting for implementation in xmpp_parser).
Enters to all MUC in `account.chatrooms` at start.
Answers empty commands list. (Awaiting for implementation in xmpp_parser).
#### XEP-0092: Software Version
Answers version.
#### Sending messages
#### XEP-0050: Ad-Hoc Commands
#### XEP-0045: Multi-User Chat
Sends ping each `account.ping` seconds to XMPP server.
Answers to incoming pings.
## HTTP API
### Sending messages
### Sending messages to MUC
#### Sending messages to MUC
#### Sending messages to MUC
```
curl http://localhost:8083/ -H "X-XMPP-Muc: smac" -d "Test"
```
```
curl http://localhost:8083/ -H "X-XMPP-To: some@domain.org" -d "Test"
```
#### XEP-0199: XMPP Ping
#### Sending messages
Answers to `http://jabber.org/protocol/disco#items` query.
Enters to all MUC in `account.chatrooms` at start.
Answers to `http://jabber.org/protocol/disco#info` query.
### Sending messages
#### XEP-0045: Multi-User Chat
#### XEP-0030: Service Discovery
## HTTP API
#### Sending messages
#### XEP-0030: Service Discovery
Answers to `http://jabber.org/protocol/disco#info` query.
Answers to `http://jabber.org/protocol/disco#items` query.
### XEPs
#### XEP-0045: Multi-User Chat
Enters to all MUC in `account.chatrooms` at start.
#### Sending messages
### 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"
```
### XMPP client daemon
### XMPP client daemon
### XMPP client daemon
# XMPP client daemon
## XMPP
### XMPP Core
Ensures granted subscription before delivering messages
# XMPP client daemon
## XMPP
### XMPP Core
Ensures granted subscription before delivering messages
### XEPs
# XMPP client daemon
## XMPP
### XMPP Core
Ensures granted subscription before delivering messages
### XEPs
#### XEP-0030: Service Discovery
Answers to `http://jabber.org/protocol/disco#info` query.
Answers to `http://jabber.org/protocol/disco#items` query.
#### XEP-0045: Multi-User Chat
Enters to all MUC in `account.chatrooms` at start.
#### XEP-0050: Ad-Hoc Commands
Answers empty commands list. (Awaiting for implementation in xmpp_parser).
#### XEP-0092: Software Version
Answers version.
#### XEP-0199: XMPP Ping
Sends ping each `account.ping` seconds to XMPP server.
Answers to incoming pings.
#### XEP-0203: Delayed Delivery
Ignores delayed messages.
### 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"
```
### XMPP client daemon
### XMPP client daemon
### XMPP client daemon
### 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"
```

File deletion: LICENSE-MIT

BF:BFD[1.0] → [10.77:90]

BF:BFD[10.90] → [10.91:91]

B:BD[10.91] → [10.92:1115]

Permission is hereby granted, free of charge, to any
person obtaining a copy of this software and associated
documentation files (the "Software"), to deal in the
Software without restriction, including without
limitation the rights to use, copy, modify, merge,
publish, distribute, sublicense, and/or sell copies of
the Software, and to permit persons to whom the Software
is furnished to do so, subject to the following
conditions:
The above copyright notice and this permission notice
shall be included in all copies or substantial portions
of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
DEALINGS IN THE SOFTWARE.

File deletion: LICENSE-APACHE

BF:BFD[1.0] → [10.1116:1132]

BF:BFD[10.1132] → [10.1133:1133]

B:BD[10.1133] → [10.1134:11981]

                              Apache License
                        Version 2.0, January 2004
                     http://www.apache.org/licenses/
TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
1. Definitions.
   "License" shall mean the terms and conditions for use, reproduction,
   and distribution as defined by Sections 1 through 9 of this document.
   "Licensor" shall mean the copyright owner or entity authorized by
   the copyright owner that is granting the License.
   "Legal Entity" shall mean the union of the acting entity and all
   other entities that control, are controlled by, or are under common
   control with that entity. For the purposes of this definition,
   "control" means (i) the power, direct or indirect, to cause the
   direction or management of such entity, whether by contract or
   otherwise, or (ii) ownership of fifty percent (50%) or more of the
   outstanding shares, or (iii) beneficial ownership of such entity.
   "You" (or "Your") shall mean an individual or Legal Entity
   exercising permissions granted by this License.
   "Source" form shall mean the preferred form for making modifications,
   including but not limited to software source code, documentation
   source, and configuration files.
   "Object" form shall mean any form resulting from mechanical
   transformation or translation of a Source form, including but
   not limited to compiled object code, generated documentation,
   and conversions to other media types.
   "Work" shall mean the work of authorship, whether in Source or
   Object form, made available under the License, as indicated by a
   copyright notice that is included in or attached to the work
   (an example is provided in the Appendix below).
   "Derivative Works" shall mean any work, whether in Source or Object
   form, that is based on (or derived from) the Work and for which the
   editorial revisions, annotations, elaborations, or other modifications
   represent, as a whole, an original work of authorship. For the purposes
   of this License, Derivative Works shall not include works that remain
   separable from, or merely link (or bind by name) to the interfaces of,
   the Work and Derivative Works thereof.
   "Contribution" shall mean any work of authorship, including
   the original version of the Work and any modifications or additions
   to that Work or Derivative Works thereof, that is intentionally
   submitted to Licensor for inclusion in the Work by the copyright owner
   or by an individual or Legal Entity authorized to submit on behalf of
   the copyright owner. For the purposes of this definition, "submitted"
   means any form of electronic, verbal, or written communication sent
   to the Licensor or its representatives, including but not limited to
   communication on electronic mailing lists, source code control systems,
   and issue tracking systems that are managed by, or on behalf of, the
   Licensor for the purpose of discussing and improving the Work, but
   excluding communication that is conspicuously marked or otherwise
   designated in writing by the copyright owner as "Not a Contribution."
   "Contributor" shall mean Licensor and any individual or Legal Entity
   on behalf of whom a Contribution has been received by Licensor and
   subsequently incorporated within the Work.
2. Grant of Copyright License. Subject to the terms and conditions of
   this License, each Contributor hereby grants to You a perpetual,
   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
   copyright license to reproduce, prepare Derivative Works of,
   publicly display, publicly perform, sublicense, and distribute the
   Work and such Derivative Works in Source or Object form.
3. Grant of Patent License. Subject to the terms and conditions of
   this License, each Contributor hereby grants to You a perpetual,
   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
   (except as stated in this section) patent license to make, have made,
   use, offer to sell, sell, import, and otherwise transfer the Work,
   where such license applies only to those patent claims licensable
   by such Contributor that are necessarily infringed by their
   Contribution(s) alone or by combination of their Contribution(s)
   with the Work to which such Contribution(s) was submitted. If You
   institute patent litigation against any entity (including a
   cross-claim or counterclaim in a lawsuit) alleging that the Work
   or a Contribution incorporated within the Work constitutes direct
   or contributory patent infringement, then any patent licenses
   granted to You under this License for that Work shall terminate
   as of the date such litigation is filed.
4. Redistribution. You may reproduce and distribute copies of the
   Work or Derivative Works thereof in any medium, with or without
   modifications, and in Source or Object form, provided that You
   meet the following conditions:
   (a) You must give any other recipients of the Work or
       Derivative Works a copy of this License; and
   (b) You must cause any modified files to carry prominent notices
       stating that You changed the files; and
   (c) You must retain, in the Source form of any Derivative Works
       that You distribute, all copyright, patent, trademark, and
       attribution notices from the Source form of the Work,
       excluding those notices that do not pertain to any part of
       the Derivative Works; and
   (d) If the Work includes a "NOTICE" text file as part of its
       distribution, then any Derivative Works that You distribute must
       include a readable copy of the attribution notices contained
       within such NOTICE file, excluding those notices that do not
       pertain to any part of the Derivative Works, in at least one
       of the following places: within a NOTICE text file distributed
       as part of the Derivative Works; within the Source form or
       documentation, if provided along with the Derivative Works; or,
       within a display generated by the Derivative Works, if and
       wherever such third-party notices normally appear. The contents
       of the NOTICE file are for informational purposes only and
       do not modify the License. You may add Your own attribution
       notices within Derivative Works that You distribute, alongside
       or as an addendum to the NOTICE text from the Work, provided
       that such additional attribution notices cannot be construed
       as modifying the License.
   You may add Your own copyright statement to Your modifications and
   may provide additional or different license terms and conditions
   for use, reproduction, or distribution of Your modifications, or
   for any such Derivative Works as a whole, provided Your use,
   reproduction, and distribution of the Work otherwise complies with
   the conditions stated in this License.
5. Submission of Contributions. Unless You explicitly state otherwise,
   any Contribution intentionally submitted for inclusion in the Work
   by You to the Licensor shall be under the terms and conditions of
   this License, without any additional terms or conditions.
   Notwithstanding the above, nothing herein shall supersede or modify
   the terms of any separate license agreement you may have executed
   with Licensor regarding such Contributions.
6. Trademarks. This License does not grant permission to use the trade
   names, trademarks, service marks, or product names of the Licensor,
   except as required for reasonable and customary use in describing the
   origin of the Work and reproducing the content of the NOTICE file.
7. Disclaimer of Warranty. Unless required by applicable law or
   agreed to in writing, Licensor provides the Work (and each
   Contributor provides its Contributions) on an "AS IS" BASIS,
   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
   implied, including, without limitation, any warranties or conditions
   of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
   PARTICULAR PURPOSE. You are solely responsible for determining the
   appropriateness of using or redistributing the Work and assume any
   risks associated with Your exercise of permissions under this License.
8. Limitation of Liability. In no event and under no legal theory,
   whether in tort (including negligence), contract, or otherwise,
   unless required by applicable law (such as deliberate and grossly
   negligent acts) or agreed to in writing, shall any Contributor be
   liable to You for damages, including any direct, indirect, special,
   incidental, or consequential damages of any character arising as a
   result of this License or out of the use or inability to use the
   Work (including but not limited to damages for loss of goodwill,
   work stoppage, computer failure or malfunction, or any and all
   other commercial damages or losses), even if such Contributor
   has been advised of the possibility of such damages.
9. Accepting Warranty or Additional Liability. While redistributing
   the Work or Derivative Works thereof, You may choose to offer,
   and charge a fee for, acceptance of support, warranty, indemnity,
   or other liability obligations and/or rights consistent with this
   License. However, in accepting such obligations, You may act only
   on Your own behalf and on Your sole responsibility, not on behalf
   of any other Contributor, and only if You agree to indemnify,
   defend, and hold each Contributor harmless for any liability
   incurred by, or claims asserted against, such Contributor by reason
   of your accepting any such warranty or additional liability.
END OF TERMS AND CONDITIONS
APPENDIX: How to apply the Apache License to your work.
   To apply the Apache License to your work, attach the following
   boilerplate notice, with the fields enclosed by brackets "[]"
   replaced with your own identifying information. (Don't include
   the brackets!)  The text should be enclosed in the appropriate
   comment syntax for the file format. We also recommend that a
   file or class name and description of purpose be included on the
   same "printed page" as the copyright notice for easier
   identification within third-party archives.
Copyright [yyyy] [name of copyright owner]
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
	http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.

File deletion: Cargo.toml
BF:BFD[1.0] → [10.11982:11994]
BF:BFD[10.11994] → [10.11995:11995]
B:BD[10.11995] → [10.11996:12171]
∅:BD[17.52638] → [10.12171:12187]
∅:BD[26.2531] → [10.12171:12187]
∅:BD[20.6842] → [10.12171:12187]
∅:BD[22.6353] → [10.12171:12187]
∅:BD[28.960] → [10.12171:12187]
∅:BD[58.54499] → [10.12171:12187]
B:BD[10.12171] → [10.12171:12187]
B:BD[17.52696] → [59.46566:46585]
B:BD[17.52750] → [59.46586:46599]
∅:BD[60.47540] → [17.52763:52798]
∅:BD[77.37255] → [17.52763:52798]
∅:BD[62.69567] → [17.52763:52798]
∅:BD[58.54553] → [17.52763:52798]
∅:BD[63.48389] → [17.52763:52798]
∅:BD[59.46599] → [17.52763:52798]
B:BD[17.52763] → [17.52763:52798]
∅:BD[21.36250] → [17.52812:52824]
B:BD[17.52812] → [17.52812:52824]
B:BD[17.52900] → [73.35285:35362]
B:BD[58.54573] → [63.48390:48414]
B:BD[58.54630] → [63.48415:48450]
B:BD[58.54630] → [58.54630:54707]
B:BD[58.54630] → [62.69593:69628]
B:BD[58.54630] → [77.37279:37356]
B:BD[58.54630] → [60.47564:47641]
B:BD[58.54573] → [58.54573:54595]
B:BD[58.54595] → [58.54595:54630]
B:BD[58.54573] → [62.69568:69592]
B:BD[58.54573] → [77.37256:37278]
B:BD[58.54573] → [60.47541:47563]
B:BD[17.52824] → [59.46600:46661]
B:BD[17.52824] → [58.54554:54573]
B:BD[17.52824] → [21.36251:36526]
∅:BD[2.4073] → [21.36645:36646]
B:BD[21.36645] → [21.36645:36646]
B:BD[21.36526] → [21.36526:36645]
B:BD[21.36526] → [2.3920:4073]
B:BD[17.52824] → [17.52824:52900]
B:BD[17.52798] → [21.36236:36250]
B:BD[17.52798] → [17.52798:52812]
B:BD[17.52750] → [63.48376:48389]
B:BD[17.52750] → [58.54540:54553]
B:BD[17.52750] → [62.69554:69567]
∅:BD[21.36235] → [77.37242:37255]
B:BD[17.52750] → [77.37242:37255]
B:BD[17.52750] → [60.47527:47540]
B:BD[17.52750] → [17.52750:52763]
B:BD[9.2097] → [13.3347:3369]
B:BD[9.2214] → [19.238:269]
B:BD[9.2214] → [9.2214:2215]
B:BD[19.269] → [12.3520:3537]
B:BD[17.52696] → [58.54500:54539]
B:BD[20.6857] → [22.6354:6376]
B:BD[20.6900] → [24.1348:1367]
B:BD[20.6950] → [92.3341:3354]
B:BD[20.7012] → [22.6394:6425]
B:BD[20.7012] → [24.1368:1369]
B:BD[43.19184] → [43.19184:19219]
B:BD[43.19219] → [43.19219:19254]
B:BD[29.35813] → [29.35813:35848]
B:BD[29.35848] → [46.59493:59528]
B:BD[22.6425] → [92.3355:3377]
B:BD[22.6425] → [43.19160:19184]
B:BD[22.6425] → [29.35791:35813]
B:BD[22.6425] → [46.59468:59492]
B:BD[22.6425] → [47.8587:8611]
B:BD[22.6425] → [22.6425:6542]
B:BD[22.6425] → [48.14017:14111]
B:BD[22.6425] → [30.13138:13160]
B:BD[22.6425] → [49.13276:13394]
B:BD[22.6425] → [53.4470:4588]
B:BD[20.7012] → [20.7012:7043]
B:BD[20.7111] → [40.9785:9878]
B:BD[20.7111] → [84.3927:3976]
B:BD[20.7111] → [20.7111:7112]
B:BD[20.7111] → [83.10655:10704]
B:BD[20.7111] → [81.10253:10302]
B:BD[20.7111] → [37.13540:13589]
B:BD[20.7043] → [42.14102:14196]
B:BD[20.7043] → [20.7043:7111]
B:BD[20.7111] → [31.8552:8553]
B:BD[20.7043] → [54.7858:7927]
B:BD[20.7043] → [55.31778:31872]
B:BD[20.6950] → [29.35777:35790]
B:BD[20.6950] → [46.59454:59467]
B:BD[20.6950] → [47.8573:8586]
B:BD[20.6950] → [30.13124:13137]
B:BD[20.6950] → [49.13262:13275]
B:BD[20.6950] → [20.6950:6963]
B:BD[20.6963] → [20.6963:7012]
B:BD[20.6935] → [20.6935:6950]
B:BD[24.1367] → [22.6377:6393]
B:BD[20.6900] → [42.14062:14101]
B:BD[20.6900] → [43.19120:19159]
B:BD[20.6900] → [29.35737:35776]
B:BD[20.6900] → [48.13977:14016]
B:BD[20.6900] → [49.13226:13261]
B:BD[20.6900] → [20.6900:6919]
B:BD[20.6919] → [41.4748:4764]
B:BD[20.6919] → [33.7608:7626]
B:BD[20.6919] → [20.6919:6935]
B:BD[20.6900] → [53.4434:4469]
B:BD[20.6900] → [54.7822:7857]
B:BD[20.6900] → [55.31738:31777]
B:BD[20.6857] → [20.6857:6879]
B:BD[20.6879] → [20.6879:6900]
B:BD[15.6667] → [26.2532:2548]
B:BD[15.6756] → [15.6756:6794]
B:BD[15.6794] → [15.6794:6817]
B:BD[15.6756] → [137.0:65]
B:BD[15.6756] → [25.4378:4416]
B:BD[15.6756] → [16.1862:1900]
B:BD[15.6756] → [26.2549:2614]
B:BD[15.6756] → [27.773:838]
B:BD[15.6667] → [27.756:772]
B:BD[17.52696] → [17.52696:52735]
B:BD[17.52735] → [17.52735:52750]
B:BD[10.12187] → [15.6591:6667]
B:BD[15.6667] → [15.6667:6756]
B:BD[10.12187] → [21.36119:36142]
∅:BD[2.3919] → [21.36202:36235]
B:BD[21.36202] → [21.36202:36235]
B:BD[21.36142] → [21.36142:36202]
B:BD[21.36142] → [2.3842:3919]
B:BD[10.12187] → [9.2083:2097]
B:BD[9.2097] → [9.2097:2214]
B:BD[10.12187] → [20.6843:6857]
B:BD[10.12187] → [17.52639:52696]
B:BD[10.12171] → [58.54482:54499]
B:BD[10.12171] → [28.943:960]
B:BD[10.12171] → [22.6336:6353]
B:BD[10.12171] → [20.6825:6842]
B:BD[10.12171] → [26.2514:2531]
B:BD[10.12171] → [17.52621:52638]
```
[package]
name = "sendxmppd-rust"
version = "0.1.0"
authors = ["O01eg <o01eg@yandex.ru>"]
license = "MIT/Apache-2.0"
repository = "https://bitbucket.org/O01eg/sendxmppd-rust"
[dependencies]
tokio-xmpp = "0.2"
toml = "0.4"
serde = "1.0"
serde_derive = "1.0"
log = "0.4"
lazy_static = "1.3.0" # ToDo: remove after const fn will be powerfull enough
xmpp-parsers = "0.12.2"
try_from = "=0.3.2" # xmpp-parsers
lazy_static = "1.3.0" # ToDo: remove after const fn will be powerfull enough
try_from = "=0.3.2" # xmpp-parsers
lazy_static = "1.3.0" # ToDo: remove after const fn will be powerfull enough
lazy_static = "1.3.0" # ToDo: remove after const fn will be powerfull enough
xmpp-parsers = "0.13"
minidom = "=0.10.0" # xmpp-parsers
xmpp-parsers = "0.12.2"
xmpp-parsers = "0.13"
xmpp-parsers = "0.13"
env_logger = "0.5"
minidom = "=0.9.1"
xmpp-parsers = "0.11"
env_logger = "0.6"
env_logger = "0.7"
xmpp-parsers = "0.17"
minidom = "=0.12.0" # xmpp-parsers
lazy_static = "1.4.0" # ToDo: remove after const fn will be powerfull enough
pin-project = "0.4"
[dependencies.tokio]
version = "0.2"
features = ["signal", "sync", "rt-threaded"]
[patch.crates-io]
xmpp-parsers = { git = "https://gitlab.com/xmpp-rs/xmpp-rs" }
minidom = { git = "https://gitlab.com/xmpp-rs/xmpp-rs" }
xmpp-parsers = { git = "https://gitlab.com/xmpp-rs/xmpp-rs", branch = "main" }
minidom = { git = "https://gitlab.com/xmpp-rs/xmpp-rs", branch = "main" }
env_logger = "0.6"
xmpp-parsers = "0.13"
minidom = "=0.10.0" # xmpp-parsers
clap = "2.33"
clap = "2.32"
toml = "0.4"
toml = "0.5"
toml = "0.4"
toml = "0.5"
toml = "0.5"
toml = "0.5"
tokio-channel = "0.1"
log = "0.4"
env_logger = "0.5"
minidom = "0.10"
tokio-xmpp = "1.0.0"
failure = "0.1.5"
tokio-channel = "0.1"
tokio-xmpp = "0.2"
toml = "0.5"
log = "0.4"
env_logger = "0.6"
minidom = "=0.10.0" # xmpp-parsers
try_from = "=0.3.2" # xmpp-parsers
minidom = "=0.10.0" # xmpp-parsers
try_from = "=0.3.2" # xmpp-parsers
xmpp-parsers = "0.13"
xmpp-parsers = "0.12.2"
xmpp-parsers = "0.13"
xmpp-parsers = "0.12.2"
xmpp-parsers = "0.12.2"
minidom = "=0.9.1" # dependency of tokio-xmpp
xmpp-parsers = "0.11"
try_from = "=0.2.2" # dependency of xmpp-parsers
xmpp-parsers = "0.12.2"
minidom = "=0.10.0" # xmpp-parsers
try_from = "=0.3.2" # xmpp-parsers
xmpp-parsers = "0.13"
minidom = "=0.9.1" # dependency of tokio-xmpp
xmpp-parsers = "0.11"
try_from = "=0.2.2" # dependency of xmpp-parsers
minidom = "=0.9.1" # dependency of tokio-xmpp
xmpp-parsers = "0.11"
try_from = "=0.2.2" # dependency of xmpp-parsers
log = "0.4"
env_logger = "0.6"
try_from = "=0.2.2" # dependency of xmpp-parsers
jid = "=0.5.2" # dependency of xmpp-parsers
try_from = "=0.2.2" # dependency of xmpp-parsers
try_from = "=0.2.2" # dependency of xmpp-parsers
try_from = "=0.2.2" # dependency of xmpp-parsers
try_from = "=0.2.2" # dependency of xmpp-parsers
xmpp-parsers = "0.12.2"
minidom = "=0.10.0" # xmpp-parsers
try_from = "=0.3.2" # xmpp-parsers
minidom = "=0.9.1" # dependency of tokio-xmpp
xmpp-parsers = "0.11"
minidom = "=0.9.1" # dependency of tokio-xmpp
xmpp-parsers = "0.11"
xmpp-parsers = "0.12.2"
minidom = "=0.10.0" # xmpp-parsers
try_from = "=0.3.2" # xmpp-parsers
toml = "0.5"
toml = "0.4"
toml = "0.4"
toml = "0.5"
toml = "0.4"
toml = "0.4"
serde = "1.0"
serde_derive = "1.0"
clap = "2.32"
hyper = "0.12"
failure = "0.1"
tokio-xmpp = "0.2.3"
failure = "0.1.5"
tokio-xmpp = "1.0.0"
failure = "0.1.5"
tokio-xmpp = "1.0.0"
failure = "0.1.5"
tokio-xmpp = "0.2.3"
failure = "0.1.5"
tokio-xmpp = "0.2"
failure = "0.1"
tokio-xmpp = "0.2"
failure = "0.1"
failure = "0.1.4"
failure = "0.1"
tokio-xmpp = "0.2"
failure = "0.1"
tokio-xmpp = "0.2"
failure = "0.1"
tokio-xmpp = "0.2.3"
failure = "0.1.5"
tokio-channel = "0.1"
tokio-signal = "0.2"
failure = "0.1"
env_logger = "0.5"
minidom = "=0.9.1"
xmpp-parsers = "0.11"
env_logger = "0.6"
minidom = "=0.9.1" # dependency of tokio-xmpp
env_logger = "0.5"
minidom = "=0.9.1"
env_logger = "0.5"
minidom = "=0.9.1"
env_logger = "0.6"
minidom = "=0.9.1" # dependency of tokio-xmpp
env_logger = "0.6"
minidom = "=0.9.1" # dependency of tokio-xmpp
failure = "0.1"
tokio-xmpp = "1.0.0"
failure = "0.1.5"
hyper = "0.12"
tokio = "0.1"
tokio-channel = "0.1"
tokio-signal = "0.2"
tokio-xmpp = "0.2"
hyper = "0.12"
toml = "0.4"
serde = "1.0"
serde_derive = "1.0"
clap = "2.32"
log = "0.4"
futures-util = "0.3.5"
failure = "0.1.8"
hyper = "0.13"
tokio-xmpp = { git = "https://gitlab.com/xmpp-rs/xmpp-rs" }
tokio-xmpp = { git = "https://gitlab.com/xmpp-rs/xmpp-rs", branch = "main" }
tokio = "0.1"
tokio-signal = "0.2"
tokio-xmpp = "0.2"
hyper = "0.12"
toml = "0.4"
serde = "1.0"
serde_derive = "1.0"
clap = "2.32"
tokio = "0.1"
tokio = "0.1"
tokio-channel = "0.1"
tokio-signal = "0.2"
edition = "2018"
edition = "2018"
edition = "2018"
edition = "2018"
edition = "2018"
edition = "2018"
```

File deletion: Cargo.lock

BF:BFD[1.0] → [10.12188:12200]

BF:BFD[10.12200] → [10.12201:12201]

B:BD[15.6852] → [15.6852:6870]

B:BD[15.6952] → [15.6952:7025]

B:BD[15.7266] → [15.7266:7284]

B:BD[15.7494] → [15.7494:7512]

B:BD[15.7594] → [15.7594:7668]

B:BD[15.7798] → [15.7798:7870]

B:BD[15.8019] → [26.2894:2907]

B:BD[15.8032] → [15.8032:8151]

B:BD[15.8232] → [15.8232:8462]

B:BD[15.8615] → [15.8615:8722]

B:BD[15.8740] → [15.8740:8822]

B:BD[15.8903] → [15.8903:8976]

B:BD[15.9129] → [15.9129:9240]

B:BD[15.9259] → [15.9259:9341]

B:BD[15.9483] → [15.9483:10786]

B:BD[15.10805] → [15.10805:11172]

B:BD[15.11191] → [15.11191:11653]

B:BD[15.11725] → [15.11725:12938]

B:BD[15.13010] → [15.13010:13154]

B:BD[15.13226] → [15.13226:13266]

B:BD[15.13284] → [15.13284:13366]

B:BD[15.13530] → [15.13530:13570]

B:BD[15.13588] → [15.13588:13670]

B:BD[15.13745] → [15.13745:13818]

B:BD[15.13978] → [15.13978:14171]

B:BD[15.14189] → [15.14189:14254]

B:BD[15.14254] → [15.14254:15438]

B:BD[15.15457] → [15.15457:15647]

B:BD[15.15666] → [15.15666:15820]

B:BD[15.16038] → [15.16038:16463]

B:BD[15.16539] → [15.16539:16671]

B:BD[15.16747] → [15.16747:16967]

B:BD[15.17270] → [15.17270:18884]

B:BD[15.18959] → [15.18959:19199]

B:BD[15.19218] → [15.19218:19376]

B:BD[15.19449] → [15.19449:19594]

B:BD[15.19666] → [15.19666:19741]

B:BD[15.19811] → [15.19811:19882]

B:BD[15.19955] → [15.19955:20164]

B:BD[15.20236] → [15.20236:20339]

B:BD[15.20358] → [15.20358:20440]

B:BD[15.20513] → [15.20513:20802]

B:BD[15.20820] → [15.20820:21010]

B:BD[15.21030] → [15.21030:21112]

B:BD[15.21185] → [15.21185:21342]

B:BD[15.21484] → [15.21484:21702]

B:BD[15.21772] → [15.21772:21844]

B:BD[15.21916] → [15.21916:21989]

B:BD[15.22146] → [15.22146:22226]

B:BD[15.22302] → [15.22302:22463]

B:BD[15.23148] → [15.23148:23220]

B:BD[15.23326] → [15.23326:23344]

B:BD[15.24705] → [15.24705:24723]

B:BD[15.24788] → [15.24788:24887]

B:BD[15.24918] → [15.24918:24936]

B:BD[15.25028] → [15.25028:25047]

B:BD[15.25264] → [15.25264:25282]

B:BD[15.25364] → [15.25364:25441]

B:BD[15.25518] → [15.25518:25716]

B:BD[15.25744] → [15.25744:25762]

B:BD[15.26278] → [15.26278:26296]

B:BD[15.26528] → [15.26528:26681]

B:BD[15.26925] → [15.26925:26999]

B:BD[15.27143] → [15.27143:27161]

B:BD[15.27316] → [15.27316:27388]

B:BD[15.28393] → [15.28393:28468]

B:BD[15.28610] → [15.28610:29101]

B:BD[15.29173] → [15.29173:29809]

B:BD[15.30029] → [15.30029:30514]

B:BD[15.30589] → [15.30589:30792]

B:BD[15.30864] → [15.30864:31192]

B:BD[15.31211] → [15.31211:31607]

B:BD[9.5081] → [15.31608:31626]

B:BD[15.31644] → [15.31644:31726]

B:BD[15.31798] → [15.31798:32160]

B:BD[15.32310] → [15.32310:32645]

B:BD[15.32787] → [15.32787:32972]

B:BD[15.32990] → [15.32990:33293]

B:BD[15.33368] → [15.33368:33592]

B:BD[15.33664] → [15.33664:33815]

B:BD[15.33890] → [15.33890:35363]

B:BD[15.35382] → [15.35382:35794]

B:BD[15.35873] → [15.35873:35947]

B:BD[15.36090] → [15.36090:36232]

B:BD[15.36250] → [15.36250:36332]

B:BD[15.36411] → [15.36411:36621]

B:BD[15.36693] → [15.36693:37051]

B:BD[15.37123] → [15.37123:37199]

B:BD[27.5780] → [26.9026:9029]

B:BD[26.9041] → [20.37378:37392]

B:BD[20.37410] → [20.37410:37492]

B:BD[24.12070] → [24.12070:12151]

B:BD[24.12223] → [24.12223:12299]

B:BD[22.12274] → [43.29951:29969]

B:BD[22.12374] → [43.29970:30044]

B:BD[43.30116] → [43.30116:30270]

B:BD[22.12907] → [43.30271:30349]

B:BD[70.6390] → [70.6390:6465]

B:BD[22.13179] → [43.30505:30523]

B:BD[22.13279] → [43.30524:30674]

B:BD[20.38348] → [20.38348:38369]

B:BD[20.38469] → [42.23911:23985]

B:BD[20.38545] → [20.38545:38625]

B:BD[20.38640] → [20.38640:38659]

B:BD[20.38677] → [20.38677:38759]

B:BD[20.38835] → [20.38835:38869]

B:BD[20.38887] → [22.13436:13631]

B:BD[22.13707] → [22.13707:13742]

B:BD[22.13742] → [22.13742:13760]

B:BD[20.38952] → [22.13761:13778]

B:BD[43.30943] → [43.30943:30958]

B:BD[43.31587] → [92.6471:6543]

B:BD[43.31332] → [92.6452:6470]

B:BD[43.31079] → [92.6379:6451]

B:BD[43.31587] → [70.6558:6630]

B:BD[43.31332] → [70.6539:6557]

B:BD[43.31079] → [70.6466:6538]

B:BD[43.31808] → [43.31808:31881]

B:BD[22.13875] → [70.6631:6649]

B:BD[22.13975] → [70.6650:6800]

B:BD[22.14146] → [29.50572:50606]

B:BD[43.32059] → [43.32059:32135]

B:BD[43.32150] → [43.32150:32184]

B:BD[48.24586] → [43.32185:32261]

B:BD[22.14187] → [22.14187:14360]

B:BD[20.39910] → [24.12300:12319]

B:BD[20.40048] → [22.14381:14463]

B:BD[22.14544] → [22.14544:14574]

B:BD[22.14592] → [22.14592:14674]

B:BD[43.32456] → [43.32456:32535]

B:BD[22.15099] → [43.32536:32554]

B:BD[20.40341] → [24.12320:12401]

B:BD[20.40744] → [20.40744:40766]

B:BD[20.41080] → [29.51056:51129]

B:BD[20.41189] → [24.12402:12420]

B:BD[20.41481] → [24.12421:12439]

B:BD[20.41801] → [24.12440:12458]

B:BD[24.12536] → [24.12536:12571]

B:BD[20.41897] → [20.41897:42010]

B:BD[20.42024] → [24.12572:12590]

B:BD[20.42124] → [24.12591:12740]

∅:BD[17.90991] → [10.12214:12238]

∅:BD[20.43796] → [10.12214:12238]

∅:BD[9.35265] → [10.12214:12238]

∅:BD[15.41521] → [10.12214:12238]

B:BD[10.12214] → [10.12214:12238]

B:BD[10.12256] → [10.12256:12257]

B:BD[19.2078] → [12.4336:4411]

B:BD[9.45320] → [13.3451:3664]

B:BD[9.35655] → [13.3370:3450]

B:BD[9.57125] → [9.57125:57143]

B:BD[15.41611] → [15.41611:41833]

B:BD[15.41907] → [15.41907:42060]

B:BD[15.42213] → [15.42213:42292]

B:BD[15.42369] → [15.42369:42440]

B:BD[15.42550] → [15.42550:42569]

B:BD[15.42669] → [15.42669:42688]

B:BD[15.42770] → [15.42770:42993]

B:BD[15.43028] → [15.43028:43047]

B:BD[15.43200] → [15.43200:43270]

B:BD[15.44679] → [15.44679:44697]

B:BD[15.44779] → [15.44779:44926]

B:BD[15.45184] → [15.45184:45202]

B:BD[15.45567] → [15.45567:45720]

B:BD[15.45948] → [15.45948:45966]

B:BD[15.46166] → [15.46166:46244]

B:BD[15.46493] → [15.46493:46566]

B:BD[15.47043] → [15.47043:47194]

B:BD[15.47899] → [15.47899:47919]

B:BD[15.48001] → [15.48001:48152]

B:BD[9.60736] → [15.48233:48476]

B:BD[15.48495] → [15.48495:48577]

B:BD[15.48800] → [15.48800:48911]

B:BD[15.48929] → [15.48929:49084]

B:BD[15.49308] → [15.49308:49494]

B:BD[15.49512] → [15.49512:50148]

B:BD[15.50301] → [15.50301:50732]

B:BD[15.50810] → [15.50810:50839]

B:BD[15.50858] → [15.50858:50940]

B:BD[15.51093] → [15.51093:51196]

B:BD[15.51215] → [15.51215:51297]

B:BD[15.51370] → [15.51370:51516]

B:BD[15.51516] → [15.51516:51594]

B:BD[15.51681] → [15.51681:51913]

B:BD[15.51993] → [15.51993:52069]

B:BD[15.52382] → [15.52382:52420]

B:BD[15.52438] → [15.52438:52731]

B:BD[15.52958] → [15.52958:53000]

B:BD[15.70370] → [15.70370:70518]

B:BD[15.70518] → [15.70518:70670]

B:BD[15.70979] → [15.70979:71888]

B:BD[15.72037] → [15.72037:72184]

B:BD[15.72330] → [15.72330:73406]

B:BD[15.73880] → [15.73880:74491]

B:BD[15.74800] → [15.74800:76963]

B:BD[15.77109] → [15.77109:77260]

B:BD[15.77408] → [15.77408:77559]

B:BD[15.77861] → [15.77861:78307]

B:BD[15.78458] → [15.78458:79055]

B:BD[15.79508] → [15.79508:79666]

B:BD[15.80109] → [15.80109:80407]

B:BD[15.80561] → [15.80561:80711]

B:BD[15.80860] → [15.80860:82071]

B:BD[15.82221] → [15.82221:82529]

B:BD[15.82680] → [15.82680:83143]

B:BD[15.83296] → [15.83296:84694]

B:BD[15.84849] → [15.84849:85305]

B:BD[15.85453] → [15.85453:85747]

B:BD[15.85747] → [15.85747:86051]

B:BD[15.86208] → [15.86208:86364]

B:BD[15.86667] → [15.86667:86978]

B:BD[15.87135] → [15.87135:87291]

B:BD[15.87437] → [15.87437:88670]

B:BD[15.89129] → [15.89129:89571]

B:BD[15.89725] → [15.89725:90024]

B:BD[15.90175] → [15.90175:90486]

B:BD[15.90635] → [15.90635:91412]

B:BD[15.91560] → [15.91560:91709]

B:BD[15.92166] → [15.92166:92775]

B:BD[15.92923] → [15.92923:93072]

B:BD[15.93382] → [15.93382:93545]

B:BD[15.94005] → [15.94005:94316]

B:BD[15.94468] → [15.94468:94781]

B:BD[15.94933] → [15.94933:95237]

B:BD[15.95390] → [15.95390:95537]

B:BD[15.96309] → [15.96309:96460]

B:BD[15.97397] → [15.97397:97543]

B:BD[15.97691] → [15.97691:97845]

B:BD[15.100296] → [15.100296:100448]

B:BD[15.100448] → [15.100448:100604]

B:BD[15.100296] → [137.22165:22317]

B:BD[15.100296] → [25.25207:25359]

B:BD[15.100296] → [16.21093:21245]

B:BD[15.100296] → [26.29084:29236]

B:BD[15.100296] → [27.23012:23164]

B:BD[15.97845] → [15.97845:100296]

B:BD[15.97691] → [137.22010:22164]

B:BD[15.97691] → [25.25052:25206]

B:BD[15.97691] → [16.20938:21092]

B:BD[15.97691] → [26.28929:29083]

B:BD[15.97691] → [27.22857:23011]

B:BD[15.97543] → [15.97543:97691]

B:BD[15.97397] → [137.21863:22009]

B:BD[15.97397] → [25.24905:25051]

B:BD[15.97397] → [16.20791:20937]

B:BD[15.97397] → [26.28782:28928]

B:BD[15.97397] → [27.22710:22856]

B:BD[15.96460] → [15.96460:97397]

B:BD[15.96309] → [137.21711:21862]

B:BD[15.96309] → [25.24753:24904]

B:BD[15.96309] → [16.20639:20790]

B:BD[15.96309] → [26.28630:28781]

B:BD[15.96309] → [27.22558:22709]

B:BD[15.95537] → [15.95537:96309]

B:BD[15.95390] → [137.21563:21710]

B:BD[15.95390] → [25.24605:24752]

B:BD[15.95390] → [28.1786:1934]

B:BD[15.95390] → [16.20491:20638]

B:BD[15.95390] → [26.28481:28629]

B:BD[15.95390] → [27.22410:22557]

B:BD[15.95237] → [15.95237:95390]

B:BD[15.94933] → [137.21258:21562]

B:BD[15.94933] → [25.24300:24604]

B:BD[15.94933] → [16.20186:20490]

B:BD[15.94933] → [26.28176:28480]

B:BD[15.94933] → [27.22105:22409]

B:BD[15.94781] → [15.94781:94933]

B:BD[15.94468] → [137.20944:21257]

B:BD[15.94468] → [25.23986:24299]

B:BD[15.94468] → [16.19872:20185]

B:BD[15.94468] → [26.27862:28175]

B:BD[15.94468] → [27.21791:22104]

B:BD[15.94316] → [15.94316:94468]

B:BD[15.94005] → [137.20632:20943]

B:BD[15.94005] → [25.23674:23985]

B:BD[15.94005] → [16.19560:19871]

B:BD[15.94005] → [26.27550:27861]

B:BD[15.94005] → [27.21479:21790]

B:BD[15.93545] → [15.93545:94005]

B:BD[15.93382] → [137.20468:20631]

B:BD[15.93382] → [25.23510:23673]

B:BD[15.93382] → [16.19396:19559]

B:BD[15.93382] → [26.27386:27549]

B:BD[15.93382] → [27.21315:21478]

B:BD[15.93072] → [15.93072:93382]

B:BD[15.92923] → [137.20318:20467]

B:BD[15.92923] → [25.23360:23509]

B:BD[15.92923] → [16.19246:19395]

B:BD[26.27236] → [26.27236:27385]

B:BD[15.92923] → [27.21165:21314]

B:BD[15.92775] → [15.92775:92923]

B:BD[15.92775] → [109.9764:9912]

B:BD[15.92775] → [26.27088:27236]

B:BD[15.92016] → [15.92016:92166]

B:BD[26.26937] → [109.9613:9763]

B:BD[26.26937] → [26.26937:27087]

B:BD[27.21164] → [138.3849:3999]

B:BD[15.91709] → [15.91709:92016]

B:BD[15.91709] → [137.20010:20317]

B:BD[15.91709] → [25.22902:23359]

B:BD[15.91709] → [16.18938:19245]

B:BD[15.91709] → [26.26630:26937]

B:BD[15.91709] → [27.20857:21164]

B:BD[15.91412] → [15.91412:91560]

B:BD[15.91412] → [137.19861:20009]

B:BD[15.91412] → [25.22753:22901]

B:BD[15.91412] → [16.18789:18937]

B:BD[15.91412] → [109.9464:9612]

B:BD[15.91412] → [26.26481:26629]

B:BD[15.91412] → [27.20708:20856]

B:BD[15.90486] → [15.90486:90635]

B:BD[15.90486] → [137.19711:19860]

B:BD[15.90486] → [25.22603:22752]

B:BD[15.90486] → [16.18639:18788]

B:BD[15.90486] → [26.26331:26480]

B:BD[15.90486] → [27.20558:20707]

B:BD[15.90024] → [15.90024:90175]

B:BD[15.90024] → [139.998:1149]

B:BD[15.90024] → [137.19559:19710]

B:BD[15.90024] → [25.22451:22602]

B:BD[15.90024] → [16.18487:18638]

B:BD[15.90024] → [109.9312:9463]

B:BD[15.90024] → [26.26179:26330]

B:BD[15.90024] → [27.20406:20557]

B:BD[15.89571] → [15.89571:89725]

B:BD[15.89571] → [137.19404:19558]

B:BD[15.89571] → [25.22296:22450]

B:BD[15.89571] → [16.18332:18486]

B:BD[15.89571] → [26.26024:26178]

B:BD[15.89571] → [27.20251:20405]

B:BD[15.88975] → [15.88975:89129]

B:BD[15.88975] → [137.19249:19403]

B:BD[15.88975] → [16.18177:18331]

B:BD[26.25869] → [26.25869:26023]

B:BD[15.88975] → [27.20096:20250]

B:BD[15.88670] → [15.88670:88975]

B:BD[15.88670] → [25.21836:22295]

B:BD[15.88670] → [109.9006:9311]

B:BD[15.88670] → [26.25564:25869]

B:BD[15.88670] → [138.3543:3848]

B:BD[15.87291] → [15.87291:87437]

B:BD[15.87291] → [137.19102:19248]

B:BD[15.87291] → [25.21689:21835]

B:BD[15.87291] → [16.18030:18176]

B:BD[15.87291] → [26.25417:25563]

B:BD[15.87291] → [27.19949:20095]

B:BD[15.86978] → [15.86978:87135]

B:BD[15.86978] → [109.8848:9005]

B:BD[15.86978] → [26.25258:25416]

B:BD[15.86364] → [15.86364:86667]

B:BD[15.86364] → [139.694:997]

B:BD[15.86364] → [137.18798:19101]

B:BD[15.86364] → [25.21385:21688]

B:BD[15.86364] → [16.17726:18029]

B:BD[15.86364] → [109.8544:8847]

B:BD[15.86364] → [26.24954:25257]

B:BD[15.86364] → [27.19645:19948]

B:BD[26.24796] → [109.8386:8543]

B:BD[26.24796] → [26.24796:24953]

B:BD[15.86051] → [15.86051:86208]

B:BD[15.86051] → [137.18030:18797]

B:BD[15.86051] → [25.21227:21384]

B:BD[15.86051] → [16.17568:17725]

B:BD[15.86051] → [26.24186:24796]

B:BD[15.86051] → [27.18877:19644]

B:BD[15.85747] → [137.17728:18029]

B:BD[15.85747] → [26.23884:24185]

B:BD[15.85747] → [27.18575:18876]

B:BD[15.85305] → [15.85305:85453]

B:BD[15.85305] → [137.17578:17727]

B:BD[15.85305] → [25.21078:21226]

B:BD[15.85305] → [16.17419:17567]

B:BD[15.85305] → [26.23734:23883]

B:BD[15.85305] → [27.18425:18574]

B:BD[15.84694] → [15.84694:84849]

B:BD[15.84694] → [137.17422:17577]

B:BD[15.84694] → [25.20922:21077]

B:BD[15.84694] → [16.17263:17418]

B:BD[15.84694] → [26.23578:23733]

B:BD[15.84694] → [27.18269:18424]

B:BD[15.83143] → [15.83143:83296]

B:BD[15.83143] → [137.17268:17421]

B:BD[15.83143] → [25.20768:20921]

B:BD[15.83143] → [16.17109:17262]

B:BD[15.83143] → [26.23424:23577]

B:BD[15.83143] → [27.18115:18268]

B:BD[15.82529] → [15.82529:82680]

B:BD[15.82529] → [109.8234:8385]

B:BD[15.82529] → [26.23272:23423]

B:BD[15.82071] → [15.82071:82221]

B:BD[15.82071] → [137.17117:17267]

B:BD[15.82071] → [25.20617:20767]

B:BD[15.82071] → [16.16958:17108]

B:BD[15.82071] → [26.23121:23271]

B:BD[15.82071] → [27.17964:18114]

B:BD[15.80711] → [15.80711:80860]

B:BD[15.80711] → [137.16967:17116]

B:BD[15.80711] → [25.20467:20616]

B:BD[15.80711] → [16.16808:16957]

B:BD[15.80711] → [109.8084:8233]

B:BD[15.80711] → [26.22971:23120]

B:BD[15.80711] → [27.17814:17963]

B:BD[15.80407] → [15.80407:80561]

B:BD[15.80407] → [109.7929:8083]

B:BD[15.80407] → [26.22816:22970]

B:BD[15.79666] → [15.79666:80109]

B:BD[15.79666] → [137.16669:16966]

B:BD[15.79666] → [25.20023:20466]

B:BD[15.79666] → [16.16364:16807]

B:BD[15.79666] → [26.22518:22815]

B:BD[15.79666] → [27.17516:17813]

B:BD[15.79360] → [15.79360:79508]

B:BD[15.79209] → [15.79209:79360]

B:BD[15.79360] → [137.16520:16668]

B:BD[27.17366] → [28.1634:1785]

B:BD[28.1785] → [138.3394:3542]

B:BD[15.79360] → [16.16215:16363]

B:BD[26.22369] → [109.7780:7928]

B:BD[26.22369] → [26.22369:22517]

B:BD[15.79360] → [27.17367:17515]

B:BD[15.79055] → [15.79055:79209]

B:BD[15.79055] → [137.16365:16519]

B:BD[15.79055] → [25.19569:20022]

B:BD[15.79055] → [16.16060:16214]

B:BD[15.79055] → [26.22064:22369]

B:BD[15.79055] → [27.17212:17366]

B:BD[15.78307] → [15.78307:78458]

B:BD[15.78307] → [137.16213:16364]

B:BD[15.78307] → [25.19417:19568]

B:BD[15.78307] → [16.15908:16059]

B:BD[15.78307] → [26.21912:22063]

B:BD[15.78307] → [27.17060:17211]

B:BD[27.16909] → [28.1483:1633]

B:BD[26.21761] → [109.7629:7779]

B:BD[26.21761] → [26.21761:21911]

B:BD[27.16909] → [27.16909:17059]

B:BD[15.77559] → [15.77559:77861]

B:BD[15.77559] → [137.15910:16212]

B:BD[15.77559] → [25.19114:19416]

B:BD[15.77559] → [16.15605:15907]

B:BD[15.77559] → [26.21609:21761]

B:BD[15.77559] → [27.16757:16909]

B:BD[15.77260] → [15.77260:77408]

B:BD[15.77260] → [137.15761:15909]

B:BD[15.77260] → [25.18965:19113]

B:BD[15.77260] → [16.15456:15604]

B:BD[15.77260] → [26.21460:21608]

B:BD[15.77260] → [27.16608:16756]

B:BD[15.76963] → [15.76963:77109]

B:BD[15.76963] → [25.18818:18964]

B:BD[15.76963] → [28.1336:1482]

B:BD[15.76963] → [26.21313:21459]

B:BD[137.15607] → [137.15607:15760]

B:BD[26.21159] → [26.21159:21312]

B:BD[15.74491] → [15.74491:74800]

B:BD[15.74491] → [139.538:693]

B:BD[15.74491] → [137.15452:15607]

B:BD[15.74491] → [25.18508:18817]

B:BD[15.74491] → [16.15146:15455]

B:BD[15.74491] → [109.7473:7628]

B:BD[15.74491] → [26.21004:21159]

B:BD[15.74491] → [27.16299:16607]

B:BD[26.20845] → [109.7314:7472]

B:BD[26.20845] → [26.20845:21003]

B:BD[27.16140] → [27.16140:16298]

B:BD[27.16140] → [138.3235:3393]

B:BD[15.73406] → [15.73406:73880]

B:BD[15.73406] → [137.14977:15451]

B:BD[15.73406] → [25.18033:18507]

B:BD[15.73406] → [16.14671:15145]

B:BD[15.73406] → [26.20529:20845]

B:BD[15.73406] → [27.15824:16140]

B:BD[15.72184] → [15.72184:72330]

B:BD[15.72184] → [109.7167:7313]

B:BD[15.72184] → [26.20382:20528]

B:BD[15.71888] → [15.71888:72037]

B:BD[15.71888] → [137.14827:14976]

B:BD[15.71888] → [25.17883:18032]

B:BD[15.71888] → [16.14521:14670]

B:BD[15.71888] → [26.20232:20381]

B:BD[15.71888] → [27.15674:15823]

B:BD[15.70670] → [15.70670:70979]

B:BD[15.70670] → [109.6857:7166]

B:BD[15.70670] → [26.19921:20231]

B:BD[15.70219] → [15.70219:70370]

B:BD[15.70068] → [15.70068:70219]

B:BD[15.69917] → [15.69917:70068]

B:BD[15.69764] → [15.69764:69917]

B:BD[15.69609] → [15.69609:69764]

B:BD[15.68732] → [15.68732:69609]

B:BD[15.68582] → [15.68582:68732]

B:BD[15.68512] → [15.68512:68582]

B:BD[15.68442] → [15.68442:68512]

B:BD[15.68360] → [15.68360:68442]

B:BD[15.68341] → [15.68341:68360]

B:BD[15.66113] → [15.66113:68341]

B:BD[15.66043] → [15.66043:66113]

B:BD[15.65323] → [15.65323:66043]

B:BD[15.65305] → [15.65305:65323]

B:BD[15.64848] → [15.64848:65305]

B:BD[15.64830] → [15.64830:64848]

B:BD[15.63841] → [15.63841:64830]

B:BD[15.63823] → [15.63823:63841]

B:BD[15.63366] → [15.63366:63823]

B:BD[15.63218] → [15.63218:63366]

B:BD[15.63064] → [15.63064:63218]

B:BD[137.14074] → [137.14074:14147]

B:BD[15.62841] → [15.62841:63064]

B:BD[15.62471] → [15.62471:62841]

B:BD[15.62247] → [15.62247:62471]

B:BD[15.62171] → [15.62171:62247]

B:BD[15.62091] → [15.62091:62171]

B:BD[15.61860] → [15.61860:62091]

B:BD[15.61785] → [15.61785:61860]

B:BD[15.61714] → [15.61714:61785]

B:BD[15.61566] → [15.61566:61714]

B:BD[15.61125] → [15.61125:61566]

B:BD[15.61052] → [15.61052:61125]

B:BD[15.60970] → [15.60970:61052]

B:BD[15.60952] → [15.60952:60970]

B:BD[15.60843] → [15.60843:60952]

B:BD[15.60767] → [15.60767:60843]

B:BD[15.60295] → [15.60295:60767]

B:BD[15.60222] → [15.60222:60295]

B:BD[15.59628] → [15.59628:60222]

B:BD[15.59555] → [15.59555:59628]

B:BD[15.59420] → [15.59420:59555]

B:BD[15.59340] → [15.59340:59420]

B:BD[15.59264] → [15.59264:59340]

B:BD[15.59119] → [15.59119:59264]

B:BD[15.58977] → [15.58977:59119]

B:BD[15.58830] → [15.58830:58977]

B:BD[27.13616] → [27.13616:13686]

B:BD[15.58757] → [15.58757:58830]

B:BD[15.58675] → [15.58675:58757]

B:BD[15.58657] → [15.58657:58675]

B:BD[15.58623] → [15.58623:58657]

B:BD[15.58543] → [15.58543:58623]

B:BD[15.58318] → [15.58318:58543]

B:BD[15.58248] → [15.58248:58318]

B:BD[15.58173] → [15.58173:58248]

B:BD[15.58100] → [15.58100:58173]

B:BD[15.58018] → [15.58018:58100]

B:BD[15.58000] → [15.58000:58018]

B:BD[15.57377] → [15.57377:58000]

B:BD[15.57295] → [15.57295:57377]

B:BD[15.57213] → [15.57213:57295]

B:BD[15.57195] → [15.57195:57213]

B:BD[15.57078] → [15.57078:57195]

B:BD[15.56862] → [15.56862:56932]

B:BD[15.57007] → [15.57007:57078]

B:BD[15.57007] → [137.12185:12256]

B:BD[15.57007] → [25.15246:15317]

B:BD[15.57007] → [16.11958:12029]

B:BD[15.57007] → [27.13032:13103]

B:BD[15.56932] → [15.56932:57007]

B:BD[15.56787] → [15.56787:56862]

B:BD[15.56623] → [15.56623:56787]

B:BD[15.56541] → [15.56541:56623]

B:BD[27.12878] → [27.12878:12960]

B:BD[27.12878] → [138.2922:3004]

B:BD[15.56523] → [15.56523:56541]

B:BD[15.56482] → [15.56482:56523]

B:BD[15.56402] → [15.56402:56482]

B:BD[15.56108] → [15.56108:56402]

B:BD[15.56035] → [15.56035:56108]

B:BD[15.55828] → [15.55828:56035]

B:BD[15.55748] → [15.55748:55828]

B:BD[15.55591] → [15.55591:55748]

B:BD[15.55513] → [15.55513:55591]

B:BD[15.55368] → [15.55368:55513]

B:BD[15.55296] → [15.55296:55368]

B:BD[15.55139] → [15.55139:55296]

B:BD[15.55121] → [15.55121:55139]

B:BD[15.54778] → [15.54778:55121]

B:BD[15.54703] → [15.54703:54778]

B:BD[15.54632] → [15.54632:54703]

B:BD[15.54484] → [15.54484:54632]

B:BD[15.54409] → [15.54409:54484]

B:BD[15.54327] → [15.54327:54409]

B:BD[15.54245] → [15.54245:54327]

B:BD[15.54227] → [15.54227:54245]

B:BD[15.54189] → [15.54189:54227]

B:BD[15.54119] → [15.54119:54189]

B:BD[15.54044] → [15.54044:54119]

B:BD[15.53971] → [15.53971:54044]

B:BD[15.53837] → [15.53837:53971]

B:BD[15.53754] → [15.53754:53837]

B:BD[15.53018] → [15.53018:53754]

B:BD[15.63218] → [139.462:537]

B:BD[15.61785] → [139.386:461]

B:BD[15.70219] → [137.14675:14826]

B:BD[15.69917] → [137.14523:14674]

B:BD[15.69609] → [137.14367:14522]

B:BD[15.68442] → [137.14296:14366]

B:BD[15.68341] → [137.14276:14295]

B:BD[15.66043] → [137.14205:14275]

B:BD[15.65305] → [137.14186:14204]

B:BD[15.64830] → [137.14167:14185]

B:BD[15.63823] → [137.14148:14166]

B:BD[15.63218] → [137.13999:14074]

B:BD[15.62841] → [137.13775:13998]

B:BD[15.62247] → [137.13550:13774]

B:BD[15.62091] → [137.13469:13549]

B:BD[15.61785] → [137.13393:13468]

B:BD[15.61566] → [137.13244:13392]

B:BD[15.60952] → [137.13225:13243]

B:BD[15.60767] → [137.13148:13224]

B:BD[15.60222] → [137.13074:13147]

B:BD[15.59555] → [137.13000:13073]

B:BD[15.59340] → [137.12919:12999]

B:BD[15.59264] → [137.12840:12918]

B:BD[15.58977] → [137.12697:12839]

B:BD[15.58757] → [137.12623:12696]

B:BD[15.58657] → [137.12604:12622]

B:BD[15.58543] → [137.12523:12603]

B:BD[15.58248] → [137.12452:12522]

B:BD[15.58100] → [137.12378:12451]

B:BD[15.58000] → [137.12359:12377]

B:BD[15.57295] → [137.12276:12358]

B:BD[15.57195] → [137.12257:12275]

B:BD[15.56862] → [137.12114:12184]

B:BD[15.56623] → [137.11949:12113]

B:BD[15.56523] → [137.11930:11948]

B:BD[15.56402] → [137.11849:11929]

B:BD[15.56035] → [137.11775:11848]

B:BD[15.55748] → [137.11694:11774]

B:BD[15.55513] → [137.11615:11693]

B:BD[15.55296] → [137.11542:11614]

B:BD[15.55121] → [137.11523:11541]

B:BD[15.54484] → [137.11374:11522]

B:BD[15.54327] → [137.11291:11373]

B:BD[15.54227] → [137.11272:11290]

B:BD[15.54119] → [137.11201:11271]

B:BD[15.53971] → [137.11127:11200]

B:BD[15.53754] → [137.11043:11126]

B:BD[15.70219] → [25.17731:17882]

B:BD[15.69917] → [25.17579:17730]

B:BD[15.69609] → [25.17423:17578]

B:BD[15.68442] → [25.17352:17422]

B:BD[15.68341] → [25.17332:17351]

B:BD[15.66043] → [25.17261:17331]

B:BD[15.65305] → [25.17242:17260]

B:BD[15.64830] → [25.17223:17241]

B:BD[15.63823] → [25.17204:17222]

B:BD[15.63218] → [25.17055:17203]

B:BD[15.62841] → [25.16831:17054]

B:BD[15.62247] → [25.16606:16830]

B:BD[15.62091] → [25.16525:16605]

B:BD[15.61785] → [25.16449:16524]

B:BD[15.61566] → [25.16300:16448]

B:BD[15.61052] → [25.16226:16299]

B:BD[15.60952] → [25.16207:16225]

B:BD[15.60767] → [25.16130:16206]

B:BD[15.60222] → [25.16056:16129]

B:BD[15.59555] → [25.15982:16055]

B:BD[15.59340] → [25.15901:15981]

B:BD[15.58977] → [25.15758:15900]

B:BD[15.58757] → [25.15684:15757]

B:BD[15.58657] → [25.15665:15683]

B:BD[15.58543] → [25.15584:15664]

B:BD[15.58248] → [25.15513:15583]

B:BD[15.58100] → [25.15439:15512]

B:BD[15.58000] → [25.15420:15438]

B:BD[15.57295] → [25.15337:15419]

B:BD[15.57195] → [25.15318:15336]

B:BD[15.56862] → [25.15175:15245]

B:BD[15.56623] → [25.15010:15174]

B:BD[15.56523] → [25.14991:15009]

B:BD[15.56402] → [25.14910:14990]

B:BD[15.56035] → [25.14836:14909]

B:BD[15.55748] → [25.14755:14835]

B:BD[15.55513] → [25.14676:14754]

B:BD[15.55296] → [25.14603:14675]

B:BD[15.55121] → [25.14584:14602]

B:BD[15.54484] → [25.14435:14583]

B:BD[15.54327] → [25.14352:14434]

B:BD[15.54227] → [25.14333:14351]

B:BD[15.54119] → [25.14262:14332]

B:BD[15.53971] → [25.14188:14261]

B:BD[15.53754] → [25.14104:14187]

B:BD[15.60952] → [28.1316:1335]

B:BD[15.70219] → [16.14369:14520]

B:BD[15.69917] → [16.14217:14368]

B:BD[15.69609] → [16.14061:14216]

B:BD[15.68442] → [16.13990:14060]

B:BD[15.68341] → [16.13970:13989]

B:BD[15.66043] → [16.13899:13969]

B:BD[15.65305] → [16.13880:13898]

B:BD[15.64830] → [16.13861:13879]

B:BD[15.63823] → [16.13842:13860]

B:BD[15.63218] → [16.13693:13841]

B:BD[15.62841] → [16.13469:13692]

B:BD[15.62247] → [16.13244:13468]

B:BD[15.62091] → [16.13163:13243]

B:BD[15.61785] → [16.13087:13162]

B:BD[15.61566] → [16.12938:13086]

B:BD[15.60952] → [16.12919:12937]

B:BD[15.60767] → [16.12842:12918]

B:BD[15.60222] → [16.12768:12841]

B:BD[15.59555] → [16.12694:12767]

B:BD[15.59340] → [16.12613:12693]

B:BD[15.58977] → [16.12470:12612]

B:BD[15.58757] → [16.12396:12469]

B:BD[15.58657] → [16.12377:12395]

B:BD[15.58543] → [16.12296:12376]

B:BD[15.58248] → [16.12225:12295]

B:BD[15.58100] → [16.12151:12224]

B:BD[15.58000] → [16.12132:12150]

B:BD[15.57295] → [16.12049:12131]

B:BD[15.57195] → [16.12030:12048]

B:BD[15.56862] → [16.11887:11957]

B:BD[15.56623] → [16.11722:11886]

B:BD[15.56523] → [16.11703:11721]

B:BD[15.56402] → [16.11622:11702]

B:BD[15.56035] → [16.11548:11621]

B:BD[15.55748] → [16.11467:11547]

B:BD[15.55513] → [16.11388:11466]

B:BD[15.55296] → [16.11315:11387]

B:BD[15.55121] → [16.11296:11314]

B:BD[15.54484] → [16.11147:11295]

B:BD[15.54327] → [16.11064:11146]

B:BD[15.54227] → [16.11045:11063]

B:BD[15.54119] → [16.10974:11044]

B:BD[15.53971] → [16.10900:10973]

B:BD[15.53754] → [16.10816:10899]

B:BD[15.68582] → [109.6706:6856]

B:BD[15.63218] → [109.6630:6705]

B:BD[15.61785] → [109.6554:6629]

B:BD[15.61052] → [109.6480:6553]

B:BD[15.58977] → [109.6407:6479]

B:BD[15.57295] → [109.6324:6406]

B:BD[26.16827] → [109.6248:6323]

B:BD[26.16674] → [109.6165:6247]

B:BD[15.55296] → [109.6092:6164]

B:BD[15.54703] → [109.6016:6091]

B:BD[15.54327] → [109.5933:6015]

B:BD[15.70518] → [26.19770:19920]

B:BD[15.70219] → [26.19618:19769]

B:BD[15.69917] → [26.19466:19617]

B:BD[15.69609] → [26.19310:19465]

B:BD[15.68582] → [26.19159:19309]

B:BD[15.68442] → [26.19088:19158]

B:BD[15.68341] → [26.19068:19087]

B:BD[15.66043] → [26.18997:19067]

B:BD[15.65305] → [26.18978:18996]

B:BD[15.64830] → [26.18959:18977]

B:BD[15.63823] → [26.18940:18958]

B:BD[26.18866] → [26.18866:18939]

B:BD[15.63218] → [26.18791:18866]

B:BD[15.62841] → [26.18567:18790]

B:BD[15.62247] → [26.18342:18566]

B:BD[15.62091] → [26.18261:18341]

B:BD[15.61785] → [26.18185:18260]

B:BD[15.61566] → [26.18036:18184]

B:BD[15.61052] → [26.17962:18035]

B:BD[15.60952] → [26.17942:17961]

B:BD[15.60767] → [26.17865:17941]

B:BD[15.60222] → [26.17791:17864]

B:BD[15.59555] → [26.17717:17790]

B:BD[15.59340] → [26.17636:17716]

B:BD[15.59264] → [26.17557:17635]

B:BD[26.17486] → [26.17486:17556]

B:BD[15.58977] → [26.17414:17486]

B:BD[15.58757] → [26.17340:17413]

B:BD[15.58657] → [26.17321:17339]

B:BD[15.58543] → [26.17240:17320]

B:BD[15.58248] → [26.17169:17239]

B:BD[15.58100] → [26.17095:17168]

B:BD[15.58000] → [26.17076:17094]

B:BD[15.57295] → [26.16993:17075]

B:BD[15.57195] → [26.16974:16992]

B:BD[26.16902] → [26.16902:16973]

B:BD[26.16827] → [26.16827:16902]

B:BD[15.56862] → [26.16757:16827]

B:BD[26.16674] → [26.16674:16756]

B:BD[15.56623] → [26.16592:16674]

B:BD[15.56523] → [26.16573:16591]

B:BD[15.56402] → [26.16492:16572]

B:BD[15.56035] → [26.16418:16491]

B:BD[15.55748] → [26.16337:16417]

B:BD[15.55513] → [26.16258:16336]

B:BD[15.55296] → [26.16185:16257]

B:BD[15.55121] → [26.16166:16184]

B:BD[15.54703] → [26.16090:16165]

B:BD[15.54484] → [26.15941:16089]

B:BD[15.54327] → [26.15858:15940]

B:BD[15.54227] → [26.15839:15857]

B:BD[15.54119] → [26.15768:15838]

B:BD[15.53971] → [26.15694:15767]

B:BD[15.53754] → [26.15610:15693]

B:BD[15.70219] → [27.15522:15673]

B:BD[15.69917] → [27.15370:15521]

B:BD[15.69609] → [27.15214:15369]

B:BD[15.68442] → [27.15143:15213]

B:BD[15.68341] → [27.15123:15142]

B:BD[15.66043] → [27.15052:15122]

B:BD[15.65305] → [27.15033:15051]

B:BD[15.64830] → [27.15014:15032]

B:BD[15.63823] → [27.14995:15013]

B:BD[15.63218] → [27.14846:14994]

B:BD[15.62841] → [27.14622:14845]

B:BD[15.62247] → [27.14397:14621]

B:BD[15.62091] → [27.14316:14396]

B:BD[15.61785] → [27.14240:14315]

B:BD[15.61566] → [27.14091:14239]

B:BD[15.60952] → [27.14072:14090]

B:BD[15.60767] → [27.13995:14071]

B:BD[15.60222] → [27.13921:13994]

B:BD[15.59555] → [27.13847:13920]

B:BD[15.59340] → [27.13766:13846]

B:BD[15.59264] → [27.13687:13765]

B:BD[15.58977] → [27.13544:13616]

B:BD[15.58757] → [27.13470:13543]

B:BD[15.58657] → [27.13451:13469]

B:BD[15.58543] → [27.13370:13450]

B:BD[15.58248] → [27.13299:13369]

B:BD[15.58100] → [27.13225:13298]

B:BD[15.58000] → [27.13206:13224]

B:BD[15.57295] → [27.13123:13205]

B:BD[15.57195] → [27.13104:13122]

B:BD[15.56862] → [27.12961:13031]

B:BD[15.56623] → [27.12796:12878]

B:BD[15.56523] → [27.12777:12795]

B:BD[15.56402] → [27.12696:12776]

B:BD[15.56035] → [27.12622:12695]

B:BD[15.55748] → [27.12541:12621]

B:BD[15.55513] → [27.12462:12540]

B:BD[15.55296] → [27.12389:12461]

B:BD[15.55121] → [27.12370:12388]

B:BD[15.54484] → [27.12221:12369]

B:BD[15.54327] → [27.12138:12220]

B:BD[15.54227] → [27.12119:12137]

B:BD[15.54119] → [27.12048:12118]

B:BD[15.53971] → [27.11974:12047]

B:BD[15.53754] → [27.11890:11973]

B:BD[15.61052] → [138.3161:3234]

B:BD[15.58977] → [138.3088:3160]

B:BD[15.57295] → [138.3005:3087]

B:BD[15.55296] → [138.2849:2921]

B:BD[15.54327] → [138.2766:2848]

B:BD[15.53000] → [15.53000:53018]

B:BD[15.53000] → [137.11024:11042]

B:BD[15.53000] → [25.14085:14103]

B:BD[15.53000] → [16.10797:10815]

B:BD[15.53000] → [26.15591:15609]

B:BD[15.53000] → [27.11871:11889]

B:BD[15.52957] → [15.52957:52958]

B:BD[20.55429] → [24.17832:17850]

B:BD[20.55529] → [29.58281:58437]

B:BD[20.55724] → [24.17933:17951]

B:BD[20.55824] → [42.30638:30720]

B:BD[20.55932] → [24.17952:17970]

B:BD[20.56032] → [29.58634:58709]

B:BD[29.58785] → [29.58785:58869]

B:BD[20.56299] → [24.18131:18150]

B:BD[20.56400] → [24.18151:18224]

B:BD[20.56548] → [24.18225:18295]

B:BD[20.56656] → [24.18296:18314]

B:BD[20.56756] → [24.18315:18397]

B:BD[20.56913] → [24.18398:18546]

B:BD[20.57132] → [24.18547:18928]

B:BD[20.57550] → [24.18929:18947]

B:BD[20.57650] → [29.59754:59901]

B:BD[20.57942] → [24.19021:19099]

B:BD[24.19256] → [24.19256:19336]

B:BD[43.39449] → [43.39449:39469]

B:BD[43.39569] → [70.10857:10927]

B:BD[43.39569] → [43.39569:39644]

B:BD[20.58364] → [24.19337:19355]

B:BD[20.58464] → [24.19356:19429]

B:BD[20.58755] → [24.19430:19506]

B:BD[20.58952] → [24.19587:19605]

B:BD[20.59052] → [24.19606:19770]

B:BD[24.19916] → [24.19916:19987]

B:BD[20.59624] → [24.20069:20087]

B:BD[20.59724] → [24.20088:20170]

B:BD[20.59881] → [24.20171:20323]

B:BD[20.60067] → [24.20324:20342]

B:BD[20.60167] → [29.61887:61962]

B:BD[20.60319] → [24.20343:20419]

B:BD[20.60410] → [92.8396:8615]

B:BD[20.60429] → [24.20420:20438]

B:BD[20.60529] → [24.20439:20512]

B:BD[20.60677] → [24.20513:20583]

B:BD[20.60896] → [24.20584:20660]

B:BD[20.61086] → [24.20741:20759]

B:BD[20.61186] → [24.20760:20833]

B:BD[20.61406] → [24.20834:20976]

B:BD[20.61693] → [24.20977:21053]

B:BD[20.61927] → [20.61927:61962]

B:BD[20.61980] → [20.61980:62062]

B:BD[20.62135] → [20.62135:62214]

B:BD[20.62289] → [20.62289:62360]

B:BD[20.62504] → [20.62504:62581]

B:BD[24.21520] → [24.21520:21593]

B:BD[20.62880] → [24.21594:21988]

B:BD[24.22064] → [24.22064:22144]

B:BD[20.63459] → [24.22145:22163]

B:BD[20.63560] → [24.22164:22237]

B:BD[20.63673] → [24.22238:22256]

B:BD[20.63773] → [24.22257:22412]

B:BD[20.64074] → [24.22413:22561]

B:BD[24.22632] → [24.22632:22707]

B:BD[20.64442] → [24.22708:22865]

B:BD[24.22945] → [24.22945:23021]

B:BD[22.22118] → [22.22118:22264]

B:BD[20.65022] → [24.23246:23264]

B:BD[20.65122] → [92.9004:9077]

B:BD[20.65349] → [24.23345:23568]

B:BD[20.65648] → [24.23569:23647]

B:BD[24.23795] → [24.23795:23877]

B:BD[20.66103] → [24.23878:23896]

B:BD[20.66186] → [42.34976:35068]

B:BD[20.66235] → [22.22638:22752]

B:BD[20.66669] → [43.43166:43184]

B:BD[20.66752] → [43.43185:43202]

B:BD[43.43277] → [43.43277:43279]

B:BD[20.67040] → [20.67040:67118]

B:BD[20.67325] → [20.67325:67338]

B:BD[20.67356] → [20.67356:67696]

B:BD[24.23934] → [22.22772:22889]

B:BD[20.67792] → [20.67792:67909]

B:BD[20.68055] → [49.41042:41271]

B:BD[20.68362] → [47.22510:22620]

B:BD[20.68476] → [29.65665:65740]

B:BD[20.68621] → [20.68621:68955]

B:BD[20.68973] → [20.68973:69508]

B:BD[22.22982] → [43.43299:43317]

B:BD[22.23082] → [29.65779:65852]

B:BD[20.69773] → [22.23171:23285]

B:BD[20.69838] → [22.23286:23303]

B:BD[22.23376] → [43.43318:43396]

B:BD[20.70122] → [20.70122:70251]

B:BD[20.70324] → [20.70324:70456]

B:BD[20.70529] → [20.70529:70849]

B:BD[20.70868] → [20.70868:70950]

B:BD[20.71020] → [20.71020:71090]

B:BD[43.44223] → [30.31448:31485]

B:BD[30.31504] → [30.31504:31586]

B:BD[30.31733] → [30.31733:31806]

B:BD[29.66979] → [29.66979:67769]

B:BD[20.72106] → [92.9303:10168]

B:BD[20.72117] → [40.17782:17937]

B:BD[20.72425] → [24.25042:25193]

B:BD[24.25344] → [24.25344:25495]

B:BD[20.73026] → [24.25496:26106]

B:BD[20.73787] → [24.26107:26716]

B:BD[20.74692] → [24.26866:27012]

B:BD[20.75136] → [29.70208:70356]

B:BD[20.75435] → [24.27013:27172]

B:BD[20.75914] → [24.27173:27647]

B:BD[20.76850] → [24.27955:28104]

B:BD[24.28259] → [24.28259:28414]

B:BD[20.77616] → [24.28415:28722]

B:BD[20.78540] → [43.47761:47917]

B:BD[20.79005] → [29.72066:72217]

B:BD[20.79314] → [24.28723:28879]

B:BD[20.79767] → [24.29026:29174]

B:BD[20.80066] → [24.29175:29325]

B:BD[20.80814] → [24.29326:29477]

B:BD[20.81112] → [24.29478:29624]

B:BD[20.81562] → [24.29625:30078]

B:BD[20.82173] → [24.30079:30522]

B:BD[20.82768] → [24.30523:30677]

B:BD[20.83072] → [24.30678:30827]

B:BD[20.83373] → [24.30828:30978]

B:BD[20.84268] → [140.3232:3396]

B:BD[20.84582] → [20.84582:84890]

B:BD[43.49573] → [43.49573:49728]

B:BD[43.49728] → [92.11376:11528]

B:BD[20.85349] → [24.31434:31589]

B:BD[24.31742] → [24.31742:32055]

B:BD[20.86129] → [24.32056:32669]

B:BD[20.87055] → [24.32670:32825]

B:BD[20.87364] → [24.32826:32979]

B:BD[20.87666] → [24.32980:33128]

B:BD[20.88109] → [42.42807:43108]

B:BD[20.88714] → [24.33276:33433]

B:BD[20.89637] → [40.20706:21009]

B:BD[20.90097] → [24.33434:33745]

B:BD[20.90564] → [24.33746:33892]

B:BD[20.91007] → [20.91007:91159]

B:BD[20.91312] → [24.34190:34516]

B:BD[20.91943] → [24.34517:34822]

B:BD[24.34976] → [24.34976:35418]

B:BD[20.93150] → [24.35573:35720]

B:BD[20.93759] → [24.35872:36021]

B:BD[20.94388] → [29.80925:81074]

B:BD[20.94685] → [24.36022:36170]

B:BD[20.94982] → [24.36171:36478]

B:BD[24.36628] → [22.29796:29948]

B:BD[20.95741] → [29.81675:81827]

B:BD[24.36777] → [24.36777:36926]

B:BD[20.96655] → [24.36927:37090]

B:BD[24.37550] → [24.37550:37861]

B:BD[24.38013] → [24.38013:38326]

B:BD[24.38478] → [24.38478:38782]

B:BD[24.38935] → [24.38935:39082]

B:BD[20.99281] → [24.39402:39553]

B:BD[20.99583] → [22.31655:31806]

B:BD[20.99889] → [43.58759:58923]

B:BD[20.100517] → [47.29215:29369]

B:BD[22.31953] → [43.58924:59072]

B:BD[20.101417] → [24.39849:40005]

B:BD[20.102169] → [29.85077:85226]

B:BD[20.102642] → [43.59073:59227]

B:BD[20.102967] → [22.32264:32415]

B:BD[20.103570] → [24.40006:40158]

B:BD[24.40158] → [24.40158:40314]

B:BD[20.103570] → [22.32416:32568]

B:BD[43.59384] → [92.12597:12753]

B:BD[29.85538] → [29.85538:85694]

B:BD[43.59384] → [30.40525:40681]

B:BD[22.32568] → [43.59228:59384]

B:BD[22.32568] → [29.85382:85538]

B:BD[22.32568] → [48.48994:49150]

B:BD[22.32568] → [49.59574:59730]

B:BD[22.32568] → [53.38031:38187]

B:BD[20.103570] → [20.103570:103722]

B:BD[20.103722] → [42.49079:49235]

B:BD[20.103722] → [20.103722:103878]

B:BD[20.103722] → [54.41295:41451]

B:BD[20.103722] → [55.66753:66909]

B:BD[20.102967] → [20.102967:103118]

B:BD[20.103118] → [20.103118:103570]

B:BD[20.102642] → [29.85227:85381]

B:BD[20.102642] → [22.32109:32263]

B:BD[20.102642] → [49.59419:59573]

B:BD[20.102642] → [20.102642:102796]

B:BD[20.102796] → [20.102796:102967]

B:BD[20.102169] → [46.77318:77467]

B:BD[20.102169] → [30.40375:40524]

B:BD[20.102169] → [49.59269:59418]

B:BD[20.102169] → [20.102169:102318]

B:BD[20.102318] → [20.102318:102642]

B:BD[20.101720] → [20.101720:102169]

B:BD[20.101417] → [47.29370:29517]

B:BD[20.101417] → [49.58965:59268]

B:BD[20.101417] → [20.101417:101573]

B:BD[20.101573] → [20.101573:101720]

B:BD[20.101119] → [20.101119:101417]

B:BD[20.101417] → [52.22916:23063]

B:BD[20.101417] → [53.37874:38030]

B:BD[20.101417] → [54.41138:41294]

B:BD[20.101417] → [71.9078:9225]

B:BD[22.31953] → [29.84928:85076]

B:BD[22.31953] → [48.48845:48993]

B:BD[22.31953] → [49.58816:58964]

B:BD[22.31953] → [53.37725:37873]

B:BD[20.100517] → [49.58661:58815]

B:BD[24.39848] → [22.31954:32108]

B:BD[20.100517] → [20.100517:100671]

B:BD[24.39700] → [24.39700:39848]

B:BD[20.100817] → [42.48930:49078]

B:BD[20.100965] → [20.100965:101119]

B:BD[20.100817] → [20.100817:100965]

B:BD[20.100817] → [54.40989:41137]

B:BD[20.100817] → [55.66604:66752]

B:BD[20.100671] → [24.39554:39700]

B:BD[20.100671] → [22.31807:31953]

B:BD[20.100671] → [20.100671:100817]

B:BD[20.100517] → [52.22761:22915]

B:BD[20.100517] → [71.8923:9077]

B:BD[20.99889] → [29.84763:84927]

B:BD[20.99889] → [49.58496:58660]

B:BD[20.99889] → [20.99889:100053]

B:BD[20.100053] → [20.100053:100517]

B:BD[20.99583] → [20.99583:99734]

B:BD[20.99734] → [20.99734:99889]

B:BD[20.99281] → [42.48778:48929]

B:BD[20.99281] → [43.58607:58758]

B:BD[20.99281] → [29.84611:84762]

B:BD[20.99281] → [48.48693:48844]

B:BD[20.99281] → [49.58344:58495]

B:BD[20.99281] → [20.99281:99432]

B:BD[20.99432] → [20.99432:99583]

B:BD[20.99130] → [20.99130:99281]

B:BD[20.99281] → [53.37573:37724]

B:BD[20.99281] → [54.40837:40988]

B:BD[20.99281] → [55.66452:66603]

B:BD[24.39082] → [24.39082:39401]

B:BD[24.38935] → [22.31506:31654]

B:BD[22.31654] → [43.58286:58606]

B:BD[22.31654] → [48.48372:48692]

B:BD[22.31654] → [53.37253:37572]

B:BD[24.38782] → [24.38782:38935]

B:BD[24.38478] → [22.31201:31353]

B:BD[43.58285] → [92.12449:12596]

B:BD[29.84143] → [29.84143:84290]

B:BD[29.84290] → [29.84290:84610]

B:BD[29.84143] → [46.77169:77317]

B:BD[43.58285] → [47.29066:29214]

B:BD[43.58285] → [30.40227:40374]

B:BD[22.31353] → [43.57980:58285]

B:BD[22.31353] → [29.83838:84143]

B:BD[22.31353] → [22.31353:31505]

B:BD[22.31353] → [48.48066:48371]

B:BD[22.31353] → [49.57571:58343]

B:BD[22.31353] → [53.36947:37252]

B:BD[24.38326] → [24.38326:38478]

B:BD[24.38013] → [22.30887:31046]

B:BD[22.31200] → [48.47913:48065]

B:BD[22.31200] → [53.36794:36946]

B:BD[22.31046] → [22.31046:31200]

B:BD[24.37861] → [24.37861:38013]

B:BD[24.37550] → [22.30575:30731]

B:BD[22.30886] → [92.12135:12288]

B:BD[43.57512] → [70.18849:19009]

B:BD[43.57979] → [92.12289:12448]

B:BD[43.57979] → [30.40067:40226]

B:BD[43.57512] → [43.57512:57672]

B:BD[43.57672] → [43.57672:57979]

B:BD[43.57512] → [47.28905:29065]

B:BD[43.57512] → [30.39906:40066]

B:BD[43.57512] → [52.22600:22760]

B:BD[43.57512] → [38.30329:30489]

B:BD[22.30886] → [70.18695:18848]

B:BD[22.30886] → [43.57207:57360]

B:BD[43.57360] → [43.57360:57512]

B:BD[29.83059] → [29.83059:83211]

B:BD[29.83371] → [29.83371:83678]

B:BD[29.83678] → [29.83678:83837]

B:BD[29.83211] → [29.83211:83371]

B:BD[29.83211] → [46.77008:77168]

B:BD[22.30886] → [29.82906:83059]

B:BD[22.30886] → [46.76854:77007]

B:BD[22.30886] → [47.28751:28904]

B:BD[22.30886] → [48.47600:47912]

B:BD[22.30886] → [30.39752:39905]

B:BD[22.30886] → [49.56953:57570]

B:BD[22.30886] → [52.22446:22599]

B:BD[22.30886] → [38.30175:30328]

B:BD[22.30886] → [53.36482:36793]

B:BD[22.30731] → [22.30731:30886]

B:BD[24.37090] → [24.37090:37550]

B:BD[20.96655] → [70.18071:18234]

B:BD[43.56747] → [70.18235:18694]

B:BD[43.56747] → [43.56747:57206]

B:BD[43.56747] → [47.28291:28750]

B:BD[43.56747] → [52.21986:22445]

B:BD[43.56747] → [38.29715:30174]

B:BD[20.96655] → [29.82126:82446]

B:BD[29.82446] → [29.82446:82905]

B:BD[20.96655] → [46.76533:76853]

B:BD[20.96655] → [47.28127:28290]

B:BD[20.96655] → [22.30411:30574]

B:BD[22.30574] → [43.56590:56747]

B:BD[22.30574] → [48.46983:47599]

B:BD[22.30574] → [53.35865:36481]

B:BD[20.96655] → [30.38972:39751]

B:BD[20.96655] → [49.56173:56952]

B:BD[20.96655] → [20.96655:96818]

B:BD[20.97434] → [20.97434:97589]

B:BD[20.97900] → [20.97900:98054]

B:BD[20.98206] → [20.98206:98358]

B:BD[20.98510] → [40.22397:22550]

B:BD[20.98811] → [42.48457:48777]

B:BD[20.98811] → [20.98811:99130]

B:BD[20.98811] → [54.40517:40836]

B:BD[20.98811] → [55.66131:66451]

B:BD[20.98510] → [41.17228:17381]

B:BD[20.98510] → [44.13238:13391]

B:BD[20.98510] → [33.20886:21039]

B:BD[20.98510] → [51.17256:17409]

B:BD[20.98663] → [20.98663:98811]

B:BD[20.98510] → [20.98510:98663]

B:BD[20.98510] → [37.25494:25647]

B:BD[20.98358] → [42.48151:48456]

B:BD[20.98358] → [20.98358:98510]

B:BD[20.98358] → [54.40211:40516]

B:BD[20.98358] → [55.65825:66130]

B:BD[20.98054] → [42.47998:48150]

B:BD[20.98054] → [20.98054:98206]

B:BD[20.98054] → [54.40058:40210]

B:BD[20.98054] → [55.65672:65824]

B:BD[20.97589] → [42.47685:47997]

B:BD[20.97589] → [20.97589:97900]

B:BD[20.97589] → [54.39746:40057]

B:BD[20.97589] → [55.65359:65671]

B:BD[20.96818] → [42.47068:47684]

B:BD[20.96818] → [20.96818:97434]

B:BD[20.96818] → [54.39129:39745]

B:BD[20.96818] → [55.64742:65358]

B:BD[20.96655] → [52.21822:21985]

B:BD[20.96655] → [38.29551:29714]

B:BD[22.30104] → [43.56292:56440]

B:BD[22.30254] → [22.30254:30410]

B:BD[20.96501] → [20.96501:96655]

B:BD[43.56440] → [92.11985:12134]

B:BD[43.56440] → [70.17921:18070]

B:BD[43.56440] → [43.56440:56589]

B:BD[43.56440] → [47.27977:28126]

B:BD[43.56440] → [30.38822:38971]

B:BD[43.56440] → [52.21672:21821]

B:BD[43.56440] → [38.29401:29550]

B:BD[22.30104] → [29.81828:81976]

B:BD[29.81976] → [29.81976:82125]

B:BD[29.81976] → [46.76383:76532]

B:BD[24.36777] → [22.30105:30254]

B:BD[22.30104] → [48.46685:46982]

B:BD[22.30104] → [49.55875:56172]

B:BD[22.30104] → [53.35567:35864]

B:BD[20.95741] → [46.76230:76382]

B:BD[20.95741] → [30.38669:38821]

B:BD[20.95741] → [49.55722:55874]

B:BD[20.95741] → [20.95741:95893]

B:BD[20.96048] → [40.22248:22396]

B:BD[20.96345] → [20.96345:96501]

B:BD[20.96048] → [41.17079:17227]

B:BD[20.96048] → [111.16041:16189]

B:BD[20.96048] → [42.46770:47067]

B:BD[20.96048] → [44.13089:13237]

B:BD[20.96048] → [33.20737:20885]

B:BD[20.96048] → [50.13409:13557]

B:BD[20.96048] → [51.17107:17255]

B:BD[20.96048] → [20.96048:96196]

B:BD[20.96196] → [20.96196:96345]

B:BD[20.96048] → [54.38831:39128]

B:BD[20.96048] → [55.64444:64741]

B:BD[20.96048] → [37.25345:25493]

B:BD[20.95893] → [24.36629:36777]

B:BD[20.95893] → [22.29949:30104]

B:BD[20.95893] → [20.95893:96048]

B:BD[24.36478] → [24.36478:36628]

B:BD[20.95591] → [20.95591:95741]

B:BD[20.94982] → [22.29488:29644]

B:BD[43.56141] → [43.56141:56291]

B:BD[22.29795] → [48.46534:46684]

B:BD[22.29795] → [53.35416:35566]

B:BD[22.29644] → [140.4008:4159]

B:BD[22.29644] → [70.17769:17920]

B:BD[22.29644] → [43.55990:56141]

B:BD[22.29644] → [29.81373:81674]

B:BD[22.29644] → [47.27825:27976]

B:BD[22.29644] → [22.29644:29795]

B:BD[22.29644] → [30.38517:38668]

B:BD[22.29644] → [49.55420:55721]

B:BD[22.29644] → [52.21520:21671]

B:BD[22.29644] → [38.29249:29400]

B:BD[22.29644] → [71.8771:8922]

B:BD[20.94982] → [20.94982:95289]

B:BD[20.95439] → [20.95439:95591]

B:BD[20.95289] → [40.22097:22247]

B:BD[20.95289] → [41.16928:17078]

B:BD[20.95289] → [111.15890:16040]

B:BD[20.95289] → [42.46619:46769]

B:BD[20.95289] → [44.12938:13088]

B:BD[20.95289] → [33.20586:20736]

B:BD[20.95289] → [50.13258:13408]

B:BD[20.95289] → [51.16956:17106]

B:BD[20.95289] → [20.95289:95439]

B:BD[20.95289] → [54.38680:38830]

B:BD[20.95289] → [55.64293:64443]

B:BD[20.95289] → [37.25194:25344]

B:BD[20.94685] → [40.21948:22096]

B:BD[20.94685] → [41.16779:16927]

B:BD[20.94685] → [92.11836:11984]

B:BD[20.94685] → [70.17620:17768]

B:BD[20.94685] → [111.15741:15889]

B:BD[20.94685] → [42.46470:46618]

B:BD[20.94685] → [43.55841:55989]

B:BD[20.94685] → [29.81224:81372]

B:BD[20.94685] → [44.12789:12937]

B:BD[20.94685] → [46.76081:76229]

B:BD[20.94685] → [47.27676:27824]

B:BD[20.94685] → [22.29339:29487]

B:BD[20.94685] → [33.20437:20585]

B:BD[20.94685] → [48.46385:46533]

B:BD[20.94685] → [30.38368:38516]

B:BD[20.94685] → [49.55271:55419]

B:BD[20.94685] → [50.13109:13257]

B:BD[20.94685] → [51.16807:16955]

B:BD[20.94685] → [20.94685:94833]

B:BD[20.94833] → [20.94833:94982]

B:BD[20.94537] → [20.94537:94685]

B:BD[20.94685] → [52.21371:21519]

B:BD[20.94685] → [38.29100:29248]

B:BD[20.94685] → [53.35267:35415]

B:BD[20.94685] → [54.38531:38679]

B:BD[20.94685] → [55.64144:64292]

B:BD[20.94685] → [37.25045:25193]

B:BD[20.94685] → [39.9459:9607]

B:BD[29.81074] → [29.81074:81223]

B:BD[20.94388] → [46.75931:76080]

B:BD[20.94388] → [30.38218:38367]

B:BD[20.94388] → [49.55121:55270]

B:BD[20.94388] → [20.94388:94537]

B:BD[20.94537] → [42.46320:46469]

B:BD[20.94537] → [43.55691:55840]

B:BD[20.94537] → [48.46235:46384]

B:BD[20.94537] → [55.63994:64143]

B:BD[20.93759] → [42.46170:46319]

B:BD[20.93759] → [43.55541:55690]

B:BD[20.93759] → [29.80775:80924]

B:BD[20.93759] → [22.29189:29338]

B:BD[20.93759] → [48.46085:46234]

B:BD[20.93759] → [49.54971:55120]

B:BD[20.93759] → [20.93759:93908]

B:BD[20.93908] → [20.93908:94388]

B:BD[20.93448] → [20.93448:93759]

B:BD[20.93759] → [53.35117:35266]

B:BD[20.93759] → [54.38381:38530]

B:BD[20.93759] → [55.63844:63993]

B:BD[24.35720] → [24.35720:35871]

B:BD[24.35720] → [22.29037:29188]

B:BD[20.93150] → [42.45871:46169]

B:BD[20.93150] → [43.55242:55389]

B:BD[43.55389] → [140.3856:4007]

B:BD[43.55389] → [70.17468:17619]

B:BD[43.55389] → [43.55389:55540]

B:BD[43.55389] → [47.27524:27675]

B:BD[43.55389] → [30.38066:38217]

B:BD[43.55389] → [52.21219:21370]

B:BD[43.55389] → [38.28948:29099]

B:BD[43.55389] → [71.8619:8770]

B:BD[20.93150] → [29.80476:80774]

B:BD[20.93150] → [48.45786:46084]

B:BD[20.93150] → [49.54672:54970]

B:BD[20.93150] → [20.93150:93297]

B:BD[20.93297] → [40.21796:21947]

B:BD[20.93297] → [41.16627:16778]

B:BD[20.93297] → [111.15589:15740]

B:BD[20.93297] → [44.12637:12788]

B:BD[20.93297] → [33.20285:20436]

B:BD[20.93297] → [50.12957:13108]

B:BD[20.93297] → [51.16655:16806]

B:BD[20.93297] → [20.93297:93448]

B:BD[20.93297] → [37.24893:25044]

B:BD[20.92998] → [20.92998:93150]

B:BD[20.93150] → [53.34818:35116]

B:BD[20.93150] → [54.38082:38380]

B:BD[20.93150] → [55.63545:63843]

B:BD[24.35418] → [24.35418:35572]

B:BD[24.35418] → [22.28882:29036]

B:BD[24.34822] → [24.34822:34976]

B:BD[24.34822] → [22.28727:28881]

B:BD[20.91943] → [40.21335:21640]

B:BD[20.92844] → [40.21641:21795]

B:BD[20.92844] → [41.16472:16626]

B:BD[20.92844] → [44.12482:12636]

B:BD[20.92844] → [33.20130:20284]

B:BD[20.92844] → [51.16500:16654]

B:BD[20.92844] → [20.92844:92998]

B:BD[20.92402] → [20.92402:92844]

B:BD[20.92844] → [37.24738:24892]

B:BD[40.21640] → [31.8653:8807]

B:BD[20.91943] → [41.16166:16471]

B:BD[20.91943] → [140.3550:3855]

B:BD[43.55087] → [70.17313:17467]

B:BD[43.55087] → [43.55087:55241]

B:BD[43.54645] → [43.54645:55087]

B:BD[43.55087] → [47.27369:27523]

B:BD[43.55087] → [30.37911:38065]

B:BD[43.55087] → [52.21064:21218]

B:BD[43.55087] → [38.28793:28947]

B:BD[20.91943] → [70.16853:17312]

B:BD[20.91943] → [111.15283:15588]

B:BD[20.91943] → [42.44815:45870]

B:BD[20.91943] → [43.54186:54491]

B:BD[43.54491] → [43.54491:54645]

B:BD[20.91943] → [29.79420:79725]

B:BD[29.79725] → [29.79725:80475]

B:BD[20.91943] → [44.12176:12481]

B:BD[20.91943] → [46.75625:75930]

B:BD[20.91943] → [47.26909:27368]

B:BD[20.91943] → [33.19824:20129]

B:BD[20.91943] → [48.44730:45785]

B:BD[20.91943] → [30.37451:37910]

B:BD[20.91943] → [49.53616:54671]

B:BD[20.91943] → [50.12651:12956]

B:BD[20.91943] → [51.16194:16499]

B:BD[20.91943] → [20.91943:92248]

B:BD[20.92248] → [20.92248:92402]

B:BD[20.91943] → [52.20604:21063]

B:BD[20.91943] → [38.28333:28792]

B:BD[20.91943] → [53.33762:34817]

B:BD[20.91943] → [54.37026:38081]

B:BD[20.91943] → [55.62489:63544]

B:BD[20.91943] → [37.24278:24737]

B:BD[20.91943] → [71.8313:8618]

B:BD[20.91312] → [42.44488:44814]

B:BD[20.91312] → [43.53859:54185]

B:BD[20.91312] → [29.79093:79419]

B:BD[20.91312] → [48.44403:44729]

B:BD[20.91312] → [49.53289:53615]

B:BD[20.91638] → [20.91638:91943]

B:BD[20.91312] → [20.91312:91473]

B:BD[20.91473] → [40.21169:21334]

B:BD[20.91473] → [41.16000:16165]

B:BD[20.91473] → [44.12010:12175]

B:BD[20.91473] → [33.19658:19823]

B:BD[20.91473] → [51.16028:16193]

B:BD[20.91473] → [20.91473:91638]

B:BD[20.91473] → [37.24112:24277]

B:BD[20.91312] → [53.33435:33761]

B:BD[20.91312] → [54.36699:37025]

B:BD[20.91312] → [55.62162:62488]

B:BD[20.91159] → [20.91159:91312]

B:BD[24.33892] → [24.33892:34189]

B:BD[20.90564] → [22.28580:28726]

B:BD[43.53858] → [70.16700:16852]

B:BD[43.53858] → [47.26756:26908]

B:BD[43.53858] → [30.37298:37450]

B:BD[43.53858] → [52.20451:20603]

B:BD[43.53858] → [38.28180:28332]

B:BD[22.28726] → [43.53711:53858]

B:BD[22.28726] → [29.78793:79092]

B:BD[22.28726] → [48.44255:44402]

B:BD[22.28726] → [49.52839:53288]

B:BD[22.28726] → [53.33137:33434]

B:BD[20.90564] → [20.90564:90710]

B:BD[20.90710] → [42.44340:44487]

B:BD[20.90710] → [20.90710:91007]

B:BD[20.90710] → [54.36401:36698]

B:BD[20.90710] → [55.62014:62161]

B:BD[20.90097] → [42.44027:44339]

B:BD[20.90097] → [43.53398:53552]

B:BD[20.90408] → [20.90408:90564]

B:BD[43.53552] → [43.53552:53710]

B:BD[43.53552] → [30.37139:37297]

B:BD[20.90097] → [29.78480:78634]

B:BD[29.78634] → [29.78634:78792]

B:BD[29.78634] → [46.75466:75624]

B:BD[20.90097] → [48.43942:44254]

B:BD[20.90097] → [49.52527:52838]

B:BD[20.90097] → [20.90097:90251]

B:BD[20.90251] → [40.21010:21168]

B:BD[20.90251] → [41.15842:15999]

B:BD[20.90251] → [111.15124:15282]

B:BD[20.90251] → [44.11851:12009]

B:BD[20.90251] → [33.19499:19657]

B:BD[20.90251] → [50.12493:12650]

B:BD[20.90251] → [51.15870:16027]

B:BD[20.90251] → [20.90251:90408]

B:BD[20.90251] → [37.23954:24111]

B:BD[20.90097] → [53.32825:33136]

B:BD[20.90097] → [54.36089:36400]

B:BD[20.90097] → [55.61701:62013]

B:BD[20.89637] → [41.15538:15841]

B:BD[20.89637] → [70.16551:16699]

B:BD[20.89940] → [20.89940:90097]

B:BD[20.89637] → [111.14820:15123]

B:BD[20.89637] → [42.43723:44026]

B:BD[20.89637] → [43.53094:53242]

B:BD[43.53242] → [43.53242:53397]

B:BD[20.89637] → [29.78176:78479]

B:BD[20.89637] → [44.11547:11850]

B:BD[20.89637] → [46.75162:75465]

B:BD[20.89637] → [47.26607:26755]

B:BD[20.89637] → [22.28276:28579]

B:BD[20.89637] → [33.19195:19498]

B:BD[20.89637] → [48.43638:43941]

B:BD[20.89637] → [30.36835:37138]

B:BD[20.89637] → [49.52223:52526]

B:BD[20.89637] → [50.12189:12492]

B:BD[20.89637] → [51.15566:15869]

B:BD[20.89637] → [20.89637:89940]

B:BD[20.89637] → [52.20302:20450]

B:BD[20.89637] → [38.28031:28179]

B:BD[20.89637] → [53.32521:32824]

B:BD[20.89637] → [54.35785:36088]

B:BD[20.89637] → [55.61397:61700]

B:BD[20.89637] → [37.23650:23953]

B:BD[22.27811] → [43.52326:52480]

B:BD[70.16399] → [70.16399:16550]

B:BD[43.52936] → [43.52936:53093]

B:BD[43.52936] → [30.36677:36834]

B:BD[20.89481] → [20.89481:89637]

B:BD[22.27962] → [43.52631:52936]

B:BD[22.27811] → [22.27811:27962]

B:BD[22.27962] → [22.27962:28275]

B:BD[22.27962] → [48.43175:43637]

B:BD[22.27962] → [53.32207:32520]

B:BD[39.9458] → [52.20150:20301]

B:BD[39.9458] → [38.27879:28030]

B:BD[43.52480] → [92.11685:11835]

B:BD[43.52480] → [70.16249:16399]

B:BD[43.52480] → [43.52480:52630]

B:BD[43.52480] → [47.26305:26606]

B:BD[43.52480] → [30.36375:36676]

B:BD[43.52480] → [39.9308:9458]

B:BD[29.77412] → [29.77412:77562]

B:BD[29.78018] → [29.78018:78175]

B:BD[29.78018] → [46.75004:75161]

B:BD[29.77562] → [29.77562:78018]

B:BD[22.27811] → [29.77258:77412]

B:BD[29.77412] → [46.74853:75003]

B:BD[20.88714] → [22.27508:27811]

B:BD[22.27811] → [48.43024:43174]

B:BD[22.27811] → [49.51758:52222]

B:BD[20.88714] → [20.88714:89017]

B:BD[20.89017] → [42.43109:43259]

B:BD[20.89168] → [42.43260:43722]

B:BD[20.89168] → [20.89168:89324]

B:BD[20.89324] → [40.20548:20705]

B:BD[20.89324] → [41.15380:15537]

B:BD[20.89324] → [111.14662:14819]

B:BD[20.89324] → [44.11389:11546]

B:BD[20.89324] → [33.19037:19194]

B:BD[20.89324] → [50.12031:12188]

B:BD[20.89324] → [51.15408:15565]

B:BD[20.89324] → [20.89324:89481]

B:BD[20.89324] → [37.23492:23649]

B:BD[20.89168] → [54.35471:35784]

B:BD[20.89168] → [55.60934:61396]

B:BD[20.89017] → [20.89017:89168]

B:BD[20.89017] → [55.60783:60933]

B:BD[20.88109] → [22.27206:27507]

B:BD[20.88109] → [48.42722:43023]

B:BD[20.88109] → [20.88109:88410]

B:BD[20.88410] → [20.88410:88714]

B:BD[20.87962] → [20.87962:88109]

B:BD[20.88109] → [53.31905:32206]

B:BD[20.88109] → [54.35169:35470]

B:BD[20.88109] → [55.60481:60782]

B:BD[24.33128] → [24.33128:33275]

B:BD[20.87666] → [42.42657:42806]

B:BD[20.87666] → [43.51424:51573]

B:BD[43.51573] → [43.51573:52325]

B:BD[20.87666] → [29.76356:76505]

B:BD[29.76505] → [29.76505:77257]

B:BD[20.87666] → [46.74703:74852]

B:BD[20.87666] → [22.27056:27205]

B:BD[20.87666] → [48.42572:42721]

B:BD[20.87666] → [30.36225:36374]

B:BD[20.87666] → [49.50709:51757]

B:BD[20.87666] → [20.87666:87962]

B:BD[20.87666] → [53.31608:31904]

B:BD[20.87666] → [54.34872:35168]

B:BD[20.87666] → [55.60331:60480]

B:BD[20.87364] → [70.16095:16248]

B:BD[20.87364] → [42.42503:42656]

B:BD[20.87364] → [43.51270:51423]

B:BD[20.87364] → [29.76202:76355]

B:BD[20.87364] → [47.26151:26304]

B:BD[20.87364] → [48.42418:42571]

B:BD[20.87364] → [30.36071:36224]

B:BD[20.87364] → [49.50555:50708]

B:BD[20.87364] → [20.87364:87517]

B:BD[20.87517] → [20.87517:87666]

B:BD[20.87364] → [52.19996:20149]

B:BD[20.87364] → [38.27725:27878]

B:BD[20.87364] → [53.31454:31607]

B:BD[20.87364] → [54.34718:34871]

B:BD[20.87364] → [55.60177:60330]

B:BD[20.87055] → [42.42347:42502]

B:BD[20.87055] → [43.51114:51269]

B:BD[20.87055] → [29.76046:76201]

B:BD[20.87055] → [22.26900:27055]

B:BD[20.87055] → [48.42262:42417]

B:BD[20.87055] → [49.50399:50554]

B:BD[20.87055] → [20.87055:87210]

B:BD[20.87210] → [20.87210:87364]

B:BD[20.87055] → [53.31298:31453]

B:BD[20.87055] → [54.34562:34717]

B:BD[20.87055] → [55.60021:60176]

B:BD[20.86129] → [42.41733:42346]

B:BD[20.86129] → [43.50500:51113]

B:BD[20.86129] → [29.75432:76045]

B:BD[20.86129] → [48.41648:42261]

B:BD[20.86129] → [49.49785:50398]

B:BD[20.86129] → [20.86129:86742]

B:BD[20.86742] → [20.86742:87055]

B:BD[20.86129] → [53.30684:31297]

B:BD[20.86129] → [54.33948:34561]

B:BD[20.86129] → [55.59407:60020]

B:BD[22.26899] → [43.50037:50499]

B:BD[22.26899] → [29.74969:75431]

B:BD[22.26899] → [48.41185:41647]

B:BD[22.26899] → [49.49471:49784]

B:BD[22.26899] → [53.30370:30683]

B:BD[24.31589] → [24.31589:31742]

B:BD[20.85970] → [20.85970:86129]

B:BD[20.85349] → [40.20392:20547]

B:BD[20.85657] → [42.41270:41732]

B:BD[20.85657] → [20.85657:85970]

B:BD[20.85657] → [54.33634:33947]

B:BD[20.85657] → [55.58944:59406]

B:BD[20.85349] → [41.15224:15379]

B:BD[20.85349] → [92.11529:11684]

B:BD[20.85349] → [70.15939:16094]

B:BD[20.85349] → [111.14506:14661]

B:BD[20.85349] → [42.41114:41269]

B:BD[20.85349] → [43.49881:50036]

B:BD[20.85349] → [29.74813:74968]

B:BD[20.85349] → [44.11233:11388]

B:BD[20.85349] → [46.74547:74702]

B:BD[20.85349] → [47.25995:26150]

B:BD[24.31589] → [22.26746:26899]

B:BD[20.85349] → [33.18881:19036]

B:BD[20.85349] → [48.41029:41184]

B:BD[20.85349] → [30.35915:36070]

B:BD[20.85349] → [49.49315:49470]

B:BD[20.85349] → [50.11875:12030]

B:BD[20.85349] → [51.15252:15407]

B:BD[20.85349] → [20.85349:85504]

B:BD[20.85504] → [20.85504:85657]

B:BD[20.85349] → [52.19840:19995]

B:BD[20.85349] → [38.27569:27724]

B:BD[20.85349] → [53.30214:30369]

B:BD[20.85349] → [54.33478:33633]

B:BD[20.85349] → [55.58788:58943]

B:BD[20.85349] → [37.23336:23491]

B:BD[43.49728] → [70.15786:15938]

B:BD[43.49728] → [43.49728:49880]

B:BD[43.49728] → [47.25842:25994]

B:BD[43.49728] → [30.35762:35914]

B:BD[43.49728] → [52.19687:19839]

B:BD[43.49728] → [38.27416:27568]

B:BD[29.74660] → [29.74660:74812]

B:BD[29.74660] → [46.74394:74546]

B:BD[20.85193] → [20.85193:85349]

B:BD[20.84890] → [24.31130:31433]

B:BD[20.84890] → [40.20088:20391]

B:BD[20.84890] → [41.14920:15223]

B:BD[20.84890] → [140.3397:3549]

B:BD[20.84890] → [70.15633:15785]

B:BD[20.84890] → [111.14202:14505]

B:BD[20.84890] → [42.40655:41113]

B:BD[20.84890] → [43.49422:49573]

B:BD[20.84890] → [29.74353:74660]

B:BD[20.84890] → [44.10929:11232]

B:BD[20.84890] → [47.25690:25841]

B:BD[20.84890] → [33.18577:18880]

B:BD[20.84890] → [48.40570:41028]

B:BD[20.84890] → [30.35609:35761]

B:BD[20.84890] → [49.49011:49314]

B:BD[20.84890] → [50.11571:11874]

B:BD[20.84890] → [51.14948:15251]

B:BD[20.84890] → [20.84890:85193]

B:BD[20.84890] → [52.19535:19686]

B:BD[20.84890] → [38.27263:27415]

B:BD[20.84890] → [53.29910:30213]

B:BD[20.84890] → [54.33174:33477]

B:BD[20.84890] → [55.58329:58787]

B:BD[20.84890] → [37.23032:23335]

B:BD[20.84890] → [71.8161:8312]

B:BD[20.84268] → [70.15468:15632]

B:BD[20.84268] → [29.74188:74352]

B:BD[20.84268] → [47.25525:25689]

B:BD[20.84268] → [30.35444:35608]

B:BD[20.84268] → [49.48846:49010]

B:BD[20.84268] → [20.84268:84432]

B:BD[20.84432] → [24.30979:31129]

B:BD[20.84432] → [22.26595:26745]

B:BD[20.84432] → [20.84432:84582]

B:BD[20.84268] → [52.19370:19534]

B:BD[20.84268] → [38.27098:27262]

B:BD[20.84268] → [71.7996:8160]

B:BD[20.83373] → [42.40503:40654]

B:BD[20.83373] → [43.49270:49421]

B:BD[20.83373] → [29.74036:74187]

B:BD[20.83373] → [48.40418:40569]

B:BD[20.83373] → [49.48695:48845]

B:BD[20.83373] → [20.83373:83523]

B:BD[20.83523] → [20.83523:84268]

B:BD[20.83373] → [53.29759:29909]

B:BD[20.83373] → [54.33023:33173]

B:BD[20.83373] → [55.58177:58328]

B:BD[20.83072] → [40.19938:20087]

B:BD[20.83072] → [41.14770:14919]

B:BD[20.83072] → [140.3082:3231]

B:BD[20.83072] → [70.15318:15467]

B:BD[20.83072] → [111.14052:14201]

B:BD[20.83072] → [42.40353:40502]

B:BD[20.83072] → [43.49120:49269]

B:BD[20.83072] → [29.73886:74035]

B:BD[20.83072] → [44.10779:10928]

B:BD[20.83072] → [47.25375:25524]

B:BD[20.83072] → [22.26445:26594]

B:BD[20.83072] → [33.18427:18576]

B:BD[20.83072] → [48.40268:40417]

B:BD[20.83072] → [30.35294:35443]

B:BD[20.83072] → [49.48545:48694]

B:BD[20.83072] → [50.11421:11570]

B:BD[20.83072] → [51.14798:14947]

B:BD[20.83072] → [20.83072:83221]

B:BD[20.83221] → [20.83221:83373]

B:BD[20.83072] → [52.19220:19369]

B:BD[20.83072] → [38.26948:27097]

B:BD[20.83072] → [53.29609:29758]

B:BD[20.83072] → [54.32873:33022]

B:BD[20.83072] → [55.58027:58176]

B:BD[20.83072] → [37.22882:23031]

B:BD[20.83072] → [71.7846:7995]

B:BD[20.82768] → [40.19783:19937]

B:BD[20.82768] → [41.14615:14769]

B:BD[20.82768] → [111.13897:14051]

B:BD[20.82768] → [42.40198:40352]

B:BD[20.82768] → [43.48965:49119]

B:BD[20.82768] → [29.73731:73885]

B:BD[20.82768] → [44.10624:10778]

B:BD[20.82768] → [33.18272:18426]

B:BD[20.82768] → [48.40113:40267]

B:BD[20.82768] → [49.48390:48544]

B:BD[20.82768] → [50.11266:11420]

B:BD[20.82768] → [51.14643:14797]

B:BD[20.82768] → [20.82768:82922]

B:BD[20.82922] → [20.82922:83072]

B:BD[20.82622] → [20.82622:82768]

B:BD[20.82768] → [53.29454:29608]

B:BD[20.82768] → [54.32718:32872]

B:BD[20.82768] → [55.57872:58026]

B:BD[20.82768] → [37.22727:22881]

B:BD[22.26444] → [92.11223:11375]

B:BD[22.26444] → [29.73578:73730]

B:BD[22.26444] → [46.74241:74393]

B:BD[22.26444] → [47.25222:25374]

B:BD[20.82173] → [22.26147:26444]

B:BD[22.26444] → [30.35141:35293]

B:BD[22.26444] → [49.48237:48389]

B:BD[20.82173] → [20.82173:82470]

B:BD[20.82470] → [20.82470:82622]

B:BD[20.81562] → [70.15014:15168]

B:BD[22.25998] → [92.10916:11222]

B:BD[22.25998] → [70.15169:15317]

B:BD[22.25998] → [43.48816:48964]

B:BD[22.25998] → [29.73271:73577]

B:BD[22.25998] → [46.73934:74240]

B:BD[22.25998] → [47.24915:25221]

B:BD[22.25998] → [22.25998:26146]

B:BD[22.25998] → [48.39964:40112]

B:BD[22.25998] → [30.34834:35140]

B:BD[22.25998] → [49.47930:48236]

B:BD[20.82015] → [20.82015:82173]

B:BD[22.25998] → [52.19071:19219]

B:BD[22.25998] → [38.26799:26947]

B:BD[22.25998] → [53.29305:29453]

B:BD[22.25998] → [39.9159:9307]

B:BD[20.81562] → [29.73116:73270]

B:BD[20.81562] → [47.24760:24914]

B:BD[20.81562] → [22.25693:25847]

B:BD[22.25847] → [22.25847:25998]

B:BD[20.81562] → [30.34679:34833]

B:BD[20.81562] → [49.47775:47929]

B:BD[20.81562] → [20.81562:81867]

B:BD[20.81867] → [40.19634:19782]

B:BD[20.81867] → [41.14466:14614]

B:BD[20.81867] → [111.13748:13896]

B:BD[20.81867] → [42.40049:40197]

B:BD[20.81867] → [44.10475:10623]

B:BD[20.81867] → [33.18123:18271]

B:BD[20.81867] → [50.11117:11265]

B:BD[20.81867] → [51.14494:14642]

B:BD[20.81867] → [20.81867:82015]

B:BD[20.81867] → [54.32569:32717]

B:BD[20.81867] → [55.57723:57871]

B:BD[20.81867] → [37.22578:22726]

B:BD[20.81562] → [52.18916:19070]

B:BD[20.81562] → [38.26644:26798]

B:BD[20.81112] → [42.39902:40048]

B:BD[20.81112] → [43.48669:48815]

B:BD[20.81112] → [29.72969:73115]

B:BD[20.81112] → [48.39817:39963]

B:BD[20.81112] → [49.47628:47774]

B:BD[20.81112] → [20.81112:81258]

B:BD[20.81258] → [20.81258:81562]

B:BD[20.81112] → [53.29158:29304]

B:BD[20.81112] → [54.32422:32568]

B:BD[20.81112] → [55.57576:57722]

B:BD[20.80814] → [22.25541:25692]

B:BD[20.80814] → [20.80814:80965]

B:BD[20.80965] → [20.80965:81112]

B:BD[20.80066] → [22.25238:25390]

B:BD[20.80368] → [20.80368:80814]

B:BD[22.25390] → [140.2931:3081]

B:BD[22.25390] → [70.14863:15013]

B:BD[22.25390] → [43.48518:48668]

B:BD[22.25390] → [29.72818:72968]

B:BD[22.25390] → [46.73783:73933]

B:BD[22.25390] → [47.24609:24759]

B:BD[22.25390] → [22.25390:25540]

B:BD[22.25390] → [48.39666:39816]

B:BD[22.25390] → [30.34528:34678]

B:BD[22.25390] → [49.47477:47627]

B:BD[22.25390] → [52.18765:18915]

B:BD[22.25390] → [38.26493:26643]

B:BD[22.25390] → [53.29007:29157]

B:BD[22.25390] → [71.7695:7845]

B:BD[20.80066] → [20.80066:80218]

B:BD[20.80218] → [40.19483:19633]

B:BD[20.80218] → [41.14315:14465]

B:BD[20.80218] → [111.13597:13747]

B:BD[20.80218] → [42.39751:39901]

B:BD[20.80218] → [44.10324:10474]

B:BD[20.80218] → [33.17972:18122]

B:BD[20.80218] → [50.10966:11116]

B:BD[20.80218] → [51.14343:14493]

B:BD[20.80218] → [20.80218:80368]

B:BD[20.80218] → [54.32271:32421]

B:BD[20.80218] → [55.57425:57575]

B:BD[20.80218] → [37.22427:22577]

B:BD[20.79767] → [70.14714:14862]

B:BD[20.79767] → [43.48369:48517]

B:BD[20.79767] → [29.72669:72817]

B:BD[20.79767] → [46.73634:73782]

B:BD[20.79767] → [47.24460:24608]

B:BD[20.79767] → [22.25089:25237]

B:BD[20.79767] → [30.34379:34527]

B:BD[20.79767] → [49.47328:47476]

B:BD[20.79767] → [20.79767:79915]

B:BD[20.79915] → [20.79915:80066]

B:BD[20.79616] → [20.79616:79767]

B:BD[20.79767] → [52.18616:18764]

B:BD[20.79767] → [38.26344:26492]

B:BD[24.28879] → [24.28879:29025]

B:BD[24.28879] → [22.24942:25088]

B:BD[20.79314] → [42.39300:39750]

B:BD[20.79314] → [43.47918:48075]

B:BD[43.48221] → [43.48221:48368]

B:BD[43.48075] → [92.10769:10915]

B:BD[43.48075] → [43.48075:48221]

B:BD[43.48075] → [47.24313:24459]

B:BD[43.48075] → [30.34232:34378]

B:BD[20.79314] → [29.72218:72375]

B:BD[29.72521] → [29.72521:72668]

B:BD[29.72375] → [29.72375:72521]

B:BD[29.72375] → [46.73487:73633]

B:BD[20.79314] → [48.39215:39665]

B:BD[20.79314] → [49.47025:47327]

B:BD[20.79314] → [20.79314:79616]

B:BD[20.79314] → [53.28704:29006]

B:BD[20.79314] → [54.31968:32270]

B:BD[20.79314] → [55.56974:57424]

B:BD[20.79005] → [46.73335:73486]

B:BD[20.79005] → [30.34080:34231]

B:BD[20.79005] → [49.46873:47024]

B:BD[20.79005] → [20.79005:79156]

B:BD[20.79156] → [20.79156:79314]

B:BD[20.78540] → [29.71909:72065]

B:BD[20.77616] → [41.14007:14314]

B:BD[20.78540] → [20.78540:79005]

B:BD[20.77616] → [42.38992:39299]

B:BD[20.77616] → [43.47453:47760]

B:BD[20.77616] → [29.71601:71908]

B:BD[20.77616] → [33.17664:17971]

B:BD[20.77616] → [48.38907:39214]

B:BD[20.77616] → [49.46565:46872]

B:BD[20.77616] → [20.77616:77923]

B:BD[20.77923] → [20.77923:78540]

B:BD[20.77616] → [53.28396:28703]

B:BD[20.77616] → [54.31660:31967]

B:BD[20.77616] → [55.56666:56973]

B:BD[22.24788] → [22.24788:24941]

B:BD[20.77462] → [20.77462:77616]

B:BD[22.24941] → [53.28240:28395]

B:BD[24.28104] → [24.28104:28259]

B:BD[24.28104] → [22.24633:24788]

B:BD[20.76850] → [42.38687:38991]

B:BD[20.77307] → [20.77307:77462]

B:BD[20.77307] → [54.31504:31659]

B:BD[20.76850] → [43.47148:47297]

B:BD[38.26343] → [92.10615:10768]

B:BD[70.14560] → [70.14560:14713]

B:BD[70.14560] → [39.9005:9158]

B:BD[43.47297] → [140.2775:2930]

B:BD[43.47297] → [70.14405:14560]

B:BD[43.47297] → [43.47297:47452]

B:BD[43.47297] → [47.24004:24312]

B:BD[43.47297] → [30.33771:34079]

B:BD[43.47297] → [52.18460:18615]

B:BD[43.47297] → [38.26188:26343]

B:BD[43.47297] → [71.7539:7694]

B:BD[20.76850] → [29.71143:71447]

B:BD[29.71447] → [29.71447:71600]

B:BD[29.71447] → [46.73181:73334]

B:BD[20.76850] → [48.38602:38906]

B:BD[20.76850] → [49.45952:46564]

B:BD[20.76850] → [20.76850:76999]

B:BD[20.77154] → [20.77154:77307]

B:BD[20.76999] → [40.19327:19482]

B:BD[20.76999] → [41.13851:14006]

B:BD[20.76999] → [111.13441:13596]

B:BD[20.76999] → [44.10168:10323]

B:BD[20.76999] → [33.17508:17663]

B:BD[20.76999] → [50.10810:10965]

B:BD[20.76999] → [51.14187:14342]

B:BD[20.76999] → [20.76999:77154]

B:BD[20.76999] → [37.22271:22426]

B:BD[20.76695] → [20.76695:76850]

B:BD[20.76850] → [53.27935:28239]

B:BD[20.76850] → [54.31199:31503]

B:BD[20.76850] → [55.56361:56665]

B:BD[24.27647] → [24.27647:27954]

B:BD[20.75914] → [40.18852:19326]

B:BD[20.75914] → [41.13376:13850]

B:BD[20.75914] → [70.14087:14245]

B:BD[43.46836] → [70.14246:14404]

B:BD[43.46836] → [30.33612:33770]

B:BD[43.46836] → [38.26029:26187]

B:BD[20.75914] → [111.12966:13440]

B:BD[20.75914] → [42.37899:38686]

B:BD[20.75914] → [43.46208:46678]

B:BD[43.46836] → [43.46836:47147]

B:BD[43.46678] → [43.46678:46836]

B:BD[20.75914] → [29.70357:71142]

B:BD[20.75914] → [44.9693:10167]

B:BD[20.75914] → [47.23533:24003]

B:BD[20.75914] → [22.24158:24632]

B:BD[20.75914] → [33.17033:17507]

B:BD[20.75914] → [48.37814:38601]

B:BD[20.75914] → [30.33453:33611]

B:BD[20.75914] → [49.45170:45951]

B:BD[20.75914] → [50.10335:10809]

B:BD[20.75914] → [51.13712:14186]

B:BD[20.75914] → [20.75914:76388]

B:BD[20.76388] → [20.76388:76695]

B:BD[20.75914] → [52.17989:18459]

B:BD[20.75914] → [38.25870:26028]

B:BD[20.75914] → [53.27153:27934]

B:BD[20.75914] → [54.30417:31198]

B:BD[20.75914] → [55.55573:56360]

B:BD[20.75914] → [37.21796:22270]

B:BD[20.75435] → [49.45010:45169]

B:BD[20.75435] → [20.75435:75594]

B:BD[20.75594] → [20.75594:75914]

B:BD[20.75435] → [53.26993:27152]

B:BD[20.75435] → [54.30257:30416]

B:BD[20.75136] → [46.73032:73180]

B:BD[20.75136] → [30.33304:33452]

B:BD[20.75136] → [49.44861:45009]

B:BD[20.75136] → [20.75136:75284]

B:BD[20.75284] → [20.75284:75435]

B:BD[20.74987] → [20.74987:75136]

B:BD[20.74692] → [40.18705:18851]

B:BD[20.74692] → [41.13229:13375]

B:BD[20.74692] → [92.10319:10614]

B:BD[20.74692] → [70.13791:13937]

B:BD[70.13937] → [70.13937:14086]

B:BD[70.13937] → [39.8855:9004]

B:BD[20.74692] → [111.12819:12965]

B:BD[20.74692] → [42.37752:37898]

B:BD[20.74692] → [43.46061:46207]

B:BD[20.74692] → [29.69912:70207]

B:BD[20.74692] → [44.9546:9692]

B:BD[20.74692] → [46.72736:73031]

B:BD[20.74692] → [47.23237:23532]

B:BD[20.74692] → [33.16886:17032]

B:BD[20.74692] → [48.37667:37813]

B:BD[20.74692] → [30.33008:33303]

B:BD[20.74692] → [49.44565:44860]

B:BD[20.74692] → [50.10188:10334]

B:BD[20.74692] → [51.13565:13711]

B:BD[20.74692] → [20.74692:74838]

B:BD[20.74838] → [20.74838:74987]

B:BD[20.74545] → [20.74545:74692]

B:BD[20.74692] → [52.17842:17988]

B:BD[20.74692] → [38.25723:25869]

B:BD[20.74692] → [53.26846:26992]

B:BD[20.74692] → [54.30110:30256]

B:BD[20.74692] → [55.55426:55572]

B:BD[20.74692] → [37.21649:21795]

B:BD[24.26716] → [24.26716:26865]

B:BD[24.26716] → [22.24008:24157]

B:BD[20.73787] → [42.36986:37751]

B:BD[20.73787] → [43.45295:45444]

B:BD[43.45599] → [43.45599:46060]

B:BD[43.46060] → [92.10169:10318]

B:BD[43.46060] → [70.13641:13790]

B:BD[43.46060] → [47.23087:23236]

B:BD[43.46060] → [30.32858:33007]

B:BD[43.46060] → [39.8705:8854]

B:BD[43.45444] → [140.2619:2774]

B:BD[43.45444] → [70.13485:13640]

B:BD[43.45444] → [43.45444:45599]

B:BD[43.45444] → [47.22931:23086]

B:BD[43.45444] → [30.32702:32857]

B:BD[43.45444] → [52.17686:17841]

B:BD[43.45444] → [38.25567:25722]

B:BD[43.45444] → [71.7383:7538]

B:BD[20.73787] → [29.68997:69762]

B:BD[29.69762] → [29.69762:69911]

B:BD[29.69762] → [46.72586:72735]

B:BD[20.73787] → [48.36901:37666]

B:BD[20.73787] → [49.43806:44564]

B:BD[20.73787] → [20.73787:74396]

B:BD[20.74396] → [20.74396:74545]

B:BD[20.73787] → [53.26236:26845]

B:BD[20.73787] → [54.29500:30109]

B:BD[20.73787] → [55.54660:55425]

B:BD[20.73026] → [40.18243:18393]

B:BD[20.73178] → [40.18394:18704]

B:BD[20.73636] → [20.73636:73787]

B:BD[20.73178] → [41.12919:13228]

B:BD[20.73178] → [111.12508:12818]

B:BD[20.73178] → [44.9235:9545]

B:BD[20.73178] → [33.16575:16885]

B:BD[20.73178] → [50.9878:10187]

B:BD[20.73178] → [51.13255:13564]

B:BD[20.73178] → [20.73178:73487]

B:BD[20.73487] → [20.73487:73636]

B:BD[20.73178] → [37.21339:21648]

B:BD[20.73026] → [111.12357:12507]

B:BD[20.73026] → [42.36375:36985]

B:BD[20.73026] → [43.44684:44834]

B:BD[43.44987] → [43.44987:45294]

B:BD[43.44834] → [70.13331:13484]

B:BD[43.44834] → [43.44834:44987]

B:BD[43.44834] → [47.22777:22930]

B:BD[43.44834] → [30.32548:32701]

B:BD[43.44834] → [52.17532:17685]

B:BD[43.44834] → [38.25413:25566]

B:BD[29.68536] → [29.68536:68689]

B:BD[29.68689] → [29.68689:68996]

B:BD[20.73026] → [29.68386:68536]

B:BD[20.73026] → [44.9084:9234]

B:BD[29.68536] → [46.72432:72585]

B:BD[20.73026] → [33.16424:16574]

B:BD[20.73026] → [48.36290:36900]

B:BD[20.73026] → [49.43195:43805]

B:BD[20.73026] → [20.73026:73178]

B:BD[20.73026] → [53.25625:26235]

B:BD[20.73026] → [54.28889:29499]

B:BD[20.73026] → [55.54049:54659]

B:BD[24.25344] → [22.23856:24007]

B:BD[24.25193] → [24.25193:25344]

B:BD[20.72878] → [20.72878:73026]

B:BD[20.72425] → [40.17938:18089]

B:BD[20.72727] → [40.18090:18242]

B:BD[20.72727] → [41.12767:12918]

B:BD[20.72727] → [111.12205:12356]

B:BD[20.72727] → [44.8931:9083]

B:BD[20.72727] → [33.16271:16423]

B:BD[20.72727] → [50.9726:9877]

B:BD[20.72727] → [51.13103:13254]

B:BD[20.72727] → [20.72727:72878]

B:BD[20.72727] → [37.21187:21338]

B:BD[20.72425] → [41.12615:12766]

B:BD[20.72425] → [42.36071:36374]

B:BD[20.72425] → [43.44380:44531]

B:BD[43.44531] → [43.44531:44683]

B:BD[20.72425] → [29.68081:68233]

B:BD[29.68233] → [29.68233:68385]

B:BD[20.72425] → [44.8779:8930]

B:BD[20.72425] → [46.72280:72431]

B:BD[20.72425] → [22.23704:23855]

B:BD[20.72425] → [33.16119:16270]

B:BD[20.72425] → [48.35986:36289]

B:BD[20.72425] → [30.32395:32547]

B:BD[20.72425] → [49.42741:43194]

B:BD[20.72425] → [51.12951:13102]

B:BD[20.72425] → [20.72425:72576]

B:BD[20.72576] → [20.72576:72727]

B:BD[20.72272] → [20.72272:72425]

B:BD[20.72425] → [53.25171:25624]

B:BD[20.72425] → [54.28435:28888]

B:BD[20.72425] → [55.53745:54048]

B:BD[20.72425] → [37.21035:21186]

B:BD[20.72117] → [42.35915:36070]

B:BD[20.72117] → [43.44224:44379]

B:BD[43.44379] → [140.2462:2618]

B:BD[43.44379] → [70.13174:13330]

B:BD[43.44379] → [47.22621:22776]

B:BD[43.44379] → [30.32239:32394]

B:BD[43.44379] → [52.17376:17531]

B:BD[43.44379] → [38.25256:25412]

B:BD[43.44379] → [71.7227:7382]

B:BD[20.72117] → [29.67770:67925]

B:BD[29.67925] → [29.67925:68080]

B:BD[29.67925] → [46.72123:72279]

B:BD[20.72117] → [44.8623:8778]

B:BD[20.72117] → [22.23548:23703]

B:BD[20.72117] → [33.15963:16118]

B:BD[20.72117] → [48.35830:35985]

B:BD[20.72117] → [49.42585:42740]

B:BD[20.72117] → [20.72117:72272]

B:BD[20.72117] → [55.53589:53744]

B:BD[20.72103] → [20.72103:72106]

B:BD[20.72106] → [20.72106:72117]

B:BD[30.31806] → [29.66472:66979]

B:BD[30.31806] → [30.31806:32238]

B:BD[30.31806] → [49.42078:42584]

B:BD[30.31586] → [29.66324:66471]

B:BD[30.31586] → [30.31586:31733]

B:BD[30.31586] → [49.41931:42077]

B:BD[30.31485] → [29.66304:66323]

B:BD[30.31485] → [30.31485:31504]

B:BD[30.31485] → [49.41911:41930]

B:BD[20.71240] → [20.71240:71277]

B:BD[20.71296] → [20.71296:71378]

B:BD[20.71524] → [20.71524:71597]

B:BD[20.71597] → [24.24535:25041]

B:BD[20.71597] → [42.35407:35914]

B:BD[20.71597] → [43.43716:44223]

B:BD[20.71597] → [48.35322:35829]

B:BD[20.71597] → [20.71597:72103]

B:BD[20.71597] → [53.24664:25170]

B:BD[20.71597] → [54.27928:28434]

B:BD[20.71597] → [55.53081:53588]

B:BD[20.71378] → [24.24388:24534]

B:BD[20.71378] → [42.35259:35406]

B:BD[20.71378] → [43.43568:43715]

B:BD[20.71378] → [48.35174:35321]

B:BD[20.71378] → [20.71378:71524]

B:BD[20.71378] → [53.24517:24663]

B:BD[20.71378] → [54.27781:27927]

B:BD[20.71378] → [55.52933:53080]

B:BD[20.71277] → [24.24368:24387]

B:BD[20.71277] → [42.35239:35258]

B:BD[20.71277] → [43.43548:43567]

B:BD[20.71277] → [48.35154:35173]

B:BD[20.71277] → [20.71277:71296]

B:BD[20.71277] → [53.24497:24516]

B:BD[20.71277] → [54.27761:27780]

B:BD[20.71277] → [55.52913:52932]

B:BD[20.71090] → [24.24217:24367]

B:BD[20.71090] → [40.17631:17781]

B:BD[20.71090] → [41.12464:12614]

B:BD[20.71090] → [111.12054:12204]

B:BD[20.71090] → [42.35088:35238]

B:BD[20.71090] → [43.43397:43547]

B:BD[20.71090] → [29.66153:66303]

B:BD[20.71090] → [44.8472:8622]

B:BD[20.71090] → [33.15812:15962]

B:BD[20.71090] → [48.35003:35153]

B:BD[20.71090] → [49.41760:41910]

B:BD[20.71090] → [50.9575:9725]

B:BD[20.71090] → [51.12800:12950]

B:BD[20.71090] → [20.71090:71240]

B:BD[20.71090] → [53.24346:24496]

B:BD[20.71090] → [54.27610:27760]

B:BD[20.71090] → [55.52762:52912]

B:BD[20.71090] → [37.20884:21034]

B:BD[20.70950] → [24.24146:24216]

B:BD[20.70950] → [22.23477:23547]

B:BD[20.70950] → [20.70950:71020]

B:BD[20.70849] → [24.24126:24145]

B:BD[20.70849] → [22.23457:23476]

B:BD[20.70849] → [20.70849:70868]

B:BD[20.70456] → [29.66079:66152]

B:BD[20.70456] → [46.72049:72122]

B:BD[20.70456] → [30.31374:31447]

B:BD[20.70456] → [49.41686:41759]

B:BD[20.70456] → [20.70456:70529]

B:BD[20.70251] → [29.66005:66078]

B:BD[20.70251] → [46.71975:72048]

B:BD[20.70251] → [30.31300:31373]

B:BD[20.70251] → [49.41612:41685]

B:BD[20.70251] → [20.70251:70324]

B:BD[29.65926] → [29.65926:66004]

B:BD[22.23454] → [22.23454:23456]

B:BD[22.23376] → [22.23376:23454]

B:BD[22.23303] → [29.65853:65926]

B:BD[22.23303] → [46.71901:71974]

B:BD[22.23303] → [22.23303:23376]

B:BD[22.23303] → [30.31226:31299]

B:BD[22.23303] → [49.41460:41611]

B:BD[20.69838] → [20.69838:70122]

B:BD[22.23082] → [46.71827:71900]

B:BD[22.23082] → [22.23082:23155]

B:BD[22.23155] → [22.23155:23170]

B:BD[22.23082] → [30.31152:31225]

B:BD[22.23082] → [49.41386:41459]

B:BD[22.22982] → [29.65760:65778]

B:BD[22.22982] → [22.22982:23000]

B:BD[22.23000] → [22.23000:23082]

B:BD[22.22982] → [49.41367:41385]

B:BD[20.69717] → [20.69717:69773]

B:BD[20.69773] → [20.69773:69838]

B:BD[20.69508] → [22.22961:22982]

B:BD[20.69508] → [20.69508:69717]

B:BD[20.68955] → [29.65741:65759]

B:BD[20.68955] → [46.71808:71826]

B:BD[20.68955] → [30.31133:31151]

B:BD[20.68955] → [49.41348:41366]

B:BD[20.68955] → [20.68955:68973]

B:BD[20.68476] → [46.71732:71807]

B:BD[20.68476] → [30.31057:31132]

B:BD[20.68476] → [49.41272:41347]

B:BD[20.68476] → [20.68476:68551]

B:BD[20.68551] → [24.24055:24125]

B:BD[20.68551] → [22.22890:22960]

B:BD[20.68551] → [20.68551:68621]

B:BD[20.68055] → [20.68055:68174]

B:BD[20.68252] → [24.23935:23976]

B:BD[20.68284] → [20.68284:68362]

B:BD[20.68362] → [20.68362:68476]

B:BD[20.68252] → [20.68252:68284]

B:BD[24.23976] → [24.23976:24054]

B:BD[20.68174] → [20.68174:68252]

B:BD[20.68055] → [52.17265:17375]

B:BD[20.68055] → [53.24226:24304]

B:BD[53.24304] → [53.24304:24345]

B:BD[20.68055] → [54.27490:27609]

B:BD[20.68055] → [71.7116:7226]

B:BD[20.67909] → [20.67909:68055]

B:BD[20.67714] → [20.67714:67792]

B:BD[20.67696] → [24.23916:23934]

B:BD[20.67696] → [42.35069:35087]

B:BD[20.67696] → [43.43280:43298]

B:BD[20.67696] → [29.65646:65664]

B:BD[20.67696] → [48.34984:35002]

B:BD[20.67696] → [49.41023:41041]

B:BD[20.67696] → [20.67696:67714]

B:BD[20.67696] → [53.24207:24225]

B:BD[20.67696] → [54.27471:27489]

B:BD[20.67696] → [55.52743:52761]

B:BD[20.67338] → [24.23897:23915]

B:BD[20.67338] → [22.22753:22771]

B:BD[20.67338] → [20.67338:67356]

B:BD[71.7012] → [71.7012:7102]

B:BD[71.7115] → [47.22302:22509]

B:BD[71.7115] → [49.40815:41022]

B:BD[71.7115] → [52.17057:17264]

B:BD[71.7102] → [71.7102:7115]

B:BD[71.6947] → [71.6947:7012]

B:BD[20.67118] → [20.67118:67325]

B:BD[20.67118] → [71.6908:6947]

B:BD[43.43202] → [140.2386:2461]

B:BD[20.66752] → [20.66752:67040]

B:BD[43.43202] → [70.13098:13173]

B:BD[43.43202] → [43.43202:43277]

B:BD[43.43202] → [47.22226:22301]

B:BD[43.43202] → [30.30981:31056]

B:BD[43.43202] → [52.16981:17056]

B:BD[43.43202] → [38.25180:25255]

B:BD[43.43202] → [71.6832:6907]

B:BD[20.66752] → [29.65551:65645]

B:BD[20.66669] → [29.65532:65550]

B:BD[20.66669] → [49.40796:40814]

B:BD[20.66669] → [20.66669:66687]

B:BD[20.66687] → [20.66687:66752]

B:BD[20.66235] → [20.66235:66349]

B:BD[20.66349] → [20.66349:66669]

B:BD[20.66186] → [43.43073:43090]

B:BD[43.43163] → [43.43163:43165]

B:BD[43.43090] → [92.9229:9302]

B:BD[20.66186] → [20.66186:66235]

B:BD[43.43090] → [70.13024:13097]

B:BD[43.43090] → [43.43090:43163]

B:BD[43.43090] → [47.22152:22225]

B:BD[43.43090] → [30.30907:30980]

B:BD[43.43090] → [39.8631:8704]

B:BD[20.66186] → [29.65439:65456]

B:BD[29.65529] → [29.65529:65531]

B:BD[29.65456] → [29.65456:65529]

B:BD[29.65456] → [46.71658:71731]

B:BD[20.66186] → [48.34891:34983]

B:BD[20.66186] → [55.52650:52742]

B:BD[20.66103] → [42.34957:34975]

B:BD[20.66103] → [43.43054:43072]

B:BD[20.66103] → [29.65420:65438]

B:BD[20.66103] → [48.34872:34890]

B:BD[20.66103] → [49.40777:40795]

B:BD[20.66121] → [20.66121:66186]

B:BD[20.66103] → [20.66103:66121]

B:BD[20.66103] → [53.24188:24206]

B:BD[20.66103] → [54.27452:27470]

B:BD[20.66103] → [55.52631:52649]

B:BD[24.23647] → [24.23647:23795]

B:BD[20.65956] → [20.65956:66103]

B:BD[24.23647] → [22.22489:22637]

B:BD[43.42823] → [140.2310:2385]

B:BD[43.42971] → [43.42971:43053]

B:BD[43.42823] → [70.12875:13023]

B:BD[20.65648] → [42.34648:34956]

B:BD[43.42823] → [43.42823:42898]

B:BD[43.42898] → [43.42898:42971]

B:BD[20.65648] → [43.42745:42823]

B:BD[38.25106] → [92.9155:9228]

B:BD[38.25106] → [38.25106:25179]

B:BD[43.42823] → [47.22003:22151]

B:BD[20.65648] → [48.34563:34871]

B:BD[43.42823] → [30.30758:30906]

B:BD[20.65648] → [20.65648:65726]

B:BD[20.65801] → [20.65801:65956]

B:BD[20.65726] → [40.17555:17630]

B:BD[20.65726] → [41.12388:12463]

B:BD[20.65726] → [111.11978:12053]

B:BD[20.65726] → [44.8396:8471]

B:BD[20.65726] → [33.15736:15811]

B:BD[20.65726] → [50.9499:9574]

B:BD[20.65726] → [51.12724:12799]

B:BD[20.65726] → [20.65726:65801]

B:BD[20.65726] → [37.20808:20883]

B:BD[43.42823] → [52.16832:16980]

B:BD[43.42823] → [38.25031:25106]

B:BD[20.65648] → [53.23879:24187]

B:BD[20.65648] → [54.27143:27451]

B:BD[20.65648] → [55.52322:52630]

B:BD[43.42823] → [71.6756:6831]

B:BD[43.42744] → [30.30526:30601]

B:BD[22.22340] → [70.12796:12874]

B:BD[22.22488] → [92.9078:9154]

B:BD[22.22488] → [29.65035:65111]

B:BD[29.65264] → [29.65264:65337]

B:BD[29.65337] → [29.65337:65419]

B:BD[29.65264] → [46.71584:71657]

B:BD[29.65111] → [29.65111:65264]

B:BD[22.22488] → [46.71507:71583]

B:BD[22.22488] → [47.21926:22002]

B:BD[22.22488] → [30.30681:30757]

B:BD[22.22488] → [49.40392:40776]

B:BD[22.22340] → [29.64956:65034]

B:BD[22.22340] → [47.21847:21925]

B:BD[22.22418] → [22.22418:22488]

B:BD[22.22340] → [22.22340:22418]

B:BD[22.22340] → [30.30602:30680]

B:BD[22.22340] → [49.40313:40391]

B:BD[22.22340] → [52.16753:16831]

B:BD[22.22340] → [38.24952:25030]

B:BD[20.65349] → [20.65349:65572]

B:BD[20.65572] → [20.65572:65648]

B:BD[20.65122] → [70.12722:12795]

B:BD[20.65349] → [22.22265:22340]

B:BD[20.65122] → [29.64733:64806]

B:BD[29.64880] → [29.64880:64955]

B:BD[29.64880] → [46.71431:71506]

B:BD[29.64806] → [29.64806:64880]

B:BD[20.65122] → [46.71357:71430]

B:BD[20.65122] → [47.21773:21846]

B:BD[20.65122] → [30.30452:30525]

B:BD[20.65122] → [49.40085:40312]

B:BD[20.65122] → [20.65122:65195]

B:BD[20.65274] → [20.65274:65349]

B:BD[20.65195] → [24.23265:23344]

B:BD[20.65195] → [42.34573:34647]

B:BD[20.65195] → [43.42670:42744]

B:BD[20.65195] → [48.34488:34562]

B:BD[20.65195] → [20.65195:65274]

B:BD[20.65195] → [53.23799:23878]

B:BD[20.65195] → [54.27063:27142]

B:BD[20.65195] → [55.52247:52321]

B:BD[20.65122] → [39.8557:8630]

B:BD[20.65022] → [42.34553:34572]

B:BD[20.65022] → [43.42650:42669]

B:BD[20.65022] → [29.64713:64732]

B:BD[20.65022] → [48.34468:34487]

B:BD[20.65022] → [49.40066:40084]

B:BD[20.65040] → [20.65040:65122]

B:BD[20.65022] → [20.65022:65040]

B:BD[20.65022] → [53.23780:23798]

B:BD[20.65022] → [54.27044:27062]

B:BD[20.65022] → [55.52227:52246]

B:BD[20.64979] → [20.64979:65022]

B:BD[24.23021] → [24.23021:23245]

B:BD[24.23021] → [22.22040:22118]

B:BD[24.22865] → [24.22865:22945]

B:BD[24.22865] → [22.21959:22039]

B:BD[20.64442] → [42.34239:34552]

B:BD[20.64442] → [43.42257:42338]

B:BD[43.42494] → [43.42494:42649]

B:BD[43.42338] → [70.12565:12721]

B:BD[43.42338] → [43.42338:42494]

B:BD[43.42338] → [47.21616:21772]

B:BD[43.42338] → [52.16596:16752]

B:BD[43.42338] → [38.24795:24951]

B:BD[29.64401] → [29.64401:64712]

B:BD[20.64442] → [29.64320:64401]

B:BD[20.64442] → [46.71275:71356]

B:BD[20.64442] → [48.34154:34467]

B:BD[20.64442] → [30.30214:30451]

B:BD[20.64442] → [49.39674:40065]

B:BD[20.64442] → [20.64442:64755]

B:BD[20.64755] → [20.64755:64979]

B:BD[20.64442] → [53.23466:23779]

B:BD[20.64442] → [54.26730:27043]

B:BD[20.64442] → [55.51913:52226]

B:BD[24.22632] → [22.21883:21958]

B:BD[24.22561] → [24.22561:22632]

B:BD[20.64368] → [20.64368:64442]

B:BD[20.64074] → [70.12410:12488]

B:BD[22.21882] → [43.42110:42181]

B:BD[43.42181] → [140.2234:2309]

B:BD[43.42181] → [70.12489:12564]

B:BD[43.42181] → [43.42181:42256]

B:BD[43.42181] → [47.21540:21615]

B:BD[43.42181] → [30.30138:30213]

B:BD[43.42181] → [52.16520:16595]

B:BD[43.42181] → [38.24719:24794]

B:BD[43.42181] → [71.6680:6755]

B:BD[22.21882] → [29.64173:64319]

B:BD[22.21882] → [48.34007:34153]

B:BD[22.21882] → [49.39527:39673]

B:BD[22.21882] → [53.23319:23465]

B:BD[20.64074] → [29.64094:64172]

B:BD[20.64074] → [47.21461:21539]

B:BD[20.64074] → [22.21734:21812]

B:BD[22.21812] → [22.21812:21882]

B:BD[20.64074] → [30.30059:30137]

B:BD[20.64074] → [49.39448:39526]

B:BD[20.64074] → [20.64074:64222]

B:BD[20.64293] → [40.17479:17554]

B:BD[20.64293] → [41.12312:12387]

B:BD[20.64293] → [111.11902:11977]

B:BD[20.64293] → [44.8320:8395]

B:BD[20.64293] → [33.15660:15735]

B:BD[20.64293] → [50.9423:9498]

B:BD[20.64293] → [51.12648:12723]

B:BD[20.64293] → [20.64293:64368]

B:BD[20.64293] → [37.20732:20807]

B:BD[20.64222] → [42.34092:34238]

B:BD[20.64222] → [20.64222:64293]

B:BD[20.64222] → [54.26583:26729]

B:BD[20.64222] → [55.51766:51912]

B:BD[20.64003] → [20.64003:64074]

B:BD[20.64074] → [52.16441:16519]

B:BD[20.64074] → [38.24640:24718]

B:BD[20.63773] → [42.33941:34091]

B:BD[20.63773] → [43.41959:42109]

B:BD[43.42109] → [30.29983:30058]

B:BD[20.63773] → [29.63868:64018]

B:BD[29.64018] → [29.64018:64093]

B:BD[29.64018] → [46.71199:71274]

B:BD[20.63773] → [48.33856:34006]

B:BD[20.63773] → [49.39217:39447]

B:BD[20.63773] → [20.63773:63928]

B:BD[20.63928] → [20.63928:64003]

B:BD[20.63773] → [53.23163:23318]

B:BD[20.63773] → [54.26427:26582]

B:BD[20.63773] → [55.51615:51765]

B:BD[20.63673] → [42.33922:33940]

B:BD[20.63673] → [43.41940:41958]

B:BD[20.63673] → [29.63849:63867]

B:BD[20.63673] → [48.33837:33855]

B:BD[20.63673] → [49.39198:39216]

B:BD[20.63673] → [20.63673:63691]

B:BD[20.63691] → [20.63691:63773]

B:BD[20.63673] → [53.23144:23162]

B:BD[20.63673] → [54.26408:26426]

B:BD[20.63673] → [55.51596:51614]

B:BD[20.63560] → [40.17405:17478]

B:BD[20.63560] → [41.12238:12311]

B:BD[20.63560] → [140.2160:2233]

B:BD[20.63560] → [70.12336:12409]

B:BD[20.63560] → [111.11828:11901]

B:BD[20.63560] → [42.33848:33921]

B:BD[20.63560] → [43.41866:41939]

B:BD[20.63560] → [29.63775:63848]

B:BD[20.63560] → [44.8246:8319]

B:BD[20.63560] → [46.71125:71198]

B:BD[20.63560] → [47.21387:21460]

B:BD[20.63560] → [33.15586:15659]

B:BD[20.63560] → [48.33763:33836]

B:BD[20.63560] → [30.29909:29982]

B:BD[20.63560] → [49.39124:39197]

B:BD[20.63560] → [50.9349:9422]

B:BD[20.63560] → [51.12574:12647]

B:BD[20.63560] → [20.63560:63633]

B:BD[20.63633] → [20.63633:63673]

B:BD[20.63560] → [52.16367:16440]

B:BD[20.63560] → [38.24566:24639]

B:BD[20.63560] → [53.23070:23143]

B:BD[20.63560] → [54.26334:26407]

B:BD[20.63560] → [55.51522:51595]

B:BD[20.63560] → [37.20658:20731]

B:BD[20.63560] → [71.6606:6679]

B:BD[20.63459] → [92.8985:9003]

B:BD[20.63459] → [29.63756:63774]

B:BD[20.63459] → [46.71105:71124]

B:BD[20.63459] → [47.21367:21386]

B:BD[20.63459] → [22.21714:21733]

B:BD[20.63459] → [30.29890:29908]

B:BD[20.63459] → [49.39104:39123]

B:BD[20.63459] → [20.63459:63478]

B:BD[20.63478] → [20.63478:63560]

B:BD[22.21713] → [43.41785:41865]

B:BD[22.21713] → [29.63675:63755]

B:BD[22.21713] → [48.33682:33762]

B:BD[22.21713] → [49.39023:39103]

B:BD[22.21713] → [53.22989:23069]

B:BD[24.21988] → [24.21988:22064]

B:BD[20.63430] → [20.63430:63459]

B:BD[20.62880] → [70.12259:12335]

B:BD[20.62880] → [42.33446:33766]

B:BD[20.63350] → [42.33767:33847]

B:BD[20.63350] → [20.63350:63430]

B:BD[20.63350] → [54.26253:26333]

B:BD[20.63350] → [55.51441:51521]

B:BD[20.62880] → [43.41464:41540]

B:BD[43.41540] → [43.41540:41784]

B:BD[20.62880] → [29.63354:63674]

B:BD[20.62880] → [47.21290:21366]

B:BD[24.21988] → [22.21637:21713]

B:BD[20.62880] → [48.33361:33681]

B:BD[20.62880] → [30.29813:29889]

B:BD[20.62880] → [49.38628:39022]

B:BD[20.62880] → [20.62880:63274]

B:BD[20.63274] → [20.63274:63350]

B:BD[20.62880] → [52.16290:16366]

B:BD[20.62880] → [38.24489:24565]

B:BD[20.62880] → [53.22594:22988]

B:BD[20.62880] → [54.25858:26252]

B:BD[20.62880] → [55.51120:51440]

B:BD[43.41319] → [43.41319:41390]

B:BD[43.41390] → [92.8911:8984]

B:BD[43.41390] → [70.12185:12258]

B:BD[43.41390] → [43.41390:41463]

B:BD[43.41390] → [47.21216:21289]

B:BD[43.41390] → [30.29739:29812]

B:BD[43.41390] → [52.16216:16289]

B:BD[43.41390] → [38.24415:24488]

B:BD[29.63280] → [29.63280:63353]

B:BD[29.63280] → [46.71031:71104]

B:BD[24.21520] → [22.21563:21636]

B:BD[20.62802] → [20.62802:62880]

B:BD[20.62581] → [24.21372:21520]

B:BD[20.62581] → [70.12107:12184]

B:BD[20.62581] → [42.33224:33445]

B:BD[20.62581] → [43.41242:41319]

B:BD[20.62581] → [29.63132:63280]

B:BD[20.62581] → [47.21138:21215]

B:BD[20.62581] → [48.33139:33360]

B:BD[20.62581] → [30.29661:29738]

B:BD[20.62581] → [49.38406:38627]

B:BD[20.62581] → [20.62581:62802]

B:BD[20.62581] → [52.16138:16215]

B:BD[20.62581] → [38.24337:24414]

B:BD[20.62581] → [53.22372:22593]

B:BD[20.62581] → [54.25636:25857]

B:BD[20.62581] → [55.50898:51119]

B:BD[20.62360] → [24.21227:21371]

B:BD[20.62360] → [49.38261:38405]

B:BD[20.62360] → [20.62360:62504]

B:BD[20.62360] → [53.22227:22371]

B:BD[20.62360] → [54.25491:25635]

B:BD[20.62214] → [29.63056:63131]

B:BD[20.62214] → [46.70955:71030]

B:BD[20.62214] → [30.29585:29660]

B:BD[20.62214] → [49.38185:38260]

B:BD[20.62214] → [20.62214:62289]

B:BD[20.62062] → [24.21153:21226]

B:BD[20.62062] → [92.8837:8910]

B:BD[20.62062] → [70.12033:12106]

B:BD[20.62062] → [29.62982:63055]

B:BD[20.62062] → [46.70881:70954]

B:BD[20.62062] → [47.21064:21137]

B:BD[20.62062] → [22.21489:21562]

B:BD[20.62062] → [30.29511:29584]

B:BD[20.62062] → [49.38111:38184]

B:BD[20.62062] → [20.62062:62135]

B:BD[20.62062] → [39.8483:8556]

B:BD[20.61962] → [24.21134:21152]

B:BD[20.61962] → [40.17386:17404]

B:BD[20.61962] → [41.12219:12237]

B:BD[20.61962] → [42.33205:33223]

B:BD[20.61962] → [43.41223:41241]

B:BD[20.61962] → [29.62963:62981]

B:BD[20.61962] → [44.8227:8245]

B:BD[20.61962] → [33.15567:15585]

B:BD[20.61962] → [48.33120:33138]

B:BD[20.61962] → [49.38092:38110]

B:BD[20.61962] → [51.12555:12573]

B:BD[20.61962] → [20.61962:61980]

B:BD[20.61962] → [53.22208:22226]

B:BD[20.61962] → [54.25472:25490]

B:BD[20.61962] → [55.50879:50897]

B:BD[20.61962] → [37.20639:20657]

B:BD[24.21053] → [24.21053:21133]

B:BD[24.21053] → [22.21408:21488]

B:BD[20.61693] → [22.21329:21407]

B:BD[22.21407] → [70.11876:12032]

B:BD[22.21407] → [43.41066:41222]

B:BD[22.21407] → [29.62806:62962]

B:BD[22.21407] → [47.20907:21063]

B:BD[22.21407] → [48.32963:33119]

B:BD[22.21407] → [30.29354:29510]

B:BD[22.21407] → [49.37935:38091]

B:BD[22.21407] → [52.15981:16137]

B:BD[22.21407] → [38.24180:24336]

B:BD[22.21407] → [53.22051:22207]

B:BD[20.61693] → [20.61693:61771]

B:BD[20.61771] → [42.33048:33204]

B:BD[20.61771] → [20.61771:61927]

B:BD[20.61771] → [54.25315:25471]

B:BD[20.61771] → [55.50722:50878]

B:BD[20.61406] → [40.17313:17385]

B:BD[20.61548] → [20.61548:61693]

B:BD[20.61406] → [41.12146:12218]

B:BD[20.61406] → [92.8764:8836]

B:BD[20.61406] → [70.11803:11875]

B:BD[20.61406] → [111.11755:11827]

B:BD[20.61406] → [42.32975:33047]

B:BD[20.61406] → [43.40993:41065]

B:BD[20.61406] → [29.62733:62805]

B:BD[20.61406] → [44.8154:8226]

B:BD[20.61406] → [46.70808:70880]

B:BD[20.61406] → [47.20834:20906]

B:BD[20.61406] → [22.21186:21258]

B:BD[22.21258] → [22.21258:21328]

B:BD[20.61406] → [33.15494:15566]

B:BD[20.61406] → [48.32890:32962]

B:BD[20.61406] → [30.29281:29353]

B:BD[20.61406] → [49.37862:37934]

B:BD[20.61406] → [50.9276:9348]

B:BD[20.61406] → [51.12482:12554]

B:BD[20.61406] → [20.61406:61478]

B:BD[20.61478] → [20.61478:61548]

B:BD[20.61334] → [20.61334:61406]

B:BD[20.61406] → [52.15908:15980]

B:BD[20.61406] → [38.24107:24179]

B:BD[20.61406] → [53.21978:22050]

B:BD[20.61406] → [54.25242:25314]

B:BD[20.61406] → [55.50649:50721]

B:BD[20.61406] → [37.20566:20638]

B:BD[20.61406] → [39.8410:8482]

B:BD[20.61186] → [92.8690:8763]

B:BD[20.61186] → [70.11729:11802]

B:BD[20.61186] → [29.62584:62732]

B:BD[20.61186] → [46.70659:70807]

B:BD[20.61186] → [47.20760:20833]

B:BD[20.61186] → [22.21112:21185]

B:BD[20.61186] → [30.29132:29280]

B:BD[20.61186] → [49.37713:37861]

B:BD[20.61186] → [20.61186:61259]

B:BD[20.61259] → [20.61259:61334]

B:BD[20.61186] → [39.8336:8409]

B:BD[20.61086] → [42.32956:32974]

B:BD[20.61086] → [43.40974:40992]

B:BD[20.61086] → [29.62565:62583]

B:BD[20.61086] → [22.21093:21111]

B:BD[20.61086] → [48.32871:32889]

B:BD[20.61086] → [49.37694:37712]

B:BD[20.61086] → [20.61086:61104]

B:BD[20.61104] → [20.61104:61186]

B:BD[20.61052] → [20.61052:61086]

B:BD[20.61086] → [53.21959:21977]

B:BD[20.61086] → [54.25223:25241]

B:BD[20.61086] → [55.50630:50648]

B:BD[24.20660] → [24.20660:20740]

B:BD[24.20660] → [22.21012:21092]

B:BD[20.60896] → [70.11572:11728]

B:BD[20.60896] → [42.32799:32955]

B:BD[20.60896] → [43.40817:40973]

B:BD[20.60896] → [29.62408:62564]

B:BD[20.60896] → [47.20603:20759]

B:BD[20.60896] → [48.32714:32870]

B:BD[20.60896] → [30.28975:29131]

B:BD[20.60896] → [49.37537:37693]

B:BD[20.60896] → [20.60896:61052]

B:BD[20.60896] → [52.15751:15907]

B:BD[20.60896] → [38.23950:24106]

B:BD[20.60896] → [53.21802:21958]

B:BD[20.60896] → [54.25066:25222]

B:BD[20.60896] → [55.50473:50629]

B:BD[20.60677] → [22.20941:21011]

B:BD[20.60747] → [20.60747:60896]

B:BD[20.60677] → [20.60677:60747]

B:BD[20.60529] → [92.8616:8689]

B:BD[20.60529] → [70.11498:11571]

B:BD[20.60529] → [29.62259:62407]

B:BD[20.60529] → [46.70510:70658]

B:BD[20.60529] → [47.20529:20602]

B:BD[20.60529] → [22.20867:20940]

B:BD[20.60529] → [30.28826:28974]

B:BD[20.60529] → [49.37388:37536]

B:BD[20.60529] → [20.60529:60602]

B:BD[20.60602] → [20.60602:60677]

B:BD[20.60529] → [39.8262:8335]

B:BD[20.60429] → [22.20848:20866]

B:BD[20.60429] → [20.60429:60447]

B:BD[20.60447] → [20.60447:60529]

B:BD[20.60319] → [70.11421:11497]

B:BD[20.60319] → [42.32722:32798]

B:BD[20.60319] → [43.40740:40816]

B:BD[20.60319] → [29.61963:62039]

B:BD[20.60395] → [20.60395:60410]

B:BD[20.60410] → [20.60410:60429]

B:BD[29.62039] → [29.62039:62258]

B:BD[20.60319] → [47.20452:20528]

B:BD[20.60319] → [48.32637:32713]

B:BD[20.60319] → [30.28530:28825]

B:BD[20.60319] → [49.37311:37387]

B:BD[20.60319] → [20.60319:60395]

B:BD[20.60319] → [52.15674:15750]

B:BD[20.60319] → [38.23873:23949]

B:BD[20.60319] → [53.21725:21801]

B:BD[20.60319] → [54.24989:25065]

B:BD[20.60319] → [55.50396:50472]

B:BD[20.60167] → [46.70434:70509]

B:BD[20.60167] → [30.28454:28529]

B:BD[20.60167] → [49.37235:37310]

B:BD[20.60167] → [20.60167:60242]

B:BD[20.60242] → [20.60242:60319]

B:BD[20.60067] → [42.32703:32721]

B:BD[20.60067] → [43.40721:40739]

B:BD[20.60067] → [29.61868:61886]

B:BD[20.60067] → [48.32618:32636]

B:BD[20.60067] → [49.37216:37234]

B:BD[20.60067] → [20.60067:60085]

B:BD[20.60085] → [20.60085:60167]

B:BD[20.60067] → [53.21706:21724]

B:BD[20.60067] → [54.24970:24988]

B:BD[20.60067] → [55.50377:50395]

B:BD[20.59881] → [42.32550:32702]

B:BD[43.40639] → [43.40639:40720]

B:BD[20.59881] → [43.40568:40639]

B:BD[20.60033] → [20.60033:60067]

B:BD[20.59881] → [48.32465:32617]

B:BD[43.40639] → [30.28372:28453]

B:BD[20.59881] → [20.59881:60033]

B:BD[20.59881] → [53.21553:21705]

B:BD[20.59881] → [54.24817:24969]

B:BD[20.59881] → [55.50224:50376]

B:BD[20.59724] → [40.17230:17312]

B:BD[20.59724] → [41.12063:12145]

B:BD[20.59724] → [111.11672:11754]

B:BD[20.59724] → [42.32467:32549]

B:BD[20.59724] → [43.40485:40567]

B:BD[43.40567] → [30.28296:28371]

B:BD[20.59724] → [29.61558:61640]

B:BD[29.61715] → [29.61715:61786]

B:BD[29.61786] → [29.61786:61867]

B:BD[29.61786] → [46.70352:70433]

B:BD[29.61640] → [29.61640:61715]

B:BD[29.61640] → [46.70276:70351]

B:BD[20.59724] → [44.8071:8153]

B:BD[20.59724] → [22.20765:20847]

B:BD[20.59724] → [33.15411:15493]

B:BD[20.59724] → [48.32382:32464]

B:BD[20.59724] → [49.36906:37215]

B:BD[20.59724] → [50.9193:9275]

B:BD[20.59724] → [51.12399:12481]

B:BD[20.59724] → [20.59724:59806]

B:BD[20.59806] → [20.59806:59881]

B:BD[20.59724] → [53.21470:21552]

B:BD[20.59724] → [54.24734:24816]

B:BD[20.59724] → [55.50141:50223]

B:BD[20.59724] → [37.20483:20565]

B:BD[20.59624] → [43.40465:40484]

B:BD[20.59624] → [29.61538:61557]

B:BD[20.59624] → [22.20746:20764]

B:BD[20.59624] → [49.36887:36905]

B:BD[20.59624] → [20.59624:59642]

B:BD[20.59642] → [20.59642:59724]

B:BD[20.59588] → [20.59588:59624]

B:BD[24.19987] → [24.19987:20068]

B:BD[20.59291] → [24.19771:19841]

B:BD[24.19841] → [24.19841:19916]

B:BD[22.20673] → [140.2083:2159]

B:BD[43.40383] → [43.40383:40464]

B:BD[43.40383] → [30.28214:28295]

B:BD[22.20673] → [70.11344:11420]

B:BD[22.20673] → [43.40166:40241]

B:BD[43.40241] → [43.40241:40383]

B:BD[22.20673] → [29.61238:61456]

B:BD[29.61456] → [29.61456:61537]

B:BD[29.61456] → [46.70194:70275]

B:BD[22.20673] → [47.20376:20451]

B:BD[24.19916] → [22.20674:20745]

B:BD[20.59291] → [22.20603:20673]

B:BD[22.20673] → [48.32154:32381]

B:BD[22.20673] → [30.28137:28213]

B:BD[22.20673] → [49.36659:36886]

B:BD[20.59291] → [20.59291:59361]

B:BD[20.59436] → [20.59436:59588]

B:BD[20.59361] → [40.17154:17229]

B:BD[20.59361] → [41.11987:12062]

B:BD[20.59361] → [111.11596:11671]

B:BD[20.59361] → [42.32239:32466]

B:BD[20.59361] → [44.7995:8070]

B:BD[20.59361] → [33.15335:15410]

B:BD[20.59361] → [50.9117:9192]

B:BD[20.59361] → [51.12323:12398]

B:BD[20.59361] → [20.59361:59436]

B:BD[20.59361] → [54.24506:24733]

B:BD[20.59361] → [55.49913:50140]

B:BD[20.59361] → [37.20407:20482]

B:BD[22.20673] → [52.15598:15673]

B:BD[22.20673] → [38.23796:23872]

B:BD[22.20673] → [53.21242:21469]

B:BD[22.20673] → [71.6530:6605]

B:BD[20.59052] → [40.16989:17153]

B:BD[20.59052] → [41.11822:11986]

B:BD[20.59052] → [70.11179:11343]

B:BD[43.40165] → [30.28061:28136]

B:BD[20.59052] → [111.11431:11595]

B:BD[20.59052] → [42.31990:32238]

B:BD[20.59052] → [43.39841:40083]

B:BD[43.40083] → [43.40083:40165]

B:BD[20.59052] → [29.60916:61162]

B:BD[29.61162] → [29.61162:61237]

B:BD[29.61162] → [46.70118:70193]

B:BD[20.59052] → [44.7830:7994]

B:BD[20.59052] → [47.20133:20375]

B:BD[20.59052] → [22.20438:20602]

B:BD[20.59052] → [33.15170:15334]

B:BD[20.59052] → [48.31905:32153]

B:BD[20.59052] → [30.27896:28060]

B:BD[20.59052] → [49.36419:36658]

B:BD[20.59052] → [50.8952:9116]

B:BD[20.59052] → [51.12158:12322]

B:BD[20.59052] → [20.59052:59216]

B:BD[20.59216] → [20.59216:59291]

B:BD[20.59052] → [52.15355:15597]

B:BD[20.59052] → [38.23631:23795]

B:BD[20.59052] → [53.21077:21241]

B:BD[20.59052] → [54.24341:24505]

B:BD[20.59052] → [55.49664:49912]

B:BD[20.59052] → [37.20242:20406]

B:BD[20.58952] → [70.11159:11178]

B:BD[20.58952] → [42.31970:31989]

B:BD[20.58952] → [43.39821:39840]

B:BD[20.58952] → [29.60896:60915]

B:BD[20.58952] → [46.70098:70117]

B:BD[20.58952] → [47.20113:20132]

B:BD[20.58952] → [22.20419:20437]

B:BD[20.58952] → [48.31885:31904]

B:BD[20.58952] → [30.27876:27895]

B:BD[20.58952] → [49.36400:36418]

B:BD[20.58952] → [20.58952:58970]

B:BD[20.58970] → [20.58970:59052]

B:BD[20.58911] → [20.58911:58952]

B:BD[20.58952] → [52.15335:15354]

B:BD[20.58952] → [38.23611:23630]

B:BD[20.58952] → [53.21058:21076]

B:BD[20.58952] → [54.24322:24340]

B:BD[20.58952] → [55.49644:49663]

B:BD[24.19506] → [24.19506:19586]

B:BD[24.19506] → [22.20338:20418]

B:BD[20.58755] → [70.11002:11158]

B:BD[20.58755] → [42.31813:31969]

B:BD[20.58755] → [43.39664:39820]

B:BD[20.58755] → [29.60739:60895]

B:BD[20.58755] → [47.19956:20112]

B:BD[20.58755] → [48.31728:31884]

B:BD[20.58755] → [30.27719:27875]

B:BD[20.58755] → [49.36243:36399]

B:BD[20.58755] → [20.58755:58911]

B:BD[20.58612] → [20.58612:58755]

B:BD[20.58755] → [52.15178:15334]

B:BD[20.58755] → [38.23454:23610]

B:BD[20.58755] → [53.20901:21057]

B:BD[20.58755] → [54.24165:24321]

B:BD[20.58755] → [55.49487:49643]

B:BD[20.58464] → [92.8322:8395]

B:BD[20.58464] → [70.10928:11001]

B:BD[20.58464] → [29.60590:60738]

B:BD[20.58464] → [46.69949:70097]

B:BD[20.58464] → [47.19882:19955]

B:BD[20.58464] → [22.20264:20337]

B:BD[20.58464] → [30.27570:27718]

B:BD[20.58464] → [49.36094:36242]

B:BD[20.58464] → [20.58464:58537]

B:BD[20.58537] → [20.58537:58612]

B:BD[20.58464] → [39.8188:8261]

B:BD[20.58364] → [42.31794:31812]

B:BD[20.58364] → [43.39645:39663]

B:BD[20.58364] → [29.60571:60589]

B:BD[20.58364] → [48.31709:31727]

B:BD[20.58364] → [49.36075:36093]

B:BD[20.58364] → [20.58364:58382]

B:BD[20.58382] → [20.58382:58464]

B:BD[20.58364] → [53.20882:20900]

B:BD[20.58364] → [54.24146:24164]

B:BD[20.58364] → [55.49468:49486]

B:BD[43.39487] → [43.39487:39569]

B:BD[43.39569] → [30.27424:27569]

B:BD[20.58345] → [20.58345:58364]

B:BD[20.58330] → [20.58330:58345]

B:BD[43.39569] → [38.23383:23453]

B:BD[43.39469] → [92.8303:8321]

B:BD[43.39469] → [70.10838:10856]

B:BD[43.39469] → [43.39469:39487]

B:BD[43.39469] → [47.19863:19881]

B:BD[43.39469] → [30.27405:27423]

B:BD[43.39469] → [52.15159:15177]

B:BD[43.39469] → [38.23364:23382]

B:BD[20.58330] → [43.39434:39449]

B:BD[24.19256] → [22.20183:20263]

B:BD[24.19099] → [24.19099:19256]

B:BD[20.58257] → [20.58257:58330]

B:BD[20.57942] → [40.16910:16988]

B:BD[20.57942] → [41.11743:11821]

B:BD[20.57942] → [70.10602:10680]

B:BD[43.39277] → [70.10681:10837]

B:BD[43.39277] → [43.39277:39433]

B:BD[43.39277] → [47.19706:19862]

B:BD[43.39277] → [52.15002:15158]

B:BD[43.39277] → [38.23207:23363]

B:BD[20.57942] → [42.31478:31793]

B:BD[20.57942] → [43.39118:39196]

B:BD[43.39196] → [43.39196:39277]

B:BD[20.57942] → [29.59902:59980]

B:BD[29.60061] → [29.60061:60217]

B:BD[29.60290] → [29.60290:60325]

B:BD[29.60343] → [29.60343:60495]

B:BD[29.60495] → [29.60495:60570]

B:BD[29.60495] → [46.69873:69948]

B:BD[29.60325] → [29.60325:60343]

B:BD[29.60325] → [46.69854:69872]

B:BD[29.60217] → [29.60217:60290]

B:BD[29.60217] → [46.69780:69853]

B:BD[29.59980] → [29.59980:60061]

B:BD[29.59980] → [46.69698:69779]

B:BD[20.57942] → [44.7751:7829]

B:BD[20.57942] → [47.19627:19705]

B:BD[20.57942] → [22.20104:20182]

B:BD[20.57942] → [33.15091:15169]

B:BD[20.57942] → [48.31393:31708]

B:BD[20.57942] → [30.27016:27404]

B:BD[20.57942] → [49.35686:36074]

B:BD[20.57942] → [51.12079:12157]

B:BD[20.57942] → [20.57942:58020]

B:BD[20.58020] → [20.58020:58257]

B:BD[20.57942] → [52.14923:15001]

B:BD[20.57942] → [38.23128:23206]

B:BD[20.57942] → [53.20566:20881]

B:BD[20.57942] → [54.23830:24145]

B:BD[20.57942] → [55.49152:49467]

B:BD[20.57942] → [37.20163:20241]

B:BD[20.57650] → [46.69550:69697]

B:BD[20.57650] → [30.26868:27015]

B:BD[20.57650] → [49.35538:35685]

B:BD[20.57650] → [20.57650:57725]

B:BD[20.57797] → [20.57797:57942]

B:BD[20.57725] → [24.18948:19020]

B:BD[20.57725] → [40.16837:16909]

B:BD[20.57725] → [41.11670:11742]

B:BD[20.57725] → [92.8230:8302]

B:BD[20.57725] → [70.10529:10601]

B:BD[20.57725] → [111.11358:11430]

B:BD[20.57725] → [42.31405:31477]

B:BD[20.57725] → [43.39045:39117]

B:BD[20.57725] → [44.7678:7750]

B:BD[20.57725] → [47.19554:19626]

B:BD[20.57725] → [22.20031:20103]

B:BD[20.57725] → [33.15018:15090]

B:BD[20.57725] → [48.31320:31392]

B:BD[20.57725] → [50.8879:8951]

B:BD[20.57725] → [51.12006:12078]

B:BD[20.57725] → [20.57725:57797]

B:BD[20.57725] → [52.14850:14922]

B:BD[20.57725] → [38.23055:23127]

B:BD[20.57725] → [53.20493:20565]

B:BD[20.57725] → [54.23757:23829]

B:BD[20.57725] → [55.49079:49151]

B:BD[20.57725] → [37.20090:20162]

B:BD[20.57725] → [39.8115:8187]

B:BD[20.57550] → [22.20012:20030]

B:BD[20.57550] → [20.57550:57568]

B:BD[20.57568] → [20.57568:57650]

B:BD[20.57132] → [40.16761:16836]

B:BD[20.57513] → [20.57513:57550]

B:BD[20.57132] → [41.11594:11669]

B:BD[20.57132] → [140.2006:2082]

B:BD[43.38887] → [43.38887:38968]

B:BD[38.22977] → [92.8152:8229]

B:BD[38.22977] → [38.22977:23054]

B:BD[43.38968] → [70.10375:10528]

B:BD[43.38968] → [43.38968:39044]

B:BD[43.38968] → [47.19477:19553]

B:BD[43.38968] → [52.14773:14849]

B:BD[43.38968] → [38.22901:22977]

B:BD[43.38887] → [30.26633:26867]

B:BD[20.57132] → [70.10298:10374]

B:BD[20.57132] → [111.11282:11357]

B:BD[20.57132] → [42.31023:31404]

B:BD[20.57132] → [43.38663:38738]

B:BD[43.38738] → [43.38738:38887]

B:BD[29.59519] → [29.59519:59600]

B:BD[29.59676] → [29.59676:59753]

B:BD[29.59676] → [46.69472:69549]

B:BD[29.59600] → [29.59600:59676]

B:BD[20.57132] → [29.59294:59519]

B:BD[20.57132] → [44.7602:7677]

B:BD[29.59519] → [46.69390:69471]

B:BD[20.57132] → [47.19401:19476]

B:BD[20.57132] → [33.14942:15017]

B:BD[20.57132] → [48.30938:31319]

B:BD[20.57132] → [30.26556:26632]

B:BD[20.57132] → [49.35156:35537]

B:BD[20.57132] → [50.8803:8878]

B:BD[20.57132] → [51.11930:12005]

B:BD[20.57132] → [20.57132:57207]

B:BD[20.57207] → [20.57207:57513]

B:BD[20.57132] → [52.14697:14772]

B:BD[20.57132] → [38.22824:22900]

B:BD[20.57132] → [53.20111:20492]

B:BD[20.57132] → [54.23375:23756]

B:BD[20.57132] → [55.48697:49078]

B:BD[20.57132] → [37.20014:20089]

B:BD[20.57132] → [71.6454:6529]

B:BD[20.56913] → [70.10219:10297]

B:BD[20.57061] → [20.57061:57132]

B:BD[20.56913] → [47.19322:19400]

B:BD[20.56913] → [22.19863:19941]

B:BD[22.19941] → [22.19941:20011]

B:BD[20.56913] → [20.56913:57061]

B:BD[20.56913] → [52.14618:14696]

B:BD[20.56913] → [38.22745:22823]

B:BD[20.56756] → [40.16678:16760]

B:BD[20.56756] → [41.11511:11593]

B:BD[20.56756] → [111.11199:11281]

B:BD[20.56756] → [42.30940:31022]

B:BD[20.56756] → [43.38580:38662]

B:BD[43.38662] → [30.26402:26555]

B:BD[20.56756] → [29.59058:59140]

B:BD[29.59215] → [29.59215:59293]

B:BD[29.59140] → [29.59140:59215]

B:BD[29.59140] → [46.69314:69389]

B:BD[20.56756] → [44.7519:7601]

B:BD[20.56756] → [22.19780:19862]

B:BD[20.56756] → [33.14859:14941]

B:BD[20.56756] → [48.30855:30937]

B:BD[20.56756] → [49.34920:35155]

B:BD[20.56756] → [50.8720:8802]

B:BD[20.56756] → [51.11847:11929]

B:BD[20.56756] → [20.56756:56838]

B:BD[20.56838] → [20.56838:56913]

B:BD[20.56756] → [53.20028:20110]

B:BD[20.56756] → [54.23292:23374]

B:BD[20.56756] → [55.48614:48696]

B:BD[20.56756] → [37.19931:20013]

B:BD[20.56656] → [70.10200:10218]

B:BD[20.56656] → [42.30921:30939]

B:BD[20.56656] → [43.38561:38579]

B:BD[20.56656] → [29.59039:59057]

B:BD[20.56656] → [47.19303:19321]

B:BD[20.56656] → [22.19761:19779]

B:BD[20.56656] → [48.30836:30854]

B:BD[20.56656] → [30.26383:26401]

B:BD[20.56656] → [49.34901:34919]

B:BD[20.56656] → [20.56656:56674]

B:BD[20.56674] → [20.56674:56756]

B:BD[20.56656] → [52.14599:14617]

B:BD[20.56656] → [38.22726:22744]

B:BD[20.56656] → [53.20009:20027]

B:BD[20.56656] → [54.23273:23291]

B:BD[20.56656] → [55.48595:48613]

B:BD[20.56548] → [22.19690:19760]

B:BD[20.56618] → [20.56618:56656]

B:BD[20.56548] → [20.56548:56618]

B:BD[20.56400] → [92.8078:8151]

B:BD[20.56400] → [70.10126:10199]

B:BD[20.56400] → [29.58890:59038]

B:BD[20.56400] → [46.69165:69313]

B:BD[20.56400] → [47.19229:19302]

B:BD[20.56400] → [22.19616:19689]

B:BD[20.56400] → [30.26234:26382]

B:BD[20.56400] → [49.34752:34900]

B:BD[20.56400] → [20.56400:56473]

B:BD[20.56473] → [20.56473:56548]

B:BD[20.56400] → [39.8041:8114]

B:BD[20.56299] → [70.10106:10125]

B:BD[20.56299] → [42.30901:30920]

B:BD[20.56299] → [43.38541:38560]

B:BD[20.56299] → [29.58870:58889]

B:BD[20.56299] → [47.19209:19228]

B:BD[20.56299] → [48.30816:30835]

B:BD[20.56299] → [30.26214:26233]

B:BD[20.56299] → [49.34732:34751]

B:BD[20.56299] → [20.56299:56318]

B:BD[20.56318] → [20.56318:56400]

B:BD[20.56299] → [52.14579:14598]

B:BD[20.56299] → [38.22706:22725]

B:BD[20.56299] → [53.19989:20008]

B:BD[20.56299] → [54.23253:23272]

B:BD[20.56299] → [55.48575:48594]

B:BD[29.58785] → [46.69080:69164]

B:BD[29.58709] → [29.58709:58785]

B:BD[20.56266] → [20.56266:56299]

B:BD[20.56032] → [46.69004:69079]

B:BD[20.56032] → [30.25978:26213]

B:BD[20.56032] → [49.34497:34731]

B:BD[20.56032] → [20.56032:56107]

B:BD[24.18047] → [24.18047:18130]

B:BD[24.18047] → [22.19532:19615]

B:BD[20.56107] → [24.17971:18047]

B:BD[20.56107] → [70.9945:10105]

B:BD[20.56107] → [42.30740:30900]

B:BD[20.56107] → [43.38380:38540]

B:BD[20.56107] → [47.19048:19208]

B:BD[20.56107] → [48.30655:30815]

B:BD[20.56107] → [20.56107:56266]

B:BD[20.56107] → [52.14418:14578]

B:BD[20.56107] → [38.22545:22705]

B:BD[20.56107] → [53.19829:19988]

B:BD[20.56107] → [54.23093:23252]

B:BD[20.56107] → [55.48414:48574]

B:BD[20.55932] → [70.9926:9944]

B:BD[20.55932] → [42.30721:30739]

B:BD[20.55932] → [43.38361:38379]

B:BD[20.55932] → [29.58615:58633]

B:BD[20.55932] → [47.19029:19047]

B:BD[20.55932] → [48.30636:30654]

B:BD[20.55932] → [30.25959:25977]

B:BD[20.55932] → [49.34478:34496]

B:BD[20.55932] → [20.55932:55950]

B:BD[20.55950] → [20.55950:56032]

B:BD[20.55899] → [20.55899:55932]

B:BD[20.55932] → [52.14399:14417]

B:BD[20.55932] → [38.22526:22544]

B:BD[20.55932] → [53.19810:19828]

B:BD[20.55932] → [54.23074:23092]

B:BD[20.55932] → [55.48395:48413]

B:BD[20.55824] → [43.38278:38360]

B:BD[43.38360] → [30.25883:25958]

B:BD[20.55824] → [29.58457:58539]

B:BD[29.58539] → [29.58539:58614]

B:BD[29.58539] → [46.68928:69003]

B:BD[20.55824] → [48.30553:30635]

B:BD[20.55824] → [49.34402:34477]

B:BD[20.55824] → [20.55824:55899]

B:BD[20.55824] → [55.48312:48394]

B:BD[20.55724] → [42.30619:30637]

B:BD[20.55724] → [43.38259:38277]

B:BD[20.55724] → [29.58438:58456]

B:BD[20.55724] → [46.68909:68927]

B:BD[20.55724] → [48.30534:30552]

B:BD[20.55724] → [30.25864:25882]

B:BD[20.55724] → [49.34383:34401]

B:BD[20.55724] → [20.55724:55742]

B:BD[20.55742] → [20.55742:55824]

B:BD[20.55724] → [53.19791:19809]

B:BD[20.55724] → [54.23055:23073]

B:BD[20.55724] → [55.48293:48311]

B:BD[20.55529] → [46.68752:68908]

B:BD[20.55529] → [30.25707:25863]

B:BD[20.55529] → [49.34226:34382]

B:BD[20.55529] → [20.55529:55604]

B:BD[20.55685] → [20.55685:55724]

B:BD[20.55604] → [24.17851:17932]

B:BD[20.55604] → [42.30537:30618]

B:BD[20.55604] → [43.38177:38258]

B:BD[20.55604] → [48.30452:30533]

B:BD[20.55604] → [20.55604:55685]

B:BD[20.55604] → [53.19709:19790]

B:BD[20.55604] → [54.22973:23054]

B:BD[20.55604] → [55.48211:48292]

B:BD[20.55429] → [70.9907:9925]

B:BD[20.55429] → [29.58262:58280]

B:BD[20.55429] → [46.68733:68751]

B:BD[20.55429] → [47.19010:19028]

B:BD[20.55429] → [22.19513:19531]

B:BD[20.55429] → [30.25688:25706]

B:BD[20.55429] → [49.34207:34225]

B:BD[20.55429] → [20.55429:55447]

B:BD[20.55447] → [20.55447:55529]

B:BD[20.55429] → [52.14380:14398]

B:BD[20.55429] → [38.22507:22525]

B:BD[15.52804] → [15.52804:52957]

B:BD[15.52958] → [20.55387:55429]

B:BD[15.52731] → [15.52731:52804]

B:BD[15.52731] → [137.10950:11023]

B:BD[15.52731] → [25.14011:14084]

B:BD[15.52731] → [16.10723:10796]

B:BD[15.52731] → [26.15517:15590]

B:BD[15.52731] → [27.11797:11870]

B:BD[15.52438] → [20.54867:55024]

B:BD[20.55160] → [24.17681:17754]

B:BD[20.55308] → [24.17755:17831]

B:BD[20.55308] → [70.9830:9906]

B:BD[20.55308] → [42.30460:30536]

B:BD[20.55308] → [43.38100:38176]

B:BD[20.55308] → [47.18933:19009]

B:BD[20.55308] → [48.30375:30451]

B:BD[20.55308] → [20.55308:55384]

B:BD[20.55384] → [20.55384:55386]

B:BD[20.55308] → [52.14303:14379]

B:BD[20.55308] → [38.22430:22506]

B:BD[20.55308] → [53.19632:19708]

B:BD[20.55308] → [54.22896:22972]

B:BD[20.55308] → [55.48134:48210]

B:BD[20.55160] → [92.8004:8077]

B:BD[20.55160] → [70.9756:9829]

B:BD[29.58185] → [29.58185:58261]

B:BD[20.55160] → [29.58037:58185]

B:BD[20.55160] → [46.68584:68732]

B:BD[20.55160] → [47.18859:18932]

B:BD[20.55160] → [22.19439:19512]

B:BD[20.55160] → [30.25463:25687]

B:BD[20.55160] → [49.33982:34206]

B:BD[20.55160] → [20.55160:55233]

B:BD[20.55233] → [20.55233:55308]

B:BD[20.55160] → [39.7967:8040]

B:BD[20.55024] → [20.55024:55160]

B:BD[15.52420] → [15.52420:52438]

B:BD[15.52069] → [15.52069:52382]

B:BD[15.52069] → [137.10636:10949]

B:BD[15.52069] → [25.13697:14010]

B:BD[15.52069] → [16.10409:10722]

B:BD[15.52069] → [26.15203:15516]

B:BD[15.52069] → [27.11483:11796]

B:BD[15.51913] → [15.51913:51993]

B:BD[15.51913] → [137.10555:10635]

B:BD[15.51913] → [25.13616:13696]

B:BD[15.51913] → [16.10328:10408]

B:BD[15.51913] → [26.15122:15202]

B:BD[15.51913] → [27.11402:11482]

B:BD[15.51594] → [15.51594:51681]

B:BD[15.51594] → [137.10467:10554]

B:BD[15.51594] → [25.13528:13615]

B:BD[15.51594] → [16.10240:10327]

B:BD[15.51594] → [26.15034:15121]

B:BD[15.51594] → [27.11314:11401]

B:BD[15.51516] → [137.10391:10466]

B:BD[15.51516] → [109.5857:5932]

B:BD[15.51516] → [26.14958:15033]

B:BD[15.51516] → [27.11238:11313]

B:BD[15.51297] → [15.51297:51370]

B:BD[15.51297] → [137.10317:10390]

B:BD[15.51297] → [25.13454:13527]

B:BD[15.51297] → [16.10166:10239]

B:BD[15.51297] → [26.14884:14957]

B:BD[15.51297] → [27.11164:11237]

B:BD[15.51196] → [15.51196:51215]

B:BD[15.51196] → [137.10297:10316]

B:BD[15.51196] → [25.13434:13453]

B:BD[15.51196] → [16.10146:10165]

B:BD[15.51196] → [26.14864:14883]

B:BD[15.51196] → [27.11144:11163]

B:BD[27.11062] → [27.11062:11143]

B:BD[15.50940] → [15.50940:51093]

B:BD[15.50940] → [137.10143:10296]

B:BD[15.50940] → [25.13280:13433]

B:BD[15.50940] → [16.9992:10145]

B:BD[15.50940] → [109.5703:5856]

B:BD[15.50940] → [26.14710:14863]

B:BD[15.50940] → [27.10990:11062]

B:BD[15.50940] → [138.2693:2765]

B:BD[15.50839] → [15.50839:50858]

B:BD[15.50839] → [109.5683:5702]

B:BD[15.50839] → [26.14690:14709]

B:BD[15.50732] → [15.50732:50810]

B:BD[15.50732] → [137.10064:10142]

B:BD[15.50732] → [25.13201:13279]

B:BD[15.50732] → [16.9913:9991]

B:BD[15.50732] → [26.14611:14689]

B:BD[15.50732] → [27.10911:10989]

B:BD[27.10829] → [27.10829:10910]

B:BD[15.50148] → [15.50148:50301]

B:BD[15.50148] → [137.9910:10063]

B:BD[15.50148] → [25.13047:13200]

B:BD[15.50148] → [16.9759:9912]

B:BD[15.50148] → [109.5529:5682]

B:BD[15.50148] → [26.14457:14610]

B:BD[15.50148] → [27.10757:10829]

B:BD[15.50148] → [138.2620:2692]

B:BD[15.49494] → [15.49494:49512]

B:BD[15.49494] → [25.13028:13046]

B:BD[15.49494] → [109.5510:5528]

B:BD[15.49494] → [26.14438:14456]

B:BD[15.49494] → [138.2601:2619]

B:BD[26.14285] → [26.14285:14356]

B:BD[26.14356] → [109.5428:5509]

B:BD[26.14356] → [26.14356:14437]

B:BD[27.10604] → [27.10604:10756]

B:BD[15.49084] → [15.49084:49308]

B:BD[15.49084] → [137.9685:9909]

B:BD[15.49084] → [25.12803:13027]

B:BD[15.49084] → [16.9534:9758]

B:BD[15.49084] → [109.5355:5427]

B:BD[15.49084] → [26.14213:14285]

B:BD[15.49084] → [27.10532:10604]

B:BD[15.49084] → [138.2528:2600]

B:BD[15.48911] → [15.48911:48929]

B:BD[15.48911] → [137.9666:9684]

B:BD[15.48911] → [25.12784:12802]

B:BD[15.48911] → [16.9515:9533]

B:BD[15.48911] → [26.14194:14212]

B:BD[15.48911] → [27.10513:10531]

B:BD[26.14121] → [109.5282:5354]

B:BD[26.14121] → [26.14121:14193]

B:BD[15.48577] → [15.48577:48800]

B:BD[15.48577] → [137.9441:9665]

B:BD[15.48577] → [25.12560:12783]

B:BD[15.48577] → [16.9291:9514]

B:BD[15.48577] → [26.13969:14121]

B:BD[15.48577] → [27.10288:10512]

B:BD[15.48476] → [15.48476:48495]

B:BD[15.48476] → [137.9421:9440]

B:BD[15.48476] → [25.12540:12559]

B:BD[15.48476] → [16.9271:9290]

B:BD[15.48476] → [26.13949:13968]

B:BD[15.48476] → [27.10268:10287]

B:BD[9.60736] → [9.60736:61610]

B:BD[9.76696] → [12.4564:4717]

B:BD[9.72552] → [12.4412:4563]

B:BD[9.84002] → [13.3665:3821]

B:BD[9.90008] → [9.90008:90768]

B:BD[9.89837] → [9.89837:90008]

B:BD[9.88314] → [9.88314:89837]

B:BD[9.87083] → [9.87083:88314]

B:BD[9.84002] → [9.84002:87083]

B:BD[9.83705] → [9.83705:84002]

B:BD[9.83403] → [9.83403:83705]

B:BD[9.77904] → [9.77904:83403]

B:BD[9.76696] → [9.76696:77904]

B:BD[9.72552] → [9.72552:76696]

B:BD[9.69251] → [9.69251:72552]

B:BD[9.66492] → [9.66492:69251]

B:BD[9.90008] → [19.4773:4924]

B:BD[9.89837] → [19.4618:4772]

B:BD[9.88314] → [19.4463:4617]

B:BD[9.87083] → [19.4311:4462]

B:BD[9.83705] → [19.4155:4310]

B:BD[9.83403] → [19.4002:4154]

B:BD[9.77904] → [19.3698:4001]

B:BD[9.69251] → [19.3545:3697]

B:BD[9.66492] → [19.3390:3544]

B:BD[9.61610] → [9.61610:66492]

B:BD[9.61610] → [19.3234:3389]

B:BD[15.48152] → [15.48152:48232]

B:BD[15.48001] → [137.9268:9420]

B:BD[15.48001] → [25.12388:12539]

B:BD[15.48001] → [16.9119:9270]

B:BD[15.48001] → [26.13796:13948]

B:BD[15.48001] → [27.10115:10267]

B:BD[15.47919] → [15.47919:48001]

B:BD[15.47899] → [137.9247:9267]

B:BD[15.47899] → [25.12367:12387]

B:BD[15.47899] → [16.9098:9118]

B:BD[15.47899] → [109.5261:5281]

B:BD[15.47899] → [26.13775:13795]

B:BD[15.47899] → [27.10094:10114]

B:BD[15.47194] → [15.47194:47899]

B:BD[15.47043] → [137.9094:9246]

B:BD[15.47043] → [25.12215:12366]

B:BD[15.47043] → [16.8946:9097]

B:BD[15.47043] → [26.13622:13774]

B:BD[15.47043] → [27.9941:10093]

B:BD[15.46566] → [15.46566:47043]

B:BD[15.46493] → [25.12141:12214]

B:BD[15.46493] → [109.5187:5260]

B:BD[15.46493] → [26.13548:13621]

B:BD[15.46493] → [138.2454:2527]

B:BD[15.46244] → [15.46244:46493]

B:BD[15.46166] → [137.9015:9093]

B:BD[15.46166] → [25.12062:12140]

B:BD[15.46166] → [16.8867:8945]

B:BD[15.46166] → [26.13469:13547]

B:BD[15.46166] → [27.9862:9940]

B:BD[15.45966] → [15.45966:46166]

B:BD[15.45948] → [137.8996:9014]

B:BD[15.45948] → [25.12043:12061]

B:BD[15.45948] → [16.8848:8866]

B:BD[15.45948] → [26.13450:13468]

B:BD[15.45948] → [27.9843:9861]

B:BD[15.45720] → [15.45720:45948]

B:BD[15.45567] → [137.8842:8995]

B:BD[15.45567] → [25.11889:12042]

B:BD[15.45567] → [16.8694:8847]

B:BD[15.45567] → [109.5033:5186]

B:BD[15.45567] → [26.13296:13449]

B:BD[15.45567] → [27.9689:9761]

B:BD[27.9761] → [27.9761:9842]

B:BD[15.45567] → [138.2381:2453]

B:BD[15.45202] → [15.45202:45567]

B:BD[15.45184] → [139.367:385]

B:BD[15.45184] → [137.8823:8841]

B:BD[15.45184] → [25.11870:11888]

B:BD[15.45184] → [16.8675:8693]

B:BD[15.45184] → [109.5014:5032]

B:BD[15.45184] → [26.13277:13295]

B:BD[15.45184] → [27.9670:9688]

B:BD[15.44926] → [15.44926:45184]

B:BD[15.44779] → [137.8675:8822]

B:BD[15.44779] → [25.11722:11869]

B:BD[15.44779] → [16.8527:8674]

B:BD[15.44779] → [26.13129:13204]

B:BD[26.13204] → [109.4941:5013]

B:BD[26.13204] → [26.13204:13276]

B:BD[15.44779] → [27.9522:9597]

B:BD[27.9597] → [27.9597:9669]

B:BD[27.9597] → [138.2308:2380]

B:BD[15.44697] → [15.44697:44779]

B:BD[15.43343] → [15.43343:44679]

B:BD[15.44679] → [137.8656:8674]

B:BD[15.44679] → [25.11703:11721]

B:BD[15.44679] → [16.8508:8526]

B:BD[15.44679] → [26.13110:13128]

B:BD[15.44679] → [27.9503:9521]

B:BD[15.43270] → [15.43270:43343]

B:BD[15.43200] → [137.8585:8655]

B:BD[15.43200] → [25.11559:11702]

B:BD[15.43200] → [16.8437:8507]

B:BD[15.43200] → [26.12966:13036]

B:BD[26.13036] → [109.4867:4940]

B:BD[26.13036] → [26.13036:13109]

B:BD[15.43200] → [27.9432:9502]

B:BD[27.9502] → [138.2234:2307]

B:BD[15.43047] → [15.43047:43200]

B:BD[15.43028] → [137.8565:8584]

B:BD[15.43028] → [25.11539:11558]

B:BD[15.43028] → [16.8417:8436]

B:BD[15.43028] → [26.12946:12965]

B:BD[15.43028] → [27.9412:9431]

B:BD[15.42993] → [15.42993:43028]

B:BD[15.42770] → [137.8340:8564]

B:BD[15.42770] → [25.11315:11538]

B:BD[15.42770] → [16.8193:8416]

B:BD[15.42770] → [26.12721:12873]

B:BD[26.12873] → [109.4794:4866]

B:BD[26.12873] → [26.12873:12945]

B:BD[15.42770] → [27.9187:9411]

B:BD[15.42688] → [15.42688:42770]

B:BD[15.42669] → [25.11295:11314]

B:BD[15.42669] → [109.4774:4793]

B:BD[15.42669] → [26.12701:12720]

B:BD[15.42669] → [138.2214:2233]

B:BD[15.42569] → [15.42569:42669]

B:BD[15.42550] → [25.11275:11294]

B:BD[15.42550] → [109.4754:4773]

B:BD[15.42550] → [26.12681:12700]

B:BD[15.42550] → [138.2194:2213]

B:BD[15.42440] → [15.42440:42550]

B:BD[15.42369] → [137.8268:8339]

B:BD[15.42369] → [25.11203:11274]

B:BD[15.42369] → [28.1243:1315]

B:BD[15.42369] → [16.8121:8192]

B:BD[15.42369] → [26.12608:12680]

B:BD[15.42369] → [27.9115:9186]

B:BD[15.42292] → [15.42292:42369]

B:BD[15.42133] → [15.42133:42213]

B:BD[15.42213] → [137.8188:8267]

B:BD[15.42213] → [25.11123:11202]

B:BD[15.42213] → [16.8041:8120]

B:BD[15.42213] → [26.12528:12607]

B:BD[15.42213] → [27.9035:9114]

B:BD[15.42060] → [15.42060:42133]

B:BD[15.42060] → [137.8114:8187]

B:BD[15.42060] → [16.7967:8040]

B:BD[15.42060] → [27.8961:9034]

B:BD[15.41907] → [25.10896:11122]

B:BD[15.41907] → [109.4600:4753]

B:BD[15.41907] → [26.12301:12454]

B:BD[26.12454] → [26.12454:12527]

B:BD[15.41907] → [138.2040:2193]

B:BD[15.41833] → [15.41833:41907]

B:BD[15.41611] → [137.7892:8113]

B:BD[15.41611] → [25.10673:10895]

B:BD[15.41611] → [16.7744:7966]

B:BD[9.60735] → [9.60735:60736]

B:BD[9.59615] → [9.59615:60735]

B:BD[9.59481] → [9.59481:59615]

B:BD[9.59416] → [9.59416:59481]

B:BD[9.57895] → [9.57895:59416]

B:BD[15.41611] → [26.12005:12156]

B:BD[26.12230] → [26.12230:12300]

B:BD[26.12156] → [109.4525:4599]

B:BD[26.12156] → [26.12156:12230]

B:BD[9.59615] → [19.2949:3233]

B:BD[9.59481] → [19.2856:2948]

B:BD[9.59416] → [19.2738:2855]

B:BD[9.57895] → [19.2620:2737]

B:BD[15.41611] → [27.8665:8816]

B:BD[27.8890] → [27.8890:8960]

B:BD[27.8816] → [28.1168:1242]

B:BD[27.8816] → [27.8816:8890]

B:BD[9.57143] → [15.41522:41611]

B:BD[9.57143] → [9.57143:57895]

B:BD[9.56530] → [9.56530:57125]

B:BD[9.45320] → [9.45320:56530]

B:BD[9.43748] → [9.43748:45320]

B:BD[9.43169] → [9.43169:43748]

B:BD[10.12257] → [9.42243:43169]

B:BD[9.35655] → [9.35655:42242]

B:BD[9.35429] → [9.35429:35655]

B:BD[9.35355] → [9.35355:35429]

B:BD[10.12256] → [9.35266:35355]

B:BD[9.56530] → [19.2505:2619]

B:BD[9.43748] → [19.2289:2504]

B:BD[9.43169] → [19.2079:2288]

B:BD[9.35429] → [19.2008:2078]

B:BD[9.35355] → [19.1929:2007]

B:BD[10.12238] → [10.12238:12256]

B:BD[10.12238] → [20.43797:43815]

B:BD[20.45568] → [24.13905:13975]

B:BD[24.13975] → [24.13975:14048]

B:BD[20.45396] → [24.13885:13904]

B:BD[20.45137] → [24.13661:13884]

B:BD[20.45036] → [24.13641:13660]

B:BD[20.44917] → [24.13621:13640]

B:BD[24.13549] → [24.13549:13620]

B:BD[24.13167] → [24.13167:13320]

B:BD[24.13472] → [24.13472:13549]

B:BD[22.16113] → [43.33931:34006]

B:BD[43.34006] → [92.6989:7069]

B:BD[43.34006] → [43.34006:34086]

B:BD[43.34006] → [47.16599:16679]

B:BD[22.16113] → [22.16113:16268]

B:BD[22.16113] → [48.26381:26536]

B:BD[22.16113] → [53.15838:15993]

B:BD[24.13320] → [24.13320:13472]

B:BD[24.13320] → [22.15808:15881]

B:BD[20.45036] → [40.15425:15444]

B:BD[20.44917] → [40.15405:15424]

B:BD[20.45036] → [41.10258:10277]

B:BD[20.44917] → [41.10238:10257]

B:BD[20.45396] → [31.8633:8652]

B:BD[22.16584] → [140.1414:1487]

B:BD[20.45036] → [140.1394:1413]

B:BD[20.44917] → [140.1374:1393]

B:BD[22.16584] → [70.7807:7880]

B:BD[20.45396] → [70.7787:7806]

B:BD[20.45036] → [70.7694:7713]

B:BD[20.44917] → [70.7674:7693]

B:BD[20.45036] → [111.10040:10059]

B:BD[20.44917] → [111.10020:10039]

B:BD[20.45396] → [42.26887:26906]

B:BD[20.45137] → [42.26662:26886]

B:BD[20.45036] → [42.26642:26661]

B:BD[20.44917] → [42.26622:26641]

B:BD[22.16584] → [43.34372:34445]

B:BD[20.45396] → [43.34352:34371]

B:BD[20.45137] → [43.34127:34206]

B:BD[43.34279] → [92.7070:7142]

B:BD[43.34279] → [70.7714:7786]

B:BD[43.34279] → [43.34279:34351]

B:BD[43.34279] → [47.16720:16792]

B:BD[43.34279] → [52.12384:12456]

B:BD[43.34279] → [38.20608:20680]

B:BD[43.34279] → [39.7215:7287]

B:BD[43.34206] → [43.34206:34279]

B:BD[43.34206] → [30.22152:22297]

B:BD[20.45036] → [43.34107:34126]

B:BD[20.44917] → [43.34087:34106]

B:BD[22.16040] → [43.33853:33930]

B:BD[43.33930] → [92.6917:6988]

B:BD[43.33930] → [47.16526:16598]

B:BD[43.33930] → [30.21960:22111]

B:BD[22.15733] → [43.33551:33626]

B:BD[38.20494] → [92.6843:6916]

B:BD[43.33779] → [43.33779:33852]

B:BD[38.20494] → [38.20494:20567]

B:BD[43.33626] → [140.1220:1373]

B:BD[43.33626] → [70.7447:7673]

B:BD[43.33626] → [43.33626:33779]

B:BD[43.33626] → [47.16299:16525]

B:BD[43.33626] → [30.21733:21959]

B:BD[43.33626] → [52.12117:12343]

B:BD[43.33626] → [38.20341:20494]

B:BD[43.33626] → [71.5571:5724]

B:BD[22.16584] → [29.53263:53336]

B:BD[20.45396] → [29.53243:53262]

B:BD[29.53097] → [29.53097:53242]

B:BD[20.45137] → [29.53018:53097]

B:BD[20.45036] → [29.52998:53017]

B:BD[20.44917] → [29.52978:52997]

B:BD[29.52826] → [29.52826:52977]

B:BD[22.16040] → [29.52749:52826]

B:BD[29.52522] → [29.52522:52748]

B:BD[22.15733] → [29.52447:52522]

B:BD[29.52372] → [29.52372:52446]

B:BD[29.52298] → [29.52298:52372]

B:BD[20.43832] → [29.52149:52298]

B:BD[20.45036] → [44.6266:6285]

B:BD[20.44917] → [44.6246:6265]

B:BD[22.16584] → [46.66374:66447]

B:BD[29.53097] → [46.66228:66373]

B:BD[20.45036] → [46.66208:66227]

B:BD[20.44917] → [46.66188:66207]

B:BD[29.52826] → [46.65960:66187]

B:BD[29.52522] → [46.65733:65959]

B:BD[29.52372] → [46.65658:65732]

B:BD[20.43832] → [46.65508:65657]

B:BD[22.16584] → [47.16813:16886]

B:BD[20.45396] → [47.16793:16812]

B:BD[20.45036] → [47.16700:16719]

B:BD[20.44917] → [47.16680:16699]

B:BD[20.45568] → [22.16514:16584]

B:BD[20.45396] → [22.16494:16513]

B:BD[20.45137] → [22.16269:16493]

B:BD[24.13549] → [22.16041:16113]

B:BD[22.15881] → [22.15881:16040]

B:BD[22.15733] → [22.15733:15807]

B:BD[22.15663] → [22.15663:15733]

B:BD[20.45036] → [33.13606:13625]

B:BD[20.44917] → [33.13586:13605]

B:BD[22.16584] → [48.26822:26895]

B:BD[20.45396] → [48.26802:26821]

B:BD[20.45137] → [48.26577:26801]

B:BD[20.45036] → [48.26557:26576]

B:BD[20.44917] → [48.26537:26556]

B:BD[22.16040] → [48.26303:26380]

B:BD[22.15733] → [48.26001:26302]

B:BD[22.16584] → [30.22318:22391]

B:BD[20.45396] → [30.22298:22317]

B:BD[20.45036] → [30.22132:22151]

B:BD[20.44917] → [30.22112:22131]

B:BD[20.43832] → [30.21508:21657]

B:BD[43.33476] → [140.1145:1219]

B:BD[43.33476] → [70.7372:7446]

B:BD[43.33476] → [43.33476:33550]

B:BD[43.33476] → [47.16224:16298]

B:BD[43.33476] → [30.21658:21732]

B:BD[43.33476] → [52.12042:12116]

B:BD[43.33476] → [38.20266:20340]

B:BD[43.33476] → [71.5496:5570]

B:BD[22.16584] → [49.29472:29545]

B:BD[20.45396] → [49.29452:29471]

B:BD[20.45137] → [49.29227:29451]

B:BD[20.45036] → [49.29207:29226]

B:BD[20.44917] → [49.29187:29206]

B:BD[22.16040] → [49.28882:29186]

B:BD[22.15733] → [49.28581:28881]

B:BD[20.43832] → [49.28283:28580]

B:BD[20.45036] → [50.7561:7580]

B:BD[20.44917] → [50.7541:7560]

B:BD[20.45036] → [51.10594:10613]

B:BD[20.44917] → [51.10574:10593]

∅:BD[17.117634] → [20.45713:45714]

∅:BD[2.29070] → [20.45713:45714]

B:BD[20.45713] → [20.45713:45714]

B:BD[20.47552] → [24.14982:15000]

B:BD[20.47438] → [24.14963:14981]

B:BD[20.47147] → [24.14815:14962]

B:BD[20.47047] → [24.14796:14814]

B:BD[20.46709] → [24.14566:14795]

B:BD[20.46609] → [24.14547:14565]

B:BD[20.46275] → [24.14317:14546]

B:BD[20.46175] → [24.14298:14316]

B:BD[20.45841] → [24.14068:14297]

B:BD[20.45741] → [24.14049:14067]

B:BD[20.47552] → [40.15759:15777]

B:BD[20.47147] → [40.15611:15758]

B:BD[20.47047] → [40.15592:15610]

B:BD[20.47552] → [41.10592:10610]

B:BD[20.47147] → [41.10444:10591]

B:BD[20.47047] → [41.10425:10443]

B:BD[20.47552] → [140.1728:1746]

B:BD[20.46709] → [140.1648:1727]

B:BD[20.46275] → [140.1568:1647]

B:BD[20.45841] → [140.1488:1567]

B:BD[20.47552] → [70.8213:8231]

B:BD[20.47047] → [70.8121:8139]

B:BD[20.46709] → [70.8041:8120]

B:BD[20.46275] → [70.7961:8040]

B:BD[20.45841] → [70.7881:7960]

B:BD[20.47552] → [111.10280:10298]

B:BD[20.47552] → [42.28000:28018]

B:BD[20.47438] → [42.27981:27999]

B:BD[20.47147] → [42.27833:27980]

B:BD[20.47047] → [42.27814:27832]

B:BD[20.47011] → [42.27734:27813]

B:BD[20.46709] → [42.27504:27733]

B:BD[20.46609] → [42.27485:27503]

B:BD[20.46580] → [42.27405:27484]

B:BD[20.46275] → [42.27252:27404]

B:BD[20.46175] → [42.27233:27251]

B:BD[20.46146] → [42.27153:27232]

B:BD[20.45841] → [42.27000:27152]

B:BD[20.45741] → [42.26981:26999]

B:BD[20.47552] → [43.35465:35483]

B:BD[20.47438] → [43.35446:35464]

B:BD[20.47147] → [43.35298:35373]

B:BD[43.35373] → [92.7143:7215]

B:BD[43.35373] → [70.8140:8212]

B:BD[43.35373] → [43.35373:35445]

B:BD[43.35373] → [47.17146:17218]

B:BD[43.35373] → [52.12810:12882]

B:BD[43.35373] → [38.21034:21106]

B:BD[43.35373] → [39.7288:7360]

B:BD[20.47047] → [43.35279:35297]

B:BD[20.47011] → [43.35199:35278]

B:BD[20.46709] → [43.34969:35048]

B:BD[43.35048] → [43.35048:35198]

B:BD[20.46609] → [43.34950:34968]

B:BD[20.46580] → [43.34870:34949]

B:BD[20.46275] → [43.34717:34796]

B:BD[43.34796] → [43.34796:34869]

B:BD[20.46175] → [43.34698:34716]

B:BD[20.46146] → [43.34618:34697]

B:BD[20.45841] → [43.34465:34544]

B:BD[43.34544] → [43.34544:34617]

B:BD[20.45741] → [43.34446:34464]

B:BD[20.47552] → [29.54357:54375]

B:BD[20.47438] → [29.54338:54356]

B:BD[20.47147] → [29.54189:54337]

B:BD[20.47047] → [29.54170:54188]

B:BD[20.47011] → [29.54090:54169]

B:BD[20.46709] → [29.53860:54089]

B:BD[20.46609] → [29.53841:53859]

B:BD[20.46580] → [29.53761:53840]

B:BD[20.46275] → [29.53608:53760]

B:BD[20.46175] → [29.53589:53607]

B:BD[20.46146] → [29.53509:53588]

B:BD[20.45841] → [29.53356:53508]

B:BD[20.45741] → [29.53337:53355]

B:BD[20.47552] → [44.6600:6618]

B:BD[20.47147] → [44.6452:6599]

B:BD[20.47047] → [44.6433:6451]

B:BD[20.47147] → [46.66448:66595]

B:BD[20.47635] → [47.17238:17335]

B:BD[20.47862] → [92.7216:7361]

B:BD[20.48088] → [20.48088:48161]

B:BD[20.48316] → [24.15155:15173]

B:BD[20.48534] → [24.15174:15252]

B:BD[20.48861] → [24.15332:15405]

B:BD[20.49252] → [24.15406:15565]

B:BD[20.49805] → [29.55326:55344]

B:BD[20.49901] → [42.28657:28769]

B:BD[20.50268] → [24.15717:15737]

B:BD[20.50370] → [24.15738:15889]

B:BD[20.50846] → [24.15890:15909]

B:BD[20.50947] → [24.15910:16133]

B:BD[20.51282] → [24.16134:16152]

B:BD[20.51382] → [92.7456:7601]

B:BD[43.36796] → [43.36796:36877]

B:BD[20.51760] → [29.56173:56246]

B:BD[20.51865] → [24.16378:16396]

B:BD[20.52106] → [24.16397:16469]

B:BD[20.52387] → [20.52387:52519]

B:BD[43.37042] → [43.37042:37123]

B:BD[20.52785] → [29.56493:56512]

B:BD[20.52966] → [22.18203:18340]

B:BD[20.52966] → [20.52966:52981]

B:BD[20.53196] → [20.53196:53210]

B:BD[20.53229] → [20.53229:53311]

B:BD[43.37216] → [43.37216:37297]

B:BD[20.53567] → [24.16798:16817]

B:BD[20.53668] → [24.16818:16891]

B:BD[20.53887] → [40.16602:16677]

B:BD[20.54040] → [24.16892:16979]

B:BD[24.17211] → [24.17211:17291]

B:BD[24.17367] → [24.17367:17680]

B:BD[24.17367] → [22.18912:18995]

B:BD[22.19073] → [22.19073:19149]

B:BD[22.19225] → [22.19225:19363]

B:BD[22.19363] → [29.57961:58036]

B:BD[22.19363] → [46.68508:68583]

B:BD[22.19363] → [22.19363:19438]

B:BD[22.19363] → [30.25387:25462]

B:BD[22.19363] → [49.33906:33981]

B:BD[22.19149] → [43.38023:38099]

B:BD[22.19149] → [29.57884:57960]

B:BD[22.19149] → [22.19149:19225]

B:BD[22.19149] → [48.30298:30374]

B:BD[22.19149] → [49.33829:33905]

B:BD[22.19149] → [53.19555:19631]

B:BD[22.18995] → [22.18995:19073]

B:BD[24.17291] → [24.17291:17367]

B:BD[24.17211] → [22.18831:18911]

B:BD[24.16979] → [24.16979:17211]

B:BD[20.54040] → [70.9274:9361]

B:BD[43.37475] → [70.9362:9670]

B:BD[43.37859] → [70.9671:9755]

B:BD[43.38022] → [92.7920:8003]

B:BD[43.38022] → [30.25303:25386]

B:BD[43.37859] → [43.37859:37943]

B:BD[43.37943] → [43.37943:38022]

B:BD[43.37859] → [47.18774:18858]

B:BD[43.37859] → [30.25218:25302]

B:BD[43.37859] → [52.14218:14302]

B:BD[43.37859] → [38.22345:22429]

B:BD[43.37475] → [43.37475:37783]

B:BD[43.37783] → [43.37783:37859]

B:BD[43.37475] → [47.18465:18773]

B:BD[43.37475] → [52.13909:14217]

B:BD[43.37475] → [38.22036:22267]

B:BD[38.22267] → [92.7842:7919]

B:BD[38.22267] → [38.22267:22344]

B:BD[20.54040] → [29.57085:57253]

B:BD[29.57484] → [29.57484:57561]

B:BD[29.57637] → [29.57637:57721]

B:BD[29.57800] → [29.57800:57883]

B:BD[29.57721] → [29.57721:57800]

B:BD[29.57637] → [46.68423:68507]

B:BD[29.57561] → [29.57561:57637]

B:BD[29.57484] → [46.68345:68422]

B:BD[29.57253] → [29.57253:57484]

B:BD[20.54040] → [46.68176:68344]

B:BD[20.54040] → [47.18377:18464]

B:BD[20.54040] → [22.18743:18830]

B:BD[22.18830] → [43.37394:37475]

B:BD[22.18830] → [48.29825:30297]

B:BD[22.18830] → [53.19083:19554]

B:BD[20.54040] → [30.24741:25217]

B:BD[20.54040] → [49.33192:33828]

B:BD[20.54040] → [20.54040:54127]

B:BD[20.54598] → [20.54598:54752]

B:BD[20.54828] → [20.54828:54866]

B:BD[20.54752] → [42.30383:30459]

B:BD[20.54752] → [20.54752:54828]

B:BD[20.54752] → [54.22819:22895]

B:BD[20.54752] → [55.48057:48133]

B:BD[20.54127] → [42.29910:30382]

B:BD[20.54127] → [20.54127:54598]

B:BD[20.54127] → [54.22347:22818]

B:BD[20.54127] → [55.47584:48056]

B:BD[20.54040] → [52.13821:13908]

B:BD[20.54040] → [38.21948:22035]

B:BD[20.53887] → [41.11435:11510]

B:BD[20.53887] → [140.1929:2005]

B:BD[20.53887] → [70.9197:9273]

B:BD[20.53887] → [111.11123:11198]

B:BD[20.53887] → [42.29834:29909]

B:BD[20.53887] → [43.37318:37393]

B:BD[20.53887] → [29.57008:57084]

B:BD[20.53887] → [44.7443:7518]

B:BD[20.53887] → [47.18301:18376]

B:BD[20.53887] → [22.18667:18742]

B:BD[20.53887] → [33.14783:14858]

B:BD[20.53887] → [48.29749:29824]

B:BD[20.53887] → [30.24664:24740]

B:BD[20.53887] → [49.33116:33191]

B:BD[20.53887] → [50.8644:8719]

B:BD[20.53887] → [51.11771:11846]

B:BD[20.53887] → [20.53887:53962]

B:BD[20.53962] → [20.53962:54040]

B:BD[20.53816] → [20.53816:53887]

B:BD[20.53887] → [52.13745:13820]

B:BD[20.53887] → [38.21871:21947]

B:BD[20.53887] → [53.19007:19082]

B:BD[20.53887] → [54.22271:22346]

B:BD[20.53887] → [55.47508:47583]

B:BD[20.53887] → [37.19855:19930]

B:BD[20.53887] → [71.6378:6453]

B:BD[20.53668] → [92.7768:7841]

B:BD[20.53668] → [70.9123:9196]

B:BD[20.53668] → [29.56859:57007]

B:BD[20.53668] → [46.68027:68175]

B:BD[20.53668] → [47.18227:18300]

B:BD[20.53668] → [22.18593:18666]

B:BD[20.53668] → [30.24515:24663]

B:BD[20.53668] → [49.32967:33115]

B:BD[20.53668] → [20.53668:53741]

B:BD[20.53741] → [20.53741:53816]

B:BD[20.53668] → [39.7893:7966]

B:BD[20.53567] → [92.7748:7767]

B:BD[20.53567] → [70.9103:9122]

B:BD[20.53567] → [42.29814:29833]

B:BD[20.53567] → [43.37298:37317]

B:BD[20.53567] → [29.56839:56858]

B:BD[20.53567] → [46.68007:68026]

B:BD[20.53567] → [47.18207:18226]

B:BD[20.53567] → [22.18573:18592]

B:BD[20.53567] → [48.29729:29748]

B:BD[20.53567] → [30.24495:24514]

B:BD[20.53567] → [49.32947:32966]

B:BD[20.53586] → [20.53586:53668]

B:BD[20.53567] → [20.53567:53586]

B:BD[20.53567] → [52.13725:13744]

B:BD[20.53567] → [38.21851:21870]

B:BD[20.53567] → [53.18987:19006]

B:BD[20.53567] → [54.22251:22270]

B:BD[20.53567] → [55.47488:47507]

B:BD[20.53537] → [20.53537:53567]

B:BD[20.53464] → [20.53464:53537]

B:BD[20.53311] → [24.16644:16797]

B:BD[20.53311] → [40.16448:16601]

B:BD[20.53311] → [41.11281:11434]

B:BD[20.53311] → [92.7675:7747]

B:BD[20.53311] → [70.9030:9102]

B:BD[20.53311] → [111.10969:11122]

B:BD[20.53311] → [42.29660:29813]

B:BD[20.53311] → [43.37144:37216]

B:BD[20.53311] → [29.56612:56838]

B:BD[20.53311] → [44.7289:7442]

B:BD[20.53311] → [46.67780:68006]

B:BD[20.53311] → [47.18134:18206]

B:BD[20.53311] → [22.18419:18572]

B:BD[20.53311] → [33.14629:14782]

B:BD[20.53311] → [48.29575:29728]

B:BD[20.53311] → [30.24268:24494]

B:BD[20.53311] → [49.32720:32946]

B:BD[20.53311] → [50.8490:8643]

B:BD[20.53311] → [51.11617:11770]

B:BD[20.53311] → [20.53311:53464]

B:BD[20.53311] → [52.13652:13724]

B:BD[20.53311] → [38.21778:21850]

B:BD[20.53311] → [53.18833:18986]

B:BD[20.53311] → [54.22097:22250]

B:BD[20.53311] → [55.47334:47487]

B:BD[20.53311] → [37.19701:19854]

B:BD[20.53311] → [39.7820:7892]

B:BD[20.53210] → [24.16624:16643]

B:BD[20.53210] → [40.16428:16447]

B:BD[20.53210] → [41.11261:11280]

B:BD[20.53210] → [111.10949:10968]

B:BD[20.53210] → [42.29640:29659]

B:BD[20.53210] → [43.37124:37143]

B:BD[20.53210] → [29.56592:56611]

B:BD[20.53210] → [44.7269:7288]

B:BD[20.53210] → [33.14609:14628]

B:BD[20.53210] → [48.29555:29574]

B:BD[20.53210] → [49.32700:32719]

B:BD[20.53210] → [50.8470:8489]

B:BD[20.53210] → [51.11597:11616]

B:BD[20.53210] → [20.53210:53229]

B:BD[20.53210] → [53.18813:18832]

B:BD[20.53210] → [54.22077:22096]

B:BD[20.53210] → [55.47314:47333]

B:BD[20.53210] → [37.19681:19700]

B:BD[20.52981] → [20.52981:53196]

B:BD[22.18340] → [70.8951:9029]

B:BD[22.18340] → [29.56513:56591]

B:BD[22.18340] → [47.18055:18133]

B:BD[22.18340] → [22.18340:18418]

B:BD[22.18340] → [30.24189:24267]

B:BD[22.18340] → [49.32621:32699]

B:BD[22.18340] → [52.13573:13651]

B:BD[22.18340] → [38.21699:21777]

B:BD[20.52785] → [46.67760:67779]

B:BD[20.52785] → [30.24169:24188]

B:BD[20.52785] → [49.32601:32620]

B:BD[20.52804] → [20.52804:52966]

B:BD[20.52785] → [20.52785:52804]

B:BD[20.52672] → [20.52672:52785]

B:BD[20.52519] → [24.16470:16623]

B:BD[20.52519] → [40.16274:16427]

B:BD[20.52519] → [41.11107:11260]

B:BD[20.52519] → [92.7602:7674]

B:BD[20.52519] → [70.8878:8950]

B:BD[20.52519] → [111.10795:10948]

B:BD[20.52519] → [42.29486:29639]

B:BD[20.52519] → [43.36970:37042]

B:BD[20.52519] → [29.56339:56492]

B:BD[20.52519] → [44.7115:7268]

B:BD[20.52519] → [46.67606:67759]

B:BD[20.52519] → [47.17982:18054]

B:BD[20.52519] → [22.18049:18202]

B:BD[20.52519] → [33.14455:14608]

B:BD[20.52519] → [48.29401:29554]

B:BD[20.52519] → [30.24015:24168]

B:BD[20.52519] → [49.32447:32600]

B:BD[20.52519] → [50.8316:8469]

B:BD[20.52519] → [51.11443:11596]

B:BD[20.52519] → [20.52519:52672]

B:BD[20.52519] → [52.13500:13572]

B:BD[20.52519] → [38.21626:21698]

B:BD[20.52519] → [53.18659:18812]

B:BD[20.52519] → [54.21923:22076]

B:BD[20.52519] → [55.47160:47313]

B:BD[20.52519] → [37.19527:19680]

B:BD[20.52519] → [39.7747:7819]

B:BD[24.16469] → [22.17839:18048]

B:BD[20.52106] → [42.29413:29485]

B:BD[20.52106] → [43.36897:36969]

B:BD[20.52106] → [29.56266:56338]

B:BD[20.52106] → [48.29328:29400]

B:BD[20.52106] → [49.32374:32446]

B:BD[20.52106] → [20.52106:52178]

B:BD[20.52178] → [20.52178:52387]

B:BD[20.52106] → [53.18586:18658]

B:BD[20.52106] → [54.21850:21922]

B:BD[20.52106] → [55.47087:47159]

B:BD[20.51865] → [40.16255:16273]

B:BD[20.51865] → [41.11088:11106]

B:BD[20.51865] → [111.10776:10794]

B:BD[20.51865] → [42.29394:29412]

B:BD[20.51865] → [43.36878:36896]

B:BD[20.51865] → [29.56247:56265]

B:BD[20.51865] → [44.7096:7114]

B:BD[20.51865] → [33.14436:14454]

B:BD[20.51865] → [48.29309:29327]

B:BD[20.51865] → [49.32355:32373]

B:BD[20.51865] → [50.8297:8315]

B:BD[20.51865] → [51.11424:11442]

B:BD[20.51865] → [20.51865:51883]

B:BD[20.51883] → [20.51883:52106]

B:BD[20.51865] → [53.18567:18585]

B:BD[20.51865] → [54.21831:21849]

B:BD[20.51865] → [55.47068:47086]

B:BD[20.51865] → [37.19508:19526]

B:BD[20.51760] → [46.67532:67605]

B:BD[20.51760] → [30.23941:24014]

B:BD[20.51760] → [49.32281:32354]

B:BD[20.51760] → [20.51760:51833]

B:BD[20.51833] → [20.51833:51865]

B:BD[43.36796] → [30.23859:23940]

B:BD[20.51382] → [70.8732:8877]

B:BD[20.51679] → [20.51679:51760]

B:BD[20.51382] → [29.55875:56020]

B:BD[29.56091] → [29.56091:56172]

B:BD[29.56091] → [46.67450:67531]

B:BD[29.56020] → [29.56020:56091]

B:BD[20.51382] → [46.67304:67449]

B:BD[20.51382] → [47.17836:17981]

B:BD[20.51382] → [30.23713:23858]

B:BD[20.51382] → [49.31983:32280]

B:BD[20.51382] → [20.51382:51455]

B:BD[43.36725] → [43.36725:36796]

B:BD[20.51527] → [20.51527:51598]

B:BD[20.51598] → [40.16173:16254]

B:BD[20.51598] → [41.11006:11087]

B:BD[20.51598] → [111.10694:10775]

B:BD[20.51598] → [44.7014:7095]

B:BD[20.51598] → [33.14354:14435]

B:BD[20.51598] → [50.8215:8296]

B:BD[20.51598] → [51.11342:11423]

B:BD[20.51598] → [20.51598:51679]

B:BD[20.51598] → [37.19426:19507]

B:BD[20.51455] → [24.16153:16377]

B:BD[20.51455] → [40.16100:16172]

B:BD[20.51455] → [41.10933:11005]

B:BD[20.51455] → [111.10621:10693]

B:BD[20.51455] → [42.29169:29393]

B:BD[20.51455] → [43.36653:36725]

B:BD[20.51455] → [44.6941:7013]

B:BD[20.51455] → [22.17614:17838]

B:BD[20.51455] → [33.14281:14353]

B:BD[20.51455] → [48.29084:29308]

B:BD[20.51455] → [50.8142:8214]

B:BD[20.51455] → [51.11269:11341]

B:BD[20.51455] → [20.51455:51527]

B:BD[20.51455] → [53.18342:18566]

B:BD[20.51455] → [54.21606:21830]

B:BD[20.51455] → [55.46843:47067]

B:BD[20.51455] → [37.19353:19425]

B:BD[20.51382] → [39.7601:7674]

B:BD[39.7674] → [52.13427:13499]

B:BD[39.7674] → [38.21553:21625]

B:BD[39.7674] → [39.7674:7746]

B:BD[20.51282] → [140.1910:1928]

B:BD[20.51282] → [70.8713:8731]

B:BD[20.51282] → [43.36634:36652]

B:BD[20.51282] → [29.55856:55874]

B:BD[20.51282] → [47.17817:17835]

B:BD[20.51282] → [22.17595:17613]

B:BD[20.51282] → [30.23694:23712]

B:BD[20.51282] → [49.31964:31982]

B:BD[20.51282] → [20.51282:51300]

B:BD[20.51300] → [20.51300:51382]

B:BD[20.51282] → [52.13408:13426]

B:BD[20.51282] → [38.21534:21552]

B:BD[20.51282] → [71.6359:6377]

B:BD[20.50947] → [42.28944:29168]

B:BD[20.50947] → [43.36409:36488]

B:BD[43.36561] → [92.7383:7455]

B:BD[43.36561] → [70.8640:8712]

B:BD[43.36561] → [43.36561:36633]

B:BD[43.36561] → [47.17744:17816]

B:BD[20.51171] → [20.51171:51282]

B:BD[43.36561] → [52.13335:13407]

B:BD[43.36561] → [38.21461:21533]

B:BD[43.36561] → [39.7528:7600]

B:BD[43.36488] → [43.36488:36561]

B:BD[43.36488] → [30.23548:23693]

B:BD[20.50947] → [29.55631:55710]

B:BD[29.55710] → [29.55710:55855]

B:BD[29.55710] → [46.67158:67303]

B:BD[20.50947] → [22.17370:17594]

B:BD[20.50947] → [48.28859:29083]

B:BD[20.50947] → [49.31739:31963]

B:BD[20.50947] → [20.50947:51099]

B:BD[20.51099] → [40.16027:16099]

B:BD[20.51099] → [41.10860:10932]

B:BD[20.51099] → [111.10548:10620]

B:BD[20.51099] → [44.6868:6940]

B:BD[20.51099] → [33.14208:14280]

B:BD[20.51099] → [50.8069:8141]

B:BD[20.51099] → [51.11196:11268]

B:BD[20.51099] → [20.51099:51171]

B:BD[20.51099] → [37.19280:19352]

B:BD[20.50947] → [53.18117:18341]

B:BD[20.50947] → [54.21381:21605]

B:BD[20.50947] → [55.46618:46842]

B:BD[20.50846] → [22.17350:17369]

B:BD[20.50846] → [20.50846:50865]

B:BD[20.50865] → [20.50865:50947]

B:BD[20.50370] → [42.28791:28943]

B:BD[20.50370] → [43.36256:36335]

B:BD[20.50522] → [20.50522:50846]

B:BD[43.36335] → [43.36335:36408]

B:BD[43.36335] → [30.23474:23547]

B:BD[20.50370] → [29.55478:55557]

B:BD[29.55557] → [29.55557:55630]

B:BD[29.55557] → [46.67084:67157]

B:BD[20.50370] → [22.17197:17349]

B:BD[20.50370] → [48.28706:28858]

B:BD[20.50370] → [49.31586:31738]

B:BD[20.50370] → [20.50370:50522]

B:BD[20.50370] → [53.17964:18116]

B:BD[20.50370] → [54.21228:21380]

B:BD[20.50370] → [55.46465:46617]

B:BD[20.50268] → [40.16006:16026]

B:BD[20.50268] → [41.10839:10859]

B:BD[20.50268] → [92.7362:7382]

B:BD[20.50268] → [70.8619:8639]

B:BD[20.50268] → [111.10527:10547]

B:BD[20.50268] → [42.28770:28790]

B:BD[20.50268] → [43.36235:36255]

B:BD[20.50268] → [29.55457:55477]

B:BD[20.50268] → [44.6847:6867]

B:BD[20.50268] → [46.67063:67083]

B:BD[20.50268] → [47.17723:17743]

B:BD[20.50268] → [22.17176:17196]

B:BD[20.50268] → [33.14187:14207]

B:BD[20.50268] → [48.28685:28705]

B:BD[20.50268] → [30.23453:23473]

B:BD[20.50268] → [49.31565:31585]

B:BD[20.50268] → [50.8048:8068]

B:BD[20.50268] → [51.11175:11195]

B:BD[20.50268] → [20.50268:50288]

B:BD[20.50288] → [20.50288:50370]

B:BD[20.50268] → [52.13314:13334]

B:BD[20.50268] → [38.21440:21460]

B:BD[20.50268] → [53.17943:17963]

B:BD[20.50268] → [54.21207:21227]

B:BD[20.50268] → [55.46444:46464]

B:BD[20.50268] → [37.19259:19279]

B:BD[20.50268] → [39.7507:7527]

B:BD[20.49901] → [48.28572:28684]

B:BD[20.49823] → [20.49823:49901]

B:BD[20.49901] → [20.49901:50268]

B:BD[20.49901] → [55.46331:46443]

B:BD[29.55344] → [29.55344:55456]

B:BD[20.49805] → [46.67044:67062]

B:BD[20.49805] → [30.23434:23452]

B:BD[20.49805] → [49.31546:31564]

B:BD[20.49805] → [20.49805:49823]

B:BD[20.49823] → [43.36122:36234]

B:BD[20.49563] → [20.49563:49805]

B:BD[24.15565] → [24.15565:15716]

B:BD[24.15565] → [22.17023:17175]

B:BD[20.49252] → [42.28345:28656]

B:BD[20.49252] → [43.35810:36048]

B:BD[43.36048] → [43.36048:36121]

B:BD[43.36048] → [30.23360:23433]

B:BD[20.49252] → [29.55014:55252]

B:BD[29.55252] → [29.55252:55325]

B:BD[29.55252] → [46.66970:67043]

B:BD[20.49252] → [48.28260:28571]

B:BD[20.49252] → [49.31234:31545]

B:BD[20.49252] → [20.49252:49563]

B:BD[20.49252] → [53.17631:17942]

B:BD[20.49252] → [54.20895:21206]

B:BD[20.49252] → [55.46019:46330]

B:BD[20.48700] → [24.15253:15331]

B:BD[20.48861] → [40.15932:16005]

B:BD[20.48861] → [41.10765:10838]

B:BD[20.48861] → [140.1836:1909]

B:BD[20.48861] → [70.8545:8618]

B:BD[20.48861] → [111.10453:10526]

B:BD[20.48861] → [42.28271:28344]

B:BD[20.48700] → [42.28192:28270]

B:BD[20.48934] → [20.48934:49252]

B:BD[20.48861] → [43.35736:35809]

B:BD[20.48700] → [43.35657:35735]

B:BD[20.48861] → [29.54940:55013]

B:BD[20.48861] → [44.6773:6846]

B:BD[20.48861] → [46.66896:66969]

B:BD[20.48861] → [47.17649:17722]

B:BD[20.48861] → [33.14113:14186]

B:BD[20.48861] → [48.28186:28259]

B:BD[20.48700] → [48.28107:28185]

B:BD[20.48861] → [30.23286:23359]

B:BD[20.48861] → [49.31160:31233]

B:BD[20.48861] → [50.7974:8047]

B:BD[20.48861] → [51.11101:11174]

B:BD[20.48861] → [20.48861:48934]

B:BD[20.48778] → [20.48778:48861]

B:BD[20.48700] → [20.48700:48778]

B:BD[20.48861] → [52.13240:13313]

B:BD[20.48861] → [38.21366:21439]

B:BD[20.48861] → [53.17557:17630]

B:BD[20.48700] → [53.17478:17556]

B:BD[20.48861] → [54.20821:20894]

B:BD[20.48700] → [54.20742:20820]

B:BD[20.48861] → [55.45945:46018]

B:BD[20.48700] → [55.45866:45944]

B:BD[20.48861] → [37.19185:19258]

B:BD[20.48861] → [71.6285:6358]

B:BD[20.48534] → [70.8378:8544]

B:BD[20.48534] → [29.54695:54939]

B:BD[20.48534] → [47.17482:17648]

B:BD[20.48534] → [22.16944:17022]

B:BD[22.17022] → [140.1747:1835]

B:BD[22.17022] → [71.6196:6284]

B:BD[20.48534] → [30.23119:23285]

B:BD[20.48534] → [49.30915:31159]

B:BD[20.48534] → [20.48534:48612]

B:BD[20.48612] → [20.48612:48700]

B:BD[20.48534] → [52.13073:13239]

B:BD[20.48534] → [38.21199:21365]

B:BD[20.48316] → [42.28173:28191]

B:BD[20.48316] → [43.35638:35656]

B:BD[20.48316] → [29.54676:54694]

B:BD[20.48316] → [22.16925:16943]

B:BD[20.48316] → [48.28088:28106]

B:BD[20.48316] → [49.30896:30914]

B:BD[20.48334] → [20.48334:48534]

B:BD[20.48316] → [20.48316:48334]

B:BD[20.48316] → [53.17459:17477]

B:BD[20.48316] → [54.20723:20741]

B:BD[20.48316] → [55.45847:45865]

B:BD[20.48161] → [20.48161:48316]

B:BD[20.47862] → [70.8232:8377]

B:BD[20.47862] → [29.54376:54675]

B:BD[20.47862] → [46.66596:66895]

B:BD[20.47862] → [47.17336:17481]

B:BD[20.47862] → [30.22819:23118]

B:BD[20.47862] → [49.30596:30895]

B:BD[20.47862] → [20.47862:47935]

B:BD[43.35556] → [43.35556:35637]

B:BD[20.47935] → [24.15001:15154]

B:BD[20.47935] → [40.15778:15931]

B:BD[20.47935] → [41.10611:10764]

B:BD[20.47935] → [111.10299:10452]

B:BD[20.47935] → [42.28019:28172]

B:BD[20.47935] → [43.35484:35556]

B:BD[20.47935] → [44.6619:6772]

B:BD[20.47935] → [22.16771:16924]

B:BD[20.47935] → [33.13959:14112]

B:BD[20.47935] → [48.27934:28087]

B:BD[20.47935] → [50.7820:7973]

B:BD[20.47935] → [51.10947:11100]

B:BD[20.47935] → [20.47935:48088]

B:BD[20.47935] → [53.17305:17458]

B:BD[20.47935] → [54.20569:20722]

B:BD[20.47935] → [55.45693:45846]

B:BD[20.47935] → [37.19031:19184]

B:BD[20.47862] → [39.7361:7434]

B:BD[39.7434] → [52.13000:13072]

B:BD[39.7434] → [38.21126:21198]

B:BD[39.7434] → [39.7434:7506]

B:BD[20.47552] → [47.17219:17237]

B:BD[20.47047] → [47.17127:17145]

B:BD[20.46709] → [47.17047:17126]

B:BD[20.46275] → [47.16967:17046]

B:BD[20.45841] → [47.16887:16966]

B:BD[20.47552] → [22.16752:16770]

B:BD[20.47147] → [22.16604:16751]

B:BD[20.47047] → [22.16585:16603]

B:BD[20.47552] → [33.13940:13958]

B:BD[20.47147] → [33.13792:13939]

B:BD[20.47047] → [33.13773:13791]

B:BD[20.47552] → [48.27915:27933]

B:BD[20.47438] → [48.27896:27914]

B:BD[20.47147] → [48.27748:27895]

B:BD[20.47047] → [48.27729:27747]

B:BD[20.47011] → [48.27649:27728]

B:BD[20.46709] → [48.27419:27648]

B:BD[20.46609] → [48.27400:27418]

B:BD[20.46580] → [48.27320:27399]

B:BD[20.46275] → [48.27167:27319]

B:BD[20.46175] → [48.27148:27166]

B:BD[20.46146] → [48.27068:27147]

B:BD[20.45841] → [48.26915:27067]

B:BD[20.45741] → [48.26896:26914]

B:BD[20.47552] → [30.22800:22818]

B:BD[20.47147] → [30.22651:22799]

B:BD[20.47047] → [30.22632:22650]

B:BD[20.46709] → [30.22552:22631]

B:BD[20.46275] → [30.22472:22551]

B:BD[20.45841] → [30.22392:22471]

B:BD[20.47635] → [49.30498:30595]

B:BD[20.47552] → [49.30479:30497]

B:BD[20.47438] → [49.30460:30478]

B:BD[20.47147] → [49.30312:30459]

B:BD[20.47047] → [49.30293:30311]

B:BD[20.46709] → [49.30063:30292]

B:BD[20.46609] → [49.30044:30062]

B:BD[20.46275] → [49.29814:30043]

B:BD[20.46175] → [49.29795:29813]

B:BD[20.45841] → [49.29565:29794]

B:BD[20.45741] → [49.29546:29564]

B:BD[20.47552] → [50.7801:7819]

B:BD[20.47552] → [51.10928:10946]

B:BD[20.47147] → [51.10780:10927]

B:BD[20.47047] → [51.10761:10779]

B:BD[20.47635] → [20.47635:47732]

B:BD[20.47732] → [20.47732:47862]

B:BD[20.47570] → [20.47570:47635]

B:BD[20.47552] → [20.47552:47570]

B:BD[20.47456] → [20.47456:47552]

B:BD[20.47438] → [20.47438:47456]

B:BD[20.47294] → [20.47294:47438]

B:BD[20.47147] → [20.47147:47222]

B:BD[20.47222] → [111.10207:10279]

B:BD[20.47222] → [50.7728:7800]

B:BD[20.47222] → [20.47222:47294]

B:BD[20.47065] → [20.47065:47147]

B:BD[20.47047] → [20.47047:47065]

B:BD[20.47011] → [20.47011:47047]

B:BD[20.46938] → [20.46938:47011]

B:BD[20.46709] → [20.46709:46938]

B:BD[20.46627] → [20.46627:46709]

B:BD[20.46609] → [20.46609:46627]

B:BD[20.46580] → [20.46580:46609]

B:BD[20.46504] → [20.46504:46580]

B:BD[20.46275] → [20.46275:46504]

B:BD[20.46193] → [20.46193:46275]

B:BD[20.46175] → [20.46175:46193]

B:BD[20.46146] → [20.46146:46175]

B:BD[20.46070] → [20.46070:46146]

B:BD[20.45841] → [20.45841:46070]

B:BD[20.45759] → [20.45759:45841]

B:BD[20.45741] → [20.45741:45759]

B:BD[20.47635] → [52.12902:12999]

B:BD[20.47552] → [52.12883:12901]

B:BD[20.47047] → [52.12791:12809]

B:BD[20.46709] → [52.12711:12790]

B:BD[20.46275] → [52.12631:12710]

B:BD[20.45841] → [52.12551:12630]

B:BD[20.47552] → [38.21107:21125]

B:BD[20.47047] → [38.21015:21033]

B:BD[20.46709] → [38.20935:21014]

B:BD[20.46275] → [38.20855:20934]

B:BD[20.45841] → [38.20775:20854]

B:BD[20.47552] → [53.17286:17304]

B:BD[20.47438] → [53.17267:17285]

B:BD[20.47147] → [53.17119:17266]

B:BD[20.47047] → [53.17100:17118]

B:BD[20.46709] → [53.16870:17099]

B:BD[20.46609] → [53.16851:16869]

B:BD[20.46275] → [53.16621:16850]

B:BD[20.46175] → [53.16602:16620]

B:BD[20.45841] → [53.16372:16601]

B:BD[20.45741] → [53.16353:16371]

B:BD[20.47552] → [54.20550:20568]

B:BD[20.47438] → [54.20531:20549]

B:BD[20.47147] → [54.20383:20530]

B:BD[20.47047] → [54.20364:20382]

B:BD[20.46709] → [54.20134:20363]

B:BD[20.46609] → [54.20115:20133]

B:BD[20.46275] → [54.19885:20114]

B:BD[20.46175] → [54.19866:19884]

B:BD[20.45841] → [54.19636:19865]

B:BD[20.45741] → [54.19617:19635]

B:BD[20.47552] → [55.45674:45692]

B:BD[20.47438] → [55.45655:45673]

B:BD[20.47147] → [55.45507:45654]

B:BD[20.47047] → [55.45488:45506]

B:BD[20.47011] → [55.45408:45487]

B:BD[20.46709] → [55.45178:45407]

B:BD[20.46609] → [55.45159:45177]

B:BD[20.46580] → [55.45079:45158]

B:BD[20.46275] → [55.44926:45078]

B:BD[20.46175] → [55.44907:44925]

B:BD[20.46146] → [55.44827:44906]

B:BD[20.45841] → [55.44674:44826]

B:BD[20.45741] → [55.44655:44673]

B:BD[20.47552] → [37.19012:19030]

B:BD[20.47147] → [37.18864:19011]

B:BD[20.47047] → [37.18845:18863]

B:BD[20.47635] → [71.6098:6195]

B:BD[20.47552] → [71.6079:6097]

B:BD[20.46709] → [71.5999:6078]

B:BD[20.46275] → [71.5919:5998]

B:BD[20.45841] → [71.5839:5918]

B:BD[20.45714] → [20.45714:45741]

B:BD[20.45714] → [17.117635:117647]

B:BD[17.117765] → [59.75818:75969]

B:BD[17.117765] → [63.62974:63047]

B:BD[58.88238] → [58.88238:88316]

B:BD[17.117765] → [58.88165:88238]

B:BD[17.117765] → [62.88791:88864]

B:BD[17.117765] → [77.57596:57669]

B:BD[17.117765] → [60.65785:65858]

B:BD[17.117931] → [17.117931:117947]

∅:BD[21.71450] → [17.117965:118030]

B:BD[17.117965] → [17.117965:118030]

B:BD[17.118030] → [2.29071:29149]

∅:BD[2.29149] → [17.118030:118047]

B:BD[17.118030] → [17.118030:118047]

∅:BD[2.29167] → [17.118120:118135]

∅:BD[60.65932] → [17.118120:118135]

∅:BD[77.57743] → [17.118120:118135]

∅:BD[21.71524] → [17.118120:118135]

∅:BD[62.88938] → [17.118120:118135]

∅:BD[58.88390] → [17.118120:118135]

∅:BD[63.63121] → [17.118120:118135]

∅:BD[59.76043] → [17.118120:118135]

B:BD[17.118120] → [17.118120:118135]

B:BD[17.118252] → [59.76044:76117]

B:BD[17.118252] → [63.63122:63195]

B:BD[17.118252] → [58.88391:88464]

B:BD[17.118252] → [62.88939:89012]

B:BD[17.118252] → [77.57744:57817]

B:BD[17.118252] → [60.65933:66006]

B:BD[17.118340] → [17.118340:118443]

B:BD[17.118443] → [2.29168:29246]

∅:BD[2.29246] → [17.118443:118460]

B:BD[17.118443] → [17.118443:118460]

∅:BD[2.29281] → [17.118612:118645]

B:BD[17.118612] → [17.118612:118645]

∅:BD[21.71544] → [17.118664:118729]

∅:BD[58.88484] → [17.118664:118729]

∅:BD[59.76137] → [17.118664:118729]

B:BD[17.118664] → [17.118664:118729]

B:BD[17.118729] → [2.29282:29360]

∅:BD[2.29360] → [17.118729:118746]

B:BD[17.118729] → [17.118729:118746]

B:BD[17.118816] → [17.118816:118886]

∅:BD[2.29402] → [77.57890:57927]

∅:BD[21.71768] → [77.57890:57927]

B:BD[58.89382] → [77.57890:57927]

∅:BD[2.29506] → [77.58011:58028]

∅:BD[21.71879] → [77.58011:58028]

B:BD[77.58011] → [77.58011:58028]

B:BD[77.58609] → [64.45281:45352]

B:BD[77.58609] → [77.58609:58680]

∅:BD[2.29624] → [17.120691:120693]

∅:BD[60.66797] → [17.120691:120693]

∅:BD[77.58680] → [17.120691:120693]

∅:BD[21.72518] → [17.120691:120693]

∅:BD[58.90172] → [17.120691:120693]

∅:BD[64.45352] → [17.120691:120693]

∅:BD[102.49576] → [17.120691:120693]

∅:BD[59.77033] → [17.120691:120693]

B:BD[17.120691] → [17.120691:120693]

B:BD[17.152783] → [59.95669:95977]

B:BD[17.151855] → [59.95514:95668]

B:BD[17.151382] → [59.95364:95513]

B:BD[17.149559] → [59.94292:94456]

B:BD[17.150187] → [59.94457:95059]

B:BD[17.150933] → [59.95060:95363]

B:BD[17.150933] → [62.97296:97443]

B:BD[17.150187] → [62.97141:97295]

B:BD[17.150187] → [17.150187:150635]

B:BD[17.145404] → [59.91215:91512]

B:BD[17.146011] → [59.91513:93987]

B:BD[17.148951] → [59.93988:94139]

B:BD[17.149253] → [59.94140:94291]

B:BD[17.149253] → [58.109127:109278]

B:BD[17.149253] → [17.149253:149404]

B:BD[17.148951] → [58.108975:109126]

B:BD[17.148951] → [17.148951:149102]

B:BD[17.149102] → [17.149102:149253]

B:BD[17.146011] → [63.69555:69875]

B:BD[58.107119] → [102.52363:52516]

B:BD[58.107424] → [102.52517:52677]

B:BD[58.107891] → [64.53015:53174]

B:BD[58.108507] → [63.70191:70339]

B:BD[17.148800] → [17.148800:148951]

B:BD[58.108507] → [64.53175:53322]

B:BD[58.108507] → [58.108507:108654]

B:BD[58.108654] → [58.108654:108974]

B:BD[58.108507] → [62.96992:97140]

B:BD[58.108507] → [77.69112:69259]

B:BD[58.108507] → [60.74786:74933]

B:BD[58.107891] → [58.107891:108050]

B:BD[58.108050] → [58.108050:108507]

B:BD[58.107739] → [58.107739:107891]

B:BD[58.107891] → [77.68952:69111]

B:BD[58.107891] → [60.74626:74785]

B:BD[58.107424] → [63.70030:70190]

B:BD[58.107424] → [64.52699:53014]

B:BD[58.107424] → [58.107424:107584]

B:BD[58.107584] → [58.107584:107739]

B:BD[58.107424] → [62.96831:96991]

B:BD[58.107424] → [77.68636:68951]

B:BD[58.107424] → [60.74465:74625]

B:BD[58.107119] → [63.69876:70029]

B:BD[58.107119] → [64.52545:52698]

B:BD[58.107119] → [58.107119:107272]

B:BD[58.107272] → [58.107272:107424]

B:BD[58.106964] → [58.106964:107119]

B:BD[58.107119] → [62.96677:96830]

B:BD[58.107119] → [77.68482:68635]

B:BD[58.107119] → [60.74311:74464]

B:BD[17.146011] → [58.106185:106964]

B:BD[17.146011] → [62.95897:96676]

B:BD[17.146011] → [77.68161:68481]

B:BD[17.146011] → [60.73531:73851]

B:BD[60.73851] → [60.73851:74310]

B:BD[17.146011] → [17.146011:148800]

B:BD[17.144041] → [59.90455:90603]

B:BD[17.144338] → [59.90604:91061]

B:BD[17.144338] → [64.51784:52091]

B:BD[17.144338] → [58.105276:105432]

B:BD[58.105432] → [58.105432:105583]

B:BD[58.105432] → [62.95442:95593]

B:BD[58.105432] → [60.73076:73227]

B:BD[17.144338] → [77.67096:67403]

B:BD[17.144338] → [17.144338:144795]

B:BD[17.145249] → [17.145249:145404]

B:BD[58.106035] → [102.52213:52362]

B:BD[58.106035] → [63.69405:69554]

B:BD[58.106035] → [64.52395:52544]

B:BD[58.106035] → [58.106035:106184]

B:BD[58.106035] → [62.95747:95896]

B:BD[58.106035] → [77.67859:68160]

B:BD[58.106035] → [60.73381:73530]

B:BD[17.145701] → [17.145701:146011]

B:BD[17.144795] → [17.144795:144947]

B:BD[17.145097] → [59.91062:91214]

B:BD[17.145097] → [58.105734:105886]

B:BD[17.145097] → [62.95594:95746]

B:BD[17.145097] → [60.73228:73380]

B:BD[17.145097] → [17.145097:145249]

B:BD[17.136105] → [59.86047:86202]

B:BD[17.136414] → [59.86203:86356]

B:BD[17.136716] → [59.86357:87260]

B:BD[17.138993] → [59.87261:87564]

B:BD[17.139453] → [59.87565:87876]

B:BD[17.139921] → [59.87877:88472]

B:BD[17.140519] → [59.88473:88799]

B:BD[17.141150] → [59.88800:89855]

B:BD[17.142357] → [59.89856:90154]

B:BD[17.142966] → [59.90155:90304]

B:BD[17.143595] → [59.90305:90454]

B:BD[17.143595] → [63.68803:68952]

B:BD[17.143595] → [58.104828:104977]

B:BD[17.143595] → [62.95143:95292]

B:BD[17.143595] → [60.72777:72926]

B:BD[17.143595] → [17.143595:143893]

B:BD[17.144189] → [17.144189:144338]

B:BD[17.143893] → [17.143893:144041]

B:BD[17.142966] → [64.51485:51634]

B:BD[17.142966] → [58.104678:104827]

B:BD[17.142966] → [77.66647:66796]

B:BD[17.142966] → [17.142966:143115]

B:BD[17.143115] → [17.143115:143595]

B:BD[17.142805] → [17.142805:142966]

B:BD[17.142357] → [17.142357:142655]

B:BD[17.141150] → [63.68195:68500]

B:BD[58.104077] → [102.51448:51912]

B:BD[58.104077] → [63.68501:68802]

B:BD[58.104077] → [64.50881:51182]

B:BD[58.104077] → [58.104077:104224]

B:BD[17.142205] → [17.142205:142357]

B:BD[58.104224] → [58.104224:104378]

B:BD[58.104224] → [62.94836:94990]

B:BD[58.104224] → [60.72470:72624]

B:BD[58.103782] → [58.103782:104077]

B:BD[58.104077] → [77.65879:66343]

B:BD[17.141150] → [64.50575:50880]

B:BD[17.141150] → [58.103323:103782]

B:BD[17.141150] → [62.94376:94835]

B:BD[17.141150] → [77.65573:65878]

B:BD[17.141150] → [60.72010:72315]

B:BD[60.72315] → [60.72315:72469]

B:BD[17.141150] → [17.141150:142205]

B:BD[17.140519] → [102.51121:51447]

B:BD[17.140519] → [63.67868:68194]

B:BD[17.140519] → [64.50248:50574]

B:BD[17.140519] → [58.102996:103322]

B:BD[17.140519] → [77.65246:65572]

B:BD[17.140519] → [17.140519:140845]

B:BD[17.140845] → [17.140845:141150]

B:BD[17.139921] → [64.50101:50247]

B:BD[17.139921] → [58.102550:102696]

B:BD[17.139921] → [77.65099:65245]

B:BD[17.139921] → [17.139921:140366]

B:BD[58.102391] → [63.67709:67867]

B:BD[58.102391] → [64.49942:50100]

B:BD[58.102391] → [58.102391:102549]

B:BD[17.139453] → [58.102237:102391]

B:BD[17.139765] → [17.139765:139921]

B:BD[58.102391] → [62.94064:94222]

B:BD[58.102391] → [77.64940:65098]

B:BD[58.102391] → [60.71698:71856]

B:BD[17.139453] → [17.139453:139765]

B:BD[17.138993] → [102.50972:51120]

B:BD[17.139296] → [17.139296:139453]

B:BD[17.138993] → [63.67405:67708]

B:BD[17.138993] → [64.49481:49941]

B:BD[17.138993] → [58.101933:102236]

B:BD[17.138993] → [62.93760:94063]

B:BD[17.138993] → [65.31347:31495]

B:BD[17.138993] → [77.64479:64939]

B:BD[17.138993] → [60.71394:71542]

B:BD[60.71542] → [60.71542:71697]

B:BD[17.138993] → [17.138993:139141]

B:BD[17.139141] → [17.139141:139296]

B:BD[17.138993] → [93.63586:63734]

B:BD[17.136716] → [63.66946:67095]

B:BD[17.136716] → [58.99811:99960]

B:BD[58.99960] → [58.99960:100408]

B:BD[17.136716] → [62.93150:93299]

B:BD[17.136716] → [77.63866:64015]

B:BD[17.136716] → [60.70784:70933]

B:BD[17.136716] → [17.136716:138837]

B:BD[17.136414] → [58.99657:99810]

B:BD[17.136414] → [62.92996:93149]

B:BD[17.136414] → [60.70630:70783]

B:BD[17.136414] → [17.136414:136567]

B:BD[17.136567] → [17.136567:136716]

B:BD[17.135179] → [59.85433:86046]

B:BD[17.134250] → [59.84811:85432]

B:BD[17.131816] → [59.83891:84040]

B:BD[17.132117] → [59.84041:84191]

B:BD[17.132415] → [17.132415:132565]

B:BD[17.132117] → [58.97189:97340]

B:BD[58.97340] → [64.48098:48245]

B:BD[58.97340] → [77.62489:62636]

B:BD[17.132117] → [17.132117:132268]

B:BD[17.132268] → [17.132268:132415]

B:BD[17.131512] → [59.83736:83890]

B:BD[17.130306] → [59.82529:83735]

B:BD[17.127601] → [59.81323:81474]

B:BD[17.127910] → [59.81475:81777]

B:BD[17.128511] → [59.81778:81926]

B:BD[17.128810] → [59.81927:82229]

B:BD[17.129558] → [59.82230:82381]

B:BD[17.129856] → [59.82382:82528]

B:BD[17.129856] → [58.95676:95822]

B:BD[17.129856] → [17.129856:130002]

B:BD[17.129558] → [58.95524:95675]

B:BD[58.95675] → [64.47650:47797]

B:BD[58.95675] → [77.61881:62028]

B:BD[17.129558] → [17.129558:129709]

B:BD[17.129709] → [17.129709:129856]

B:BD[17.128810] → [58.95221:95373]

B:BD[17.129112] → [17.129112:129558]

B:BD[58.95373] → [63.65716:65866]

B:BD[58.95373] → [64.47499:47649]

B:BD[58.95373] → [58.95373:95523]

B:BD[58.95373] → [62.91454:91604]

B:BD[58.95373] → [77.61730:61880]

B:BD[58.95373] → [60.69087:69237]

B:BD[17.128810] → [17.128810:129112]

B:BD[17.128511] → [63.65567:65715]

B:BD[17.128511] → [58.95072:95220]

B:BD[17.128511] → [62.91305:91453]

B:BD[17.128511] → [77.61429:61577]

B:BD[17.128659] → [17.128659:128810]

B:BD[77.61577] → [77.61577:61729]

B:BD[17.128511] → [60.68938:69086]

B:BD[17.128511] → [17.128511:128659]

B:BD[17.127910] → [58.94621:94778]

B:BD[58.94924] → [58.94924:95071]

B:BD[58.94778] → [63.65420:65566]

B:BD[17.128360] → [17.128360:128511]

B:BD[58.94778] → [64.47352:47498]

B:BD[58.94778] → [58.94778:94924]

B:BD[58.94778] → [62.91158:91304]

B:BD[58.94778] → [77.61282:61428]

B:BD[58.94778] → [60.68791:68937]

B:BD[17.127910] → [17.127910:128360]

B:BD[17.125445] → [59.80401:81014]

B:BD[17.126056] → [59.81015:81322]

B:BD[17.126056] → [58.94004:94311]

B:BD[17.126056] → [17.126056:126363]

B:BD[17.124185] → [59.79459:79618]

B:BD[17.124505] → [59.79619:80400]

B:BD[58.92918] → [58.92918:93076]

B:BD[58.93234] → [58.93234:93392]

B:BD[58.93076] → [58.93076:93234]

B:BD[58.93076] → [60.68171:68329]

B:BD[17.124505] → [58.92760:92918]

B:BD[17.124505] → [62.90226:90696]

B:BD[17.124505] → [60.68012:68170]

B:BD[17.124505] → [17.124505:125290]

B:BD[58.93695] → [58.93695:94003]

B:BD[58.93695] → [62.90697:91005]

B:BD[58.93695] → [77.60826:60975]

B:BD[60.68485] → [63.65114:65267]

B:BD[60.68485] → [77.60976:61129]

B:BD[60.68485] → [60.68485:68638]

B:BD[17.125290] → [17.125290:125445]

B:BD[17.125902] → [17.125902:126056]

B:BD[17.122381] → [59.78255:79013]

B:BD[17.123442] → [59.79014:79309]

B:BD[17.123886] → [59.79310:79458]

B:BD[17.123886] → [63.64644:64792]

B:BD[17.123886] → [58.92611:92759]

B:BD[17.123886] → [62.90077:90225]

B:BD[17.123886] → [77.60356:60504]

B:BD[17.123886] → [60.67863:68011]

B:BD[17.123886] → [17.123886:124034]

B:BD[17.123442] → [63.64348:64643]

B:BD[17.123442] → [64.46583:46878]

B:BD[17.123442] → [58.92315:92610]

B:BD[17.123442] → [62.89781:90076]

B:BD[17.123442] → [77.60060:60355]

B:BD[17.123442] → [60.67567:67862]

B:BD[17.123442] → [17.123442:123737]

B:BD[17.123737] → [17.123737:123886]

B:BD[17.121168] → [59.77190:77643]

B:BD[17.121620] → [59.77644:78254]

B:BD[58.91549] → [102.49730:50041]

B:BD[58.91549] → [63.63886:64197]

B:BD[58.91549] → [64.46118:46429]

B:BD[58.91549] → [58.91549:91704]

B:BD[58.91704] → [58.91704:91860]

B:BD[58.91549] → [62.89475:89630]

B:BD[58.91549] → [77.59446:59757]

B:BD[58.91549] → [60.67261:67416]

B:BD[17.121620] → [64.45662:45965]

B:BD[17.121620] → [58.90789:90939]

B:BD[58.91092] → [58.91092:91249]

B:BD[58.90939] → [63.63732:63885]

B:BD[58.90939] → [58.90939:91092]

B:BD[58.90939] → [62.89321:89474]

B:BD[58.90939] → [60.67107:67260]

B:BD[17.121620] → [77.58990:59293]

B:BD[17.121620] → [17.121620:122230]

B:BD[17.122230] → [17.122230:122381]

B:BD[17.122530] → [65.31191:31346]

B:BD[17.123295] → [17.123295:123442]

B:BD[17.122530] → [17.122530:122685]

B:BD[17.122685] → [17.122685:123295]

B:BD[17.122530] → [93.63430:63585]

B:BD[17.120705] → [59.77034:77189]

B:BD[17.144947] → [102.52062:52212]

B:BD[17.144041] → [102.51913:52061]

B:BD[17.136105] → [102.50816:50971]

B:BD[17.132712] → [102.50512:50665]

B:BD[17.133013] → [59.84192:84506]

B:BD[17.133635] → [59.84507:84810]

B:BD[17.133635] → [58.97656:97808]

B:BD[58.97963] → [63.66481:66633]

B:BD[58.97963] → [64.48861:49013]

B:BD[58.97963] → [58.97963:98115]

B:BD[58.97963] → [62.92687:92839]

B:BD[58.97963] → [77.63401:63553]

B:BD[58.97963] → [60.70321:70473]

B:BD[58.97808] → [58.97808:97963]

B:BD[17.133635] → [62.92535:92686]

B:BD[17.133635] → [60.70168:70320]

B:BD[60.70320] → [102.50666:50815]

B:BD[17.133635] → [17.133635:134094]

B:BD[17.133013] → [58.97341:97505]

B:BD[58.97655] → [64.48400:48860]

B:BD[58.97655] → [77.62791:63400]

B:BD[58.97505] → [58.97505:97655]

B:BD[17.133013] → [62.92370:92534]

B:BD[17.133013] → [60.70003:70167]

B:BD[17.133013] → [17.133013:133327]

B:BD[17.133327] → [17.133327:133635]

B:BD[17.124185] → [102.50042:50362]

B:BD[17.121168] → [102.49577:49729]

B:BD[17.121472] → [17.121472:121620]

B:BD[17.151382] → [63.70340:70489]

B:BD[17.144947] → [63.69102:69404]

B:BD[17.144041] → [63.68953:69101]

B:BD[58.101775] → [63.67247:67404]

B:BD[17.136105] → [63.66790:66945]

B:BD[17.134250] → [63.66634:66789]

B:BD[17.132712] → [63.66327:66480]

B:BD[17.127601] → [63.65268:65419]

B:BD[17.124185] → [63.64793:65113]

B:BD[17.121168] → [63.63580:63731]

B:BD[17.120705] → [63.63268:63579]

B:BD[17.144041] → [86.35018:35166]

B:BD[17.121168] → [86.34865:35017]

B:BD[58.109738] → [64.53323:53477]

B:BD[58.105733] → [64.52092:52394]

B:BD[17.144041] → [64.51635:51783]

B:BD[58.104526] → [64.51183:51484]

B:BD[17.136105] → [64.49170:49325]

B:BD[17.134250] → [64.49014:49169]

B:BD[17.132712] → [64.48246:48399]

B:BD[17.127601] → [64.47200:47351]

B:BD[17.124185] → [64.46879:47199]

B:BD[58.92013] → [64.46430:46582]

B:BD[58.91399] → [64.45966:46117]

B:BD[17.121168] → [64.45509:45661]

B:BD[17.120705] → [64.45353:45508]

B:BD[17.152783] → [58.110198:110506]

B:BD[58.110506] → [58.110506:110662]

B:BD[58.110506] → [77.69565:69721]

B:BD[58.110506] → [60.75084:75240]

B:BD[17.151855] → [58.110043:110197]

B:BD[17.151382] → [58.109893:110042]

B:BD[58.109738] → [58.109738:109892]

B:BD[58.109590] → [58.109590:109738]

B:BD[17.149559] → [58.109279:109443]

B:BD[17.145404] → [58.105887:106035]

B:BD[58.105583] → [58.105583:105733]

B:BD[17.144041] → [58.105127:105275]

B:BD[58.104977] → [58.104977:105126]

B:BD[58.104526] → [58.104526:104677]

B:BD[17.142357] → [58.104379:104526]

B:BD[58.102843] → [58.102843:102995]

B:BD[58.102696] → [58.102696:102843]

B:BD[58.101775] → [58.101775:101932]

B:BD[58.101626] → [58.101626:101775]

B:BD[58.101470] → [58.101470:101626]

B:BD[58.100560] → [58.100560:101015]

B:BD[58.101169] → [63.67096:67246]

B:BD[58.101169] → [58.101169:101470]

B:BD[58.101169] → [62.93300:93601]

B:BD[58.101169] → [60.70934:71084]

B:BD[60.71084] → [60.71084:71235]

B:BD[58.101015] → [64.49326:49480]

B:BD[58.101015] → [58.101015:101169]

B:BD[58.101015] → [77.64016:64170]

B:BD[58.100408] → [58.100408:100560]

B:BD[17.136105] → [58.99501:99656]

B:BD[17.135179] → [58.98887:99500]

B:BD[58.98737] → [58.98737:98886]

B:BD[17.135792] → [17.135792:135946]

B:BD[17.134250] → [58.98116:98271]

B:BD[58.98271] → [58.98271:98737]

B:BD[17.131816] → [58.97039:97188]

B:BD[17.131512] → [58.96884:97038]

B:BD[17.130306] → [58.95823:95977]

B:BD[58.96128] → [102.50363:50511]

B:BD[58.96731] → [63.66174:66326]

B:BD[58.96731] → [58.96731:96883]

B:BD[58.96434] → [58.96434:96731]

B:BD[58.96731] → [62.92067:92219]

B:BD[58.96731] → [60.69700:69852]

B:BD[58.96128] → [63.65867:66173]

B:BD[58.96128] → [58.96128:96434]

B:BD[58.96128] → [62.91760:92066]

B:BD[58.96128] → [60.69393:69541]

B:BD[60.69541] → [60.69541:69699]

B:BD[58.95977] → [58.95977:96128]

B:BD[17.127601] → [58.94469:94620]

B:BD[17.126980] → [58.94312:94468]

B:BD[17.125445] → [58.93546:93695]

B:BD[58.93695] → [60.68330:68485]

B:BD[58.93392] → [58.93392:93545]

B:BD[58.92013] → [58.92013:92165]

B:BD[58.92165] → [63.64198:64347]

B:BD[58.92165] → [58.92165:92314]

B:BD[58.92165] → [62.89631:89780]

B:BD[58.92165] → [60.67417:67566]

B:BD[58.91860] → [58.91860:92013]

B:BD[77.59910] → [77.59910:60059]

B:BD[17.122381] → [58.91400:91549]

B:BD[58.91249] → [58.91249:91399]

B:BD[17.121168] → [58.90484:90636]

B:BD[58.90636] → [58.90636:90788]

B:BD[17.120705] → [58.90173:90328]

B:BD[58.90328] → [58.90328:90483]

B:BD[58.90328] → [62.89013:89168]

B:BD[58.90328] → [60.66798:66953]

B:BD[17.151382] → [62.97444:97593]

B:BD[17.144041] → [62.95293:95441]

B:BD[58.104526] → [62.94991:95142]

B:BD[58.102843] → [62.94223:94375]

B:BD[58.101775] → [62.93602:93759]

B:BD[17.134250] → [62.92840:92995]

B:BD[17.131816] → [62.92220:92369]

B:BD[17.130306] → [62.91605:91759]

B:BD[17.127601] → [62.91006:91157]

B:BD[17.121168] → [62.89169:89320]

B:BD[17.152783] → [21.96874:97109]

B:BD[17.152180] → [21.96724:96873]

B:BD[17.151855] → [21.96569:96723]

B:BD[17.151382] → [21.96419:96568]

B:BD[58.109738] → [21.95478:96418]

B:BD[17.149559] → [21.94693:95477]

B:BD[77.67858] → [21.91853:94692]

B:BD[58.105733] → [21.91700:91852]

B:BD[58.105126] → [21.91245:91699]

B:BD[58.104526] → [21.90624:91244]

B:BD[58.102843] → [21.88927:90623]

B:BD[58.101775] → [21.87850:88926]

B:BD[77.64320] → [21.87698:87849]

B:BD[58.100560] → [21.87243:87697]

B:BD[17.136105] → [21.86012:87242]

B:BD[58.98886] → [21.84306:86011]

B:BD[17.134250] → [21.84150:84305]

B:BD[17.132712] → [21.82614:84149]

B:BD[17.131816] → [21.81935:82613]

B:BD[17.131512] → [21.81627:81934]

B:BD[17.130306] → [21.81019:81626]

B:BD[17.127601] → [21.76626:81018]

B:BD[17.126515] → [21.76479:76625]

B:BD[58.93545] → [21.75713:76478]

B:BD[17.124185] → [21.75392:75712]

B:BD[58.92013] → [21.74497:75391]

B:BD[58.91399] → [21.73735:74496]

B:BD[17.121168] → [21.72977:73734]

B:BD[17.120705] → [21.72519:72976]

B:BD[17.151382] → [77.69415:69564]

B:BD[58.109738] → [77.69260:69414]

B:BD[77.67706] → [77.67706:67858]

B:BD[58.105733] → [77.67404:67706]

B:BD[17.144041] → [77.66947:67095]

B:BD[17.143595] → [77.66797:66946]

B:BD[58.104526] → [77.66344:66646]

B:BD[58.101775] → [77.64321:64478]

B:BD[77.64170] → [77.64170:64320]

B:BD[17.136105] → [77.63710:63865]

B:BD[17.134250] → [77.63554:63709]

B:BD[17.132712] → [77.62637:62790]

B:BD[58.96731] → [77.62336:62488]

B:BD[17.127601] → [77.61130:61281]

B:BD[17.124185] → [77.60505:60825]

B:BD[58.92013] → [77.59758:59910]

B:BD[58.91399] → [77.59294:59445]

B:BD[17.121168] → [77.58837:58989]

B:BD[17.120705] → [77.58681:58836]

B:BD[17.151382] → [60.74934:75083]

B:BD[17.144041] → [60.72927:73075]

B:BD[58.104526] → [60.72625:72776]

B:BD[58.102843] → [60.71857:72009]

B:BD[58.101775] → [60.71236:71393]

B:BD[17.134250] → [60.70474:70629]

B:BD[17.131816] → [60.69853:70002]

B:BD[17.130306] → [60.69238:69392]

B:BD[77.62177] → [77.62177:62335]

B:BD[60.69392] → [64.47798:48097]

B:BD[60.69392] → [77.62029:62177]

B:BD[17.127601] → [60.68639:68790]

B:BD[17.121168] → [60.66954:67106]

B:BD[17.152783] → [17.152783:153247]

B:BD[17.152630] → [17.152630:152783]

B:BD[17.152180] → [17.152180:152630]

B:BD[17.152009] → [17.152009:152180]

B:BD[17.151855] → [17.151855:152009]

B:BD[17.151531] → [17.151531:151855]

B:BD[17.151382] → [17.151382:151531]

B:BD[17.151233] → [17.151233:151382]

B:BD[17.150635] → [17.150635:150933]

B:BD[17.150933] → [17.150933:151233]

B:BD[17.149559] → [17.149559:149723]

B:BD[17.149723] → [17.149723:150187]

B:BD[17.150187] → [58.109444:109590]

B:BD[17.149404] → [17.149404:149559]

B:BD[17.145404] → [17.145404:145701]

B:BD[17.144947] → [17.144947:145097]

B:BD[17.144041] → [17.144041:144189]

B:BD[17.142655] → [17.142655:142805]

B:BD[17.140366] → [17.140366:140519]

B:BD[17.138837] → [17.138837:138993]

B:BD[17.136105] → [17.136105:136260]

B:BD[17.136260] → [17.136260:136414]

B:BD[17.135946] → [17.135946:136105]

B:BD[17.135179] → [17.135179:135792]

B:BD[17.134250] → [17.134250:135020]

B:BD[17.135020] → [17.135020:135179]

B:BD[17.134094] → [17.134094:134250]

B:BD[17.132712] → [17.132712:132865]

B:BD[17.132865] → [17.132865:133013]

B:BD[17.132565] → [17.132565:132712]

B:BD[17.131816] → [17.131816:131965]

B:BD[17.131965] → [17.131965:132117]

B:BD[17.131666] → [17.131666:131816]

B:BD[17.131512] → [17.131512:131666]

B:BD[17.131366] → [17.131366:131512]

B:BD[17.130306] → [17.130306:131366]

B:BD[17.130002] → [17.130002:130306]

B:BD[17.127601] → [17.127601:127752]

B:BD[17.127752] → [17.127752:127910]

B:BD[17.127136] → [17.127136:127601]

B:BD[17.126980] → [17.126980:127136]

B:BD[17.126661] → [17.126661:126980]

B:BD[17.126515] → [17.126515:126661]

B:BD[17.126363] → [17.126363:126515]

B:BD[17.125445] → [17.125445:125902]

B:BD[17.124185] → [17.124185:124505]

B:BD[17.124034] → [17.124034:124185]

B:BD[17.122381] → [17.122381:122530]

B:BD[17.121168] → [17.121168:121320]

B:BD[17.121320] → [17.121320:121472]

B:BD[17.121015] → [17.121015:121168]

B:BD[17.120705] → [17.120705:121015]

B:BD[17.120693] → [17.120693:120705]

B:BD[77.58028] → [21.71880:72518]

B:BD[77.58028] → [77.58028:58609]

B:BD[77.58028] → [2.29507:29624]

B:BD[77.57927] → [21.71769:71788]

B:BD[21.71788] → [21.71788:71879]

B:BD[21.71788] → [2.29403:29506]

B:BD[77.57927] → [77.57927:58011]

B:BD[17.119036] → [17.119036:119073]

B:BD[17.119092] → [17.119092:119174]

B:BD[17.120186] → [17.120186:120259]

B:BD[58.89236] → [102.49433:49504]

B:BD[58.89382] → [58.89382:90172]

B:BD[58.89382] → [60.66007:66726]

B:BD[60.66726] → [102.49505:49576]

B:BD[60.66726] → [60.66726:66797]

B:BD[58.89236] → [63.63196:63267]

B:BD[58.89236] → [64.45209:45280]

B:BD[58.89236] → [58.89236:89307]

B:BD[58.89307] → [58.89307:89382]

B:BD[58.89236] → [77.57818:57889]

B:BD[17.120259] → [59.76527:77033]

B:BD[17.120259] → [58.88875:89236]

B:BD[17.120259] → [17.120259:120691]

B:BD[17.119174] → [59.76380:76526]

B:BD[17.119174] → [58.88727:88874]

B:BD[17.119174] → [17.119174:120186]

B:BD[17.119073] → [59.76360:76379]

B:BD[17.119073] → [58.88707:88726]

B:BD[17.119073] → [17.119073:119092]

B:BD[17.118886] → [59.76209:76359]

B:BD[17.118886] → [58.88556:88706]

B:BD[17.118886] → [21.71617:71768]

B:BD[17.118886] → [17.118886:119036]

B:BD[17.118746] → [59.76138:76208]

B:BD[17.118746] → [58.88485:88555]

B:BD[17.118746] → [21.71545:71616]

B:BD[17.118746] → [2.29361:29402]

B:BD[17.118746] → [17.118746:118816]

B:BD[17.118645] → [59.76118:76137]

B:BD[17.118645] → [58.88465:88484]

B:BD[17.118645] → [21.71525:71544]

B:BD[17.118645] → [17.118645:118664]

B:BD[17.118460] → [2.29247:29281]

B:BD[17.118460] → [17.118460:118612]

B:BD[17.118325] → [17.118325:118340]

B:BD[17.118252] → [17.118252:118325]

B:BD[17.118135] → [17.118135:118252]

B:BD[17.118047] → [59.75970:76043]

B:BD[17.118047] → [63.63048:63121]

B:BD[17.118047] → [58.88317:88390]

B:BD[17.118047] → [62.88865:88938]

B:BD[17.118047] → [21.71451:71524]

B:BD[17.118047] → [77.57670:57743]

B:BD[17.118047] → [60.65859:65932]

B:BD[17.118047] → [2.29150:29167]

B:BD[17.118047] → [17.118047:118120]

B:BD[17.117947] → [21.71432:71450]

B:BD[17.117947] → [17.117947:117965]

B:BD[17.117916] → [17.117916:117931]

B:BD[17.117765] → [17.117765:117916]

B:BD[17.117647] → [17.117647:117765]

B:BD[20.45711] → [20.45711:45713]

B:BD[20.45568] → [20.45568:45638]

B:BD[20.45638] → [40.15518:15591]

B:BD[20.45638] → [41.10351:10424]

B:BD[20.45638] → [111.10133:10206]

B:BD[20.45638] → [42.26907:26980]

B:BD[20.45638] → [44.6359:6432]

B:BD[20.45638] → [33.13699:13772]

B:BD[20.45638] → [50.7654:7727]

B:BD[20.45638] → [51.10687:10760]

B:BD[20.45638] → [20.45638:45711]

B:BD[20.45638] → [54.19543:19616]

B:BD[20.45638] → [55.44581:44654]

B:BD[20.45638] → [37.18771:18844]

B:BD[20.45415] → [20.45415:45568]

B:BD[20.45396] → [20.45396:45415]

B:BD[20.45361] → [20.45361:45396]

B:BD[20.45137] → [20.45137:45289]

B:BD[20.45289] → [40.15445:15517]

B:BD[20.45289] → [41.10278:10350]

B:BD[20.45289] → [111.10060:10132]

B:BD[20.45289] → [44.6286:6358]

B:BD[20.45289] → [33.13626:13698]

B:BD[20.45289] → [50.7581:7653]

B:BD[20.45289] → [51.10614:10686]

B:BD[20.45289] → [20.45289:45361]

B:BD[20.45289] → [37.18678:18750]

B:BD[20.45055] → [20.45055:45137]

B:BD[20.45036] → [20.45036:45055]

B:BD[20.44936] → [20.44936:45036]

B:BD[20.44917] → [20.44917:44936]

B:BD[20.44887] → [20.44887:44917]

B:BD[20.43832] → [20.43832:43904]

B:BD[20.43981] → [41.9857:9931]

B:BD[40.15026] → [40.15026:15096]

B:BD[20.44199] → [42.26086:26387]

B:BD[20.44658] → [40.15251:15328]

B:BD[20.44807] → [40.15329:15404]

B:BD[20.44807] → [42.26466:26621]

B:BD[20.44807] → [84.3977:4052]

B:BD[20.44807] → [20.44807:44887]

B:BD[20.44807] → [83.10705:10780]

B:BD[20.44807] → [81.10303:10378]

B:BD[20.44807] → [54.19177:19257]

B:BD[20.44807] → [55.44140:44295]

B:BD[20.44807] → [37.18562:18637]

B:BD[20.44658] → [41.10160:10237]

B:BD[20.44658] → [42.26388:26465]

B:BD[20.44658] → [44.6168:6245]

B:BD[20.44658] → [33.13508:13585]

B:BD[20.44658] → [51.10496:10573]

B:BD[20.44658] → [20.44658:44735]

B:BD[20.44735] → [20.44735:44807]

B:BD[20.44658] → [54.19099:19176]

B:BD[20.44658] → [55.44062:44139]

B:BD[20.44658] → [37.18484:18561]

B:BD[20.44199] → [20.44199:44273]

B:BD[20.44426] → [20.44426:44499]

B:BD[20.44499] → [20.44499:44658]

B:BD[20.44273] → [40.15097:15250]

B:BD[20.44273] → [41.10006:10159]

B:BD[20.44273] → [111.9866:10019]

B:BD[20.44273] → [44.6014:6167]

B:BD[20.44273] → [33.13354:13507]

B:BD[20.44273] → [50.7387:7540]

B:BD[20.44273] → [51.10342:10495]

B:BD[20.44273] → [20.44273:44426]

B:BD[20.44273] → [37.18330:18483]

B:BD[20.44199] → [54.18798:19098]

B:BD[20.44199] → [55.43760:44061]

B:BD[20.44129] → [20.44129:44199]

B:BD[41.9931] → [40.14952:15026]

B:BD[41.9931] → [41.9931:10005]

B:BD[41.9931] → [37.18255:18329]

B:BD[20.43981] → [42.25937:26085]

B:BD[22.15515] → [43.33402:33476]

B:BD[22.15515] → [22.15515:15663]

B:BD[20.43981] → [33.13205:13353]

B:BD[22.15515] → [48.25852:26000]

B:BD[20.43981] → [20.43981:44055]

B:BD[20.44055] → [111.9791:9865]

B:BD[20.44055] → [44.5939:6013]

B:BD[20.44055] → [50.7312:7386]

B:BD[20.44055] → [51.10267:10341]

B:BD[20.44055] → [20.44055:44129]

B:BD[22.15515] → [53.15310:15458]

B:BD[20.43981] → [54.18649:18797]

B:BD[20.43981] → [55.43611:43759]

B:BD[20.43904] → [24.13093:13167]

B:BD[20.43904] → [92.6765:6842]

B:BD[20.43904] → [70.7294:7371]

B:BD[20.43904] → [47.16146:16223]

B:BD[20.43904] → [22.15438:15515]

B:BD[20.43904] → [20.43904:43981]

B:BD[20.43904] → [39.7137:7214]

B:BD[22.16584] → [52.12477:12550]

B:BD[20.45396] → [52.12457:12476]

B:BD[20.45036] → [52.12364:12383]

B:BD[20.44917] → [52.12344:12363]

B:BD[22.16584] → [38.20701:20774]

B:BD[20.45396] → [38.20681:20700]

B:BD[20.45036] → [38.20588:20607]

B:BD[20.44917] → [38.20568:20587]

B:BD[22.16584] → [53.16279:16352]

B:BD[20.45396] → [53.16259:16278]

B:BD[20.45137] → [53.16034:16258]

B:BD[20.45036] → [53.16014:16033]

B:BD[20.44917] → [53.15994:16013]

B:BD[22.16040] → [53.15760:15837]

B:BD[22.15733] → [53.15459:15759]

B:BD[20.45396] → [54.19523:19542]

B:BD[20.45137] → [54.19298:19522]

B:BD[20.45036] → [54.19278:19297]

B:BD[20.44917] → [54.19258:19277]

B:BD[20.45396] → [55.44561:44580]

B:BD[20.45137] → [55.44336:44560]

B:BD[20.45036] → [55.44316:44335]

B:BD[20.44917] → [55.44296:44315]

B:BD[20.45396] → [37.18751:18770]

B:BD[20.45036] → [37.18658:18677]

B:BD[20.44917] → [37.18638:18657]

B:BD[22.16584] → [71.5765:5838]

B:BD[20.45036] → [71.5745:5764]

B:BD[20.44917] → [71.5725:5744]

B:BD[20.43815] → [20.43815:43832]

∅:BD[21.70652] → [17.115272:115337]

B:BD[20.43815] → [17.115272:115337]

B:BD[17.115337] → [2.27521:27599]

∅:BD[2.27599] → [17.115337:115350]

B:BD[17.115337] → [17.115337:115350]

B:BD[17.115350] → [59.75065:75272]

B:BD[17.115350] → [62.88303:88510]

∅:BD[62.88510] → [17.115350:115363]

∅:BD[59.75272] → [17.115350:115363]

B:BD[17.115350] → [17.115350:115363]

∅:BD[21.70671] → [17.115381:115446]

∅:BD[58.87868] → [17.115381:115446]

∅:BD[59.75291] → [17.115381:115446]

B:BD[17.115381] → [17.115381:115446]

B:BD[17.115446] → [2.27600:27678]

∅:BD[2.27678] → [17.115446:115463]

B:BD[17.115446] → [17.115446:115463]

B:BD[17.115534] → [17.115534:115608]

∅:BD[2.27721] → [17.115691:115721]

∅:BD[21.70827] → [17.115691:115721]

B:BD[17.115691] → [17.115691:115721]

B:BD[17.115739] → [17.115739:115838]

∅:BD[77.57426] → [17.115856:115921]

∅:BD[58.87906] → [17.115856:115921]

∅:BD[64.45132] → [17.115856:115921]

∅:BD[59.75329] → [17.115856:115921]

B:BD[17.115856] → [17.115856:115921]

B:BD[17.115921] → [2.27722:27800]

∅:BD[2.27800] → [17.115921:115949]

B:BD[17.115921] → [17.115921:115949]

∅:BD[21.70847] → [17.115967:116032]

B:BD[17.115967] → [17.115967:116032]

B:BD[17.116032] → [2.27801:27879]

∅:BD[2.27879] → [17.116032:116062]

B:BD[17.116032] → [17.116032:116062]

B:BD[17.116080] → [59.75330:75559]

∅:BD[21.70866] → [17.116080:116145]

∅:BD[59.75559] → [17.116080:116145]

B:BD[17.116080] → [17.116080:116145]

B:BD[17.116145] → [2.27880:27958]

∅:BD[2.27958] → [17.116145:116158]

B:BD[17.116145] → [17.116145:116158]

B:BD[17.116158] → [62.88511:88621]

B:BD[17.116158] → [2.27959:28156]

∅:BD[2.28156] → [17.116158:116172]

∅:BD[62.88621] → [17.116158:116172]

B:BD[17.116158] → [17.116158:116172]

∅:BD[21.70885] → [17.116190:116255]

B:BD[17.116190] → [17.116190:116255]

B:BD[17.116255] → [2.28157:28235]

∅:BD[2.28235] → [17.116255:116272]

B:BD[17.116255] → [17.116255:116272]

B:BD[58.87982] → [58.87982:88052]

∅:BD[2.28257] → [17.116492:116494]

∅:BD[21.71032] → [17.116492:116494]

B:BD[17.116492] → [17.116492:116494]

B:BD[17.116494] → [21.71033:71166]

∅:BD[2.28336] → [21.71166:71300]

B:BD[21.71166] → [21.71166:71300]

B:BD[21.71300] → [2.28337:28415]

B:BD[21.71166] → [2.28258:28336]

∅:BD[2.28415] → [17.116494:116527]

∅:BD[21.71300] → [17.116494:116527]

B:BD[17.116494] → [17.116494:116527]

∅:BD[2.28434] → [17.116545:116610]

∅:BD[21.71319] → [17.116545:116610]

B:BD[17.116545] → [17.116545:116610]

B:BD[17.116610] → [2.28435:28513]

∅:BD[2.28513] → [17.116610:116722]

B:BD[17.116610] → [17.116610:116722]

B:BD[17.116722] → [2.28514:28592]

∅:BD[2.28592] → [17.116722:116751]

B:BD[17.116722] → [17.116722:116751]

∅:BD[60.65710] → [17.116769:116834]

∅:BD[77.57521] → [17.116769:116834]

∅:BD[21.71338] → [17.116769:116834]

∅:BD[62.88716] → [17.116769:116834]

∅:BD[58.88071] → [17.116769:116834]

∅:BD[63.62899] → [17.116769:116834]

∅:BD[59.75724] → [17.116769:116834]

B:BD[17.116769] → [17.116769:116834]

B:BD[17.116834] → [2.28593:28671]

∅:BD[2.28671] → [17.116834:116851]

B:BD[17.116834] → [17.116834:116851]

∅:BD[2.28736] → [17.117039:117159]

B:BD[17.117039] → [17.117039:117159]

B:BD[17.117159] → [2.28737:28815]

∅:BD[2.28815] → [17.117159:117291]

B:BD[17.117159] → [17.117159:117291]

B:BD[17.117291] → [2.28816:28894]

∅:BD[2.28894] → [17.117291:117325]

B:BD[17.117291] → [17.117291:117325]

∅:BD[21.71357] → [17.117343:117408]

∅:BD[58.88090] → [17.117343:117408]

∅:BD[59.75743] → [17.117343:117408]

B:BD[17.117343] → [17.117343:117408]

B:BD[17.117408] → [2.28895:28973]

∅:BD[2.28973] → [17.117408:117425]

B:BD[17.117408] → [17.117408:117425]

∅:BD[2.28991] → [17.117498:117634]

∅:BD[60.65784] → [17.117498:117634]

∅:BD[77.57595] → [17.117498:117634]

∅:BD[21.71431] → [17.117498:117634]

∅:BD[62.88790] → [17.117498:117634]

∅:BD[58.88164] → [17.117498:117634]

∅:BD[63.62973] → [17.117498:117634]

∅:BD[59.75817] → [17.117498:117634]

B:BD[17.117498] → [17.117498:117634]

B:BD[17.117634] → [2.28992:29070]

B:BD[17.117425] → [59.75744:75817]

B:BD[17.117425] → [63.62900:62973]

B:BD[17.117425] → [58.88091:88164]

B:BD[17.117425] → [62.88717:88790]

B:BD[17.117425] → [21.71358:71431]

B:BD[17.117425] → [77.57522:57595]

B:BD[17.117425] → [60.65711:65784]

B:BD[17.117425] → [2.28974:28991]

B:BD[17.117425] → [17.117425:117498]

B:BD[17.117325] → [59.75725:75743]

B:BD[17.117325] → [58.88072:88090]

B:BD[17.117325] → [21.71339:71357]

B:BD[17.117325] → [17.117325:117343]

B:BD[17.116851] → [2.28672:28736]

B:BD[17.116851] → [17.116851:117039]

B:BD[17.116751] → [59.75706:75724]

B:BD[17.116751] → [63.62881:62899]

B:BD[17.116751] → [58.88053:88071]

B:BD[17.116751] → [62.88698:88716]

B:BD[17.116751] → [21.71320:71338]

B:BD[17.116751] → [77.57503:57521]

B:BD[17.116751] → [60.65692:65710]

B:BD[17.116751] → [17.116751:116769]

B:BD[17.116527] → [21.71301:71319]

B:BD[17.116527] → [2.28416:28434]

B:BD[17.116527] → [17.116527:116545]

B:BD[17.116417] → [17.116417:116492]

B:BD[17.116272] → [59.75560:75705]

B:BD[17.116272] → [63.62805:62880]

B:BD[17.116272] → [64.45133:45208]

B:BD[17.116272] → [58.87907:87982]

B:BD[17.116272] → [62.88622:88697]

B:BD[17.116272] → [21.70886:71032]

B:BD[17.116272] → [77.57427:57502]

B:BD[17.116272] → [60.65616:65691]

B:BD[17.116272] → [2.28236:28257]

B:BD[17.116272] → [17.116272:116417]

B:BD[17.116172] → [21.70867:70885]

B:BD[17.116172] → [17.116172:116190]

B:BD[17.116062] → [21.70848:70866]

B:BD[17.116062] → [17.116062:116080]

B:BD[17.115949] → [21.70828:70847]

B:BD[17.115949] → [17.115949:115967]

B:BD[17.115838] → [59.75311:75329]

B:BD[17.115838] → [64.45114:45132]

B:BD[17.115838] → [58.87888:87906]

B:BD[17.115838] → [77.57408:57426]

B:BD[17.115838] → [17.115838:115856]

B:BD[17.115721] → [59.75292:75310]

B:BD[17.115721] → [58.87869:87887]

B:BD[17.115721] → [17.115721:115739]

B:BD[17.115608] → [21.70744:70827]

B:BD[17.115608] → [17.115608:115691]

B:BD[17.115463] → [21.70672:70743]

B:BD[17.115463] → [2.27679:27721]

B:BD[17.115463] → [17.115463:115534]

B:BD[17.115363] → [59.75273:75291]

B:BD[17.115363] → [58.87850:87868]

B:BD[17.115363] → [21.70653:70671]

B:BD[17.115363] → [17.115363:115381]

B:BD[10.12238] → [17.90992:91027]

B:BD[17.91324] → [73.35363:35441]

B:BD[17.91775] → [59.62206:62513]

B:BD[58.73948] → [63.56187:56414]

B:BD[58.73948] → [64.39230:39301]

B:BD[58.73948] → [58.73948:74099]

B:BD[17.91775] → [58.73792:73948]

B:BD[77.48253] → [77.48253:48333]

B:BD[58.73948] → [62.79407:79634]

B:BD[58.73948] → [77.48182:48253]

B:BD[58.73948] → [60.56519:56670]

B:BD[17.91775] → [17.91775:92082]

B:BD[58.73194] → [58.73194:73268]

B:BD[58.73420] → [58.73420:73565]

B:BD[60.56445] → [102.46843:46916]

B:BD[60.56445] → [60.56445:56518]

B:BD[58.73565] → [63.55960:56186]

B:BD[58.73565] → [64.39003:39229]

B:BD[58.73565] → [58.73565:73791]

B:BD[58.73565] → [62.79180:79406]

B:BD[58.73565] → [77.47955:48181]

B:BD[58.73565] → [60.56292:56445]

B:BD[60.56213] → [60.56213:56291]

B:BD[58.73268] → [63.55885:55959]

B:BD[58.73268] → [64.38928:39002]

B:BD[58.73268] → [58.73268:73420]

B:BD[58.73268] → [62.79105:79179]

B:BD[58.73268] → [77.47802:47954]

B:BD[58.73268] → [60.56139:56213]

∅:BD[2.21264] → [17.92082:92112]

∅:BD[60.56670] → [17.92082:92112]

∅:BD[77.48333] → [17.92082:92112]

∅:BD[21.59932] → [17.92082:92112]

∅:BD[62.79634] → [17.92082:92112]

∅:BD[58.74099] → [17.92082:92112]

∅:BD[63.56414] → [17.92082:92112]

∅:BD[59.62513] → [17.92082:92112]

B:BD[17.92082] → [17.92082:92112]

∅:BD[2.21285] → [17.92131:92196]

∅:BD[60.56690] → [17.92131:92196]

∅:BD[77.48353] → [17.92131:92196]

∅:BD[21.59953] → [17.92131:92196]

∅:BD[62.79654] → [17.92131:92196]

∅:BD[58.74119] → [17.92131:92196]

∅:BD[64.39321] → [17.92131:92196]

∅:BD[63.56434] → [17.92131:92196]

∅:BD[59.62533] → [17.92131:92196]

B:BD[17.92131] → [17.92131:92196]

B:BD[17.92196] → [2.21286:21364]

∅:BD[2.21364] → [17.92196:92231]

B:BD[17.92196] → [17.92196:92231]

∅:BD[2.21385] → [17.92250:92315]

∅:BD[60.56710] → [17.92250:92315]

∅:BD[77.48373] → [17.92250:92315]

∅:BD[21.59974] → [17.92250:92315]

∅:BD[62.79674] → [17.92250:92315]

∅:BD[58.74139] → [17.92250:92315]

∅:BD[64.39341] → [17.92250:92315]

∅:BD[63.56454] → [17.92250:92315]

∅:BD[59.62553] → [17.92250:92315]

B:BD[17.92250] → [17.92250:92315]

B:BD[17.92315] → [2.21386:21464]

∅:BD[2.21464] → [17.92315:92332]

B:BD[17.92315] → [17.92315:92332]

B:BD[17.92484] → [86.34621:34693]

B:BD[58.74219] → [58.74219:74364]

B:BD[58.74219] → [62.79675:79820]

B:BD[77.48453] → [77.48453:48526]

B:BD[77.48526] → [64.39422:39494]

B:BD[77.48526] → [77.48526:48598]

B:BD[58.74219] → [60.56711:56784]

B:BD[60.56784] → [102.46997:47069]

B:BD[60.56784] → [60.56784:56856]

∅:BD[2.21499] → [17.92556:92591]

∅:BD[60.56856] → [17.92556:92591]

∅:BD[77.48598] → [17.92556:92591]

∅:BD[21.60197] → [17.92556:92591]

∅:BD[62.79820] → [17.92556:92591]

∅:BD[58.74364] → [17.92556:92591]

∅:BD[64.39494] → [17.92556:92591]

∅:BD[86.34693] → [17.92556:92591]

∅:BD[63.56679] → [17.92556:92591]

∅:BD[102.47069] → [17.92556:92591]

∅:BD[59.62777] → [17.92556:92591]

B:BD[17.92556] → [17.92556:92591]

∅:BD[2.21519] → [17.92610:92675]

∅:BD[60.56876] → [17.92610:92675]

∅:BD[21.60217] → [17.92610:92675]

∅:BD[62.79840] → [17.92610:92675]

∅:BD[58.74384] → [17.92610:92675]

∅:BD[59.62797] → [17.92610:92675]

B:BD[17.92610] → [17.92610:92675]

B:BD[17.92675] → [2.21520:21598]

∅:BD[2.21598] → [17.92675:92692]

B:BD[17.92675] → [17.92675:92692]

B:BD[17.92763] → [59.62798:62941]

B:BD[17.92763] → [58.74385:74455]

B:BD[58.74455] → [63.56680:56753]

B:BD[58.74455] → [58.74455:74528]

B:BD[58.74455] → [62.79841:79914]

B:BD[58.74455] → [60.56877:56950]

∅:BD[2.21626] → [17.92906:92936]

∅:BD[60.56950] → [17.92906:92936]

∅:BD[77.48813] → [17.92906:92936]

∅:BD[21.60433] → [17.92906:92936]

∅:BD[62.79914] → [17.92906:92936]

∅:BD[58.74528] → [17.92906:92936]

∅:BD[64.39709] → [17.92906:92936]

∅:BD[63.56753] → [17.92906:92936]

∅:BD[59.62941] → [17.92906:92936]

B:BD[17.92906] → [17.92906:92936]

∅:BD[21.60452] → [17.92954:93019]

∅:BD[58.74547] → [17.92954:93019]

∅:BD[59.62960] → [17.92954:93019]

B:BD[17.92954] → [17.92954:93019]

B:BD[17.93019] → [2.21627:21705]

∅:BD[2.21705] → [17.93019:93036]

B:BD[17.93019] → [17.93019:93036]

B:BD[58.74627] → [58.74627:74700]

B:BD[17.93264] → [58.74701:74780]

B:BD[17.93264] → [21.60606:60685]

∅:BD[2.22080] → [17.93343:93372]

∅:BD[21.60685] → [17.93343:93372]

∅:BD[58.74780] → [17.93343:93372]

B:BD[17.93343] → [17.93343:93372]

∅:BD[21.60704] → [17.93390:93455]

∅:BD[58.74799] → [17.93390:93455]

∅:BD[59.63209] → [17.93390:93455]

B:BD[17.93390] → [17.93390:93455]

B:BD[17.93455] → [2.22081:22159]

∅:BD[2.22159] → [17.93455:93472]

B:BD[17.93455] → [17.93455:93472]

B:BD[58.74879] → [58.74879:74952]

B:BD[17.93700] → [58.74953:75032]

B:BD[17.93700] → [21.60858:60937]

∅:BD[2.22533] → [17.93779:93808]

∅:BD[21.60937] → [17.93779:93808]

∅:BD[58.75032] → [17.93779:93808]

B:BD[17.93779] → [17.93779:93808]

∅:BD[2.22552] → [17.93826:93891]

∅:BD[77.48992] → [17.93826:93891]

∅:BD[21.60956] → [17.93826:93891]

∅:BD[58.75051] → [17.93826:93891]

∅:BD[64.39888] → [17.93826:93891]

∅:BD[63.56932] → [17.93826:93891]

∅:BD[102.47248] → [17.93826:93891]

∅:BD[59.63458] → [17.93826:93891]

B:BD[17.93826] → [17.93826:93891]

B:BD[17.93891] → [2.22553:22631]

∅:BD[2.22631] → [17.93891:93908]

B:BD[17.93891] → [17.93891:93908]

B:BD[58.75131] → [58.75131:75208]

B:BD[58.75208] → [58.75208:75281]

B:BD[17.94210] → [58.75282:75361]

B:BD[17.94210] → [21.61111:61190]

∅:BD[2.22706] → [17.94289:94304]

∅:BD[21.61190] → [17.94289:94304]

∅:BD[58.75361] → [17.94289:94304]

B:BD[17.94289] → [17.94289:94304]

B:BD[17.94325] → [59.63689:63707]

B:BD[17.94425] → [59.63708:63855]

B:BD[17.94588] → [17.94588:94607]

∅:BD[21.61406] → [17.94625:94690]

B:BD[17.94625] → [17.94625:94690]

B:BD[17.94690] → [2.22809:22887]

∅:BD[2.22887] → [17.94690:94717]

B:BD[17.94690] → [17.94690:94717]

∅:BD[58.75548] → [17.94735:94800]

∅:BD[59.63874] → [17.94735:94800]

B:BD[17.94735] → [17.94735:94800]

B:BD[17.94800] → [2.22888:22966]

∅:BD[2.22966] → [17.94800:94831]

B:BD[17.94800] → [17.94800:94831]

∅:BD[60.57377] → [17.94849:94914]

∅:BD[77.49564] → [17.94849:94914]

∅:BD[21.61425] → [17.94849:94914]

∅:BD[62.80340] → [17.94849:94914]

∅:BD[58.75567] → [17.94849:94914]

∅:BD[64.40155] → [17.94849:94914]

∅:BD[59.63893] → [17.94849:94914]

B:BD[17.94849] → [17.94849:94914]

B:BD[17.94914] → [59.63894:63991]

B:BD[17.94914] → [62.80341:80438]

B:BD[17.94914] → [2.22967:23045]

∅:BD[2.23045] → [17.94914:94944]

∅:BD[62.80438] → [17.94914:94944]

∅:BD[59.63991] → [17.94914:94944]

B:BD[17.94914] → [17.94914:94944]

∅:BD[2.23065] → [17.94962:95027]

∅:BD[77.49583] → [17.94962:95027]

∅:BD[21.61445] → [17.94962:95027]

∅:BD[64.40174] → [17.94962:95027]

B:BD[17.94962] → [17.94962:95027]

B:BD[17.95027] → [2.23066:23144]

∅:BD[2.23144] → [17.95027:95044]

B:BD[17.95027] → [17.95027:95044]

B:BD[60.57451] → [102.47801:47873]

B:BD[77.49729] → [77.49729:49883]

B:BD[60.57451] → [60.57451:57523]

B:BD[60.57523] → [60.57523:57677]

∅:BD[2.23200] → [17.95343:95345]

∅:BD[60.57677] → [17.95343:95345]

∅:BD[77.49883] → [17.95343:95345]

∅:BD[21.61746] → [17.95343:95345]

∅:BD[62.80738] → [17.95343:95345]

∅:BD[58.75867] → [17.95343:95345]

∅:BD[63.57479] → [17.95343:95345]

∅:BD[59.64291] → [17.95343:95345]

B:BD[17.95343] → [17.95343:95345]

B:BD[17.95498] → [59.64292:64310]

B:BD[17.95498] → [64.40321:40339]

B:BD[17.95498] → [58.75868:75886]

B:BD[17.95581] → [77.49903:49995]

∅:BD[77.49995] → [17.95581:95616]

B:BD[17.95581] → [17.95581:95616]

∅:BD[21.61765] → [17.95634:95699]

B:BD[17.95634] → [17.95634:95699]

B:BD[17.95699] → [2.23201:23279]

∅:BD[2.23279] → [17.95699:95716]

B:BD[17.95699] → [17.95699:95716]

B:BD[58.76053] → [58.76053:76131]

B:BD[17.96043] → [59.64556:64629]

B:BD[17.96043] → [63.57480:57553]

B:BD[17.96043] → [64.40340:40413]

B:BD[17.96043] → [58.76132:76205]

B:BD[17.96043] → [62.80906:80979]

B:BD[17.96043] → [21.62010:62084]

B:BD[17.96043] → [77.49996:50069]

B:BD[17.96043] → [60.57845:57918]

∅:BD[2.23368] → [17.96289:96334]

∅:BD[21.62084] → [17.96289:96334]

B:BD[17.96289] → [17.96289:96334]

∅:BD[21.62103] → [17.96352:96417]

B:BD[17.96352] → [17.96352:96417]

B:BD[17.96417] → [2.23369:23447]

∅:BD[2.23447] → [17.96417:96434]

B:BD[17.96417] → [17.96417:96434]

B:BD[58.76365] → [102.47874:47953]

B:BD[58.76365] → [63.57554:57706]

B:BD[58.76365] → [64.40414:40493]

B:BD[58.76365] → [58.76365:76444]

B:BD[58.76444] → [58.76444:76517]

B:BD[58.76444] → [62.80980:81053]

B:BD[58.76444] → [60.57919:57992]

B:BD[58.76365] → [77.50070:50149]

B:BD[77.50149] → [77.50149:50222]

∅:BD[2.23507] → [17.96831:96846]

∅:BD[21.62412] → [17.96831:96846]

B:BD[17.96831] → [17.96831:96846]

B:BD[17.96971] → [17.96971:96987]

∅:BD[60.58011] → [58.76536:76601]

∅:BD[77.50241] → [58.76536:76601]

∅:BD[62.81072] → [58.76536:76601]

∅:BD[63.57725] → [58.76536:76601]

B:BD[58.76536] → [58.76536:76601]

∅:BD[2.23586] → [58.76601:76648]

B:BD[58.76601] → [58.76601:76648]

B:BD[58.76648] → [2.23587:23777]

∅:BD[2.23777] → [17.97228:97293]

B:BD[17.97228] → [17.97228:97293]

∅:BD[2.23856] → [17.97536:97562]

B:BD[17.97536] → [17.97536:97562]

B:BD[17.97664] → [59.64981:65132]

B:BD[17.97664] → [102.47975:48054]

B:BD[17.97664] → [63.57747:57899]

B:BD[17.97664] → [64.40515:40594]

B:BD[17.97664] → [58.76670:76749]

B:BD[58.76749] → [58.76749:76822]

B:BD[58.76749] → [62.81094:81167]

B:BD[58.76749] → [60.58033:58106]

B:BD[77.50342] → [77.50342:50415]

B:BD[17.97664] → [77.50263:50342]

∅:BD[2.23876] → [17.97943:98008]

∅:BD[21.62432] → [17.97943:98008]

B:BD[17.97943] → [17.97943:98008]

B:BD[17.98008] → [2.23877:23955]

∅:BD[2.23955] → [17.98008:98025]

B:BD[17.98008] → [17.98008:98025]

∅:BD[2.23998] → [17.98103:98140]

∅:BD[21.62662] → [17.98103:98140]

B:BD[17.98103] → [17.98103:98140]

∅:BD[77.50435] → [17.98159:98224]

∅:BD[21.62682] → [17.98159:98224]

∅:BD[58.76842] → [17.98159:98224]

∅:BD[64.40614] → [17.98159:98224]

∅:BD[59.65152] → [17.98159:98224]

B:BD[17.98159] → [17.98159:98224]

B:BD[17.98224] → [2.23999:24077]

∅:BD[2.24077] → [17.98224:98241]

B:BD[17.98224] → [17.98224:98241]

B:BD[17.98393] → [86.34792:34864]

B:BD[58.76922] → [58.76922:77067]

B:BD[58.76922] → [62.81168:81313]

B:BD[77.50515] → [77.50515:50588]

B:BD[77.50588] → [64.40695:40767]

B:BD[77.50588] → [77.50588:50660]

B:BD[58.76922] → [60.58107:58180]

B:BD[60.58180] → [102.48135:48207]

B:BD[60.58180] → [60.58180:58252]

∅:BD[2.24128] → [17.98543:98576]

∅:BD[21.62983] → [17.98543:98576]

B:BD[17.98543] → [17.98543:98576]

∅:BD[60.58271] → [17.98594:98659]

∅:BD[77.50679] → [17.98594:98659]

∅:BD[21.63002] → [17.98594:98659]

∅:BD[62.81332] → [17.98594:98659]

∅:BD[58.77086] → [17.98594:98659]

∅:BD[64.40786] → [17.98594:98659]

∅:BD[59.65395] → [17.98594:98659]

B:BD[17.98594] → [17.98594:98659]

B:BD[17.98659] → [2.24129:24207]

∅:BD[2.24207] → [17.98659:98676]

B:BD[17.98659] → [17.98659:98676]

B:BD[60.58345] → [102.48208:48280]

B:BD[58.77303] → [63.58271:58352]

B:BD[17.99054] → [59.65694:65767]

B:BD[17.99054] → [63.58353:58426]

B:BD[17.99054] → [58.77385:77458]

B:BD[17.99054] → [62.81561:81634]

B:BD[17.99054] → [60.58500:58573]

B:BD[17.99054] → [17.99054:99127]

B:BD[77.50907] → [64.40933:41014]

B:BD[58.77303] → [58.77303:77384]

B:BD[58.77303] → [62.81479:81560]

B:BD[77.50907] → [77.50907:50988]

B:BD[77.50988] → [77.50988:51061]

B:BD[58.77303] → [77.50826:50907]

B:BD[58.77303] → [60.58418:58499]

B:BD[58.77232] → [58.77232:77303]

B:BD[60.58345] → [60.58345:58417]

∅:BD[2.24291] → [17.99127:99159]

∅:BD[60.58573] → [17.99127:99159]

∅:BD[77.51061] → [17.99127:99159]

∅:BD[21.63455] → [17.99127:99159]

∅:BD[62.81634] → [17.99127:99159]

∅:BD[58.77458] → [17.99127:99159]

∅:BD[63.58426] → [17.99127:99159]

∅:BD[59.65767] → [17.99127:99159]

B:BD[17.99127] → [17.99127:99159]

∅:BD[58.77477] → [17.99177:99242]

∅:BD[59.65786] → [17.99177:99242]

B:BD[17.99177] → [17.99177:99242]

B:BD[17.99242] → [2.24292:24370]

∅:BD[2.24370] → [17.99242:99259]

B:BD[17.99242] → [17.99242:99259]

B:BD[17.99400] → [59.65787:65859]

∅:BD[2.24398] → [17.99472:99506]

∅:BD[58.77550] → [17.99472:99506]

∅:BD[59.65859] → [17.99472:99506]

B:BD[17.99472] → [17.99472:99506]

∅:BD[77.51080] → [17.99524:99589]

∅:BD[21.63474] → [17.99524:99589]

∅:BD[64.41033] → [17.99524:99589]

B:BD[17.99524] → [17.99524:99589]

B:BD[17.99589] → [2.24399:24477]

∅:BD[2.24477] → [17.99589:99606]

B:BD[17.99589] → [17.99589:99606]

∅:BD[2.24494] → [17.99681:99696]

∅:BD[21.63553] → [17.99681:99696]

B:BD[17.99681] → [17.99681:99696]

B:BD[17.99813] → [59.65860:66013]

B:BD[17.99813] → [102.48300:48445]

B:BD[17.99713] → [102.48281:48299]

B:BD[17.99813] → [63.58446:58599]

B:BD[17.99713] → [63.58427:58445]

B:BD[17.99813] → [64.41053:41125]

B:BD[17.99713] → [64.41034:41052]

B:BD[17.99813] → [58.77551:77704]

B:BD[17.99813] → [62.81635:81788]

B:BD[77.51245] → [77.51245:51326]

B:BD[17.99813] → [77.51100:51245]

B:BD[17.99713] → [77.51081:51099]

B:BD[17.99813] → [60.58574:58646]

B:BD[60.58646] → [60.58646:58727]

B:BD[17.100061] → [17.100061:100079]

B:BD[17.100861] → [59.66360:66379]

B:BD[17.100605] → [59.66133:66359]

B:BD[17.100504] → [59.66113:66132]

B:BD[17.100397] → [59.66034:66112]

B:BD[17.100861] → [102.48519:48538]

B:BD[17.100605] → [102.48446:48518]

B:BD[17.100861] → [63.58847:58866]

B:BD[17.100605] → [63.58620:58846]

B:BD[17.100861] → [64.41199:41218]

B:BD[17.100605] → [64.41126:41198]

B:BD[17.100861] → [58.78051:78070]

B:BD[17.100605] → [58.77824:78050]

B:BD[17.100504] → [58.77804:77823]

B:BD[17.100397] → [58.77725:77803]

B:BD[17.100861] → [62.82115:82134]

B:BD[17.100605] → [62.81888:82114]

B:BD[17.100397] → [62.81809:81887]

B:BD[17.100861] → [77.51574:51593]

B:BD[77.51419] → [77.51419:51573]

B:BD[17.100605] → [77.51347:51419]

B:BD[17.100861] → [60.59054:59073]

B:BD[17.100605] → [60.58827:58899]

B:BD[60.58899] → [60.58899:59053]

B:BD[17.100397] → [60.58748:58826]

∅:BD[60.59073] → [17.100880:100945]

∅:BD[77.51593] → [17.100880:100945]

∅:BD[62.82134] → [17.100880:100945]

∅:BD[58.78070] → [17.100880:100945]

∅:BD[64.41218] → [17.100880:100945]

∅:BD[63.58866] → [17.100880:100945]

∅:BD[102.48538] → [17.100880:100945]

∅:BD[59.66379] → [17.100880:100945]

B:BD[17.100880] → [17.100880:100945]

B:BD[17.100945] → [2.24495:24573]

∅:BD[2.24573] → [17.100945:100962]

B:BD[17.100945] → [17.100945:100962]

B:BD[77.51667] → [64.41219:41441]

B:BD[17.101335] → [59.66529:67317]

B:BD[17.101335] → [63.59016:59184]

B:BD[60.59699] → [102.48539:48616]

B:BD[58.78849] → [102.48617:48701]

B:BD[58.79012] → [58.79012:79095]

B:BD[58.79247] → [77.52384:52739]

B:BD[58.79012] → [60.59862:59945]

B:BD[58.78849] → [63.59263:59347]

B:BD[58.78849] → [64.41520:41766]

B:BD[58.79095] → [58.79095:79247]

B:BD[58.78849] → [58.78849:78933]

B:BD[58.78933] → [58.78933:79012]

B:BD[58.78849] → [62.82837:82921]

B:BD[58.78849] → [77.52137:52383]

B:BD[58.78849] → [60.59777:59861]

B:BD[60.59699] → [63.59185:59262]

B:BD[60.59699] → [64.41442:41519]

B:BD[60.59699] → [77.52059:52136]

B:BD[60.59699] → [60.59699:59776]

B:BD[17.101335] → [58.78297:78773]

B:BD[58.78773] → [58.78773:78849]

B:BD[17.101335] → [62.82360:82836]

B:BD[17.101335] → [77.51890:52058]

B:BD[60.59468] → [60.59468:59699]

B:BD[17.101335] → [60.59300:59468]

B:BD[17.101335] → [17.101335:102285]

B:BD[77.51667] → [77.51667:51889]

∅:BD[2.24592] → [17.102285:102300]

∅:BD[77.52739] → [17.102285:102300]

∅:BD[21.63634] → [17.102285:102300]

∅:BD[58.79247] → [17.102285:102300]

∅:BD[59.67317] → [17.102285:102300]

B:BD[17.102285] → [17.102285:102300]

∅:BD[2.24612] → [17.102341:102406]

∅:BD[21.63673] → [17.102341:102406]

B:BD[17.102341] → [17.102341:102406]

B:BD[17.102406] → [2.24613:24691]

∅:BD[2.24691] → [17.102406:102423]

B:BD[17.102406] → [17.102406:102423]

∅:BD[2.24711] → [17.102498:102513]

∅:BD[60.60021] → [17.102498:102513]

∅:BD[77.52815] → [17.102498:102513]

∅:BD[21.63756] → [17.102498:102513]

∅:BD[62.82997] → [17.102498:102513]

∅:BD[58.79323] → [17.102498:102513]

∅:BD[64.41842] → [17.102498:102513]

∅:BD[63.59423] → [17.102498:102513]

∅:BD[59.67393] → [17.102498:102513]

B:BD[17.102498] → [17.102498:102513]

B:BD[17.102634] → [59.67394:67618]

B:BD[17.102903] → [59.67619:67637]

∅:BD[2.24731] → [17.102921:102986]

∅:BD[60.60265] → [17.102921:102986]

∅:BD[77.52983] → [17.102921:102986]

∅:BD[21.63800] → [17.102921:102986]

∅:BD[62.83241] → [17.102921:102986]

∅:BD[58.79567] → [17.102921:102986]

∅:BD[63.59591] → [17.102921:102986]

∅:BD[59.67637] → [17.102921:102986]

B:BD[17.102921] → [17.102921:102986]

B:BD[17.102986] → [2.24732:24810]

∅:BD[2.24810] → [17.102986:103003]

B:BD[17.102986] → [17.102986:103003]

B:BD[77.53059] → [77.53059:53140]

∅:BD[2.24845] → [17.103159:103174]

∅:BD[60.60422] → [17.103159:103174]

∅:BD[77.53140] → [17.103159:103174]

∅:BD[21.64023] → [17.103159:103174]

∅:BD[62.83398] → [17.103159:103174]

∅:BD[58.79724] → [17.103159:103174]

∅:BD[63.59748] → [17.103159:103174]

∅:BD[59.67794] → [17.103159:103174]

B:BD[17.103159] → [17.103159:103174]

B:BD[17.103198] → [59.67795:67813]

∅:BD[60.60441] → [17.103216:103281]

∅:BD[77.53159] → [17.103216:103281]

∅:BD[21.64064] → [17.103216:103281]

∅:BD[62.83417] → [17.103216:103281]

∅:BD[58.79743] → [17.103216:103281]

∅:BD[63.59767] → [17.103216:103281]

∅:BD[59.67813] → [17.103216:103281]

B:BD[17.103216] → [17.103216:103281]

B:BD[17.103281] → [2.24846:24924]

∅:BD[2.24924] → [17.103281:103298]

B:BD[17.103281] → [17.103281:103298]

B:BD[58.79826] → [63.59768:59843]

B:BD[58.79826] → [64.41995:42070]

B:BD[58.79826] → [58.79826:79901]

B:BD[58.79826] → [62.83418:83493]

B:BD[58.79826] → [77.53160:53235]

B:BD[58.79826] → [60.60442:60517]

∅:BD[2.24941] → [17.103455:103470]

∅:BD[60.60517] → [17.103455:103470]

∅:BD[77.53235] → [17.103455:103470]

∅:BD[21.64143] → [17.103455:103470]

∅:BD[62.83493] → [17.103455:103470]

∅:BD[58.79901] → [17.103455:103470]

∅:BD[64.42070] → [17.103455:103470]

∅:BD[63.59843] → [17.103455:103470]

∅:BD[59.67889] → [17.103455:103470]

B:BD[17.103455] → [17.103455:103470]

B:BD[17.103488] → [59.67890:67908]

∅:BD[60.60536] → [17.103506:103571]

∅:BD[21.64177] → [17.103506:103571]

∅:BD[62.83512] → [17.103506:103571]

∅:BD[58.79920] → [17.103506:103571]

∅:BD[59.67908] → [17.103506:103571]

B:BD[17.103506] → [17.103506:103571]

B:BD[17.103571] → [2.24942:25020]

∅:BD[2.25020] → [17.103571:103588]

B:BD[17.103571] → [17.103571:103588]

B:BD[60.60612] → [60.60612:60688]

B:BD[60.60688] → [102.48702:48786]

B:BD[60.60688] → [63.59920:60004]

B:BD[60.60688] → [64.42147:42231]

B:BD[60.60688] → [77.53312:53396]

B:BD[60.60688] → [60.60688:60772]

∅:BD[2.25086] → [17.103823:103838]

∅:BD[60.60772] → [17.103823:103838]

∅:BD[77.53396] → [17.103823:103838]

∅:BD[21.64418] → [17.103823:103838]

∅:BD[62.83748] → [17.103823:103838]

∅:BD[58.80156] → [17.103823:103838]

∅:BD[64.42231] → [17.103823:103838]

∅:BD[63.60004] → [17.103823:103838]

∅:BD[102.48786] → [17.103823:103838]

∅:BD[59.68143] → [17.103823:103838]

B:BD[17.103823] → [17.103823:103838]

B:BD[17.103856] → [59.68144:68163]

∅:BD[60.60792] → [17.103875:103940]

∅:BD[21.64454] → [17.103875:103940]

∅:BD[62.83768] → [17.103875:103940]

∅:BD[58.80176] → [17.103875:103940]

∅:BD[59.68163] → [17.103875:103940]

B:BD[17.103875] → [17.103875:103940]

B:BD[17.103957] → [59.68164:68382]

B:BD[17.103957] → [63.60005:60153]

B:BD[77.53470] → [64.42232:42307]

B:BD[58.80325] → [58.80325:80395]

B:BD[17.103957] → [58.80177:80325]

B:BD[17.103957] → [62.83769:83917]

B:BD[77.53470] → [77.53470:53545]

B:BD[17.103957] → [77.53397:53470]

B:BD[17.103957] → [60.60793:60941]

∅:BD[2.25165] → [17.104177:104190]

B:BD[17.104177] → [17.104177:104190]

B:BD[17.104213] → [59.68383:68401]

B:BD[17.104213] → [58.80396:80414]

B:BD[17.104213] → [62.83918:83936]

B:BD[17.104213] → [60.60942:60960]

∅:BD[60.60960] → [17.104231:104296]

∅:BD[21.64489] → [17.104231:104296]

∅:BD[62.83936] → [17.104231:104296]

∅:BD[58.80414] → [17.104231:104296]

∅:BD[59.68401] → [17.104231:104296]

B:BD[17.104231] → [17.104231:104296]

B:BD[17.104296] → [2.25166:25244]

∅:BD[2.25244] → [17.104296:104313]

B:BD[17.104296] → [17.104296:104313]

B:BD[58.80497] → [63.60154:60229]

B:BD[17.104689] → [59.68708:69089]

B:BD[17.105185] → [59.69090:69108]

B:BD[17.105285] → [59.69109:69256]

B:BD[17.105577] → [59.69257:69645]

∅:BD[2.25448] → [17.105965:105980]

∅:BD[60.62128] → [17.105965:105980]

∅:BD[77.54477] → [17.105965:105980]

∅:BD[21.65550] → [17.105965:105980]

∅:BD[62.84956] → [17.105965:105980]

∅:BD[58.82016] → [17.105965:105980]

∅:BD[64.43002] → [17.105965:105980]

∅:BD[63.60866] → [17.105965:105980]

∅:BD[59.69645] → [17.105965:105980]

B:BD[17.105965] → [17.105965:105980]

B:BD[17.106260] → [17.106260:106279]

∅:BD[21.65591] → [17.106297:106362]

∅:BD[58.82035] → [17.106297:106362]

∅:BD[59.69664] → [17.106297:106362]

B:BD[17.106297] → [17.106297:106362]

B:BD[17.106362] → [2.25449:25527]

∅:BD[2.25527] → [17.106362:106379]

B:BD[17.106362] → [17.106362:106379]

B:BD[77.54551] → [64.43003:43078]

B:BD[17.106599] → [64.43079:43150]

B:BD[17.106599] → [77.54627:54698]

B:BD[17.106670] → [60.62278:62434]

B:BD[17.106599] → [17.106599:106670]

B:BD[17.106670] → [59.69814:69970]

B:BD[17.106670] → [58.82185:82341]

B:BD[17.106670] → [62.85106:85262]

B:BD[17.106670] → [17.106670:106826]

B:BD[77.54551] → [77.54551:54626]

∅:BD[2.25562] → [17.106826:106841]

∅:BD[60.62434] → [17.106826:106841]

∅:BD[21.65814] → [17.106826:106841]

∅:BD[62.85262] → [17.106826:106841]

∅:BD[58.82341] → [17.106826:106841]

∅:BD[59.69970] → [17.106826:106841]

B:BD[17.106826] → [17.106826:106841]

B:BD[17.106867] → [59.69971:69989]

∅:BD[60.62454] → [17.106886:106951]

∅:BD[77.54718] → [17.106886:106951]

∅:BD[21.65852] → [17.106886:106951]

∅:BD[62.85282] → [17.106886:106951]

∅:BD[58.82361] → [17.106886:106951]

∅:BD[64.43170] → [17.106886:106951]

∅:BD[63.61035] → [17.106886:106951]

∅:BD[102.49055] → [17.106886:106951]

∅:BD[59.69989] → [17.106886:106951]

B:BD[17.106886] → [17.106886:106951]

B:BD[17.106951] → [2.25563:25641]

∅:BD[2.25641] → [17.106951:106968]

B:BD[17.106951] → [17.106951:106968]

B:BD[58.82526] → [58.82526:82608]

B:BD[58.82683] → [58.82683:82753]

B:BD[58.82829] → [58.82829:82971]

B:BD[58.82971] → [63.61112:61193]

B:BD[58.82971] → [58.82971:83052]

B:BD[58.82971] → [62.85678:85759]

B:BD[58.82971] → [77.54872:54953]

B:BD[58.82971] → [60.62773:62854]

B:BD[58.82753] → [64.43247:43323]

B:BD[58.82753] → [58.82753:82829]

B:BD[58.82753] → [62.85602:85677]

B:BD[58.82753] → [77.54795:54871]

B:BD[58.82753] → [60.62696:62772]

B:BD[58.82608] → [63.61036:61111]

B:BD[58.82608] → [64.43171:43246]

B:BD[58.82608] → [58.82608:82683]

B:BD[58.82608] → [62.85526:85601]

B:BD[58.82608] → [77.54719:54794]

B:BD[58.82608] → [60.62620:62695]

∅:BD[2.25667] → [17.107658:107673]

∅:BD[60.62854] → [17.107658:107673]

∅:BD[77.54953] → [17.107658:107673]

∅:BD[21.66003] → [17.107658:107673]

∅:BD[62.85759] → [17.107658:107673]

∅:BD[58.83052] → [17.107658:107673]

∅:BD[63.61193] → [17.107658:107673]

∅:BD[59.70526] → [17.107658:107673]

B:BD[17.107658] → [17.107658:107673]

B:BD[17.107694] → [59.70527:70545]

B:BD[17.107795] → [59.70546:70855]

B:BD[21.66521] → [21.66521:66539]

∅:BD[21.66539] → [17.108156:108221]

∅:BD[58.83401] → [17.108156:108221]

∅:BD[59.70874] → [17.108156:108221]

B:BD[17.108156] → [17.108156:108221]

B:BD[17.108221] → [2.25668:25746]

∅:BD[2.25746] → [17.108221:108238]

B:BD[17.108221] → [17.108221:108238]

B:BD[17.108390] → [59.70951:71027]

B:BD[17.108481] → [17.108481:108700]

B:BD[17.108719] → [59.71028:71046]

B:BD[17.108719] → [58.83774:83792]

∅:BD[21.68133] → [17.108737:108802]

∅:BD[58.83792] → [17.108737:108802]

∅:BD[59.71046] → [17.108737:108802]

B:BD[17.108737] → [17.108737:108802]

B:BD[17.108802] → [2.26111:26189]

∅:BD[2.26189] → [17.108802:108819]

B:BD[17.108802] → [17.108802:108819]

B:BD[77.55578] → [64.43592:43667]

B:BD[58.84011] → [64.43668:43739]

B:BD[17.109186] → [59.71266:71422]

B:BD[17.109186] → [58.84012:84168]

B:BD[17.109186] → [62.86220:86376]

B:BD[17.109186] → [60.63534:63690]

B:BD[17.109186] → [17.109186:109342]

B:BD[58.84011] → [77.55654:55725]

B:BD[17.109108] → [17.109108:109186]

B:BD[58.83941] → [58.83941:84011]

B:BD[77.55578] → [77.55578:55653]

∅:BD[2.26200] → [17.109342:109357]

∅:BD[60.63690] → [17.109342:109357]

∅:BD[21.68208] → [17.109342:109357]

∅:BD[62.86376] → [17.109342:109357]

∅:BD[58.84168] → [17.109342:109357]

∅:BD[59.71422] → [17.109342:109357]

B:BD[17.109342] → [17.109342:109357]

B:BD[17.109376] → [59.71423:71441]

∅:BD[21.68250] → [17.109394:109459]

∅:BD[58.84187] → [17.109394:109459]

∅:BD[59.71441] → [17.109394:109459]

B:BD[17.109394] → [17.109394:109459]

B:BD[17.109983] → [59.71734:71890]

B:BD[17.109696] → [59.71591:71733]

B:BD[17.109476] → [59.71442:71590]

B:BD[17.109696] → [102.49134:49206]

B:BD[17.109696] → [63.61803:61875]

B:BD[17.109476] → [63.61654:61802]

B:BD[58.84479] → [64.43889:43960]

B:BD[17.109696] → [64.43816:43888]

B:BD[77.55799] → [64.43740:43815]

B:BD[58.84558] → [58.84558:84714]

B:BD[17.109983] → [58.84480:84558]

B:BD[58.84409] → [58.84409:84479]

B:BD[17.109696] → [58.84337:84409]

B:BD[17.109476] → [58.84188:84336]

B:BD[58.84558] → [62.86599:86755]

B:BD[17.109696] → [62.86526:86598]

B:BD[17.109476] → [62.86377:86525]

B:BD[58.84479] → [77.55948:56019]

B:BD[17.109696] → [77.55875:55947]

B:BD[77.55799] → [77.55799:55874]

B:BD[17.109476] → [77.55726:55799]

B:BD[58.84558] → [60.63913:64069]

B:BD[17.109696] → [60.63840:63912]

B:BD[17.109476] → [60.63691:63839]

∅:BD[2.26279] → [17.110219:110232]

B:BD[17.110219] → [17.110219:110232]

B:BD[17.110252] → [59.71891:71909]

B:BD[17.110252] → [58.84715:84733]

∅:BD[2.26299] → [17.110270:110335]

∅:BD[21.68287] → [17.110270:110335]

∅:BD[58.84733] → [17.110270:110335]

∅:BD[59.71909] → [17.110270:110335]

B:BD[17.110270] → [17.110270:110335]

B:BD[17.110335] → [2.26300:26378]

∅:BD[2.26378] → [17.110335:110352]

B:BD[17.110335] → [17.110335:110352]

∅:BD[2.26436] → [17.111502:111517]

∅:BD[21.68513] → [17.111502:111517]

∅:BD[58.85582] → [17.111502:111517]

∅:BD[59.72977] → [17.111502:111517]

B:BD[17.111502] → [17.111502:111517]

B:BD[17.111531] → [59.72978:72996]

∅:BD[2.26456] → [17.111549:111614]

∅:BD[60.64467] → [17.111549:111614]

∅:BD[77.56340] → [17.111549:111614]

∅:BD[21.68555] → [17.111549:111614]

∅:BD[62.87154] → [17.111549:111614]

∅:BD[58.85601] → [17.111549:111614]

∅:BD[64.44207] → [17.111549:111614]

∅:BD[63.62197] → [17.111549:111614]

∅:BD[59.72996] → [17.111549:111614]

B:BD[17.111549] → [17.111549:111614]

B:BD[17.111614] → [2.26457:26535]

∅:BD[2.26535] → [17.111614:111631]

B:BD[17.111614] → [17.111614:111631]

∅:BD[2.26552] → [17.111704:111744]

∅:BD[60.64541] → [17.111704:111744]

∅:BD[77.56414] → [17.111704:111744]

∅:BD[21.68634] → [17.111704:111744]

∅:BD[62.87228] → [17.111704:111744]

∅:BD[58.85675] → [17.111704:111744]

∅:BD[64.44281] → [17.111704:111744]

∅:BD[63.62271] → [17.111704:111744]

∅:BD[59.73070] → [17.111704:111744]

B:BD[17.111704] → [17.111704:111744]

∅:BD[21.68654] → [17.111762:111827]

∅:BD[58.85694] → [17.111762:111827]

∅:BD[59.73089] → [17.111762:111827]

B:BD[17.111762] → [17.111762:111827]

B:BD[17.111827] → [2.26553:26631]

∅:BD[2.26631] → [17.111827:111844]

B:BD[17.111827] → [17.111827:111844]

B:BD[58.85771] → [58.85771:85845]

B:BD[58.85845] → [63.62272:62347]

B:BD[17.112140] → [59.73321:73615]

B:BD[17.112508] → [59.73616:74153]

B:BD[17.112508] → [63.62348:62429]

B:BD[58.86453] → [58.86453:86529]

B:BD[58.86608] → [58.86608:86754]

B:BD[58.86529] → [64.44585:44664]

B:BD[58.86529] → [58.86529:86608]

B:BD[58.86529] → [77.56800:56879]

B:BD[17.112508] → [58.86216:86453]

B:BD[17.112508] → [62.87460:87697]

B:BD[17.112508] → [60.64773:64854]

B:BD[60.64854] → [60.64854:65010]

B:BD[17.112508] → [17.112508:113046]

B:BD[58.85999] → [58.85999:86140]

B:BD[77.56718] → [77.56718:56799]

B:BD[17.112434] → [17.112434:112508]

B:BD[58.86140] → [64.44435:44584]

B:BD[58.86140] → [58.86140:86215]

B:BD[58.86140] → [62.87384:87459]

B:BD[58.86140] → [77.56568:56718]

B:BD[58.86140] → [60.64697:64772]

B:BD[17.112140] → [58.85921:85999]

B:BD[17.112140] → [62.87305:87383]

B:BD[17.112140] → [60.64618:64696]

B:BD[17.112140] → [17.112140:112434]

B:BD[58.85845] → [64.44359:44434]

B:BD[58.85845] → [58.85845:85920]

B:BD[58.85845] → [62.87229:87304]

B:BD[58.85845] → [77.56492:56567]

B:BD[58.85845] → [60.64542:64617]

∅:BD[2.26779] → [17.113046:113089]

∅:BD[21.69551] → [17.113046:113089]

∅:BD[58.86754] → [17.113046:113089]

∅:BD[59.74153] → [17.113046:113089]

B:BD[17.113046] → [17.113046:113089]

∅:BD[21.69571] → [17.113108:113173]

∅:BD[58.86774] → [17.113108:113173]

∅:BD[59.74172] → [17.113108:113173]

B:BD[17.113108] → [17.113108:113173]

B:BD[17.113173] → [2.26780:26858]

∅:BD[2.26858] → [17.113173:113190]

B:BD[17.113173] → [17.113173:113190]

B:BD[58.86848] → [58.86848:86922]

B:BD[58.86997] → [58.86997:87072]

B:BD[58.87150] → [58.87150:87220]

B:BD[58.87374] → [64.44815:44963]

B:BD[58.87374] → [58.87374:87522]

B:BD[58.87522] → [58.87522:87604]

B:BD[58.87296] → [58.87296:87374]

B:BD[60.65392] → [102.49359:49432]

B:BD[60.65392] → [63.62657:62730]

B:BD[60.65392] → [60.65392:65465]

B:BD[58.87374] → [62.88004:88152]

B:BD[77.57106] → [21.70022:70408]

B:BD[58.87374] → [77.57107:57256]

B:BD[58.87374] → [60.65317:65392]

B:BD[58.87220] → [63.62580:62656]

B:BD[58.87220] → [58.87220:87296]

B:BD[58.87220] → [62.87927:88003]

B:BD[58.87220] → [60.65240:65316]

B:BD[58.87072] → [58.87072:87150]

B:BD[58.87072] → [62.87848:87926]

B:BD[58.87072] → [60.65161:65239]

B:BD[58.86922] → [63.62504:62579]

B:BD[58.86922] → [64.44739:44814]

B:BD[58.86922] → [58.86922:86997]

B:BD[58.86922] → [62.87772:87847]

B:BD[58.86922] → [77.56954:57029]

B:BD[58.86922] → [60.65085:65160]

B:BD[58.87220] → [77.57030:57106]

∅:BD[2.27020] → [17.114019:114052]

∅:BD[21.70408] → [17.114019:114052]

∅:BD[58.87604] → [17.114019:114052]

∅:BD[59.75007] → [17.114019:114052]

B:BD[17.114019] → [17.114019:114052]

∅:BD[21.70427] → [17.114070:114135]

B:BD[17.114070] → [17.114070:114135]

B:BD[17.114135] → [2.27021:27099]

∅:BD[2.27099] → [17.114135:114148]

B:BD[17.114135] → [17.114135:114148]

B:BD[17.114166] → [59.75008:75026]

B:BD[58.87641] → [63.62731:62804]

B:BD[58.87641] → [64.44964:45037]

B:BD[58.87714] → [58.87714:87716]

B:BD[58.87641] → [58.87641:87714]

B:BD[17.114249] → [58.87624:87641]

B:BD[17.114166] → [58.87605:87623]

B:BD[58.87641] → [62.88153:88226]

B:BD[58.87641] → [77.57257:57330]

B:BD[58.87641] → [60.65466:65539]

B:BD[17.114354] → [17.114354:114371]

∅:BD[21.70447] → [17.114390:114455]

B:BD[17.114390] → [17.114390:114455]

B:BD[17.114455] → [2.27100:27178]

∅:BD[2.27178] → [17.114455:114468]

B:BD[17.114455] → [17.114455:114468]

B:BD[17.114486] → [59.75027:75045]

B:BD[17.114486] → [58.87717:87735]

B:BD[17.114582] → [17.114582:114687]

B:BD[17.114687] → [2.27179:27257]

∅:BD[2.27257] → [17.114687:114704]

B:BD[17.114687] → [17.114687:114704]

∅:BD[2.27270] → [17.114778:114824]

B:BD[17.114778] → [17.114778:114824]

∅:BD[21.70467] → [17.114842:114907]

∅:BD[58.87754] → [17.114842:114907]

∅:BD[59.75064] → [17.114842:114907]

B:BD[17.114842] → [17.114842:114907]

∅:BD[58.87849] → [17.115001:115014]

B:BD[17.115001] → [17.115001:115014]

∅:BD[21.70591] → [17.115055:115120]

B:BD[17.115055] → [17.115055:115120]

B:BD[17.115120] → [2.27363:27441]

∅:BD[2.27441] → [17.115120:115133]

B:BD[17.115120] → [17.115120:115133]

∅:BD[21.70633] → [17.115172:115237]

B:BD[17.115172] → [17.115172:115237]

B:BD[17.115237] → [2.27442:27520]

∅:BD[2.27520] → [17.115237:115271]

B:BD[17.115237] → [17.115237:115271]

B:BD[17.115271] → [21.70634:70652]

B:BD[17.115133] → [21.70592:70633]

B:BD[17.115133] → [17.115133:115172]

B:BD[17.115014] → [21.70543:70591]

B:BD[17.115014] → [17.115014:115055]

∅:BD[2.27349] → [58.87755:87772]

B:BD[17.114907] → [58.87755:87772]

∅:BD[2.27362] → [58.87847:87849]

∅:BD[60.65615] → [58.87847:87849]

∅:BD[77.57407] → [58.87847:87849]

∅:BD[21.70542] → [58.87847:87849]

∅:BD[62.88302] → [58.87847:87849]

∅:BD[64.45113] → [58.87847:87849]

B:BD[58.87847] → [58.87847:87849]

B:BD[58.87772] → [64.45038:45113]

B:BD[58.87772] → [58.87772:87847]

B:BD[58.87772] → [62.88227:88302]

B:BD[58.87772] → [21.70468:70542]

B:BD[58.87772] → [77.57331:57407]

B:BD[58.87772] → [60.65540:65615]

B:BD[58.87772] → [2.27350:27362]

B:BD[17.114907] → [2.27271:27349]

B:BD[17.114907] → [17.114907:115001]

B:BD[17.114824] → [59.75046:75064]

B:BD[17.114824] → [58.87736:87754]

B:BD[17.114824] → [21.70448:70467]

B:BD[17.114824] → [17.114824:114842]

B:BD[17.114704] → [2.27258:27270]

B:BD[17.114704] → [17.114704:114778]

B:BD[17.114504] → [17.114504:114582]

B:BD[17.114486] → [17.114486:114504]

B:BD[17.114468] → [17.114468:114486]

B:BD[17.114371] → [21.70428:70447]

B:BD[17.114371] → [17.114371:114390]

B:BD[17.114341] → [17.114341:114354]

B:BD[17.114249] → [17.114249:114341]

B:BD[17.114184] → [17.114184:114249]

B:BD[17.114166] → [17.114166:114184]

B:BD[17.114148] → [17.114148:114166]

B:BD[17.114052] → [21.70409:70427]

B:BD[17.114052] → [17.114052:114070]

B:BD[17.113190] → [59.74173:75007]

B:BD[17.113190] → [63.62430:62503]

B:BD[17.113190] → [64.44665:44738]

B:BD[17.113190] → [58.86775:86848]

B:BD[17.113190] → [62.87698:87771]

B:BD[17.113190] → [21.69572:70021]

B:BD[17.113190] → [77.56880:56953]

B:BD[17.113190] → [60.65011:65084]

B:BD[17.113190] → [2.26859:27020]

B:BD[17.113190] → [17.113190:114019]

B:BD[17.113089] → [59.74154:74172]

B:BD[17.113089] → [58.86755:86774]

B:BD[17.113089] → [21.69552:69571]

B:BD[17.113089] → [17.113089:113108]

B:BD[17.112069] → [17.112069:112140]

B:BD[17.111844] → [59.73090:73320]

B:BD[17.111844] → [64.44282:44358]

B:BD[17.111844] → [58.85695:85771]

B:BD[17.111844] → [21.68655:69551]

B:BD[17.111844] → [77.56415:56491]

B:BD[17.111844] → [2.26632:26779]

B:BD[17.111844] → [17.111844:112069]

B:BD[17.111744] → [59.73071:73089]

B:BD[17.111744] → [58.85676:85694]

B:BD[17.111744] → [21.68635:68654]

B:BD[17.111744] → [17.111744:111762]

B:BD[17.111631] → [59.72997:73070]

B:BD[17.111631] → [63.62198:62271]

B:BD[17.111631] → [64.44208:44281]

B:BD[17.111631] → [58.85602:85675]

B:BD[17.111631] → [62.87155:87228]

B:BD[17.111631] → [21.68556:68634]

B:BD[17.111631] → [77.56341:56414]

B:BD[17.111631] → [60.64468:64541]

B:BD[17.111631] → [2.26536:26552]

B:BD[17.111631] → [17.111631:111704]

B:BD[17.111531] → [63.62178:62197]

B:BD[17.111531] → [64.44189:44207]

B:BD[17.111531] → [58.85583:85601]

B:BD[17.111531] → [62.87135:87154]

B:BD[17.111531] → [77.56322:56340]

B:BD[17.111531] → [60.64449:64467]

B:BD[17.111531] → [17.111531:111549]

B:BD[17.111517] → [21.68514:68536]

B:BD[21.68536] → [21.68536:68555]

B:BD[21.68536] → [2.26437:26456]

B:BD[17.111517] → [17.111517:111531]

B:BD[17.110425] → [17.110425:110504]

B:BD[17.110579] → [17.110579:110650]

B:BD[17.110727] → [60.64220:64297]

B:BD[58.85032] → [102.49285:49358]

B:BD[17.111026] → [59.72427:72977]

B:BD[58.85182] → [58.85182:85582]

B:BD[17.111026] → [58.85106:85182]

B:BD[17.111026] → [62.87058:87134]

B:BD[17.111026] → [60.64372:64448]

B:BD[17.111026] → [17.111026:111502]

B:BD[58.85032] → [63.62104:62177]

B:BD[58.85032] → [64.44115:44188]

B:BD[58.85032] → [58.85032:85105]

B:BD[58.85032] → [62.86984:87057]

B:BD[58.85032] → [77.56248:56321]

B:BD[58.85032] → [60.64298:64371]

B:BD[17.110650] → [59.72060:72204]

B:BD[17.110727] → [59.72205:72426]

B:BD[58.84961] → [58.84961:85032]

B:BD[17.110948] → [17.110948:111026]

B:BD[17.110727] → [58.84884:84961]

B:BD[17.110727] → [62.86906:86983]

B:BD[17.110727] → [17.110727:110948]

B:BD[17.110650] → [102.49207:49284]

B:BD[17.110650] → [63.62026:62103]

B:BD[17.110650] → [64.44037:44114]

B:BD[17.110650] → [77.56170:56247]

B:BD[17.110650] → [17.110650:110727]

B:BD[17.110504] → [59.71984:72059]

B:BD[17.110504] → [63.61950:62025]

B:BD[17.110504] → [64.43961:44036]

B:BD[17.110504] → [58.84808:84883]

B:BD[17.110504] → [62.86830:86905]

B:BD[17.110504] → [77.56094:56169]

B:BD[17.110504] → [60.64144:64219]

B:BD[17.110504] → [17.110504:110579]

B:BD[17.110352] → [59.71910:71983]

B:BD[17.110352] → [63.61876:61949]

B:BD[17.110352] → [58.84734:84807]

B:BD[17.110352] → [62.86756:86829]

B:BD[17.110352] → [21.68288:68513]

B:BD[17.110352] → [77.56020:56093]

B:BD[17.110352] → [60.64070:64143]

B:BD[17.110352] → [2.26379:26436]

B:BD[17.110352] → [17.110352:110425]

B:BD[17.110252] → [17.110252:110270]

B:BD[17.110232] → [21.68251:68268]

B:BD[21.68268] → [21.68268:68287]

B:BD[21.68268] → [2.26280:26299]

B:BD[17.110232] → [17.110232:110252]

B:BD[17.110217] → [17.110217:110219]

B:BD[17.109983] → [17.109983:110217]

B:BD[17.109909] → [17.109909:109983]

B:BD[17.109696] → [17.109696:109838]

B:BD[17.109838] → [17.109838:109909]

B:BD[17.109624] → [17.109624:109696]

B:BD[17.109476] → [17.109476:109624]

B:BD[17.109459] → [2.26201:26279]

B:BD[17.109459] → [17.109459:109476]

B:BD[17.109376] → [58.84169:84187]

B:BD[17.109376] → [17.109376:109394]

B:BD[17.109357] → [21.68209:68250]

B:BD[17.109357] → [17.109357:109376]

B:BD[17.109037] → [17.109037:109108]

B:BD[17.108819] → [59.71047:71265]

B:BD[17.108819] → [63.61505:61653]

B:BD[17.108819] → [58.83793:83941]

B:BD[17.108819] → [62.86071:86219]

B:BD[17.108819] → [21.68134:68208]

B:BD[17.108819] → [77.55505:55578]

B:BD[17.108819] → [60.63385:63533]

B:BD[17.108819] → [2.26190:26200]

B:BD[17.108819] → [17.108819:109037]

B:BD[17.108719] → [17.108719:108737]

B:BD[17.108700] → [17.108700:108719]

B:BD[60.63088] → [102.49056:49133]

B:BD[17.108390] → [58.83478:83554]

B:BD[58.83569] → [58.83569:83773]

B:BD[17.108466] → [17.108466:108481]

B:BD[58.83554] → [58.83554:83569]

B:BD[17.108390] → [62.85994:86070]

∅:BD[2.25830] → [60.63165:63180]

∅:BD[21.66997] → [60.63165:63180]

B:BD[60.63165] → [60.63165:63180]

B:BD[77.55311] → [64.43573:43591]

∅:BD[2.25934] → [77.55394:55411]

∅:BD[21.67127] → [77.55394:55411]

B:BD[77.55394] → [77.55394:55411]

∅:BD[2.26110] → [77.55489:55504]

∅:BD[21.68100] → [77.55489:55504]

B:BD[77.55489] → [77.55489:55504]

B:BD[77.55504] → [21.68101:68133]

B:BD[77.55411] → [21.67128:68100]

B:BD[77.55411] → [77.55411:55489]

B:BD[77.55411] → [2.25935:26110]

B:BD[77.55311] → [77.55311:55329]

B:BD[77.55329] → [77.55329:55394]

B:BD[60.63180] → [21.66998:67036]

B:BD[21.67036] → [21.67036:67127]

B:BD[21.67036] → [2.25831:25934]

B:BD[60.63180] → [77.55285:55311]

B:BD[60.63180] → [60.63180:63384]

B:BD[17.108390] → [60.63089:63165]

B:BD[17.108390] → [17.108390:108466]

B:BD[17.108313] → [17.108313:108390]

B:BD[17.108238] → [59.70875:70950]

B:BD[17.108238] → [63.61352:61504]

B:BD[17.108238] → [64.43420:43572]

B:BD[17.108238] → [58.83402:83477]

B:BD[17.108238] → [62.85918:85993]

B:BD[17.108238] → [21.66540:66997]

B:BD[17.108238] → [77.55132:55284]

B:BD[17.108238] → [60.63013:63088]

B:BD[17.108238] → [2.25747:25830]

B:BD[17.108238] → [17.108238:108313]

B:BD[17.108119] → [21.66501:66521]

B:BD[17.108119] → [17.108119:108138]

B:BD[17.108138] → [59.70856:70874]

B:BD[17.108138] → [58.83383:83401]

B:BD[17.108138] → [17.108138:108156]

B:BD[17.107795] → [58.83073:83155]

B:BD[58.83230] → [58.83230:83301]

B:BD[58.83301] → [63.61270:61351]

B:BD[58.83301] → [58.83301:83382]

B:BD[58.83301] → [62.85836:85917]

B:BD[58.83301] → [77.55050:55131]

B:BD[58.83301] → [60.62931:63012]

B:BD[58.83155] → [63.61194:61269]

B:BD[58.83155] → [64.43344:43419]

B:BD[58.83155] → [58.83155:83230]

B:BD[58.83155] → [62.85760:85835]

B:BD[58.83155] → [77.54974:55049]

B:BD[58.83155] → [60.62855:62930]

B:BD[17.107795] → [21.66043:66500]

B:BD[17.108104] → [17.108104:108119]

B:BD[17.107795] → [17.107795:108104]

B:BD[17.107694] → [64.43324:43343]

B:BD[17.107694] → [58.83053:83072]

B:BD[17.107694] → [77.54954:54973]

B:BD[17.107694] → [17.107694:107713]

B:BD[17.107713] → [17.107713:107795]

B:BD[17.107673] → [21.66004:66024]

B:BD[21.66024] → [21.66024:66042]

B:BD[17.107673] → [17.107673:107694]

B:BD[17.106968] → [59.69990:70526]

B:BD[17.106968] → [58.82362:82526]

B:BD[17.106968] → [62.85283:85525]

B:BD[17.106968] → [21.65853:66003]

B:BD[17.106968] → [60.62455:62619]

B:BD[17.106968] → [2.25642:25667]

B:BD[17.106968] → [17.106968:107658]

B:BD[17.106867] → [102.49036:49055]

B:BD[17.106867] → [63.61016:61035]

B:BD[17.106867] → [64.43151:43170]

B:BD[17.106867] → [58.82342:82361]

B:BD[17.106867] → [62.85263:85282]

B:BD[17.106867] → [77.54699:54718]

B:BD[17.106867] → [60.62435:62454]

B:BD[17.106867] → [17.106867:106886]

B:BD[17.106841] → [21.65815:65852]

B:BD[17.106841] → [17.106841:106867]

B:BD[17.106527] → [17.106527:106599]

B:BD[17.106379] → [59.69665:69813]

B:BD[17.106379] → [63.60867:61015]

B:BD[17.106379] → [58.82036:82184]

B:BD[17.106379] → [62.84957:85105]

B:BD[17.106379] → [21.65592:65814]

B:BD[17.106379] → [77.54478:54551]

B:BD[17.106379] → [60.62129:62277]

B:BD[17.106379] → [2.25528:25562]

B:BD[17.106379] → [17.106379:106527]

B:BD[17.106279] → [59.69646:69664]

B:BD[17.106279] → [58.82017:82035]

B:BD[17.106279] → [17.106279:106297]

B:BD[17.105980] → [21.65551:65591]

B:BD[17.105980] → [17.105980:106260]

B:BD[17.105577] → [102.48938:49016]

B:BD[60.61890] → [63.60698:60771]

B:BD[58.81771] → [102.49017:49035]

B:BD[58.81871] → [58.81871:82016]

B:BD[58.81871] → [62.84881:84956]

B:BD[58.81871] → [60.61983:62053]

B:BD[60.62053] → [63.60791:60866]

B:BD[60.62053] → [64.42927:43002]

B:BD[60.62053] → [77.54402:54477]

B:BD[60.62053] → [60.62053:62128]

B:BD[58.81771] → [63.60772:60790]

B:BD[58.81771] → [64.42908:42926]

B:BD[58.81789] → [58.81789:81871]

B:BD[58.81771] → [58.81771:81789]

B:BD[58.81771] → [62.84862:84880]

B:BD[58.81771] → [77.54383:54401]

B:BD[58.81771] → [60.61964:61982]

B:BD[60.61890] → [77.54309:54382]

B:BD[60.61890] → [60.61890:61963]

B:BD[60.61734] → [60.61734:61890]

B:BD[58.81736] → [58.81736:81771]

B:BD[17.105577] → [63.60538:60697]

B:BD[17.105577] → [64.42829:42907]

B:BD[17.105577] → [58.81348:81736]

B:BD[17.105577] → [62.84473:84861]

B:BD[17.105577] → [77.54149:54227]

B:BD[77.54227] → [77.54227:54308]

B:BD[17.105577] → [60.61575:61653]

B:BD[60.61653] → [60.61653:61734]

B:BD[17.105577] → [17.105577:105965]

B:BD[17.105503] → [17.105503:105577]

B:BD[17.105285] → [63.60390:60537]

B:BD[17.105285] → [64.42610:42828]

B:BD[17.105285] → [58.81200:81347]

B:BD[17.105285] → [62.84325:84472]

B:BD[17.105285] → [77.53930:54148]

B:BD[17.105285] → [60.61427:61502]

B:BD[17.105432] → [17.105432:105503]

B:BD[60.61502] → [102.48865:48937]

B:BD[60.61502] → [60.61502:61574]

B:BD[17.105285] → [17.105285:105432]

B:BD[17.105185] → [58.81181:81199]

B:BD[17.105185] → [17.105185:105203]

B:BD[17.105203] → [17.105203:105285]

B:BD[58.80720] → [64.42384:42531]

B:BD[58.80946] → [63.60230:60311]

B:BD[60.61349] → [102.48787:48864]

B:BD[60.61349] → [63.60312:60389]

B:BD[60.61349] → [64.42532:42609]

B:BD[60.61349] → [77.53852:53929]

B:BD[60.61349] → [60.61349:61426]

B:BD[58.80946] → [58.80946:81180]

B:BD[58.80946] → [62.84167:84324]

B:BD[58.80946] → [21.65398:65550]

B:BD[58.80946] → [77.53770:53851]

B:BD[17.105148] → [17.105148:105185]

B:BD[58.80946] → [60.61192:61273]

B:BD[60.61273] → [60.61273:61349]

B:BD[17.104689] → [58.80721:80797]

B:BD[58.80797] → [58.80797:80875]

B:BD[58.80650] → [58.80650:80720]

B:BD[17.104689] → [62.84091:84166]

B:BD[58.80720] → [77.53622:53769]

B:BD[17.104689] → [60.61115:61191]

B:BD[17.104689] → [17.104689:105148]

B:BD[58.80497] → [64.42308:42383]

B:BD[58.80875] → [58.80875:80946]

B:BD[58.80497] → [58.80497:80650]

B:BD[58.80497] → [62.83937:84090]

B:BD[58.80497] → [77.53546:53621]

B:BD[58.80497] → [60.60961:61036]

B:BD[60.61036] → [60.61036:61114]

B:BD[17.104618] → [17.104618:104689]

B:BD[17.104313] → [59.68402:68707]

B:BD[17.104313] → [58.80415:80497]

B:BD[17.104313] → [21.64490:65397]

B:BD[17.104313] → [2.25245:25448]

B:BD[17.104313] → [17.104313:104618]

B:BD[17.104213] → [17.104213:104231]

B:BD[17.104190] → [21.64455:64489]

B:BD[17.104190] → [17.104190:104213]

B:BD[17.104175] → [17.104175:104177]

B:BD[17.103957] → [17.103957:104175]

B:BD[17.103940] → [2.25087:25165]

B:BD[17.103940] → [17.103940:103957]

B:BD[17.103856] → [58.80157:80176]

B:BD[17.103856] → [62.83749:83768]

B:BD[17.103856] → [60.60773:60792]

B:BD[17.103856] → [17.103856:103875]

B:BD[17.103838] → [21.64419:64454]

B:BD[17.103838] → [17.103838:103856]

B:BD[17.103588] → [59.67909:68143]

B:BD[17.103588] → [63.59844:59919]

B:BD[17.103588] → [64.42071:42146]

B:BD[17.103588] → [58.79921:80156]

B:BD[17.103588] → [62.83513:83748]

B:BD[17.103588] → [21.64178:64418]

B:BD[17.103588] → [77.53236:53311]

B:BD[17.103588] → [60.60537:60612]

B:BD[17.103588] → [2.25021:25086]

B:BD[17.103588] → [17.103588:103823]

B:BD[17.103488] → [58.79902:79920]

B:BD[17.103488] → [62.83494:83512]

B:BD[17.103488] → [60.60518:60536]

B:BD[17.103488] → [17.103488:103506]

B:BD[17.103470] → [21.64144:64177]

B:BD[17.103470] → [17.103470:103488]

B:BD[17.103298] → [59.67814:67889]

B:BD[17.103298] → [58.79744:79826]

B:BD[17.103298] → [21.64065:64143]

B:BD[17.103298] → [2.24925:24941]

B:BD[17.103298] → [17.103298:103455]

B:BD[17.103198] → [63.59749:59767]

B:BD[17.103198] → [58.79725:79743]

B:BD[17.103198] → [62.83399:83417]

B:BD[17.103198] → [77.53141:53159]

B:BD[17.103198] → [60.60423:60441]

B:BD[17.103198] → [17.103198:103216]

B:BD[17.103174] → [21.64024:64064]

B:BD[17.103174] → [17.103174:103198]

B:BD[17.103003] → [59.67638:67794]

B:BD[17.103003] → [63.59592:59748]

B:BD[17.103003] → [64.41919:41994]

B:BD[17.103003] → [58.79568:79724]

B:BD[17.103003] → [62.83242:83398]

B:BD[17.103003] → [21.63801:64023]

B:BD[17.103003] → [77.52984:53059]

B:BD[17.103003] → [60.60266:60422]

B:BD[17.103003] → [2.24811:24845]

B:BD[17.103003] → [17.103003:103159]

B:BD[17.102903] → [63.59573:59591]

B:BD[17.102903] → [58.79549:79567]

B:BD[17.102903] → [62.83223:83241]

B:BD[17.102903] → [77.52965:52983]

B:BD[17.102903] → [60.60247:60265]

B:BD[17.102903] → [17.102903:102921]

B:BD[17.102634] → [63.59424:59572]

B:BD[17.102858] → [17.102858:102903]

B:BD[17.102634] → [58.79324:79548]

B:BD[17.102634] → [62.82998:83222]

B:BD[17.102634] → [77.52816:52889]

B:BD[60.60170] → [60.60170:60246]

B:BD[77.52889] → [64.41843:41918]

B:BD[77.52889] → [77.52889:52964]

B:BD[17.102634] → [60.60022:60170]

B:BD[17.102634] → [17.102634:102858]

B:BD[17.102513] → [21.63757:63781]

B:BD[21.63781] → [21.63781:63800]

B:BD[21.63781] → [2.24712:24731]

B:BD[17.102513] → [17.102513:102634]

B:BD[17.102423] → [59.67318:67393]

B:BD[17.102423] → [63.59348:59423]

B:BD[17.102423] → [64.41767:41842]

B:BD[17.102423] → [58.79248:79323]

B:BD[17.102423] → [62.82922:82997]

B:BD[17.102423] → [21.63674:63756]

B:BD[17.102423] → [77.52740:52815]

B:BD[17.102423] → [60.59946:60021]

B:BD[17.102423] → [2.24692:24711]

B:BD[17.102423] → [17.102423:102498]

B:BD[17.102300] → [21.63635:63654]

B:BD[21.63654] → [21.63654:63673]

B:BD[21.63654] → [2.24593:24612]

B:BD[17.102300] → [17.102300:102341]

B:BD[17.101110] → [17.101110:101181]

B:BD[17.101257] → [17.101257:101335]

B:BD[17.101181] → [58.78220:78296]

B:BD[17.101181] → [62.82284:82359]

B:BD[17.101181] → [60.59223:59299]

B:BD[17.101181] → [17.101181:101257]

B:BD[17.100962] → [59.66380:66528]

B:BD[17.100962] → [63.58867:59015]

B:BD[17.100962] → [58.78071:78219]

B:BD[17.100962] → [62.82135:82283]

B:BD[17.100962] → [21.63554:63634]

B:BD[17.100962] → [77.51594:51667]

B:BD[17.100962] → [60.59074:59222]

B:BD[17.100962] → [2.24574:24592]

B:BD[17.100962] → [17.100962:101110]

B:BD[17.100861] → [17.100861:100880]

B:BD[17.100831] → [17.100831:100861]

B:BD[17.100605] → [17.100605:100831]

B:BD[17.100523] → [17.100523:100605]

B:BD[17.100504] → [17.100504:100523]

B:BD[17.100475] → [17.100475:100504]

B:BD[17.100397] → [17.100397:100475]

B:BD[17.100098] → [17.100098:100397]

B:BD[17.100079] → [59.66014:66033]

B:BD[17.100079] → [63.58600:58619]

B:BD[17.100079] → [58.77705:77724]

B:BD[17.100079] → [62.81789:81808]

B:BD[17.100079] → [77.51327:51346]

B:BD[17.100079] → [60.58728:58747]

B:BD[17.100079] → [17.100079:100098]

B:BD[17.99966] → [17.99966:100061]

B:BD[17.99813] → [17.99813:99966]

B:BD[17.99731] → [17.99731:99813]

B:BD[17.99713] → [17.99713:99731]

B:BD[17.99696] → [17.99696:99713]

B:BD[17.99606] → [21.63475:63553]

B:BD[17.99606] → [2.24478:24494]

B:BD[17.99606] → [17.99606:99681]

B:BD[17.99506] → [64.41015:41033]

B:BD[17.99506] → [21.63456:63474]

B:BD[17.99506] → [77.51062:51080]

B:BD[17.99506] → [17.99506:99524]

B:BD[17.99400] → [58.77478:77550]

B:BD[17.99400] → [17.99400:99472]

B:BD[17.99259] → [2.24371:24398]

B:BD[17.99259] → [17.99259:99400]

B:BD[17.99159] → [59.65768:65786]

B:BD[17.99159] → [58.77459:77477]

B:BD[17.99159] → [17.99159:99177]

B:BD[17.98973] → [17.98973:99054]

B:BD[17.98676] → [59.65396:65693]

B:BD[17.98676] → [63.58125:58270]

B:BD[17.98676] → [64.40787:40932]

B:BD[17.98676] → [58.77087:77232]

B:BD[17.98676] → [62.81333:81478]

B:BD[17.98676] → [21.63003:63455]

B:BD[17.98676] → [77.50680:50825]

B:BD[17.98676] → [60.58272:58345]

B:BD[17.98676] → [2.24208:24291]

B:BD[17.98676] → [17.98676:98973]

B:BD[17.98576] → [59.65377:65395]

B:BD[17.98576] → [64.40768:40786]

B:BD[17.98576] → [58.77068:77086]

B:BD[17.98576] → [62.81314:81332]

B:BD[17.98576] → [21.62984:63002]

B:BD[17.98576] → [77.50661:50679]

B:BD[17.98576] → [60.58253:58271]

B:BD[17.98576] → [17.98576:98594]

B:BD[17.98465] → [17.98465:98543]

B:BD[17.98393] → [17.98393:98465]

B:BD[17.98241] → [59.65153:65376]

B:BD[17.98241] → [102.48055:48134]

B:BD[17.98241] → [63.57900:58124]

B:BD[17.98241] → [64.40615:40694]

B:BD[17.98241] → [58.76843:76922]

B:BD[17.98241] → [21.62683:62983]

B:BD[17.98241] → [77.50436:50515]

B:BD[17.98241] → [2.24078:24128]

B:BD[17.98241] → [17.98241:98393]

B:BD[17.98140] → [59.65133:65152]

B:BD[17.98140] → [64.40595:40614]

B:BD[17.98140] → [58.76823:76842]

B:BD[17.98140] → [21.62663:62682]

B:BD[17.98140] → [77.50416:50435]

B:BD[17.98140] → [17.98140:98159]

B:BD[17.98025] → [21.62433:62662]

B:BD[17.98025] → [2.23956:23998]

B:BD[17.98025] → [17.98025:98103]

B:BD[17.97816] → [17.97816:97943]

B:BD[17.97664] → [17.97664:97816]

B:BD[17.97582] → [17.97582:97664]

B:BD[17.97562] → [59.64960:64980]

B:BD[17.97562] → [102.47954:47974]

B:BD[17.97562] → [63.57726:57746]

B:BD[17.97562] → [86.34771:34791]

B:BD[17.97562] → [64.40494:40514]

B:BD[17.97562] → [58.76649:76669]

B:BD[17.97562] → [62.81073:81093]

B:BD[17.97562] → [21.62413:62432]

B:BD[17.97562] → [77.50242:50262]

B:BD[17.97562] → [60.58012:58032]

B:BD[17.97562] → [2.23857:23876]

B:BD[17.97562] → [17.97562:97582]

B:BD[17.97293] → [2.23778:23856]

B:BD[17.97293] → [17.97293:97536]

B:BD[58.76601] → [2.23508:23586]

B:BD[17.97083] → [17.97083:97195]

B:BD[17.97195] → [17.97195:97228]

B:BD[17.97005] → [17.97005:97083]

B:BD[17.96987] → [59.64941:64959]

B:BD[17.96987] → [63.57707:57725]

B:BD[17.96987] → [58.76518:76536]

B:BD[17.96987] → [62.81054:81072]

B:BD[17.96987] → [77.50223:50241]

B:BD[17.96987] → [60.57993:58011]

B:BD[17.96987] → [17.96987:97005]

B:BD[17.96846] → [17.96846:96971]

B:BD[17.96745] → [17.96745:96831]

B:BD[17.96434] → [59.64630:64940]

B:BD[17.96434] → [58.76206:76365]

B:BD[17.96434] → [21.62104:62412]

B:BD[17.96434] → [2.23448:23507]

B:BD[17.96434] → [17.96434:96745]

B:BD[17.96334] → [21.62085:62103]

B:BD[17.96334] → [17.96334:96352]

B:BD[17.96043] → [17.96043:96116]

B:BD[17.96116] → [17.96116:96289]

B:BD[17.95960] → [17.95960:96043]

B:BD[17.95716] → [59.64311:64555]

B:BD[17.95716] → [58.75887:76053]

B:BD[17.95716] → [62.80739:80905]

B:BD[17.95716] → [21.61766:62009]

B:BD[17.95716] → [60.57678:57844]

B:BD[17.95716] → [2.23280:23368]

B:BD[17.95716] → [17.95716:95960]

B:BD[17.95616] → [21.61747:61765]

B:BD[17.95616] → [17.95616:95634]

B:BD[17.95498] → [77.49884:49902]

B:BD[17.95516] → [17.95516:95581]

B:BD[17.95498] → [17.95498:95516]

B:BD[17.95345] → [17.95345:95498]

B:BD[17.95044] → [59.63992:64291]

B:BD[17.95044] → [63.57180:57479]

B:BD[17.95044] → [64.40175:40320]

B:BD[17.95044] → [58.75568:75867]

B:BD[17.95044] → [62.80439:80738]

B:BD[17.95044] → [21.61446:61746]

B:BD[17.95044] → [77.49584:49729]

B:BD[17.95044] → [60.57378:57451]

B:BD[17.95044] → [2.23145:23200]

B:BD[17.95044] → [17.95044:95343]

B:BD[17.94944] → [64.40156:40174]

B:BD[17.94944] → [21.61426:61445]

B:BD[17.94944] → [77.49565:49583]

B:BD[17.94944] → [2.23046:23065]

B:BD[17.94944] → [17.94944:94962]

B:BD[17.94831] → [59.63875:63893]

B:BD[17.94831] → [64.40137:40155]

B:BD[17.94831] → [58.75549:75567]

B:BD[17.94831] → [62.80322:80340]

B:BD[17.94831] → [21.61407:61425]

B:BD[17.94831] → [77.49545:49564]

B:BD[17.94831] → [60.57359:57377]

B:BD[17.94831] → [17.94831:94849]

B:BD[17.94717] → [59.63856:63874]

B:BD[17.94717] → [58.75530:75548]

B:BD[17.94717] → [17.94717:94735]

B:BD[17.94607] → [21.61388:61406]

B:BD[17.94607] → [17.94607:94625]

B:BD[17.94425] → [102.47652:47800]

B:BD[17.94425] → [63.57032:57179]

B:BD[17.94425] → [86.34694:34770]

B:BD[17.94573] → [17.94573:94588]

B:BD[17.94425] → [58.75381:75529]

B:BD[17.94425] → [62.80174:80321]

B:BD[17.94425] → [77.49396:49544]

B:BD[17.94425] → [60.57210:57358]

B:BD[17.94425] → [17.94425:94501]

B:BD[17.94501] → [17.94501:94573]

B:BD[17.94325] → [102.47329:47651]

B:BD[17.94325] → [63.57013:57031]

B:BD[17.94325] → [64.39969:39987]

∅:BD[21.61239] → [77.49091:49156]

∅:BD[64.39987] → [77.49091:49156]

B:BD[77.49091] → [77.49091:49156]

∅:BD[2.22785] → [77.49156:49173]

B:BD[77.49156] → [77.49156:49173]

∅:BD[2.22808] → [77.49332:49347]

∅:BD[21.61387] → [77.49332:49347]

∅:BD[64.40136] → [77.49332:49347]

B:BD[77.49332] → [77.49332:49347]

B:BD[17.94343] → [17.94343:94425]

B:BD[77.49347] → [77.49347:49395]

B:BD[77.49173] → [64.39988:40136]

B:BD[77.49173] → [21.61240:61387]

B:BD[77.49173] → [77.49173:49332]

B:BD[77.49173] → [2.22786:22808]

B:BD[77.49156] → [2.22707:22785]

B:BD[17.94325] → [58.75362:75380]

B:BD[17.94325] → [62.80155:80173]

B:BD[17.94325] → [77.49073:49091]

B:BD[17.94325] → [60.57191:57209]

B:BD[17.94325] → [17.94325:94343]

B:BD[17.94304] → [21.61191:61239]

B:BD[17.94304] → [17.94304:94325]

B:BD[17.94210] → [17.94210:94289]

B:BD[58.75208] → [21.61037:61110]

B:BD[17.94137] → [17.94137:94210]

B:BD[17.93987] → [17.93987:94137]

B:BD[17.93908] → [59.63459:63688]

B:BD[17.93908] → [102.47249:47328]

B:BD[17.93908] → [63.56933:57012]

B:BD[17.93908] → [64.39889:39968]

B:BD[17.93908] → [58.75052:75131]

B:BD[17.93908] → [62.80075:80154]

B:BD[17.93908] → [21.60957:61036]

B:BD[17.93908] → [65.31111:31190]

B:BD[17.93908] → [77.48993:49072]

B:BD[17.93908] → [60.57111:57190]

B:BD[17.93908] → [2.22632:22706]

B:BD[17.93908] → [17.93908:93987]

B:BD[17.93908] → [93.63350:63429]

B:BD[17.93808] → [59.63440:63458]

B:BD[17.93808] → [102.47230:47248]

B:BD[17.93808] → [63.56914:56932]

B:BD[17.93808] → [64.39870:39888]

B:BD[17.93808] → [58.75033:75051]

B:BD[17.93808] → [21.60938:60956]

B:BD[17.93808] → [77.48974:48992]

B:BD[17.93808] → [2.22534:22552]

B:BD[17.93808] → [17.93808:93826]

B:BD[17.93700] → [17.93700:93779]

B:BD[17.93624] → [17.93624:93700]

B:BD[17.93551] → [17.93551:93624]

B:BD[17.93472] → [59.63210:63439]

B:BD[17.93472] → [102.47150:47229]

B:BD[17.93472] → [63.56834:56913]

B:BD[17.93472] → [64.39790:39869]

B:BD[17.93472] → [58.74800:74879]

B:BD[17.93472] → [62.79995:80074]

B:BD[17.93472] → [21.60705:60857]

B:BD[17.93472] → [65.31031:31110]

B:BD[17.93472] → [77.48894:48973]

B:BD[17.93472] → [60.57031:57110]

B:BD[17.93472] → [2.22160:22533]

B:BD[17.93472] → [17.93472:93551]

B:BD[17.93472] → [93.63270:63349]

B:BD[17.93372] → [59.63191:63209]

B:BD[17.93372] → [58.74781:74799]

B:BD[17.93372] → [21.60686:60704]

B:BD[17.93372] → [17.93372:93390]

B:BD[17.93264] → [17.93264:93343]

B:BD[17.93188] → [17.93188:93264]

B:BD[17.93115] → [17.93115:93188]

B:BD[17.93036] → [59.62961:63190]

B:BD[17.93036] → [102.47070:47149]

B:BD[17.93036] → [63.56754:56833]

B:BD[17.93036] → [64.39710:39789]

B:BD[17.93036] → [58.74548:74627]

B:BD[17.93036] → [62.79915:79994]

B:BD[17.93036] → [21.60453:60605]

B:BD[17.93036] → [65.30951:31030]

B:BD[17.93036] → [77.48814:48893]

B:BD[17.93036] → [60.56951:57030]

B:BD[17.93036] → [2.21706:22080]

B:BD[17.93036] → [17.93036:93115]

B:BD[17.93036] → [93.63190:63269]

B:BD[17.92936] → [59.62942:62960]

B:BD[17.92936] → [58.74529:74547]

B:BD[17.92936] → [21.60434:60452]

B:BD[17.92936] → [17.92936:92954]

B:BD[17.92763] → [17.92763:92906]

B:BD[17.92692] → [64.39495:39709]

B:BD[17.92692] → [21.60218:60433]

B:BD[17.92692] → [77.48599:48813]

B:BD[17.92692] → [2.21599:21626]

B:BD[17.92692] → [17.92692:92763]

B:BD[17.92591] → [59.62778:62797]

B:BD[17.92591] → [58.74365:74384]

B:BD[17.92591] → [62.79821:79840]

B:BD[17.92591] → [21.60198:60217]

B:BD[17.92591] → [60.56857:56876]

B:BD[17.92591] → [2.21500:21519]

B:BD[17.92591] → [17.92591:92610]

B:BD[17.92484] → [17.92484:92556]

B:BD[17.92332] → [59.62554:62777]

B:BD[17.92332] → [102.46917:46996]

B:BD[17.92332] → [63.56455:56679]

B:BD[17.92332] → [64.39342:39421]

B:BD[17.92332] → [58.74140:74219]

B:BD[17.92332] → [21.59975:60197]

B:BD[17.92332] → [77.48374:48453]

B:BD[17.92332] → [2.21465:21499]

B:BD[17.92332] → [17.92332:92484]

B:BD[17.92231] → [59.62534:62553]

B:BD[17.92231] → [63.56435:56454]

B:BD[17.92231] → [64.39322:39341]

B:BD[17.92231] → [58.74120:74139]

B:BD[17.92231] → [62.79655:79674]

B:BD[17.92231] → [21.59954:59974]

B:BD[17.92231] → [77.48354:48373]

B:BD[17.92231] → [60.56691:56710]

B:BD[17.92231] → [2.21365:21385]

B:BD[17.92231] → [17.92231:92250]

B:BD[17.92112] → [59.62514:62533]

B:BD[17.92112] → [63.56415:56434]

B:BD[17.92112] → [64.39302:39321]

B:BD[17.92112] → [58.74100:74119]

B:BD[17.92112] → [62.79635:79654]

B:BD[17.92112] → [21.59933:59953]

B:BD[17.92112] → [77.48334:48353]

B:BD[17.92112] → [60.56671:56690]

B:BD[17.92112] → [2.21265:21285]

B:BD[17.92112] → [17.92112:92131]

B:BD[17.91695] → [17.91695:91775]

B:BD[17.91027] → [59.61611:62205]

B:BD[17.91027] → [63.55735:55884]

B:BD[17.91027] → [58.73045:73194]

B:BD[17.91027] → [62.78955:79104]

B:BD[17.91027] → [21.58843:59932]

B:BD[17.91027] → [77.47652:47801]

B:BD[17.91027] → [60.55989:56138]

B:BD[17.91027] → [2.21071:21264]

B:BD[17.91027] → [17.91027:91324]

B:BD[17.91324] → [17.91324:91695]

B:BD[20.42288] → [20.42288:42306]

B:BD[20.43379] → [24.13020:13092]

B:BD[20.43193] → [24.13001:13019]

B:BD[20.42985] → [24.12839:12911]

B:BD[24.12911] → [24.12911:13000]

B:BD[20.42717] → [24.12820:12838]

B:BD[20.42407] → [24.12741:12819]

B:BD[20.43379] → [40.14879:14951]

B:BD[20.43293] → [40.14799:14878]

B:BD[20.43193] → [40.14780:14798]

B:BD[20.42985] → [40.14618:14779]

B:BD[20.43379] → [41.9784:9856]

B:BD[20.43193] → [41.9765:9783]

B:BD[20.42985] → [41.9603:9764]

B:BD[20.43379] → [92.6692:6764]

B:BD[20.42985] → [92.6619:6691]

B:BD[20.43379] → [70.7221:7293]

B:BD[20.42985] → [70.7148:7220]

B:BD[20.42407] → [70.7069:7147]

B:BD[20.43379] → [111.9718:9790]

B:BD[20.42985] → [111.9645:9717]

B:BD[20.43379] → [42.25864:25936]

B:BD[20.43293] → [42.25784:25863]

B:BD[20.43193] → [42.25765:25783]

B:BD[20.42985] → [42.25603:25764]

B:BD[20.42717] → [42.25584:25602]

B:BD[20.43379] → [43.33329:33401]

B:BD[20.43293] → [43.33249:33328]

B:BD[20.43193] → [43.33230:33248]

B:BD[20.42985] → [43.33068:33140]

B:BD[43.33140] → [43.33140:33229]

B:BD[20.42717] → [43.33049:33067]

B:BD[20.43379] → [29.52076:52148]

B:BD[20.43293] → [29.51996:52075]

B:BD[20.43193] → [29.51977:51995]

B:BD[29.51887] → [29.51887:51976]

B:BD[20.42985] → [29.51815:51887]

B:BD[20.42717] → [29.51796:51814]

B:BD[29.51722] → [29.51722:51795]

B:BD[20.42407] → [29.51644:51722]

B:BD[20.43379] → [44.5866:5938]

B:BD[20.43293] → [44.5786:5865]

B:BD[20.43193] → [44.5767:5785]

B:BD[20.42985] → [44.5605:5766]

B:BD[20.43379] → [46.65435:65507]

B:BD[20.42985] → [46.65362:65434]

B:BD[29.51722] → [46.65288:65361]

B:BD[20.43379] → [47.16073:16145]

B:BD[20.42985] → [47.16000:16072]

B:BD[20.42407] → [47.15921:15999]

B:BD[20.43379] → [22.15365:15437]

B:BD[20.42985] → [22.15292:15364]

B:BD[20.42407] → [22.15213:15291]

B:BD[20.43379] → [33.13132:13204]

B:BD[20.43293] → [33.13052:13131]

B:BD[20.43193] → [33.13033:13051]

B:BD[20.42985] → [33.12871:13032]

B:BD[20.43379] → [48.25779:25851]

B:BD[20.43293] → [48.25699:25778]

B:BD[20.43193] → [48.25680:25698]

B:BD[20.42985] → [48.25518:25679]

B:BD[20.42717] → [48.25499:25517]

B:BD[20.43379] → [30.21435:21507]

B:BD[20.42985] → [30.21362:21434]

B:BD[20.42407] → [30.21210:21361]

B:BD[20.43379] → [49.28210:28282]

B:BD[20.43193] → [49.28191:28209]

B:BD[20.42985] → [49.28029:28190]

B:BD[20.42717] → [49.28010:28028]

B:BD[20.42407] → [49.27858:28009]

B:BD[20.43379] → [50.7239:7311]

B:BD[20.42985] → [50.7166:7238]

B:BD[20.43379] → [51.10194:10266]

B:BD[20.43193] → [51.10175:10193]

B:BD[20.42985] → [51.10013:10174]

B:BD[20.43451] → [20.43451:43796]

B:BD[20.43379] → [20.43379:43451]

B:BD[20.43293] → [20.43293:43379]

B:BD[20.43211] → [20.43211:43293]

B:BD[20.43193] → [20.43193:43211]

B:BD[20.43146] → [20.43146:43193]

B:BD[20.42985] → [20.42985:43057]

B:BD[20.43057] → [20.43057:43146]

B:BD[20.42735] → [20.42735:42985]

B:BD[20.42717] → [20.42717:42735]

B:BD[20.42558] → [20.42558:42717]

B:BD[20.42407] → [20.42407:42485]

B:BD[20.42485] → [20.42485:42558]

B:BD[20.42325] → [20.42325:42407]

B:BD[20.43379] → [52.11969:12041]

B:BD[20.42985] → [52.11896:11968]

B:BD[20.42407] → [52.11817:11895]

B:BD[20.43379] → [38.20193:20265]

B:BD[20.42985] → [38.20120:20192]

B:BD[20.42407] → [38.20041:20119]

B:BD[20.43379] → [53.15237:15309]

B:BD[20.43193] → [53.15218:15236]

B:BD[20.42985] → [53.15056:15217]

B:BD[20.42717] → [53.15037:15055]

B:BD[20.43379] → [54.18576:18648]

B:BD[20.43193] → [54.18557:18575]

B:BD[20.42985] → [54.18395:18556]

B:BD[20.42717] → [54.18376:18394]

B:BD[20.43379] → [55.43538:43610]

B:BD[20.43293] → [55.43458:43537]

B:BD[20.43193] → [55.43439:43457]

B:BD[20.42985] → [55.43277:43438]

B:BD[20.42717] → [55.43258:43276]

B:BD[20.43379] → [37.18182:18254]

B:BD[20.43193] → [37.18163:18181]

B:BD[20.42985] → [37.18001:18162]

B:BD[20.43379] → [39.7064:7136]

B:BD[20.42985] → [39.6991:7063]

B:BD[20.42306] → [70.7049:7068]

B:BD[20.42306] → [29.51624:51643]

B:BD[20.42306] → [47.15901:15920]

B:BD[20.42306] → [30.21190:21209]

B:BD[20.42306] → [49.27838:27857]

B:BD[20.42306] → [20.42306:42325]

B:BD[20.42306] → [52.11797:11816]

B:BD[20.42306] → [38.20021:20040]

B:BD[20.42276] → [20.42276:42288]

B:BD[20.42288] → [17.90872:90991]

B:BD[20.42124] → [42.25148:25583]

B:BD[20.42124] → [43.32613:32831]

B:BD[43.32905] → [43.32905:33048]

B:BD[43.32831] → [92.6544:6618]

B:BD[20.42273] → [20.42273:42276]

B:BD[43.32831] → [70.6974:7048]

B:BD[43.32831] → [43.32831:32905]

B:BD[43.32831] → [47.15826:15900]

B:BD[43.32831] → [30.21115:21189]

B:BD[43.32831] → [39.6916:6990]

B:BD[20.42124] → [29.51188:51406]

B:BD[29.51480] → [29.51480:51623]

B:BD[29.51406] → [29.51406:51480]

B:BD[29.51406] → [46.65213:65287]

B:BD[20.42124] → [48.25063:25498]

B:BD[20.42124] → [49.27688:27837]

B:BD[20.42124] → [20.42124:42197]

B:BD[20.42197] → [40.14541:14617]

B:BD[20.42197] → [41.9526:9602]

B:BD[20.42197] → [111.9568:9644]

B:BD[20.42197] → [44.5528:5604]

B:BD[20.42197] → [33.12794:12870]

B:BD[20.42197] → [50.7089:7165]

B:BD[20.42197] → [51.9936:10012]

B:BD[20.42197] → [20.42197:42273]

B:BD[20.42197] → [37.17924:18000]

B:BD[20.42124] → [53.14887:15036]

B:BD[20.42124] → [54.18226:18375]

B:BD[20.42124] → [55.42822:43257]

B:BD[20.42024] → [42.25129:25147]

B:BD[20.42024] → [43.32594:32612]

B:BD[20.42024] → [29.51169:51187]

B:BD[20.42024] → [48.25044:25062]

B:BD[20.42024] → [49.27669:27687]

B:BD[20.42042] → [20.42042:42124]

B:BD[20.42024] → [20.42024:42042]

B:BD[20.42024] → [53.14868:14886]

B:BD[20.42024] → [54.18207:18225]

B:BD[20.42024] → [55.42803:42821]

B:BD[20.42010] → [20.42010:42024]

B:BD[20.41897] → [54.18093:18206]

B:BD[20.41819] → [20.41819:41897]

B:BD[24.12536] → [53.14754:14789]

B:BD[53.14789] → [53.14789:14867]

B:BD[24.12458] → [24.12458:12536]

B:BD[20.41801] → [22.15194:15212]

B:BD[22.15212] → [49.27555:27668]

B:BD[20.41801] → [20.41801:41819]

B:BD[20.41481] → [40.14521:14540]

B:BD[20.41481] → [41.9507:9525]

B:BD[20.41481] → [111.9548:9567]

B:BD[20.41481] → [42.25109:25128]

B:BD[20.41481] → [43.32574:32593]

B:BD[20.41481] → [29.51149:51168]

B:BD[20.41481] → [44.5508:5527]

B:BD[20.41481] → [46.65193:65212]

B:BD[20.41481] → [33.12774:12793]

B:BD[20.41481] → [48.25024:25043]

B:BD[20.41481] → [30.21095:21114]

B:BD[20.41481] → [49.27536:27554]

B:BD[20.41481] → [50.7070:7088]

B:BD[20.41481] → [51.9917:9935]

B:BD[20.41481] → [20.41481:41499]

B:BD[20.41499] → [20.41499:41801]

B:BD[20.41481] → [53.14735:14753]

B:BD[20.41481] → [54.18074:18092]

B:BD[20.41481] → [55.42783:42802]

B:BD[20.41481] → [37.17905:17923]

B:BD[20.41189] → [42.25090:25108]

B:BD[20.41189] → [43.32555:32573]

B:BD[20.41189] → [29.51130:51148]

B:BD[20.41189] → [48.25005:25023]

B:BD[20.41189] → [49.27517:27535]

B:BD[20.41189] → [20.41189:41207]

B:BD[20.41207] → [20.41207:41481]

B:BD[20.41189] → [53.14716:14734]

B:BD[20.41189] → [54.18055:18073]

B:BD[20.41189] → [55.42764:42782]

B:BD[20.41080] → [46.65119:65192]

B:BD[20.41080] → [30.21021:21094]

B:BD[20.41080] → [49.27443:27516]

B:BD[20.41080] → [20.41080:41153]

B:BD[20.41153] → [20.41153:41189]

B:BD[20.40956] → [20.40956:41080]

B:BD[20.40784] → [20.40784:40956]

B:BD[20.40766] → [40.14502:14520]

B:BD[20.40766] → [41.9488:9506]

B:BD[20.40766] → [111.9529:9547]

B:BD[20.40766] → [42.25071:25089]

B:BD[20.40766] → [44.5489:5507]

B:BD[20.40766] → [33.12755:12773]

B:BD[20.40766] → [50.7051:7069]

B:BD[20.40766] → [51.9898:9916]

B:BD[20.40766] → [20.40766:40784]

B:BD[20.40766] → [54.18036:18054]

B:BD[20.40766] → [55.42745:42763]

B:BD[20.40766] → [37.17886:17904]

B:BD[20.40341] → [22.15118:15193]

B:BD[20.40341] → [20.40341:40420]

B:BD[20.40572] → [20.40572:40729]

B:BD[20.40729] → [20.40729:40744]

B:BD[20.40420] → [40.14349:14501]

B:BD[20.40420] → [41.9335:9487]

B:BD[20.40420] → [111.9376:9528]

B:BD[20.40420] → [42.24918:25070]

B:BD[20.40420] → [44.5336:5488]

B:BD[20.40420] → [33.12602:12754]

B:BD[20.40420] → [50.6898:7050]

B:BD[20.40420] → [51.9745:9897]

B:BD[20.40420] → [20.40420:40572]

B:BD[20.40420] → [54.17883:18035]

B:BD[20.40420] → [55.42592:42744]

B:BD[20.40420] → [37.17733:17885]

B:BD[22.15099] → [29.51037:51055]

B:BD[22.15099] → [46.65100:65118]

B:BD[22.15099] → [22.15099:15117]

B:BD[22.15099] → [48.24986:25004]

B:BD[22.15099] → [30.21002:21020]

B:BD[22.15099] → [49.27424:27442]

B:BD[20.40259] → [20.40259:40341]

B:BD[22.15099] → [53.14697:14715]

B:BD[22.14753] → [43.32383:32456]

B:BD[29.50884] → [29.50884:50957]

B:BD[29.50957] → [29.50957:51036]

B:BD[29.50957] → [46.65020:65099]

B:BD[22.14905] → [22.14905:15099]

B:BD[22.14753] → [22.14753:14905]

B:BD[22.14753] → [48.24833:24985]

B:BD[22.14753] → [53.14544:14696]

B:BD[22.14674] → [140.991:1144]

B:BD[22.14674] → [70.6820:6973]

B:BD[22.14674] → [29.50805:50884]

B:BD[22.14674] → [46.64939:65019]

B:BD[22.14674] → [47.15673:15825]

B:BD[22.14674] → [22.14674:14753]

B:BD[22.14674] → [30.20770:21001]

B:BD[22.14674] → [49.27192:27423]

B:BD[22.14674] → [52.11644:11796]

B:BD[22.14674] → [38.19867:20020]

B:BD[22.14674] → [71.5343:5495]

B:BD[22.14574] → [70.6801:6819]

B:BD[22.14574] → [43.32364:32382]

B:BD[22.14574] → [29.50786:50804]

B:BD[22.14574] → [46.64920:64938]

B:BD[22.14574] → [47.15654:15672]

B:BD[22.14574] → [22.14574:14592]

B:BD[22.14574] → [48.24814:24832]

B:BD[22.14574] → [30.20751:20769]

B:BD[22.14574] → [49.27173:27191]

B:BD[22.14574] → [52.11625:11643]

B:BD[22.14574] → [38.19848:19866]

B:BD[22.14574] → [53.14525:14543]

B:BD[22.14463] → [43.32282:32363]

B:BD[22.14463] → [29.50704:50785]

B:BD[22.14463] → [46.64838:64919]

B:BD[22.14463] → [22.14463:14544]

B:BD[22.14463] → [48.24732:24813]

B:BD[22.14463] → [30.20669:20750]

B:BD[22.14463] → [49.27091:27172]

B:BD[22.14463] → [53.14443:14524]

B:BD[20.40048] → [20.40048:40130]

B:BD[20.40241] → [40.14330:14348]

B:BD[20.40241] → [41.9316:9334]

B:BD[20.40241] → [111.9357:9375]

B:BD[20.40241] → [42.24899:24917]

B:BD[20.40241] → [44.5317:5335]

B:BD[20.40241] → [33.12583:12601]

B:BD[20.40241] → [50.6879:6897]

B:BD[20.40241] → [51.9726:9744]

B:BD[20.40241] → [20.40241:40259]

B:BD[20.40211] → [20.40211:40241]

B:BD[20.40241] → [54.17864:17882]

B:BD[20.40241] → [55.42573:42591]

B:BD[20.40241] → [37.17714:17732]

B:BD[20.40130] → [40.14248:14329]

B:BD[20.40130] → [41.9234:9315]

B:BD[20.40130] → [111.9275:9356]

B:BD[20.40130] → [42.24817:24898]

B:BD[20.40130] → [44.5235:5316]

B:BD[20.40130] → [33.12501:12582]

B:BD[20.40130] → [50.6797:6878]

B:BD[20.40130] → [51.9644:9725]

B:BD[20.40130] → [20.40130:40211]

B:BD[20.40130] → [54.17782:17863]

B:BD[20.40130] → [55.42491:42572]

B:BD[20.40130] → [37.17632:17713]

B:BD[20.39910] → [40.14228:14247]

B:BD[20.39910] → [41.9214:9233]

B:BD[20.39910] → [111.9255:9274]

B:BD[20.39910] → [42.24797:24816]

B:BD[20.39910] → [43.32262:32281]

B:BD[20.39910] → [29.50684:50703]

B:BD[20.39910] → [44.5215:5234]

B:BD[20.39910] → [46.64818:64837]

B:BD[20.39910] → [22.14361:14380]

B:BD[20.39910] → [33.12481:12500]

B:BD[20.39910] → [48.24712:24731]

B:BD[20.39910] → [30.20649:20668]

B:BD[20.39910] → [49.27071:27090]

B:BD[20.39910] → [50.6777:6796]

B:BD[20.39910] → [51.9624:9643]

B:BD[20.39929] → [20.39929:40048]

B:BD[20.39910] → [20.39910:39929]

B:BD[20.39910] → [53.14423:14442]

B:BD[20.39910] → [54.17762:17781]

B:BD[20.39910] → [55.42471:42490]

B:BD[20.39910] → [37.17612:17631]

B:BD[48.24677] → [48.24677:24711]

B:BD[20.39887] → [20.39887:39910]

B:BD[48.24662] → [48.24662:24677]

B:BD[48.24586] → [48.24586:24662]

B:BD[48.24504] → [48.24504:24586]

B:BD[43.32135] → [43.32135:32150]

B:BD[43.32059] → [29.50607:50683]

B:BD[43.32059] → [49.26994:27070]

B:BD[22.14146] → [22.14146:14169]

B:BD[43.31977] → [43.31977:32059]

B:BD[22.14169] → [43.31959:31977]

B:BD[22.14169] → [22.14169:14187]

B:BD[22.14169] → [48.24486:24504]

B:BD[22.14169] → [49.26975:26993]

B:BD[22.14169] → [53.14404:14422]

B:BD[22.13975] → [43.31882:31958]

B:BD[22.14131] → [22.14131:14146]

B:BD[22.13975] → [29.50495:50571]

B:BD[22.13975] → [47.15497:15653]

B:BD[22.13975] → [22.13975:14051]

B:BD[22.14051] → [22.14051:14131]

B:BD[22.13975] → [30.20498:20648]

B:BD[22.13975] → [49.26818:26974]

B:BD[22.13975] → [52.11468:11624]

B:BD[22.13975] → [38.19697:19847]

B:BD[22.13875] → [29.50206:50494]

B:BD[22.13893] → [22.13893:13975]

B:BD[22.13875] → [47.15478:15496]

B:BD[22.13875] → [22.13875:13893]

B:BD[22.13875] → [30.20479:20497]

B:BD[22.13875] → [52.11449:11467]

B:BD[22.13875] → [38.19678:19696]

B:BD[43.31659] → [43.31659:31808]

B:BD[43.31587] → [43.31587:31659]

B:BD[43.31350] → [43.31350:31587]

B:BD[43.31332] → [43.31332:31350]

B:BD[43.31300] → [43.31300:31332]

B:BD[43.31227] → [43.31227:31300]

B:BD[43.31151] → [43.31151:31227]

B:BD[43.31079] → [43.31079:31151]

B:BD[43.31587] → [47.15405:15477]

B:BD[43.31332] → [47.15386:15404]

B:BD[43.31079] → [47.15313:15385]

B:BD[20.38965] → [22.13857:13875]

B:BD[22.13875] → [49.26799:26817]

B:BD[22.13854] → [22.13854:13856]

B:BD[43.31808] → [30.20405:20478]

B:BD[43.31587] → [30.20332:20404]

B:BD[43.31332] → [30.20313:20331]

B:BD[43.31227] → [30.20239:20312]

B:BD[43.31079] → [30.20166:20238]

B:BD[20.38965] → [20.38965:39193]

B:BD[20.39696] → [42.24571:24796]

B:BD[20.39293] → [42.24195:24423]

B:BD[20.39369] → [42.24424:24570]

B:BD[42.24177] → [42.24177:24194]

B:BD[20.39369] → [20.39369:39384]

B:BD[20.39293] → [20.39293:39369]

B:BD[20.39714] → [20.39714:39887]

B:BD[20.39696] → [20.39696:39714]

B:BD[20.39384] → [20.39384:39696]

B:BD[20.39696] → [54.17743:17761]

B:BD[20.39696] → [55.42245:42470]

B:BD[42.24177] → [55.41662:42244]

B:BD[20.39193] → [42.23986:24177]

B:BD[20.39193] → [20.39193:39293]

B:BD[20.38952] → [20.38952:38965]

B:BD[43.31587] → [52.11376:11448]

B:BD[43.31079] → [52.11303:11375]

B:BD[43.31587] → [38.19605:19677]

B:BD[43.31079] → [38.19532:19604]

B:BD[43.31587] → [39.6843:6915]

B:BD[43.31332] → [39.6824:6842]

B:BD[43.31079] → [39.6751:6823]

B:BD[43.30958] → [43.30958:31079]

B:BD[29.49403] → [29.49403:49475]

B:BD[29.49551] → [29.49551:49624]

B:BD[29.49656] → [29.49656:49674]

B:BD[29.49911] → [29.49911:49983]

B:BD[29.50132] → [29.50132:50205]

B:BD[29.50132] → [46.64744:64817]

B:BD[29.49983] → [29.49983:50132]

B:BD[29.49911] → [46.64671:64743]

B:BD[29.49674] → [29.49674:49911]

B:BD[29.49656] → [46.64652:64670]

B:BD[29.49624] → [29.49624:49656]

B:BD[29.49551] → [46.64578:64651]

B:BD[29.49475] → [29.49475:49551]

B:BD[29.49403] → [46.64505:64577]

B:BD[22.13778] → [43.30867:30943]

B:BD[22.13778] → [29.49191:49403]

B:BD[22.13778] → [22.13778:13854]

B:BD[22.13854] → [48.24339:24485]

B:BD[22.13778] → [48.24110:24338]

B:BD[22.13778] → [49.26722:26798]

B:BD[22.13742] → [48.23901:24109]

B:BD[20.38887] → [20.38887:38952]

B:BD[22.13631] → [43.30790:30866]

B:BD[22.13631] → [29.49114:49190]

B:BD[22.13631] → [22.13631:13707]

B:BD[22.13631] → [49.26645:26721]

B:BD[20.38869] → [43.30771:30789]

B:BD[20.38869] → [29.49095:49113]

B:BD[20.38869] → [49.26626:26644]

B:BD[20.38869] → [20.38869:38887]

B:BD[20.38759] → [43.30694:30770]

B:BD[20.38759] → [29.49018:49094]

B:BD[20.38759] → [49.26549:26625]

B:BD[20.38759] → [20.38759:38835]

B:BD[20.38659] → [43.30675:30693]

B:BD[20.38659] → [29.48999:49017]

B:BD[20.38659] → [49.26530:26548]

B:BD[20.38659] → [20.38659:38677]

B:BD[20.38625] → [20.38625:38640]

B:BD[20.38469] → [20.38469:38545]

B:BD[20.38387] → [20.38387:38469]

B:BD[20.38545] → [54.17662:17742]

B:BD[20.38469] → [55.41587:41661]

B:BD[20.38369] → [42.23892:23910]

B:BD[20.38369] → [20.38369:38387]

B:BD[20.38369] → [54.17643:17661]

B:BD[20.38369] → [55.41568:41586]

B:BD[22.13279] → [29.48848:48998]

B:BD[22.13279] → [22.13279:13355]

B:BD[20.38333] → [20.38333:38348]

B:BD[22.13355] → [22.13355:13435]

B:BD[22.13355] → [53.14323:14403]

B:BD[22.13279] → [48.23826:23900]

B:BD[22.13279] → [49.26373:26529]

B:BD[22.13179] → [29.48829:48847]

B:BD[22.13179] → [22.13179:13197]

B:BD[22.13197] → [22.13197:13279]

B:BD[20.38333] → [22.13143:13179]

B:BD[22.13179] → [48.23807:23825]

B:BD[43.30504] → [30.20092:20165]

B:BD[22.13179] → [49.26354:26372]

B:BD[22.13179] → [53.14304:14322]

B:BD[22.12982] → [43.30424:30504]

B:BD[22.12907] → [22.12907:12982]

B:BD[20.38260] → [20.38260:38333]

B:BD[22.12982] → [22.12982:13142]

B:BD[22.12982] → [48.23726:23806]

B:BD[22.12982] → [53.14143:14303]

B:BD[39.6750] → [52.11227:11302]

B:BD[39.6750] → [38.19456:19531]

B:BD[43.30349] → [92.6304:6378]

B:BD[43.30349] → [70.6316:6390]

B:BD[43.30349] → [43.30349:30423]

B:BD[43.30349] → [47.15163:15312]

B:BD[43.30349] → [30.19942:20091]

B:BD[43.30349] → [39.6676:6750]

B:BD[29.48526] → [29.48526:48600]

B:BD[29.48755] → [29.48755:48828]

B:BD[29.48755] → [46.64431:64504]

B:BD[29.48600] → [29.48600:48755]

B:BD[22.12907] → [29.48448:48526]

B:BD[29.48526] → [46.64356:64430]

B:BD[22.12907] → [48.23651:23725]

B:BD[22.12907] → [49.26045:26353]

B:BD[43.30044] → [92.6231:6303]

B:BD[22.12756] → [22.12756:12907]

B:BD[43.30044] → [70.6243:6315]

B:BD[43.30044] → [43.30044:30116]

B:BD[43.30044] → [47.15090:15162]

B:BD[43.30044] → [30.19869:19941]

B:BD[43.30044] → [52.11154:11226]

B:BD[43.30044] → [38.19383:19455]

B:BD[43.30044] → [39.6603:6675]

B:BD[22.12374] → [29.48147:48221]

B:BD[29.48293] → [29.48293:48447]

B:BD[29.48221] → [29.48221:48293]

B:BD[29.48221] → [46.64283:64355]

B:BD[22.12374] → [22.12374:12680]

B:BD[22.12680] → [22.12680:12756]

B:BD[22.12374] → [48.23426:23650]

B:BD[22.12374] → [49.25662:26044]

B:BD[22.12374] → [53.13836:14142]

B:BD[22.12274] → [29.48128:48146]

B:BD[22.12274] → [22.12274:12292]

B:BD[22.12292] → [22.12292:12374]

B:BD[22.12245] → [22.12245:12274]

B:BD[22.12274] → [48.23407:23425]

B:BD[22.12274] → [49.25643:25661]

B:BD[22.12274] → [53.13817:13835]

B:BD[24.12299] → [22.12172:12245]

B:BD[24.12151] → [24.12151:12223]

B:BD[24.12151] → [22.12099:12171]

B:BD[24.12151] → [48.23334:23406]

B:BD[24.12151] → [53.13744:13816]

B:BD[20.37648] → [40.14155:14227]

B:BD[20.38025] → [42.23736:23810]

B:BD[20.38100] → [42.23811:23891]

B:BD[20.38100] → [20.38100:38260]

B:BD[20.38100] → [54.17482:17642]

B:BD[20.38100] → [55.41487:41567]

B:BD[20.38025] → [20.38025:38100]

B:BD[20.38025] → [55.41412:41486]

B:BD[20.37648] → [41.9141:9213]

B:BD[20.37648] → [111.9182:9254]

B:BD[24.12070] → [43.29722:29802]

B:BD[43.29874] → [43.29874:29950]

B:BD[43.29950] → [30.19795:19868]

B:BD[43.29802] → [92.6158:6230]

B:BD[43.29802] → [70.6170:6242]

B:BD[43.29802] → [43.29802:29874]

B:BD[43.29802] → [47.15017:15089]

B:BD[43.29802] → [30.19722:19794]

B:BD[43.29802] → [52.11081:11153]

B:BD[43.29802] → [38.19310:19382]

B:BD[43.29802] → [39.6530:6602]

B:BD[29.47906] → [29.47906:47978]

B:BD[29.48054] → [29.48054:48127]

B:BD[29.48054] → [46.64209:64282]

B:BD[29.47978] → [29.47978:48054]

B:BD[24.12070] → [29.47826:47906]

B:BD[20.37648] → [44.5142:5214]

B:BD[29.47906] → [46.64136:64208]

B:BD[20.37648] → [33.12408:12480]

B:BD[24.12070] → [49.25340:25642]

B:BD[20.37648] → [50.6704:6776]

B:BD[20.37648] → [51.9551:9623]

B:BD[20.37798] → [20.37798:38025]

B:BD[20.37648] → [20.37648:37720]

B:BD[20.37720] → [20.37720:37798]

B:BD[20.37648] → [37.17539:17611]

B:BD[20.37492] → [24.11995:12070]

B:BD[20.37492] → [42.23511:23735]

B:BD[20.37492] → [20.37492:37648]

B:BD[20.37492] → [54.17175:17481]

B:BD[20.37492] → [55.41187:41411]

B:BD[20.37392] → [24.11976:11994]

B:BD[20.37392] → [42.23492:23510]

B:BD[20.37392] → [43.29703:29721]

B:BD[20.37392] → [49.25321:25339]

B:BD[20.37392] → [20.37392:37410]

B:BD[20.37392] → [54.17156:17174]

B:BD[20.37392] → [55.41168:41186]

B:BD[26.9041] → [26.9041:9311]

B:BD[26.9383] → [26.9383:10288]

B:BD[27.5795] → [27.5795:6065]

B:BD[15.37287] → [15.37287:37534]

B:BD[15.37612] → [137.6198:7120]

B:BD[15.37635] → [15.37635:37654]

B:BD[15.37855] → [15.37855:37936]

B:BD[15.37966] → [15.37966:37984]

B:BD[15.38066] → [15.38066:38297]

B:BD[15.38376] → [15.38376:38454]

B:BD[15.38491] → [15.38491:38509]

B:BD[15.38591] → [15.38591:38666]

B:BD[15.39206] → [15.39206:39224]

B:BD[15.39526] → [15.39526:39544]

B:BD[15.40132] → [15.40132:40210]

B:BD[15.40710] → [15.40710:40782]

B:BD[15.41104] → [15.41104:41176]

B:BD[15.41176] → [15.41176:41521]

B:BD[15.41104] → [137.7819:7891]

B:BD[15.41104] → [25.10600:10672]

B:BD[15.41104] → [16.7671:7743]

B:BD[15.41104] → [109.4452:4524]

B:BD[15.41104] → [26.11932:12004]

B:BD[15.41104] → [27.8592:8664]

B:BD[15.41104] → [138.1967:2039]

B:BD[15.40782] → [15.40782:41104]

B:BD[15.40710] → [137.7746:7818]

B:BD[15.40710] → [25.10527:10599]

B:BD[15.40710] → [16.7598:7670]

B:BD[15.40710] → [109.4379:4451]

B:BD[15.40710] → [26.11859:11931]

B:BD[15.40710] → [27.8519:8591]

B:BD[15.40710] → [138.1894:1966]

B:BD[15.40210] → [15.40210:40710]

B:BD[15.40132] → [137.7667:7745]

B:BD[15.40132] → [25.10448:10526]

B:BD[15.40132] → [16.7519:7597]

B:BD[15.40132] → [26.11780:11858]

B:BD[15.40132] → [27.8440:8518]

B:BD[15.39544] → [15.39544:40132]

B:BD[15.39526] → [137.7648:7666]

B:BD[15.39526] → [25.10429:10447]

B:BD[15.39526] → [16.7500:7518]

B:BD[15.39526] → [26.11761:11779]

B:BD[15.39526] → [27.8421:8439]

B:BD[15.39224] → [15.39224:39526]

B:BD[15.39206] → [109.4360:4378]

B:BD[15.39206] → [26.11741:11760]

B:BD[15.38666] → [15.38666:39206]

B:BD[15.38591] → [137.7572:7647]

B:BD[15.38591] → [25.10353:10428]

B:BD[15.38591] → [16.7424:7499]

B:BD[15.38591] → [26.11665:11740]

B:BD[15.38591] → [27.8345:8420]

B:BD[15.38509] → [15.38509:38591]

B:BD[15.38491] → [139.348:366]

B:BD[15.38491] → [137.7553:7571]

B:BD[15.38491] → [25.10334:10352]

B:BD[15.38491] → [16.7405:7423]

B:BD[15.38491] → [109.4341:4359]

B:BD[15.38491] → [26.11646:11664]

B:BD[15.38491] → [27.8326:8344]

B:BD[15.38454] → [15.38454:38491]

B:BD[15.38376] → [137.7474:7552]

B:BD[15.38376] → [25.10255:10333]

B:BD[15.38376] → [16.7326:7404]

B:BD[15.38376] → [26.11567:11645]

B:BD[15.38376] → [27.8247:8325]

B:BD[15.38297] → [15.38297:38376]

B:BD[15.38066] → [137.7242:7394]

B:BD[137.7394] → [139.268:347]

B:BD[137.7394] → [137.7394:7473]

B:BD[15.38066] → [25.10023:10254]

B:BD[15.38066] → [16.7094:7325]

B:BD[15.38066] → [26.11335:11414]

B:BD[26.11414] → [109.4188:4340]

B:BD[26.11414] → [26.11414:11566]

B:BD[15.38066] → [27.8015:8246]

B:BD[15.37984] → [15.37984:38066]

B:BD[15.37966] → [139.249:267]

B:BD[15.37966] → [137.7223:7241]

B:BD[15.37966] → [25.10004:10022]

B:BD[15.37966] → [16.7075:7093]

B:BD[15.37966] → [109.4169:4187]

B:BD[15.37966] → [26.11316:11334]

B:BD[15.37966] → [27.7996:8014]

B:BD[15.37936] → [15.37936:37966]

B:BD[15.37855] → [137.7141:7222]

B:BD[15.37855] → [25.9922:10003]

B:BD[15.37855] → [16.6993:7074]

B:BD[15.37855] → [109.4087:4168]

B:BD[15.37855] → [26.11234:11315]

B:BD[15.37855] → [27.7914:7995]

B:BD[15.37654] → [15.37654:37855]

B:BD[15.37635] → [137.7121:7140]

B:BD[15.37635] → [25.9902:9921]

B:BD[15.37635] → [16.6973:6992]

B:BD[15.37635] → [109.4067:4086]

B:BD[15.37635] → [26.11214:11233]

B:BD[15.37635] → [27.7894:7913]

B:BD[27.7006] → [27.7006:7071]

B:BD[27.7166] → [27.7166:7179]

B:BD[15.37612] → [15.37612:37635]

B:BD[27.7179] → [26.10999:11213]

B:BD[27.7179] → [27.7179:7893]

B:BD[27.7071] → [26.10823:10998]

B:BD[27.7071] → [27.7071:7166]

B:BD[15.37612] → [27.6971:7006]

B:BD[15.37534] → [15.37534:37612]

B:BD[15.37534] → [26.10289:10822]

B:BD[15.37287] → [137.5905:6197]

B:BD[15.37287] → [27.6678:6970]

B:BD[27.6137] → [27.6137:6677]

B:BD[27.6065] → [27.6065:6137]

B:BD[27.6065] → [138.1821:1893]

B:BD[27.5780] → [27.5780:5795]

B:BD[26.9311] → [109.3994:4066]

B:BD[26.9311] → [26.9311:9383]

B:BD[26.9029] → [26.9029:9041]

B:BD[15.37199] → [15.37199:37287]

B:BD[15.37199] → [137.4934:5904]

B:BD[15.37199] → [27.5707:5780]

B:BD[15.37051] → [15.37051:37123]

B:BD[15.37051] → [137.4861:4933]

B:BD[15.37051] → [25.9829:9901]

B:BD[15.37051] → [16.6900:6972]

B:BD[15.37051] → [109.3921:3993]

B:BD[15.37051] → [26.8953:9025]

B:BD[15.37051] → [27.5634:5706]

B:BD[15.37051] → [138.1748:1820]

B:BD[15.36621] → [15.36621:36693]

B:BD[15.36621] → [137.4788:4860]

B:BD[15.36621] → [25.9756:9828]

B:BD[15.36621] → [16.6827:6899]

B:BD[15.36621] → [109.3848:3920]

B:BD[15.36621] → [26.8880:8952]

B:BD[15.36621] → [27.5561:5633]

B:BD[15.36621] → [138.1675:1747]

B:BD[15.36332] → [15.36332:36411]

B:BD[15.36332] → [137.4708:4787]

B:BD[15.36332] → [25.9676:9755]

B:BD[15.36332] → [16.6747:6826]

B:BD[15.36332] → [26.8800:8879]

B:BD[15.36332] → [27.5481:5560]

B:BD[15.36232] → [15.36232:36250]

B:BD[15.36232] → [137.4688:4707]

B:BD[15.36232] → [25.9657:9675]

B:BD[15.36232] → [16.6728:6746]

B:BD[15.36232] → [26.8780:8799]

B:BD[15.36232] → [27.5461:5480]

B:BD[26.8706] → [109.3774:3847]

B:BD[26.8706] → [26.8706:8779]

B:BD[15.35947] → [15.35947:36090]

B:BD[15.35947] → [137.4544:4687]

B:BD[15.35947] → [25.9513:9656]

B:BD[15.35947] → [16.6584:6727]

B:BD[15.35947] → [26.8636:8706]

B:BD[15.35947] → [27.5317:5460]

B:BD[15.35794] → [15.35794:35873]

B:BD[15.35794] → [139.169:248]

B:BD[15.35794] → [137.4464:4543]

B:BD[15.35794] → [25.9433:9512]

B:BD[15.35794] → [16.6504:6583]

B:BD[15.35794] → [109.3694:3773]

B:BD[15.35794] → [26.8556:8635]

B:BD[15.35794] → [27.5237:5316]

B:BD[15.35363] → [15.35363:35382]

B:BD[15.35363] → [137.4444:4463]

B:BD[15.35363] → [25.9413:9432]

B:BD[15.35363] → [16.6484:6503]

B:BD[15.35363] → [26.8536:8555]

B:BD[15.35363] → [27.5217:5236]

B:BD[15.33815] → [15.33815:33890]

B:BD[15.33815] → [139.93:168]

B:BD[15.33815] → [137.4368:4443]

B:BD[15.33815] → [25.9337:9412]

B:BD[15.33815] → [16.6408:6483]

B:BD[15.33815] → [109.3618:3693]

B:BD[15.33815] → [26.8460:8535]

B:BD[15.33815] → [27.5141:5216]

B:BD[15.33592] → [15.33592:33664]

B:BD[15.33592] → [137.4295:4367]

B:BD[15.33592] → [25.9264:9336]

B:BD[15.33592] → [16.6335:6407]

B:BD[15.33592] → [109.3545:3617]

B:BD[15.33592] → [26.8387:8459]

B:BD[15.33592] → [27.5068:5140]

B:BD[15.33592] → [138.1602:1674]

B:BD[15.33293] → [15.33293:33368]

B:BD[15.33293] → [137.4219:4294]

B:BD[15.33293] → [25.9188:9263]

B:BD[15.33293] → [16.6259:6334]

B:BD[15.33293] → [26.8311:8386]

B:BD[15.33293] → [27.4992:5067]

B:BD[15.32972] → [15.32972:32990]

B:BD[15.32972] → [137.4200:4218]

B:BD[15.32972] → [25.9169:9187]

B:BD[15.32972] → [16.6240:6258]

B:BD[15.32972] → [26.8292:8310]

B:BD[15.32972] → [27.4973:4991]

B:BD[15.32715] → [15.32715:32787]

B:BD[15.32715] → [137.4127:4199]

B:BD[15.32715] → [25.9096:9168]

B:BD[15.32715] → [16.6167:6239]

B:BD[15.32715] → [27.4900:4972]

B:BD[15.32715] → [138.1529:1601]

B:BD[15.32645] → [15.32645:32715]

B:BD[15.32645] → [109.3402:3544]

B:BD[15.32645] → [26.8149:8291]

B:BD[26.8076] → [109.3329:3401]

B:BD[26.8076] → [26.8076:8148]

B:BD[27.4827] → [27.4827:4899]

B:BD[27.4827] → [138.1456:1528]

B:BD[15.32160] → [15.32160:32310]

B:BD[15.32160] → [137.3976:4126]

B:BD[15.32160] → [25.8945:9095]

B:BD[15.32160] → [16.6016:6166]

B:BD[15.32160] → [26.7998:8076]

B:BD[15.32160] → [27.4749:4827]

B:BD[15.31726] → [15.31726:31798]

B:BD[15.31726] → [137.3903:3975]

B:BD[15.31726] → [25.8872:8944]

B:BD[15.31726] → [16.5943:6015]

B:BD[15.31726] → [109.3256:3328]

B:BD[15.31726] → [26.7925:7997]

B:BD[15.31726] → [27.4676:4748]

B:BD[15.31726] → [138.1383:1455]

B:BD[15.31626] → [15.31626:31644]

B:BD[15.31626] → [109.3237:3255]

B:BD[15.31626] → [26.7906:7924]

B:BD[9.5081] → [9.5081:10800]

B:BD[9.30186] → [12.3904:4335]

B:BD[9.22421] → [12.3538:3903]

B:BD[9.32425] → [9.32425:35265]

B:BD[9.32410] → [9.32410:32425]

B:BD[9.30186] → [9.30186:32410]

B:BD[10.12214] → [9.26878:30186]

B:BD[9.22421] → [9.22421:26877]

B:BD[9.15456] → [9.15456:22421]

B:BD[9.32425] → [19.1716:1928]

B:BD[9.32410] → [19.1197:1715]

B:BD[9.15456] → [19.984:1196]

B:BD[9.10800] → [9.10800:15456]

B:BD[9.10800] → [19.481:983]

B:BD[15.31192] → [15.31192:31211]

B:BD[9.5069] → [9.5069:5081]

B:BD[15.31192] → [137.3883:3902]

B:BD[15.31192] → [25.8852:8871]

B:BD[15.31192] → [16.5923:5942]

B:BD[15.31192] → [26.7886:7905]

B:BD[15.31192] → [27.4656:4675]

B:BD[15.30792] → [15.30792:30864]

B:BD[15.30792] → [137.3810:3882]

B:BD[15.30792] → [25.8779:8851]

B:BD[15.30792] → [16.5850:5922]

B:BD[15.30792] → [109.3164:3236]

B:BD[15.30792] → [26.7813:7885]

B:BD[15.30792] → [27.4583:4655]

B:BD[15.30792] → [138.1310:1382]

B:BD[15.30514] → [15.30514:30589]

B:BD[15.30514] → [137.3734:3809]

B:BD[15.30514] → [25.8703:8778]

B:BD[15.30514] → [16.5774:5849]

B:BD[15.30514] → [26.7737:7812]

B:BD[15.30514] → [27.4507:4582]

B:BD[26.7594] → [109.3091:3163]

B:BD[26.7594] → [26.7594:7666]

B:BD[26.7666] → [26.7666:7736]

B:BD[27.4364] → [27.4364:4436]

B:BD[27.4436] → [27.4436:4506]

B:BD[27.4364] → [138.1237:1309]

B:BD[15.29809] → [15.29809:30029]

B:BD[15.29809] → [137.3513:3733]

B:BD[15.29809] → [25.8482:8702]

B:BD[15.29809] → [16.5553:5773]

B:BD[15.29809] → [26.7516:7594]

B:BD[15.29809] → [27.4286:4364]

B:BD[15.29101] → [15.29101:29173]

B:BD[15.29101] → [137.3440:3512]

B:BD[15.29101] → [25.8409:8481]

B:BD[15.29101] → [16.5480:5552]

B:BD[15.29101] → [109.3018:3090]

B:BD[15.29101] → [26.7443:7515]

B:BD[15.29101] → [27.4213:4285]

B:BD[15.29101] → [138.1164:1236]

B:BD[27.4142] → [27.4142:4212]

B:BD[15.28468] → [15.28468:28610]

B:BD[15.28468] → [137.3297:3439]

B:BD[15.28468] → [16.5337:5479]

B:BD[15.28468] → [27.4070:4142]

B:BD[15.28393] → [25.8191:8408]

B:BD[15.28393] → [28.1092:1167]

B:BD[28.1167] → [138.1091:1163]

B:BD[15.28393] → [26.7225:7300]

B:BD[26.7372] → [26.7372:7442]

B:BD[26.7300] → [109.2945:3017]

B:BD[26.7300] → [26.7300:7372]

B:BD[15.27388] → [15.27388:28393]

B:BD[15.27316] → [137.3224:3296]

B:BD[15.27316] → [25.8118:8190]

B:BD[15.27316] → [16.5264:5336]

B:BD[15.27316] → [109.2872:2944]

B:BD[15.27316] → [26.7152:7224]

B:BD[15.27316] → [27.3997:4069]

B:BD[15.27316] → [138.1018:1090]

B:BD[15.27161] → [15.27161:27316]

B:BD[15.27143] → [137.3205:3223]

B:BD[15.27143] → [25.8099:8117]

B:BD[15.27143] → [16.5245:5263]

B:BD[15.27143] → [109.2853:2871]

B:BD[15.27143] → [26.7133:7151]

B:BD[15.27143] → [27.3978:3996]

B:BD[15.26999] → [15.26999:27143]

B:BD[15.26759] → [15.26759:26925]

B:BD[15.26925] → [25.8024:8098]

B:BD[15.26925] → [109.2778:2852]

B:BD[15.26925] → [26.7058:7132]

B:BD[15.26925] → [138.943:1017]

B:BD[15.26681] → [15.26681:26759]

B:BD[15.26681] → [137.3126:3204]

B:BD[15.26681] → [16.5166:5244]

B:BD[15.26681] → [27.3899:3977]

B:BD[15.26528] → [25.7792:8023]

B:BD[15.26528] → [109.2624:2777]

B:BD[15.26528] → [26.6826:6979]

B:BD[26.6979] → [26.6979:7057]

B:BD[15.26528] → [138.789:942]

B:BD[15.26296] → [15.26296:26528]

B:BD[15.26278] → [109.2605:2623]

B:BD[15.26278] → [26.6807:6825]

B:BD[15.25762] → [15.25762:26278]

B:BD[15.25744] → [137.3107:3125]

B:BD[15.25744] → [16.4949:5119]

B:BD[16.5147] → [25.7773:7791]

B:BD[16.5147] → [16.5147:5165]

B:BD[16.5147] → [27.3880:3898]

B:BD[16.5119] → [16.5119:5147]

B:BD[15.25716] → [15.25716:25744]

B:BD[15.25518] → [25.7574:7602]

B:BD[25.7602] → [25.7602:7772]

B:BD[25.7602] → [26.6788:6806]

B:BD[15.25441] → [15.25441:25518]

B:BD[15.25364] → [137.3029:3106]

B:BD[15.25364] → [25.7496:7573]

B:BD[15.25364] → [16.4871:4948]

B:BD[15.25364] → [26.6710:6787]

B:BD[15.25364] → [27.3802:3879]

B:BD[15.25282] → [15.25282:25364]

B:BD[15.25264] → [137.3010:3028]

B:BD[15.25264] → [25.7477:7495]

B:BD[15.25264] → [16.4852:4870]

B:BD[15.25264] → [26.6691:6709]

B:BD[15.25264] → [27.3783:3801]

B:BD[15.25047] → [15.25047:25264]

B:BD[15.25028] → [137.2990:3009]

B:BD[15.25028] → [25.7457:7476]

B:BD[15.25028] → [16.4832:4851]

B:BD[15.25028] → [109.2585:2604]

B:BD[15.25028] → [26.6671:6690]

B:BD[15.25028] → [27.3763:3782]

B:BD[15.25028] → [138.769:788]

B:BD[15.24936] → [15.24936:25028]

B:BD[15.24918] → [25.7438:7456]

B:BD[15.24918] → [28.1073:1091]

B:BD[15.24918] → [26.6652:6670]

B:BD[15.24887] → [15.24887:24918]

B:BD[15.24788] → [25.7338:7437]

B:BD[15.24788] → [16.4732:4831]

B:BD[15.24723] → [15.24723:24788]

B:BD[15.24705] → [137.2971:2989]

B:BD[15.24705] → [25.7319:7337]

B:BD[15.24705] → [16.4713:4731]

B:BD[15.24705] → [26.6633:6651]

B:BD[15.24705] → [27.3744:3762]

B:BD[15.23344] → [15.23344:24705]

B:BD[15.23326] → [137.2952:2970]

B:BD[15.23326] → [25.7300:7318]

B:BD[15.23326] → [16.4694:4712]

B:BD[15.23326] → [26.6614:6632]

B:BD[15.23326] → [27.3725:3743]

B:BD[15.23220] → [15.23220:23326]

B:BD[15.23148] → [137.2879:2951]

B:BD[15.23148] → [25.7227:7299]

B:BD[15.23148] → [16.4621:4693]

B:BD[15.23148] → [109.2512:2584]

B:BD[15.23148] → [26.6541:6613]

B:BD[15.23148] → [27.3652:3724]

B:BD[15.23148] → [138.696:768]

B:BD[15.22463] → [15.22463:23148]

B:BD[15.22302] → [137.2717:2878]

B:BD[15.22302] → [25.7065:7226]

B:BD[15.22302] → [16.4459:4620]

B:BD[15.22302] → [26.6379:6540]

B:BD[15.22302] → [27.3490:3651]

B:BD[15.22226] → [15.22226:22302]

B:BD[15.22146] → [137.2636:2716]

B:BD[15.22146] → [25.6984:7064]

B:BD[15.22146] → [16.4378:4458]

B:BD[15.22146] → [26.6298:6378]

B:BD[15.22146] → [27.3409:3489]

B:BD[15.21989] → [15.21989:22146]

B:BD[15.21916] → [137.2562:2635]

B:BD[15.21916] → [25.6910:6983]

B:BD[15.21916] → [16.4304:4377]

B:BD[26.6224] → [26.6224:6297]

B:BD[15.21916] → [27.3335:3408]

B:BD[15.21844] → [15.21844:21916]

B:BD[15.21844] → [109.2439:2511]

B:BD[15.21844] → [26.6152:6224]

B:BD[15.21702] → [15.21702:21772]

B:BD[15.21702] → [137.2491:2561]

B:BD[15.21702] → [25.6839:6909]

B:BD[15.21702] → [16.4233:4303]

B:BD[15.21702] → [26.6081:6151]

B:BD[15.21702] → [27.3264:3334]

B:BD[15.21412] → [15.21412:21484]

B:BD[15.21412] → [137.2418:2490]

B:BD[15.21412] → [16.4160:4232]

B:BD[15.21412] → [27.3191:3263]

B:BD[15.21342] → [15.21342:21412]

B:BD[15.21342] → [25.6696:6838]

B:BD[15.21342] → [28.1002:1072]

B:BD[15.21342] → [26.5938:6080]

B:BD[15.21112] → [15.21112:21185]

B:BD[15.21112] → [137.2344:2417]

B:BD[15.21112] → [25.6622:6695]

B:BD[15.21112] → [16.4086:4159]

B:BD[15.21112] → [26.5864:5937]

B:BD[15.21112] → [27.3117:3190]

B:BD[15.21010] → [15.21010:21030]

B:BD[15.21010] → [137.2323:2343]

B:BD[15.21010] → [25.6601:6621]

B:BD[15.21010] → [28.981:1001]

B:BD[15.21010] → [16.4065:4085]

B:BD[15.21010] → [109.2418:2438]

B:BD[15.21010] → [26.5843:5863]

B:BD[15.21010] → [27.3096:3116]

B:BD[15.20802] → [15.20802:20820]

B:BD[15.20802] → [137.2304:2322]

B:BD[15.20802] → [25.6582:6600]

B:BD[15.20802] → [16.4046:4064]

B:BD[15.20802] → [26.5824:5842]

B:BD[15.20802] → [27.3077:3095]

B:BD[15.20440] → [15.20440:20513]

B:BD[15.20440] → [137.2230:2303]

B:BD[15.20440] → [25.6508:6581]

B:BD[15.20440] → [16.3972:4045]

B:BD[15.20440] → [26.5750:5823]

B:BD[15.20440] → [27.3003:3076]

B:BD[15.20339] → [15.20339:20358]

B:BD[15.20339] → [137.2210:2229]

B:BD[15.20339] → [25.6488:6507]

B:BD[15.20339] → [16.3952:3971]

B:BD[15.20339] → [26.5730:5749]

B:BD[15.20339] → [27.2983:3002]

B:BD[15.20164] → [15.20164:20236]

B:BD[15.20164] → [137.2137:2209]

B:BD[15.20164] → [25.6415:6487]

B:BD[15.20164] → [16.3879:3951]

B:BD[15.20164] → [109.2345:2417]

B:BD[15.20164] → [26.5657:5729]

B:BD[15.20164] → [27.2910:2982]

B:BD[15.20164] → [138.623:695]

B:BD[15.19882] → [15.19882:19955]

B:BD[15.19882] → [137.2063:2136]

B:BD[15.19882] → [25.6341:6414]

B:BD[15.19882] → [16.3805:3878]

B:BD[15.19882] → [26.5583:5656]

B:BD[15.19882] → [27.2836:2909]

B:BD[15.19741] → [15.19741:19811]

B:BD[15.19741] → [137.1992:2062]

B:BD[15.19741] → [25.6270:6340]

B:BD[15.19741] → [16.3734:3804]

B:BD[15.19741] → [26.5512:5582]

B:BD[15.19741] → [27.2765:2835]

B:BD[15.19594] → [15.19594:19666]

B:BD[15.19594] → [137.1919:1991]

B:BD[15.19594] → [25.6197:6269]

B:BD[15.19594] → [16.3661:3733]

B:BD[15.19594] → [26.5439:5511]

B:BD[15.19594] → [27.2692:2764]

B:BD[15.19376] → [15.19376:19449]

B:BD[15.19376] → [137.1845:1918]

B:BD[15.19376] → [25.6123:6196]

B:BD[15.19376] → [16.3587:3660]

B:BD[15.19376] → [26.5365:5438]

B:BD[15.19376] → [27.2618:2691]

B:BD[15.19199] → [15.19199:19218]

B:BD[15.19199] → [25.6103:6122]

B:BD[15.19199] → [28.961:980]

B:BD[15.19199] → [26.5345:5364]

B:BD[15.18884] → [15.18884:18959]

B:BD[15.18884] → [109.2269:2344]

B:BD[15.18884] → [26.5269:5344]

B:BD[26.5116] → [109.2196:2268]

B:BD[26.5116] → [26.5116:5188]

B:BD[26.5188] → [26.5188:5268]

B:BD[15.16967] → [15.16967:17270]

B:BD[15.16967] → [137.1540:1844]

B:BD[15.16967] → [25.5799:6102]

B:BD[15.16967] → [16.3283:3586]

B:BD[15.16967] → [26.4964:5116]

B:BD[15.16967] → [27.2313:2617]

B:BD[15.16671] → [15.16671:16747]

B:BD[15.16671] → [109.2119:2195]

B:BD[15.16671] → [26.4886:4963]

B:BD[15.16463] → [15.16463:16539]

B:BD[15.16463] → [109.2042:2118]

B:BD[15.16463] → [26.4808:4885]

B:BD[137.1467] → [139.20:92]

B:BD[137.1467] → [137.1467:1539]

B:BD[26.4735] → [109.1969:2041]

B:BD[26.4735] → [26.4735:4807]

B:BD[15.15820] → [15.15820:16038]

B:BD[15.15820] → [137.1321:1467]

B:BD[15.15820] → [25.5580:5798]

B:BD[15.15820] → [16.3064:3282]

B:BD[15.15820] → [26.4589:4735]

B:BD[15.15820] → [27.2094:2312]

B:BD[15.15647] → [15.15647:15666]

B:BD[15.15647] → [137.1302:1320]

B:BD[15.15647] → [25.5560:5579]

B:BD[15.15647] → [16.3044:3063]

B:BD[15.15647] → [26.4570:4588]

B:BD[15.15647] → [27.2075:2093]

B:BD[15.15438] → [15.15438:15457]

B:BD[15.15438] → [139.0:19]

B:BD[15.15438] → [137.1282:1301]

B:BD[15.15438] → [25.5540:5559]

B:BD[15.15438] → [16.3024:3043]

B:BD[15.15438] → [109.1949:1968]

B:BD[15.15438] → [26.4550:4569]

B:BD[15.15438] → [27.2055:2074]

B:BD[15.14254] → [137.1189:1281]

B:BD[15.14254] → [26.4457:4549]

B:BD[15.14254] → [27.1962:2054]

B:BD[15.14171] → [15.14171:14189]

B:BD[15.14171] → [137.1170:1188]

B:BD[15.14171] → [25.5521:5539]

B:BD[15.14171] → [16.3005:3023]

B:BD[15.14171] → [109.1930:1948]

B:BD[15.14171] → [26.4438:4456]

B:BD[15.14171] → [27.1943:1961]

B:BD[15.14171] → [138.604:622]

B:BD[26.4359] → [26.4359:4437]

B:BD[27.1864] → [27.1864:1942]

B:BD[15.13818] → [15.13818:13978]

B:BD[15.13818] → [137.1009:1169]

B:BD[15.13818] → [25.5360:5520]

B:BD[15.13818] → [16.2844:3004]

B:BD[15.13818] → [109.1847:1929]

B:BD[15.13818] → [26.4277:4359]

B:BD[15.13818] → [27.1782:1864]

B:BD[15.13818] → [138.521:603]

B:BD[15.13670] → [15.13670:13745]

B:BD[15.13670] → [137.933:1008]

B:BD[15.13670] → [25.5284:5359]

B:BD[15.13670] → [16.2768:2843]

B:BD[15.13670] → [26.4201:4276]

B:BD[15.13670] → [27.1706:1781]

B:BD[15.13570] → [15.13570:13588]

B:BD[15.13570] → [137.914:932]

B:BD[15.13570] → [25.5265:5283]

B:BD[15.13570] → [16.2749:2767]

B:BD[15.13570] → [26.4182:4200]

B:BD[15.13570] → [27.1687:1705]

B:BD[26.4099] → [109.1764:1846]

B:BD[26.4099] → [26.4099:4181]

B:BD[27.1604] → [27.1604:1686]

B:BD[27.1604] → [138.438:520]

B:BD[15.13366] → [15.13366:13530]

B:BD[15.13366] → [137.749:913]

B:BD[15.13366] → [25.5100:5264]

B:BD[15.13366] → [16.2584:2748]

B:BD[15.13366] → [26.4017:4099]

B:BD[15.13366] → [27.1522:1604]

B:BD[15.13266] → [15.13266:13284]

B:BD[15.13266] → [137.730:748]

B:BD[15.13266] → [25.5081:5099]

B:BD[15.13266] → [16.2565:2583]

B:BD[15.13266] → [26.3998:4016]

B:BD[15.13266] → [27.1503:1521]

B:BD[15.13154] → [15.13154:13226]

B:BD[15.13154] → [137.657:729]

B:BD[15.13154] → [25.5008:5080]

B:BD[15.13154] → [16.2492:2564]

B:BD[15.13154] → [109.1691:1763]

B:BD[15.13154] → [26.3925:3997]

B:BD[15.13154] → [27.1430:1502]

B:BD[15.13154] → [138.365:437]

B:BD[15.12938] → [15.12938:13010]

B:BD[15.12938] → [137.584:656]

B:BD[15.12938] → [25.4935:5007]

B:BD[15.12938] → [16.2419:2491]

B:BD[15.12938] → [109.1618:1690]

B:BD[15.12938] → [26.3852:3924]

B:BD[15.12938] → [27.1357:1429]

B:BD[15.12938] → [138.292:364]

B:BD[15.11653] → [15.11653:11725]

B:BD[15.11653] → [109.1545:1617]

B:BD[15.11653] → [26.3779:3851]

B:BD[15.11172] → [15.11172:11191]

B:BD[15.11172] → [109.1525:1544]

B:BD[15.11172] → [26.3759:3778]

B:BD[15.10786] → [15.10786:10805]

B:BD[15.10786] → [137.564:583]

B:BD[15.10786] → [25.4915:4934]

B:BD[15.10786] → [16.2399:2418]

B:BD[15.10786] → [26.3739:3758]

B:BD[15.10786] → [27.1337:1356]

B:BD[15.9411] → [15.9411:9483]

B:BD[15.9411] → [137.491:563]

B:BD[15.9411] → [25.4842:4914]

B:BD[15.9411] → [16.2326:2398]

B:BD[15.9411] → [27.1264:1336]

B:BD[15.9411] → [138.219:291]

B:BD[15.9341] → [15.9341:9411]

B:BD[15.9341] → [109.1382:1524]

B:BD[15.9341] → [26.3596:3738]

B:BD[15.9240] → [15.9240:9259]

B:BD[15.9240] → [109.1362:1381]

B:BD[15.9240] → [26.3576:3595]

B:BD[15.9048] → [15.9048:9129]

B:BD[15.8976] → [15.8976:9048]

B:BD[15.8976] → [137.418:490]

B:BD[15.8976] → [25.4769:4841]

B:BD[15.8976] → [16.2253:2325]

B:BD[15.8976] → [109.1208:1361]

B:BD[15.8976] → [26.3421:3575]

B:BD[15.8976] → [27.1191:1263]

B:BD[15.8976] → [138.146:218]

B:BD[15.8822] → [15.8822:8903]

B:BD[15.8822] → [109.1126:1207]

B:BD[15.8822] → [26.3265:3420]

B:BD[15.8722] → [15.8722:8740]

B:BD[15.8722] → [109.1107:1125]

B:BD[15.8722] → [26.3245:3264]

B:BD[15.8534] → [15.8534:8615]

B:BD[15.8462] → [15.8462:8534]

B:BD[15.8462] → [137.345:417]

B:BD[15.8462] → [25.4696:4768]

B:BD[15.8462] → [16.2180:2252]

B:BD[15.8462] → [109.953:1106]

B:BD[15.8462] → [26.3090:3244]

B:BD[15.8462] → [27.1118:1190]

B:BD[15.8462] → [138.73:145]

B:BD[15.8151] → [15.8151:8232]

B:BD[15.8151] → [109.871:952]

B:BD[15.8151] → [26.3008:3089]

B:BD[15.8019] → [15.8019:8032]

B:BD[26.2907] → [26.2907:3007]

B:BD[15.7870] → [15.7870:8019]

B:BD[15.7798] → [137.272:344]

B:BD[15.7798] → [25.4623:4695]

B:BD[15.7798] → [16.2107:2179]

B:BD[15.7798] → [109.798:870]

B:BD[15.7798] → [26.2821:2893]

B:BD[15.7798] → [27.1045:1117]

B:BD[15.7798] → [138.0:72]

B:BD[15.7668] → [15.7668:7798]

B:BD[15.7594] → [137.197:271]

B:BD[15.7594] → [25.4548:4622]

B:BD[15.7594] → [16.2032:2106]

B:BD[15.7594] → [26.2746:2820]

B:BD[15.7594] → [27.970:1044]

B:BD[15.7512] → [15.7512:7594]

B:BD[15.7494] → [137.178:196]

B:BD[15.7494] → [25.4529:4547]

B:BD[15.7494] → [16.2013:2031]

B:BD[15.7494] → [26.2727:2745]

B:BD[15.7494] → [27.951:969]

B:BD[15.7284] → [15.7284:7494]

B:BD[15.7266] → [137.159:177]

B:BD[15.7266] → [25.4510:4528]

B:BD[15.7266] → [16.1994:2012]

B:BD[15.7266] → [26.2708:2726]

B:BD[15.7266] → [27.932:950]

B:BD[15.7025] → [15.7025:7266]

B:BD[15.6952] → [137.85:158]

B:BD[15.6952] → [25.4436:4509]

B:BD[15.6952] → [16.1920:1993]

B:BD[15.6952] → [109.724:797]

B:BD[15.6952] → [26.2634:2707]

B:BD[15.6952] → [27.858:931]

B:BD[15.6870] → [15.6870:6952]

B:BD[15.6852] → [137.66:84]

B:BD[58.54799] → [58.54799:54933]

B:BD[58.55005] → [58.55005:55008]

B:BD[17.53213] → [17.53213:53235]

∅:BD[60.47825] → [17.53253:53318]

∅:BD[77.37375] → [17.53253:53318]

∅:BD[21.36891] → [17.53253:53318]

∅:BD[62.69720] → [17.53253:53318]

∅:BD[58.55027] → [17.53253:53318]

∅:BD[63.48680] → [17.53253:53318]

∅:BD[59.46680] → [17.53253:53318]

B:BD[17.53253] → [17.53253:53318]

B:BD[17.53318] → [2.4243:4321]

∅:BD[2.4321] → [17.53318:53335]

B:BD[17.53318] → [17.53318:53335]

∅:BD[2.4333] → [17.53408:53526]

∅:BD[60.47899] → [17.53408:53526]

∅:BD[21.36965] → [17.53408:53526]

∅:BD[62.69794] → [17.53408:53526]

∅:BD[58.55101] → [17.53408:53526]

∅:BD[59.46754] → [17.53408:53526]

B:BD[17.53408] → [17.53408:53526]

B:BD[17.53526] → [2.4334:4412]

∅:BD[2.4412] → [17.53526:53543]

B:BD[17.53526] → [17.53526:53543]

∅:BD[2.4430] → [17.53616:53649]

∅:BD[60.47973] → [17.53616:53649]

∅:BD[77.37449] → [17.53616:53649]

∅:BD[21.37039] → [17.53616:53649]

∅:BD[62.69868] → [17.53616:53649]

∅:BD[58.55175] → [17.53616:53649]

∅:BD[63.48754] → [17.53616:53649]

∅:BD[59.46828] → [17.53616:53649]

B:BD[17.53616] → [17.53616:53649]

∅:BD[60.47993] → [59.46847:46912]

∅:BD[77.37469] → [59.46847:46912]

∅:BD[21.37058] → [59.46847:46912]

∅:BD[62.69887] → [59.46847:46912]

∅:BD[58.55195] → [59.46847:46912]

∅:BD[64.31255] → [59.46847:46912]

∅:BD[63.48773] → [59.46847:46912]

∅:BD[102.43925] → [59.46847:46912]

B:BD[59.46847] → [59.46847:46912]

∅:BD[2.4509] → [59.46912:46925]

B:BD[59.46912] → [59.46912:46925]

B:BD[17.53746] → [17.53746:53764]

∅:BD[2.4529] → [17.53783:53848]

∅:BD[21.37099] → [17.53783:53848]

∅:BD[58.55215] → [17.53783:53848]

∅:BD[59.46980] → [17.53783:53848]

B:BD[17.53783] → [17.53783:53848]

B:BD[17.53848] → [2.4530:4608]

∅:BD[2.4608] → [17.53848:53865]

B:BD[17.53848] → [17.53848:53865]

∅:BD[2.4643] → [17.53939:53968]

∅:BD[21.37322] → [17.53939:53968]

∅:BD[58.55290] → [17.53939:53968]

∅:BD[59.47055] → [17.53939:53968]

B:BD[17.53939] → [17.53939:53968]

∅:BD[21.37342] → [17.53987:54052]

B:BD[17.53987] → [17.53987:54052]

B:BD[17.54052] → [2.4644:4722]

∅:BD[2.4722] → [17.54052:54069]

B:BD[17.54052] → [17.54052:54069]

B:BD[77.37616] → [77.37616:37689]

B:BD[17.54215] → [60.48067:48140]

∅:BD[2.4764] → [17.54288:54303]

∅:BD[60.48140] → [17.54288:54303]

∅:BD[77.37689] → [17.54288:54303]

∅:BD[21.37566] → [17.54288:54303]

∅:BD[62.70034] → [17.54288:54303]

∅:BD[58.55437] → [17.54288:54303]

∅:BD[63.48993] → [17.54288:54303]

∅:BD[59.47202] → [17.54288:54303]

B:BD[17.54288] → [17.54288:54303]

∅:BD[77.37708] → [17.54338:54403]

∅:BD[21.37585] → [17.54338:54403]

∅:BD[58.55473] → [17.54338:54403]

∅:BD[64.31421] → [17.54338:54403]

∅:BD[59.47240] → [17.54338:54403]

B:BD[17.54338] → [17.54338:54403]

B:BD[17.54403] → [59.47241:47797]

B:BD[17.54403] → [2.4765:4843]

∅:BD[2.4843] → [17.54403:54435]

∅:BD[59.47797] → [17.54403:54435]

B:BD[17.54403] → [17.54403:54435]

∅:BD[2.4863] → [17.54454:54519]

∅:BD[60.48160] → [17.54454:54519]

∅:BD[77.37728] → [17.54454:54519]

∅:BD[21.37605] → [17.54454:54519]

∅:BD[62.70054] → [17.54454:54519]

∅:BD[58.55493] → [17.54454:54519]

∅:BD[64.31441] → [17.54454:54519]

∅:BD[63.49013] → [17.54454:54519]

∅:BD[59.47816] → [17.54454:54519]

B:BD[17.54454] → [17.54454:54519]

B:BD[17.54519] → [2.4864:4942]

∅:BD[2.4942] → [17.54519:54536]

B:BD[17.54519] → [17.54519:54536]

B:BD[58.55568] → [58.55568:55649]

B:BD[60.48234] → [102.44073:44145]

B:BD[60.48234] → [60.48234:48306]

B:BD[60.48306] → [60.48306:48461]

B:BD[58.55649] → [63.49014:49314]

B:BD[58.55649] → [64.31517:31817]

B:BD[58.55649] → [58.55649:55949]

B:BD[58.55649] → [62.70055:70355]

B:BD[58.55649] → [77.37804:38031]

B:BD[58.55649] → [60.48161:48234]

∅:BD[2.5023] → [17.54991:55006]

∅:BD[60.48461] → [17.54991:55006]

∅:BD[77.38031] → [17.54991:55006]

∅:BD[21.38063] → [17.54991:55006]

∅:BD[62.70355] → [17.54991:55006]

∅:BD[58.55949] → [17.54991:55006]

∅:BD[64.31817] → [17.54991:55006]

∅:BD[63.49314] → [17.54991:55006]

∅:BD[59.48197] → [17.54991:55006]

B:BD[17.54991] → [17.54991:55006]

B:BD[17.55029] → [59.48198:48217]

∅:BD[21.38099] → [17.55048:55113]

∅:BD[58.55969] → [17.55048:55113]

∅:BD[59.48217] → [17.55048:55113]

B:BD[17.55048] → [17.55048:55113]

B:BD[17.55113] → [2.5024:5102]

∅:BD[2.5102] → [17.55113:55130]

B:BD[17.55113] → [17.55113:55130]

B:BD[60.48532] → [102.44146:44218]

B:BD[60.48532] → [60.48532:48604]

∅:BD[2.5117] → [17.55272:55303]

∅:BD[60.48604] → [17.55272:55303]

∅:BD[77.38174] → [17.55272:55303]

∅:BD[21.38176] → [17.55272:55303]

∅:BD[62.70498] → [17.55272:55303]

∅:BD[58.56112] → [17.55272:55303]

∅:BD[64.31960] → [17.55272:55303]

∅:BD[63.49457] → [17.55272:55303]

∅:BD[102.44218] → [17.55272:55303]

∅:BD[59.48360] → [17.55272:55303]

B:BD[17.55272] → [17.55272:55303]

∅:BD[21.38196] → [17.55322:55387]

∅:BD[58.56132] → [17.55322:55387]

∅:BD[59.48379] → [17.55322:55387]

B:BD[17.55322] → [17.55322:55387]

B:BD[17.55404] → [59.48380:48530]

B:BD[17.55404] → [64.31961:32037]

B:BD[17.55404] → [58.56133:56209]

B:BD[17.55404] → [77.38175:38251]

∅:BD[2.5196] → [17.55482:55513]

B:BD[17.55482] → [17.55482:55513]

∅:BD[77.38270] → [17.55531:55596]

∅:BD[21.38215] → [17.55531:55596]

∅:BD[64.32056] → [17.55531:55596]

B:BD[17.55531] → [17.55531:55596]

B:BD[17.55596] → [2.5197:5275]

∅:BD[2.5275] → [17.55596:55625]

B:BD[17.55596] → [17.55596:55625]

∅:BD[2.5294] → [17.55643:55708]

∅:BD[21.38234] → [17.55643:55708]

∅:BD[58.56228] → [17.55643:55708]

∅:BD[59.48549] → [17.55643:55708]

B:BD[17.55643] → [17.55643:55708]

B:BD[17.55708] → [2.5295:5373]

∅:BD[2.5373] → [17.55708:55725]

B:BD[17.55708] → [17.55708:55725]

B:BD[58.56383] → [58.56383:56535]

B:BD[58.56383] → [21.38235:38387]

∅:BD[2.5464] → [17.56031:56068]

∅:BD[21.38387] → [17.56031:56068]

∅:BD[58.56535] → [17.56031:56068]

∅:BD[59.48777] → [17.56031:56068]

B:BD[17.56031] → [17.56031:56068]

∅:BD[60.48623] → [17.56538:56603]

∅:BD[77.38289] → [17.56538:56603]

∅:BD[21.38406] → [17.56538:56603]

∅:BD[62.70517] → [17.56538:56603]

∅:BD[58.56554] → [17.56538:56603]

∅:BD[64.32075] → [17.56538:56603]

∅:BD[63.49476] → [17.56538:56603]

∅:BD[102.44237] → [17.56538:56603]

∅:BD[59.48796] → [17.56538:56603]

B:BD[17.56538] → [17.56538:56603]

B:BD[17.56603] → [2.5465:5543]

∅:BD[2.5543] → [17.56603:56620]

B:BD[17.56603] → [17.56603:56620]

B:BD[58.56635] → [58.56635:56712]

∅:BD[2.5886] → [58.56869:56907]

∅:BD[21.38645] → [58.56869:56907]

B:BD[58.56869] → [58.56869:56907]

∅:BD[77.38466] → [58.56925:56990]

∅:BD[21.38664] → [58.56925:56990]

∅:BD[64.32252] → [58.56925:56990]

∅:BD[63.49576] → [58.56925:56990]

∅:BD[102.44337] → [58.56925:56990]

B:BD[58.56925] → [58.56925:56990]

∅:BD[2.5965] → [58.56990:57007]

B:BD[58.56990] → [58.56990:57007]

B:BD[58.57007] → [58.57007:57084]

B:BD[58.57007] → [2.5966:5981]

B:BD[58.56990] → [2.5887:5965]

B:BD[58.56907] → [102.44319:44337]

B:BD[58.56907] → [63.49558:49576]

B:BD[58.56907] → [64.32234:32252]

B:BD[58.56907] → [58.56907:56925]

B:BD[58.56907] → [21.38646:38664]

B:BD[58.56907] → [77.38448:38466]

B:BD[58.56788] → [58.56788:56869]

B:BD[58.56712] → [64.32157:32233]

B:BD[58.56712] → [58.56712:56788]

B:BD[58.56712] → [21.38488:38645]

B:BD[58.56712] → [77.38371:38447]

∅:BD[2.5981] → [17.56697:56712]

∅:BD[58.57084] → [17.56697:56712]

∅:BD[59.48949] → [17.56697:56712]

B:BD[17.56697] → [17.56697:56712]

B:BD[17.56712] → [2.5982:6179]

∅:BD[2.6179] → [17.56712:56732]

B:BD[17.56712] → [17.56712:56732]

∅:BD[58.57103] → [17.56750:56815]

∅:BD[59.48968] → [17.56750:56815]

B:BD[17.56750] → [17.56750:56815]

B:BD[17.56815] → [2.6180:6258]

∅:BD[2.6258] → [17.56815:56847]

B:BD[17.56815] → [17.56815:56847]

∅:BD[77.38485] → [17.56865:56930]

∅:BD[21.38683] → [17.56865:56930]

∅:BD[58.57122] → [17.56865:56930]

∅:BD[64.32271] → [17.56865:56930]

∅:BD[59.48987] → [17.56865:56930]

B:BD[17.56865] → [17.56865:56930]

B:BD[17.56930] → [2.6259:6337]

∅:BD[2.6337] → [17.56930:56958]

B:BD[17.56930] → [17.56930:56958]

∅:BD[60.48643] → [17.56977:57042]

∅:BD[77.38505] → [17.56977:57042]

∅:BD[21.38702] → [17.56977:57042]

∅:BD[62.70537] → [17.56977:57042]

∅:BD[58.57142] → [17.56977:57042]

∅:BD[63.49596] → [17.56977:57042]

∅:BD[59.49007] → [17.56977:57042]

B:BD[17.56977] → [17.56977:57042]

B:BD[17.57059] → [59.49008:49084]

B:BD[17.57059] → [64.32272:32348]

B:BD[17.57059] → [58.57143:57219]

B:BD[17.57059] → [77.38506:38655]

∅:BD[2.6416] → [17.57209:57222]

B:BD[17.57209] → [17.57209:57222]

B:BD[17.57332] → [17.57332:57344]

∅:BD[2.6436] → [17.57363:57428]

∅:BD[60.48663] → [17.57363:57428]

∅:BD[77.38675] → [17.57363:57428]

∅:BD[21.38722] → [17.57363:57428]

∅:BD[62.70557] → [17.57363:57428]

∅:BD[58.57239] → [17.57363:57428]

∅:BD[64.32368] → [17.57363:57428]

∅:BD[63.49616] → [17.57363:57428]

∅:BD[59.49104] → [17.57363:57428]

B:BD[17.57363] → [17.57363:57428]

B:BD[17.57428] → [2.6437:6515]

∅:BD[2.6515] → [17.57428:57457]

B:BD[17.57428] → [17.57428:57457]

∅:BD[60.48682] → [17.57475:57540]

∅:BD[77.38694] → [17.57475:57540]

∅:BD[21.38742] → [17.57475:57540]

∅:BD[62.70576] → [17.57475:57540]

∅:BD[58.57258] → [17.57475:57540]

∅:BD[64.32387] → [17.57475:57540]

∅:BD[63.49635] → [17.57475:57540]

∅:BD[59.49123] → [17.57475:57540]

B:BD[17.57475] → [17.57475:57540]

B:BD[17.57540] → [2.6516:6594]

∅:BD[2.6594] → [17.57540:57569]

B:BD[17.57540] → [17.57540:57569]

∅:BD[2.6614] → [17.57587:57652]

∅:BD[21.38762] → [17.57587:57652]

B:BD[17.57587] → [17.57587:57652]

B:BD[17.57652] → [2.6615:6693]

∅:BD[2.6693] → [17.57652:57669]

B:BD[17.57652] → [17.57652:57669]

B:BD[17.57825] → [59.49124:49196]

B:BD[17.57825] → [58.57259:57331]

∅:BD[2.6760] → [17.57897:57926]

∅:BD[21.38992] → [17.57897:57926]

∅:BD[58.57331] → [17.57897:57926]

∅:BD[59.49196] → [17.57897:57926]

B:BD[17.57897] → [17.57897:57926]

∅:BD[60.48702] → [17.57945:58010]

∅:BD[77.38871] → [17.57945:58010]

∅:BD[21.39012] → [17.57945:58010]

∅:BD[62.70596] → [17.57945:58010]

∅:BD[58.57351] → [17.57945:58010]

∅:BD[63.49655] → [17.57945:58010]

∅:BD[59.49216] → [17.57945:58010]

B:BD[17.57945] → [17.57945:58010]

B:BD[17.58010] → [2.6761:6839]

∅:BD[2.6839] → [17.58010:58027]

B:BD[17.58010] → [17.58010:58027]

B:BD[17.58104] → [21.39013:39160]

B:BD[77.39096] → [21.39161:39315]

∅:BD[2.6930] → [17.58554:58670]

∅:BD[21.39315] → [17.58554:58670]

B:BD[17.58554] → [17.58554:58670]

B:BD[17.58670] → [2.6931:7009]

∅:BD[2.7009] → [17.58670:58687]

B:BD[17.58670] → [17.58670:58687]

∅:BD[2.7023] → [17.58762:58777]

∅:BD[77.39172] → [17.58762:58777]

∅:BD[21.39391] → [17.58762:58777]

∅:BD[64.32696] → [17.58762:58777]

B:BD[17.58762] → [17.58762:58777]

B:BD[17.58777] → [59.49367:49489]

∅:BD[59.49489] → [17.58777:58802]

B:BD[17.58777] → [17.58777:58802]

∅:BD[77.39191] → [17.58820:58885]

∅:BD[21.39410] → [17.58820:58885]

∅:BD[64.32715] → [17.58820:58885]

∅:BD[63.49824] → [17.58820:58885]

∅:BD[102.44356] → [17.58820:58885]

B:BD[17.58820] → [17.58820:58885]

B:BD[17.58885] → [2.7024:7102]

∅:BD[2.7102] → [17.58885:58902]

B:BD[17.58885] → [17.58885:58902]

B:BD[17.58988] → [59.49490:49562]

B:BD[17.58988] → [58.57502:57574]

B:BD[17.58988] → [62.70747:70819]

B:BD[17.58988] → [60.48853:48925]

∅:BD[2.7136] → [17.59060:59104]

∅:BD[60.48925] → [17.59060:59104]

∅:BD[77.39350] → [17.59060:59104]

∅:BD[21.39569] → [17.59060:59104]

∅:BD[62.70819] → [17.59060:59104]

∅:BD[58.57574] → [17.59060:59104]

∅:BD[64.32874] → [17.59060:59104]

∅:BD[63.49983] → [17.59060:59104]

∅:BD[102.44515] → [17.59060:59104]

∅:BD[59.49562] → [17.59060:59104]

B:BD[17.59060] → [17.59060:59104]

B:BD[17.59638] → [17.59638:59703]

B:BD[17.59720] → [59.49839:50147]

B:BD[17.59720] → [58.57851:58000]

B:BD[58.58082] → [58.58082:58160]

B:BD[17.60197] → [59.50148:50191]

∅:BD[60.49017] → [17.60240:60305]

∅:BD[21.39588] → [17.60240:60305]

∅:BD[62.71568] → [17.60240:60305]

∅:BD[58.58204] → [17.60240:60305]

∅:BD[59.50191] → [17.60240:60305]

B:BD[17.60240] → [17.60240:60305]

B:BD[58.58222] → [62.71569:71651]

∅:BD[2.7215] → [17.60406:60419]

∅:BD[58.58306] → [17.60406:60419]

B:BD[17.60406] → [17.60406:60419]

B:BD[62.71853] → [63.50095:50168]

B:BD[62.72008] → [62.72008:72086]

B:BD[62.72254] → [60.49171:49393]

B:BD[17.60544] → [59.50231:50394]

B:BD[17.60710] → [59.50395:50434]

∅:BD[58.58541] → [17.60748:60813]

∅:BD[59.50434] → [17.60748:60813]

B:BD[17.60748] → [17.60748:60813]

B:BD[17.60813] → [2.7411:7489]

∅:BD[2.7489] → [17.60813:60830]

B:BD[17.60813] → [17.60813:60830]

B:BD[58.58623] → [58.58623:58696]

∅:BD[2.7787] → [17.60984:60999]

∅:BD[58.58696] → [17.60984:60999]

∅:BD[59.50587] → [17.60984:60999]

B:BD[17.60984] → [17.60984:60999]

B:BD[17.61352] → [17.61352:61368]

∅:BD[21.39689] → [17.61386:61451]

∅:BD[58.58715] → [17.61386:61451]

∅:BD[59.50606] → [17.61386:61451]

B:BD[17.61386] → [17.61386:61451]

B:BD[17.61451] → [2.7788:7866]

∅:BD[2.7866] → [17.61451:61468]

B:BD[17.61451] → [17.61451:61468]

∅:BD[2.8126] → [17.61549:61551]

∅:BD[21.39771] → [17.61549:61551]

∅:BD[58.58797] → [17.61549:61551]

∅:BD[59.50687] → [17.61549:61551]

B:BD[17.61549] → [17.61549:61551]

B:BD[77.39617] → [77.39617:39630]

B:BD[17.61585] → [59.50688:50707]

∅:BD[60.49565] → [17.61604:61669]

∅:BD[21.39813] → [17.61604:61669]

∅:BD[62.72426] → [17.61604:61669]

∅:BD[58.58817] → [17.61604:61669]

∅:BD[59.50707] → [17.61604:61669]

B:BD[17.61604] → [17.61604:61669]

B:BD[17.61669] → [2.8127:8205]

∅:BD[2.8205] → [17.61669:61686]

B:BD[17.61669] → [17.61669:61686]

∅:BD[2.8249] → [17.61759:61794]

∅:BD[60.49639] → [17.61759:61794]

∅:BD[77.39704] → [17.61759:61794]

∅:BD[21.40107] → [17.61759:61794]

∅:BD[62.72500] → [17.61759:61794]

∅:BD[58.58891] → [17.61759:61794]

∅:BD[64.33207] → [17.61759:61794]

∅:BD[63.50316] → [17.61759:61794]

∅:BD[59.50781] → [17.61759:61794]

B:BD[17.61759] → [17.61759:61794]

∅:BD[60.49658] → [17.61812:61877]

∅:BD[77.39723] → [17.61812:61877]

∅:BD[21.40126] → [17.61812:61877]

∅:BD[62.72519] → [17.61812:61877]

∅:BD[58.58910] → [17.61812:61877]

∅:BD[63.50335] → [17.61812:61877]

∅:BD[59.50801] → [17.61812:61877]

B:BD[17.61812] → [17.61812:61877]

B:BD[17.61877] → [2.8250:8328]

∅:BD[2.8328] → [17.61877:61894]

B:BD[17.61877] → [17.61877:61894]

B:BD[17.61966] → [59.50802:51020]

B:BD[17.62260] → [59.51021:51234]

B:BD[17.61966] → [58.58911:59057]

B:BD[17.62184] → [17.62184:62260]

B:BD[58.59057] → [102.44535:44607]

B:BD[58.59057] → [63.50336:50408]

B:BD[58.59057] → [64.33208:33356]

B:BD[58.59057] → [58.59057:59129]

B:BD[58.59057] → [62.72520:72592]

B:BD[58.59057] → [77.39724:39872]

B:BD[58.59057] → [60.49659:49731]

∅:BD[2.8384] → [17.62260:62275]

∅:BD[77.39872] → [17.62260:62275]

∅:BD[21.40494] → [17.62260:62275]

∅:BD[64.33356] → [17.62260:62275]

∅:BD[59.51234] → [17.62260:62275]

B:BD[17.62260] → [17.62260:62275]

B:BD[17.62396] → [59.51235:51311]

B:BD[17.62396] → [63.50409:50486]

B:BD[17.62396] → [64.33357:33434]

B:BD[17.62396] → [58.59130:59207]

B:BD[17.62396] → [62.72593:72670]

B:BD[17.62396] → [77.39873:39950]

B:BD[17.62396] → [60.49732:49809]

B:BD[17.62488] → [17.62488:62505]

∅:BD[21.40513] → [17.62523:62588]

∅:BD[58.59226] → [17.62523:62588]

∅:BD[59.51330] → [17.62523:62588]

B:BD[17.62523] → [17.62523:62588]

B:BD[17.62588] → [2.8385:8463]

∅:BD[2.8463] → [17.62588:62605]

B:BD[17.62588] → [17.62588:62605]

B:BD[58.59304] → [58.59304:59385]

∅:BD[2.8497] → [17.62763:62802]

∅:BD[21.40672] → [17.62763:62802]

∅:BD[58.59385] → [17.62763:62802]

∅:BD[59.51488] → [17.62763:62802]

B:BD[17.62763] → [17.62763:62802]

∅:BD[21.40691] → [17.62820:62885]

∅:BD[58.59404] → [17.62820:62885]

∅:BD[59.51507] → [17.62820:62885]

B:BD[17.62820] → [17.62820:62885]

B:BD[17.62885] → [2.8498:8576]

∅:BD[2.8576] → [17.62885:62902]

B:BD[17.62885] → [17.62885:62902]

B:BD[17.63054] → [86.34548:34620]

B:BD[58.59629] → [58.59629:59709]

B:BD[58.59484] → [58.59484:59629]

B:BD[58.59484] → [62.72749:72894]

B:BD[77.40108] → [77.40108:40181]

B:BD[77.40181] → [64.33593:33745]

B:BD[77.40181] → [77.40181:40333]

B:BD[58.59484] → [60.49888:49961]

B:BD[60.49961] → [102.44688:44760]

B:BD[60.49961] → [60.49961:50033]

∅:BD[2.8628] → [17.63206:63323]

∅:BD[77.40333] → [17.63206:63323]

∅:BD[21.40994] → [17.63206:63323]

∅:BD[58.59709] → [17.63206:63323]

∅:BD[64.33745] → [17.63206:63323]

∅:BD[59.51811] → [17.63206:63323]

B:BD[17.63206] → [17.63206:63323]

B:BD[17.63323] → [2.8629:8707]

∅:BD[2.8707] → [17.63323:63349]

B:BD[17.63323] → [17.63323:63349]

∅:BD[21.41013] → [17.63367:63432]

B:BD[17.63367] → [17.63367:63432]

B:BD[17.63432] → [2.8708:8786]

∅:BD[2.8786] → [17.63432:63551]

B:BD[17.63432] → [17.63432:63551]

B:BD[17.63551] → [2.8787:8865]

∅:BD[2.8865] → [17.63551:63568]

B:BD[17.63551] → [17.63551:63568]

∅:BD[2.8891] → [17.63655:63783]

B:BD[17.63655] → [17.63655:63783]

B:BD[17.63783] → [2.8892:8970]

∅:BD[2.8970] → [17.63783:63796]

B:BD[17.63783] → [17.63783:63796]

∅:BD[58.59829] → [17.63915:64022]

B:BD[17.63915] → [17.63915:64022]

B:BD[17.64022] → [2.9050:9128]

∅:BD[2.9128] → [17.64022:64039]

B:BD[17.64022] → [17.64022:64039]

B:BD[17.64114] → [17.64114:64199]

∅:BD[2.9165] → [17.64199:64325]

B:BD[17.64199] → [17.64199:64325]

B:BD[17.64325] → [2.9166:9244]

∅:BD[2.9244] → [17.64325:64435]

B:BD[17.64325] → [17.64325:64435]

B:BD[17.64435] → [2.9245:9323]

∅:BD[2.9323] → [17.64435:64452]

B:BD[17.64435] → [17.64435:64452]

B:BD[17.64522] → [59.51812:51900]

∅:BD[2.9358] → [17.64610:64642]

∅:BD[60.50122] → [17.64610:64642]

∅:BD[21.41178] → [17.64610:64642]

∅:BD[62.72983] → [17.64610:64642]

∅:BD[58.59918] → [17.64610:64642]

∅:BD[59.51900] → [17.64610:64642]

B:BD[17.64610] → [17.64610:64642]

∅:BD[2.9377] → [21.41197:41262]

B:BD[21.41197] → [21.41197:41262]

∅:BD[2.9456] → [21.41262:41279]

B:BD[21.41262] → [21.41262:41279]

∅:BD[2.9581] → [21.41837:41877]

B:BD[21.41837] → [21.41837:41877]

∅:BD[2.9600] → [21.41895:41960]

B:BD[21.41895] → [21.41895:41960]

∅:BD[2.9679] → [21.41960:41977]

B:BD[21.41960] → [21.41960:41977]

∅:BD[2.9714] → [21.42135:42172]

B:BD[21.42135] → [21.42135:42172]

B:BD[21.42172] → [21.42172:42190]

B:BD[21.42172] → [2.9715:9733]

B:BD[21.41977] → [21.41977:42135]

B:BD[21.41977] → [2.9680:9714]

B:BD[21.41960] → [2.9601:9679]

B:BD[21.41877] → [21.41877:41895]

B:BD[21.41877] → [2.9582:9600]

B:BD[21.41279] → [21.41279:41837]

B:BD[21.41279] → [2.9457:9581]

B:BD[21.41262] → [2.9378:9456]

∅:BD[2.9733] → [17.64661:64726]

∅:BD[60.50142] → [17.64661:64726]

∅:BD[77.40429] → [17.64661:64726]

∅:BD[21.42190] → [17.64661:64726]

∅:BD[62.73003] → [17.64661:64726]

∅:BD[58.59938] → [17.64661:64726]

∅:BD[64.33841] → [17.64661:64726]

∅:BD[63.50809] → [17.64661:64726]

∅:BD[59.51920] → [17.64661:64726]

B:BD[17.64661] → [17.64661:64726]

B:BD[17.64726] → [2.9734:9812]

∅:BD[2.9812] → [17.64726:64739]

B:BD[17.64726] → [17.64726:64739]

∅:BD[2.10079] → [17.64782:64847]

∅:BD[21.42726] → [17.64782:64847]

B:BD[17.64782] → [17.64782:64847]

B:BD[17.64847] → [2.10080:10158]

∅:BD[2.10158] → [17.64847:64864]

B:BD[17.64847] → [17.64847:64864]

∅:BD[2.10213] → [21.43032:43069]

B:BD[21.43032] → [21.43032:43069]

∅:BD[2.10232] → [21.43087:43152]

B:BD[21.43087] → [21.43087:43152]

∅:BD[2.10311] → [21.43152:43187]

B:BD[21.43152] → [21.43152:43187]

∅:BD[2.10330] → [21.43205:43270]

B:BD[21.43205] → [21.43205:43270]

∅:BD[2.10409] → [21.43270:43287]

B:BD[21.43270] → [21.43270:43287]

∅:BD[2.10424] → [21.43363:43400]

B:BD[21.43363] → [21.43363:43400]

∅:BD[2.10443] → [21.43418:43483]

B:BD[21.43418] → [21.43418:43483]

∅:BD[2.10522] → [21.43483:43500]

B:BD[21.43483] → [21.43483:43500]

B:BD[21.43500] → [21.43500:44442]

B:BD[21.43500] → [2.10523:10719]

B:BD[21.43483] → [2.10444:10522]

B:BD[21.43400] → [21.43400:43418]

B:BD[21.43400] → [2.10425:10443]

B:BD[21.43287] → [21.43287:43363]

B:BD[21.43287] → [2.10410:10424]

B:BD[21.43270] → [2.10331:10409]

B:BD[21.43187] → [21.43187:43205]

B:BD[21.43187] → [2.10312:10330]

B:BD[21.43152] → [2.10233:10311]

B:BD[21.43069] → [21.43069:43087]

B:BD[21.43069] → [2.10214:10232]

B:BD[60.50218] → [60.50218:50294]

∅:BD[2.10719] → [17.65015:65053]

∅:BD[60.50294] → [17.65015:65053]

∅:BD[77.40581] → [17.65015:65053]

∅:BD[21.44442] → [17.65015:65053]

∅:BD[62.73154] → [17.65015:65053]

∅:BD[58.60090] → [17.65015:65053]

∅:BD[64.33993] → [17.65015:65053]

∅:BD[59.52071] → [17.65015:65053]

B:BD[17.65015] → [17.65015:65053]

∅:BD[2.11078] → [17.65072:65137]

∅:BD[21.44672] → [17.65072:65137]

∅:BD[58.60110] → [17.65072:65137]

∅:BD[59.52090] → [17.65072:65137]

B:BD[17.65072] → [17.65072:65137]

B:BD[17.65137] → [2.11079:11157]

∅:BD[2.11157] → [17.65137:65154]

B:BD[17.65137] → [17.65137:65154]

∅:BD[2.11216] → [17.65229:65244]

∅:BD[21.44913] → [17.65229:65244]

B:BD[17.65229] → [17.65229:65244]

B:BD[17.65244] → [21.44914:45013]

∅:BD[2.11295] → [21.45013:45026]

B:BD[21.45013] → [21.45013:45026]

B:BD[21.45013] → [2.11217:11295]

∅:BD[21.45026] → [17.65244:65256]

B:BD[17.65244] → [17.65244:65256]

∅:BD[60.50314] → [17.65275:65340]

∅:BD[77.40601] → [17.65275:65340]

∅:BD[21.45045] → [17.65275:65340]

∅:BD[62.73174] → [17.65275:65340]

∅:BD[58.60130] → [17.65275:65340]

∅:BD[64.34013] → [17.65275:65340]

∅:BD[63.50905] → [17.65275:65340]

∅:BD[59.52110] → [17.65275:65340]

B:BD[17.65275] → [17.65275:65340]

B:BD[17.65340] → [2.11296:11374]

∅:BD[2.11374] → [17.65340:65357]

B:BD[17.65340] → [17.65340:65357]

B:BD[58.60207] → [63.50906:50979]

B:BD[17.65576] → [59.52261:52408]

B:BD[17.65798] → [59.52409:52699]

∅:BD[2.11942] → [17.66088:66103]

∅:BD[21.46429] → [17.66088:66103]

∅:BD[58.60998] → [17.66088:66103]

∅:BD[59.52699] → [17.66088:66103]

B:BD[17.66088] → [17.66088:66103]

B:BD[17.66382] → [17.66382:66400]

∅:BD[21.46448] → [17.66418:66483]

B:BD[17.66418] → [17.66418:66483]

B:BD[17.66483] → [2.11943:12021]

∅:BD[2.12021] → [17.66483:66500]

B:BD[17.66483] → [17.66483:66500]

∅:BD[2.12062] → [17.66646:66675]

∅:BD[21.46670] → [17.66646:66675]

B:BD[17.66646] → [17.66646:66675]

∅:BD[60.50706] → [17.66694:66759]

∅:BD[77.41066] → [17.66694:66759]

∅:BD[21.47036] → [17.66694:66759]

∅:BD[62.73566] → [17.66694:66759]

∅:BD[58.61091] → [17.66694:66759]

∅:BD[63.51220] → [17.66694:66759]

∅:BD[59.52792] → [17.66694:66759]

B:BD[17.66694] → [17.66694:66759]

B:BD[17.66759] → [2.12170:12248]

∅:BD[2.12248] → [17.66759:66776]

B:BD[17.66759] → [17.66759:66776]

∅:BD[2.12268] → [77.41212:41227]

∅:BD[21.47180] → [77.41212:41227]

∅:BD[64.34385] → [77.41212:41227]

B:BD[77.41212] → [77.41212:41227]

B:BD[17.67005] → [17.67005:67023]

∅:BD[2.12461] → [17.67041:67106]

∅:BD[21.47199] → [17.67041:67106]

B:BD[17.67041] → [17.67041:67106]

B:BD[17.67106] → [2.12462:12540]

∅:BD[2.12540] → [17.67106:67138]

B:BD[17.67106] → [17.67106:67138]

∅:BD[21.47218] → [17.67156:67221]

∅:BD[58.61184] → [17.67156:67221]

∅:BD[59.52885] → [17.67156:67221]

B:BD[17.67156] → [17.67156:67221]

B:BD[17.67221] → [2.12541:12619]

∅:BD[2.12619] → [17.67221:67238]

B:BD[17.67221] → [17.67221:67238]

∅:BD[2.12636] → [17.67316:67346]

∅:BD[21.47297] → [17.67316:67346]

B:BD[17.67316] → [17.67316:67346]

∅:BD[2.12656] → [17.67366:67431]

∅:BD[60.50801] → [17.67366:67431]

∅:BD[77.41663] → [17.67366:67431]

∅:BD[21.47317] → [17.67366:67431]

∅:BD[62.73661] → [17.67366:67431]

∅:BD[58.61205] → [17.67366:67431]

∅:BD[64.34406] → [17.67366:67431]

∅:BD[63.51315] → [17.67366:67431]

∅:BD[59.52906] → [17.67366:67431]

B:BD[17.67366] → [17.67366:67431]

B:BD[17.67431] → [2.12657:12735]

∅:BD[2.12735] → [17.67431:67448]

B:BD[17.67431] → [17.67431:67448]

B:BD[77.41737] → [64.34407:34482]

B:BD[17.67678] → [59.53056:53198]

B:BD[17.67967] → [64.34554:34625]

B:BD[17.68108] → [17.68108:68180]

B:BD[58.61649] → [58.61649:61721]

B:BD[58.62031] → [58.62031:62107]

B:BD[58.62191] → [58.62191:62270]

B:BD[58.62107] → [102.44908:44992]

B:BD[58.62107] → [63.51763:51847]

B:BD[58.62107] → [64.34700:34863]

B:BD[58.62107] → [58.62107:62191]

B:BD[58.62107] → [62.74265:74349]

B:BD[58.62107] → [77.42335:42498]

B:BD[58.62107] → [60.51486:51570]

B:BD[77.42253] → [77.42253:42334]

B:BD[60.51329] → [60.51329:51485]

B:BD[60.51248] → [60.51248:51329]

B:BD[58.61721] → [102.44834:44907]

B:BD[58.61721] → [63.51608:51762]

B:BD[58.61721] → [64.34626:34699]

B:BD[58.61721] → [58.61721:62031]

B:BD[58.61721] → [62.73954:74264]

B:BD[58.61721] → [77.42104:42253]

B:BD[58.61721] → [60.51175:51248]

B:BD[17.68881] → [17.68881:68952]

B:BD[17.68180] → [59.53270:53889]

B:BD[17.68180] → [58.61569:61649]

B:BD[17.68180] → [60.51094:51174]

B:BD[17.68180] → [17.68180:68881]

B:BD[17.67967] → [77.42032:42103]

B:BD[17.67967] → [17.67967:68038]

B:BD[17.68038] → [59.53199:53269]

B:BD[17.68038] → [58.61498:61568]

B:BD[17.68038] → [17.68038:68108]

B:BD[17.67678] → [63.51465:51607]

B:BD[17.67678] → [64.34483:34553]

B:BD[77.41955] → [77.41955:42031]

B:BD[17.67678] → [58.61355:61497]

B:BD[17.67678] → [62.73811:73953]

B:BD[77.41883] → [77.41883:41955]

B:BD[17.67820] → [17.67820:67967]

B:BD[17.67678] → [77.41813:41883]

B:BD[17.67678] → [60.50951:51093]

B:BD[17.67678] → [17.67678:67820]

B:BD[77.41737] → [77.41737:41812]

∅:BD[2.12942] → [17.68952:68981]

∅:BD[21.48517] → [17.68952:68981]

B:BD[17.68952] → [17.68952:68981]

∅:BD[21.48536] → [17.68999:69064]

B:BD[17.68999] → [17.68999:69064]

B:BD[17.69064] → [2.12943:13021]

∅:BD[2.13021] → [17.69064:69081]

B:BD[17.69064] → [17.69064:69081]

B:BD[17.69234] → [59.53890:53978]

∅:BD[2.13077] → [17.69322:69355]

∅:BD[21.48626] → [17.69322:69355]

∅:BD[58.62359] → [17.69322:69355]

∅:BD[59.53978] → [17.69322:69355]

B:BD[17.69322] → [17.69322:69355]

∅:BD[21.48645] → [17.69373:69438]

B:BD[17.69373] → [17.69373:69438]

∅:BD[2.13156] → [21.48646:48663]

B:BD[17.69438] → [21.48646:48663]

∅:BD[2.13183] → [21.48813:48815]

B:BD[21.48813] → [21.48813:48815]

B:BD[21.48663] → [21.48663:48813]

B:BD[21.48663] → [2.13157:13183]

B:BD[17.69438] → [2.13078:13156]

∅:BD[21.48815] → [17.69438:69466]

B:BD[17.69438] → [17.69438:69466]

∅:BD[21.48834] → [17.69484:69549]

B:BD[17.69484] → [17.69484:69549]

B:BD[17.69549] → [2.13184:13262]

∅:BD[2.13262] → [17.69549:69566]

B:BD[17.69549] → [17.69549:69566]

∅:BD[2.13272] → [17.69711:69744]

∅:BD[21.48907] → [17.69711:69744]

B:BD[17.69711] → [17.69711:69744]

∅:BD[21.48926] → [17.69762:69827]

∅:BD[58.62451] → [17.69762:69827]

∅:BD[59.54070] → [17.69762:69827]

B:BD[17.69762] → [17.69762:69827]

B:BD[17.69827] → [2.13273:13351]

∅:BD[2.13351] → [17.69827:69844]

B:BD[17.69827] → [17.69827:69844]

B:BD[17.69922] → [64.34937:35011]

B:BD[17.70073] → [59.54071:54144]

B:BD[17.70073] → [63.51921:51994]

B:BD[17.70073] → [58.62452:62525]

B:BD[17.70073] → [62.74423:74496]

B:BD[17.70073] → [77.42647:42720]

B:BD[17.70073] → [60.51644:51717]

B:BD[17.70073] → [17.70073:70146]

B:BD[17.70146] → [17.70146:70219]

B:BD[17.69922] → [77.42572:42646]

∅:BD[2.13407] → [17.70219:70248]

∅:BD[21.49225] → [17.70219:70248]

B:BD[17.70219] → [17.70219:70248]

∅:BD[77.42739] → [17.70266:70331]

∅:BD[21.49244] → [17.70266:70331]

∅:BD[64.35030] → [17.70266:70331]

B:BD[17.70266] → [17.70266:70331]

B:BD[17.70331] → [2.13408:13486]

∅:BD[2.13486] → [17.70331:70357]

B:BD[17.70331] → [17.70331:70357]

∅:BD[21.49263] → [17.70375:70440]

∅:BD[58.62544] → [17.70375:70440]

∅:BD[59.54163] → [17.70375:70440]

B:BD[17.70375] → [17.70375:70440]

B:BD[17.70440] → [2.13487:13565]

∅:BD[2.13565] → [17.70440:70457]

B:BD[17.70440] → [17.70440:70457]

∅:BD[2.13578] → [17.70687:70801]

∅:BD[21.49324] → [17.70687:70801]

∅:BD[58.62775] → [17.70687:70801]

∅:BD[59.54393] → [17.70687:70801]

B:BD[17.70687] → [17.70687:70801]

B:BD[17.70801] → [2.13579:13657]

∅:BD[2.13657] → [17.70801:70919]

B:BD[17.70801] → [17.70801:70919]

B:BD[17.70919] → [2.13658:13736]

∅:BD[2.13736] → [17.70919:70936]

B:BD[17.70919] → [17.70919:70936]

∅:BD[2.13771] → [17.71088:71124]

B:BD[17.71088] → [17.71088:71124]

B:BD[60.51736] → [64.35031:35145]

∅:BD[60.51736] → [17.71142:71207]

∅:BD[21.49343] → [17.71142:71207]

∅:BD[62.74515] → [17.71142:71207]

∅:BD[58.62794] → [17.71142:71207]

∅:BD[64.35145] → [17.71142:71207]

∅:BD[59.54412] → [17.71142:71207]

B:BD[17.71142] → [17.71142:71207]

B:BD[17.71207] → [59.54413:54512]

B:BD[17.71207] → [2.13772:13850]

∅:BD[2.13850] → [17.71207:71220]

∅:BD[59.54512] → [17.71207:71220]

B:BD[17.71207] → [17.71207:71220]

B:BD[17.71238] → [59.54513:54531]

B:BD[17.71238] → [58.62795:62813]

B:BD[17.71334] → [17.71334:71348]

∅:BD[2.13870] → [17.71367:71432]

∅:BD[60.51756] → [17.71367:71432]

∅:BD[77.42759] → [17.71367:71432]

∅:BD[21.49363] → [17.71367:71432]

∅:BD[62.74535] → [17.71367:71432]

∅:BD[58.62833] → [17.71367:71432]

∅:BD[64.35165] → [17.71367:71432]

∅:BD[63.52014] → [17.71367:71432]

∅:BD[102.45085] → [17.71367:71432]

∅:BD[59.54551] → [17.71367:71432]

B:BD[17.71367] → [17.71367:71432]

B:BD[17.71432] → [2.13871:13949]

∅:BD[2.13949] → [17.71432:71470]

B:BD[17.71432] → [17.71432:71470]

B:BD[17.71488] → [17.71488:71584]

∅:BD[21.49382] → [17.71602:71667]

∅:BD[58.62871] → [17.71602:71667]

∅:BD[59.54589] → [17.71602:71667]

B:BD[17.71602] → [17.71602:71667]

B:BD[17.71684] → [59.54590:54667]

B:BD[17.71684] → [58.62872:62949]

B:BD[17.71838] → [17.71838:71866]

∅:BD[2.14028] → [59.54759:54785]

B:BD[59.54759] → [59.54759:54785]

∅:BD[21.49402] → [59.54803:54868]

∅:BD[58.62968] → [59.54803:54868]

B:BD[59.54803] → [59.54803:54868]

∅:BD[2.14107] → [59.54868:54885]

B:BD[59.54868] → [59.54868:54885]

∅:BD[2.14119] → [17.72039:72073]

∅:BD[60.51849] → [17.72039:72073]

∅:BD[77.42852] → [17.72039:72073]

∅:BD[21.49477] → [17.72039:72073]

∅:BD[62.74628] → [17.72039:72073]

∅:BD[58.63042] → [17.72039:72073]

∅:BD[64.35239] → [17.72039:72073]

∅:BD[63.52107] → [17.72039:72073]

∅:BD[59.54958] → [17.72039:72073]

B:BD[17.72039] → [17.72039:72073]

∅:BD[60.51868] → [17.72091:72156]

∅:BD[77.42871] → [17.72091:72156]

∅:BD[62.74647] → [17.72091:72156]

∅:BD[58.63061] → [17.72091:72156]

∅:BD[63.52126] → [17.72091:72156]

∅:BD[59.54977] → [17.72091:72156]

B:BD[17.72091] → [17.72091:72156]

B:BD[17.72156] → [2.14120:14198]

∅:BD[2.14198] → [17.72156:72173]

B:BD[17.72156] → [17.72156:72173]

∅:BD[2.14219] → [17.72255:72366]

∅:BD[60.51951] → [17.72255:72366]

∅:BD[77.42954] → [17.72255:72366]

∅:BD[21.49560] → [17.72255:72366]

∅:BD[62.74730] → [17.72255:72366]

∅:BD[58.63144] → [17.72255:72366]

∅:BD[63.52209] → [17.72255:72366]

∅:BD[59.55060] → [17.72255:72366]

B:BD[17.72255] → [17.72255:72366]

B:BD[17.72366] → [2.14220:14298]

∅:BD[2.14298] → [17.72366:72400]

B:BD[17.72366] → [17.72366:72400]

∅:BD[21.49580] → [17.72418:72483]

∅:BD[58.63163] → [17.72418:72483]

∅:BD[59.55079] → [17.72418:72483]

B:BD[17.72418] → [17.72418:72483]

B:BD[17.72483] → [2.14299:14377]

∅:BD[2.14377] → [17.72483:72500]

B:BD[17.72483] → [17.72483:72500]

B:BD[58.63314] → [63.52210:52363]

B:BD[17.73047] → [59.55462:55536]

∅:BD[2.14506] → [17.73121:73136]

∅:BD[58.63620] → [17.73121:73136]

∅:BD[59.55536] → [17.73121:73136]

B:BD[17.73121] → [17.73121:73136]

B:BD[17.73136] → [21.50200:50302]

∅:BD[2.14585] → [21.50302:50315]

B:BD[21.50302] → [21.50302:50315]

B:BD[21.50302] → [2.14507:14585]

∅:BD[21.50315] → [17.73136:73236]

B:BD[17.73136] → [17.73136:73236]

B:BD[17.73236] → [2.14586:14664]

∅:BD[2.14664] → [17.73236:73265]

B:BD[17.73236] → [17.73236:73265]

∅:BD[60.52202] → [17.73283:73348]

∅:BD[21.50334] → [17.73283:73348]

∅:BD[62.74981] → [17.73283:73348]

∅:BD[58.63639] → [17.73283:73348]

∅:BD[59.55555] → [17.73283:73348]

B:BD[17.73283] → [17.73283:73348]

B:BD[17.73348] → [59.55556:55800]

B:BD[17.73348] → [62.74982:75146]

B:BD[17.73348] → [2.14665:14743]

∅:BD[2.14743] → [17.73348:73361]

∅:BD[62.75146] → [17.73348:73361]

∅:BD[59.55800] → [17.73348:73361]

B:BD[17.73348] → [17.73348:73361]

∅:BD[21.50558] → [17.73463:73476]

B:BD[17.73463] → [17.73463:73476]

B:BD[17.73493] → [59.55801:55819]

∅:BD[2.14881] → [17.73512:73577]

∅:BD[21.50598] → [17.73512:73577]

∅:BD[58.63659] → [17.73512:73577]

∅:BD[59.55819] → [17.73512:73577]

B:BD[17.73512] → [17.73512:73577]

B:BD[17.73577] → [2.14882:14960]

∅:BD[2.14960] → [17.73577:73594]

B:BD[17.73577] → [17.73577:73594]

B:BD[58.63815] → [58.63815:63892]

B:BD[58.63815] → [62.75147:75224]

B:BD[58.63815] → [60.52203:52280]

∅:BD[2.14983] → [17.73826:73854]

∅:BD[60.52280] → [17.73826:73854]

∅:BD[21.50671] → [17.73826:73854]

∅:BD[62.75224] → [17.73826:73854]

∅:BD[58.63892] → [17.73826:73854]

∅:BD[59.56052] → [17.73826:73854]

B:BD[17.73826] → [17.73826:73854]

∅:BD[77.43128] → [17.73873:73938]

∅:BD[21.50691] → [17.73873:73938]

∅:BD[64.35413] → [17.73873:73938]

B:BD[17.73873] → [17.73873:73938]

B:BD[17.73938] → [2.14984:15062]

∅:BD[2.15062] → [17.73938:73955]

B:BD[17.73938] → [17.73938:73955]

B:BD[17.73955] → [21.50692:50766]

B:BD[17.74121] → [21.50767:50839]

B:BD[17.74272] → [59.56053:56270]

B:BD[17.74560] → [21.50984:51056]

B:BD[17.74703] → [17.74703:74776]

∅:BD[2.15204] → [17.74776:74808]

B:BD[17.74776] → [17.74776:74808]

∅:BD[21.51075] → [17.74826:74891]

B:BD[17.74826] → [17.74826:74891]

B:BD[17.74891] → [2.15205:15283]

∅:BD[2.15283] → [17.74891:74908]

B:BD[17.74891] → [17.74891:74908]

B:BD[17.74980] → [59.56343:56415]

B:BD[17.74980] → [102.45159:45231]

B:BD[17.74980] → [63.52437:52509]

B:BD[17.74980] → [64.35562:35705]

B:BD[17.74980] → [58.64183:64255]

B:BD[17.74980] → [62.75298:75370]

B:BD[17.74980] → [77.43202:43345]

B:BD[17.74980] → [60.52354:52426]

∅:BD[2.15311] → [17.75123:75235]

∅:BD[77.43345] → [17.75123:75235]

∅:BD[21.51291] → [17.75123:75235]

∅:BD[64.35705] → [17.75123:75235]

B:BD[17.75123] → [17.75123:75235]

B:BD[17.75235] → [2.15312:15390]

∅:BD[2.15390] → [17.75235:75252]

B:BD[17.75235] → [17.75235:75252]

B:BD[17.75331] → [21.51292:51364]

∅:BD[2.15449] → [17.75553:75588]

B:BD[17.75553] → [17.75553:75588]

∅:BD[77.43364] → [17.75606:75671]

∅:BD[21.51383] → [17.75606:75671]

∅:BD[64.35724] → [17.75606:75671]

∅:BD[63.52528] → [17.75606:75671]

∅:BD[102.45250] → [17.75606:75671]

B:BD[17.75606] → [17.75606:75671]

B:BD[17.75671] → [2.15450:15528]

∅:BD[2.15528] → [17.75671:75688]

B:BD[17.75671] → [17.75671:75688]

B:BD[60.52505] → [102.45251:45323]

B:BD[58.64476] → [63.52602:52678]

B:BD[17.76064] → [59.56713:57117]

B:BD[17.76064] → [63.52679:52758]

B:BD[60.52810] → [102.45324:45498]

B:BD[60.52810] → [63.52759:52933]

B:BD[60.52810] → [64.35955:36204]

B:BD[58.64882] → [58.64882:64957]

B:BD[58.64882] → [62.75755:75830]

B:BD[60.52810] → [77.43595:43844]

B:BD[58.64882] → [60.52811:52886]

B:BD[17.76064] → [64.35875:35954]

B:BD[17.76064] → [58.64553:64708]

B:BD[58.64708] → [58.64708:64882]

B:BD[17.76064] → [62.75599:75754]

B:BD[17.76064] → [21.51682:52086]

B:BD[17.76064] → [77.43515:43594]

B:BD[17.76064] → [60.52655:52734]

B:BD[60.52734] → [60.52734:52810]

∅:BD[2.15684] → [17.76468:76497]

∅:BD[60.52886] → [17.76468:76497]

∅:BD[77.43844] → [17.76468:76497]

∅:BD[21.52086] → [17.76468:76497]

∅:BD[62.75830] → [17.76468:76497]

∅:BD[58.64957] → [17.76468:76497]

∅:BD[64.36204] → [17.76468:76497]

∅:BD[59.57117] → [17.76468:76497]

B:BD[17.76468] → [17.76468:76497]

∅:BD[21.52106] → [17.76516:76581]

B:BD[17.76516] → [17.76516:76581]

B:BD[17.76581] → [2.15685:15763]

∅:BD[2.15763] → [17.76581:76598]

B:BD[17.76581] → [17.76581:76598]

B:BD[60.52960] → [102.45499:45571]

B:BD[77.43990] → [77.43990:44063]

B:BD[60.52960] → [60.52960:53032]

B:BD[60.53032] → [60.53032:53105]

∅:BD[2.15801] → [17.76816:76862]

∅:BD[60.53105] → [17.76816:76862]

∅:BD[77.44063] → [17.76816:76862]

∅:BD[21.52326] → [17.76816:76862]

∅:BD[62.76049] → [17.76816:76862]

∅:BD[58.65176] → [17.76816:76862]

∅:BD[63.53152] → [17.76816:76862]

∅:BD[59.57336] → [17.76816:76862]

B:BD[17.76816] → [17.76816:76862]

∅:BD[60.53124] → [17.76880:76945]

∅:BD[21.52345] → [17.76880:76945]

∅:BD[62.76068] → [17.76880:76945]

∅:BD[58.65195] → [17.76880:76945]

∅:BD[59.57355] → [17.76880:76945]

B:BD[17.76880] → [17.76880:76945]

B:BD[17.76945] → [59.57356:57453]

B:BD[17.76945] → [62.76069:76166]

B:BD[17.76945] → [2.15802:15880]

∅:BD[2.15880] → [17.76945:76958]

∅:BD[62.76166] → [17.76945:76958]

∅:BD[59.57453] → [17.76945:76958]

B:BD[17.76945] → [17.76945:76958]

B:BD[17.76974] → [59.57454:57473]

B:BD[17.76974] → [58.65196:65215]

B:BD[17.77071] → [17.77071:77092]

∅:BD[77.44083] → [17.77111:77176]

∅:BD[21.52365] → [17.77111:77176]

∅:BD[64.36370] → [17.77111:77176]

B:BD[17.77111] → [17.77111:77176]

B:BD[17.77176] → [2.15881:15959]

∅:BD[2.15959] → [17.77176:77193]

B:BD[17.77176] → [17.77176:77193]

∅:BD[2.15987] → [17.77270:77305]

∅:BD[77.44235] → [17.77270:77305]

∅:BD[21.52518] → [17.77270:77305]

∅:BD[64.36448] → [17.77270:77305]

B:BD[17.77270] → [17.77270:77305]

∅:BD[77.44254] → [17.77323:77388]

∅:BD[21.52538] → [17.77323:77388]

∅:BD[64.36467] → [17.77323:77388]

B:BD[17.77323] → [17.77323:77388]

∅:BD[2.16066] → [21.52539:52556]

B:BD[17.77388] → [21.52539:52556]

∅:BD[2.16079] → [21.52630:52632]

B:BD[21.52630] → [21.52630:52632]

B:BD[21.52556] → [21.52556:52630]

B:BD[21.52556] → [2.16067:16079]

B:BD[17.77388] → [77.44255:44348]

B:BD[17.77388] → [2.15988:16066]

∅:BD[77.44348] → [17.77388:77419]

∅:BD[21.52632] → [17.77388:77419]

B:BD[17.77388] → [17.77388:77419]

∅:BD[60.53144] → [17.77438:77503]

∅:BD[77.44368] → [17.77438:77503]

∅:BD[21.52652] → [17.77438:77503]

∅:BD[62.76185] → [17.77438:77503]

∅:BD[58.65235] → [17.77438:77503]

∅:BD[64.36487] → [17.77438:77503]

∅:BD[59.57492] → [17.77438:77503]

B:BD[17.77438] → [17.77438:77503]

B:BD[17.77503] → [2.16080:16158]

∅:BD[2.16158] → [17.77503:77520]

B:BD[17.77503] → [17.77503:77520]

∅:BD[2.16183] → [17.77592:77594]

∅:BD[60.53217] → [17.77592:77594]

∅:BD[77.44441] → [17.77592:77594]

∅:BD[21.52803] → [17.77592:77594]

∅:BD[62.76258] → [17.77592:77594]

∅:BD[58.65308] → [17.77592:77594]

∅:BD[64.36560] → [17.77592:77594]

∅:BD[63.53225] → [17.77592:77594]

∅:BD[102.45644] → [17.77592:77594]

∅:BD[59.57565] → [17.77592:77594]

B:BD[17.77592] → [17.77592:77594]

B:BD[58.65322] → [102.45645:45757]

∅:BD[21.53032] → [58.65322:65344]

∅:BD[102.45757] → [58.65322:65344]

B:BD[58.65322] → [58.65322:65344]

∅:BD[21.53051] → [58.65362:65427]

B:BD[58.65362] → [58.65362:65427]

B:BD[58.65427] → [2.16342:16420]

B:BD[58.65344] → [58.65344:65362]

B:BD[58.65344] → [21.53033:53051]

∅:BD[2.16420] → [17.77712:77725]

∅:BD[58.65427] → [17.77712:77725]

B:BD[17.77712] → [17.77712:77725]

B:BD[17.77725] → [2.16421:16617]

∅:BD[2.16617] → [17.77725:77742]

B:BD[17.77725] → [17.77725:77742]

∅:BD[60.53238] → [17.77762:77827]

∅:BD[77.44575] → [17.77762:77827]

∅:BD[21.53072] → [17.77762:77827]

∅:BD[62.76279] → [17.77762:77827]

∅:BD[58.65448] → [17.77762:77827]

∅:BD[64.36581] → [17.77762:77827]

∅:BD[63.53246] → [17.77762:77827]

∅:BD[59.57586] → [17.77762:77827]

B:BD[17.77762] → [17.77762:77827]

B:BD[17.77827] → [2.16618:16696]

∅:BD[2.16696] → [17.77827:77844]

B:BD[17.77827] → [17.77827:77844]

B:BD[17.77919] → [59.57587:57660]

B:BD[17.78072] → [59.57661:57890]

B:BD[17.78072] → [58.65523:65752]

B:BD[17.78072] → [62.76354:76583]

B:BD[17.78072] → [21.53223:53452]

B:BD[17.78072] → [60.53313:53391]

B:BD[60.53463] → [60.53463:53542]

B:BD[60.53391] → [102.45758:45830]

B:BD[60.53391] → [63.53321:53472]

B:BD[60.53391] → [64.36731:36882]

B:BD[60.53391] → [77.44725:44876]

B:BD[60.53391] → [60.53391:53463]

∅:BD[2.16780] → [17.78301:78422]

∅:BD[60.53542] → [17.78301:78422]

∅:BD[77.44876] → [17.78301:78422]

∅:BD[21.53452] → [17.78301:78422]

∅:BD[62.76583] → [17.78301:78422]

∅:BD[58.65752] → [17.78301:78422]

∅:BD[64.36882] → [17.78301:78422]

∅:BD[63.53472] → [17.78301:78422]

∅:BD[59.57890] → [17.78301:78422]

B:BD[17.78301] → [17.78301:78422]

B:BD[17.78422] → [2.16781:16859]

∅:BD[2.16859] → [17.78422:78456]

B:BD[17.78422] → [17.78422:78456]

∅:BD[60.53562] → [17.78475:78540]

∅:BD[77.44896] → [17.78475:78540]

∅:BD[21.53472] → [17.78475:78540]

∅:BD[62.76603] → [17.78475:78540]

∅:BD[58.65772] → [17.78475:78540]

∅:BD[64.36902] → [17.78475:78540]

∅:BD[63.53492] → [17.78475:78540]

∅:BD[59.57910] → [17.78475:78540]

B:BD[17.78475] → [17.78475:78540]

B:BD[17.78540] → [2.16860:16938]

∅:BD[2.16938] → [17.78540:78557]

B:BD[17.78540] → [17.78540:78557]

B:BD[60.53633] → [102.45831:45903]

B:BD[17.78777] → [64.37046:37126]

B:BD[17.78777] → [58.65916:65996]

B:BD[17.78777] → [60.53706:53786]

B:BD[17.78857] → [17.78857:78929]

B:BD[17.78777] → [17.78777:78857]

B:BD[60.53633] → [60.53633:53705]

∅:BD[2.16992] → [17.78929:78944]

∅:BD[21.53840] → [17.78929:78944]

B:BD[17.78929] → [17.78929:78944]

B:BD[17.78964] → [59.58054:58072]

∅:BD[21.53875] → [17.78982:79047]

∅:BD[58.66015] → [17.78982:79047]

∅:BD[59.58072] → [17.78982:79047]

B:BD[17.78982] → [17.78982:79047]

B:BD[17.79047] → [2.16993:17071]

∅:BD[2.17071] → [17.79047:79064]

B:BD[17.79047] → [17.79047:79064]

∅:BD[2.17107] → [17.79149:79164]

∅:BD[21.54029] → [17.79149:79164]

B:BD[17.79149] → [17.79149:79164]

B:BD[17.79185] → [59.58073:58091]

∅:BD[21.54074] → [17.79203:79268]

∅:BD[58.66034] → [17.79203:79268]

∅:BD[59.58091] → [17.79203:79268]

B:BD[17.79203] → [17.79203:79268]

B:BD[17.79285] → [59.58092:58250]

B:BD[17.79285] → [58.66035:66193]

∅:BD[2.17186] → [17.79445:79458]

B:BD[17.79445] → [17.79445:79458]

B:BD[17.79484] → [59.58251:58269]

B:BD[17.79484] → [58.66194:66212]

∅:BD[21.54106] → [17.79502:79567]

∅:BD[58.66212] → [17.79502:79567]

∅:BD[59.58269] → [17.79502:79567]

B:BD[17.79502] → [17.79502:79567]

B:BD[17.79567] → [2.17187:17265]

∅:BD[2.17265] → [17.79567:79584]

B:BD[17.79567] → [17.79567:79584]

∅:BD[2.17281] → [58.66505:66520]

∅:BD[60.54008] → [58.66505:66520]

∅:BD[77.45336] → [58.66505:66520]

∅:BD[21.54184] → [58.66505:66520]

∅:BD[62.76968] → [58.66505:66520]

∅:BD[63.53782] → [58.66505:66520]

B:BD[58.66505] → [58.66505:66520]

∅:BD[21.54224] → [58.66554:66619]

B:BD[58.66554] → [58.66554:66619]

∅:BD[2.17360] → [58.66619:66636]

B:BD[58.66619] → [58.66619:66636]

B:BD[58.66712] → [58.66712:66789]

∅:BD[2.17394] → [17.80239:80254]

∅:BD[21.54382] → [17.80239:80254]

∅:BD[58.66789] → [17.80239:80254]

∅:BD[59.58562] → [17.80239:80254]

B:BD[17.80239] → [17.80239:80254]

∅:BD[21.54424] → [17.80298:80363]

B:BD[17.80298] → [17.80298:80363]

∅:BD[2.17473] → [21.54425:54442]

B:BD[17.80363] → [21.54425:54442]

∅:BD[2.17498] → [21.54590:54592]

B:BD[21.54590] → [21.54590:54592]

B:BD[21.54442] → [21.54442:54590]

B:BD[21.54442] → [2.17474:17498]

B:BD[17.80363] → [2.17395:17473]

∅:BD[21.54592] → [17.80363:80376]

B:BD[17.80363] → [17.80363:80376]

B:BD[17.80389] → [59.58563:58582]

∅:BD[21.54631] → [17.80408:80473]

∅:BD[58.66809] → [17.80408:80473]

∅:BD[59.58582] → [17.80408:80473]

B:BD[17.80408] → [17.80408:80473]

B:BD[17.80473] → [2.17499:17577]

∅:BD[2.17577] → [17.80473:80490]

B:BD[17.80473] → [17.80473:80490]

∅:BD[2.17592] → [17.80568:80583]

∅:BD[21.54708] → [17.80568:80583]

∅:BD[58.66888] → [17.80568:80583]

∅:BD[59.58661] → [17.80568:80583]

B:BD[17.80568] → [17.80568:80583]

B:BD[17.80604] → [59.58662:58681]

∅:BD[2.17612] → [17.80623:80688]

∅:BD[21.54749] → [17.80623:80688]

∅:BD[58.66908] → [17.80623:80688]

∅:BD[59.58681] → [17.80623:80688]

B:BD[17.80623] → [17.80623:80688]

B:BD[17.80688] → [2.17613:17691]

∅:BD[2.17691] → [17.80688:80705]

B:BD[17.80688] → [17.80688:80705]

∅:BD[2.17717] → [17.80864:80879]

∅:BD[21.54838] → [17.80864:80879]

∅:BD[58.67068] → [17.80864:80879]

∅:BD[59.58841] → [17.80864:80879]

B:BD[17.80864] → [17.80864:80879]

B:BD[17.80902] → [59.58842:58861]

∅:BD[2.17737] → [17.80921:80986]

∅:BD[21.54888] → [17.80921:80986]

∅:BD[58.67088] → [17.80921:80986]

∅:BD[59.58861] → [17.80921:80986]

B:BD[17.80921] → [17.80921:80986]

B:BD[17.80986] → [2.17738:17816]

∅:BD[2.17816] → [17.80986:81003]

B:BD[17.80986] → [17.80986:81003]

∅:BD[2.17851] → [17.81152:81167]

∅:BD[21.55111] → [17.81152:81167]

∅:BD[58.67238] → [17.81152:81167]

∅:BD[59.59011] → [17.81152:81167]

B:BD[17.81152] → [17.81152:81167]

B:BD[17.81187] → [59.59012:59031]

∅:BD[2.17871] → [17.81206:81271]

∅:BD[21.55156] → [17.81206:81271]

∅:BD[58.67258] → [17.81206:81271]

∅:BD[59.59031] → [17.81206:81271]

B:BD[17.81206] → [17.81206:81271]

∅:BD[2.18029] → [17.81366:81399]

∅:BD[21.55272] → [17.81366:81399]

B:BD[17.81366] → [17.81366:81399]

∅:BD[21.55408] → [17.81418:81483]

B:BD[17.81418] → [17.81418:81483]

B:BD[17.81483] → [2.18109:18187]

∅:BD[2.18187] → [17.81483:81605]

B:BD[17.81483] → [17.81483:81605]

B:BD[17.81605] → [2.18188:18266]

∅:BD[2.18266] → [17.81605:81618]

B:BD[17.81605] → [17.81605:81618]

B:BD[17.81639] → [59.59032:59051]

∅:BD[77.45433] → [17.81658:81723]

∅:BD[21.55453] → [17.81658:81723]

∅:BD[58.67278] → [17.81658:81723]

∅:BD[64.37372] → [17.81658:81723]

∅:BD[63.53802] → [17.81658:81723]

∅:BD[102.45996] → [17.81658:81723]

∅:BD[59.59051] → [17.81658:81723]

B:BD[17.81658] → [17.81658:81723]

∅:BD[2.18345] → [17.81820:81833]

B:BD[17.81820] → [17.81820:81833]

∅:BD[21.55499] → [17.81872:81937]

B:BD[17.81872] → [17.81872:81937]

B:BD[17.81937] → [2.18346:18424]

∅:BD[2.18424] → [17.81937:81950]

B:BD[17.81937] → [17.81937:81950]

B:BD[17.81969] → [59.59052:59071]

∅:BD[2.18444] → [17.81988:82053]

∅:BD[60.54028] → [17.81988:82053]

∅:BD[21.55540] → [17.81988:82053]

∅:BD[62.76988] → [17.81988:82053]

∅:BD[58.67298] → [17.81988:82053]

∅:BD[59.59071] → [17.81988:82053]

B:BD[17.81988] → [17.81988:82053]

B:BD[17.82053] → [2.18445:18523]

∅:BD[2.18523] → [17.82053:82070]

B:BD[17.82053] → [17.82053:82070]

B:BD[58.67378] → [58.67378:67522]

B:BD[58.67522] → [58.67522:67595]

B:BD[58.67522] → [62.77069:77142]

B:BD[58.67522] → [60.54109:54182]

∅:BD[2.18540] → [17.82366:82381]

∅:BD[60.54182] → [17.82366:82381]

∅:BD[21.55619] → [17.82366:82381]

∅:BD[62.77142] → [17.82366:82381]

∅:BD[58.67595] → [17.82366:82381]

∅:BD[59.59368] → [17.82366:82381]

B:BD[17.82366] → [17.82366:82381]

∅:BD[21.55659] → [17.82415:82480]

B:BD[17.82415] → [17.82415:82480]

B:BD[17.82480] → [2.18541:18619]

∅:BD[2.18619] → [17.82480:82493]

B:BD[17.82480] → [17.82480:82493]

B:BD[17.82508] → [59.59369:59387]

∅:BD[60.54202] → [17.82527:82592]

∅:BD[77.45453] → [17.82527:82592]

∅:BD[21.55698] → [17.82527:82592]

∅:BD[62.77162] → [17.82527:82592]

∅:BD[58.67615] → [17.82527:82592]

∅:BD[63.53822] → [17.82527:82592]

∅:BD[59.59387] → [17.82527:82592]

B:BD[17.82527] → [17.82527:82592]

B:BD[17.82592] → [2.18620:18698]

∅:BD[2.18698] → [17.82592:82609]

B:BD[17.82592] → [17.82592:82609]

∅:BD[2.18710] → [17.82688:82703]

∅:BD[77.45533] → [17.82688:82703]

∅:BD[21.55772] → [17.82688:82703]

∅:BD[58.67695] → [17.82688:82703]

∅:BD[64.37452] → [17.82688:82703]

∅:BD[63.53902] → [17.82688:82703]

∅:BD[102.46076] → [17.82688:82703]

∅:BD[59.59467] → [17.82688:82703]

B:BD[17.82688] → [17.82688:82703]

B:BD[17.82717] → [59.59468:59486]

∅:BD[21.55806] → [17.82735:82800]

∅:BD[58.67714] → [17.82735:82800]

∅:BD[59.59486] → [17.82735:82800]

B:BD[17.82735] → [17.82735:82800]

B:BD[17.82800] → [2.18711:18789]

∅:BD[2.18789] → [17.82800:82817]

B:BD[17.82800] → [17.82800:82817]

B:BD[58.67870] → [102.46077:46149]

B:BD[58.68018] → [63.53976:54049]

B:BD[58.68018] → [58.68018:68091]

B:BD[58.68018] → [62.77236:77309]

B:BD[58.68018] → [77.45607:45680]

B:BD[58.68018] → [60.54276:54349]

B:BD[58.67870] → [63.53903:53975]

B:BD[58.67870] → [64.37453:37525]

B:BD[58.67870] → [58.67870:67942]

B:BD[58.67942] → [58.67942:68018]

B:BD[58.67870] → [62.77163:77235]

B:BD[58.67870] → [77.45534:45606]

B:BD[58.67870] → [60.54203:54275]

∅:BD[2.18806] → [17.83193:83222]

∅:BD[60.54349] → [17.83193:83222]

∅:BD[77.45680] → [17.83193:83222]

∅:BD[21.55886] → [17.83193:83222]

∅:BD[62.77309] → [17.83193:83222]

∅:BD[58.68091] → [17.83193:83222]

∅:BD[63.54049] → [17.83193:83222]

∅:BD[59.59713] → [17.83193:83222]

B:BD[17.83193] → [17.83193:83222]

∅:BD[21.55905] → [58.68110:68175]

B:BD[58.68110] → [58.68110:68175]

∅:BD[2.18885] → [58.68175:68192]

B:BD[58.68175] → [58.68175:68192]

B:BD[58.68266] → [102.46150:46222]

B:BD[58.68643] → [64.37673:37751]

B:BD[60.54497] → [60.54497:54572]

B:BD[58.68950] → [63.54198:54271]

B:BD[58.68950] → [58.68950:69023]

B:BD[58.68950] → [62.77533:77606]

B:BD[58.68950] → [77.45981:46054]

B:BD[58.68950] → [60.54573:54646]

B:BD[58.68643] → [58.68643:68721]

B:BD[58.68870] → [58.68870:68950]

B:BD[58.68721] → [63.54123:54197]

B:BD[58.68721] → [58.68721:68870]

B:BD[58.68721] → [62.77383:77532]

B:BD[58.68721] → [60.54423:54497]

B:BD[77.45906] → [77.45906:45980]

B:BD[58.68643] → [77.45828:45906]

B:BD[58.68266] → [63.54050:54122]

∅:BD[2.18970] → [58.69023:69059]

∅:BD[60.54646] → [58.69023:69059]

∅:BD[77.46054] → [58.69023:69059]

∅:BD[21.56358] → [58.69023:69059]

∅:BD[62.77606] → [58.69023:69059]

∅:BD[63.54271] → [58.69023:69059]

B:BD[58.69023] → [58.69023:69059]

B:BD[58.69059] → [58.69059:69077]

B:BD[58.69059] → [21.56359:56377]

B:BD[58.68338] → [58.68338:68643]

B:BD[58.68266] → [58.68266:68338]

B:BD[58.68266] → [62.77310:77382]

B:BD[58.68266] → [60.54350:54422]

B:BD[58.68192] → [64.37526:37672]

B:BD[58.68192] → [58.68192:68266]

B:BD[58.68192] → [21.55906:56358]

B:BD[58.68192] → [77.45681:45827]

B:BD[58.68192] → [2.18886:18970]

B:BD[58.68175] → [2.18807:18885]

∅:BD[21.56377] → [17.83240:83305]

∅:BD[58.69077] → [17.83240:83305]

∅:BD[59.59732] → [17.83240:83305]

B:BD[17.83240] → [17.83240:83305]

B:BD[17.83305] → [2.18971:19049]

∅:BD[2.19049] → [17.83305:83322]

B:BD[17.83305] → [17.83305:83322]

B:BD[58.69152] → [58.69152:69228]

∅:BD[2.19085] → [17.84153:84168]

∅:BD[21.56531] → [17.84153:84168]

∅:BD[58.69228] → [17.84153:84168]

∅:BD[59.60110] → [17.84153:84168]

B:BD[17.84153] → [17.84153:84168]

B:BD[17.84454] → [17.84454:84473]

∅:BD[58.69247] → [17.84491:84556]

∅:BD[59.60129] → [17.84491:84556]

B:BD[17.84491] → [17.84491:84556]

B:BD[17.84556] → [2.19086:19164]

∅:BD[2.19164] → [17.84556:84573]

B:BD[17.84556] → [17.84556:84573]

∅:BD[2.19185] → [17.84649:84683]

∅:BD[21.56608] → [17.84649:84683]

∅:BD[58.69324] → [17.84649:84683]

∅:BD[59.60206] → [17.84649:84683]

B:BD[17.84649] → [17.84649:84683]

∅:BD[21.56627] → [58.69343:69408]

B:BD[58.69343] → [58.69343:69408]

∅:BD[2.19264] → [58.69408:69421]

B:BD[58.69408] → [58.69408:69421]

∅:BD[21.56665] → [58.69456:69521]

B:BD[58.69456] → [58.69456:69521]

∅:BD[2.19343] → [58.69521:69538]

B:BD[58.69521] → [58.69521:69538]

∅:BD[2.19358] → [58.69614:69629]

∅:BD[21.56743] → [58.69614:69629]

B:BD[58.69614] → [58.69614:69629]

∅:BD[21.56779] → [58.69667:69732]

B:BD[58.69667] → [58.69667:69732]

∅:BD[2.19437] → [58.69732:69749]

B:BD[58.69732] → [58.69732:69749]

∅:BD[2.19458] → [58.69825:69840]

∅:BD[21.56856] → [58.69825:69840]

B:BD[58.69825] → [58.69825:69840]

B:BD[58.69961] → [102.46223:46295]

B:BD[58.70109] → [63.54345:54418]

B:BD[58.69961] → [63.54272:54344]

B:BD[58.69961] → [64.37846:37918]

B:BD[58.69861] → [64.37827:37845]

B:BD[58.70197] → [58.70197:70214]

∅:BD[60.54812] → [58.70232:70297]

∅:BD[77.46314] → [58.70232:70297]

∅:BD[62.77772] → [58.70232:70297]

∅:BD[63.54437] → [58.70232:70297]

B:BD[58.70232] → [58.70232:70297]

∅:BD[2.19537] → [58.70297:70314]

B:BD[58.70297] → [58.70297:70314]

B:BD[58.70469] → [102.46296:46368]

B:BD[58.70690] → [63.54511:54584]

∅:BD[2.19626] → [58.70763:70796]

∅:BD[60.54959] → [58.70763:70796]

∅:BD[77.46461] → [58.70763:70796]

∅:BD[21.57079] → [58.70763:70796]

∅:BD[62.77919] → [58.70763:70796]

∅:BD[63.54584] → [58.70763:70796]

B:BD[58.70763] → [58.70763:70796]

∅:BD[60.54978] → [58.70814:70879]

∅:BD[21.57098] → [58.70814:70879]

∅:BD[62.77938] → [58.70814:70879]

B:BD[58.70814] → [58.70814:70879]

∅:BD[2.19705] → [58.70879:70896]

B:BD[58.70879] → [58.70879:70896]

∅:BD[2.19726] → [58.71046:71061]

∅:BD[60.55129] → [58.71046:71061]

∅:BD[21.57175] → [58.71046:71061]

∅:BD[62.78095] → [58.71046:71061]

B:BD[58.71046] → [58.71046:71061]

B:BD[58.71275] → [58.71275:71309]

B:BD[58.71061] → [58.71061:71275]

B:BD[60.55053] → [60.55053:55129]

B:BD[58.70896] → [64.37992:38066]

B:BD[58.70896] → [58.70896:71046]

B:BD[58.70896] → [62.77939:78095]

B:BD[58.70896] → [21.57099:57175]

B:BD[58.70896] → [77.46462:46536]

B:BD[58.70896] → [60.54979:55053]

B:BD[58.70896] → [2.19706:19726]

B:BD[58.70879] → [2.19627:19705]

B:BD[58.70796] → [58.70796:70814]

B:BD[58.70796] → [62.77920:77938]

B:BD[58.70796] → [21.57080:57098]

B:BD[58.70796] → [60.54960:54978]

B:BD[58.70690] → [58.70690:70763]

B:BD[58.70617] → [58.70617:70690]

B:BD[58.70690] → [62.77846:77919]

B:BD[58.70690] → [21.57006:57079]

B:BD[58.70690] → [77.46388:46461]

B:BD[58.70690] → [60.54886:54959]

B:BD[58.70469] → [63.54438:54510]

B:BD[58.70469] → [64.37919:37991]

B:BD[58.70469] → [58.70469:70541]

B:BD[58.70541] → [58.70541:70617]

B:BD[58.70469] → [62.77773:77845]

B:BD[58.70469] → [21.56857:57005]

B:BD[58.70469] → [77.46315:46387]

B:BD[58.70469] → [60.54813:54885]

B:BD[58.70314] → [58.70314:70469]

B:BD[58.70314] → [2.19538:19626]

B:BD[58.70297] → [2.19459:19537]

B:BD[58.70214] → [63.54419:54437]

B:BD[58.70214] → [58.70214:70232]

B:BD[58.70214] → [62.77754:77772]

B:BD[58.70214] → [77.46296:46314]

B:BD[58.70214] → [60.54794:54812]

B:BD[58.70182] → [58.70182:70197]

B:BD[58.70109] → [58.70109:70182]

B:BD[58.70033] → [58.70033:70109]

B:BD[58.69961] → [58.69961:70033]

B:BD[58.69879] → [58.69879:69961]

B:BD[58.69861] → [58.69861:69879]

B:BD[58.70109] → [62.77680:77753]

B:BD[58.69961] → [62.77607:77679]

B:BD[58.70109] → [77.46222:46295]

B:BD[58.69961] → [77.46149:46221]

B:BD[58.69861] → [77.46130:46148]

B:BD[58.70109] → [60.54720:54793]

B:BD[58.69961] → [60.54647:54719]

B:BD[58.69840] → [58.69840:69861]

B:BD[58.69749] → [58.69749:69825]

B:BD[58.69749] → [21.56780:56856]

B:BD[58.69749] → [2.19438:19458]

B:BD[58.69732] → [2.19359:19437]

B:BD[58.69629] → [58.69629:69667]

B:BD[58.69629] → [21.56744:56779]

B:BD[58.69538] → [58.69538:69614]

B:BD[58.69538] → [21.56666:56743]

B:BD[58.69538] → [2.19344:19358]

B:BD[58.69521] → [2.19265:19343]

B:BD[58.69421] → [58.69421:69456]

B:BD[58.69421] → [21.56628:56665]

B:BD[58.69408] → [2.19186:19264]

∅:BD[58.71309] → [17.86667:86732]

∅:BD[59.60225] → [17.86667:86732]

B:BD[17.86667] → [17.86667:86732]

∅:BD[58.71405] → [17.86827:86863]

B:BD[17.86827] → [17.86827:86863]

B:BD[17.86882] → [17.86882:87001]

∅:BD[21.57195] → [17.87001:87066]

B:BD[17.87001] → [17.87001:87066]

B:BD[17.87083] → [59.60246:60327]

B:BD[17.87083] → [63.54605:54686]

B:BD[17.87083] → [58.71426:71507]

B:BD[17.87083] → [62.78116:78197]

B:BD[17.87083] → [77.46557:46638]

B:BD[17.87083] → [60.55150:55231]

∅:BD[2.19905] → [17.87166:87194]

B:BD[17.87166] → [17.87166:87194]

∅:BD[93.63189] → [17.87212:87277]

∅:BD[60.55250] → [17.87212:87277]

∅:BD[77.46657] → [17.87212:87277]

∅:BD[65.30950] → [17.87212:87277]

∅:BD[21.57214] → [17.87212:87277]

∅:BD[62.78216] → [17.87212:87277]

∅:BD[58.71526] → [17.87212:87277]

∅:BD[64.38085] → [17.87212:87277]

∅:BD[63.54705] → [17.87212:87277]

∅:BD[102.46387] → [17.87212:87277]

∅:BD[59.60346] → [17.87212:87277]

B:BD[17.87212] → [17.87212:87277]

B:BD[17.87277] → [2.19906:19984]

∅:BD[2.19984] → [17.87277:87294]

B:BD[17.87277] → [17.87277:87294]

B:BD[60.55330] → [60.55330:55403]

B:BD[60.55403] → [63.54787:54866]

B:BD[17.87604] → [59.60579:60657]

B:BD[17.87604] → [64.38166:38244]

B:BD[17.87604] → [58.71759:71837]

B:BD[17.87604] → [77.46818:46896]

B:BD[17.87604] → [17.87604:87682]

B:BD[60.55403] → [64.38086:38165]

B:BD[60.55403] → [77.46738:46817]

B:BD[60.55403] → [60.55403:55482]

∅:BD[2.20047] → [17.87682:87719]

∅:BD[77.46896] → [17.87682:87719]

∅:BD[21.57527] → [17.87682:87719]

∅:BD[58.71837] → [17.87682:87719]

∅:BD[64.38244] → [17.87682:87719]

∅:BD[59.60657] → [17.87682:87719]

B:BD[17.87682] → [17.87682:87719]

∅:BD[60.55501] → [17.87737:87802]

∅:BD[77.46915] → [17.87737:87802]

∅:BD[21.57547] → [17.87737:87802]

∅:BD[62.78467] → [17.87737:87802]

∅:BD[58.71856] → [17.87737:87802]

∅:BD[64.38263] → [17.87737:87802]

∅:BD[63.54885] → [17.87737:87802]

∅:BD[59.60676] → [17.87737:87802]

B:BD[17.87737] → [17.87737:87802]

B:BD[17.87819] → [59.60677:60752]

B:BD[17.87819] → [58.71857:71932]

∅:BD[2.20126] → [17.87896:87933]

B:BD[17.87896] → [17.87896:87933]

∅:BD[77.46934] → [17.87951:88016]

∅:BD[21.57566] → [17.87951:88016]

∅:BD[64.38282] → [17.87951:88016]

B:BD[17.87951] → [17.87951:88016]

B:BD[17.88016] → [2.20127:20205]

∅:BD[2.20205] → [17.88016:88033]

B:BD[17.88016] → [17.88016:88033]

∅:BD[2.20223] → [17.88106:88142]

∅:BD[60.55575] → [17.88106:88142]

∅:BD[77.47008] → [17.88106:88142]

∅:BD[21.57640] → [17.88106:88142]

∅:BD[62.78541] → [17.88106:88142]

∅:BD[58.72006] → [17.88106:88142]

∅:BD[63.54959] → [17.88106:88142]

∅:BD[59.60826] → [17.88106:88142]

B:BD[17.88106] → [17.88106:88142]

∅:BD[21.57659] → [17.88160:88225]

∅:BD[58.72025] → [17.88160:88225]

∅:BD[59.60845] → [17.88160:88225]

B:BD[17.88160] → [17.88160:88225]

B:BD[17.88225] → [2.20224:20302]

∅:BD[2.20302] → [17.88225:88242]

B:BD[17.88225] → [17.88225:88242]

∅:BD[2.20332] → [17.88395:88434]

∅:BD[21.57813] → [17.88395:88434]

B:BD[17.88395] → [17.88395:88434]

∅:BD[2.20352] → [17.88453:88518]

∅:BD[60.55595] → [17.88453:88518]

∅:BD[77.47028] → [17.88453:88518]

∅:BD[21.57833] → [17.88453:88518]

∅:BD[62.78561] → [17.88453:88518]

∅:BD[58.72045] → [17.88453:88518]

∅:BD[64.38302] → [17.88453:88518]

∅:BD[63.54979] → [17.88453:88518]

∅:BD[59.60864] → [17.88453:88518]

B:BD[17.88453] → [17.88453:88518]

B:BD[17.88518] → [2.20353:20431]

∅:BD[2.20431] → [17.88518:88531]

B:BD[17.88518] → [17.88518:88531]

B:BD[17.88742] → [17.88742:88755]

∅:BD[77.47047] → [17.88773:88838]

∅:BD[21.57852] → [17.88773:88838]

∅:BD[58.72064] → [17.88773:88838]

∅:BD[64.38321] → [17.88773:88838]

∅:BD[59.60996] → [17.88773:88838]

B:BD[17.88773] → [17.88773:88838]

B:BD[17.88838] → [2.20432:20510]

∅:BD[2.20510] → [17.88838:88865]

B:BD[17.88838] → [17.88838:88865]

∅:BD[58.72083] → [17.88883:88948]

∅:BD[59.61015] → [17.88883:88948]

B:BD[17.88883] → [17.88883:88948]

B:BD[17.88948] → [2.20511:20589]

∅:BD[2.20589] → [17.88948:88965]

B:BD[17.88948] → [17.88948:88965]

B:BD[58.72158] → [58.72158:72229]

B:BD[58.72302] → [63.54980:55054]

B:BD[58.72302] → [58.72302:72376]

B:BD[58.72376] → [58.72376:72519]

B:BD[58.72302] → [62.78562:78636]

B:BD[58.72302] → [77.47048:47122]

B:BD[77.47122] → [21.57925:58068]

B:BD[58.72302] → [60.55596:55670]

B:BD[58.72229] → [58.72229:72302]

B:BD[58.72158] → [21.57853:57924]

∅:BD[2.20671] → [17.89400:89433]

∅:BD[21.58068] → [17.89400:89433]

∅:BD[58.72519] → [17.89400:89433]

∅:BD[59.61165] → [17.89400:89433]

B:BD[17.89400] → [17.89400:89433]

∅:BD[60.55690] → [17.89452:89517]

∅:BD[21.58088] → [17.89452:89517]

∅:BD[62.78656] → [17.89452:89517]

∅:BD[58.72539] → [17.89452:89517]

∅:BD[59.61185] → [17.89452:89517]

B:BD[17.89452] → [17.89452:89517]

B:BD[17.89517] → [2.20672:20750]

∅:BD[2.20750] → [17.89517:89534]

B:BD[17.89517] → [17.89517:89534]

B:BD[60.55769] → [63.55055:55128]

B:BD[60.55769] → [77.47123:47196]

B:BD[60.55769] → [60.55769:55842]

∅:BD[2.20784] → [17.89685:89687]

∅:BD[60.55842] → [17.89685:89687]

∅:BD[77.47196] → [17.89685:89687]

∅:BD[21.58240] → [17.89685:89687]

∅:BD[62.78808] → [17.89685:89687]

∅:BD[58.72691] → [17.89685:89687]

∅:BD[63.55128] → [17.89685:89687]

∅:BD[59.61337] → [17.89685:89687]

B:BD[17.89685] → [17.89685:89687]

B:BD[17.89803] → [17.89803:89844]

∅:BD[77.47215] → [17.89862:89927]

∅:BD[21.58259] → [17.89862:89927]

∅:BD[58.72710] → [17.89862:89927]

∅:BD[64.38340] → [17.89862:89927]

∅:BD[63.55147] → [17.89862:89927]

∅:BD[102.46406] → [17.89862:89927]

∅:BD[59.61356] → [17.89862:89927]

B:BD[17.89862] → [17.89862:89927]

B:BD[17.89927] → [2.20785:20863]

∅:BD[2.20863] → [17.89927:89944]

B:BD[17.89927] → [17.89927:89944]

B:BD[17.90112] → [59.61357:61518]

B:BD[17.90112] → [58.72711:72783]

B:BD[58.72783] → [58.72783:72872]

B:BD[17.90112] → [62.78809:78881]

B:BD[17.90112] → [60.55843:55915]

∅:BD[2.20957] → [17.90273:90320]

∅:BD[77.47545] → [17.90273:90320]

∅:BD[21.58664] → [17.90273:90320]

∅:BD[58.72872] → [17.90273:90320]

∅:BD[64.38670] → [17.90273:90320]

∅:BD[63.55477] → [17.90273:90320]

∅:BD[102.46736] → [17.90273:90320]

∅:BD[59.61518] → [17.90273:90320]

B:BD[17.90273] → [17.90273:90320]

∅:BD[77.47564] → [17.90338:90403]

∅:BD[21.58683] → [17.90338:90403]

∅:BD[58.72891] → [17.90338:90403]

∅:BD[64.38689] → [17.90338:90403]

∅:BD[63.55496] → [17.90338:90403]

∅:BD[102.46755] → [17.90338:90403]

∅:BD[59.61537] → [17.90338:90403]

B:BD[17.90338] → [17.90338:90403]

B:BD[17.90403] → [2.20958:21036]

∅:BD[2.21036] → [17.90403:90420]

B:BD[17.90403] → [17.90403:90420]

∅:BD[2.21070] → [17.90657:90672]

∅:BD[60.55988] → [17.90657:90672]

∅:BD[77.47651] → [17.90657:90672]

∅:BD[21.58842] → [17.90657:90672]

∅:BD[62.78954] → [17.90657:90672]

∅:BD[58.73044] → [17.90657:90672]

∅:BD[64.38927] → [17.90657:90672]

∅:BD[63.55734] → [17.90657:90672]

∅:BD[102.46842] → [17.90657:90672]

∅:BD[59.61610] → [17.90657:90672]

B:BD[17.90657] → [17.90657:90672]

B:BD[17.90672] → [17.90672:90871]

B:BD[17.90499] → [17.90499:90585]

B:BD[17.90585] → [59.61538:61610]

B:BD[17.90585] → [58.72972:73044]

B:BD[17.90585] → [62.78882:78954]

B:BD[17.90585] → [60.55916:55988]

B:BD[17.90585] → [17.90585:90657]

B:BD[17.90420] → [102.46756:46842]

B:BD[17.90420] → [63.55497:55734]

B:BD[17.90420] → [64.38690:38927]

B:BD[17.90420] → [58.72892:72971]

B:BD[17.90420] → [21.58684:58842]

B:BD[17.90420] → [77.47565:47651]

B:BD[17.90420] → [2.21037:21070]

B:BD[17.90420] → [17.90420:90499]

B:BD[17.90320] → [59.61519:61537]

B:BD[17.90320] → [102.46737:46755]

B:BD[17.90320] → [63.55478:55496]

B:BD[17.90320] → [64.38671:38689]

B:BD[17.90320] → [58.72873:72891]

B:BD[17.90320] → [21.58665:58683]

B:BD[17.90320] → [77.47546:47564]

B:BD[17.90320] → [17.90320:90338]

B:BD[17.90112] → [17.90112:90273]

B:BD[17.89944] → [102.46407:46736]

B:BD[17.89944] → [63.55148:55477]

B:BD[17.89944] → [64.38341:38670]

B:BD[17.89944] → [21.58260:58664]

B:BD[17.89944] → [77.47216:47545]

B:BD[17.89944] → [2.20864:20957]

B:BD[17.89944] → [17.89944:90112]

B:BD[17.89844] → [59.61338:61356]

B:BD[17.89844] → [102.46388:46406]

B:BD[17.89844] → [63.55129:55147]

B:BD[17.89844] → [64.38322:38340]

B:BD[17.89844] → [58.72692:72710]

B:BD[17.89844] → [21.58241:58259]

B:BD[17.89844] → [77.47197:47215]

B:BD[17.89844] → [17.89844:89862]

B:BD[17.89687] → [17.89687:89803]

B:BD[17.89534] → [59.61186:61337]

B:BD[17.89534] → [58.72540:72691]

B:BD[17.89534] → [62.78657:78808]

B:BD[17.89534] → [21.58089:58240]

B:BD[17.89534] → [60.55691:55769]

B:BD[17.89534] → [2.20751:20784]

B:BD[17.89534] → [17.89534:89685]

B:BD[17.89433] → [59.61166:61185]

B:BD[17.89433] → [58.72520:72539]

B:BD[17.89433] → [62.78637:78656]

B:BD[17.89433] → [21.58069:58088]

B:BD[17.89433] → [60.55671:55690]

B:BD[17.89433] → [17.89433:89452]

B:BD[17.88965] → [59.61016:61165]

B:BD[17.88965] → [58.72084:72158]

B:BD[17.88965] → [2.20590:20671]

B:BD[17.88965] → [17.88965:89400]

B:BD[17.88865] → [59.60997:61015]

B:BD[17.88865] → [58.72065:72083]

B:BD[17.88865] → [17.88865:88883]

B:BD[17.88755] → [59.60865:60996]

B:BD[17.88755] → [64.38303:38321]

B:BD[17.88755] → [58.72046:72064]

B:BD[17.88755] → [21.57834:57852]

B:BD[17.88755] → [77.47029:47047]

B:BD[17.88755] → [17.88755:88773]

B:BD[17.88531] → [17.88531:88742]

B:BD[17.88434] → [59.60846:60864]

B:BD[17.88434] → [63.54960:54979]

B:BD[17.88434] → [64.38283:38302]

B:BD[17.88434] → [58.72026:72045]

B:BD[17.88434] → [62.78542:78561]

B:BD[17.88434] → [21.57814:57833]

B:BD[17.88434] → [77.47009:47028]

B:BD[17.88434] → [60.55576:55595]

B:BD[17.88434] → [2.20333:20352]

B:BD[17.88434] → [17.88434:88453]

B:BD[17.88242] → [21.57660:57813]

B:BD[17.88242] → [2.20303:20332]

B:BD[17.88242] → [17.88242:88395]

B:BD[17.88142] → [59.60827:60845]

B:BD[17.88142] → [58.72007:72025]

B:BD[17.88142] → [21.57641:57659]

B:BD[17.88142] → [17.88142:88160]

B:BD[17.88033] → [59.60753:60826]

B:BD[17.88033] → [63.54886:54959]

B:BD[17.88033] → [58.71933:72006]

B:BD[17.88033] → [62.78468:78541]

B:BD[17.88033] → [21.57567:57640]

B:BD[17.88033] → [77.46935:47008]

B:BD[17.88033] → [60.55502:55575]

B:BD[17.88033] → [2.20206:20223]

B:BD[17.88033] → [17.88033:88106]

B:BD[17.87933] → [64.38264:38282]

B:BD[17.87933] → [21.57548:57566]

B:BD[17.87933] → [77.46916:46934]

B:BD[17.87933] → [17.87933:87951]

B:BD[17.87894] → [17.87894:87896]

B:BD[17.87819] → [17.87819:87894]

B:BD[17.87802] → [2.20048:20126]

B:BD[17.87802] → [17.87802:87819]

B:BD[17.87719] → [59.60658:60676]

B:BD[17.87719] → [63.54867:54885]

B:BD[17.87719] → [64.38245:38263]

B:BD[17.87719] → [58.71838:71856]

B:BD[17.87719] → [62.78449:78467]

B:BD[17.87719] → [21.57528:57547]

B:BD[17.87719] → [77.46897:46915]

B:BD[17.87719] → [60.55483:55501]

B:BD[17.87719] → [17.87719:87737]

B:BD[17.87525] → [17.87525:87604]

B:BD[17.87294] → [59.60347:60578]

B:BD[17.87294] → [63.54706:54786]

B:BD[17.87294] → [58.71527:71758]

B:BD[17.87294] → [62.78217:78448]

B:BD[17.87294] → [21.57215:57527]

B:BD[17.87294] → [77.46658:46737]

B:BD[17.87294] → [60.55251:55330]

B:BD[17.87294] → [2.19985:20047]

B:BD[17.87294] → [17.87294:87525]

B:BD[17.87194] → [59.60328:60346]

B:BD[17.87194] → [102.46369:46387]

B:BD[17.87194] → [63.54687:54705]

B:BD[17.87194] → [64.38067:38085]

B:BD[17.87194] → [58.71508:71526]

B:BD[17.87194] → [62.78198:78216]

B:BD[17.87194] → [21.57196:57214]

B:BD[17.87194] → [65.30932:30950]

B:BD[17.87194] → [77.46639:46657]

B:BD[17.87194] → [60.55232:55250]

B:BD[17.87194] → [17.87194:87212]

B:BD[17.87194] → [93.63171:63189]

B:BD[17.87164] → [17.87164:87166]

B:BD[17.87083] → [17.87083:87164]

B:BD[17.87066] → [2.19827:19905]

B:BD[17.87066] → [17.87066:87083]

B:BD[17.86863] → [59.60226:60245]

B:BD[17.86863] → [63.54585:54604]

B:BD[17.86863] → [58.71406:71425]

B:BD[17.86863] → [62.78096:78115]

B:BD[17.86863] → [21.57176:57195]

B:BD[17.86863] → [77.46537:46556]

B:BD[17.86863] → [60.55130:55149]

B:BD[17.86863] → [17.86863:86882]

∅:BD[2.19805] → [58.71310:71327]

B:BD[17.86732] → [58.71310:71327]

∅:BD[2.19826] → [58.71403:71405]

B:BD[58.71403] → [58.71403:71405]

B:BD[58.71327] → [58.71327:71403]

B:BD[58.71327] → [2.19806:19826]

B:BD[17.86732] → [2.19727:19805]

B:BD[17.86732] → [17.86732:86827]

B:BD[17.84683] → [59.60207:60225]

B:BD[17.84683] → [58.69325:69343]

B:BD[17.84683] → [21.56609:56627]

B:BD[17.84683] → [17.84683:86667]

B:BD[17.84573] → [59.60130:60206]

B:BD[17.84573] → [58.69248:69324]

B:BD[17.84573] → [21.56532:56608]

B:BD[17.84573] → [2.19165:19185]

B:BD[17.84573] → [17.84573:84649]

B:BD[17.84473] → [59.60111:60129]

B:BD[17.84473] → [58.69229:69247]

B:BD[17.84473] → [17.84473:84491]

B:BD[17.84168] → [17.84168:84454]

B:BD[17.83322] → [59.59733:60110]

B:BD[17.83322] → [64.37752:37826]

B:BD[17.83322] → [58.69078:69152]

B:BD[17.83322] → [21.56378:56531]

B:BD[17.83322] → [77.46055:46129]

B:BD[17.83322] → [2.19050:19085]

B:BD[17.83322] → [17.83322:84153]

B:BD[17.83222] → [59.59714:59732]

B:BD[17.83222] → [58.68092:68110]

B:BD[17.83222] → [21.55887:55905]

B:BD[17.83222] → [17.83222:83240]

B:BD[17.82817] → [59.59487:59713]

B:BD[17.82817] → [58.67715:67870]

B:BD[17.82817] → [21.55807:55886]

B:BD[17.82817] → [2.18790:18806]

B:BD[17.82817] → [17.82817:83193]

B:BD[17.82717] → [58.67696:67714]

B:BD[17.82717] → [17.82717:82735]

B:BD[17.82703] → [21.55773:55806]

B:BD[17.82703] → [17.82703:82717]

B:BD[17.82609] → [59.59388:59467]

B:BD[17.82609] → [102.45997:46076]

B:BD[17.82609] → [63.53823:53902]

B:BD[17.82609] → [64.37373:37452]

B:BD[17.82609] → [58.67616:67695]

B:BD[17.82609] → [21.55699:55772]

B:BD[17.82609] → [77.45454:45533]

B:BD[17.82609] → [2.18699:18710]

B:BD[17.82609] → [17.82609:82688]

B:BD[17.82508] → [63.53803:53822]

B:BD[17.82508] → [58.67596:67615]

B:BD[17.82508] → [62.77143:77162]

B:BD[17.82508] → [77.45434:45453]

B:BD[17.82508] → [60.54183:54202]

B:BD[17.82508] → [17.82508:82527]

B:BD[17.82493] → [21.55660:55698]

B:BD[17.82493] → [17.82493:82508]

B:BD[17.82381] → [21.55620:55659]

B:BD[17.82381] → [17.82381:82415]

B:BD[17.82070] → [59.59072:59368]

B:BD[17.82070] → [58.67299:67378]

B:BD[17.82070] → [62.76989:77068]

B:BD[17.82070] → [21.55541:55619]

B:BD[17.82070] → [60.54029:54108]

B:BD[17.82070] → [2.18524:18540]

B:BD[17.82070] → [17.82070:82366]

B:BD[17.81969] → [58.67279:67298]

B:BD[17.81969] → [62.76969:76988]

B:BD[17.81969] → [60.54009:54028]

B:BD[17.81969] → [17.81969:81988]

B:BD[17.81950] → [21.55500:55521]

B:BD[21.55521] → [21.55521:55540]

B:BD[21.55521] → [2.18425:18444]

B:BD[17.81950] → [17.81950:81969]

B:BD[17.81833] → [21.55454:55499]

B:BD[17.81833] → [17.81833:81872]

B:BD[17.81723] → [2.18267:18345]

B:BD[17.81723] → [17.81723:81820]

B:BD[17.81639] → [102.45977:45996]

B:BD[17.81639] → [63.53783:53802]

B:BD[17.81639] → [64.37353:37372]

B:BD[17.81639] → [58.67259:67278]

B:BD[17.81639] → [77.45414:45433]

B:BD[17.81639] → [17.81639:81658]

B:BD[17.81618] → [21.55409:55453]

B:BD[17.81618] → [17.81618:81639]

B:BD[17.81399] → [21.55273:55357]

∅:BD[2.18108] → [21.55357:55408]

B:BD[21.55357] → [21.55357:55408]

B:BD[21.55357] → [2.18030:18108]

B:BD[17.81399] → [17.81399:81418]

∅:BD[2.17950] → [21.55157:55272]

B:BD[17.81271] → [21.55157:55272]

B:BD[21.55272] → [2.17951:18029]

B:BD[17.81271] → [2.17872:17950]

B:BD[17.81271] → [17.81271:81366]

B:BD[17.81187] → [58.67239:67258]

B:BD[17.81187] → [17.81187:81206]

B:BD[17.81167] → [21.55112:55138]

B:BD[21.55138] → [21.55138:55156]

B:BD[21.55138] → [2.17852:17871]

B:BD[17.81167] → [17.81167:81187]

B:BD[17.81003] → [59.58862:59011]

B:BD[17.81003] → [58.67089:67238]

B:BD[17.81003] → [21.54889:55111]

B:BD[17.81003] → [2.17817:17851]

B:BD[17.81003] → [17.81003:81152]

B:BD[17.80902] → [58.67069:67088]

B:BD[17.80902] → [17.80902:80921]

B:BD[17.80879] → [21.54839:54869]

B:BD[21.54869] → [21.54869:54888]

B:BD[21.54869] → [2.17718:17737]

B:BD[17.80879] → [17.80879:80902]

B:BD[17.80705] → [59.58682:58841]

B:BD[17.80705] → [58.66909:67068]

B:BD[17.80705] → [21.54750:54838]

B:BD[17.80705] → [2.17692:17717]

B:BD[17.80705] → [17.80705:80864]

B:BD[17.80604] → [58.66889:66908]

B:BD[17.80604] → [17.80604:80623]

B:BD[17.80583] → [21.54709:54730]

B:BD[21.54730] → [21.54730:54749]

B:BD[21.54730] → [2.17593:17612]

B:BD[17.80583] → [17.80583:80604]

B:BD[17.80490] → [59.58583:58661]

B:BD[17.80490] → [58.66810:66888]

B:BD[17.80490] → [21.54632:54708]

B:BD[17.80490] → [2.17578:17592]

B:BD[17.80490] → [17.80490:80568]

B:BD[17.80389] → [58.66790:66809]

B:BD[17.80389] → [17.80389:80408]

B:BD[17.80376] → [21.54593:54631]

B:BD[17.80376] → [17.80376:80389]

B:BD[17.80254] → [21.54383:54424]

B:BD[17.80254] → [17.80254:80298]

B:BD[58.66636] → [64.37276:37352]

B:BD[58.66636] → [58.66636:66712]

B:BD[58.66636] → [21.54225:54382]

B:BD[58.66636] → [77.45337:45413]

B:BD[58.66636] → [2.17361:17394]

B:BD[58.66619] → [2.17282:17360]

B:BD[58.66520] → [58.66520:66554]

B:BD[58.66520] → [21.54185:54224]

B:BD[58.66285] → [58.66285:66356]

B:BD[17.79807] → [59.58414:58562]

B:BD[17.79807] → [64.37200:37275]

B:BD[17.79807] → [58.66357:66505]

B:BD[17.79807] → [62.76820:76968]

B:BD[77.45263] → [77.45263:45336]

B:BD[17.79807] → [77.45187:45263]

B:BD[17.79807] → [60.53860:53935]

B:BD[60.53935] → [63.53709:53782]

B:BD[60.53935] → [60.53935:54008]

B:BD[17.79807] → [17.79807:80239]

B:BD[17.79727] → [17.79727:79807]

B:BD[17.79584] → [59.58270:58413]

B:BD[17.79584] → [102.45904:45976]

B:BD[17.79584] → [63.53636:53708]

B:BD[17.79584] → [64.37127:37199]

B:BD[17.79584] → [58.66213:66285]

B:BD[17.79584] → [62.76747:76819]

B:BD[17.79584] → [21.54107:54184]

B:BD[17.79584] → [77.45114:45186]

B:BD[17.79584] → [60.53787:53859]

B:BD[17.79584] → [2.17266:17281]

B:BD[17.79584] → [17.79584:79727]

B:BD[17.79484] → [17.79484:79502]

B:BD[17.79458] → [21.54075:54106]

B:BD[17.79458] → [17.79458:79484]

B:BD[17.79443] → [17.79443:79445]

B:BD[17.79285] → [17.79285:79443]

B:BD[17.79268] → [2.17108:17186]

B:BD[17.79268] → [17.79268:79285]

B:BD[17.79185] → [58.66016:66034]

B:BD[17.79185] → [17.79185:79203]

B:BD[17.79164] → [21.54030:54074]

B:BD[17.79164] → [17.79164:79185]

B:BD[17.79064] → [21.53876:54029]

B:BD[17.79064] → [2.17072:17107]

B:BD[17.79064] → [17.79064:79149]

B:BD[17.78964] → [58.65997:66015]

B:BD[17.78964] → [17.78964:78982]

B:BD[17.78944] → [21.53841:53875]

B:BD[17.78944] → [17.78944:78964]

B:BD[17.78699] → [17.78699:78777]

B:BD[17.78557] → [59.57911:58053]

B:BD[17.78557] → [63.53493:53635]

B:BD[17.78557] → [64.36903:37045]

B:BD[17.78557] → [58.65773:65915]

B:BD[17.78557] → [62.76604:76746]

B:BD[17.78557] → [21.53473:53840]

B:BD[17.78557] → [77.44897:45113]

B:BD[17.78557] → [60.53563:53633]

B:BD[17.78557] → [2.16939:16992]

B:BD[17.78557] → [17.78557:78699]

B:BD[17.78456] → [59.57891:57910]

B:BD[17.78456] → [63.53473:53492]

B:BD[17.78456] → [64.36883:36902]

B:BD[17.78456] → [58.65753:65772]

B:BD[17.78456] → [62.76584:76603]

B:BD[17.78456] → [21.53453:53472]

B:BD[17.78456] → [77.44877:44896]

B:BD[17.78456] → [60.53543:53562]

B:BD[17.78456] → [17.78456:78475]

B:BD[17.78072] → [17.78072:78301]

B:BD[17.77919] → [63.53247:53320]

B:BD[17.77919] → [58.65449:65522]

B:BD[17.77919] → [62.76280:76353]

B:BD[17.77919] → [60.53239:53312]

B:BD[17.77992] → [17.77992:78072]

B:BD[17.77919] → [17.77919:77992]

B:BD[17.77844] → [64.36582:36730]

B:BD[17.77844] → [21.53073:53222]

B:BD[17.77844] → [77.44576:44724]

B:BD[17.77844] → [2.16697:16780]

B:BD[17.77844] → [17.77844:77919]

B:BD[17.77742] → [59.57566:57586]

B:BD[17.77742] → [63.53226:53246]

B:BD[17.77742] → [64.36561:36581]

B:BD[17.77742] → [58.65428:65448]

B:BD[17.77742] → [62.76259:76279]

B:BD[17.77742] → [21.53052:53072]

B:BD[17.77742] → [77.44555:44575]

B:BD[17.77742] → [60.53218:53238]

B:BD[17.77742] → [17.77742:77762]

B:BD[17.77594] → [58.65309:65322]

B:BD[17.77594] → [77.44442:44455]

B:BD[77.44455] → [21.52804:52904]

∅:BD[2.16262] → [21.52904:53019]

B:BD[21.52904] → [21.52904:53019]

∅:BD[2.16341] → [21.53019:53032]

B:BD[21.53019] → [21.53019:53032]

B:BD[21.53019] → [2.16263:16341]

B:BD[21.52904] → [2.16184:16262]

B:BD[77.44455] → [77.44455:44554]

B:BD[17.77594] → [17.77594:77712]

B:BD[17.77520] → [59.57493:57565]

B:BD[17.77520] → [102.45572:45644]

B:BD[17.77520] → [63.53153:53225]

B:BD[17.77520] → [64.36488:36560]

B:BD[17.77520] → [58.65236:65308]

B:BD[17.77520] → [62.76186:76258]

B:BD[17.77520] → [21.52653:52803]

B:BD[17.77520] → [77.44369:44441]

B:BD[17.77520] → [60.53145:53217]

B:BD[17.77520] → [2.16159:16183]

B:BD[17.77520] → [17.77520:77592]

B:BD[17.77419] → [59.57474:57492]

B:BD[17.77419] → [64.36468:36487]

B:BD[17.77419] → [58.65216:65235]

B:BD[17.77419] → [62.76167:76185]

B:BD[17.77419] → [21.52633:52652]

B:BD[17.77419] → [77.44349:44368]

B:BD[17.77419] → [60.53125:53144]

B:BD[17.77419] → [17.77419:77438]

B:BD[17.77305] → [64.36449:36467]

B:BD[17.77305] → [21.52519:52538]

B:BD[17.77305] → [77.44236:44254]

B:BD[17.77305] → [17.77305:77323]

B:BD[17.77193] → [64.36371:36448]

B:BD[17.77193] → [21.52366:52518]

B:BD[17.77193] → [77.44084:44235]

B:BD[17.77193] → [2.15960:15987]

B:BD[17.77193] → [17.77193:77270]

B:BD[17.77092] → [64.36351:36370]

B:BD[17.77092] → [21.52346:52365]

B:BD[17.77092] → [77.44064:44083]

B:BD[17.77092] → [17.77092:77111]

B:BD[17.76993] → [17.76993:77071]

B:BD[17.76974] → [17.76974:76993]

B:BD[17.76958] → [17.76958:76974]

B:BD[17.76862] → [59.57337:57355]

B:BD[17.76862] → [58.65177:65195]

B:BD[17.76862] → [62.76050:76068]

B:BD[17.76862] → [21.52327:52345]

B:BD[17.76862] → [60.53106:53124]

B:BD[17.76862] → [17.76862:76880]

B:BD[17.76598] → [59.57118:57336]

B:BD[17.76598] → [63.52934:53152]

B:BD[17.76598] → [64.36205:36350]

B:BD[17.76598] → [58.64958:65176]

B:BD[17.76598] → [62.75831:76049]

B:BD[17.76598] → [21.52107:52326]

B:BD[17.76598] → [77.43845:43990]

B:BD[17.76598] → [60.52887:52960]

B:BD[17.76598] → [2.15764:15801]

B:BD[17.76598] → [17.76598:76816]

B:BD[17.76497] → [21.52087:52106]

B:BD[17.76497] → [17.76497:76516]

B:BD[17.76064] → [17.76064:76468]

B:BD[58.64476] → [64.35798:35874]

B:BD[58.64476] → [58.64476:64552]

B:BD[58.64476] → [62.75522:75598]

B:BD[58.64476] → [77.43438:43514]

B:BD[58.64476] → [60.52578:52654]

B:BD[60.52505] → [63.52529:52601]

B:BD[60.52505] → [64.35725:35797]

B:BD[58.64406] → [58.64406:64476]

B:BD[60.52505] → [77.43365:43437]

B:BD[60.52505] → [60.52505:52577]

B:BD[17.75984] → [17.75984:76064]

B:BD[17.75688] → [59.56416:56712]

B:BD[17.75688] → [58.64256:64406]

B:BD[17.75688] → [62.75371:75521]

B:BD[17.75688] → [21.51384:51681]

B:BD[17.75688] → [60.52427:52505]

B:BD[17.75688] → [2.15529:15684]

B:BD[17.75688] → [17.75688:75984]

B:BD[17.75588] → [102.45232:45250]

B:BD[17.75588] → [63.52510:52528]

B:BD[17.75588] → [64.35706:35724]

B:BD[17.75588] → [21.51365:51383]

B:BD[17.75588] → [77.43346:43364]

B:BD[17.75588] → [17.75588:75606]

B:BD[17.75331] → [17.75331:75403]

B:BD[17.75403] → [17.75403:75553]

B:BD[17.75252] → [2.15391:15449]

B:BD[17.75252] → [17.75252:75331]

B:BD[17.74980] → [17.74980:75052]

B:BD[17.75052] → [17.75052:75123]

B:BD[17.74908] → [21.51076:51291]

B:BD[17.74908] → [2.15284:15311]

B:BD[17.74908] → [17.74908:74980]

B:BD[17.74808] → [21.51057:51075]

B:BD[17.74808] → [17.74808:74826]

B:BD[17.74560] → [17.74560:74632]

B:BD[17.74632] → [59.56271:56342]

B:BD[17.74632] → [58.64111:64182]

B:BD[17.74632] → [17.74632:74703]

B:BD[17.74272] → [64.35414:35561]

B:BD[17.74489] → [17.74489:74560]

B:BD[17.74272] → [58.63893:63968]

B:BD[58.64040] → [58.64040:64110]

B:BD[58.63968] → [102.45086:45158]

B:BD[58.63968] → [63.52364:52436]

B:BD[58.63968] → [58.63968:64040]

B:BD[58.63968] → [62.75225:75297]

B:BD[58.63968] → [60.52281:52353]

B:BD[17.74272] → [21.50840:50983]

B:BD[17.74272] → [77.43129:43201]

B:BD[17.74272] → [17.74272:74489]

B:BD[17.74121] → [17.74121:74193]

B:BD[17.74193] → [17.74193:74272]

B:BD[17.73955] → [2.15063:15204]

B:BD[17.73955] → [17.73955:74121]

B:BD[17.73854] → [64.35394:35413]

B:BD[17.73854] → [21.50672:50691]

B:BD[17.73854] → [77.43109:43128]

B:BD[17.73854] → [17.73854:73873]

B:BD[17.73594] → [59.55820:56052]

B:BD[17.73594] → [58.63660:63815]

B:BD[17.73594] → [21.50599:50671]

B:BD[17.73594] → [2.14961:14983]

B:BD[17.73594] → [17.73594:73826]

B:BD[17.73493] → [58.63640:63659]

B:BD[17.73493] → [17.73493:73512]

B:BD[17.73476] → [21.50559:50580]

B:BD[21.50580] → [21.50580:50598]

B:BD[21.50580] → [2.14863:14881]

B:BD[17.73476] → [17.73476:73493]

B:BD[17.73361] → [21.50335:50371]

∅:BD[2.14847] → [21.50462:50479]

B:BD[21.50462] → [21.50462:50479]

∅:BD[2.14862] → [21.50556:50558]

B:BD[21.50556] → [21.50556:50558]

B:BD[21.50479] → [21.50479:50556]

B:BD[21.50479] → [2.14848:14862]

B:BD[21.50371] → [21.50371:50462]

B:BD[21.50371] → [2.14744:14847]

B:BD[17.73361] → [17.73361:73463]

B:BD[17.73265] → [59.55537:55555]

B:BD[17.73265] → [58.63621:63639]

B:BD[17.73265] → [62.74963:74981]

B:BD[17.73265] → [21.50316:50334]

B:BD[17.73265] → [60.52184:52202]

B:BD[17.73265] → [17.73265:73283]

B:BD[17.73047] → [17.73047:73121]

B:BD[58.63314] → [64.35240:35393]

B:BD[17.73047] → [58.63546:63620]

B:BD[58.63314] → [58.63314:63545]

B:BD[58.63314] → [62.74731:74962]

B:BD[58.63314] → [77.42955:43108]

B:BD[58.63314] → [60.51952:52105]

B:BD[60.52105] → [60.52105:52183]

B:BD[17.72881] → [17.72881:73047]

B:BD[17.72500] → [59.55080:55461]

B:BD[17.72500] → [58.63164:63314]

B:BD[17.72500] → [21.49581:50199]

B:BD[17.72500] → [2.14378:14506]

B:BD[17.72500] → [17.72500:72881]

B:BD[17.72400] → [59.55061:55079]

B:BD[17.72400] → [58.63145:63163]

B:BD[17.72400] → [21.49561:49580]

B:BD[17.72400] → [17.72400:72418]

B:BD[17.72173] → [59.54978:55060]

B:BD[17.72173] → [63.52127:52209]

B:BD[17.72173] → [58.63062:63144]

B:BD[17.72173] → [62.74648:74730]

B:BD[17.72173] → [21.49478:49560]

B:BD[17.72173] → [77.42872:42954]

B:BD[17.72173] → [60.51869:51951]

B:BD[17.72173] → [2.14199:14219]

B:BD[17.72173] → [17.72173:72255]

B:BD[17.72073] → [59.54959:54977]

B:BD[17.72073] → [63.52108:52126]

B:BD[17.72073] → [58.63043:63061]

B:BD[17.72073] → [62.74629:74647]

B:BD[17.72073] → [77.42853:42871]

B:BD[17.72073] → [60.51850:51868]

B:BD[17.72073] → [17.72073:72091]

B:BD[59.54885] → [59.54885:54958]

B:BD[59.54885] → [63.52034:52107]

B:BD[59.54885] → [64.35166:35239]

B:BD[59.54885] → [58.62969:63042]

B:BD[59.54885] → [62.74555:74628]

B:BD[59.54885] → [21.49403:49477]

B:BD[59.54885] → [77.42779:42852]

B:BD[59.54885] → [60.51776:51849]

B:BD[59.54885] → [2.14108:14119]

B:BD[59.54868] → [2.14029:14107]

B:BD[59.54785] → [59.54785:54803]

B:BD[59.54785] → [58.62950:62968]

B:BD[59.54785] → [21.49383:49402]

B:BD[59.54757] → [59.54757:54759]

B:BD[17.71966] → [59.54687:54757]

B:BD[17.71966] → [17.71966:72039]

B:BD[17.71884] → [17.71884:71966]

B:BD[17.71866] → [59.54668:54686]

B:BD[17.71866] → [17.71866:71884]

B:BD[17.71761] → [17.71761:71838]

B:BD[17.71684] → [17.71684:71761]

B:BD[17.71667] → [2.13950:14028]

B:BD[17.71667] → [17.71667:71684]

B:BD[17.71584] → [59.54571:54589]

B:BD[17.71584] → [58.62853:62871]

B:BD[17.71584] → [17.71584:71602]

B:BD[17.71470] → [59.54552:54570]

B:BD[17.71470] → [63.52015:52033]

B:BD[17.71470] → [58.62834:62852]

B:BD[17.71470] → [62.74536:74554]

B:BD[17.71470] → [21.49364:49382]

B:BD[17.71470] → [77.42760:42778]

B:BD[17.71470] → [60.51757:51775]

B:BD[17.71470] → [17.71470:71488]

B:BD[17.71348] → [59.54532:54551]

B:BD[17.71348] → [102.45066:45085]

B:BD[17.71348] → [63.51995:52014]

B:BD[17.71348] → [64.35146:35165]

B:BD[17.71348] → [58.62814:62833]

B:BD[17.71348] → [62.74516:74535]

B:BD[17.71348] → [21.49344:49363]

B:BD[17.71348] → [77.42740:42759]

B:BD[17.71348] → [60.51737:51756]

B:BD[17.71348] → [2.13851:13870]

B:BD[17.71348] → [17.71348:71367]

B:BD[17.71256] → [17.71256:71334]

B:BD[17.71238] → [17.71238:71256]

B:BD[17.71220] → [17.71220:71238]

B:BD[17.71124] → [59.54394:54412]

B:BD[17.71124] → [58.62776:62794]

B:BD[17.71124] → [62.74497:74515]

B:BD[17.71124] → [21.49325:49343]

B:BD[17.71124] → [60.51718:51736]

B:BD[17.71124] → [17.71124:71142]

B:BD[17.70936] → [2.13737:13771]

B:BD[17.70936] → [17.70936:71088]

B:BD[17.70457] → [59.54164:54393]

B:BD[17.70457] → [58.62545:62775]

B:BD[17.70457] → [21.49264:49324]

B:BD[17.70457] → [2.13566:13578]

B:BD[17.70457] → [17.70457:70687]

B:BD[17.70357] → [59.54145:54163]

B:BD[17.70357] → [58.62526:62544]

B:BD[17.70357] → [21.49245:49263]

B:BD[17.70357] → [17.70357:70375]

B:BD[17.70248] → [64.35012:35030]

B:BD[17.70248] → [21.49226:49244]

B:BD[17.70248] → [77.42721:42739]

B:BD[17.70248] → [17.70248:70266]

B:BD[17.69922] → [17.69922:69996]

B:BD[17.69996] → [17.69996:70073]

B:BD[17.69844] → [21.48927:49225]

B:BD[17.69844] → [2.13352:13407]

B:BD[17.69844] → [17.69844:69922]

B:BD[17.69744] → [59.54052:54070]

B:BD[17.69744] → [58.62433:62451]

B:BD[17.69744] → [21.48908:48926]

B:BD[17.69744] → [17.69744:69762]

B:BD[17.69638] → [17.69638:69711]

B:BD[17.69566] → [59.53979:54051]

B:BD[17.69566] → [102.44993:45065]

B:BD[17.69566] → [63.51848:51920]

B:BD[17.69566] → [64.34864:34936]

B:BD[17.69566] → [58.62360:62432]

B:BD[17.69566] → [62.74350:74422]

B:BD[17.69566] → [21.48835:48907]

B:BD[17.69566] → [77.42499:42571]

B:BD[17.69566] → [60.51571:51643]

B:BD[17.69566] → [2.13263:13272]

B:BD[17.69566] → [17.69566:69638]

B:BD[17.69466] → [21.48816:48834]

B:BD[17.69466] → [17.69466:69484]

B:BD[17.69355] → [21.48627:48645]

B:BD[17.69355] → [17.69355:69373]

B:BD[17.69234] → [58.62271:62359]

B:BD[17.69234] → [21.48537:48626]

B:BD[17.69234] → [17.69234:69322]

B:BD[17.69081] → [2.13022:13077]

B:BD[17.69081] → [17.69081:69234]

B:BD[17.68981] → [21.48518:48536]

B:BD[17.68981] → [17.68981:68999]

B:BD[17.67596] → [17.67596:67678]

B:BD[17.67448] → [59.52907:53055]

B:BD[17.67448] → [63.51316:51464]

B:BD[17.67448] → [58.61206:61354]

B:BD[17.67448] → [62.73662:73810]

B:BD[17.67448] → [21.47318:48517]

B:BD[17.67448] → [77.41664:41737]

B:BD[17.67448] → [60.50802:50950]

B:BD[17.67448] → [2.12736:12942]

B:BD[17.67448] → [17.67448:67596]

B:BD[17.67346] → [59.52886:52906]

B:BD[17.67346] → [63.51295:51315]

B:BD[17.67346] → [64.34386:34406]

B:BD[17.67346] → [58.61185:61205]

B:BD[17.67346] → [62.73641:73661]

B:BD[17.67346] → [21.47298:47317]

B:BD[17.67346] → [77.41643:41663]

B:BD[17.67346] → [60.50781:50801]

B:BD[17.67346] → [2.12637:12656]

B:BD[17.67346] → [17.67346:67366]

B:BD[17.67238] → [21.47219:47297]

B:BD[17.67238] → [2.12620:12636]

B:BD[17.67238] → [17.67238:67316]

B:BD[17.67138] → [59.52867:52885]

B:BD[17.67138] → [58.61166:61184]

B:BD[17.67138] → [21.47200:47218]

B:BD[17.67138] → [17.67138:67156]

B:BD[17.67023] → [21.47181:47199]

B:BD[21.47199] → [2.12269:12461]

B:BD[17.67023] → [17.67023:67041]

B:BD[17.66990] → [17.66990:67005]

B:BD[77.41227] → [77.41227:41642]

B:BD[17.66849] → [17.66849:66919]

B:BD[17.66919] → [64.34314:34385]

B:BD[17.66919] → [77.41141:41212]

B:BD[17.66919] → [17.66919:66990]

B:BD[17.66776] → [59.52793:52866]

B:BD[17.66776] → [63.51221:51294]

B:BD[17.66776] → [58.61092:61165]

B:BD[17.66776] → [62.73567:73640]

B:BD[17.66776] → [21.47037:47180]

B:BD[17.66776] → [77.41067:41140]

B:BD[17.66776] → [60.50707:50780]

B:BD[17.66776] → [2.12249:12268]

B:BD[17.66776] → [17.66776:66849]

B:BD[17.66675] → [59.52773:52792]

B:BD[17.66675] → [63.51201:51220]

B:BD[17.66675] → [58.61072:61091]

B:BD[17.66675] → [62.73547:73566]

B:BD[17.66675] → [21.46671:46754]

∅:BD[2.12141] → [21.46754:46771]

B:BD[21.46754] → [21.46754:46771]

∅:BD[2.12169] → [21.46984:47036]

B:BD[21.46984] → [21.46984:47036]

B:BD[21.46771] → [21.46771:46984]

B:BD[21.46771] → [2.12142:12169]

B:BD[21.46754] → [2.12063:12141]

B:BD[17.66675] → [77.41047:41066]

B:BD[17.66675] → [60.50687:50706]

B:BD[17.66675] → [17.66675:66694]

B:BD[17.66572] → [17.66572:66646]

B:BD[17.66500] → [59.52700:52772]

B:BD[17.66500] → [102.44761:44833]

B:BD[17.66500] → [63.51128:51200]

B:BD[17.66500] → [64.34241:34313]

B:BD[17.66500] → [58.60999:61071]

B:BD[17.66500] → [62.73474:73546]

B:BD[17.66500] → [21.46449:46670]

B:BD[17.66500] → [77.40974:41046]

B:BD[17.66500] → [60.50614:50686]

B:BD[17.66500] → [2.12022:12062]

B:BD[17.66500] → [17.66500:66572]

B:BD[17.66400] → [21.46430:46448]

B:BD[17.66400] → [17.66400:66418]

B:BD[17.66103] → [17.66103:66382]

B:BD[17.65798] → [58.60429:60499]

B:BD[58.60570] → [64.34167:34240]

∅:BD[2.11824] → [58.60719:60748]

∅:BD[60.50613] → [58.60719:60748]

∅:BD[21.46336] → [58.60719:60748]

∅:BD[62.73473] → [58.60719:60748]

B:BD[58.60719] → [58.60719:60748]

∅:BD[21.46355] → [58.60766:60831]

B:BD[58.60766] → [58.60766:60831]

∅:BD[2.11903] → [58.60831:60848]

B:BD[58.60831] → [58.60831:60848]

B:BD[58.60925] → [58.60925:60998]

B:BD[58.60925] → [21.46356:46429]

B:BD[58.60848] → [58.60848:60925]

B:BD[58.60848] → [2.11904:11942]

B:BD[58.60831] → [2.11825:11903]

B:BD[58.60748] → [58.60748:60766]

B:BD[58.60748] → [21.46337:46355]

B:BD[58.60570] → [58.60570:60643]

B:BD[58.60643] → [58.60643:60719]

B:BD[58.60643] → [62.73397:73473]

B:BD[58.60643] → [60.50537:50613]

∅:BD[2.11512] → [21.45797:45831]

B:BD[21.45797] → [21.45797:45831]

∅:BD[2.11531] → [21.45849:45914]

B:BD[21.45849] → [21.45849:45914]

∅:BD[2.11610] → [21.45914:46024]

B:BD[21.45914] → [21.45914:46024]

∅:BD[2.11689] → [21.46024:46041]

B:BD[21.46024] → [21.46024:46041]

∅:BD[2.11715] → [21.46128:46163]

B:BD[21.46128] → [21.46128:46163]

∅:BD[2.11735] → [21.46182:46247]

B:BD[21.46182] → [21.46182:46247]

∅:BD[2.11814] → [21.46247:46264]

B:BD[21.46247] → [21.46247:46264]

B:BD[21.46264] → [21.46264:46336]

B:BD[21.46264] → [2.11815:11824]

B:BD[21.46247] → [2.11736:11814]

B:BD[21.46163] → [21.46163:46182]

B:BD[21.46163] → [2.11716:11735]

B:BD[21.46041] → [21.46041:46128]

B:BD[21.46041] → [2.11690:11715]

B:BD[21.46024] → [2.11611:11689]

B:BD[21.45914] → [2.11532:11610]

B:BD[21.45831] → [21.45831:45849]

B:BD[21.45831] → [2.11513:11531]

B:BD[58.60570] → [21.45572:45797]

B:BD[58.60570] → [77.40900:40973]

B:BD[17.65798] → [17.65798:66088]

B:BD[17.65576] → [63.50980:51127]

B:BD[17.65576] → [64.34091:34166]

B:BD[17.65723] → [17.65723:65798]

B:BD[17.65576] → [58.60281:60428]

B:BD[17.65576] → [62.73249:73396]

B:BD[77.40827] → [77.40827:40899]

B:BD[17.65576] → [77.40752:40827]

B:BD[17.65576] → [60.50389:50536]

B:BD[17.65576] → [17.65576:65723]

B:BD[58.60499] → [58.60499:60570]

B:BD[58.60207] → [58.60207:60280]

B:BD[58.60207] → [62.73175:73248]

B:BD[77.40678] → [77.40678:40751]

B:BD[58.60207] → [60.50315:50388]

B:BD[17.65506] → [17.65506:65576]

B:BD[17.65357] → [59.52111:52260]

B:BD[17.65357] → [64.34014:34090]

B:BD[17.65357] → [58.60131:60207]

B:BD[17.65357] → [21.45046:45571]

B:BD[17.65357] → [77.40602:40678]

B:BD[17.65357] → [2.11375:11512]

B:BD[17.65357] → [17.65357:65506]

B:BD[17.65256] → [59.52091:52110]

B:BD[17.65256] → [63.50886:50905]

B:BD[17.65256] → [64.33994:34013]

B:BD[17.65256] → [58.60111:60130]

B:BD[17.65256] → [62.73155:73174]

B:BD[17.65256] → [21.45027:45045]

B:BD[17.65256] → [77.40582:40601]

B:BD[17.65256] → [60.50295:50314]

B:BD[17.65256] → [17.65256:65275]

B:BD[17.65154] → [21.44673:44913]

B:BD[17.65154] → [2.11158:11216]

B:BD[17.65154] → [17.65154:65229]

B:BD[17.65053] → [59.52072:52090]

B:BD[17.65053] → [58.60091:60110]

B:BD[17.65053] → [21.44443:44527]

∅:BD[2.10798] → [21.44527:44544]

B:BD[21.44527] → [21.44527:44544]

∅:BD[2.11058] → [21.44619:44653]

B:BD[21.44619] → [21.44619:44653]

B:BD[21.44653] → [21.44653:44672]

B:BD[21.44653] → [2.11059:11078]

B:BD[21.44544] → [21.44544:44619]

B:BD[21.44544] → [2.10799:11058]

B:BD[21.44527] → [2.10720:10798]

B:BD[17.65053] → [17.65053:65072]

B:BD[17.64864] → [59.51921:52071]

B:BD[17.64864] → [63.50810:50885]

B:BD[17.64864] → [64.33842:33993]

B:BD[17.64864] → [58.59939:60090]

B:BD[17.64864] → [62.73004:73154]

B:BD[17.64864] → [21.42727:43032]

B:BD[17.64864] → [77.40430:40581]

B:BD[17.64864] → [60.50143:50218]

B:BD[17.64864] → [2.10159:10213]

B:BD[17.64864] → [17.64864:65015]

B:BD[17.64739] → [21.42191:42217]

∅:BD[2.9831] → [21.42235:42300]

B:BD[21.42235] → [21.42235:42300]

∅:BD[2.9910] → [21.42300:42317]

B:BD[21.42300] → [21.42300:42317]

∅:BD[2.9962] → [21.42554:42589]

B:BD[21.42554] → [21.42554:42589]

∅:BD[2.9981] → [21.42607:42672]

B:BD[21.42607] → [21.42607:42672]

∅:BD[2.10060] → [21.42672:42708]

B:BD[21.42672] → [21.42672:42708]

B:BD[21.42708] → [21.42708:42726]

B:BD[21.42708] → [2.10061:10079]

B:BD[21.42672] → [2.9982:10060]

B:BD[21.42589] → [21.42589:42607]

B:BD[21.42589] → [2.9963:9981]

B:BD[21.42317] → [21.42317:42554]

B:BD[21.42317] → [2.9911:9962]

B:BD[21.42300] → [2.9832:9910]

B:BD[21.42217] → [21.42217:42235]

B:BD[21.42217] → [2.9813:9831]

B:BD[17.64739] → [17.64739:64782]

B:BD[17.64642] → [59.51901:51920]

B:BD[17.64642] → [63.50790:50809]

B:BD[17.64642] → [64.33822:33841]

B:BD[17.64642] → [58.59919:59938]

B:BD[17.64642] → [62.72984:73003]

B:BD[17.64642] → [21.41179:41197]

B:BD[17.64642] → [77.40410:40429]

B:BD[17.64642] → [60.50123:50142]

B:BD[17.64642] → [2.9359:9377]

B:BD[17.64642] → [17.64642:64661]

B:BD[17.64522] → [58.59830:59918]

B:BD[17.64522] → [62.72895:72983]

B:BD[17.64522] → [21.41090:41178]

B:BD[17.64522] → [60.50034:50122]

B:BD[17.64522] → [17.64522:64610]

B:BD[17.64452] → [2.9324:9358]

B:BD[17.64452] → [17.64452:64522]

B:BD[17.64039] → [64.33746:33821]

B:BD[17.64039] → [21.41014:41089]

B:BD[17.64039] → [77.40334:40409]

B:BD[17.64039] → [2.9129:9165]

B:BD[17.64039] → [17.64039:64114]

B:BD[17.63796] → [58.59710:59816]

∅:BD[2.9049] → [58.59816:59829]

B:BD[58.59816] → [58.59816:59829]

B:BD[58.59816] → [2.8971:9049]

B:BD[17.63796] → [17.63796:63915]

B:BD[17.63568] → [2.8866:8891]

B:BD[17.63568] → [17.63568:63655]

B:BD[17.63349] → [21.40995:41013]

B:BD[17.63349] → [17.63349:63367]

B:BD[17.63054] → [17.63054:63126]

B:BD[17.63126] → [17.63126:63206]

B:BD[17.62902] → [59.51508:51811]

B:BD[17.62902] → [102.44608:44687]

B:BD[17.62902] → [63.50565:50789]

B:BD[17.62902] → [64.33513:33592]

B:BD[17.62902] → [58.59405:59484]

B:BD[17.62902] → [21.40692:40994]

B:BD[17.62902] → [77.40029:40108]

B:BD[17.62902] → [2.8577:8628]

B:BD[17.62902] → [17.62902:63054]

B:BD[17.62802] → [59.51489:51507]

B:BD[17.62802] → [58.59386:59404]

B:BD[17.62802] → [21.40673:40691]

B:BD[17.62802] → [17.62802:62820]

B:BD[17.62605] → [59.51331:51488]

B:BD[17.62605] → [63.50487:50564]

B:BD[17.62605] → [64.33435:33512]

B:BD[17.62605] → [58.59227:59304]

B:BD[17.62605] → [62.72671:72748]

B:BD[17.62605] → [21.40514:40672]

B:BD[17.62605] → [77.39951:40028]

B:BD[17.62605] → [60.49810:49887]

B:BD[17.62605] → [2.8464:8497]

B:BD[17.62605] → [17.62605:62763]

B:BD[17.62505] → [59.51312:51330]

B:BD[17.62505] → [58.59208:59226]

B:BD[17.62505] → [21.40495:40513]

B:BD[17.62505] → [17.62505:62523]

B:BD[17.62473] → [17.62473:62488]

B:BD[17.62396] → [17.62396:62473]

B:BD[17.62275] → [17.62275:62396]

B:BD[17.61966] → [17.61966:62112]

B:BD[17.62112] → [65.30859:30931]

B:BD[17.62112] → [17.62112:62184]

B:BD[17.62112] → [93.63098:63170]

B:BD[17.61894] → [21.40127:40494]

B:BD[17.61894] → [2.8329:8384]

B:BD[17.61894] → [17.61894:61966]

B:BD[17.61794] → [59.50782:50801]

B:BD[17.61794] → [63.50317:50335]

B:BD[17.61794] → [58.58892:58910]

B:BD[17.61794] → [62.72501:72519]

B:BD[17.61794] → [21.40108:40126]

B:BD[17.61794] → [77.39705:39723]

B:BD[17.61794] → [60.49640:49658]

B:BD[17.61794] → [17.61794:61812]

B:BD[17.61686] → [59.50708:50781]

B:BD[17.61686] → [63.50243:50316]

B:BD[17.61686] → [64.33134:33207]

B:BD[17.61686] → [58.58818:58891]

B:BD[17.61686] → [62.72427:72500]

B:BD[17.61686] → [21.39814:40107]

B:BD[17.61686] → [77.39631:39704]

B:BD[17.61686] → [60.49566:49639]

B:BD[17.61686] → [2.8206:8249]

B:BD[17.61686] → [17.61686:61759]

B:BD[17.61585] → [58.58798:58817]

B:BD[17.61585] → [62.72407:72426]

B:BD[17.61585] → [60.49546:49565]

B:BD[17.61585] → [17.61585:61604]

B:BD[77.39630] → [21.39772:39813]

B:BD[17.61564] → [77.39518:39617]

B:BD[17.61551] → [17.61551:61564]

B:BD[17.61564] → [17.61564:61585]

B:BD[17.61468] → [59.50607:50687]

B:BD[17.61468] → [58.58716:58797]

B:BD[17.61468] → [21.39690:39771]

B:BD[17.61468] → [2.7867:8126]

B:BD[17.61468] → [17.61468:61549]

B:BD[17.61368] → [59.50588:50606]

B:BD[17.61368] → [58.58697:58715]

B:BD[17.61368] → [21.39671:39689]

B:BD[17.61368] → [17.61368:61386]

B:BD[17.60999] → [17.60999:61352]

B:BD[17.60830] → [59.50435:50587]

B:BD[17.60830] → [58.58542:58623]

B:BD[17.60830] → [21.39589:39670]

B:BD[17.60830] → [2.7490:7787]

B:BD[17.60830] → [17.60830:60984]

∅:BD[2.7410] → [58.58503:58541]

B:BD[17.60710] → [58.58503:58541]

B:BD[17.60710] → [17.60710:60748]

B:BD[17.60544] → [63.50169:50242]

B:BD[17.60695] → [17.60695:60710]

B:BD[17.60544] → [64.33060:33133]

B:BD[17.60544] → [58.58351:58502]

B:BD[17.60544] → [62.72255:72406]

B:BD[17.60544] → [77.39444:39517]

B:BD[17.60544] → [60.49394:49467]

B:BD[60.49467] → [60.49467:49545]

B:BD[17.60544] → [17.60544:60695]

B:BD[62.72086] → [62.72086:72254]

B:BD[62.72008] → [60.49092:49170]

B:BD[62.71853] → [64.32986:33059]

B:BD[62.71853] → [62.71853:71926]

B:BD[62.71926] → [62.71926:72008]

B:BD[62.71853] → [77.39370:39443]

B:BD[62.71853] → [60.49018:49091]

B:BD[17.60462] → [17.60462:60544]

B:BD[17.60419] → [59.50192:50230]

B:BD[17.60419] → [58.58307:58350]

B:BD[17.60419] → [62.71652:71853]

B:BD[17.60419] → [2.7216:7410]

B:BD[17.60419] → [17.60419:60462]

B:BD[17.60305] → [58.58205:58222]

B:BD[58.58222] → [58.58222:58306]

B:BD[17.60305] → [2.7137:7215]

B:BD[17.60305] → [17.60305:60406]

B:BD[17.60197] → [58.58161:58204]

B:BD[17.60197] → [62.71525:71550]

B:BD[62.71550] → [62.71550:71568]

B:BD[62.71550] → [60.48999:49017]

B:BD[17.60197] → [17.60197:60240]

B:BD[58.58082] → [62.71449:71524]

B:BD[17.60029] → [17.60029:60182]

B:BD[58.58000] → [58.58000:58082]

B:BD[17.59720] → [60.48926:48998]

B:BD[17.60184] → [17.60184:60197]

B:BD[17.60182] → [17.60182:60184]

B:BD[17.59720] → [17.59720:60029]

B:BD[17.59703] → [63.50003:50094]

B:BD[17.59703] → [64.32894:32985]

B:BD[17.59703] → [17.59703:59720]

B:BD[17.59122] → [17.59122:59204]

B:BD[17.59416] → [59.49655:49819]

B:BD[17.59416] → [58.57667:57831]

B:BD[17.59595] → [62.71403:71448]

B:BD[58.57831] → [62.71171:71402]

B:BD[17.59416] → [62.70931:71170]

B:BD[17.59291] → [62.70893:70930]

B:BD[17.59595] → [17.59595:59620]

B:BD[17.59620] → [59.49820:49838]

B:BD[17.59620] → [58.57832:57850]

B:BD[17.59620] → [17.59620:59638]

B:BD[17.59580] → [17.59580:59595]

B:BD[17.59416] → [17.59416:59580]

B:BD[17.59334] → [17.59334:59416]

B:BD[17.59291] → [17.59291:59316]

B:BD[17.59316] → [59.49636:49654]

B:BD[17.59316] → [58.57648:57666]

B:BD[17.59316] → [17.59316:59334]

B:BD[17.59276] → [17.59276:59291]

B:BD[17.59204] → [59.49563:49635]

B:BD[17.59204] → [58.57575:57647]

B:BD[17.59204] → [62.70820:70892]

B:BD[17.59204] → [17.59204:59276]

B:BD[17.59104] → [102.44516:44534]

B:BD[17.59104] → [63.49984:50002]

B:BD[17.59104] → [64.32875:32893]

B:BD[17.59104] → [21.39570:39588]

B:BD[17.59104] → [77.39351:39369]

B:BD[17.59104] → [17.59104:59122]

B:BD[17.58988] → [17.58988:59060]

B:BD[17.58902] → [102.44357:44515]

B:BD[17.58902] → [63.49825:49983]

B:BD[17.58902] → [64.32716:32874]

B:BD[17.58902] → [21.39411:39569]

B:BD[17.58902] → [77.39192:39350]

B:BD[17.58902] → [2.7103:7136]

B:BD[17.58902] → [17.58902:58988]

B:BD[17.58802] → [102.44338:44356]

B:BD[17.58802] → [63.49806:49824]

B:BD[17.58802] → [64.32697:32715]

B:BD[17.58802] → [21.39392:39410]

B:BD[17.58802] → [77.39173:39191]

B:BD[17.58802] → [17.58802:58820]

B:BD[17.58687] → [64.32621:32696]

B:BD[17.58687] → [21.39316:39391]

B:BD[17.58687] → [77.39097:39172]

B:BD[17.58687] → [2.7010:7023]

B:BD[17.58687] → [17.58687:58762]

B:BD[17.58104] → [17.58104:58176]

B:BD[17.58251] → [59.49217:49366]

B:BD[17.58251] → [63.49656:49805]

B:BD[17.58251] → [58.57352:57501]

B:BD[17.58251] → [62.70597:70746]

B:BD[77.38947] → [77.38947:39096]

B:BD[17.58251] → [60.48703:48852]

B:BD[17.58251] → [17.58251:58400]

B:BD[17.58400] → [17.58400:58554]

B:BD[17.58176] → [64.32545:32620]

B:BD[17.58176] → [77.38872:38947]

B:BD[17.58176] → [17.58176:58251]

B:BD[17.58027] → [2.6840:6930]

B:BD[17.58027] → [17.58027:58104]

B:BD[17.57926] → [59.49197:49216]

B:BD[17.57926] → [63.49636:49655]

B:BD[17.57926] → [58.57332:57351]

B:BD[17.57926] → [62.70577:70596]

B:BD[17.57926] → [21.38993:39012]

B:BD[17.57926] → [77.38852:38871]

B:BD[17.57926] → [60.48683:48702]

B:BD[17.57926] → [17.57926:57945]

B:BD[17.57825] → [17.57825:57897]

B:BD[17.57669] → [64.32388:32544]

B:BD[17.57669] → [21.38763:38992]

B:BD[17.57669] → [77.38695:38851]

B:BD[17.57669] → [2.6694:6760]

B:BD[17.57669] → [17.57669:57825]

B:BD[17.57569] → [21.38743:38762]

B:BD[17.57569] → [2.6595:6614]

B:BD[17.57569] → [17.57569:57587]

B:BD[17.57457] → [59.49105:49123]

B:BD[17.57457] → [63.49617:49635]

B:BD[17.57457] → [64.32369:32387]

B:BD[17.57457] → [58.57240:57258]

B:BD[17.57457] → [62.70558:70576]

B:BD[17.57457] → [21.38723:38742]

B:BD[17.57457] → [77.38676:38694]

B:BD[17.57457] → [60.48664:48682]

B:BD[17.57457] → [17.57457:57475]

B:BD[17.57344] → [59.49085:49104]

B:BD[17.57344] → [63.49597:49616]

B:BD[17.57344] → [64.32349:32368]

B:BD[17.57344] → [58.57220:57239]

B:BD[17.57344] → [62.70538:70557]

B:BD[17.57344] → [21.38703:38722]

B:BD[17.57344] → [77.38656:38675]

B:BD[17.57344] → [60.48644:48663]

B:BD[17.57344] → [2.6417:6436]

B:BD[17.57344] → [17.57344:57363]

B:BD[17.57222] → [17.57222:57332]

B:BD[17.57135] → [17.57135:57209]

B:BD[17.57059] → [17.57059:57135]

B:BD[17.57042] → [2.6338:6416]

B:BD[17.57042] → [17.57042:57059]

B:BD[17.56958] → [59.48988:49007]

B:BD[17.56958] → [63.49577:49596]

B:BD[17.56958] → [58.57123:57142]

B:BD[17.56958] → [62.70518:70537]

B:BD[17.56958] → [21.38684:38702]

B:BD[17.56958] → [77.38486:38505]

B:BD[17.56958] → [60.48624:48643]

B:BD[17.56958] → [17.56958:56977]

B:BD[17.56847] → [59.48969:48987]

B:BD[17.56847] → [64.32253:32271]

B:BD[17.56847] → [58.57104:57122]

B:BD[17.56847] → [21.38665:38683]

B:BD[17.56847] → [77.38467:38485]

B:BD[17.56847] → [17.56847:56865]

B:BD[17.56732] → [59.48950:48968]

B:BD[17.56732] → [58.57085:57103]

B:BD[17.56732] → [17.56732:56750]

B:BD[17.56620] → [59.48797:48949]

B:BD[17.56620] → [102.44238:44318]

B:BD[17.56620] → [63.49477:49557]

B:BD[17.56620] → [64.32076:32156]

B:BD[17.56620] → [58.56555:56635]

B:BD[17.56620] → [21.38407:38487]

B:BD[17.56620] → [77.38290:38370]

B:BD[17.56620] → [2.5544:5886]

B:BD[17.56620] → [17.56620:56697]

B:BD[17.56086] → [17.56086:56538]

B:BD[17.56068] → [59.48778:48796]

B:BD[17.56068] → [102.44219:44237]

B:BD[17.56068] → [63.49458:49476]

B:BD[17.56068] → [64.32057:32075]

B:BD[17.56068] → [58.56536:56554]

B:BD[17.56068] → [62.70499:70517]

B:BD[17.56068] → [21.38388:38406]

B:BD[17.56068] → [65.30840:30858]

B:BD[17.56068] → [77.38271:38289]

B:BD[17.56068] → [60.48605:48623]

B:BD[17.56068] → [17.56068:56086]

B:BD[17.56068] → [93.63079:63097]

B:BD[17.55725] → [59.48550:48777]

B:BD[17.55725] → [58.56229:56383]

B:BD[17.55725] → [2.5374:5464]

B:BD[17.55725] → [17.55725:56031]

B:BD[17.55625] → [59.48531:48549]

B:BD[17.55625] → [58.56210:56228]

B:BD[17.55625] → [21.38216:38234]

B:BD[17.55625] → [2.5276:5294]

B:BD[17.55625] → [17.55625:55643]

B:BD[17.55513] → [64.32038:32056]

B:BD[17.55513] → [21.38197:38215]

B:BD[17.55513] → [77.38252:38270]

B:BD[17.55513] → [17.55513:55531]

B:BD[17.55480] → [17.55480:55482]

B:BD[17.55404] → [17.55404:55480]

B:BD[17.55387] → [2.5118:5196]

B:BD[17.55387] → [17.55387:55404]

B:BD[17.55303] → [59.48361:48379]

B:BD[17.55303] → [58.56113:56132]

B:BD[17.55303] → [21.38177:38196]

B:BD[17.55303] → [17.55303:55322]

B:BD[17.55130] → [59.48218:48360]

B:BD[17.55130] → [63.49315:49457]

B:BD[17.55130] → [64.31818:31960]

B:BD[17.55130] → [58.55970:56112]

B:BD[17.55130] → [62.70356:70498]

B:BD[17.55130] → [21.38100:38176]

B:BD[17.55130] → [77.38032:38174]

B:BD[17.55130] → [60.48462:48532]

B:BD[17.55130] → [2.5103:5117]

B:BD[17.55130] → [17.55130:55272]

B:BD[17.55029] → [58.55950:55969]

B:BD[17.55029] → [17.55029:55048]

B:BD[17.55006] → [21.38064:38099]

B:BD[17.55006] → [17.55006:55029]

B:BD[17.54536] → [59.47817:48197]

B:BD[17.54536] → [64.31442:31516]

B:BD[17.54536] → [58.55494:55568]

B:BD[17.54536] → [21.37606:38063]

B:BD[17.54536] → [77.37729:37803]

B:BD[17.54536] → [2.4943:5023]

B:BD[17.54536] → [17.54536:54991]

B:BD[17.54435] → [59.47798:47816]

B:BD[17.54435] → [63.48994:49013]

B:BD[17.54435] → [64.31422:31441]

B:BD[17.54435] → [58.55474:55493]

B:BD[17.54435] → [62.70035:70054]

B:BD[17.54435] → [21.37586:37605]

B:BD[17.54435] → [77.37709:37728]

B:BD[17.54435] → [60.48141:48160]

B:BD[17.54435] → [2.4844:4863]

B:BD[17.54435] → [17.54435:54454]

B:BD[17.54303] → [59.47203:47240]

B:BD[17.54303] → [58.55438:55455]

B:BD[58.55455] → [64.31403:31421]

B:BD[58.55455] → [58.55455:55473]

B:BD[58.55455] → [21.37567:37585]

B:BD[58.55455] → [77.37690:37708]

B:BD[17.54303] → [17.54303:54338]

B:BD[17.54141] → [17.54141:54215]

B:BD[17.54215] → [59.47129:47202]

B:BD[17.54215] → [58.55364:55437]

B:BD[17.54215] → [62.69961:70034]

B:BD[17.54215] → [17.54215:54288]

B:BD[17.54069] → [59.47056:47128]

B:BD[17.54069] → [102.43926:44072]

B:BD[17.54069] → [63.48774:48993]

B:BD[17.54069] → [64.31256:31402]

B:BD[17.54069] → [58.55291:55363]

B:BD[17.54069] → [62.69888:69960]

B:BD[17.54069] → [21.37343:37566]

B:BD[17.54069] → [77.37470:37616]

B:BD[17.54069] → [60.47994:48066]

B:BD[17.54069] → [2.4723:4764]

B:BD[17.54069] → [17.54069:54141]

B:BD[17.53968] → [21.37323:37342]

B:BD[17.53968] → [17.53968:53987]

B:BD[17.53865] → [59.46981:47055]

B:BD[17.53865] → [58.55216:55290]

B:BD[17.53865] → [21.37100:37322]

B:BD[17.53865] → [2.4609:4643]

B:BD[17.53865] → [17.53865:53939]

B:BD[17.53764] → [59.46962:46980]

B:BD[17.53764] → [58.55196:55215]

B:BD[17.53764] → [17.53764:53783]

B:BD[59.46925] → [59.46925:46961]

B:BD[59.46925] → [21.37059:37080]

B:BD[21.37080] → [21.37080:37099]

B:BD[21.37080] → [2.4510:4529]

B:BD[59.46912] → [2.4431:4509]

B:BD[17.53668] → [17.53668:53746]

B:BD[17.53649] → [59.46829:46847]

B:BD[17.53649] → [102.43906:43925]

B:BD[17.53649] → [63.48755:48773]

B:BD[17.53649] → [86.34528:34547]

B:BD[17.53649] → [64.31236:31255]

B:BD[17.53649] → [58.55176:55195]

B:BD[17.53649] → [62.69869:69887]

B:BD[17.53649] → [21.37040:37058]

B:BD[17.53649] → [77.37450:37469]

B:BD[17.53649] → [60.47974:47993]

B:BD[17.53649] → [17.53649:53668]

B:BD[17.53543] → [59.46755:46828]

B:BD[17.53543] → [63.48681:48754]

B:BD[17.53543] → [58.55102:55175]

B:BD[17.53543] → [62.69795:69868]

B:BD[17.53543] → [21.36966:37039]

B:BD[17.53543] → [77.37376:37449]

B:BD[17.53543] → [60.47900:47973]

B:BD[17.53543] → [2.4413:4430]

B:BD[17.53543] → [17.53543:53616]

B:BD[17.53335] → [59.46681:46754]

B:BD[17.53335] → [58.55028:55101]

B:BD[17.53335] → [62.69721:69794]

B:BD[17.53335] → [21.36892:36965]

B:BD[17.53335] → [60.47826:47899]

B:BD[17.53335] → [2.4322:4333]

B:BD[17.53335] → [17.53335:53408]

B:BD[17.53235] → [59.46662:46680]

B:BD[17.53235] → [63.48661:48680]

B:BD[17.53235] → [58.55009:55027]

B:BD[17.53235] → [62.69702:69720]

B:BD[17.53235] → [21.36872:36891]

B:BD[17.53235] → [77.37357:37375]

B:BD[17.53235] → [60.47807:47825]

B:BD[17.53235] → [17.53235:53253]

B:BD[58.54933] → [58.54933:55005]

B:BD[58.54933] → [62.69629:69701]

B:BD[58.54933] → [60.47734:47806]

B:BD[15.6852] → [25.4417:4435]

B:BD[15.6852] → [16.1901:1919]

B:BD[15.6852] → [26.2615:2633]

B:BD[9.2228] → [19.270:480]

B:BD[15.6852] → [27.839:857]

B:BD[17.53201] → [17.53201:53213]

B:BD[10.12201] → [40.9879:10088]

B:BD[20.7125] → [33.7627:7836]

B:BD[20.7247] → [40.10089:10162]

B:BD[20.7455] → [29.36244:36317]

B:BD[20.7561] → [24.1370:1388]

B:BD[24.1466] → [24.1466:1502]

B:BD[20.7579] → [20.7579:7657]

B:BD[20.7771] → [20.7771:7789]

B:BD[20.7807] → [20.7807:7889]

B:BD[20.7963] → [20.7963:8093]

B:BD[20.8165] → [20.8165:8239]

B:BD[20.8312] → [20.8312:8314]

B:BD[20.8314] → [111.5393:5506]

B:BD[20.8327] → [40.10275:10375]

B:BD[40.10388] → [24.1670:1707]

B:BD[20.8429] → [24.1708:2036]

B:BD[24.2108] → [24.2108:2264]

B:BD[20.9017] → [24.2265:2283]

B:BD[20.9117] → [24.2284:2365]

B:BD[20.9271] → [24.2366:2438]

B:BD[20.9424] → [20.9424:9497]

B:BD[20.9535] → [24.2520:2539]

B:BD[20.9636] → [24.2540:2610]

B:BD[20.9809] → [24.2683:2701]

B:BD[20.9909] → [24.2702:2852]

B:BD[20.10204] → [24.2853:2871]

B:BD[20.10304] → [24.2872:3099]

B:BD[20.10568] → [24.3100:3118]

B:BD[42.15646] → [24.3119:3271]

B:BD[42.15975] → [42.15975:16016]

B:BD[20.10855] → [24.3272:3290]

B:BD[20.10970] → [24.3291:3309]

B:BD[20.11081] → [24.3310:3329]

B:BD[20.11182] → [24.3330:3406]

B:BD[20.11467] → [24.3407:3426]

B:BD[20.11580] → [92.3853:3871]

B:BD[20.11948] → [24.3427:3499]

B:BD[20.12049] → [29.38399:38418]

B:BD[20.12374] → [29.38419:38568]

B:BD[20.12887] → [24.3500:3622]

B:BD[20.13233] → [24.3623:3695]

B:BD[20.13367] → [20.13367:13449]

B:BD[42.16590] → [24.3696:3768]

B:BD[55.34139] → [55.34139:34572]

B:BD[20.13561] → [24.3769:3787]

B:BD[20.13661] → [24.3788:3952]

B:BD[20.13840] → [47.10194:10219]

B:BD[20.13883] → [20.13883:13965]

B:BD[20.14113] → [24.4048:4208]

B:BD[20.14426] → [70.1987:2209]

B:BD[20.14441] → [29.39228:39271]

B:BD[30.14815] → [29.39272:39354]

B:BD[20.14466] → [24.4209:4227]

B:BD[22.7801] → [92.4092:4165]

B:BD[24.4305] → [24.4305:4325]

B:BD[53.7448] → [43.23054:23208]

B:BD[53.7626] → [53.7626:7665]

B:BD[20.14654] → [24.4508:4547]

B:BD[54.10787] → [24.4548:4700]

B:BD[20.14692] → [20.14692:14774]

B:BD[20.14937] → [20.14937:14952]

B:BD[20.15240] → [20.15240:15609]

B:BD[20.15627] → [20.15627:15709]

B:BD[20.15789] → [20.15789:15825]

B:BD[20.15844] → [20.15844:15926]

B:BD[20.15999] → [22.7897:7932]

B:BD[22.7950] → [22.7950:8250]

B:BD[22.8322] → [22.8322:8398]

B:BD[20.16014] → [24.4821:4842]

B:BD[20.16134] → [24.4862:4938]

B:BD[20.16749] → [20.16749:16849]

B:BD[20.16925] → [20.16925:16957]

B:BD[20.16975] → [20.16975:17057]

B:BD[41.6489] → [41.6489:6570]

B:BD[20.17253] → [24.5193:5211]

B:BD[20.17353] → [24.5212:5515]

B:BD[20.18151] → [43.23903:24022]

B:BD[20.18854] → [140.286:374]

B:BD[20.18974] → [29.40741:40760]

B:BD[20.19196] → [29.40761:40836]

B:BD[20.19384] → [24.5592:5610]

B:BD[20.19586] → [24.5611:5630]

B:BD[20.19687] → [24.5631:5707]

B:BD[20.19906] → [29.41103:41250]

B:BD[20.20128] → [24.5854:5924]

B:BD[24.5995] → [24.5995:6068]

B:BD[42.18560] → [42.18560:18575]

B:BD[20.20433] → [20.20433:20551]

B:BD[20.20623] → [20.20623:20726]

B:BD[20.20745] → [20.20745:20827]

B:BD[20.20900] → [20.20900:21092]

B:BD[20.21092] → [22.9183:9298]

B:BD[20.21157] → [22.9299:9396]

B:BD[20.21170] → [20.21170:21382]

B:BD[20.21397] → [24.6312:6332]

B:BD[20.21499] → [24.6333:6406]

B:BD[20.21729] → [24.6407:6549]

B:BD[20.22089] → [24.6550:6620]

B:BD[20.22231] → [24.6621:6693]

B:BD[24.6766] → [24.6766:6923]

B:BD[24.7003] → [24.7003:7079]

B:BD[22.9944] → [22.9944:10022]

B:BD[20.23203] → [43.25668:25756]

B:BD[20.23535] → [24.7241:7313]

B:BD[20.23713] → [24.7314:7332]

B:BD[20.24042] → [29.43095:43168]

B:BD[20.24326] → [24.7333:7351]

B:BD[20.24426] → [24.7352:7581]

B:BD[20.25092] → [24.7582:7600]

B:BD[20.25175] → [24.7601:7700]

B:BD[20.25206] → [24.7701:7719]

B:BD[20.25316] → [24.7720:7739]

B:BD[20.25438] → [92.4885:4903]

B:BD[20.25552] → [24.7740:7758]

B:BD[20.25652] → [24.7759:7836]

B:BD[20.25806] → [20.25806:25834]

B:BD[24.8035] → [24.8035:8053]

B:BD[20.25934] → [92.4904:4977]

B:BD[20.26041] → [92.4978:4996]

B:BD[20.26141] → [92.4997:5079]

B:BD[20.26368] → [24.8054:8072]

B:BD[20.26468] → [24.8073:8376]

B:BD[20.27015] → [24.8455:8529]

B:BD[20.27233] → [24.8530:8548]

B:BD[20.27316] → [47.13002:13166]

B:BD[20.27705] → [24.8702:8720]

B:BD[20.27805] → [24.8721:8953]

B:BD[20.28483] → [24.8954:9171]

B:BD[20.28843] → [24.9172:9243]

B:BD[20.29191] → [24.9244:9316]

B:BD[20.29899] → [24.9317:9537]

B:BD[20.30195] → [20.30195:30275]

B:BD[20.30430] → [43.27369:27543]

B:BD[43.27543] → [140.646:721]

B:BD[20.30809] → [92.5456:5601]

B:BD[20.31073] → [140.722:740]

B:BD[20.31156] → [47.14016:14113]

B:BD[20.31282] → [24.10017:10036]

B:BD[20.31727] → [24.10037:10055]

B:BD[20.31827] → [24.10056:10128]

B:BD[20.31901] → [43.27784:27902]

B:BD[55.39294] → [48.21415:21533]

B:BD[20.31931] → [24.10129:10149]

B:BD[20.32108] → [92.5696:5769]

B:BD[20.32261] → [24.10150:10300]

B:BD[20.32645] → [24.10380:10399]

B:BD[20.32746] → [24.10400:10470]

B:BD[20.32966] → [70.5766:5846]

B:BD[20.33073] → [24.10543:10561]

B:BD[20.33294] → [24.10562:10580]

B:BD[20.33394] → [24.10581:10656]

B:BD[20.33552] → [20.33552:33593]

B:BD[20.33611] → [20.33611:33693]

B:BD[24.10831] → [24.10831:10902]

B:BD[20.33916] → [24.10903:10978]

B:BD[20.34064] → [43.28581:28865]

B:BD[55.40257] → [48.22212:22496]

B:BD[20.34214] → [24.10979:10998]

B:BD[20.34315] → [24.10999:11077]

B:BD[20.34429] → [24.11078:11097]

B:BD[20.34530] → [24.11098:11257]

B:BD[20.34727] → [24.11258:11277]

B:BD[20.34828] → [24.11278:11427]

B:BD[20.35012] → [24.11428:11447]

B:BD[20.35464] → [24.11448:11467]

B:BD[20.35794] → [24.11468:11487]

B:BD[20.35895] → [24.11488:11567]

B:BD[24.11641] → [24.11641:11784]

B:BD[20.36333] → [24.11785:11803]

B:BD[54.16729] → [24.11804:11883]

B:BD[54.16837] → [24.11884:11902]

B:BD[53.13517] → [43.29623:29702]

B:BD[53.13517] → [29.47727:47806]

B:BD[49.24994] → [29.47807:47825]

B:BD[49.25094] → [49.25094:25320]

B:BD[20.37374] → [20.37374:37377]

B:BD[49.24994] → [49.24994:25012]

B:BD[49.25012] → [49.25012:25094]

B:BD[20.36997] → [48.23254:23333]

B:BD[49.24965] → [49.24965:24994]

B:BD[53.13517] → [49.24886:24965]

B:BD[20.36997] → [20.36997:37072]

B:BD[20.37153] → [24.11903:11975]

B:BD[20.37153] → [40.14082:14154]

B:BD[20.37301] → [20.37301:37374]

B:BD[20.37153] → [41.9068:9140]

B:BD[20.37153] → [111.9109:9181]

B:BD[20.37153] → [42.23419:23491]

B:BD[20.37153] → [44.5069:5141]

B:BD[20.37153] → [22.12026:12098]

B:BD[20.37153] → [33.12335:12407]

B:BD[20.37153] → [50.6631:6703]

B:BD[20.37153] → [51.9478:9550]

B:BD[20.37153] → [20.37153:37225]

B:BD[20.37225] → [20.37225:37301]

B:BD[20.37153] → [54.17083:17155]

B:BD[20.37153] → [55.41095:41167]

B:BD[20.37153] → [37.17466:17538]

B:BD[20.37072] → [20.37072:37153]

B:BD[53.13517] → [53.13517:13743]

B:BD[20.36997] → [53.13309:13435]

B:BD[20.36560] → [20.36560:36642]

B:BD[20.36723] → [40.14009:14081]

B:BD[20.36915] → [20.36915:36997]

B:BD[20.36897] → [20.36897:36915]

B:BD[20.36723] → [41.8995:9067]

B:BD[20.36723] → [111.9036:9108]

B:BD[20.36723] → [44.4996:5068]

B:BD[20.36723] → [33.12262:12334]

B:BD[20.36723] → [50.6558:6630]

B:BD[20.36723] → [51.9405:9477]

B:BD[20.36868] → [20.36868:36897]

B:BD[20.36723] → [20.36723:36795]

B:BD[20.36795] → [20.36795:36868]

B:BD[20.36723] → [37.17393:17465]

B:BD[20.36642] → [42.23339:23418]

B:BD[20.36642] → [20.36642:36723]

B:BD[20.36642] → [54.16856:17082]

B:BD[54.16837] → [54.16837:16855]

B:BD[54.16729] → [22.11946:12025]

B:BD[54.16729] → [54.16729:16808]

B:BD[54.16808] → [54.16808:16837]

B:BD[54.16729] → [55.41015:41094]

B:BD[20.36333] → [42.23319:23338]

B:BD[20.36333] → [43.29603:29622]

B:BD[20.36333] → [29.47707:47726]

B:BD[20.36333] → [46.64116:64135]

B:BD[20.36333] → [22.11926:11945]

B:BD[20.36333] → [48.23234:23253]

B:BD[20.36333] → [30.19702:19721]

B:BD[20.36333] → [49.24866:24885]

B:BD[20.36333] → [20.36333:36560]

B:BD[53.13435] → [53.13435:13517]

B:BD[20.36333] → [53.13289:13308]

B:BD[20.36333] → [54.16628:16647]

B:BD[54.16647] → [54.16647:16729]

B:BD[20.36333] → [55.40995:41014]

B:BD[22.11852] → [140.917:990]

B:BD[22.11852] → [70.6096:6169]

B:BD[22.11852] → [43.29529:29602]

B:BD[22.11852] → [29.47633:47706]

B:BD[22.11852] → [47.14943:15016]

B:BD[22.11852] → [22.11852:11925]

B:BD[24.11641] → [22.11782:11852]

B:BD[20.36191] → [20.36191:36333]

B:BD[22.11852] → [48.23160:23233]

B:BD[22.11852] → [30.19628:19701]

B:BD[22.11852] → [49.24792:24865]

B:BD[22.11852] → [52.11007:11080]

B:BD[22.11852] → [38.19236:19309]

B:BD[22.11852] → [53.13215:13288]

B:BD[22.11852] → [71.5269:5342]

B:BD[24.11567] → [24.11567:11641]

B:BD[20.35895] → [40.13855:13934]

B:BD[20.36118] → [40.13935:14008]

B:BD[20.36118] → [41.8921:8994]

B:BD[20.36118] → [111.8962:9035]

B:BD[20.36118] → [42.23245:23318]

B:BD[20.36118] → [44.4922:4995]

B:BD[20.36118] → [33.12188:12261]

B:BD[20.36118] → [50.6484:6557]

B:BD[20.36118] → [51.9331:9404]

B:BD[20.36118] → [20.36118:36191]

B:BD[20.36048] → [20.36048:36118]

B:BD[20.36118] → [54.16554:16627]

B:BD[20.36118] → [55.40921:40994]

B:BD[20.36118] → [37.17319:17392]

B:BD[20.35895] → [41.8767:8846]

B:BD[41.8846] → [41.8846:8920]

B:BD[20.35895] → [140.837:916]

B:BD[20.35895] → [70.6016:6095]

B:BD[20.35895] → [111.8882:8961]

B:BD[20.35895] → [42.23091:23244]

B:BD[20.35895] → [43.29375:29454]

B:BD[43.29454] → [43.29454:29528]

B:BD[20.35895] → [29.47479:47632]

B:BD[20.35895] → [44.4842:4921]

B:BD[20.35895] → [47.14863:14942]

B:BD[20.35895] → [22.11702:11781]

B:BD[20.35895] → [33.12034:12187]

B:BD[20.35895] → [48.23006:23159]

B:BD[20.35895] → [30.19548:19627]

B:BD[20.35895] → [49.24638:24791]

B:BD[20.35895] → [50.6404:6483]

B:BD[20.35895] → [51.9251:9330]

B:BD[20.35895] → [20.35895:35974]

B:BD[20.35974] → [20.35974:36048]

B:BD[20.35895] → [52.10927:11006]

B:BD[20.35895] → [38.19156:19235]

B:BD[20.35895] → [53.13061:13214]

B:BD[20.35895] → [54.16400:16553]

B:BD[20.35895] → [55.40767:40920]

B:BD[20.35895] → [37.17239:17318]

B:BD[20.35895] → [71.5189:5268]

B:BD[20.35794] → [70.5996:6015]

B:BD[20.35794] → [42.23071:23090]

B:BD[20.35794] → [43.29355:29374]

B:BD[20.35794] → [29.47459:47478]

B:BD[20.35794] → [47.14843:14862]

B:BD[20.35794] → [48.22986:23005]

B:BD[20.35794] → [30.19528:19547]

B:BD[20.35794] → [49.24618:24637]

B:BD[20.35794] → [20.35794:35813]

B:BD[20.35813] → [20.35813:35895]

B:BD[20.35794] → [52.10907:10926]

B:BD[20.35794] → [38.19136:19155]

B:BD[20.35794] → [53.13041:13060]

B:BD[20.35794] → [54.16380:16399]

B:BD[20.35794] → [55.40747:40766]

B:BD[20.35464] → [42.23051:23070]

B:BD[20.35464] → [43.29335:29354]

B:BD[20.35464] → [29.47439:47458]

B:BD[20.35464] → [22.11682:11701]

B:BD[20.35464] → [48.22966:22985]

B:BD[20.35464] → [49.24598:24617]

B:BD[20.35464] → [20.35464:35483]

B:BD[20.35483] → [20.35483:35794]

B:BD[20.35464] → [53.13021:13040]

B:BD[20.35464] → [54.16360:16379]

B:BD[20.35464] → [55.40727:40746]

B:BD[20.35012] → [42.23031:23050]

B:BD[20.35012] → [43.29315:29334]

B:BD[20.35012] → [29.47419:47438]

B:BD[20.35012] → [48.22946:22965]

B:BD[20.35012] → [49.24578:24597]

B:BD[20.35012] → [20.35012:35031]

B:BD[20.35031] → [20.35031:35464]

B:BD[20.35012] → [53.13001:13020]

B:BD[20.35012] → [54.16340:16359]

B:BD[20.35012] → [55.40707:40726]

B:BD[20.34828] → [42.22881:23030]

B:BD[20.34828] → [43.29165:29314]

B:BD[20.34828] → [29.47269:47418]

B:BD[20.34828] → [48.22796:22945]

B:BD[20.34828] → [49.24428:24577]

B:BD[20.34828] → [20.34828:34977]

B:BD[20.34977] → [20.34977:35012]

B:BD[20.34828] → [53.12851:13000]

B:BD[20.34828] → [54.16190:16339]

B:BD[20.34828] → [55.40557:40706]

B:BD[20.34727] → [42.22861:22880]

B:BD[20.34727] → [43.29145:29164]

B:BD[20.34727] → [29.47249:47268]

B:BD[20.34727] → [48.22776:22795]

B:BD[20.34727] → [49.24408:24427]

B:BD[20.34727] → [20.34727:34746]

B:BD[20.34746] → [20.34746:34828]

B:BD[20.34727] → [53.12831:12850]

B:BD[20.34727] → [54.16170:16189]

B:BD[20.34727] → [55.40537:40556]

B:BD[20.34530] → [42.22701:22860]

B:BD[20.34530] → [43.28985:29144]

B:BD[20.34530] → [29.47089:47248]

B:BD[20.34530] → [48.22616:22775]

B:BD[20.34530] → [49.24248:24407]

B:BD[20.34530] → [20.34530:34689]

B:BD[20.34689] → [20.34689:34727]

B:BD[20.34530] → [53.12671:12830]

B:BD[20.34530] → [54.16010:16169]

B:BD[20.34530] → [55.40377:40536]

B:BD[20.34429] → [42.22681:22700]

B:BD[20.34429] → [43.28965:28984]

B:BD[20.34429] → [29.47069:47088]

B:BD[20.34429] → [48.22596:22615]

B:BD[20.34429] → [49.24228:24247]

B:BD[20.34429] → [20.34429:34448]

B:BD[20.34448] → [20.34448:34530]

B:BD[20.34429] → [53.12651:12670]

B:BD[20.34429] → [54.15990:16009]

B:BD[20.34429] → [55.40357:40376]

B:BD[20.34315] → [42.22602:22680]

B:BD[20.34315] → [43.28886:28964]

B:BD[20.34315] → [29.46990:47068]

B:BD[20.34315] → [48.22517:22595]

B:BD[20.34315] → [49.24149:24227]

B:BD[20.34315] → [20.34315:34393]

B:BD[20.34393] → [20.34393:34429]

B:BD[20.34315] → [53.12572:12650]

B:BD[20.34315] → [54.15911:15989]

B:BD[20.34315] → [55.40278:40356]

B:BD[20.34214] → [42.22582:22601]

B:BD[20.34214] → [43.28866:28885]

B:BD[20.34214] → [29.46970:46989]

B:BD[20.34214] → [48.22497:22516]

B:BD[20.34214] → [49.24129:24148]

B:BD[20.34233] → [20.34233:34315]

B:BD[20.34214] → [20.34214:34233]

B:BD[20.34214] → [53.12552:12571]

B:BD[20.34214] → [54.15891:15910]

B:BD[20.34214] → [55.40258:40277]

B:BD[20.34064] → [20.34064:34079]

B:BD[20.34079] → [42.22297:22581]

B:BD[20.34079] → [20.34079:34214]

B:BD[20.34079] → [55.39973:40242]

B:BD[55.40242] → [55.40242:40257]

B:BD[20.33916] → [40.13779:13854]

B:BD[20.33916] → [41.8691:8766]

B:BD[20.33916] → [140.761:836]

B:BD[20.33916] → [70.5920:5995]

B:BD[20.33916] → [111.8806:8881]

B:BD[20.33916] → [42.22221:22296]

B:BD[20.33916] → [43.28505:28580]

B:BD[29.46612] → [29.46612:46685]

B:BD[29.46685] → [29.46685:46969]

B:BD[20.33916] → [29.46537:46612]

B:BD[20.33916] → [44.4766:4841]

B:BD[29.46612] → [46.64042:64115]

B:BD[20.33916] → [47.14767:14842]

B:BD[20.33916] → [22.11606:11681]

B:BD[20.33916] → [33.11958:12033]

B:BD[20.33916] → [48.22136:22211]

B:BD[20.33916] → [30.19379:19527]

B:BD[20.33916] → [49.23980:24128]

B:BD[20.33916] → [50.6328:6403]

B:BD[20.33916] → [51.9175:9250]

B:BD[20.33916] → [20.33916:33991]

B:BD[20.33991] → [20.33991:34064]

B:BD[20.33916] → [52.10831:10906]

B:BD[20.33916] → [38.19060:19135]

B:BD[20.33916] → [53.12476:12551]

B:BD[20.33916] → [54.15815:15890]

B:BD[20.33916] → [55.39897:39972]

B:BD[20.33916] → [37.17163:17238]

B:BD[20.33916] → [71.5113:5188]

B:BD[43.28433] → [43.28433:28504]

B:BD[29.46465] → [29.46465:46536]

B:BD[20.33836] → [20.33836:33916]

B:BD[20.33765] → [20.33765:33836]

B:BD[20.33693] → [24.10759:10831]

B:BD[20.33693] → [40.13706:13778]

B:BD[20.33693] → [41.8618:8690]

B:BD[20.33693] → [92.6085:6157]

B:BD[20.33693] → [70.5847:5919]

B:BD[20.33693] → [111.8733:8805]

B:BD[20.33693] → [42.22077:22220]

B:BD[20.33693] → [43.28361:28433]

B:BD[20.33693] → [29.46393:46465]

B:BD[20.33693] → [44.4693:4765]

B:BD[20.33693] → [46.63969:64041]

B:BD[20.33693] → [47.14694:14766]

B:BD[20.33693] → [22.11533:11605]

B:BD[20.33693] → [33.11885:11957]

B:BD[20.33693] → [48.21992:22135]

B:BD[20.33693] → [30.19306:19378]

B:BD[20.33693] → [49.23836:23979]

B:BD[20.33693] → [50.6255:6327]

B:BD[20.33693] → [51.9102:9174]

B:BD[20.33693] → [20.33693:33765]

B:BD[20.33693] → [52.10758:10830]

B:BD[20.33693] → [38.18987:19059]

B:BD[20.33693] → [53.12332:12475]

B:BD[20.33693] → [54.15671:15814]

B:BD[20.33693] → [55.39753:39896]

B:BD[20.33693] → [37.17090:17162]

B:BD[20.33693] → [39.6457:6529]

B:BD[20.33593] → [24.10740:10758]

B:BD[20.33593] → [42.22058:22076]

B:BD[20.33593] → [43.28342:28360]

B:BD[20.33593] → [29.46374:46392]

B:BD[20.33593] → [48.21973:21991]

B:BD[20.33593] → [49.23817:23835]

B:BD[20.33593] → [20.33593:33611]

B:BD[20.33593] → [53.12313:12331]

B:BD[20.33593] → [54.15652:15670]

B:BD[20.33593] → [55.39734:39752]

B:BD[24.10656] → [24.10656:10739]

B:BD[20.33394] → [22.11457:11532]

B:BD[22.11532] → [43.28258:28341]

B:BD[22.11532] → [29.46290:46373]

B:BD[22.11532] → [48.21889:21972]

B:BD[22.11532] → [49.23733:23816]

B:BD[22.11532] → [53.12229:12312]

B:BD[20.33394] → [20.33394:33469]

B:BD[20.33469] → [42.21974:22057]

B:BD[20.33469] → [20.33469:33552]

B:BD[20.33469] → [54.15568:15651]

B:BD[20.33469] → [55.39650:39733]

B:BD[20.33294] → [42.21955:21973]

B:BD[20.33294] → [43.28239:28257]

B:BD[20.33294] → [29.46271:46289]

B:BD[20.33294] → [48.21870:21888]

B:BD[20.33294] → [49.23714:23732]

B:BD[20.33294] → [20.33294:33312]

B:BD[20.33312] → [20.33312:33394]

B:BD[20.33294] → [53.12210:12228]

B:BD[20.33294] → [54.15549:15567]

B:BD[20.33294] → [55.39631:39649]

B:BD[20.33073] → [22.11438:11456]

B:BD[20.33073] → [20.33073:33091]

B:BD[20.33091] → [20.33091:33294]

B:BD[20.32966] → [29.46190:46270]

B:BD[20.32966] → [30.19225:19305]

B:BD[20.32888] → [20.32888:32966]

B:BD[20.32966] → [20.32966:33073]

B:BD[20.32966] → [38.18906:18986]

B:BD[24.10470] → [24.10470:10542]

B:BD[24.10470] → [22.11365:11437]

B:BD[20.32746] → [40.13563:13705]

B:BD[20.32746] → [41.8475:8617]

B:BD[20.32746] → [92.5942:6084]

B:BD[20.32746] → [70.5623:5693]

B:BD[70.5693] → [70.5693:5765]

B:BD[70.5693] → [39.6384:6456]

B:BD[20.32746] → [111.8590:8732]

B:BD[20.32746] → [42.21812:21954]

B:BD[20.32746] → [43.28096:28238]

B:BD[20.32746] → [29.46047:46189]

B:BD[20.32746] → [44.4550:4692]

B:BD[20.32746] → [46.63826:63968]

B:BD[20.32746] → [47.14551:14693]

B:BD[20.32746] → [33.11742:11884]

B:BD[20.32746] → [48.21727:21869]

B:BD[20.32746] → [30.19082:19224]

B:BD[20.32746] → [49.23571:23713]

B:BD[20.32746] → [50.6112:6254]

B:BD[20.32746] → [51.8959:9101]

B:BD[20.32746] → [20.32746:32888]

B:BD[20.32746] → [52.10615:10757]

B:BD[20.32746] → [38.18763:18905]

B:BD[20.32746] → [53.12067:12209]

B:BD[20.32746] → [54.15406:15548]

B:BD[20.32746] → [55.39488:39630]

B:BD[20.32746] → [37.16947:17089]

B:BD[20.32645] → [40.13543:13562]

B:BD[20.32645] → [41.8455:8474]

B:BD[20.32645] → [92.5922:5941]

B:BD[20.32645] → [70.5603:5622]

B:BD[20.32645] → [111.8570:8589]

B:BD[20.32645] → [42.21792:21811]

B:BD[20.32645] → [43.28076:28095]

B:BD[20.32645] → [29.46027:46046]

B:BD[20.32645] → [44.4530:4549]

B:BD[20.32645] → [46.63806:63825]

B:BD[20.32645] → [47.14531:14550]

B:BD[20.32645] → [33.11722:11741]

B:BD[20.32645] → [48.21707:21726]

B:BD[20.32645] → [30.19062:19081]

B:BD[20.32645] → [49.23551:23570]

B:BD[20.32645] → [50.6092:6111]

B:BD[20.32645] → [51.8939:8958]

B:BD[20.32645] → [20.32645:32664]

B:BD[20.32664] → [20.32664:32746]

B:BD[20.32490] → [20.32490:32645]

B:BD[20.32645] → [52.10595:10614]

B:BD[20.32645] → [38.18743:18762]

B:BD[20.32645] → [53.12047:12066]

B:BD[20.32645] → [54.15386:15405]

B:BD[20.32645] → [55.39468:39487]

B:BD[20.32645] → [37.16927:16946]

B:BD[24.10300] → [24.10300:10379]

B:BD[20.32261] → [70.5373:5451]

B:BD[70.5523] → [70.5523:5602]

B:BD[70.5451] → [70.5451:5523]

B:BD[70.5451] → [39.6311:6383]

B:BD[20.32261] → [29.45797:45875]

B:BD[29.45875] → [29.45875:46026]

B:BD[29.45875] → [46.63654:63805]

B:BD[20.32261] → [47.14301:14530]

B:BD[20.32261] → [22.11214:11292]

B:BD[22.11292] → [43.27924:28075]

B:BD[22.11292] → [22.11292:11364]

B:BD[22.11292] → [48.21555:21706]

B:BD[22.11292] → [53.11895:12046]

B:BD[20.32261] → [30.18832:19061]

B:BD[20.32261] → [49.23321:23550]

B:BD[20.32261] → [20.32261:32339]

B:BD[20.32339] → [40.13391:13542]

B:BD[20.32339] → [41.8303:8454]

B:BD[20.32339] → [111.8418:8569]

B:BD[20.32339] → [42.21640:21791]

B:BD[20.32339] → [44.4378:4529]

B:BD[20.32339] → [33.11570:11721]

B:BD[20.32339] → [50.5940:6091]

B:BD[20.32339] → [51.8787:8938]

B:BD[20.32339] → [20.32339:32490]

B:BD[20.32339] → [54.15234:15385]

B:BD[20.32339] → [55.39316:39467]

B:BD[20.32339] → [37.16775:16926]

B:BD[20.32261] → [52.10365:10594]

B:BD[20.32261] → [38.18513:18591]

B:BD[38.18591] → [92.5770:5921]

B:BD[38.18591] → [38.18591:18742]

B:BD[20.32108] → [70.5299:5372]

B:BD[20.32108] → [29.45723:45796]

B:BD[20.32108] → [46.63580:63653]

B:BD[20.32108] → [47.14227:14300]

B:BD[20.32108] → [30.18758:18831]

B:BD[20.32108] → [49.23247:23320]

B:BD[20.32108] → [20.32108:32181]

B:BD[20.32181] → [20.32181:32261]

B:BD[20.32108] → [39.6237:6310]

B:BD[20.31931] → [40.13370:13390]

B:BD[20.31931] → [41.8282:8302]

B:BD[20.31931] → [92.5675:5695]

B:BD[20.31931] → [70.5278:5298]

B:BD[20.31931] → [111.8397:8417]

B:BD[20.31931] → [42.21619:21639]

B:BD[20.31931] → [43.27903:27923]

B:BD[20.31931] → [29.45702:45722]

B:BD[20.31931] → [44.4357:4377]

B:BD[20.31931] → [46.63559:63579]

B:BD[20.31931] → [47.14206:14226]

B:BD[20.31931] → [33.11549:11569]

B:BD[20.31931] → [48.21534:21554]

B:BD[20.31931] → [30.18737:18757]

B:BD[20.31931] → [49.23226:23246]

B:BD[20.31931] → [50.5919:5939]

B:BD[20.31931] → [51.8766:8786]

B:BD[20.31951] → [20.31951:32108]

B:BD[20.31931] → [20.31931:31951]

B:BD[20.31931] → [52.10344:10364]

B:BD[20.31931] → [38.18492:18512]

B:BD[20.31931] → [53.11874:11894]

B:BD[20.31931] → [54.15213:15233]

B:BD[20.31931] → [55.39295:39315]

B:BD[20.31931] → [37.16754:16774]

B:BD[20.31901] → [29.45583:45701]

B:BD[20.31901] → [20.31901:31914]

B:BD[55.39281] → [55.39281:39294]

B:BD[20.31914] → [42.21500:21618]

B:BD[20.31914] → [20.31914:31931]

B:BD[20.31914] → [55.39176:39281]

B:BD[20.31827] → [40.13297:13369]

B:BD[20.31827] → [41.8209:8281]

B:BD[20.31827] → [92.5602:5674]

B:BD[20.31827] → [70.5205:5277]

B:BD[20.31827] → [111.8324:8396]

B:BD[20.31827] → [42.21427:21499]

B:BD[20.31827] → [43.27711:27783]

B:BD[20.31827] → [29.45510:45582]

B:BD[20.31827] → [44.4284:4356]

B:BD[20.31827] → [46.63486:63558]

B:BD[20.31827] → [47.14133:14205]

B:BD[20.31827] → [22.11141:11213]

B:BD[20.31827] → [33.11476:11548]

B:BD[20.31827] → [48.21342:21414]

B:BD[20.31827] → [30.18664:18736]

B:BD[20.31827] → [49.23153:23225]

B:BD[20.31827] → [50.5846:5918]

B:BD[20.31827] → [51.8693:8765]

B:BD[20.31827] → [20.31827:31899]

B:BD[20.31899] → [20.31899:31901]

B:BD[20.31827] → [52.10271:10343]

B:BD[20.31827] → [38.18419:18491]

B:BD[20.31827] → [53.11801:11873]

B:BD[20.31827] → [54.15140:15212]

B:BD[20.31827] → [55.39103:39175]

B:BD[20.31827] → [37.16681:16753]

B:BD[20.31827] → [39.6164:6236]

B:BD[20.31727] → [40.13278:13296]

B:BD[20.31727] → [41.8190:8208]

B:BD[20.31727] → [140.741:760]

B:BD[20.31727] → [70.5185:5204]

B:BD[20.31727] → [111.8305:8323]

B:BD[20.31727] → [42.21408:21426]

B:BD[20.31727] → [43.27692:27710]

B:BD[20.31727] → [29.45490:45509]

B:BD[20.31727] → [44.4265:4283]

B:BD[20.31727] → [47.14114:14132]

B:BD[20.31727] → [33.11457:11475]

B:BD[20.31727] → [48.21323:21341]

B:BD[20.31727] → [30.18644:18663]

B:BD[20.31727] → [49.23134:23152]

B:BD[20.31727] → [50.5827:5845]

B:BD[20.31727] → [51.8674:8692]

B:BD[20.31727] → [20.31727:31745]

B:BD[20.31745] → [20.31745:31827]

B:BD[20.31727] → [52.10252:10270]

B:BD[20.31727] → [38.18399:18418]

B:BD[20.31727] → [53.11782:11800]

B:BD[20.31727] → [54.15121:15139]

B:BD[20.31727] → [55.39084:39102]

B:BD[20.31727] → [37.16662:16680]

B:BD[20.31727] → [71.5094:5112]

B:BD[20.31282] → [22.11121:11140]

B:BD[20.31282] → [20.31282:31301]

B:BD[20.31301] → [20.31301:31727]

B:BD[20.31156] → [49.23036:23133]

B:BD[20.31156] → [20.31156:31253]

B:BD[20.31253] → [20.31253:31282]

B:BD[20.31156] → [52.10154:10251]

B:BD[20.31156] → [71.4996:5093]

B:BD[20.31073] → [70.5166:5184]

B:BD[20.31073] → [29.45471:45489]

B:BD[20.31073] → [47.13997:14015]

B:BD[20.31073] → [30.18625:18643]

B:BD[20.31073] → [49.23017:23035]

B:BD[20.31073] → [20.31073:31091]

B:BD[20.31091] → [20.31091:31156]

B:BD[20.31027] → [20.31027:31073]

B:BD[20.31073] → [52.10135:10153]

B:BD[20.31073] → [38.18380:18398]

B:BD[20.31073] → [71.4977:4995]

B:BD[20.30809] → [70.5020:5165]

B:BD[20.30809] → [29.45252:45470]

B:BD[20.30809] → [46.63267:63485]

B:BD[20.30809] → [47.13851:13996]

B:BD[20.30809] → [30.18406:18624]

B:BD[20.30809] → [49.22798:23016]

B:BD[20.30809] → [20.30809:30882]

B:BD[20.30954] → [20.30954:31027]

B:BD[20.30882] → [24.9944:10016]

B:BD[20.30882] → [40.13205:13277]

B:BD[20.30882] → [41.8117:8189]

B:BD[20.30882] → [111.8232:8304]

B:BD[20.30882] → [42.21335:21407]

B:BD[20.30882] → [43.27619:27691]

B:BD[20.30882] → [44.4192:4264]

B:BD[20.30882] → [22.11048:11120]

B:BD[20.30882] → [33.11384:11456]

B:BD[20.30882] → [48.21250:21322]

B:BD[20.30882] → [50.5754:5826]

B:BD[20.30882] → [51.8601:8673]

B:BD[20.30882] → [20.30882:30954]

B:BD[20.30882] → [53.11709:11781]

B:BD[20.30882] → [54.15048:15120]

B:BD[20.30882] → [55.39011:39083]

B:BD[20.30882] → [37.16589:16661]

B:BD[20.30809] → [39.6018:6091]

B:BD[39.6091] → [52.10062:10134]

B:BD[39.6091] → [38.18307:18379]

B:BD[39.6091] → [39.6091:6163]

B:BD[43.27543] → [70.4944:5019]

B:BD[43.27543] → [43.27543:27618]

B:BD[43.27543] → [47.13775:13850]

B:BD[43.27543] → [30.18330:18405]

B:BD[43.27543] → [52.9986:10061]

B:BD[43.27543] → [38.18231:18306]

B:BD[43.27543] → [71.4901:4976]

B:BD[29.44926] → [29.44926:45251]

B:BD[20.30679] → [20.30679:30809]

B:BD[20.30354] → [20.30354:30430]

B:BD[24.9868] → [24.9868:9943]

B:BD[20.30515] → [40.13115:13204]

B:BD[20.30515] → [41.8027:8116]

B:BD[20.30515] → [44.4102:4191]

B:BD[24.9868] → [22.10972:11047]

B:BD[20.30515] → [33.11294:11383]

B:BD[20.30515] → [51.8511:8600]

B:BD[20.30604] → [20.30604:30679]

B:BD[20.30515] → [20.30515:30604]

B:BD[20.30515] → [37.16499:16588]

B:BD[20.30430] → [24.9694:9868]

B:BD[20.30430] → [42.21160:21334]

B:BD[20.30430] → [48.21075:21249]

B:BD[20.30430] → [20.30430:30515]

B:BD[20.30430] → [53.11534:11708]

B:BD[20.30430] → [54.14873:15047]

B:BD[20.30430] → [55.38836:39010]

B:BD[38.18154] → [38.18154:18230]

B:BD[20.30275] → [24.9614:9693]

B:BD[20.30275] → [40.13035:13114]

B:BD[20.30275] → [41.7947:8026]

B:BD[20.30275] → [92.5376:5455]

B:BD[20.30275] → [70.4788:4943]

B:BD[20.30275] → [111.8152:8231]

B:BD[20.30275] → [42.21080:21159]

B:BD[20.30275] → [43.27289:27368]

B:BD[20.30275] → [29.44847:44926]

B:BD[20.30275] → [44.4022:4101]

B:BD[20.30275] → [46.63187:63266]

B:BD[20.30275] → [47.13619:13774]

B:BD[20.30275] → [33.11214:11293]

B:BD[20.30275] → [48.20995:21074]

B:BD[20.30275] → [30.18174:18329]

B:BD[20.30275] → [49.22393:22797]

B:BD[20.30275] → [50.5674:5753]

B:BD[20.30275] → [51.8431:8510]

B:BD[20.30275] → [20.30275:30354]

B:BD[20.30275] → [52.9830:9985]

B:BD[20.30275] → [38.18075:18154]

B:BD[20.30275] → [53.11454:11533]

B:BD[20.30275] → [54.14793:14872]

B:BD[20.30275] → [55.38756:38835]

B:BD[20.30275] → [37.16419:16498]

B:BD[24.9537] → [24.9537:9613]

B:BD[20.29899] → [70.4560:4638]

B:BD[22.10971] → [92.5299:5375]

B:BD[22.10971] → [70.4711:4787]

B:BD[22.10971] → [43.27212:27288]

B:BD[22.10971] → [29.44770:44846]

B:BD[22.10971] → [46.63110:63186]

B:BD[22.10971] → [47.13542:13618]

B:BD[22.10901] → [22.10901:10971]

B:BD[22.10971] → [48.20918:20994]

B:BD[22.10971] → [30.18097:18173]

B:BD[22.10971] → [49.22316:22392]

B:BD[22.10971] → [52.9753:9829]

B:BD[22.10971] → [38.17998:18074]

B:BD[22.10971] → [53.11377:11453]

B:BD[70.4638] → [70.4638:4710]

B:BD[70.4638] → [39.5945:6017]

B:BD[20.29899] → [29.44619:44697]

B:BD[29.44697] → [29.44697:44769]

B:BD[29.44697] → [46.63037:63109]

B:BD[20.29899] → [47.13391:13541]

B:BD[20.29899] → [22.10751:10829]

B:BD[22.10829] → [43.27139:27211]

B:BD[22.10829] → [22.10829:10901]

B:BD[22.10829] → [48.20845:20917]

B:BD[22.10829] → [53.11304:11376]

B:BD[20.29899] → [30.17946:18096]

B:BD[20.29899] → [49.22165:22315]

B:BD[20.29899] → [20.29899:29977]

B:BD[20.30049] → [20.30049:30119]

B:BD[20.30119] → [40.12958:13034]

B:BD[20.30119] → [41.7870:7946]

B:BD[20.30119] → [111.8075:8151]

B:BD[20.30119] → [42.21003:21079]

B:BD[20.30119] → [44.3945:4021]

B:BD[20.30119] → [33.11137:11213]

B:BD[20.30119] → [50.5597:5673]

B:BD[20.30119] → [51.8354:8430]

B:BD[20.30119] → [20.30119:30195]

B:BD[20.30119] → [54.14716:14792]

B:BD[20.30119] → [55.38679:38755]

B:BD[20.30119] → [37.16342:16418]

B:BD[20.29977] → [40.12885:12957]

B:BD[20.29977] → [41.7797:7869]

B:BD[20.29977] → [111.8002:8074]

B:BD[20.29977] → [42.20930:21002]

B:BD[20.29977] → [44.3872:3944]

B:BD[20.29977] → [33.11064:11136]

B:BD[20.29977] → [50.5524:5596]

B:BD[20.29977] → [51.8281:8353]

B:BD[20.29977] → [20.29977:30049]

B:BD[20.29977] → [54.14643:14715]

B:BD[20.29977] → [55.38606:38678]

B:BD[20.29977] → [37.16269:16341]

B:BD[20.29899] → [52.9602:9752]

B:BD[20.29899] → [38.17847:17925]

B:BD[38.17925] → [92.5226:5298]

B:BD[38.17925] → [38.17925:17997]

B:BD[20.29191] → [40.12812:12884]

B:BD[20.29191] → [41.7724:7796]

B:BD[20.29191] → [92.5153:5225]

B:BD[20.29191] → [70.4487:4559]

B:BD[20.29191] → [111.7929:8001]

B:BD[20.29191] → [42.20857:20929]

B:BD[20.29191] → [43.27066:27138]

B:BD[20.29191] → [29.44546:44618]

B:BD[20.29191] → [44.3799:3871]

B:BD[20.29191] → [46.62964:63036]

B:BD[20.29191] → [47.13318:13390]

B:BD[20.29191] → [22.10678:10750]

B:BD[20.29191] → [33.10991:11063]

B:BD[20.29191] → [48.20772:20844]

B:BD[20.29191] → [30.17873:17945]

B:BD[20.29191] → [49.22092:22164]

B:BD[20.29191] → [50.5451:5523]

B:BD[20.29191] → [51.8208:8280]

B:BD[20.29191] → [20.29191:29263]

B:BD[20.29263] → [20.29263:29899]

B:BD[20.29191] → [52.9529:9601]

B:BD[20.29191] → [38.17774:17846]

B:BD[20.29191] → [53.11231:11303]

B:BD[20.29191] → [54.14570:14642]

B:BD[20.29191] → [55.38533:38605]

B:BD[20.29191] → [37.16196:16268]

B:BD[20.29191] → [39.5872:5944]

B:BD[20.28843] → [42.20785:20856]

B:BD[20.28843] → [43.26994:27065]

B:BD[20.28843] → [29.44474:44545]

B:BD[20.28843] → [48.20700:20771]

B:BD[20.28843] → [49.22020:22091]

B:BD[20.28843] → [20.28843:28914]

B:BD[20.28914] → [20.28914:29191]

B:BD[20.28843] → [53.11159:11230]

B:BD[20.28843] → [54.14498:14569]

B:BD[20.28843] → [55.38461:38532]

B:BD[20.28483] → [22.10460:10535]

B:BD[22.10607] → [22.10607:10677]

B:BD[22.10535] → [92.5080:5152]

B:BD[20.28700] → [20.28700:28843]

B:BD[22.10535] → [70.4414:4486]

B:BD[22.10535] → [43.26921:26993]

B:BD[22.10535] → [29.44401:44473]

B:BD[22.10535] → [46.62891:62963]

B:BD[22.10535] → [47.13245:13317]

B:BD[22.10535] → [22.10535:10607]

B:BD[22.10535] → [48.20627:20699]

B:BD[22.10535] → [30.17800:17872]

B:BD[22.10535] → [49.21947:22019]

B:BD[22.10535] → [52.9456:9528]

B:BD[22.10535] → [38.17701:17773]

B:BD[22.10535] → [53.11086:11158]

B:BD[22.10535] → [39.5799:5871]

B:BD[20.28483] → [20.28483:28558]

B:BD[20.28630] → [20.28630:28700]

B:BD[20.28558] → [40.12739:12811]

B:BD[20.28558] → [41.7651:7723]

B:BD[20.28558] → [111.7856:7928]

B:BD[20.28558] → [42.20712:20784]

B:BD[20.28558] → [44.3726:3798]

B:BD[20.28558] → [33.10918:10990]

B:BD[20.28558] → [50.5378:5450]

B:BD[20.28558] → [51.8135:8207]

B:BD[20.28558] → [20.28558:28630]

B:BD[20.28558] → [54.14425:14497]

B:BD[20.28558] → [55.38388:38460]

B:BD[20.28558] → [37.16123:16195]

B:BD[20.27805] → [41.7495:7650]

B:BD[20.28037] → [20.28037:28483]

B:BD[20.27805] → [42.20479:20711]

B:BD[20.27805] → [43.26688:26843]

B:BD[43.26843] → [70.4336:4413]

B:BD[43.26843] → [43.26843:26920]

B:BD[43.26843] → [47.13167:13244]

B:BD[43.26843] → [30.17722:17799]

B:BD[43.26843] → [52.9378:9455]

B:BD[43.26843] → [38.17623:17700]

B:BD[20.27805] → [29.44168:44400]

B:BD[20.27805] → [33.10762:10917]

B:BD[20.27805] → [48.20394:20626]

B:BD[20.27805] → [49.21714:21946]

B:BD[20.27805] → [20.27805:27960]

B:BD[20.27960] → [20.27960:28037]

B:BD[20.27805] → [53.10853:11085]

B:BD[20.27805] → [54.14192:14424]

B:BD[20.27805] → [55.38155:38387]

B:BD[20.27705] → [42.20459:20478]

B:BD[20.27705] → [43.26668:26687]

B:BD[20.27705] → [29.44148:44167]

B:BD[20.27705] → [48.20374:20393]

B:BD[20.27705] → [49.21695:21713]

B:BD[20.27705] → [20.27705:27723]

B:BD[20.27723] → [20.27723:27805]

B:BD[20.27705] → [53.10834:10852]

B:BD[20.27705] → [54.14173:14191]

B:BD[20.27705] → [55.38135:38154]

B:BD[20.27316] → [49.21450:21694]

B:BD[20.27316] → [20.27316:27406]

B:BD[24.8621] → [24.8621:8701]

B:BD[20.27560] → [20.27560:27705]

B:BD[20.27558] → [20.27558:27560]

B:BD[20.27478] → [20.27478:27558]

B:BD[20.27406] → [24.8549:8621]

B:BD[20.27406] → [40.12666:12738]

B:BD[20.27406] → [41.7422:7494]

B:BD[20.27406] → [111.7783:7855]

B:BD[20.27406] → [42.20386:20458]

B:BD[20.27406] → [43.26595:26667]

B:BD[20.27406] → [44.3653:3725]

B:BD[20.27406] → [22.10387:10459]

B:BD[20.27406] → [33.10689:10761]

B:BD[20.27406] → [48.20301:20373]

B:BD[20.27406] → [50.5305:5377]

B:BD[20.27406] → [51.8062:8134]

B:BD[20.27406] → [20.27406:27478]

B:BD[20.27406] → [53.10681:10833]

B:BD[20.27406] → [54.14020:14172]

B:BD[20.27406] → [55.38062:38134]

B:BD[20.27406] → [37.16050:16122]

B:BD[20.27316] → [52.9213:9377]

B:BD[20.27316] → [71.4736:4900]

B:BD[20.27233] → [40.12647:12665]

B:BD[20.27233] → [41.7403:7421]

B:BD[20.27233] → [140.627:645]

B:BD[20.27233] → [70.4317:4335]

B:BD[20.27233] → [111.7764:7782]

B:BD[20.27233] → [42.20367:20385]

B:BD[20.27233] → [43.26576:26594]

B:BD[20.27233] → [29.44129:44147]

B:BD[20.27233] → [44.3634:3652]

B:BD[20.27233] → [47.12983:13001]

B:BD[20.27233] → [22.10368:10386]

B:BD[20.27233] → [33.10670:10688]

B:BD[20.27233] → [48.20282:20300]

B:BD[20.27233] → [30.17703:17721]

B:BD[20.27233] → [49.21431:21449]

B:BD[20.27233] → [50.5286:5304]

B:BD[20.27233] → [51.8043:8061]

B:BD[20.27233] → [20.27233:27251]

B:BD[20.27251] → [20.27251:27316]

B:BD[20.27233] → [52.9194:9212]

B:BD[20.27233] → [38.17604:17622]

B:BD[20.27233] → [53.10662:10680]

B:BD[20.27233] → [54.14001:14019]

B:BD[20.27233] → [55.38043:38061]

B:BD[20.27233] → [37.16031:16049]

B:BD[20.27233] → [71.4717:4735]

B:BD[20.27015] → [40.12572:12646]

B:BD[20.27015] → [41.7328:7402]

B:BD[20.27015] → [111.7689:7763]

B:BD[20.27015] → [42.20292:20366]

B:BD[20.27015] → [43.26501:26575]

B:BD[20.27015] → [29.44054:44128]

B:BD[20.27015] → [44.3559:3633]

B:BD[20.27015] → [33.10595:10669]

B:BD[20.27015] → [48.20207:20281]

B:BD[20.27015] → [49.21356:21430]

B:BD[20.27015] → [50.5211:5285]

B:BD[20.27015] → [51.7968:8042]

B:BD[20.27015] → [20.27015:27089]

B:BD[20.27089] → [20.27089:27233]

B:BD[20.26849] → [20.26849:27015]

B:BD[20.27015] → [53.10587:10661]

B:BD[20.27015] → [54.13926:14000]

B:BD[20.27015] → [55.37968:38042]

B:BD[20.27015] → [37.15956:16030]

B:BD[24.8376] → [24.8376:8454]

B:BD[24.8376] → [22.10289:10367]

B:BD[20.26468] → [42.19910:20291]

B:BD[20.26468] → [43.26119:26269]

B:BD[43.26422] → [43.26422:26500]

B:BD[43.26269] → [140.473:626]

B:BD[43.26269] → [70.4085:4316]

B:BD[43.26269] → [43.26269:26422]

B:BD[43.26269] → [47.12751:12982]

B:BD[43.26269] → [30.17471:17702]

B:BD[43.26269] → [52.8962:9193]

B:BD[43.26269] → [38.17372:17603]

B:BD[43.26269] → [71.4563:4716]

B:BD[20.26468] → [29.43672:43822]

B:BD[29.43975] → [29.43975:44053]

B:BD[29.43822] → [29.43822:43975]

B:BD[29.43822] → [46.62737:62890]

B:BD[20.26468] → [48.19825:20206]

B:BD[20.26468] → [49.20974:21355]

B:BD[20.26468] → [20.26468:26618]

B:BD[40.12571] → [31.8554:8632]

B:BD[20.26771] → [20.26771:26849]

B:BD[20.26618] → [40.12418:12571]

B:BD[20.26618] → [41.7174:7327]

B:BD[20.26618] → [111.7535:7688]

B:BD[20.26618] → [44.3405:3558]

B:BD[20.26618] → [33.10441:10594]

B:BD[20.26618] → [50.5057:5210]

B:BD[20.26618] → [51.7814:7967]

B:BD[20.26618] → [20.26618:26771]

B:BD[20.26618] → [37.15724:15955]

B:BD[20.26468] → [53.10205:10586]

B:BD[20.26468] → [54.13544:13925]

B:BD[20.26468] → [55.37586:37967]

B:BD[20.26368] → [40.12399:12417]

B:BD[20.26368] → [41.7155:7173]

B:BD[20.26368] → [111.7516:7534]

B:BD[20.26368] → [42.19891:19909]

B:BD[20.26368] → [43.26100:26118]

B:BD[20.26368] → [29.43653:43671]

B:BD[20.26368] → [44.3386:3404]

B:BD[20.26368] → [33.10422:10440]

B:BD[20.26368] → [48.19806:19824]

B:BD[20.26368] → [49.20955:20973]

B:BD[20.26368] → [50.5038:5056]

B:BD[20.26368] → [51.7795:7813]

B:BD[20.26368] → [20.26368:26386]

B:BD[20.26386] → [20.26386:26468]

B:BD[20.26368] → [53.10186:10204]

B:BD[20.26368] → [54.13525:13543]

B:BD[20.26368] → [55.37567:37585]

B:BD[20.26368] → [37.15705:15723]

B:BD[20.26141] → [29.43570:43652]

B:BD[20.26141] → [46.62654:62736]

B:BD[20.26141] → [47.12668:12750]

B:BD[20.26141] → [30.17388:17470]

B:BD[20.26141] → [49.20872:20954]

B:BD[20.26141] → [20.26141:26223]

B:BD[20.26223] → [20.26223:26368]

B:BD[20.26041] → [29.43551:43569]

B:BD[20.26041] → [46.62635:62653]

B:BD[20.26041] → [47.12649:12667]

B:BD[20.26041] → [30.17369:17387]

B:BD[20.26041] → [49.20853:20871]

B:BD[20.26041] → [20.26041:26059]

B:BD[20.26059] → [20.26059:26141]

B:BD[20.25934] → [70.4011:4084]

B:BD[20.25934] → [29.43477:43550]

B:BD[20.25934] → [46.62561:62634]

B:BD[20.25934] → [47.12575:12648]

B:BD[20.25934] → [30.17295:17368]

B:BD[20.25934] → [49.20779:20852]

B:BD[20.25934] → [20.25934:26007]

B:BD[20.26007] → [20.26007:26041]

B:BD[20.25934] → [39.5725:5798]

B:BD[24.8007] → [24.8007:8035]

B:BD[24.8035] → [22.10270:10288]

B:BD[20.25852] → [20.25852:25934]

B:BD[20.25834] → [24.7837:8007]

B:BD[20.25834] → [20.25834:25852]

B:BD[20.25652] → [22.10192:10269]

B:BD[20.25652] → [20.25652:25729]

B:BD[20.25729] → [20.25729:25806]

B:BD[20.25552] → [22.10173:10191]

B:BD[20.25552] → [20.25552:25570]

B:BD[20.25570] → [20.25570:25652]

B:BD[20.25438] → [29.43458:43476]

B:BD[20.25438] → [46.62542:62560]

B:BD[20.25438] → [47.12556:12574]

B:BD[20.25438] → [30.17276:17294]

B:BD[20.25438] → [49.20760:20778]

B:BD[20.25438] → [20.25438:25456]

B:BD[20.25456] → [20.25456:25552]

B:BD[20.25316] → [40.12379:12398]

B:BD[20.25316] → [41.7135:7154]

B:BD[20.25316] → [92.4865:4884]

B:BD[20.25316] → [70.3991:4010]

B:BD[20.25316] → [111.7496:7515]

B:BD[20.25316] → [42.19871:19890]

B:BD[20.25316] → [43.26080:26099]

B:BD[20.25316] → [29.43438:43457]

B:BD[20.25316] → [44.3366:3385]

B:BD[20.25316] → [46.62522:62541]

B:BD[20.25316] → [47.12536:12555]

B:BD[20.25316] → [22.10153:10172]

B:BD[20.25316] → [33.10402:10421]

B:BD[20.25316] → [48.19786:19805]

B:BD[20.25316] → [30.17256:17275]

B:BD[20.25316] → [49.20740:20759]

B:BD[20.25316] → [50.5018:5037]

B:BD[20.25316] → [51.7775:7794]

B:BD[20.25316] → [20.25316:25335]

B:BD[20.25335] → [20.25335:25438]

B:BD[20.25316] → [52.8942:8961]

B:BD[20.25316] → [38.17352:17371]

B:BD[20.25316] → [53.10166:10185]

B:BD[20.25316] → [54.13505:13524]

B:BD[20.25316] → [55.37547:37566]

B:BD[20.25316] → [37.15685:15704]

B:BD[20.25316] → [39.5705:5724]

B:BD[20.25206] → [22.10134:10152]

B:BD[20.25206] → [20.25206:25224]

B:BD[20.25224] → [20.25224:25316]

B:BD[20.25092] → [70.3972:3990]

B:BD[20.25092] → [29.43419:43437]

B:BD[20.25092] → [47.12517:12535]

B:BD[20.25092] → [22.10115:10133]

B:BD[20.25092] → [30.17237:17255]

B:BD[20.25092] → [49.20721:20739]

B:BD[20.25092] → [20.25092:25110]

B:BD[20.25110] → [20.25110:25175]

B:BD[20.25175] → [20.25175:25206]

B:BD[20.25092] → [52.8923:8941]

B:BD[20.25092] → [38.17333:17351]

B:BD[20.24426] → [41.6979:7134]

B:BD[20.24655] → [20.24655:25092]

B:BD[20.24426] → [42.19640:19870]

B:BD[20.24426] → [43.25849:26079]

B:BD[20.24426] → [29.43188:43418]

B:BD[20.24426] → [33.10246:10401]

B:BD[20.24426] → [48.19555:19785]

B:BD[20.24426] → [49.20491:20720]

B:BD[20.24426] → [20.24426:24581]

B:BD[20.24581] → [20.24581:24655]

B:BD[20.24426] → [53.9936:10165]

B:BD[20.24426] → [54.13275:13504]

B:BD[20.24426] → [55.37316:37546]

B:BD[20.24326] → [42.19621:19639]

B:BD[20.24326] → [43.25830:25848]

B:BD[20.24326] → [29.43169:43187]

B:BD[20.24326] → [48.19536:19554]

B:BD[20.24326] → [49.20472:20490]

B:BD[20.24326] → [20.24326:24344]

B:BD[20.24344] → [20.24344:24426]

B:BD[20.24326] → [53.9917:9935]

B:BD[20.24326] → [54.13256:13274]

B:BD[20.24326] → [55.37297:37315]

B:BD[20.24042] → [46.62448:62521]

B:BD[20.24042] → [30.17163:17236]

B:BD[20.24042] → [49.20398:20471]

B:BD[20.24042] → [20.24042:24115]

B:BD[20.24115] → [20.24115:24326]

B:BD[20.23713] → [22.10096:10114]

B:BD[20.23713] → [20.23713:23731]

B:BD[20.23731] → [20.23731:24042]

B:BD[20.23535] → [40.12306:12378]

B:BD[20.23535] → [41.6906:6978]

B:BD[20.23535] → [92.4792:4864]

B:BD[20.23535] → [70.3899:3971]

B:BD[20.23535] → [111.7423:7495]

B:BD[20.23535] → [42.19548:19620]

B:BD[20.23535] → [43.25757:25829]

B:BD[20.23535] → [29.43022:43094]

B:BD[20.23535] → [44.3293:3365]

B:BD[20.23535] → [46.62375:62447]

B:BD[20.23535] → [47.12444:12516]

B:BD[20.23535] → [22.10023:10095]

B:BD[20.23535] → [33.10173:10245]

B:BD[20.23535] → [48.19463:19535]

B:BD[20.23535] → [30.17090:17162]

B:BD[20.23535] → [49.20325:20397]

B:BD[20.23535] → [50.4945:5017]

B:BD[20.23535] → [51.7702:7774]

B:BD[20.23535] → [20.23535:23607]

B:BD[20.23607] → [20.23607:23713]

B:BD[20.23535] → [52.8850:8922]

B:BD[20.23535] → [38.17260:17332]

B:BD[20.23535] → [53.9844:9916]

B:BD[20.23535] → [54.13183:13255]

B:BD[20.23535] → [55.37224:37296]

B:BD[20.23535] → [37.15612:15684]

B:BD[20.23535] → [39.5632:5704]

B:BD[20.23203] → [29.42933:43021]

B:BD[20.23203] → [49.20236:20324]

B:BD[20.23291] → [20.23291:23535]

B:BD[20.23203] → [20.23203:23291]

B:BD[20.22850] → [20.22850:23203]

B:BD[24.7079] → [24.7079:7240]

B:BD[24.7079] → [22.9861:9944]

B:BD[24.6923] → [24.6923:7003]

B:BD[24.6923] → [22.9780:9860]

B:BD[24.6693] → [24.6693:6766]

B:BD[24.6693] → [22.9706:9779]

B:BD[20.22231] → [40.12233:12305]

B:BD[20.22772] → [20.22772:22850]

B:BD[20.22231] → [41.6833:6905]

B:BD[20.22231] → [70.3502:3582]

B:BD[43.25118] → [92.4718:4791]

B:BD[43.25272] → [70.3657:3813]

B:BD[43.25504] → [70.3814:3898]

B:BD[43.25504] → [43.25504:25588]

B:BD[43.25588] → [43.25588:25667]

B:BD[43.25504] → [47.12359:12443]

B:BD[43.25504] → [30.17005:17089]

B:BD[43.25504] → [52.8765:8849]

B:BD[43.25504] → [38.17175:17259]

B:BD[43.25272] → [43.25272:25428]

B:BD[43.25428] → [43.25428:25504]

B:BD[43.25272] → [47.12202:12358]

B:BD[43.25272] → [52.8608:8764]

B:BD[43.25272] → [38.17018:17174]

B:BD[43.25118] → [70.3583:3656]

B:BD[43.25118] → [43.25118:25191]

B:BD[43.25191] → [43.25191:25272]

B:BD[43.25118] → [47.12128:12201]

B:BD[43.25118] → [30.16694:17004]

B:BD[43.25118] → [52.8534:8607]

B:BD[43.25118] → [38.16944:17017]

B:BD[20.22231] → [111.7350:7422]

B:BD[20.22231] → [42.19005:19547]

B:BD[20.22231] → [43.25046:25118]

B:BD[20.22231] → [29.42231:42383]

B:BD[29.42537] → [29.42537:42769]

B:BD[29.42853] → [29.42853:42932]

B:BD[29.42769] → [29.42769:42853]

B:BD[29.42769] → [46.62290:62374]

B:BD[29.42383] → [29.42383:42537]

B:BD[29.42383] → [46.62135:62289]

B:BD[20.22231] → [44.3220:3292]

B:BD[20.22231] → [33.10100:10172]

B:BD[20.22231] → [48.18920:19462]

B:BD[20.22231] → [30.16613:16693]

B:BD[20.22231] → [49.19616:20235]

B:BD[20.22231] → [50.4872:4944]

B:BD[20.22231] → [51.7629:7701]

B:BD[20.22231] → [20.22231:22303]

B:BD[20.22303] → [20.22303:22772]

B:BD[20.22231] → [38.16863:16943]

B:BD[20.22231] → [53.9302:9843]

B:BD[20.22231] → [54.12641:13182]

B:BD[20.22231] → [55.36681:37223]

B:BD[20.22231] → [37.15539:15611]

B:BD[20.22089] → [22.9635:9705]

B:BD[20.22089] → [20.22089:22159]

B:BD[20.22159] → [20.22159:22231]

B:BD[20.21729] → [92.4647:4717]

B:BD[20.21871] → [20.21871:22089]

B:BD[20.21729] → [42.18934:19004]

B:BD[20.21729] → [43.24903:24973]

B:BD[43.24973] → [70.3429:3501]

B:BD[43.24973] → [43.24973:25045]

B:BD[43.24973] → [52.8461:8533]

B:BD[43.24973] → [38.16790:16862]

B:BD[20.21729] → [29.42088:42230]

B:BD[20.21729] → [46.61992:62134]

B:BD[20.21729] → [47.11985:12127]

B:BD[20.21729] → [22.9492:9562]

B:BD[22.9562] → [22.9562:9634]

B:BD[20.21729] → [48.18849:18919]

B:BD[20.21729] → [30.16470:16612]

B:BD[20.21729] → [49.19473:19615]

B:BD[20.21729] → [20.21729:21799]

B:BD[20.21799] → [20.21799:21871]

B:BD[20.21647] → [20.21647:21729]

B:BD[20.21729] → [53.9231:9301]

B:BD[20.21729] → [54.12570:12640]

B:BD[20.21729] → [55.36610:36680]

B:BD[20.21499] → [92.4573:4646]

B:BD[20.21499] → [70.3355:3428]

B:BD[20.21499] → [29.41939:42087]

B:BD[20.21499] → [46.61843:61991]

B:BD[20.21499] → [47.11911:11984]

B:BD[20.21499] → [22.9418:9491]

B:BD[20.21499] → [30.16321:16469]

B:BD[20.21499] → [49.19324:19472]

B:BD[20.21499] → [20.21499:21572]

B:BD[20.21572] → [20.21572:21647]

B:BD[20.21499] → [39.5558:5631]

B:BD[20.21397] → [40.12212:12232]

B:BD[20.21397] → [41.6812:6832]

B:BD[20.21397] → [140.452:472]

B:BD[20.21397] → [70.3334:3354]

B:BD[20.21397] → [111.7329:7349]

B:BD[20.21397] → [42.18913:18933]

B:BD[20.21397] → [43.24882:24902]

B:BD[20.21397] → [29.41918:41938]

B:BD[20.21397] → [44.3199:3219]

B:BD[20.21397] → [46.61822:61842]

B:BD[20.21397] → [47.11890:11910]

B:BD[20.21397] → [22.9397:9417]

B:BD[20.21397] → [33.10079:10099]

B:BD[20.21397] → [48.18828:18848]

B:BD[20.21397] → [30.16300:16320]

B:BD[20.21397] → [49.19303:19323]

B:BD[20.21397] → [50.4851:4871]

B:BD[20.21397] → [51.7608:7628]

B:BD[20.21397] → [20.21397:21417]

B:BD[20.21417] → [20.21417:21499]

B:BD[20.21397] → [52.8440:8460]

B:BD[20.21397] → [38.16769:16789]

B:BD[20.21397] → [53.9210:9230]

B:BD[20.21397] → [54.12549:12569]

B:BD[20.21397] → [55.36589:36609]

B:BD[20.21397] → [37.15518:15538]

B:BD[20.21397] → [71.4542:4562]

B:BD[20.21382] → [20.21382:21397]

B:BD[20.21092] → [20.21092:21157]

B:BD[20.21157] → [20.21157:21170]

B:BD[20.20827] → [24.6238:6311]

B:BD[20.20827] → [92.4499:4572]

B:BD[20.20827] → [70.3260:3333]

B:BD[20.20827] → [29.41844:41917]

B:BD[20.20827] → [46.61748:61821]

B:BD[20.20827] → [47.11816:11889]

B:BD[20.20827] → [22.9109:9182]

B:BD[20.20827] → [30.16226:16299]

B:BD[20.20827] → [49.19229:19302]

B:BD[20.20827] → [20.20827:20900]

B:BD[20.20827] → [39.5484:5557]

B:BD[20.20726] → [24.6218:6237]

B:BD[20.20726] → [70.3240:3259]

B:BD[20.20726] → [43.24862:24881]

B:BD[20.20726] → [29.41824:41843]

B:BD[20.20726] → [46.61728:61747]

B:BD[20.20726] → [47.11796:11815]

B:BD[20.20726] → [22.9089:9108]

B:BD[20.20726] → [30.16206:16225]

B:BD[20.20726] → [49.19209:19228]

B:BD[20.20726] → [20.20726:20745]

B:BD[20.20726] → [52.8420:8439]

B:BD[20.20726] → [38.16749:16768]

B:BD[20.20551] → [24.6145:6217]

B:BD[20.20551] → [40.12139:12211]

B:BD[20.20551] → [41.6739:6811]

B:BD[20.20551] → [92.4426:4498]

B:BD[20.20551] → [70.3167:3239]

B:BD[20.20551] → [111.7256:7328]

B:BD[20.20551] → [42.18840:18912]

B:BD[20.20551] → [43.24789:24861]

B:BD[20.20551] → [29.41751:41823]

B:BD[20.20551] → [44.3126:3198]

B:BD[20.20551] → [46.61655:61727]

B:BD[20.20551] → [47.11723:11795]

B:BD[20.20551] → [22.9016:9088]

B:BD[20.20551] → [33.10006:10078]

B:BD[20.20551] → [48.18755:18827]

B:BD[20.20551] → [30.16133:16205]

B:BD[20.20551] → [49.19136:19208]

B:BD[20.20551] → [50.4778:4850]

B:BD[20.20551] → [51.7535:7607]

B:BD[20.20551] → [20.20551:20623]

B:BD[20.20551] → [52.8347:8419]

B:BD[20.20551] → [38.16676:16748]

B:BD[20.20551] → [53.9137:9209]

B:BD[20.20551] → [54.12476:12548]

B:BD[20.20551] → [55.36516:36588]

B:BD[20.20551] → [37.15445:15517]

B:BD[20.20551] → [39.5411:5483]

B:BD[20.20418] → [20.20418:20433]

B:BD[42.18575] → [42.18575:18839]

B:BD[24.6068] → [24.6068:6144]

B:BD[24.5995] → [22.8942:9015]

B:BD[24.5924] → [24.5924:5995]

B:BD[20.20128] → [22.8871:8941]

B:BD[43.24433] → [70.3090:3166]

B:BD[48.18490] → [48.18490:18754]

B:BD[43.24433] → [43.24433:24509]

B:BD[43.24509] → [43.24509:24788]

B:BD[43.24433] → [47.11646:11722]

B:BD[48.18475] → [48.18475:18490]

B:BD[43.24433] → [30.16056:16132]

B:BD[43.24433] → [52.8270:8346]

B:BD[43.24433] → [38.16599:16675]

B:BD[22.8941] → [43.24289:24433]

B:BD[22.8941] → [29.41251:41750]

B:BD[22.8941] → [48.18255:18475]

B:BD[22.8941] → [49.18915:19135]

B:BD[22.8941] → [53.8916:9136]

B:BD[20.20128] → [20.20128:20198]

B:BD[20.20198] → [42.18340:18560]

B:BD[20.20198] → [20.20198:20418]

B:BD[20.20198] → [54.12255:12475]

B:BD[20.20198] → [55.36016:36515]

B:BD[20.19906] → [46.61507:61654]

B:BD[20.19906] → [30.15908:16055]

B:BD[20.19906] → [49.18767:18914]

B:BD[20.19906] → [20.19906:19981]

B:BD[20.20053] → [20.20053:20128]

B:BD[20.19981] → [24.5781:5853]

B:BD[20.19981] → [70.3017:3089]

B:BD[20.19981] → [43.24216:24288]

B:BD[20.19981] → [47.11573:11645]

B:BD[20.19981] → [22.8798:8870]

B:BD[20.19981] → [20.19981:20053]

B:BD[20.19981] → [52.8197:8269]

B:BD[20.19981] → [38.16526:16598]

B:BD[20.19836] → [20.19836:19906]

B:BD[24.5707] → [24.5707:5780]

B:BD[24.5707] → [22.8724:8797]

B:BD[20.19687] → [42.18263:18339]

B:BD[20.19687] → [43.24139:24215]

B:BD[43.24215] → [92.4352:4425]

B:BD[43.24215] → [70.2943:3016]

B:BD[43.24215] → [47.11499:11572]

B:BD[43.24215] → [30.15834:15907]

B:BD[43.24215] → [39.5337:5410]

B:BD[20.19687] → [29.40953:41029]

B:BD[29.41029] → [29.41029:41102]

B:BD[29.41029] → [46.61433:61506]

B:BD[20.19687] → [48.18178:18254]

B:BD[20.19687] → [49.18617:18766]

B:BD[20.19687] → [20.19687:19763]

B:BD[20.19763] → [20.19763:19836]

B:BD[20.19687] → [53.8839:8915]

B:BD[20.19687] → [54.12178:12254]

B:BD[20.19687] → [55.35939:36015]

B:BD[20.19586] → [92.4332:4351]

B:BD[20.19586] → [42.18243:18262]

B:BD[20.19586] → [43.24119:24138]

B:BD[20.19586] → [29.40933:40952]

B:BD[20.19586] → [46.61413:61432]

B:BD[20.19586] → [47.11479:11498]

B:BD[20.19586] → [22.8704:8723]

B:BD[20.19586] → [48.18158:18177]

B:BD[20.19586] → [30.15814:15833]

B:BD[20.19586] → [49.18597:18616]

B:BD[20.19586] → [20.19586:19605]

B:BD[20.19605] → [20.19605:19687]

B:BD[20.19586] → [53.8819:8838]

B:BD[20.19586] → [54.12158:12177]

B:BD[20.19586] → [55.35919:35938]

B:BD[20.19384] → [42.18223:18242]

B:BD[20.19384] → [43.24099:24118]

B:BD[20.19384] → [29.40913:40932]

B:BD[20.19384] → [48.18138:18157]

B:BD[20.19384] → [49.18578:18596]

B:BD[20.19384] → [20.19384:19402]

B:BD[20.19402] → [20.19402:19586]

B:BD[20.19346] → [20.19346:19384]

B:BD[20.19384] → [53.8800:8818]

B:BD[20.19384] → [54.12139:12157]

B:BD[20.19384] → [55.35899:35918]

B:BD[29.40836] → [29.40836:40912]

B:BD[20.19196] → [46.61337:61412]

B:BD[20.19196] → [30.15662:15813]

B:BD[20.19196] → [49.18427:18577]

B:BD[20.19196] → [20.19196:19271]

B:BD[20.19271] → [24.5516:5591]

B:BD[20.19271] → [40.12063:12138]

B:BD[20.19271] → [41.6663:6738]

B:BD[20.19271] → [140.375:451]

B:BD[20.19271] → [70.2866:2942]

B:BD[20.19271] → [111.7180:7255]

B:BD[20.19271] → [42.18147:18222]

B:BD[20.19271] → [43.24023:24098]

B:BD[20.19271] → [44.3050:3125]

B:BD[20.19271] → [47.11403:11478]

B:BD[20.19271] → [33.9930:10005]

B:BD[20.19271] → [48.18062:18137]

B:BD[20.19271] → [50.4702:4777]

B:BD[20.19271] → [51.7459:7534]

B:BD[20.19271] → [20.19271:19346]

B:BD[20.19271] → [52.8121:8196]

B:BD[20.19271] → [38.16449:16525]

B:BD[20.19271] → [53.8724:8799]

B:BD[20.19271] → [54.12063:12138]

B:BD[20.19271] → [55.35823:35898]

B:BD[20.19271] → [37.15369:15444]

B:BD[20.19271] → [71.4466:4541]

B:BD[20.18974] → [46.61317:61336]

B:BD[20.18974] → [30.15642:15661]

B:BD[20.18974] → [49.18407:18426]

B:BD[20.18974] → [20.18974:18993]

B:BD[20.18993] → [20.18993:19196]

B:BD[20.18854] → [70.2777:2865]

B:BD[20.18854] → [29.40652:40740]

B:BD[20.18854] → [47.11314:11402]

B:BD[20.18854] → [30.15553:15641]

B:BD[20.18854] → [49.18318:18406]

B:BD[20.18854] → [20.18854:18942]

B:BD[20.18942] → [20.18942:18974]

B:BD[20.18854] → [52.8032:8120]

B:BD[20.18854] → [38.16360:16448]

B:BD[20.18854] → [71.4377:4465]

B:BD[20.18151] → [29.40532:40651]

B:BD[20.17353] → [42.17922:18146]

B:BD[20.18151] → [20.18151:18854]

B:BD[20.17657] → [20.17657:18151]

B:BD[20.17353] → [43.23678:23757]

B:BD[43.23830] → [92.4259:4331]

B:BD[43.23830] → [70.2704:2776]

B:BD[43.23830] → [43.23830:23902]

B:BD[43.23830] → [47.11241:11313]

B:BD[22.8623] → [22.8623:8703]

B:BD[43.23830] → [52.7959:8031]

B:BD[43.23830] → [38.16287:16359]

B:BD[43.23830] → [39.5264:5336]

B:BD[43.23757] → [43.23757:23830]

B:BD[43.23757] → [30.15407:15552]

B:BD[20.17353] → [29.40307:40386]

B:BD[29.40386] → [29.40386:40531]

B:BD[29.40386] → [46.61171:61316]

B:BD[20.17353] → [22.8399:8623]

B:BD[20.17353] → [48.17837:18061]

B:BD[20.17353] → [49.18093:18317]

B:BD[20.17353] → [20.17353:17505]

B:BD[20.17577] → [20.17577:17657]

B:BD[20.17505] → [40.11990:12062]

B:BD[20.17505] → [41.6590:6662]

B:BD[20.17505] → [111.7107:7179]

B:BD[20.17505] → [44.2977:3049]

B:BD[20.17505] → [33.9857:9929]

B:BD[20.17505] → [50.4629:4701]

B:BD[20.17505] → [51.7386:7458]

B:BD[20.17505] → [20.17505:17577]

B:BD[20.17505] → [37.15296:15368]

B:BD[20.17353] → [53.8499:8723]

B:BD[20.17353] → [54.11838:12062]

B:BD[20.17353] → [55.35598:35822]

B:BD[20.17253] → [41.6571:6589]

B:BD[20.17253] → [42.17903:17921]

B:BD[20.17253] → [43.23659:23677]

B:BD[20.17253] → [29.40288:40306]

B:BD[20.17253] → [33.9838:9856]

B:BD[20.17253] → [48.17818:17836]

B:BD[20.17253] → [49.18074:18092]

B:BD[20.17271] → [20.17271:17353]

B:BD[20.17253] → [20.17253:17271]

B:BD[20.17253] → [53.8480:8498]

B:BD[20.17253] → [54.11819:11837]

B:BD[20.17253] → [55.35579:35597]

B:BD[43.23577] → [43.23577:23658]

B:BD[29.40206] → [29.40206:40287]

B:BD[20.17214] → [20.17214:17253]

B:BD[20.17133] → [20.17133:17214]

B:BD[20.17057] → [24.5035:5192]

B:BD[20.17057] → [40.11912:11989]

B:BD[20.17057] → [41.6413:6489]

B:BD[20.17057] → [70.2626:2703]

B:BD[20.17057] → [111.7029:7106]

B:BD[20.17057] → [42.17744:17902]

B:BD[20.17057] → [43.23500:23577]

B:BD[20.17057] → [29.40129:40206]

B:BD[20.17057] → [44.2899:2976]

B:BD[20.17057] → [46.61093:61170]

B:BD[20.17057] → [47.11163:11240]

B:BD[20.17057] → [33.9679:9837]

B:BD[20.17057] → [48.17659:17817]

B:BD[20.17057] → [30.15329:15406]

B:BD[20.17057] → [49.17916:18073]

B:BD[20.17057] → [50.4552:4628]

B:BD[20.17057] → [51.7309:7385]

B:BD[20.17057] → [20.17057:17133]

B:BD[20.17057] → [52.7881:7958]

B:BD[20.17057] → [38.16209:16286]

B:BD[20.17057] → [53.8322:8479]

B:BD[20.17057] → [54.11661:11818]

B:BD[20.17057] → [55.35420:35578]

B:BD[20.17057] → [37.15219:15295]

B:BD[20.16957] → [24.5016:5034]

B:BD[20.16957] → [41.6394:6412]

B:BD[20.16957] → [42.17725:17743]

B:BD[20.16957] → [43.23481:23499]

B:BD[20.16957] → [29.40110:40128]

B:BD[20.16957] → [33.9660:9678]

B:BD[20.16957] → [48.17640:17658]

B:BD[20.16957] → [49.17897:17915]

B:BD[20.16957] → [20.16957:16975]

B:BD[20.16957] → [53.8303:8321]

B:BD[20.16957] → [54.11642:11660]

B:BD[20.16957] → [55.35401:35419]

B:BD[20.16849] → [24.4939:5015]

B:BD[20.16849] → [40.11834:11911]

B:BD[20.16849] → [41.6317:6393]

B:BD[20.16849] → [70.2548:2625]

B:BD[20.16849] → [111.6951:7028]

B:BD[20.16849] → [42.17647:17724]

B:BD[20.16849] → [43.23403:23480]

B:BD[20.16849] → [29.40032:40109]

B:BD[20.16849] → [44.2821:2898]

B:BD[20.16849] → [46.61015:61092]

B:BD[20.16849] → [47.11085:11162]

B:BD[20.16849] → [33.9582:9659]

B:BD[20.16849] → [48.17562:17639]

B:BD[20.16849] → [30.15251:15328]

B:BD[20.16849] → [49.17820:17896]

B:BD[20.16849] → [50.4475:4551]

B:BD[20.16849] → [51.7232:7308]

B:BD[20.16849] → [20.16849:16925]

B:BD[20.16849] → [52.7803:7880]

B:BD[20.16849] → [38.16131:16208]

B:BD[20.16849] → [53.8226:8302]

B:BD[20.16849] → [54.11565:11641]

B:BD[20.16849] → [55.35323:35400]

B:BD[20.16849] → [37.15142:15218]

B:BD[20.16536] → [20.16536:16749]

B:BD[20.16500] → [20.16500:16536]

B:BD[20.16134] → [20.16134:16352]

B:BD[20.16424] → [20.16424:16500]

B:BD[20.16352] → [40.11761:11833]

B:BD[20.16352] → [41.6244:6316]

B:BD[20.16352] → [111.6878:6950]

B:BD[20.16352] → [42.17574:17646]

B:BD[20.16352] → [44.2748:2820]

B:BD[20.16352] → [33.9509:9581]

B:BD[20.16352] → [50.4402:4474]

B:BD[20.16352] → [51.7159:7231]

B:BD[20.16352] → [20.16352:16424]

B:BD[20.16352] → [54.11278:11350]

B:BD[20.16352] → [55.35250:35322]

B:BD[20.16352] → [37.15069:15141]

B:BD[20.16052] → [20.16052:16134]

B:BD[20.16536] → [54.11351:11564]

B:BD[24.4842] → [24.4842:4861]

B:BD[24.4842] → [49.17606:17819]

B:BD[24.4842] → [53.8012:8225]

B:BD[20.16014] → [20.16014:16052]

B:BD[22.8250] → [70.2475:2547]

B:BD[20.15999] → [20.15999:16014]

B:BD[22.8250] → [43.23330:23402]

B:BD[22.8250] → [29.39959:40031]

B:BD[22.8250] → [46.60942:61014]

B:BD[22.8250] → [47.11012:11084]

B:BD[22.8250] → [22.8250:8322]

B:BD[22.8250] → [48.17489:17561]

B:BD[22.8250] → [30.15178:15250]

B:BD[22.8250] → [49.17533:17605]

B:BD[22.8250] → [52.7730:7802]

B:BD[22.8250] → [38.16058:16130]

B:BD[22.8250] → [53.7939:8011]

B:BD[22.7932] → [92.4240:4258]

B:BD[22.7932] → [70.2456:2474]

B:BD[22.7932] → [29.39940:39958]

B:BD[22.7932] → [46.60923:60941]

B:BD[22.7932] → [47.10993:11011]

B:BD[22.7932] → [22.7932:7950]

B:BD[22.7932] → [30.15159:15177]

B:BD[22.7932] → [49.17514:17532]

B:BD[22.7932] → [39.5245:5263]

B:BD[20.15926] → [92.4166:4239]

B:BD[20.15926] → [70.2382:2455]

B:BD[20.15926] → [29.39866:39939]

B:BD[20.15926] → [46.60849:60922]

B:BD[20.15926] → [47.10919:10992]

B:BD[20.15926] → [30.15085:15158]

B:BD[20.15926] → [49.17440:17513]

B:BD[20.15926] → [20.15926:15999]

B:BD[20.15926] → [39.5171:5244]

B:BD[20.15825] → [24.4801:4820]

B:BD[20.15825] → [40.11741:11760]

B:BD[20.15825] → [41.6224:6243]

B:BD[20.15825] → [140.266:285]

B:BD[20.15825] → [70.2362:2381]

B:BD[20.15825] → [111.6858:6877]

B:BD[20.15825] → [42.17554:17573]

B:BD[20.15825] → [43.23310:23329]

B:BD[20.15825] → [29.39846:39865]

B:BD[20.15825] → [44.2728:2747]

B:BD[20.15825] → [47.10899:10918]

B:BD[20.15825] → [22.7877:7896]

B:BD[20.15825] → [33.9489:9508]

B:BD[20.15825] → [48.17469:17488]

B:BD[20.15825] → [30.15065:15084]

B:BD[20.15825] → [49.17420:17439]

B:BD[20.15825] → [50.4382:4401]

B:BD[20.15825] → [51.7139:7158]

B:BD[20.15825] → [20.15825:15844]

B:BD[20.15825] → [52.7710:7729]

B:BD[20.15825] → [38.16038:16057]

B:BD[20.15825] → [53.7919:7938]

B:BD[20.15825] → [54.11258:11277]

B:BD[20.15825] → [55.35230:35249]

B:BD[20.15825] → [37.15049:15068]

B:BD[20.15825] → [71.4357:4376]

B:BD[20.15709] → [24.4720:4800]

B:BD[20.15709] → [42.17472:17553]

B:BD[20.15709] → [43.23228:23309]

B:BD[20.15709] → [29.39764:39845]

B:BD[20.15709] → [48.17387:17468]

B:BD[20.15709] → [49.17339:17419]

B:BD[20.15709] → [20.15709:15789]

B:BD[20.15709] → [53.7838:7918]

B:BD[20.15709] → [54.11177:11257]

B:BD[20.15709] → [55.35148:35229]

B:BD[20.15609] → [24.4701:4719]

B:BD[20.15609] → [42.17453:17471]

B:BD[20.15609] → [43.23209:23227]

B:BD[20.15609] → [29.39745:39763]

B:BD[20.15609] → [48.17368:17386]

B:BD[20.15609] → [49.17320:17338]

B:BD[20.15609] → [20.15609:15627]

B:BD[20.15609] → [53.7819:7837]

B:BD[20.15609] → [54.11158:11176]

B:BD[20.15609] → [55.35129:35147]

B:BD[20.14952] → [20.14952:15240]

B:BD[20.14774] → [42.17298:17452]

B:BD[20.14774] → [20.14774:14937]

B:BD[20.14774] → [54.11005:11157]

B:BD[54.10965] → [54.10965:11004]

B:BD[54.10787] → [54.10787:10950]

B:BD[54.10950] → [54.10950:10965]

B:BD[54.10787] → [55.34974:35128]

B:BD[20.14566] → [24.4344:4507]

B:BD[20.14566] → [48.17213:17367]

B:BD[20.14654] → [20.14654:14674]

B:BD[54.10705] → [54.10705:10787]

B:BD[20.14674] → [42.17279:17297]

B:BD[20.14674] → [20.14674:14692]

B:BD[20.14674] → [54.10687:10705]

B:BD[20.14674] → [55.34955:34973]

B:BD[20.14639] → [20.14639:14654]

B:BD[20.14566] → [20.14566:14639]

B:BD[20.14566] → [53.7666:7818]

B:BD[53.7448] → [29.39590:39744]

B:BD[53.7448] → [49.17167:17319]

B:BD[20.14484] → [20.14484:14566]

B:BD[53.7448] → [53.7448:7611]

B:BD[53.7611] → [53.7611:7626]

B:BD[53.7366] → [53.7366:7448]

B:BD[24.4325] → [24.4325:4343]

B:BD[24.4325] → [43.23035:23053]

B:BD[24.4325] → [48.17194:17212]

B:BD[24.4325] → [53.7348:7366]

B:BD[24.4292] → [24.4292:4305]

B:BD[24.4305] → [29.39551:39589]

B:BD[22.7874] → [22.7874:7876]

B:BD[24.4305] → [49.17127:17166]

B:BD[22.7801] → [70.2210:2283]

B:BD[70.2283] → [70.2283:2361]

B:BD[22.7801] → [29.39399:39472]

B:BD[29.39472] → [29.39472:39550]

B:BD[22.7801] → [46.60775:60848]

B:BD[22.7801] → [47.10747:10898]

B:BD[22.7801] → [22.7801:7874]

B:BD[22.7874] → [43.22956:23034]

B:BD[24.4292] → [22.7784:7801]

B:BD[39.5170] → [52.7631:7709]

B:BD[39.5170] → [38.15959:16037]

B:BD[22.7801] → [30.14913:15064]

B:BD[22.7801] → [49.16963:17126]

B:BD[22.7801] → [39.5097:5170]

B:BD[24.4227] → [24.4227:4292]

B:BD[20.14466] → [40.11722:11740]

B:BD[20.14466] → [41.6205:6223]

B:BD[20.14466] → [111.6839:6857]

B:BD[20.14466] → [42.17260:17278]

B:BD[20.14466] → [43.22937:22955]

B:BD[30.14912] → [29.39355:39398]

B:BD[20.14466] → [44.2709:2727]

B:BD[20.14466] → [22.7765:7783]

B:BD[20.14466] → [33.9470:9488]

B:BD[20.14466] → [48.17175:17193]

B:BD[30.14912] → [49.16924:16962]

B:BD[20.14466] → [50.4363:4381]

B:BD[20.14466] → [51.7120:7138]

B:BD[20.14466] → [20.14466:14484]

B:BD[20.14466] → [53.7329:7347]

B:BD[20.14466] → [54.10668:10686]

B:BD[20.14466] → [55.34936:34954]

B:BD[20.14466] → [37.15030:15048]

B:BD[30.14815] → [30.14815:14897]

B:BD[30.14897] → [30.14897:14912]

B:BD[30.14815] → [49.16850:16923]

B:BD[20.14441] → [30.14690:14733]

B:BD[30.14733] → [30.14733:14815]

B:BD[20.14441] → [49.16806:16849]

B:BD[20.14441] → [20.14441:14466]

B:BD[47.10346] → [29.38899:38917]

B:BD[38.15876] → [29.38918:38994]

B:BD[29.39067] → [29.39067:39227]

B:BD[20.14426] → [20.14426:14441]

B:BD[29.38994] → [29.38994:39067]

B:BD[47.10593] → [47.10593:10746]

B:BD[29.38994] → [46.60701:60774]

B:BD[38.15876] → [47.10365:10441]

B:BD[38.15876] → [38.15876:15958]

B:BD[38.15958] → [47.10515:10593]

B:BD[38.15958] → [30.14611:14689]

B:BD[47.10441] → [47.10441:10514]

B:BD[47.10441] → [30.14537:14610]

B:BD[38.15876] → [49.16497:16805]

B:BD[47.10346] → [47.10346:10364]

B:BD[38.15751] → [47.10321:10346]

B:BD[38.15794] → [38.15794:15876]

B:BD[47.10346] → [49.16478:16496]

B:BD[38.15751] → [38.15751:15794]

B:BD[20.14113] → [40.11639:11721]

B:BD[20.14273] → [20.14273:14426]

B:BD[20.14113] → [41.6122:6204]

B:BD[43.22853] → [92.4018:4091]

B:BD[43.22936] → [70.1908:1986]

B:BD[43.22936] → [52.7552:7630]

B:BD[43.22936] → [38.15657:15735]

B:BD[43.22853] → [70.1834:1907]

B:BD[20.14113] → [111.6756:6838]

B:BD[20.14113] → [42.17177:17259]

B:BD[20.14113] → [43.22854:22936]

B:BD[20.14113] → [44.2626:2708]

B:BD[20.14113] → [22.7604:7686]

B:BD[22.7686] → [22.7686:7764]

B:BD[20.14113] → [33.9387:9469]

B:BD[20.14113] → [48.17092:17174]

B:BD[20.14113] → [50.4280:4362]

B:BD[20.14113] → [51.7037:7119]

B:BD[20.14113] → [20.14113:14195]

B:BD[20.14195] → [20.14195:14273]

B:BD[20.14040] → [20.14040:14113]

B:BD[20.14426] → [38.15736:15751]

B:BD[20.14113] → [53.7246:7328]

B:BD[20.14113] → [54.10585:10667]

B:BD[20.14113] → [55.34853:34935]

B:BD[20.14113] → [37.14947:15029]

B:BD[43.22853] → [39.5023:5096]

B:BD[20.13965] → [24.3972:4047]

B:BD[20.13965] → [40.11562:11638]

B:BD[20.13965] → [41.6046:6121]

B:BD[20.13965] → [111.6680:6755]

B:BD[20.13965] → [42.17100:17176]

B:BD[20.13965] → [43.22777:22853]

B:BD[20.13965] → [29.38734:38898]

B:BD[20.13965] → [44.2549:2625]

B:BD[20.13965] → [47.10238:10320]

B:BD[20.13965] → [22.7528:7603]

B:BD[20.13965] → [33.9310:9386]

B:BD[20.13965] → [48.17015:17091]

B:BD[20.13965] → [49.16313:16477]

B:BD[20.13965] → [50.4204:4279]

B:BD[20.13965] → [51.6961:7036]

B:BD[20.13965] → [20.13965:14040]

B:BD[20.13965] → [53.7170:7245]

B:BD[20.13965] → [54.10509:10584]

B:BD[20.13965] → [55.34776:34852]

B:BD[20.13965] → [37.14871:14946]

B:BD[47.10219] → [29.38715:38733]

B:BD[47.10219] → [47.10219:10237]

B:BD[47.10219] → [30.14518:14536]

B:BD[47.10219] → [49.16294:16312]

B:BD[20.13840] → [20.13840:13865]

B:BD[20.13865] → [24.3953:3971]

B:BD[20.13865] → [40.11543:11561]

B:BD[20.13865] → [41.6027:6045]

B:BD[20.13865] → [111.6661:6679]

B:BD[20.13865] → [42.17081:17099]

B:BD[20.13865] → [43.22758:22776]

B:BD[20.13865] → [44.2530:2548]

B:BD[20.13865] → [22.7509:7527]

B:BD[20.13865] → [33.9291:9309]

B:BD[20.13865] → [48.16996:17014]

B:BD[20.13865] → [50.4185:4203]

B:BD[20.13865] → [51.6942:6960]

B:BD[20.13865] → [20.13865:13883]

B:BD[20.13865] → [53.7151:7169]

B:BD[20.13865] → [54.10490:10508]

B:BD[20.13865] → [55.34757:34775]

B:BD[20.13865] → [37.14852:14870]

B:BD[20.13661] → [40.11378:11542]

B:BD[20.13661] → [41.5862:6026]

B:BD[20.13661] → [111.6496:6660]

B:BD[20.13661] → [42.16916:17080]

B:BD[20.13661] → [43.22593:22675]

B:BD[43.22757] → [47.10118:10193]

B:BD[47.10035] → [47.10035:10117]

B:BD[20.13825] → [20.13825:13840]

B:BD[47.10117] → [29.38642:38714]

B:BD[47.10117] → [46.60628:60700]

B:BD[47.10117] → [30.14445:14517]

B:BD[47.10117] → [49.16221:16293]

B:BD[43.22675] → [43.22675:22757]

B:BD[43.22675] → [47.9662:10035]

B:BD[20.13661] → [44.2365:2529]

B:BD[20.13661] → [47.9422:9661]

B:BD[20.13661] → [22.7344:7508]

B:BD[20.13661] → [33.9126:9290]

B:BD[20.13661] → [48.16831:16995]

B:BD[20.13661] → [50.4020:4184]

B:BD[20.13661] → [51.6777:6941]

B:BD[20.13661] → [20.13661:13825]

B:BD[20.13661] → [53.6986:7150]

B:BD[20.13661] → [54.10325:10489]

B:BD[20.13661] → [55.34592:34756]

B:BD[20.13661] → [37.14687:14851]

B:BD[20.13561] → [40.11359:11377]

B:BD[20.13561] → [41.5843:5861]

B:BD[20.13561] → [70.1815:1833]

B:BD[20.13561] → [111.6477:6495]

B:BD[20.13561] → [42.16897:16915]

B:BD[20.13561] → [43.22574:22592]

B:BD[20.13561] → [44.2346:2364]

B:BD[20.13561] → [22.7325:7343]

B:BD[20.13561] → [33.9107:9125]

B:BD[20.13561] → [48.16812:16830]

B:BD[20.13561] → [50.4001:4019]

B:BD[20.13561] → [51.6758:6776]

B:BD[20.13579] → [20.13579:13661]

B:BD[20.13561] → [20.13561:13579]

B:BD[20.13536] → [20.13536:13561]

B:BD[20.13561] → [52.7533:7551]

B:BD[20.13561] → [38.15638:15656]

B:BD[20.13561] → [53.6967:6985]

B:BD[20.13561] → [54.10306:10324]

B:BD[20.13561] → [55.34573:34591]

B:BD[20.13561] → [37.14668:14686]

B:BD[42.16590] → [42.16590:16896]

B:BD[42.16508] → [42.16508:16590]

B:BD[48.16505] → [92.3945:4017]

B:BD[43.21506] → [43.21506:21521]

B:BD[43.22498] → [140.190:265]

B:BD[43.22121] → [140.113:189]

B:BD[43.22498] → [43.22498:22573]

B:BD[43.22196] → [43.22196:22498]

B:BD[43.22121] → [43.22121:22196]

B:BD[43.22498] → [71.4281:4356]

B:BD[43.22121] → [71.4205:4280]

B:BD[43.21521] → [43.21521:22121]

B:BD[52.6480] → [47.9384:9421]

B:BD[52.6480] → [52.6480:7532]

B:BD[48.16505] → [70.1742:1814]

B:BD[48.16505] → [43.21434:21506]

B:BD[48.16505] → [47.9311:9383]

B:BD[48.16505] → [48.16505:16811]

B:BD[48.16423] → [48.16423:16505]

B:BD[52.6465] → [52.6465:6480]

B:BD[48.16505] → [52.6393:6465]

B:BD[48.16505] → [38.15565:15637]

B:BD[48.16505] → [53.6894:6966]

B:BD[55.34124] → [55.34124:34139]

B:BD[48.16505] → [39.4950:5022]

B:BD[42.16590] → [22.7252:7324]

B:BD[42.16590] → [48.16291:16423]

B:BD[20.13521] → [20.13521:13536]

B:BD[42.16590] → [54.10233:10305]

B:BD[42.16590] → [55.34052:34124]

B:BD[20.13449] → [40.11286:11358]

B:BD[20.13449] → [41.5770:5842]

B:BD[20.13449] → [111.6404:6476]

B:BD[20.13449] → [42.16376:16508]

B:BD[20.13449] → [44.2273:2345]

B:BD[20.13449] → [33.9034:9106]

B:BD[20.13449] → [50.3928:4000]

B:BD[20.13449] → [51.6685:6757]

B:BD[20.13449] → [20.13449:13521]

B:BD[20.13449] → [37.14595:14667]

B:BD[20.13233] → [40.11213:11285]

B:BD[20.13233] → [41.5697:5769]

B:BD[20.13233] → [92.3872:3944]

B:BD[20.13233] → [70.1669:1741]

B:BD[20.13233] → [111.6331:6403]

B:BD[20.13233] → [42.16303:16375]

B:BD[20.13233] → [43.21361:21433]

B:BD[20.13233] → [29.38569:38641]

B:BD[20.13233] → [44.2200:2272]

B:BD[20.13233] → [46.60555:60627]

B:BD[20.13233] → [47.9238:9310]

B:BD[20.13233] → [22.7179:7251]

B:BD[20.13233] → [33.8961:9033]

B:BD[20.13233] → [48.16218:16290]

B:BD[20.13233] → [30.14372:14444]

B:BD[20.13233] → [49.16148:16220]

B:BD[20.13233] → [50.3855:3927]

B:BD[20.13233] → [51.6612:6684]

B:BD[20.13233] → [20.13233:13305]

B:BD[20.13305] → [20.13305:13367]

B:BD[20.13233] → [52.6320:6392]

B:BD[20.13233] → [38.15492:15564]

B:BD[20.13233] → [53.6821:6893]

B:BD[20.13233] → [54.10160:10232]

B:BD[20.13233] → [55.33979:34051]

B:BD[20.13233] → [37.14522:14594]

B:BD[20.13233] → [39.4877:4949]

B:BD[20.12887] → [49.16025:16147]

B:BD[20.12887] → [20.12887:13009]

B:BD[20.13009] → [20.13009:13233]

B:BD[20.12887] → [53.6698:6820]

B:BD[20.12887] → [54.10037:10159]

B:BD[20.12374] → [46.60405:60554]

B:BD[20.12374] → [30.14222:14371]

B:BD[20.12374] → [49.15875:16024]

B:BD[20.12374] → [20.12374:12523]

B:BD[20.12523] → [20.12523:12887]

B:BD[20.12049] → [46.60385:60404]

B:BD[20.12049] → [30.14202:14221]

B:BD[20.12049] → [49.15855:15874]

B:BD[20.12049] → [20.12049:12068]

B:BD[20.12068] → [20.12068:12374]

B:BD[20.11948] → [40.11140:11212]

B:BD[20.11948] → [41.5624:5696]

B:BD[20.11948] → [111.6258:6330]

B:BD[20.11948] → [42.16230:16302]

B:BD[20.11948] → [43.21288:21360]

B:BD[20.11948] → [29.38326:38398]

B:BD[20.11948] → [44.2127:2199]

B:BD[20.11948] → [33.8888:8960]

B:BD[20.11948] → [48.16145:16217]

B:BD[20.11948] → [49.15782:15854]

B:BD[20.11948] → [50.3782:3854]

B:BD[20.11948] → [51.6539:6611]

B:BD[20.11948] → [20.11948:12020]

B:BD[20.12020] → [20.12020:12049]

B:BD[20.11948] → [53.6625:6697]

B:BD[20.11948] → [54.9964:10036]

B:BD[20.11948] → [55.33906:33978]

B:BD[20.11948] → [37.14449:14521]

B:BD[20.11580] → [70.1650:1668]

B:BD[20.11580] → [29.38307:38325]

B:BD[20.11580] → [46.60366:60384]

B:BD[20.11580] → [47.9219:9237]

B:BD[20.11580] → [30.14183:14201]

B:BD[20.11580] → [49.15763:15781]

B:BD[20.11580] → [20.11580:11598]

B:BD[20.11598] → [20.11598:11948]

B:BD[20.11580] → [39.4858:4876]

B:BD[20.11467] → [40.11120:11139]

B:BD[20.11467] → [41.5604:5623]

B:BD[20.11467] → [92.3833:3852]

B:BD[20.11467] → [70.1630:1649]

B:BD[20.11467] → [111.6238:6257]

B:BD[20.11467] → [42.16210:16229]

B:BD[20.11467] → [43.21268:21287]

B:BD[20.11467] → [29.38287:38306]

B:BD[20.11467] → [44.2107:2126]

B:BD[20.11467] → [46.60346:60365]

B:BD[20.11467] → [47.9199:9218]

B:BD[20.11467] → [33.8868:8887]

B:BD[20.11467] → [48.16125:16144]

B:BD[20.11467] → [30.14163:14182]

B:BD[20.11467] → [49.15743:15762]

B:BD[20.11467] → [50.3762:3781]

B:BD[20.11467] → [51.6519:6538]

B:BD[20.11467] → [20.11467:11486]

B:BD[20.11486] → [20.11486:11580]

B:BD[20.11467] → [52.6300:6319]

B:BD[20.11467] → [38.15472:15491]

B:BD[20.11467] → [53.6605:6624]

B:BD[20.11467] → [54.9944:9963]

B:BD[20.11467] → [55.33886:33905]

B:BD[20.11467] → [37.14429:14448]

B:BD[20.11182] → [42.16133:16209]

B:BD[20.11182] → [43.21191:21267]

B:BD[20.11182] → [29.38210:38286]

B:BD[20.11182] → [48.16048:16124]

B:BD[20.11182] → [49.15666:15742]

B:BD[20.11182] → [20.11182:11258]

B:BD[20.11258] → [20.11258:11467]

B:BD[20.11182] → [53.6528:6604]

B:BD[20.11182] → [54.9867:9943]

B:BD[20.11182] → [55.33809:33885]

B:BD[20.11081] → [92.3813:3832]

B:BD[20.11081] → [70.1610:1629]

B:BD[20.11081] → [29.38190:38209]

B:BD[20.11081] → [46.60326:60345]

B:BD[20.11081] → [47.9179:9198]

B:BD[20.11081] → [22.7159:7178]

B:BD[20.11081] → [30.14143:14162]

B:BD[20.11081] → [49.15646:15665]

B:BD[20.11081] → [20.11081:11100]

B:BD[20.11100] → [20.11100:11182]

B:BD[20.11081] → [39.4838:4857]

B:BD[20.10970] → [42.16114:16132]

B:BD[20.10970] → [43.21172:21190]

B:BD[20.10970] → [29.38171:38189]

B:BD[20.10970] → [48.16029:16047]

B:BD[20.10970] → [49.15627:15645]

B:BD[20.10970] → [20.10970:10988]

B:BD[20.10988] → [20.10988:11081]

B:BD[20.10970] → [53.6509:6527]

B:BD[20.10970] → [54.9848:9866]

B:BD[20.10970] → [55.33790:33808]

B:BD[20.10855] → [42.16095:16113]

B:BD[20.10668] → [42.16017:16094]

B:BD[20.10855] → [43.21153:21171]

B:BD[20.10855] → [29.38152:38170]

B:BD[20.10855] → [48.16010:16028]

B:BD[20.10855] → [49.15608:15626]

B:BD[20.10855] → [20.10855:10873]

B:BD[20.10873] → [20.10873:10970]

B:BD[20.10835] → [20.10835:10855]

B:BD[20.10820] → [20.10820:10835]

B:BD[20.10668] → [20.10668:10820]

B:BD[20.10855] → [53.6490:6508]

B:BD[20.10855] → [54.9829:9847]

B:BD[20.10855] → [55.33771:33789]

B:BD[20.10586] → [20.10586:10668]

B:BD[42.15646] → [42.15646:15960]

B:BD[42.15960] → [42.15960:15975]

B:BD[42.15646] → [48.15932:16009]

B:BD[42.15646] → [54.9676:9828]

B:BD[42.15646] → [55.33693:33770]

B:BD[20.10568] → [140.94:112]

B:BD[48.15561] → [43.20623:20937]

B:BD[43.20952] → [43.20952:21152]

B:BD[42.15564] → [42.15564:15646]

B:BD[48.15890] → [48.15890:15931]

B:BD[48.15875] → [48.15875:15890]

B:BD[43.20937] → [43.20937:20952]

B:BD[48.15561] → [29.38074:38151]

B:BD[48.15561] → [48.15561:15875]

B:BD[48.15561] → [49.15455:15607]

B:BD[48.15561] → [53.6337:6489]

B:BD[20.10568] → [70.1591:1609]

B:BD[20.10568] → [42.15546:15564]

B:BD[20.10568] → [43.20604:20622]

B:BD[20.10568] → [29.37603:38073]

B:BD[20.10568] → [47.9160:9178]

B:BD[20.10568] → [48.15461:15479]

B:BD[48.15479] → [48.15479:15561]

B:BD[20.10568] → [30.14124:14142]

B:BD[20.10568] → [49.15436:15454]

B:BD[20.10568] → [20.10568:10586]

B:BD[20.10568] → [52.6281:6299]

B:BD[20.10568] → [38.15453:15471]

B:BD[20.10568] → [53.6318:6336]

B:BD[20.10568] → [54.9657:9675]

B:BD[20.10568] → [55.33222:33692]

B:BD[20.10568] → [71.4186:4204]

B:BD[20.10304] → [42.15239:15545]

B:BD[20.10304] → [43.20297:20603]

B:BD[20.10304] → [29.37296:37602]

B:BD[20.10304] → [48.15154:15460]

B:BD[20.10304] → [49.15208:15435]

B:BD[20.10304] → [20.10304:10531]

B:BD[20.10531] → [20.10531:10568]

B:BD[20.10304] → [53.6090:6317]

B:BD[20.10304] → [54.9429:9656]

B:BD[20.10304] → [55.32915:33221]

B:BD[20.10204] → [42.15220:15238]

B:BD[20.10204] → [43.20278:20296]

B:BD[20.10204] → [29.37277:37295]

B:BD[20.10204] → [48.15135:15153]

B:BD[20.10204] → [49.15189:15207]

B:BD[20.10204] → [20.10204:10222]

B:BD[20.10222] → [20.10222:10304]

B:BD[20.10204] → [53.6071:6089]

B:BD[20.10204] → [54.9410:9428]

B:BD[20.10204] → [55.32896:32914]

B:BD[20.9909] → [42.15143:15219]

B:BD[20.9909] → [43.20201:20277]

B:BD[20.9909] → [29.37200:37276]

B:BD[20.9909] → [48.15058:15134]

B:BD[20.9909] → [49.15038:15188]

B:BD[20.9909] → [20.9909:10059]

B:BD[20.10059] → [20.10059:10204]

B:BD[20.9909] → [53.5920:6070]

B:BD[20.9909] → [54.9259:9409]

B:BD[20.9909] → [55.32819:32895]

B:BD[20.9809] → [42.15123:15142]

B:BD[20.9809] → [43.20181:20200]

B:BD[20.9809] → [29.37180:37199]

B:BD[20.9809] → [48.15038:15057]

B:BD[20.9809] → [49.15019:15037]

B:BD[20.9809] → [20.9809:9827]

B:BD[20.9827] → [20.9827:9909]

B:BD[20.9778] → [20.9778:9809]

B:BD[20.9809] → [53.5901:5919]

B:BD[20.9809] → [54.9240:9258]

B:BD[20.9809] → [55.32799:32818]

B:BD[24.2610] → [24.2610:2682]

B:BD[24.2610] → [22.7086:7158]

B:BD[20.9636] → [40.10977:11119]

B:BD[20.9636] → [41.5461:5603]

B:BD[20.9636] → [92.3670:3812]

B:BD[20.9636] → [70.1448:1518]

B:BD[70.1518] → [70.1518:1590]

B:BD[70.1518] → [39.4765:4837]

B:BD[20.9636] → [111.6095:6237]

B:BD[20.9636] → [42.14980:15122]

B:BD[20.9636] → [43.20038:20180]

B:BD[20.9636] → [29.37037:37179]

B:BD[20.9636] → [44.1964:2106]

B:BD[20.9636] → [46.60183:60325]

B:BD[20.9636] → [47.9017:9159]

B:BD[20.9636] → [33.8725:8867]

B:BD[20.9636] → [48.14895:15037]

B:BD[20.9636] → [30.13981:14123]

B:BD[20.9636] → [49.14876:15018]

B:BD[20.9636] → [50.3619:3761]

B:BD[20.9636] → [51.6376:6518]

B:BD[20.9636] → [20.9636:9778]

B:BD[20.9636] → [52.6138:6280]

B:BD[20.9636] → [38.15310:15452]

B:BD[20.9636] → [53.5758:5900]

B:BD[20.9636] → [54.9097:9239]

B:BD[20.9636] → [55.32656:32798]

B:BD[20.9636] → [37.14286:14428]

B:BD[20.9535] → [40.10957:10976]

B:BD[20.9535] → [41.5441:5460]

B:BD[20.9535] → [111.6075:6094]

B:BD[20.9535] → [42.14960:14979]

B:BD[20.9535] → [43.20018:20037]

B:BD[20.9535] → [29.37017:37036]

B:BD[20.9535] → [44.1944:1963]

B:BD[20.9535] → [33.8705:8724]

B:BD[20.9535] → [48.14875:14894]

B:BD[20.9535] → [49.14856:14875]

B:BD[20.9535] → [50.3599:3618]

B:BD[20.9535] → [51.6356:6375]

B:BD[20.9554] → [20.9554:9636]

B:BD[20.9535] → [20.9535:9554]

B:BD[20.9535] → [53.5738:5757]

B:BD[20.9535] → [54.9077:9096]

B:BD[20.9535] → [55.32636:32655]

B:BD[20.9535] → [37.14266:14285]

B:BD[20.9497] → [20.9497:9535]

B:BD[24.2438] → [24.2438:2519]

B:BD[20.9271] → [40.10802:10956]

B:BD[20.9271] → [41.5287:5440]

B:BD[20.9271] → [111.5920:6074]

B:BD[20.9271] → [42.14805:14959]

B:BD[20.9271] → [43.19863:19935]

B:BD[43.19935] → [43.19935:20017]

B:BD[20.9271] → [44.1789:1943]

B:BD[20.9271] → [22.7013:7085]

B:BD[20.9271] → [33.8550:8704]

B:BD[20.9271] → [48.14720:14874]

B:BD[20.9271] → [50.3445:3598]

B:BD[20.9271] → [51.6202:6355]

B:BD[20.9271] → [20.9271:9424]

B:BD[20.9271] → [53.5584:5737]

B:BD[20.9271] → [54.8923:9076]

B:BD[20.9271] → [55.32481:32635]

B:BD[20.9271] → [37.14112:14265]

B:BD[20.9117] → [40.10646:10801]

B:BD[20.9117] → [41.5205:5286]

B:BD[20.9117] → [111.5764:5919]

B:BD[20.9117] → [42.14649:14804]

B:BD[20.9117] → [43.19707:19862]

B:BD[39.4692] → [52.6065:6137]

B:BD[39.4692] → [38.15237:15309]

B:BD[39.4692] → [39.4692:4764]

B:BD[43.19862] → [92.3524:3669]

B:BD[43.19862] → [70.1302:1447]

B:BD[43.19862] → [47.8871:9016]

B:BD[43.19862] → [30.13680:13980]

B:BD[43.19862] → [39.4619:4692]

B:BD[20.9117] → [29.36561:36716]

B:BD[29.36716] → [29.36716:37016]

B:BD[29.36716] → [46.59882:60182]

B:BD[20.9117] → [44.1633:1788]

B:BD[20.9117] → [33.8394:8549]

B:BD[20.9117] → [48.14564:14719]

B:BD[20.9117] → [49.14475:14855]

B:BD[20.9117] → [50.3363:3444]

B:BD[20.9117] → [51.6120:6201]

B:BD[20.9117] → [20.9117:9198]

B:BD[20.9198] → [20.9198:9271]

B:BD[20.9117] → [53.5502:5583]

B:BD[20.9117] → [54.8841:8922]

B:BD[20.9117] → [55.32325:32480]

B:BD[20.9117] → [37.14030:14111]

B:BD[20.9017] → [40.10626:10645]

B:BD[20.9017] → [41.5186:5204]

B:BD[20.9017] → [70.1282:1301]

B:BD[20.9017] → [111.5744:5763]

B:BD[20.9017] → [42.14629:14648]

B:BD[20.9017] → [43.19687:19706]

B:BD[20.9017] → [29.36541:36560]

B:BD[20.9017] → [44.1613:1632]

B:BD[20.9017] → [46.59862:59881]

B:BD[20.9017] → [47.8851:8870]

B:BD[20.9017] → [33.8374:8393]

B:BD[20.9017] → [48.14544:14563]

B:BD[20.9017] → [30.13660:13679]

B:BD[20.9017] → [49.14456:14474]

B:BD[20.9017] → [50.3344:3362]

B:BD[20.9017] → [51.6101:6119]

B:BD[20.9017] → [20.9017:9035]

B:BD[20.9035] → [20.9035:9117]

B:BD[20.9017] → [52.6045:6064]

B:BD[20.9017] → [38.15217:15236]

B:BD[20.9017] → [53.5483:5501]

B:BD[20.9017] → [54.8822:8840]

B:BD[20.9017] → [55.32305:32324]

B:BD[20.9017] → [37.14011:14029]

B:BD[24.2036] → [24.2036:2108]

B:BD[20.8985] → [20.8985:9017]

B:BD[24.2036] → [22.6940:7012]

B:BD[20.8429] → [49.13899:14455]

B:BD[20.8429] → [20.8429:8446]

B:BD[20.8757] → [40.10471:10625]

B:BD[20.8757] → [41.5032:5185]

B:BD[20.8757] → [111.5589:5743]

B:BD[20.8757] → [44.1458:1612]

B:BD[20.8757] → [33.8219:8373]

B:BD[20.8757] → [50.3190:3343]

B:BD[20.8757] → [51.5947:6100]

B:BD[20.8910] → [20.8910:8985]

B:BD[20.8757] → [20.8757:8910]

B:BD[20.8527] → [20.8527:8757]

B:BD[20.8757] → [37.13857:14010]

B:BD[20.8446] → [40.10389:10470]

B:BD[20.8446] → [41.4950:5031]

B:BD[20.8446] → [111.5507:5588]

B:BD[20.8446] → [44.1376:1457]

B:BD[20.8446] → [33.8137:8218]

B:BD[20.8446] → [50.3108:3189]

B:BD[20.8446] → [51.5865:5946]

B:BD[20.8446] → [20.8446:8527]

B:BD[20.8446] → [37.13775:13856]

B:BD[20.8429] → [53.4926:5482]

B:BD[20.8429] → [54.8265:8821]

B:BD[40.10388] → [42.14593:14628]

B:BD[40.10388] → [43.19651:19686]

B:BD[40.10388] → [29.36505:36540]

B:BD[40.10388] → [48.14508:14543]

B:BD[40.10388] → [49.13861:13898]

B:BD[20.8364] → [20.8364:8429]

B:BD[40.10388] → [53.4888:4925]

B:BD[40.10388] → [54.8227:8264]

B:BD[40.10388] → [55.32269:32304]

B:BD[40.10375] → [40.10375:10388]

B:BD[20.8327] → [44.1262:1375]

B:BD[20.8314] → [33.8023:8136]

B:BD[20.8314] → [20.8314:8327]

B:BD[20.8327] → [20.8327:8364]

B:BD[20.8239] → [29.36431:36504]

B:BD[20.8239] → [46.59788:59861]

B:BD[20.8239] → [30.13586:13659]

B:BD[20.8239] → [49.13787:13860]

B:BD[20.8239] → [20.8239:8312]

B:BD[20.8093] → [24.1597:1669]

B:BD[20.8093] → [40.10202:10274]

B:BD[20.8093] → [41.4877:4949]

B:BD[20.8093] → [92.3451:3523]

B:BD[20.8093] → [70.1209:1281]

B:BD[20.8093] → [111.5320:5392]

B:BD[20.8093] → [42.14520:14592]

B:BD[20.8093] → [43.19578:19650]

B:BD[20.8093] → [29.36358:36430]

B:BD[20.8093] → [44.1189:1261]

B:BD[20.8093] → [46.59715:59787]

B:BD[20.8093] → [47.8778:8850]

B:BD[20.8093] → [22.6867:6939]

B:BD[20.8093] → [33.7950:8022]

B:BD[20.8093] → [48.14435:14507]

B:BD[20.8093] → [30.13513:13585]

B:BD[20.8093] → [49.13714:13786]

B:BD[20.8093] → [50.3035:3107]

B:BD[20.8093] → [51.5792:5864]

B:BD[20.8093] → [20.8093:8165]

B:BD[20.8093] → [52.5972:6044]

B:BD[20.8093] → [38.15144:15216]

B:BD[20.8093] → [53.4815:4887]

B:BD[20.8093] → [54.8154:8226]

B:BD[20.8093] → [55.32196:32268]

B:BD[20.8093] → [37.13702:13774]

B:BD[20.8093] → [39.4546:4618]

B:BD[20.7889] → [24.1522:1596]

B:BD[20.7889] → [22.6792:6866]

B:BD[20.7889] → [20.7889:7963]

B:BD[20.7789] → [24.1503:1521]

B:BD[20.7789] → [40.10182:10201]

B:BD[20.7789] → [41.4858:4876]

B:BD[20.7789] → [111.5301:5319]

B:BD[20.7789] → [42.14500:14519]

B:BD[20.7789] → [43.19558:19577]

B:BD[20.7789] → [29.36338:36357]

B:BD[20.7789] → [44.1169:1188]

B:BD[20.7789] → [22.6773:6791]

B:BD[20.7789] → [33.7930:7949]

B:BD[20.7789] → [48.14415:14434]

B:BD[20.7789] → [49.13695:13713]

B:BD[20.7789] → [50.3016:3034]

B:BD[20.7789] → [51.5773:5791]

B:BD[20.7789] → [20.7789:7807]

B:BD[20.7789] → [53.4796:4814]

B:BD[20.7789] → [54.8135:8153]

B:BD[20.7789] → [55.32176:32195]

B:BD[20.7789] → [37.13683:13701]

B:BD[20.7657] → [20.7657:7771]

B:BD[54.8098] → [54.8098:8134]

B:BD[54.8020] → [54.8020:8098]

B:BD[24.1388] → [24.1388:1466]

B:BD[20.7561] → [40.10163:10181]

B:BD[20.7561] → [41.4839:4857]

B:BD[20.7561] → [42.14481:14499]

B:BD[20.7561] → [43.19539:19557]

B:BD[20.7561] → [29.36318:36337]

B:BD[49.13658] → [49.13658:13694]

B:BD[20.7561] → [44.1150:1168]

B:BD[20.7561] → [46.59696:59714]

B:BD[20.7561] → [22.6754:6772]

B:BD[20.7561] → [33.7911:7929]

B:BD[20.7561] → [48.14396:14414]

B:BD[20.7561] → [30.13493:13512]

B:BD[20.7561] → [49.13562:13580]

B:BD[49.13580] → [49.13580:13658]

B:BD[20.7561] → [51.5754:5772]

B:BD[20.7561] → [20.7561:7579]

B:BD[20.7561] → [53.4663:4795]

B:BD[20.7561] → [54.8002:8020]

B:BD[20.7561] → [55.32157:32175]

B:BD[20.7561] → [37.13664:13682]

B:BD[20.7455] → [46.59622:59695]

B:BD[20.7455] → [30.13419:13492]

B:BD[20.7455] → [49.13488:13561]

B:BD[20.7528] → [20.7528:7561]

B:BD[20.7455] → [20.7455:7528]

B:BD[20.7323] → [20.7323:7455]

B:BD[20.7247] → [41.4765:4838]

B:BD[20.7247] → [111.5227:5300]

B:BD[20.7247] → [42.14407:14480]

B:BD[20.7247] → [44.1076:1149]

B:BD[20.7247] → [33.7837:7910]

B:BD[20.7247] → [50.2942:3015]

B:BD[20.7247] → [51.5680:5753]

B:BD[20.7247] → [20.7247:7320]

B:BD[20.7320] → [20.7320:7323]

B:BD[20.7247] → [54.7928:8001]

B:BD[20.7247] → [55.32083:32156]

B:BD[20.7247] → [37.13590:13663]

B:BD[10.12201] → [15.6818:6852]

B:BD[10.12201] → [10.12202:12214]

B:BD[10.12201] → [70.950:1041]

B:BD[22.6555] → [43.19255:19377]

B:BD[43.19449] → [43.19449:19464]

B:BD[22.6577] → [140.0:19]

B:BD[22.6677] → [140.20:93]

B:BD[22.6677] → [70.1135:1208]

B:BD[22.6677] → [43.19465:19538]

B:BD[22.6677] → [29.36170:36243]

B:BD[22.6677] → [47.8704:8777]

B:BD[22.6677] → [22.6677:6750]

B:BD[22.6750] → [22.6750:6753]

B:BD[22.6677] → [48.14322:14395]

B:BD[22.6677] → [30.13345:13418]

B:BD[22.6677] → [49.13414:13487]

B:BD[22.6677] → [52.5898:5971]

B:BD[22.6677] → [38.15070:15143]

B:BD[22.6677] → [53.4589:4662]

B:BD[22.6677] → [71.4112:4185]

B:BD[22.6577] → [70.1115:1134]

B:BD[22.6577] → [29.36151:36169]

B:BD[22.6577] → [46.59602:59621]

B:BD[22.6577] → [47.8685:8703]

B:BD[22.6595] → [22.6595:6677]

B:BD[22.6577] → [22.6577:6595]

B:BD[22.6577] → [30.13326:13344]

B:BD[22.6577] → [49.13395:13413]

B:BD[22.6577] → [52.5879:5897]

B:BD[22.6577] → [38.15050:15069]

B:BD[22.6577] → [71.4093:4111]

B:BD[43.19377] → [92.3378:3450]

B:BD[22.6555] → [22.6555:6577]

B:BD[43.19377] → [70.1042:1114]

B:BD[43.19377] → [43.19377:19449]

B:BD[43.19377] → [47.8612:8684]

B:BD[43.19377] → [30.13253:13325]

B:BD[43.19377] → [52.5806:5878]

B:BD[43.19377] → [38.14977:15049]

B:BD[43.19377] → [39.4473:4545]

B:BD[22.6555] → [29.35941:36063]

B:BD[29.36135] → [29.36135:36150]

B:BD[29.36063] → [29.36063:36135]

B:BD[29.36063] → [46.59529:59601]

B:BD[10.12201] → [42.14197:14406]

B:BD[10.12201] → [29.35849:35940]

B:BD[10.12201] → [44.866:1075]

B:BD[10.12201] → [58.54708:54799]

B:BD[10.12201] → [22.6543:6555]

B:BD[10.12201] → [48.14112:14321]

B:BD[10.12201] → [30.13161:13252]

B:BD[10.12201] → [9.2216:2228]

B:BD[9.2228] → [9.2228:5069]

B:BD[10.12201] → [60.47642:47733]

∅:BD[64.31235] → [63.48451:48463]

B:BD[60.47733] → [63.48451:48463]

B:BD[63.48463] → [63.48463:48660]

B:BD[60.47733] → [64.31026:31038]

∅:BD[21.36685] → [64.31078:31143]

B:BD[64.31078] → [64.31078:31143]

∅:BD[2.4152] → [64.31143:31160]

B:BD[64.31143] → [64.31143:31160]

∅:BD[2.4163] → [64.31232:31234]

∅:BD[21.36759] → [64.31232:31234]

B:BD[64.31232] → [64.31232:31234]

∅:BD[2.4242] → [64.31234:31235]

∅:BD[21.36871] → [64.31234:31235]

B:BD[64.31234] → [64.31234:31235]

B:BD[64.31234] → [21.36760:36871]

B:BD[21.36871] → [2.4164:4242]

B:BD[64.31160] → [64.31160:31232]

B:BD[64.31160] → [21.36686:36759]

B:BD[64.31160] → [2.4153:4163]

B:BD[64.31143] → [2.4074:4152]

B:BD[64.31038] → [64.31038:31078]

B:BD[64.31038] → [21.36647:36685]

B:BD[10.12201] → [20.7113:7125]

B:BD[20.7125] → [20.7125:7247]

B:BD[10.12201] → [38.14885:14976]

B:BD[10.12201] → [17.52901:53201]

B:BD[10.12201] → [55.31873:32082]

version = "0.6.8"
 "memchr 2.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.3.4"
version = "0.4.7"
 "nodrop 0.1.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.43 (registry+https://github.com/rust-lang/crates.io-index)",
[[package]]
name = "backtrace"
version = "0.2.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)",
 "dbghelp-sys 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "kernel32-sys 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.2.8 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "backtrace"
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)",
 "winapi 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "backtrace-sys"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
]
[[package]]
name = "base64"
version = "0.9.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "byteorder 1.2.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "safemem 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "bitflags"
version = "1.0.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
name = "blake2"
version = "0.7.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "byte-tools 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "crypto-mac 0.5.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "digest 0.7.6 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "block-buffer"
version = "0.3.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "arrayref 0.3.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "byte-tools 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "byte-tools"
version = "0.2.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
name = "byteorder"
version = "1.2.7"
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
name = "bytes"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "byteorder 1.2.7 (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"
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)",
]
[[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 = "constant_time_eq"
version = "0.1.3"
source = "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)",
]
[[package]]
name = "core-foundation-sys"
version = "0.5.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
]
[[package]]
name = "crossbeam-deque"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
]
[[package]]
name = "crossbeam-epoch"
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)",
 "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-utils"
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
name = "crypto-mac"
version = "0.5.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "constant_time_eq 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "generic-array 0.9.0 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "dbghelp-sys"
version = "0.2.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "winapi 0.2.8 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi-build 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
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.7.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "generic-array 0.9.0 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "encoding_rs"
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"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "atty 0.2.11 (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.1.12"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "backtrace 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "error-chain"
version = "0.8.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
]
[[package]]
name = "failure"
version = "0.1.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "failure_derive 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "failure_derive"
version = "0.1.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
]
[[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-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.1 (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)",
]
[[package]]
name = "generic-array"
version = "0.9.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"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "byteorder 1.2.7 (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)",
 "indexmap 1.0.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "slab 0.4.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.10 (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 = [
 "winutil 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "http"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "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"
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"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "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)",
 "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)",
 "net2 0.2.33 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio 0.1.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-reactor 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-threadpool 0.1.8 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-timer 0.2.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.43 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.1.7"
version = "1.1.0"
dependencies = [
 "version_check 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
]
version = "1.2.0"
version = "0.2.43"
version = "0.1.4"
 "owning_ref 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "log"
version = "0.3.9"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "log 0.4.5 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.4.5"
version = "0.7.3"
 "serde 1.0.80 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde_derive 1.0.80 (registry+https://github.com/rust-lang/crates.io-index)",
 "tendril 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
version = "2.1.0"
 "libc 0.2.43 (registry+https://github.com/rust-lang/crates.io-index)",
 "lazycell 1.2.0 (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.1 (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)",
 "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 = [
 "openssl 0.10.15 (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.39 (registry+https://github.com/rust-lang/crates.io-index)",
 "schannel 0.1.14 (registry+https://github.com/rust-lang/crates.io-index)",
 "security-framework 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "security-framework-sys 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[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)",
 "winapi 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "new_debug_unreachable"
version = "1.0.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "unreachable 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "nodrop"
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"
name = "num_cpus"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
]
[[package]]
name = "openssl"
version = "0.10.15"
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)",
 "openssl-sys 0.9.39 (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.39"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "pkg-config 0.3.14 (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"
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.6.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "parking_lot_core 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "parking_lot_core"
version = "0.3.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "rand 0.5.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "rustc_version 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "percent-encoding"
version = "1.0.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
name = "phf"
version = "0.7.23"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "phf_shared 0.7.23 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "phf_codegen"
version = "0.7.23"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "phf_generator 0.7.23 (registry+https://github.com/rust-lang/crates.io-index)",
 "phf_shared 0.7.23 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "phf_generator"
version = "0.7.23"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "phf_shared 0.7.23 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand 0.5.5 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "phf_shared"
version = "0.7.23"
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"
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.12.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "failure 0.1.3 (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"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
]
[[package]]
name = "rand"
version = "0.4.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "fuchsia-zircon 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "rand"
version = "0.5.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "cloudabi 0.0.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "fuchsia-zircon 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand_core 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)",
]
name = "rand"
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)",
 "rand_core 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.6.5"
 "autocfg 0.1.2 (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_jitter 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand_pcg 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.1.1"
 "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)",
name = "rand_chacha"
 "autocfg 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "rustc_version 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)",
name = "rand_core"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
]
[[package]]
name = "rand_core"
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 = [
]
[[package]]
name = "rand_isaac"
version = "0.1.1"
dependencies = [
]
[[package]]
 "libc 0.2.50 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.1.3"
 "libc 0.2.50 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.50 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.1.3"
 "libc 0.2.50 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.1.2"
 "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)",
name = "rdrand"
version = "0.4.0"
 "rand_core 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
name = "rdrand"
version = "0.4.0"
 "rand_core 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "rand_core 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
version = "0.1.40"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
]
[[package]]
name = "regex"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "regex-syntax 0.6.5 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.6.5"
 "redox_syscall 0.1.40 (registry+https://github.com/rust-lang/crates.io-index)",
name = "regex-syntax"
 "winapi 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.6.1"
version = "0.1.9"
version = "0.2.6"
name = "safemem"
version = "0.3.0"
name = "safemem"
version = "0.3.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
version = "0.4.2"
 "base64 0.9.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "openssl 0.10.15 (registry+https://github.com/rust-lang/crates.io-index)",
name = "sendxmppd-rust"
 "minidom 0.10.0 (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)",
 "tokio-channel 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.1.0"
 "env_logger 0.5.13 (registry+https://github.com/rust-lang/crates.io-index)",
 "hyper 0.12.13 (registry+https://github.com/rust-lang/crates.io-index)",
 "log 0.4.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde 1.0.80 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde_derive 1.0.80 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-signal 0.2.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "toml 0.4.8 (registry+https://github.com/rust-lang/crates.io-index)",
version = "1.0.80"
version = "1.0.80"
 "proc-macro2 0.4.20 (registry+https://github.com/rust-lang/crates.io-index)",
 "quote 0.6.8 (registry+https://github.com/rust-lang/crates.io-index)",
 "syn 0.15.14 (registry+https://github.com/rust-lang/crates.io-index)",
version = "1.0.32"
 "ryu 0.2.6 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.1.5"
 "arc-swap 0.3.4 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.43 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.6.5"
 "libc 0.2.43 (registry+https://github.com/rust-lang/crates.io-index)",
 "redox_syscall 0.1.40 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.1.1"
 "lazy_static 1.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde 1.0.80 (registry+https://github.com/rust-lang/crates.io-index)",
 "proc-macro2 0.4.20 (registry+https://github.com/rust-lang/crates.io-index)",
 "quote 0.6.8 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.15.14"
 "proc-macro2 0.4.20 (registry+https://github.com/rust-lang/crates.io-index)",
 "quote 0.6.8 (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"
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 = "tempfile"
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)",
 "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"
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.4 (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 = [
 "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 = [
]
[[package]]
name = "time"
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 = "tokio"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "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)",
 "tokio-codec 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-executor 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-fs 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-tcp 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "tokio-channel"
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 = [
[[package]]
name = "tokio-current-thread"
"checksum atty 0.2.11 (registry+https://github.com/rust-lang/crates.io-index)" = "9a7d5b8723950951411ee34d271d99dddcc2035a16ab25310ea2c8cfd4369652"
"checksum backtrace 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)" = "346d7644f0b5f9bc73082d3b2236b69a05fd35cce0cfa3724e184e6a5c9e2a2f"
"checksum base64 0.9.3 (registry+https://github.com/rust-lang/crates.io-index)" = "489d6c0ed21b11d038c31b6ceccca973e65d73ba3bd8ecb9a2babf5546164643"
"checksum bitflags 1.0.4 (registry+https://github.com/rust-lang/crates.io-index)" = "228047a76f468627ca71776ecdebd732a3423081fcf5125585bcd7c49886ce12"
"checksum blake2 0.7.1 (registry+https://github.com/rust-lang/crates.io-index)" = "73b77e29dbd0115e43938be2d5128ecf81c0353e00acaa65339a1242586951d9"
"checksum block-buffer 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)" = "a076c298b9ecdb530ed9d967e74a6027d6a7478924520acddcddc24c1c8ab3ab"
"checksum byte-tools 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)" = "560c32574a12a89ecd91f5e742165893f86e3ab98d21f8ea548658eb9eef5f40"
"checksum byteorder 1.2.7 (registry+https://github.com/rust-lang/crates.io-index)" = "94f88df23a25417badc922ab0f5716cc1330e87f71ddd9203b3a3ccd9cedf75d"
"checksum case 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)" = "e88b166b48e29667f5443df64df3c61dc07dc2b1a0b0d231800e07f09a33ecc1"
"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 constant_time_eq 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)" = "8ff012e225ce166d4422e0e78419d901719760f62ae2b7969ca6b564d1b54a9e"
"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 crypto-mac 0.5.2 (registry+https://github.com/rust-lang/crates.io-index)" = "0999b4ff4d3446d4ddb19a63e9e00c1876e75cd7000d20e57a693b4b3f08d958"
"checksum dbghelp-sys 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)" = "97590ba53bcb8ac28279161ca943a924d1fd4a8fb3fa63302591647c4fc5b850"
"checksum derive-error 0.0.4 (registry+https://github.com/rust-lang/crates.io-index)" = "ec098440b29ea3b1ece3e641bac424c19cf996779b623c9e0f2171495425c2c8"
"checksum digest 0.7.6 (registry+https://github.com/rust-lang/crates.io-index)" = "03b072242a8cbaf9c145665af9d250c59af3b958f83ed6824e13533cf76d5b90"
"checksum error-chain 0.1.12 (registry+https://github.com/rust-lang/crates.io-index)" = "faa976b4fd2e4c2b2f3f486874b19e61944d3de3de8b61c9fcf835d583871bcc"
"checksum error-chain 0.8.1 (registry+https://github.com/rust-lang/crates.io-index)" = "6930e04918388a9a2e41d518c25cf679ccafe26733fb4127dbf21993f2575d46"
"checksum failure 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)" = "6dd377bcc1b1b7ce911967e3ec24fa19c3224394ec05b54aa7b083d498341ac7"
"checksum failure_derive 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)" = "64c2d913fe8ed3b6c6518eedf4538255b989945c14c2a7d5cbff62a5e2120596"
"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-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.9.0 (registry+https://github.com/rust-lang/crates.io-index)" = "ef25c5683767570c2bbd7deba372926a55eaae9982d7726ee2a1050239d45b9d"
"checksum hostname 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)" = "21ceb46a83a85e824ef93669c8b390009623863b5c195d1ba747292c0c72f94e"
"checksum httparse 1.3.3 (registry+https://github.com/rust-lang/crates.io-index)" = "e8734b0cfd3bc3e101ec59100e101c2eecd19282202e87808b3037b442777a83"
"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 itoa 0.4.3 (registry+https://github.com/rust-lang/crates.io-index)" = "1306f3464951f30e30d12373d31c79fbd52d236e5e896fd92f96ec7babbbe60b"
"checksum jid 0.5.2 (registry+https://github.com/rust-lang/crates.io-index)" = "6c4cee633b7ce95e71202ecb99e632d15ad468de7753e616a924c93842f1a3d0"
"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 linked-hash-map 0.4.2 (registry+https://github.com/rust-lang/crates.io-index)" = "7860ec297f7008ff7a1e3382d7f7e1dcd69efc94751a2284bafc3d013c2aa939"
"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 matches 0.1.8 (registry+https://github.com/rust-lang/crates.io-index)" = "7ffc5c5338469d4d3ea17d269fa8ea3512ad247247c30bd2df69e68309ed0a08"
"checksum memoffset 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)" = "0f9dc261e2b62d7a622bf416ea3c5245cdd5d9a7fcc428c0d06804dfce1775b3"
"checksum minidom 0.9.1 (registry+https://github.com/rust-lang/crates.io-index)" = "c0a5296bf9d0ac9e4a6e4cb844e3ee84bf33f841c7b3ae2cc87f05ceb81b50ae"
"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.1 (registry+https://github.com/rust-lang/crates.io-index)" = "0cdc457076c78ab54d5e0d6fa7c47981757f1e34dc39ff92787f217dede586c4"
"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 openssl 0.10.15 (registry+https://github.com/rust-lang/crates.io-index)" = "5e1309181cdcbdb51bc3b6bedb33dfac2a83b3d585033d3f6d9e22e8c1928613"
"checksum openssl-probe 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)" = "77af24da69f9d9341038eba93a073b1fdaaa1b788221b00a69bce9e762cb32de"
"checksum openssl-sys 0.9.39 (registry+https://github.com/rust-lang/crates.io-index)" = "278c1ad40a89aa1e741a1eed089a2f60b18fab8089c3139b542140fc7d674106"
"checksum parking_lot 0.6.4 (registry+https://github.com/rust-lang/crates.io-index)" = "f0802bff09003b291ba756dc7e79313e51cc31667e94afbe847def490424cde5"
"checksum parking_lot_core 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)" = "ad7f7e6ebdc79edff6fdcb87a55b620174f7a989e3eb31b65231f4af57f00b8c"
"checksum percent-encoding 1.0.1 (registry+https://github.com/rust-lang/crates.io-index)" = "31010dd2e1ac33d5b46a5b413495239882813e0369f8ed8a5e266f173602f831"
"checksum phf 0.7.23 (registry+https://github.com/rust-lang/crates.io-index)" = "cec29da322b242f4c3098852c77a0ca261c9c01b806cae85a5572a1eb94db9a6"
"checksum phf_codegen 0.7.23 (registry+https://github.com/rust-lang/crates.io-index)" = "7d187f00cd98d5afbcd8898f6cf181743a449162aeb329dcd2f3849009e605ad"
"checksum phf_generator 0.7.23 (registry+https://github.com/rust-lang/crates.io-index)" = "03dc191feb9b08b0dc1330d6549b795b9d81aec19efe6b4a45aec8d4caee0c4b"
"checksum phf_shared 0.7.23 (registry+https://github.com/rust-lang/crates.io-index)" = "b539898d22d4273ded07f64a05737649dc69095d92cb87c7097ec68e3f150b93"
"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 quick-error 1.2.2 (registry+https://github.com/rust-lang/crates.io-index)" = "9274b940887ce9addde99c4eee6b5c44cc494b182b97e73dc8ffdcb3397fd3f0"
"checksum quick-xml 0.12.4 (registry+https://github.com/rust-lang/crates.io-index)" = "1d8065cbb01701c11cc195cde85cbf39d1c6a80705b67a157ebb3042e0e5777f"
"checksum quote 0.3.15 (registry+https://github.com/rust-lang/crates.io-index)" = "7a6e920b65c65f10b2ae65c831a81a073a89edd28c7cce89475bff467ab4167a"
"checksum rand 0.4.3 (registry+https://github.com/rust-lang/crates.io-index)" = "8356f47b32624fef5b3301c1be97e5944ecdd595409cc5da11d05f211db6cfbd"
"checksum rand 0.5.5 (registry+https://github.com/rust-lang/crates.io-index)" = "e464cd887e869cddcae8792a4ee31d23c7edd516700695608f5b98c67ee0131c"
"checksum rand_core 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)" = "1961a422c4d189dfb50ffa9320bf1f2a9bd54ecb92792fb9477f99a1045f3372"
"checksum rand_core 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)" = "0905b6b7079ec73b314d4c748701f6931eb79fd97c668caa3f1899b22b32c6db"
"checksum redox_termios 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "7e891cfe48e9100a70a3b6eb652fef28920c117d366339687bd5576160db0f76"
"checksum remove_dir_all 0.5.1 (registry+https://github.com/rust-lang/crates.io-index)" = "3488ba1b9a2084d38645c4c08276a1752dcbf2c7130d74f1569681ad5d2799c5"
"checksum resolv-conf 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)" = "c62bd95a41841efdf7fca2ae9951e64a8d8eae7e5da196d8ce489a2241491a92"
"checksum rustc_version 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)" = "138e3e0acb6c9fb258b19b67cb8abd63c00679d2851805ea151465464fe9030a"
"checksum safemem 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)" = "8dca453248a96cb0749e36ccdfe2b0b4e54a61bfef89fb97ec621eb8e0a93dd9"
"checksum sasl 0.4.2 (registry+https://github.com/rust-lang/crates.io-index)" = "4dbda5436dcd059da44fbf84b87a7164c5e3cad354efd0630c1f2be3c51c8859"
"checksum schannel 0.1.14 (registry+https://github.com/rust-lang/crates.io-index)" = "0e1a231dc10abf6749cfa5d7767f25888d484201accbd919b66ab5413c502d56"
"checksum scopeguard 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)" = "94258f53601af11e6a49f722422f6e3425c52b06245a5cf9bc09908b174f5e27"
"checksum security-framework 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)" = "697d3f3c23a618272ead9e1fb259c1411102b31c6af8b93f1d64cca9c3b0e8e0"
"checksum security-framework-sys 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)" = "ab01dfbe5756785b5b4d46e0289e5a18071dfa9a7c2b24213ea00b9ef9b665bf"
"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 sha-1 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)" = "51b9d1f3b5de8a167ab06834a7c883bd197f2191e1dda1a22d9ccfeedbf9aded"
"checksum sha2 0.7.1 (registry+https://github.com/rust-lang/crates.io-index)" = "9eb6be24e4c23a84d7184280d2722f7f2731fcdd4a9d886efbfe4413e4847ea0"
"checksum sha3 0.7.3 (registry+https://github.com/rust-lang/crates.io-index)" = "b64dcef59ed4290b9fb562b53df07f564690d6539e8ecdd4728cf392477530bc"
"checksum siphasher 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)" = "0b8de496cf83d4ed58b6be86c3a275b8602f6ffe98d3024a869e124147a9a3ac"
"checksum slab 0.4.1 (registry+https://github.com/rust-lang/crates.io-index)" = "5f9776d6b986f77b35c6cf846c11ad986ff128fe0b2b63a3628e3755e8d3102d"
"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_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 syn 0.11.11 (registry+https://github.com/rust-lang/crates.io-index)" = "d3b891b9015c88c576343b9b3e41c2c11a51c219ef067b264bd9c8aa9b441dad"
"checksum synom 0.11.3 (registry+https://github.com/rust-lang/crates.io-index)" = "a393066ed9010ebaed60b9eafa373d4b1baac186dd7e008555b0f702b51945b6"
"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 tokio 0.1.11 (registry+https://github.com/rust-lang/crates.io-index)" = "6e93c78d23cc61aa245a8acd2c4a79c4d7fa7fb5c3ca90d5737029f043a84895"
"checksum tokio-current-thread 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)" = "f90fcd90952f0a496d438a976afba8e5c205fb12123f813d8ab3aa1c8436638c"
"checksum tokio-reactor 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)" = "4b26fd37f1125738b2170c80b551f69ff6fecb277e6e5ca885e53eec2b005018"
"checksum tokio-signal 0.2.6 (registry+https://github.com/rust-lang/crates.io-index)" = "40da88e6445ed335e14746b60986a6c8b3632b09bc9097df76b4a6ddd16f1f92"
"checksum tokio-threadpool 0.1.8 (registry+https://github.com/rust-lang/crates.io-index)" = "3929aee321c9220ed838ed6c3928be7f9b69986b0e3c22c972a66dbf8a298c68"
"checksum tokio-timer 0.2.7 (registry+https://github.com/rust-lang/crates.io-index)" = "3a52f00c97fedb6d535d27f65cccb7181c8dd4c6edc3eda9ea93f6d45d05168e"
"checksum tokio-udp 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)" = "da941144b816d0dcda4db3a1ba87596e4df5e860a72b70783fe435891f80601c"
"checksum tokio-uds 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)" = "df195376b43508f01570bacc73e13a1de0854dc59e79d1ec09913e8db6dd2a70"
"checksum toml 0.4.8 (registry+https://github.com/rust-lang/crates.io-index)" = "4a2ecc31b0351ea18b3fe11274b8db6e4d82bce861bbb22e6dbed40417902c65"
"checksum ucd-util 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "fd2be2d6639d0f8fe6cdda291ad456e23629558d466e2789d2c3e9892bda285d"
"checksum url 1.7.1 (registry+https://github.com/rust-lang/crates.io-index)" = "2a321979c09843d272956e73700d12c4e7d3d92b2ee112b31548aef0d4efc5a6"
"checksum utf8-ranges 1.0.1 (registry+https://github.com/rust-lang/crates.io-index)" = "fd70f467df6810094968e2fce0ee1bd0e87157aceb026a8c083bcf5e25b9efe4"
"checksum xml5ever 0.12.0 (registry+https://github.com/rust-lang/crates.io-index)" = "ead952cf8bab253fb5cb56e1fff780747bbf7a7258fb0451afe645a166050b1f"
"checksum xmpp-parsers 0.11.1 (registry+https://github.com/rust-lang/crates.io-index)" = "2e1e0a279d5af83a1dff442249f8a43214ac120267acfaac494b9d28c0027fea"
"checksum xml5ever 0.12.1 (registry+https://github.com/rust-lang/crates.io-index)" = "32cd7ebf0203c620906230ce22caa5df0b603c32b6fef72a275a48f6a2ae64b9"
"checksum xml5ever 0.12.0 (registry+https://github.com/rust-lang/crates.io-index)" = "ead952cf8bab253fb5cb56e1fff780747bbf7a7258fb0451afe645a166050b1f"
"checksum xml5ever 0.12.0 (registry+https://github.com/rust-lang/crates.io-index)" = "ead952cf8bab253fb5cb56e1fff780747bbf7a7258fb0451afe645a166050b1f"
"checksum xml5ever 0.12.1 (registry+https://github.com/rust-lang/crates.io-index)" = "32cd7ebf0203c620906230ce22caa5df0b603c32b6fef72a275a48f6a2ae64b9"
"checksum xml5ever 0.12.1 (registry+https://github.com/rust-lang/crates.io-index)" = "32cd7ebf0203c620906230ce22caa5df0b603c32b6fef72a275a48f6a2ae64b9"
"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 version_check 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)" = "914b1a6776c4c929a602fafd8bc742e06365d4bcbe48c30f9cca5824f70dc9dd"
"checksum void 1.0.2 (registry+https://github.com/rust-lang/crates.io-index)" = "6a02e4885ed3bc0f2de90ea6dd45ebcbb66dacffe03547fadbb0eeae2770887d"
"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.1 (registry+https://github.com/rust-lang/crates.io-index)" = "afc5508759c5bf4285e61feb862b6083c8480aec864fa17a81fdec6f69b461ab"
"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 utf8-ranges 1.0.2 (registry+https://github.com/rust-lang/crates.io-index)" = "796f7e48bef87609f7ade7e06495a87d5cd06c7866e6a5cbfceffc558a243737"
"checksum utf8-ranges 1.0.1 (registry+https://github.com/rust-lang/crates.io-index)" = "fd70f467df6810094968e2fce0ee1bd0e87157aceb026a8c083bcf5e25b9efe4"
"checksum utf8-ranges 1.0.1 (registry+https://github.com/rust-lang/crates.io-index)" = "fd70f467df6810094968e2fce0ee1bd0e87157aceb026a8c083bcf5e25b9efe4"
"checksum utf8-ranges 1.0.2 (registry+https://github.com/rust-lang/crates.io-index)" = "796f7e48bef87609f7ade7e06495a87d5cd06c7866e6a5cbfceffc558a243737"
"checksum utf8-ranges 1.0.2 (registry+https://github.com/rust-lang/crates.io-index)" = "796f7e48bef87609f7ade7e06495a87d5cd06c7866e6a5cbfceffc558a243737"
"checksum utf-8 0.7.4 (registry+https://github.com/rust-lang/crates.io-index)" = "bab35f71693630bb1953dce0f2bcd780e7cde025027124a202ac08a45ba25141"
"checksum url 1.7.2 (registry+https://github.com/rust-lang/crates.io-index)" = "dd4e7c0d531266369519a4aa4f399d748bd37043b00bde1e4ff1f60a120b355a"
"checksum url 1.7.1 (registry+https://github.com/rust-lang/crates.io-index)" = "2a321979c09843d272956e73700d12c4e7d3d92b2ee112b31548aef0d4efc5a6"
"checksum url 1.7.1 (registry+https://github.com/rust-lang/crates.io-index)" = "2a321979c09843d272956e73700d12c4e7d3d92b2ee112b31548aef0d4efc5a6"
"checksum url 1.7.2 (registry+https://github.com/rust-lang/crates.io-index)" = "dd4e7c0d531266369519a4aa4f399d748bd37043b00bde1e4ff1f60a120b355a"
"checksum url 1.7.2 (registry+https://github.com/rust-lang/crates.io-index)" = "dd4e7c0d531266369519a4aa4f399d748bd37043b00bde1e4ff1f60a120b355a"
"checksum unicode-bidi 0.3.4 (registry+https://github.com/rust-lang/crates.io-index)" = "49f2bd0c6468a8230e1db229cff8029217cf623c767ea5d60bfbd42729ea54d5"
"checksum unicode-normalization 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)" = "6a0180bc61fc5a987082bfa111f4cc95c4caff7f9799f3e46df09163a937aa25"
"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 unreachable 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)" = "382810877fe448991dfc7f0dd6e3ae5d58088fd0ea5e35189655f84e6814fa56"
"checksum ucd-util 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)" = "535c204ee4d8434478593480b8f86ab45ec9aae0e83c568ca81abf0fd0e88f86"
"checksum ucd-util 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "fd2be2d6639d0f8fe6cdda291ad456e23629558d466e2789d2c3e9892bda285d"
"checksum ucd-util 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "fd2be2d6639d0f8fe6cdda291ad456e23629558d466e2789d2c3e9892bda285d"
"checksum ucd-util 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)" = "535c204ee4d8434478593480b8f86ab45ec9aae0e83c568ca81abf0fd0e88f86"
"checksum ucd-util 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)" = "535c204ee4d8434478593480b8f86ab45ec9aae0e83c568ca81abf0fd0e88f86"
"checksum trust-dns-proto 0.4.3 (registry+https://github.com/rust-lang/crates.io-index)" = "f1525ca4e26f5a09d81b79584f19225e7dba5606ae3a416311c2751c5cea60bb"
"checksum trust-dns-resolver 0.9.1 (registry+https://github.com/rust-lang/crates.io-index)" = "4a821ad51a29816420b8cac4b026756b81c023630b97eaa4c8090637ee3508bd"
"checksum try-lock 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)" = "e604eb7b43c06650e854be16a2a03155743d3752dd1c943f6829e26b7a36e382"
"checksum try_from 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)" = "923a7ee3e97dbfe8685261beb4511cc9620a1252405d02693d43169729570111"
"checksum typenum 1.10.0 (registry+https://github.com/rust-lang/crates.io-index)" = "612d636f949607bdf9b123b4a6f6d966dedf3ff669f7f045890d3a4a73948169"
"checksum toml 0.4.9 (registry+https://github.com/rust-lang/crates.io-index)" = "19782e145d5abefb03758958f06ea35f7b1d8421b534140e0238fd3d0bfd66e3"
"checksum toml 0.4.8 (registry+https://github.com/rust-lang/crates.io-index)" = "4a2ecc31b0351ea18b3fe11274b8db6e4d82bce861bbb22e6dbed40417902c65"
"checksum toml 0.4.10 (registry+https://github.com/rust-lang/crates.io-index)" = "758664fc71a3a69038656bee8b6be6477d2a6c315a6b81f7081f591bffa4111f"
"checksum toml 0.4.8 (registry+https://github.com/rust-lang/crates.io-index)" = "4a2ecc31b0351ea18b3fe11274b8db6e4d82bce861bbb22e6dbed40417902c65"
"checksum toml 0.4.10 (registry+https://github.com/rust-lang/crates.io-index)" = "758664fc71a3a69038656bee8b6be6477d2a6c315a6b81f7081f591bffa4111f"
"checksum toml 0.4.9 (registry+https://github.com/rust-lang/crates.io-index)" = "19782e145d5abefb03758958f06ea35f7b1d8421b534140e0238fd3d0bfd66e3"
"checksum tokio-xmpp 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)" = "c27385c4781afc851c61ac66d79463c511bf073d3a5d71b8bfd13a816e475989"
"checksum tokio-udp 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)" = "66268575b80f4a4a710ef83d087fdfeeabdce9b74c797535fbac18a2cb906e92"
"checksum tokio-uds 0.2.4 (registry+https://github.com/rust-lang/crates.io-index)" = "99ce87382f6c1a24b513a72c048b2c8efe66cb5161c9061d00bee510f08dc168"
"checksum tokio-udp 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)" = "da941144b816d0dcda4db3a1ba87596e4df5e860a72b70783fe435891f80601c"
"checksum tokio-uds 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)" = "df195376b43508f01570bacc73e13a1de0854dc59e79d1ec09913e8db6dd2a70"
"checksum tokio-udp 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)" = "da941144b816d0dcda4db3a1ba87596e4df5e860a72b70783fe435891f80601c"
"checksum tokio-uds 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)" = "df195376b43508f01570bacc73e13a1de0854dc59e79d1ec09913e8db6dd2a70"
"checksum tokio-udp 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)" = "66268575b80f4a4a710ef83d087fdfeeabdce9b74c797535fbac18a2cb906e92"
"checksum tokio-uds 0.2.4 (registry+https://github.com/rust-lang/crates.io-index)" = "99ce87382f6c1a24b513a72c048b2c8efe66cb5161c9061d00bee510f08dc168"
"checksum tokio-udp 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)" = "66268575b80f4a4a710ef83d087fdfeeabdce9b74c797535fbac18a2cb906e92"
"checksum tokio-uds 0.2.4 (registry+https://github.com/rust-lang/crates.io-index)" = "99ce87382f6c1a24b513a72c048b2c8efe66cb5161c9061d00bee510f08dc168"
"checksum tokio-tls 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)" = "e53fdbf3156f588be1676022fe794232b24922d426e8c14f4e46891c1e31c440"
"checksum tokio-threadpool 0.1.9 (registry+https://github.com/rust-lang/crates.io-index)" = "56c5556262383032878afad66943926a1d1f0967f17e94bd7764ceceb3b70e7f"
"checksum tokio-timer 0.2.8 (registry+https://github.com/rust-lang/crates.io-index)" = "4f37f0111d76cc5da132fe9bc0590b9b9cfd079bc7e75ac3846278430a299ff8"
"checksum tokio-threadpool 0.1.8 (registry+https://github.com/rust-lang/crates.io-index)" = "3929aee321c9220ed838ed6c3928be7f9b69986b0e3c22c972a66dbf8a298c68"
"checksum tokio-timer 0.2.7 (registry+https://github.com/rust-lang/crates.io-index)" = "3a52f00c97fedb6d535d27f65cccb7181c8dd4c6edc3eda9ea93f6d45d05168e"
"checksum tokio-threadpool 0.1.8 (registry+https://github.com/rust-lang/crates.io-index)" = "3929aee321c9220ed838ed6c3928be7f9b69986b0e3c22c972a66dbf8a298c68"
"checksum tokio-timer 0.2.7 (registry+https://github.com/rust-lang/crates.io-index)" = "3a52f00c97fedb6d535d27f65cccb7181c8dd4c6edc3eda9ea93f6d45d05168e"
"checksum tokio-threadpool 0.1.9 (registry+https://github.com/rust-lang/crates.io-index)" = "56c5556262383032878afad66943926a1d1f0967f17e94bd7764ceceb3b70e7f"
"checksum tokio-timer 0.2.8 (registry+https://github.com/rust-lang/crates.io-index)" = "4f37f0111d76cc5da132fe9bc0590b9b9cfd079bc7e75ac3846278430a299ff8"
"checksum tokio-threadpool 0.1.9 (registry+https://github.com/rust-lang/crates.io-index)" = "56c5556262383032878afad66943926a1d1f0967f17e94bd7764ceceb3b70e7f"
"checksum tokio-timer 0.2.8 (registry+https://github.com/rust-lang/crates.io-index)" = "4f37f0111d76cc5da132fe9bc0590b9b9cfd079bc7e75ac3846278430a299ff8"
"checksum tokio-tcp 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)" = "7ad235e9dadd126b2d47f6736f65aa1fdcd6420e66ca63f44177bc78df89f912"
"checksum tokio-reactor 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)" = "502b625acb4ee13cbb3b90b8ca80e0addd263ddacf6931666ef751e610b07fb5"
"checksum tokio-signal 0.2.7 (registry+https://github.com/rust-lang/crates.io-index)" = "dd6dc5276ea05ce379a16de90083ec80836440d5ef8a6a39545a3207373b8296"
"checksum tokio-reactor 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)" = "4b26fd37f1125738b2170c80b551f69ff6fecb277e6e5ca885e53eec2b005018"
"checksum tokio-signal 0.2.6 (registry+https://github.com/rust-lang/crates.io-index)" = "40da88e6445ed335e14746b60986a6c8b3632b09bc9097df76b4a6ddd16f1f92"
"checksum tokio-reactor 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)" = "4b26fd37f1125738b2170c80b551f69ff6fecb277e6e5ca885e53eec2b005018"
"checksum tokio-signal 0.2.6 (registry+https://github.com/rust-lang/crates.io-index)" = "40da88e6445ed335e14746b60986a6c8b3632b09bc9097df76b4a6ddd16f1f92"
"checksum tokio-reactor 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)" = "502b625acb4ee13cbb3b90b8ca80e0addd263ddacf6931666ef751e610b07fb5"
"checksum tokio-signal 0.2.7 (registry+https://github.com/rust-lang/crates.io-index)" = "dd6dc5276ea05ce379a16de90083ec80836440d5ef8a6a39545a3207373b8296"
"checksum tokio-reactor 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)" = "502b625acb4ee13cbb3b90b8ca80e0addd263ddacf6931666ef751e610b07fb5"
"checksum tokio-signal 0.2.7 (registry+https://github.com/rust-lang/crates.io-index)" = "dd6dc5276ea05ce379a16de90083ec80836440d5ef8a6a39545a3207373b8296"
"checksum tokio-executor 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)" = "c117b6cf86bb730aab4834f10df96e4dd586eff2c3c27d3781348da49e255bde"
"checksum tokio-fs 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)" = "60ae25f6b17d25116d2cba342083abe5255d3c2c79cb21ea11aa049c53bf7c75"
"checksum tokio-io 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)" = "7392fe0a70d5ce0c882c4778116c519bd5dbaa8a7c3ae3d04578b3afafdcda21"
"checksum tokio-current-thread 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)" = "331c8acc267855ec06eb0c94618dcbbfea45bed2d20b77252940095273fb58f6"
"checksum tokio-current-thread 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)" = "f90fcd90952f0a496d438a976afba8e5c205fb12123f813d8ab3aa1c8436638c"
"checksum tokio-current-thread 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)" = "f90fcd90952f0a496d438a976afba8e5c205fb12123f813d8ab3aa1c8436638c"
"checksum tokio-current-thread 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)" = "331c8acc267855ec06eb0c94618dcbbfea45bed2d20b77252940095273fb58f6"
"checksum tokio-current-thread 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)" = "331c8acc267855ec06eb0c94618dcbbfea45bed2d20b77252940095273fb58f6"
"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 0.1.13 (registry+https://github.com/rust-lang/crates.io-index)" = "a7817d4c98cc5be21360b3b37d6036fe9b7aefa5b7a201b7b16ff33423822f7d"
"checksum tokio 0.1.11 (registry+https://github.com/rust-lang/crates.io-index)" = "6e93c78d23cc61aa245a8acd2c4a79c4d7fa7fb5c3ca90d5737029f043a84895"
"checksum tokio 0.1.11 (registry+https://github.com/rust-lang/crates.io-index)" = "6e93c78d23cc61aa245a8acd2c4a79c4d7fa7fb5c3ca90d5737029f043a84895"
"checksum tokio 0.1.13 (registry+https://github.com/rust-lang/crates.io-index)" = "a7817d4c98cc5be21360b3b37d6036fe9b7aefa5b7a201b7b16ff33423822f7d"
"checksum tokio 0.1.13 (registry+https://github.com/rust-lang/crates.io-index)" = "a7817d4c98cc5be21360b3b37d6036fe9b7aefa5b7a201b7b16ff33423822f7d"
"checksum time 0.1.40 (registry+https://github.com/rust-lang/crates.io-index)" = "d825be0eb33fda1a7e68012d51e9c7f451dc1a69391e7fdc197060bb8c56667b"
"checksum time 0.1.40 (registry+https://github.com/rust-lang/crates.io-index)" = "d825be0eb33fda1a7e68012d51e9c7f451dc1a69391e7fdc197060bb8c56667b"
"checksum time 0.1.41 (registry+https://github.com/rust-lang/crates.io-index)" = "847da467bf0db05882a9e2375934a8a55cffdc9db0d128af1518200260ba1f6c"
"checksum tendril 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)" = "9de21546595a0873061940d994bbbc5c35f024ae4fd61ec5c5b159115684f508"
"checksum tendril 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)" = "9de21546595a0873061940d994bbbc5c35f024ae4fd61ec5c5b159115684f508"
"checksum tendril 0.4.1 (registry+https://github.com/rust-lang/crates.io-index)" = "707feda9f2582d5d680d733e38755547a3e8fb471e7ba11452ecfd9ce93a5d3b"
"checksum tendril 0.4.1 (registry+https://github.com/rust-lang/crates.io-index)" = "707feda9f2582d5d680d733e38755547a3e8fb471e7ba11452ecfd9ce93a5d3b"
"checksum synstructure 0.10.0 (registry+https://github.com/rust-lang/crates.io-index)" = "ec37f4fab4bafaf6b5621c1d54e6aa5d4d059a8f84929e87abfdd7f9f04c6db2"
"checksum tempfile 3.0.4 (registry+https://github.com/rust-lang/crates.io-index)" = "55c1195ef8513f3273d55ff59fe5da6940287a0d7a98331254397f464833675b"
"checksum synstructure 0.10.1 (registry+https://github.com/rust-lang/crates.io-index)" = "73687139bf99285483c96ac0add482c3776528beac1d97d444f6e91f203a2015"
"checksum tempfile 3.0.5 (registry+https://github.com/rust-lang/crates.io-index)" = "7e91405c14320e5c79b3d148e1c86f40749a36e490642202a31689cb1a3452b2"
"checksum synstructure 0.10.0 (registry+https://github.com/rust-lang/crates.io-index)" = "ec37f4fab4bafaf6b5621c1d54e6aa5d4d059a8f84929e87abfdd7f9f04c6db2"
"checksum tempfile 3.0.4 (registry+https://github.com/rust-lang/crates.io-index)" = "55c1195ef8513f3273d55ff59fe5da6940287a0d7a98331254397f464833675b"
"checksum tendril 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)" = "9de21546595a0873061940d994bbbc5c35f024ae4fd61ec5c5b159115684f508"
"checksum synstructure 0.10.0 (registry+https://github.com/rust-lang/crates.io-index)" = "ec37f4fab4bafaf6b5621c1d54e6aa5d4d059a8f84929e87abfdd7f9f04c6db2"
"checksum tempfile 3.0.4 (registry+https://github.com/rust-lang/crates.io-index)" = "55c1195ef8513f3273d55ff59fe5da6940287a0d7a98331254397f464833675b"
"checksum synstructure 0.10.1 (registry+https://github.com/rust-lang/crates.io-index)" = "73687139bf99285483c96ac0add482c3776528beac1d97d444f6e91f203a2015"
"checksum tempfile 3.0.5 (registry+https://github.com/rust-lang/crates.io-index)" = "7e91405c14320e5c79b3d148e1c86f40749a36e490642202a31689cb1a3452b2"
"checksum synstructure 0.10.1 (registry+https://github.com/rust-lang/crates.io-index)" = "73687139bf99285483c96ac0add482c3776528beac1d97d444f6e91f203a2015"
"checksum tempfile 3.0.5 (registry+https://github.com/rust-lang/crates.io-index)" = "7e91405c14320e5c79b3d148e1c86f40749a36e490642202a31689cb1a3452b2"
"checksum syn 0.15.14 (registry+https://github.com/rust-lang/crates.io-index)" = "baaba45c6bf60fe29aaf241fa33306c0b75c801edea8378263a8f043b09a5634"
"checksum syn 0.15.22 (registry+https://github.com/rust-lang/crates.io-index)" = "ae8b29eb5210bc5cf63ed6149cbf9adfc82ac0be023d8735c176ee74a2db4da7"
"checksum syn 0.15.14 (registry+https://github.com/rust-lang/crates.io-index)" = "baaba45c6bf60fe29aaf241fa33306c0b75c801edea8378263a8f043b09a5634"
"checksum syn 0.15.14 (registry+https://github.com/rust-lang/crates.io-index)" = "baaba45c6bf60fe29aaf241fa33306c0b75c801edea8378263a8f043b09a5634"
"checksum syn 0.15.22 (registry+https://github.com/rust-lang/crates.io-index)" = "ae8b29eb5210bc5cf63ed6149cbf9adfc82ac0be023d8735c176ee74a2db4da7"
"checksum syn 0.15.23 (registry+https://github.com/rust-lang/crates.io-index)" = "9545a6a093a3f0bd59adb472700acc08cad3776f860f16a897dfce8c88721cbc"
"checksum syn 0.15.22 (registry+https://github.com/rust-lang/crates.io-index)" = "ae8b29eb5210bc5cf63ed6149cbf9adfc82ac0be023d8735c176ee74a2db4da7"
"checksum string 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "00caf261d6f90f588f8450b8e1230fa0d5be49ee6140fdfbcb55335aff350970"
"checksum string 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)" = "98998cced76115b1da46f63388b909d118a37ae0be0f82ad35773d4a4bc9d18d"
"checksum string 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "00caf261d6f90f588f8450b8e1230fa0d5be49ee6140fdfbcb55335aff350970"
"checksum string 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "00caf261d6f90f588f8450b8e1230fa0d5be49ee6140fdfbcb55335aff350970"
"checksum string 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)" = "98998cced76115b1da46f63388b909d118a37ae0be0f82ad35773d4a4bc9d18d"
"checksum string 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)" = "98998cced76115b1da46f63388b909d118a37ae0be0f82ad35773d4a4bc9d18d"
"checksum smallvec 0.6.5 (registry+https://github.com/rust-lang/crates.io-index)" = "153ffa32fd170e9944f7e0838edf824a754ec4c1fc64746fcc9fe1f8fa602e5d"
"checksum smallvec 0.6.7 (registry+https://github.com/rust-lang/crates.io-index)" = "b73ea3738b47563803ef814925e69be00799a8c07420be8b996f8e98fb2336db"
"checksum smallvec 0.6.6 (registry+https://github.com/rust-lang/crates.io-index)" = "622df2d454c29a4d89b30dc3b27b42d7d90d6b9e587dbf8f67652eb7514da484"
"checksum smallvec 0.6.5 (registry+https://github.com/rust-lang/crates.io-index)" = "153ffa32fd170e9944f7e0838edf824a754ec4c1fc64746fcc9fe1f8fa602e5d"
"checksum smallvec 0.6.5 (registry+https://github.com/rust-lang/crates.io-index)" = "153ffa32fd170e9944f7e0838edf824a754ec4c1fc64746fcc9fe1f8fa602e5d"
"checksum smallvec 0.6.6 (registry+https://github.com/rust-lang/crates.io-index)" = "622df2d454c29a4d89b30dc3b27b42d7d90d6b9e587dbf8f67652eb7514da484"
"checksum smallvec 0.6.7 (registry+https://github.com/rust-lang/crates.io-index)" = "b73ea3738b47563803ef814925e69be00799a8c07420be8b996f8e98fb2336db"
"checksum smallvec 0.6.6 (registry+https://github.com/rust-lang/crates.io-index)" = "622df2d454c29a4d89b30dc3b27b42d7d90d6b9e587dbf8f67652eb7514da484"
"checksum signal-hook 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)" = "f7ca1f1c0ed6c8beaab713ad902c041e4f09d06e1b4bb74c5fc553c078ed0110"
"checksum signal-hook 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)" = "8941ae94fa73d0f73b422774b3a40a7195cecd88d1c090f4b37ade7dc795ab66"
"checksum signal-hook 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)" = "f7ca1f1c0ed6c8beaab713ad902c041e4f09d06e1b4bb74c5fc553c078ed0110"
"checksum signal-hook 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)" = "f7ca1f1c0ed6c8beaab713ad902c041e4f09d06e1b4bb74c5fc553c078ed0110"
"checksum signal-hook 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)" = "8941ae94fa73d0f73b422774b3a40a7195cecd88d1c090f4b37ade7dc795ab66"
"checksum signal-hook 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)" = "8941ae94fa73d0f73b422774b3a40a7195cecd88d1c090f4b37ade7dc795ab66"
"checksum serde_json 1.0.32 (registry+https://github.com/rust-lang/crates.io-index)" = "43344e7ce05d0d8280c5940cabb4964bea626aa58b1ec0e8c73fa2a8512a38ce"
"checksum serde_json 1.0.33 (registry+https://github.com/rust-lang/crates.io-index)" = "c37ccd6be3ed1fdf419ee848f7c758eb31b054d7cd3ae3600e3bae0adf569811"
"checksum serde_json 1.0.32 (registry+https://github.com/rust-lang/crates.io-index)" = "43344e7ce05d0d8280c5940cabb4964bea626aa58b1ec0e8c73fa2a8512a38ce"
"checksum serde_json 1.0.33 (registry+https://github.com/rust-lang/crates.io-index)" = "c37ccd6be3ed1fdf419ee848f7c758eb31b054d7cd3ae3600e3bae0adf569811"
"checksum serde_json 1.0.33 (registry+https://github.com/rust-lang/crates.io-index)" = "c37ccd6be3ed1fdf419ee848f7c758eb31b054d7cd3ae3600e3bae0adf569811"
"checksum serde 1.0.80 (registry+https://github.com/rust-lang/crates.io-index)" = "15c141fc7027dd265a47c090bf864cf62b42c4d228bbcf4e51a0c9e2b0d3f7ef"
"checksum serde_derive 1.0.80 (registry+https://github.com/rust-lang/crates.io-index)" = "225de307c6302bec3898c51ca302fc94a7a1697ef0845fcee6448f33c032249c"
"checksum serde 1.0.80 (registry+https://github.com/rust-lang/crates.io-index)" = "15c141fc7027dd265a47c090bf864cf62b42c4d228bbcf4e51a0c9e2b0d3f7ef"
"checksum serde_derive 1.0.80 (registry+https://github.com/rust-lang/crates.io-index)" = "225de307c6302bec3898c51ca302fc94a7a1697ef0845fcee6448f33c032249c"
"checksum serde_json 1.0.32 (registry+https://github.com/rust-lang/crates.io-index)" = "43344e7ce05d0d8280c5940cabb4964bea626aa58b1ec0e8c73fa2a8512a38ce"
"checksum serde 1.0.80 (registry+https://github.com/rust-lang/crates.io-index)" = "15c141fc7027dd265a47c090bf864cf62b42c4d228bbcf4e51a0c9e2b0d3f7ef"
"checksum serde_derive 1.0.80 (registry+https://github.com/rust-lang/crates.io-index)" = "225de307c6302bec3898c51ca302fc94a7a1697ef0845fcee6448f33c032249c"
"checksum serde 1.0.82 (registry+https://github.com/rust-lang/crates.io-index)" = "6fa52f19aee12441d5ad11c9a00459122bd8f98707cadf9778c540674f1935b6"
"checksum serde_derive 1.0.82 (registry+https://github.com/rust-lang/crates.io-index)" = "96a7f9496ac65a2db5929afa087b54f8fc5008dcfbe48a8874ed20049b0d6154"
"checksum serde 1.0.82 (registry+https://github.com/rust-lang/crates.io-index)" = "6fa52f19aee12441d5ad11c9a00459122bd8f98707cadf9778c540674f1935b6"
"checksum serde_derive 1.0.82 (registry+https://github.com/rust-lang/crates.io-index)" = "96a7f9496ac65a2db5929afa087b54f8fc5008dcfbe48a8874ed20049b0d6154"
"checksum ryu 0.2.6 (registry+https://github.com/rust-lang/crates.io-index)" = "7153dd96dade874ab973e098cb62fcdbb89a03682e46b144fd09550998d4a4a7"
"checksum ryu 0.2.7 (registry+https://github.com/rust-lang/crates.io-index)" = "eb9e9b8cde282a9fe6a42dd4681319bfb63f121b8a8ee9439c6f4107e58a46f7"
"checksum ryu 0.2.6 (registry+https://github.com/rust-lang/crates.io-index)" = "7153dd96dade874ab973e098cb62fcdbb89a03682e46b144fd09550998d4a4a7"
"checksum ryu 0.2.6 (registry+https://github.com/rust-lang/crates.io-index)" = "7153dd96dade874ab973e098cb62fcdbb89a03682e46b144fd09550998d4a4a7"
"checksum ryu 0.2.7 (registry+https://github.com/rust-lang/crates.io-index)" = "eb9e9b8cde282a9fe6a42dd4681319bfb63f121b8a8ee9439c6f4107e58a46f7"
"checksum ryu 0.2.7 (registry+https://github.com/rust-lang/crates.io-index)" = "eb9e9b8cde282a9fe6a42dd4681319bfb63f121b8a8ee9439c6f4107e58a46f7"
"checksum rustc-demangle 0.1.9 (registry+https://github.com/rust-lang/crates.io-index)" = "bcfe5b13211b4d78e5c2cadfebd7769197d95c639c35a50057eb4c05de811395"
"checksum rustc-demangle 0.1.9 (registry+https://github.com/rust-lang/crates.io-index)" = "bcfe5b13211b4d78e5c2cadfebd7769197d95c639c35a50057eb4c05de811395"
"checksum rustc-demangle 0.1.11 (registry+https://github.com/rust-lang/crates.io-index)" = "01b90379b8664dd83460d59bdc5dd1fd3172b8913788db483ed1325171eab2f7"
"checksum regex 1.0.5 (registry+https://github.com/rust-lang/crates.io-index)" = "2069749032ea3ec200ca51e4a31df41759190a88edca0d2d86ee8bedf7073341"
"checksum regex-syntax 0.6.2 (registry+https://github.com/rust-lang/crates.io-index)" = "747ba3b235651f6e2f67dfa8bcdcd073ddb7c243cb21c442fc12395dfcac212d"
"checksum regex 1.1.0 (registry+https://github.com/rust-lang/crates.io-index)" = "37e7cbbd370869ce2e8dff25c7018702d10b21a20ef7135316f8daecd6c25b7f"
"checksum regex-syntax 0.6.4 (registry+https://github.com/rust-lang/crates.io-index)" = "4e47a2ed29da7a9e1960e1639e7a982e6edc6d49be308a3b02daf511504a16d1"
"checksum regex 1.0.6 (registry+https://github.com/rust-lang/crates.io-index)" = "ee84f70c8c08744ea9641a731c7fadb475bf2ecc52d7f627feb833e0b3990467"
"checksum regex-syntax 0.6.3 (registry+https://github.com/rust-lang/crates.io-index)" = "fbc557aac2b708fe84121caf261346cc2eed71978024337e42eb46b8a252ac6e"
"checksum regex 1.0.5 (registry+https://github.com/rust-lang/crates.io-index)" = "2069749032ea3ec200ca51e4a31df41759190a88edca0d2d86ee8bedf7073341"
"checksum regex-syntax 0.6.2 (registry+https://github.com/rust-lang/crates.io-index)" = "747ba3b235651f6e2f67dfa8bcdcd073ddb7c243cb21c442fc12395dfcac212d"
"checksum regex 1.0.5 (registry+https://github.com/rust-lang/crates.io-index)" = "2069749032ea3ec200ca51e4a31df41759190a88edca0d2d86ee8bedf7073341"
"checksum regex-syntax 0.6.2 (registry+https://github.com/rust-lang/crates.io-index)" = "747ba3b235651f6e2f67dfa8bcdcd073ddb7c243cb21c442fc12395dfcac212d"
"checksum regex 1.0.6 (registry+https://github.com/rust-lang/crates.io-index)" = "ee84f70c8c08744ea9641a731c7fadb475bf2ecc52d7f627feb833e0b3990467"
"checksum regex-syntax 0.6.3 (registry+https://github.com/rust-lang/crates.io-index)" = "fbc557aac2b708fe84121caf261346cc2eed71978024337e42eb46b8a252ac6e"
"checksum regex 1.1.0 (registry+https://github.com/rust-lang/crates.io-index)" = "37e7cbbd370869ce2e8dff25c7018702d10b21a20ef7135316f8daecd6c25b7f"
"checksum regex-syntax 0.6.4 (registry+https://github.com/rust-lang/crates.io-index)" = "4e47a2ed29da7a9e1960e1639e7a982e6edc6d49be308a3b02daf511504a16d1"
"checksum regex 1.0.6 (registry+https://github.com/rust-lang/crates.io-index)" = "ee84f70c8c08744ea9641a731c7fadb475bf2ecc52d7f627feb833e0b3990467"
"checksum regex-syntax 0.6.3 (registry+https://github.com/rust-lang/crates.io-index)" = "fbc557aac2b708fe84121caf261346cc2eed71978024337e42eb46b8a252ac6e"
"checksum redox_syscall 0.1.43 (registry+https://github.com/rust-lang/crates.io-index)" = "679da7508e9a6390aeaf7fbd02a800fdc64b73fe2204dd2c8ae66d22d9d5ad5d"
"checksum redox_syscall 0.1.44 (registry+https://github.com/rust-lang/crates.io-index)" = "a84bcd297b87a545980a2d25a0beb72a1f490c31f0a9fde52fca35bfbb1ceb70"
"checksum redox_syscall 0.1.40 (registry+https://github.com/rust-lang/crates.io-index)" = "c214e91d3ecf43e9a4e41e578973adeb14b474f2bee858742d127af75a0112b1"
"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_pcg 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "086bd09a33c7044e56bb44d5bdde5a60e7f119a9e95b0775f545de759a32fe05"
"checksum rand_xorshift 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)" = "effa3fcaa47e18db002bdde6060944b6d2f9cfd8db471c30e873448ad9187be3"
"checksum redox_syscall 0.1.43 (registry+https://github.com/rust-lang/crates.io-index)" = "679da7508e9a6390aeaf7fbd02a800fdc64b73fe2204dd2c8ae66d22d9d5ad5d"
"checksum redox_syscall 0.1.40 (registry+https://github.com/rust-lang/crates.io-index)" = "c214e91d3ecf43e9a4e41e578973adeb14b474f2bee858742d127af75a0112b1"
"checksum redox_syscall 0.1.40 (registry+https://github.com/rust-lang/crates.io-index)" = "c214e91d3ecf43e9a4e41e578973adeb14b474f2bee858742d127af75a0112b1"
"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_pcg 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "086bd09a33c7044e56bb44d5bdde5a60e7f119a9e95b0775f545de759a32fe05"
"checksum rand_xorshift 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)" = "effa3fcaa47e18db002bdde6060944b6d2f9cfd8db471c30e873448ad9187be3"
"checksum 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_pcg 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "086bd09a33c7044e56bb44d5bdde5a60e7f119a9e95b0775f545de759a32fe05"
"checksum rand_xorshift 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)" = "effa3fcaa47e18db002bdde6060944b6d2f9cfd8db471c30e873448ad9187be3"
"checksum redox_syscall 0.1.43 (registry+https://github.com/rust-lang/crates.io-index)" = "679da7508e9a6390aeaf7fbd02a800fdc64b73fe2204dd2c8ae66d22d9d5ad5d"
"checksum rand 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)" = "ae9d223d52ae411a33cf7e54ec6034ec165df296ccd23533d671a28252b6f66a"
"checksum rand_chacha 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)" = "771b009e3a508cb67e8823dda454aaa5368c7bc1c16829fb77d3e980440dd34a"
"checksum rand 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)" = "ae9d223d52ae411a33cf7e54ec6034ec165df296ccd23533d671a28252b6f66a"
"checksum rand_chacha 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)" = "771b009e3a508cb67e8823dda454aaa5368c7bc1c16829fb77d3e980440dd34a"
"checksum rand 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)" = "ae9d223d52ae411a33cf7e54ec6034ec165df296ccd23533d671a28252b6f66a"
"checksum rand_chacha 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)" = "771b009e3a508cb67e8823dda454aaa5368c7bc1c16829fb77d3e980440dd34a"
"checksum quote 0.6.8 (registry+https://github.com/rust-lang/crates.io-index)" = "dd636425967c33af890042c483632d33fa7a18f19ad1d7ea72e8998c6ef8dea5"
"checksum quote 0.6.10 (registry+https://github.com/rust-lang/crates.io-index)" = "53fa22a1994bd0f9372d7a816207d8a2677ad0325b073f5c5332760f0fb62b5c"
"checksum quote 0.6.8 (registry+https://github.com/rust-lang/crates.io-index)" = "dd636425967c33af890042c483632d33fa7a18f19ad1d7ea72e8998c6ef8dea5"
"checksum quote 0.6.8 (registry+https://github.com/rust-lang/crates.io-index)" = "dd636425967c33af890042c483632d33fa7a18f19ad1d7ea72e8998c6ef8dea5"
"checksum quote 0.6.10 (registry+https://github.com/rust-lang/crates.io-index)" = "53fa22a1994bd0f9372d7a816207d8a2677ad0325b073f5c5332760f0fb62b5c"
"checksum quote 0.6.10 (registry+https://github.com/rust-lang/crates.io-index)" = "53fa22a1994bd0f9372d7a816207d8a2677ad0325b073f5c5332760f0fb62b5c"
"checksum proc-macro2 0.4.20 (registry+https://github.com/rust-lang/crates.io-index)" = "3d7b7eaaa90b4a90a932a9ea6666c95a389e424eff347f0f793979289429feee"
"checksum proc-macro2 0.4.24 (registry+https://github.com/rust-lang/crates.io-index)" = "77619697826f31a02ae974457af0b29b723e5619e113e9397b8b82c6bd253f09"
"checksum proc-macro2 0.4.20 (registry+https://github.com/rust-lang/crates.io-index)" = "3d7b7eaaa90b4a90a932a9ea6666c95a389e424eff347f0f793979289429feee"
"checksum proc-macro2 0.4.20 (registry+https://github.com/rust-lang/crates.io-index)" = "3d7b7eaaa90b4a90a932a9ea6666c95a389e424eff347f0f793979289429feee"
"checksum proc-macro2 0.4.24 (registry+https://github.com/rust-lang/crates.io-index)" = "77619697826f31a02ae974457af0b29b723e5619e113e9397b8b82c6bd253f09"
"checksum proc-macro2 0.4.24 (registry+https://github.com/rust-lang/crates.io-index)" = "77619697826f31a02ae974457af0b29b723e5619e113e9397b8b82c6bd253f09"
"checksum owning_ref 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)" = "cdf84f41639e037b484f93433aa3897863b561ed65c6e59c7073d7c561710f37"
"checksum owning_ref 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)" = "49a4b8ea2179e6a2e27411d3bca09ca6dd630821cf6894c6c7c8467a8ee7ef13"
"checksum owning_ref 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)" = "cdf84f41639e037b484f93433aa3897863b561ed65c6e59c7073d7c561710f37"
"checksum owning_ref 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)" = "cdf84f41639e037b484f93433aa3897863b561ed65c6e59c7073d7c561710f37"
"checksum owning_ref 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)" = "49a4b8ea2179e6a2e27411d3bca09ca6dd630821cf6894c6c7c8467a8ee7ef13"
"checksum owning_ref 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)" = "49a4b8ea2179e6a2e27411d3bca09ca6dd630821cf6894c6c7c8467a8ee7ef13"
"checksum num_cpus 1.8.0 (registry+https://github.com/rust-lang/crates.io-index)" = "c51a3322e4bca9d212ad9a158a02abc6934d005490c054a2778df73a70aa0a30"
"checksum num_cpus 1.8.0 (registry+https://github.com/rust-lang/crates.io-index)" = "c51a3322e4bca9d212ad9a158a02abc6934d005490c054a2778df73a70aa0a30"
"checksum num_cpus 1.9.0 (registry+https://github.com/rust-lang/crates.io-index)" = "5a69d464bdc213aaaff628444e99578ede64e9c854025aa43b9796530afa9238"
"checksum nodrop 0.1.12 (registry+https://github.com/rust-lang/crates.io-index)" = "9a2228dca57108069a5262f2ed8bd2e82496d2e074a06d1ccc7ce1687b6ae0a2"
"checksum nodrop 0.1.13 (registry+https://github.com/rust-lang/crates.io-index)" = "2f9667ddcc6cc8a43afc9b7917599d7216aa09c463919ea32c59ed6cac8bc945"
"checksum nodrop 0.1.12 (registry+https://github.com/rust-lang/crates.io-index)" = "9a2228dca57108069a5262f2ed8bd2e82496d2e074a06d1ccc7ce1687b6ae0a2"
"checksum nodrop 0.1.12 (registry+https://github.com/rust-lang/crates.io-index)" = "9a2228dca57108069a5262f2ed8bd2e82496d2e074a06d1ccc7ce1687b6ae0a2"
"checksum nodrop 0.1.13 (registry+https://github.com/rust-lang/crates.io-index)" = "2f9667ddcc6cc8a43afc9b7917599d7216aa09c463919ea32c59ed6cac8bc945"
"checksum nodrop 0.1.13 (registry+https://github.com/rust-lang/crates.io-index)" = "2f9667ddcc6cc8a43afc9b7917599d7216aa09c463919ea32c59ed6cac8bc945"
"checksum memchr 2.1.0 (registry+https://github.com/rust-lang/crates.io-index)" = "4b3629fe9fdbff6daa6c33b90f7c08355c1aca05a3d01fa8063b822fcf185f3b"
"checksum memchr 2.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "0a3eb002f0535929f1199681417029ebea04aadc0c7a4224b46be99c7f5d6a16"
"checksum memchr 2.1.0 (registry+https://github.com/rust-lang/crates.io-index)" = "4b3629fe9fdbff6daa6c33b90f7c08355c1aca05a3d01fa8063b822fcf185f3b"
"checksum memchr 2.1.0 (registry+https://github.com/rust-lang/crates.io-index)" = "4b3629fe9fdbff6daa6c33b90f7c08355c1aca05a3d01fa8063b822fcf185f3b"
"checksum memchr 2.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "0a3eb002f0535929f1199681417029ebea04aadc0c7a4224b46be99c7f5d6a16"
"checksum memchr 2.1.2 (registry+https://github.com/rust-lang/crates.io-index)" = "db4c41318937f6e76648f42826b1d9ade5c09cafb5aef7e351240a70f39206e9"
"checksum memchr 2.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "0a3eb002f0535929f1199681417029ebea04aadc0c7a4224b46be99c7f5d6a16"
"checksum markup5ever 0.7.3 (registry+https://github.com/rust-lang/crates.io-index)" = "a87c4100d614080c8ab43334fb028ebe387f273fb61ed4ff0eae9189b94b6be8"
"checksum markup5ever 0.7.3 (registry+https://github.com/rust-lang/crates.io-index)" = "a87c4100d614080c8ab43334fb028ebe387f273fb61ed4ff0eae9189b94b6be8"
"checksum markup5ever 0.7.5 (registry+https://github.com/rust-lang/crates.io-index)" = "897636f9850c3eef4905a5540683ed53dc9393860f0846cab2c2ddf9939862ff"
"checksum lock_api 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)" = "775751a3e69bde4df9b38dd00a1b5d6ac13791e4223d4a0506577f0dd27cfb7a"
"checksum log 0.3.9 (registry+https://github.com/rust-lang/crates.io-index)" = "e19e8d5c34a3e0e2223db8e060f9e8264aeeb5c5fc64a4ee9965c062211c024b"
"checksum log 0.4.5 (registry+https://github.com/rust-lang/crates.io-index)" = "d4fcce5fa49cc693c312001daf1d13411c4a5283796bac1084299ea3e567113f"
"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 lock_api 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)" = "775751a3e69bde4df9b38dd00a1b5d6ac13791e4223d4a0506577f0dd27cfb7a"
"checksum log 0.3.9 (registry+https://github.com/rust-lang/crates.io-index)" = "e19e8d5c34a3e0e2223db8e060f9e8264aeeb5c5fc64a4ee9965c062211c024b"
"checksum log 0.4.5 (registry+https://github.com/rust-lang/crates.io-index)" = "d4fcce5fa49cc693c312001daf1d13411c4a5283796bac1084299ea3e567113f"
"checksum lock_api 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)" = "775751a3e69bde4df9b38dd00a1b5d6ac13791e4223d4a0506577f0dd27cfb7a"
"checksum log 0.3.9 (registry+https://github.com/rust-lang/crates.io-index)" = "e19e8d5c34a3e0e2223db8e060f9e8264aeeb5c5fc64a4ee9965c062211c024b"
"checksum log 0.4.5 (registry+https://github.com/rust-lang/crates.io-index)" = "d4fcce5fa49cc693c312001daf1d13411c4a5283796bac1084299ea3e567113f"
"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 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 libc 0.2.43 (registry+https://github.com/rust-lang/crates.io-index)" = "76e3a3ef172f1a0b9a9ff0dd1491ae5e6c948b94479a3021819ba7d860c8645d"
"checksum lazycell 1.2.0 (registry+https://github.com/rust-lang/crates.io-index)" = "ddba4c30a78328befecec92fc94970e53b3ae385827d28620f0f5bb2493081e0"
"checksum libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)" = "10923947f84a519a45c8fefb7dd1b3e8c08747993381adee176d7a82b4195311"
"checksum lazycell 1.2.1 (registry+https://github.com/rust-lang/crates.io-index)" = "b294d6fa9ee409a054354afc4352b0b9ef7ca222c69b8812cbea9e7d2bf3783f"
"checksum libc 0.2.45 (registry+https://github.com/rust-lang/crates.io-index)" = "2d2857ec59fadc0773853c664d2d18e7198e83883e7060b63c924cb077bd5c74"
"checksum libc 0.2.43 (registry+https://github.com/rust-lang/crates.io-index)" = "76e3a3ef172f1a0b9a9ff0dd1491ae5e6c948b94479a3021819ba7d860c8645d"
"checksum libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)" = "10923947f84a519a45c8fefb7dd1b3e8c08747993381adee176d7a82b4195311"
"checksum libc 0.2.45 (registry+https://github.com/rust-lang/crates.io-index)" = "2d2857ec59fadc0773853c664d2d18e7198e83883e7060b63c924cb077bd5c74"
"checksum libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)" = "10923947f84a519a45c8fefb7dd1b3e8c08747993381adee176d7a82b4195311"
"checksum lazy_static 1.1.0 (registry+https://github.com/rust-lang/crates.io-index)" = "ca488b89a5657b0a2ecd45b95609b3e848cf1755da332a0da46e2b2b1cb371a7"
"checksum lazy_static 1.2.0 (registry+https://github.com/rust-lang/crates.io-index)" = "a374c89b9db55895453a74c1e38861d9deec0b01b405a82516e9d5de4820dea1"
"checksum lazy_static 1.1.0 (registry+https://github.com/rust-lang/crates.io-index)" = "ca488b89a5657b0a2ecd45b95609b3e848cf1755da332a0da46e2b2b1cb371a7"
"checksum lazycell 1.2.0 (registry+https://github.com/rust-lang/crates.io-index)" = "ddba4c30a78328befecec92fc94970e53b3ae385827d28620f0f5bb2493081e0"
"checksum libc 0.2.43 (registry+https://github.com/rust-lang/crates.io-index)" = "76e3a3ef172f1a0b9a9ff0dd1491ae5e6c948b94479a3021819ba7d860c8645d"
"checksum lazy_static 1.1.0 (registry+https://github.com/rust-lang/crates.io-index)" = "ca488b89a5657b0a2ecd45b95609b3e848cf1755da332a0da46e2b2b1cb371a7"
"checksum lazy_static 1.2.0 (registry+https://github.com/rust-lang/crates.io-index)" = "a374c89b9db55895453a74c1e38861d9deec0b01b405a82516e9d5de4820dea1"
"checksum lazycell 1.2.1 (registry+https://github.com/rust-lang/crates.io-index)" = "b294d6fa9ee409a054354afc4352b0b9ef7ca222c69b8812cbea9e7d2bf3783f"
"checksum lazy_static 1.2.0 (registry+https://github.com/rust-lang/crates.io-index)" = "a374c89b9db55895453a74c1e38861d9deec0b01b405a82516e9d5de4820dea1"
"checksum ipconfig 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)" = "fccb81dd962b29a25de46c4f46e497b75117aa816468b6fff7a63a598a192394"
"checksum ipconfig 0.1.9 (registry+https://github.com/rust-lang/crates.io-index)" = "08f7eadeaf4b52700de180d147c4805f199854600b36faa963d91114827b2ffc"
"checksum ipconfig 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)" = "fccb81dd962b29a25de46c4f46e497b75117aa816468b6fff7a63a598a192394"
"checksum ipconfig 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)" = "fccb81dd962b29a25de46c4f46e497b75117aa816468b6fff7a63a598a192394"
"checksum ipconfig 0.1.9 (registry+https://github.com/rust-lang/crates.io-index)" = "08f7eadeaf4b52700de180d147c4805f199854600b36faa963d91114827b2ffc"
"checksum ipconfig 0.1.9 (registry+https://github.com/rust-lang/crates.io-index)" = "08f7eadeaf4b52700de180d147c4805f199854600b36faa963d91114827b2ffc"
"checksum hyper 0.12.17 (registry+https://github.com/rust-lang/crates.io-index)" = "c49a75385d35ff5e9202755f09beb0b878a05c4c363fcc52b23eeb5dcb6782cc"
"checksum hyper 0.12.17 (registry+https://github.com/rust-lang/crates.io-index)" = "c49a75385d35ff5e9202755f09beb0b878a05c4c363fcc52b23eeb5dcb6782cc"
"checksum hyper 0.12.18 (registry+https://github.com/rust-lang/crates.io-index)" = "8dd7729fc83d88353415f6816fd4bb00897aa47c7f1506b69060e74e6e3d8e8b"
"checksum hyper 0.12.16 (registry+https://github.com/rust-lang/crates.io-index)" = "0aeedb8ca5f0f96be00f84073c6d0d5f962ecad020ef543dff99a7c12717a60e"
"checksum humantime 1.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "0484fda3e7007f2a4a0d9c3a703ca38c71c54c55602ce4660c419fd32e188c9e"
"checksum hyper 0.12.13 (registry+https://github.com/rust-lang/crates.io-index)" = "95ffee0d1d30de4313fdaaa485891ce924991d45bbc18adfc8ac5b1639e62fbb"
"checksum humantime 1.2.0 (registry+https://github.com/rust-lang/crates.io-index)" = "3ca7e5f2e110db35f93b837c81797f3714500b81d517bf20c431b16d3ca4f114"
"checksum hyper 0.12.16 (registry+https://github.com/rust-lang/crates.io-index)" = "0aeedb8ca5f0f96be00f84073c6d0d5f962ecad020ef543dff99a7c12717a60e"
"checksum humantime 1.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "0484fda3e7007f2a4a0d9c3a703ca38c71c54c55602ce4660c419fd32e188c9e"
"checksum hyper 0.12.13 (registry+https://github.com/rust-lang/crates.io-index)" = "95ffee0d1d30de4313fdaaa485891ce924991d45bbc18adfc8ac5b1639e62fbb"
"checksum humantime 1.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "0484fda3e7007f2a4a0d9c3a703ca38c71c54c55602ce4660c419fd32e188c9e"
"checksum hyper 0.12.13 (registry+https://github.com/rust-lang/crates.io-index)" = "95ffee0d1d30de4313fdaaa485891ce924991d45bbc18adfc8ac5b1639e62fbb"
"checksum humantime 1.2.0 (registry+https://github.com/rust-lang/crates.io-index)" = "3ca7e5f2e110db35f93b837c81797f3714500b81d517bf20c431b16d3ca4f114"
"checksum humantime 1.2.0 (registry+https://github.com/rust-lang/crates.io-index)" = "3ca7e5f2e110db35f93b837c81797f3714500b81d517bf20c431b16d3ca4f114"
"checksum http 0.1.13 (registry+https://github.com/rust-lang/crates.io-index)" = "24f58e8c2d8e886055c3ead7b28793e1455270b5fb39650984c224bc538ba581"
"checksum http 0.1.14 (registry+https://github.com/rust-lang/crates.io-index)" = "02096a6d2c55e63f7fcb800690e4f889a25f6ec342e3adb4594e293b625215ab"
"checksum http 0.1.13 (registry+https://github.com/rust-lang/crates.io-index)" = "24f58e8c2d8e886055c3ead7b28793e1455270b5fb39650984c224bc538ba581"
"checksum http 0.1.13 (registry+https://github.com/rust-lang/crates.io-index)" = "24f58e8c2d8e886055c3ead7b28793e1455270b5fb39650984c224bc538ba581"
"checksum http 0.1.14 (registry+https://github.com/rust-lang/crates.io-index)" = "02096a6d2c55e63f7fcb800690e4f889a25f6ec342e3adb4594e293b625215ab"
"checksum http 0.1.14 (registry+https://github.com/rust-lang/crates.io-index)" = "02096a6d2c55e63f7fcb800690e4f889a25f6ec342e3adb4594e293b625215ab"
"checksum h2 0.1.13 (registry+https://github.com/rust-lang/crates.io-index)" = "7dd33bafe2e6370e6c8eb0cf1b8c5f93390b90acde7e9b03723f166b28b648ed"
"checksum h2 0.1.13 (registry+https://github.com/rust-lang/crates.io-index)" = "7dd33bafe2e6370e6c8eb0cf1b8c5f93390b90acde7e9b03723f166b28b648ed"
"checksum h2 0.1.14 (registry+https://github.com/rust-lang/crates.io-index)" = "1ac030ae20dee464c5d0f36544d8b914a6bc606da44a57e052d2b0f5dae129e0"
"checksum h2 0.1.14 (registry+https://github.com/rust-lang/crates.io-index)" = "1ac030ae20dee464c5d0f36544d8b914a6bc606da44a57e052d2b0f5dae129e0"
"checksum env_logger 0.6.0 (registry+https://github.com/rust-lang/crates.io-index)" = "afb070faf94c85d17d50ca44f6ad076bce18ae92f0037d350947240a36e9d42e"
"checksum env_logger 0.6.0 (registry+https://github.com/rust-lang/crates.io-index)" = "afb070faf94c85d17d50ca44f6ad076bce18ae92f0037d350947240a36e9d42e"
"checksum encoding_rs 0.8.10 (registry+https://github.com/rust-lang/crates.io-index)" = "065f4d0c826fdaef059ac45487169d918558e3cf86c9d89f6e81cf52369126e5"
"checksum env_logger 0.5.13 (registry+https://github.com/rust-lang/crates.io-index)" = "15b0a4d2e39f8420210be8b27eeda28029729e2fd4291019455016c348240c38"
"checksum encoding_rs 0.8.13 (registry+https://github.com/rust-lang/crates.io-index)" = "1a8fa54e6689eb2549c4efed8d00d7f3b2b994a064555b0e8df4ae3764bcc4be"
"checksum encoding_rs 0.8.12 (registry+https://github.com/rust-lang/crates.io-index)" = "ca20350a7cb5aab5b9034731123d6d412caf3e92d4985e739e411ba0955fd0eb"
"checksum encoding_rs 0.8.10 (registry+https://github.com/rust-lang/crates.io-index)" = "065f4d0c826fdaef059ac45487169d918558e3cf86c9d89f6e81cf52369126e5"
"checksum env_logger 0.5.13 (registry+https://github.com/rust-lang/crates.io-index)" = "15b0a4d2e39f8420210be8b27eeda28029729e2fd4291019455016c348240c38"
"checksum encoding_rs 0.8.10 (registry+https://github.com/rust-lang/crates.io-index)" = "065f4d0c826fdaef059ac45487169d918558e3cf86c9d89f6e81cf52369126e5"
"checksum env_logger 0.5.13 (registry+https://github.com/rust-lang/crates.io-index)" = "15b0a4d2e39f8420210be8b27eeda28029729e2fd4291019455016c348240c38"
"checksum encoding_rs 0.8.12 (registry+https://github.com/rust-lang/crates.io-index)" = "ca20350a7cb5aab5b9034731123d6d412caf3e92d4985e739e411ba0955fd0eb"
"checksum encoding_rs 0.8.13 (registry+https://github.com/rust-lang/crates.io-index)" = "1a8fa54e6689eb2549c4efed8d00d7f3b2b994a064555b0e8df4ae3764bcc4be"
"checksum encoding_rs 0.8.12 (registry+https://github.com/rust-lang/crates.io-index)" = "ca20350a7cb5aab5b9034731123d6d412caf3e92d4985e739e411ba0955fd0eb"
"checksum env_logger 0.6.0 (registry+https://github.com/rust-lang/crates.io-index)" = "afb070faf94c85d17d50ca44f6ad076bce18ae92f0037d350947240a36e9d42e"
"checksum crossbeam-utils 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)" = "c55913cc2799171a550e307918c0a360e8c16004820291bf3b638969b4a01816"
"checksum crossbeam-utils 0.6.3 (registry+https://github.com/rust-lang/crates.io-index)" = "41ee4864f4797060e52044376f7d107429ce1fb43460021b126424b7180ee21a"
"checksum crossbeam-utils 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)" = "c55913cc2799171a550e307918c0a360e8c16004820291bf3b638969b4a01816"
"checksum crossbeam-utils 0.6.2 (registry+https://github.com/rust-lang/crates.io-index)" = "e07fc155212827475223f0bcfae57e945e694fc90950ddf3f6695bbfd5555c72"
"checksum crossbeam-deque 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)" = "3486aefc4c0487b9cb52372c97df0a48b8c249514af1ee99703bf70d2f2ceda1"
"checksum crossbeam-epoch 0.5.2 (registry+https://github.com/rust-lang/crates.io-index)" = "30fecfcac6abfef8771151f8be4abc9e4edc112c2bcb233314cafde2680536e9"
"checksum crossbeam-utils 0.5.0 (registry+https://github.com/rust-lang/crates.io-index)" = "677d453a17e8bd2b913fa38e8b9cf04bcdbb5be790aa294f2389661d72036015"
"checksum crossbeam-deque 0.6.2 (registry+https://github.com/rust-lang/crates.io-index)" = "4fe1b6f945f824c7a25afe44f62e25d714c0cc523f8e99d8db5cd1026e1269d3"
"checksum crossbeam-epoch 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)" = "2449aaa4ec7ef96e5fb24db16024b935df718e9ae1cec0a1e68feeca2efca7b8"
"checksum crossbeam-utils 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)" = "c55913cc2799171a550e307918c0a360e8c16004820291bf3b638969b4a01816"
"checksum crossbeam-deque 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)" = "3486aefc4c0487b9cb52372c97df0a48b8c249514af1ee99703bf70d2f2ceda1"
"checksum crossbeam-epoch 0.5.2 (registry+https://github.com/rust-lang/crates.io-index)" = "30fecfcac6abfef8771151f8be4abc9e4edc112c2bcb233314cafde2680536e9"
"checksum crossbeam-utils 0.5.0 (registry+https://github.com/rust-lang/crates.io-index)" = "677d453a17e8bd2b913fa38e8b9cf04bcdbb5be790aa294f2389661d72036015"
"checksum crossbeam-deque 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)" = "3486aefc4c0487b9cb52372c97df0a48b8c249514af1ee99703bf70d2f2ceda1"
"checksum crossbeam-epoch 0.5.2 (registry+https://github.com/rust-lang/crates.io-index)" = "30fecfcac6abfef8771151f8be4abc9e4edc112c2bcb233314cafde2680536e9"
"checksum crossbeam-utils 0.5.0 (registry+https://github.com/rust-lang/crates.io-index)" = "677d453a17e8bd2b913fa38e8b9cf04bcdbb5be790aa294f2389661d72036015"
"checksum crossbeam-deque 0.6.2 (registry+https://github.com/rust-lang/crates.io-index)" = "4fe1b6f945f824c7a25afe44f62e25d714c0cc523f8e99d8db5cd1026e1269d3"
"checksum crossbeam-epoch 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)" = "2449aaa4ec7ef96e5fb24db16024b935df718e9ae1cec0a1e68feeca2efca7b8"
"checksum crossbeam-deque 0.6.2 (registry+https://github.com/rust-lang/crates.io-index)" = "4fe1b6f945f824c7a25afe44f62e25d714c0cc523f8e99d8db5cd1026e1269d3"
"checksum crossbeam-epoch 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)" = "2449aaa4ec7ef96e5fb24db16024b935df718e9ae1cec0a1e68feeca2efca7b8"
"checksum cc 1.0.25 (registry+https://github.com/rust-lang/crates.io-index)" = "f159dfd43363c4d08055a07703eb7a3406b0dac4d0584d96965a3262db3c9d16"
"checksum cc 1.0.25 (registry+https://github.com/rust-lang/crates.io-index)" = "f159dfd43363c4d08055a07703eb7a3406b0dac4d0584d96965a3262db3c9d16"
"checksum cc 1.0.26 (registry+https://github.com/rust-lang/crates.io-index)" = "389803e36973d242e7fecb092b2de44a3d35ac62524b3b9339e51d577d668e02"
"checksum bytes 0.4.10 (registry+https://github.com/rust-lang/crates.io-index)" = "0ce55bd354b095246fc34caf4e9e242f5297a7fd938b090cadfea6eee614aa62"
"checksum bytes 0.4.11 (registry+https://github.com/rust-lang/crates.io-index)" = "40ade3d27603c2cb345eb0912aec461a6dec7e06a4ae48589904e808335c7afa"
"checksum bytes 0.4.10 (registry+https://github.com/rust-lang/crates.io-index)" = "0ce55bd354b095246fc34caf4e9e242f5297a7fd938b090cadfea6eee614aa62"
"checksum bytes 0.4.10 (registry+https://github.com/rust-lang/crates.io-index)" = "0ce55bd354b095246fc34caf4e9e242f5297a7fd938b090cadfea6eee614aa62"
"checksum bytes 0.4.11 (registry+https://github.com/rust-lang/crates.io-index)" = "40ade3d27603c2cb345eb0912aec461a6dec7e06a4ae48589904e808335c7afa"
"checksum bytes 0.4.11 (registry+https://github.com/rust-lang/crates.io-index)" = "40ade3d27603c2cb345eb0912aec461a6dec7e06a4ae48589904e808335c7afa"
"checksum backtrace 0.3.9 (registry+https://github.com/rust-lang/crates.io-index)" = "89a47830402e9981c5c41223151efcced65a0510c13097c769cede7efb34782a"
"checksum backtrace-sys 0.1.24 (registry+https://github.com/rust-lang/crates.io-index)" = "c66d56ac8dabd07f6aacdaf633f4b8262f5b3601a810a0dcddffd5c22c69daa0"
"checksum backtrace 0.3.9 (registry+https://github.com/rust-lang/crates.io-index)" = "89a47830402e9981c5c41223151efcced65a0510c13097c769cede7efb34782a"
"checksum backtrace-sys 0.1.24 (registry+https://github.com/rust-lang/crates.io-index)" = "c66d56ac8dabd07f6aacdaf633f4b8262f5b3601a810a0dcddffd5c22c69daa0"
"checksum backtrace 0.3.13 (registry+https://github.com/rust-lang/crates.io-index)" = "b5b493b66e03090ebc4343eb02f94ff944e0cbc9ac6571491d170ba026741eb5"
"checksum backtrace-sys 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)" = "3fcce89e5ad5c8949caa9434501f7b55415b3e7ad5270cb88c75a8d35e8f1279"
"checksum arrayvec 0.4.7 (registry+https://github.com/rust-lang/crates.io-index)" = "a1e964f9e24d588183fcb43503abda40d288c8657dfc27311516ce2f05675aef"
"checksum arrayref 0.3.5 (registry+https://github.com/rust-lang/crates.io-index)" = "0d382e583f07208808f6b1249e60848879ba3543f57c32277bf52d69c2f0f0ee"
"checksum arc-swap 0.3.4 (registry+https://github.com/rust-lang/crates.io-index)" = "af192669a9f44d2fb63c691a04183c8e12428f34041449270b08c0456587f5a5"
"checksum ansi_term 0.11.0 (registry+https://github.com/rust-lang/crates.io-index)" = "ee49baf6cb617b853aa8d93bf420db2383fab46d314482ca2803b40d5fde979b"
"checksum aho-corasick 0.6.8 (registry+https://github.com/rust-lang/crates.io-index)" = "68f56c7353e5a9547cbd76ed90f7bb5ffc3ba09d4ea9bd1d8c06c8b1142eeb5a"
]
[[package]]
name = "xmpp-parsers"
version = "0.11.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "base64 0.9.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "blake2 0.7.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "chrono 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "digest 0.7.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "jid 0.5.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "minidom 0.9.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "sha-1 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "sha2 0.7.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "sha3 0.7.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "try_from 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)",
]
[metadata]
 "markup5ever 0.7.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "time 0.1.40 (registry+https://github.com/rust-lang/crates.io-index)",
 "mac 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "log 0.3.9 (registry+https://github.com/rust-lang/crates.io-index)",
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
version = "0.12.0"
 "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.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 = "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.1 (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"
 "log 0.4.5 (registry+https://github.com/rust-lang/crates.io-index)",
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 = "version_check"
version = "0.1.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
name = "void"
version = "1.0.2"
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)",
version = "1.0.1"
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.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
name = "utf8-ranges"
version = "1.7.1"
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.7"
source = "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 = "unreachable"
version = "1.0.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "void 1.0.2 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "url"
version = "0.1.1"
 "trust-dns-proto 0.4.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.2.2"
source = "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"
 "smallvec 0.6.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio 0.1.11 (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.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio 0.1.13 (registry+https://github.com/rust-lang/crates.io-index)",
 "ipconfig 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "lazy_static 1.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "log 0.4.5 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "trust-dns-resolver"
version = "0.9.1"
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)",
 "error-chain 0.1.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.25 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-timer 0.2.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-udp 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "url 1.7.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-tcp 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-reactor 0.1.6 (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.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "smallvec 0.6.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand 0.4.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "lazy_static 1.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "log 0.4.5 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "trust-dns-proto"
version = "0.4.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "byteorder 1.2.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "error-chain 0.1.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.25 (registry+https://github.com/rust-lang/crates.io-index)",
 "idna 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde 1.0.80 (registry+https://github.com/rust-lang/crates.io-index)",
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
version = "0.4.8"
 "xmpp-parsers 0.11.1 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "toml"
 "xml5ever 0.12.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-io 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-tls 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "trust-dns-proto 0.4.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "trust-dns-resolver 0.9.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "try_from 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio 0.1.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)",
 "jid 0.5.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "minidom 0.9.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "native-tls 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "quick-xml 0.12.4 (registry+https://github.com/rust-lang/crates.io-index)",
 "sasl 0.4.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "bytes 0.4.10 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "tokio-xmpp"
version = "0.2.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "tokio-reactor 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.10 (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)",
 "libc 0.2.43 (registry+https://github.com/rust-lang/crates.io-index)",
 "log 0.4.5 (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)",
 "log 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "bytes 0.4.10 (registry+https://github.com/rust-lang/crates.io-index)",
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
version = "0.2.3"
]
[[package]]
name = "tokio-uds"
 "tokio-reactor 0.1.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.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "log 0.4.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.25 (registry+https://github.com/rust-lang/crates.io-index)",
 "bytes 0.4.10 (registry+https://github.com/rust-lang/crates.io-index)",
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
version = "0.1.2"
 "futures 0.1.25 (registry+https://github.com/rust-lang/crates.io-index)",
 "slab 0.4.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-executor 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "tokio-tls"
version = "0.2.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)",
 "native-tls 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "tokio-udp"
 "crossbeam-utils 0.5.0 (registry+https://github.com/rust-lang/crates.io-index)",
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
version = "0.2.7"
 "tokio-executor 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "tokio-timer"
 "log 0.4.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand 0.5.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand 0.5.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand 0.5.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "num_cpus 1.8.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.25 (registry+https://github.com/rust-lang/crates.io-index)",
 "crossbeam-deque 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "crossbeam-utils 0.5.0 (registry+https://github.com/rust-lang/crates.io-index)",
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "crossbeam-utils 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "crossbeam-utils 0.6.2 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.1.8"
]
[[package]]
name = "tokio-threadpool"
 "tokio-reactor 0.1.6 (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.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "bytes 0.4.10 (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-tcp"
version = "0.1.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "tokio-reactor 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-executor 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "signal-hook 0.1.5 (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)",
 "libc 0.2.43 (registry+https://github.com/rust-lang/crates.io-index)",
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "futures 0.1.25 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.2.6"
 "parking_lot 0.6.4 (registry+https://github.com/rust-lang/crates.io-index)",
 "slab 0.4.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-executor 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "tokio-signal"
 "num_cpus 1.8.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "mio 0.6.16 (registry+https://github.com/rust-lang/crates.io-index)",
 "lazy_static 1.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "log 0.4.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.25 (registry+https://github.com/rust-lang/crates.io-index)",
 "crossbeam-utils 0.5.0 (registry+https://github.com/rust-lang/crates.io-index)",
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
version = "0.1.6"
]
[[package]]
name = "tokio-reactor"
 "log 0.4.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.25 (registry+https://github.com/rust-lang/crates.io-index)",
 "bytes 0.4.10 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "tokio-io"
version = "0.1.10"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "tokio-threadpool 0.1.8 (registry+https://github.com/rust-lang/crates.io-index)",
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.5 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "tokio-executor"
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)",
]
[[package]]
name = "tokio-fs"
version = "0.1.4"
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.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "smallvec 0.6.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "smallvec 0.6.7 (registry+https://github.com/rust-lang/crates.io-index)",
"checksum arrayvec 0.4.8 (registry+https://github.com/rust-lang/crates.io-index)" = "f405cc4c21cd8b784f6c8fc2adf9bc00f59558f0049b5ec21517f875963040cc"
"checksum arc-swap 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)" = "5c5ed110e2537bdd3f5b9091707a8a5556a72ac49bbd7302ae0b28fdccb3246c"
"checksum aho-corasick 0.6.9 (registry+https://github.com/rust-lang/crates.io-index)" = "1e9a933f4e58658d7b12defcf96dc5c720f20832deebe3e0a19efd3b6aaeeb9e"
 "log 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.12.1"
 "log 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)",
version = "1.0.2"
version = "1.7.2"
version = "0.1.3"
 "smallvec 0.6.6 (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.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "log 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-timer 0.2.8 (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)",
 "tokio-reactor 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "smallvec 0.6.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "lazy_static 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)",
version = "0.4.9"
 "xml5ever 0.12.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio 0.1.13 (registry+https://github.com/rust-lang/crates.io-index)",
 "bytes 0.4.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-reactor 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-codec 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "log 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "bytes 0.4.11 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.2.4"
 "tokio-reactor 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "log 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "bytes 0.4.11 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.1.3"
 "crossbeam-utils 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.2.8"
 "log 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "crossbeam-deque 0.6.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "crossbeam-utils 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.1.9"
 "tokio-reactor 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "bytes 0.4.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-reactor 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "signal-hook 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.2.7"
 "lazy_static 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)",
 "crossbeam-utils 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.1.7"
 "log 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "bytes 0.4.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-threadpool 0.1.9 (registry+https://github.com/rust-lang/crates.io-index)",
"checksum arrayvec 0.4.7 (registry+https://github.com/rust-lang/crates.io-index)" = "a1e964f9e24d588183fcb43503abda40d288c8657dfc27311516ce2f05675aef"
"checksum arc-swap 0.3.4 (registry+https://github.com/rust-lang/crates.io-index)" = "af192669a9f44d2fb63c691a04183c8e12428f34041449270b08c0456587f5a5"
"checksum aho-corasick 0.6.8 (registry+https://github.com/rust-lang/crates.io-index)" = "68f56c7353e5a9547cbd76ed90f7bb5ffc3ba09d4ea9bd1d8c06c8b1142eeb5a"
 "log 0.3.9 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.12.0"
 "log 0.4.5 (registry+https://github.com/rust-lang/crates.io-index)",
version = "1.0.1"
version = "1.7.1"
version = "0.1.1"
 "smallvec 0.6.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio 0.1.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "ipconfig 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "lazy_static 1.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "log 0.4.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-timer 0.2.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-udp 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "url 1.7.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-reactor 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "smallvec 0.6.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "lazy_static 1.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "log 0.4.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde 1.0.80 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.4.8"
 "xml5ever 0.12.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio 0.1.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "bytes 0.4.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-reactor 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.43 (registry+https://github.com/rust-lang/crates.io-index)",
 "log 0.4.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "bytes 0.4.10 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.2.3"
 "tokio-reactor 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "log 0.4.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "bytes 0.4.10 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.1.2"
 "crossbeam-utils 0.5.0 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.2.7"
 "log 0.4.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "crossbeam-deque 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "crossbeam-utils 0.5.0 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.1.8"
 "tokio-reactor 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "bytes 0.4.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-reactor 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "signal-hook 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.43 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.2.6"
 "lazy_static 1.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "log 0.4.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "crossbeam-utils 0.5.0 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.1.6"
 "log 0.4.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "bytes 0.4.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-threadpool 0.1.8 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.4.10"
"checksum arrayvec 0.4.7 (registry+https://github.com/rust-lang/crates.io-index)" = "a1e964f9e24d588183fcb43503abda40d288c8657dfc27311516ce2f05675aef"
"checksum arc-swap 0.3.4 (registry+https://github.com/rust-lang/crates.io-index)" = "af192669a9f44d2fb63c691a04183c8e12428f34041449270b08c0456587f5a5"
"checksum aho-corasick 0.6.8 (registry+https://github.com/rust-lang/crates.io-index)" = "68f56c7353e5a9547cbd76ed90f7bb5ffc3ba09d4ea9bd1d8c06c8b1142eeb5a"
 "log 0.3.9 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.12.0"
 "log 0.4.5 (registry+https://github.com/rust-lang/crates.io-index)",
version = "1.0.1"
version = "1.7.1"
version = "0.1.1"
 "smallvec 0.6.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio 0.1.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "ipconfig 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "lazy_static 1.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "log 0.4.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-timer 0.2.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-udp 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "url 1.7.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-reactor 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "smallvec 0.6.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "lazy_static 1.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "log 0.4.5 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.4.8"
 "xml5ever 0.12.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio 0.1.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "bytes 0.4.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-reactor 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.43 (registry+https://github.com/rust-lang/crates.io-index)",
 "log 0.4.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "bytes 0.4.10 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.2.3"
 "tokio-reactor 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "log 0.4.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "bytes 0.4.10 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.1.2"
 "crossbeam-utils 0.5.0 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.2.7"
 "log 0.4.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "crossbeam-deque 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "crossbeam-utils 0.5.0 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.1.8"
 "tokio-reactor 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "bytes 0.4.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-reactor 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "signal-hook 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.43 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.2.6"
 "lazy_static 1.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "log 0.4.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "crossbeam-utils 0.5.0 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.1.6"
 "log 0.4.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "bytes 0.4.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-threadpool 0.1.8 (registry+https://github.com/rust-lang/crates.io-index)",
 "markup5ever 0.7.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "time 0.1.40 (registry+https://github.com/rust-lang/crates.io-index)",
 "smallvec 0.6.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "smallvec 0.6.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde 1.0.80 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "crossbeam-utils 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "num_cpus 1.8.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "crossbeam-utils 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "num_cpus 1.8.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "crossbeam-utils 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)",
"checksum autocfg 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "4e5f34df7a019573fb8bdc7e24a2bfebe51a2a1d6bfdbaeccedb3c41fc574727"
"checksum arrayvec 0.4.8 (registry+https://github.com/rust-lang/crates.io-index)" = "f405cc4c21cd8b784f6c8fc2adf9bc00f59558f0049b5ec21517f875963040cc"
"checksum arc-swap 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)" = "5c5ed110e2537bdd3f5b9091707a8a5556a72ac49bbd7302ae0b28fdccb3246c"
"checksum aho-corasick 0.6.9 (registry+https://github.com/rust-lang/crates.io-index)" = "1e9a933f4e58658d7b12defcf96dc5c720f20832deebe3e0a19efd3b6aaeeb9e"
 "markup5ever 0.7.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "time 0.1.41 (registry+https://github.com/rust-lang/crates.io-index)",
 "log 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.12.1"
 "log 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)",
version = "1.0.2"
version = "1.7.2"
version = "0.1.3"
 "tokio 0.1.13 (registry+https://github.com/rust-lang/crates.io-index)",
 "smallvec 0.6.7 (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.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "log 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-timer 0.2.8 (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)",
 "tokio-reactor 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "smallvec 0.6.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "lazy_static 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)",
 "serde 1.0.82 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.4.10"
 "xml5ever 0.12.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio 0.1.13 (registry+https://github.com/rust-lang/crates.io-index)",
 "bytes 0.4.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-reactor 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-codec 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "log 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.45 (registry+https://github.com/rust-lang/crates.io-index)",
 "bytes 0.4.11 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.2.4"
 "tokio-reactor 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "log 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "bytes 0.4.11 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.1.3"
 "crossbeam-utils 0.6.3 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.2.8"
 "rand 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "num_cpus 1.9.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "log 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "crossbeam-utils 0.6.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "crossbeam-deque 0.6.2 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.1.9"
 "tokio-reactor 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "bytes 0.4.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-reactor 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "signal-hook 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.45 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.2.7"
 "num_cpus 1.9.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "lazy_static 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)",
 "crossbeam-utils 0.6.3 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.1.7"
 "log 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "bytes 0.4.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-threadpool 0.1.9 (registry+https://github.com/rust-lang/crates.io-index)",
"checksum arrayvec 0.4.8 (registry+https://github.com/rust-lang/crates.io-index)" = "f405cc4c21cd8b784f6c8fc2adf9bc00f59558f0049b5ec21517f875963040cc"
"checksum arc-swap 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)" = "5c5ed110e2537bdd3f5b9091707a8a5556a72ac49bbd7302ae0b28fdccb3246c"
"checksum aho-corasick 0.6.9 (registry+https://github.com/rust-lang/crates.io-index)" = "1e9a933f4e58658d7b12defcf96dc5c720f20832deebe3e0a19efd3b6aaeeb9e"
 "log 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.12.1"
 "log 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)",
version = "1.0.2"
version = "1.7.2"
version = "0.1.3"
 "smallvec 0.6.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio 0.1.13 (registry+https://github.com/rust-lang/crates.io-index)",
 "ipconfig 0.1.9 (registry+https://github.com/rust-lang/crates.io-index)",
 "lazy_static 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)",
 "tokio-timer 0.2.8 (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)",
 "tokio-reactor 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "smallvec 0.6.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "lazy_static 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)",
version = "0.4.9"
 "xml5ever 0.12.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio 0.1.13 (registry+https://github.com/rust-lang/crates.io-index)",
 "bytes 0.4.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-reactor 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-codec 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "bytes 0.4.11 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.2.4"
 "tokio-reactor 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "log 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "bytes 0.4.11 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.1.3"
 "crossbeam-utils 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.2.8"
 "log 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "crossbeam-deque 0.6.2 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.1.9"
 "tokio-reactor 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "bytes 0.4.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-reactor 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "signal-hook 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.2.7"
 "lazy_static 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)",
 "crossbeam-utils 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.1.7"
 "log 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "bytes 0.4.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-threadpool 0.1.9 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde 1.0.82 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.45 (registry+https://github.com/rust-lang/crates.io-index)",
 "crossbeam-utils 0.6.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.45 (registry+https://github.com/rust-lang/crates.io-index)",
 "crossbeam-utils 0.6.2 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.1.3"
version = "0.1.4"
version = "0.1.3"
version = "0.1.3"
version = "0.1.4"
version = "0.1.4"
version = "0.1.3"
 "futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-executor 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.1.5"
 "crossbeam-utils 0.6.3 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.1.4"
 "futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-threadpool 0.1.13 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.1.10"
 "bytes 0.4.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "log 0.4.5 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.1.6"
 "crossbeam-utils 0.5.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "lazy_static 1.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "log 0.4.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "num_cpus 1.8.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "parking_lot 0.6.4 (registry+https://github.com/rust-lang/crates.io-index)",
 "slab 0.4.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-executor 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.2.6"
 "futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
 "signal-hook 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-reactor 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
name = "tokio-sync"
 "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)",
version = "0.1.2"
 "bytes 0.4.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.1.8"
 "crossbeam-deque 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "crossbeam-utils 0.5.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand 0.5.5 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.2.7"
 "crossbeam-utils 0.5.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "slab 0.4.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-executor 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.2.0"
 "futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)",
name = "tokio-trace-core"
version = "0.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "lazy_static 1.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
version = "0.1.2"
 "bytes 0.4.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "log 0.4.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.2.3"
 "bytes 0.4.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.43 (registry+https://github.com/rust-lang/crates.io-index)",
 "log 0.4.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "tokio-xmpp"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "derive-error 0.0.4 (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)",
 "tokio 0.1.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-tls 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "trust-dns-proto 0.4.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "trust-dns-resolver 0.9.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "try_from 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "xmpp-parsers 0.11.1 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.4.8"
 "serde 1.0.80 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.4.3"
 "byteorder 1.2.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "error-chain 0.1.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "lazy_static 1.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "log 0.4.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "smallvec 0.6.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-executor 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-tcp 0.1.2 (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)",
version = "0.9.1"
 "cfg-if 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "ipconfig 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "lazy_static 1.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "log 0.4.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "resolv-conf 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "trust-dns-proto 0.4.3 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.2.2"
dependencies = [
 "cfg-if 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
]
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
name = "ucd-util"
version = "0.1.3"
version = "0.1.8"
dependencies = [
]
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
name = "url"
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"
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
name = "utf8-ranges"
version = "1.0.2"
name = "utf8-ranges"
version = "1.0.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
name = "version_check"
version = "0.1.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
name = "void"
version = "1.0.2"
name = "void"
version = "1.0.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
 "futures 0.1.26 (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"
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]]
version = "0.1.2"
 "winapi 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)",
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
name = "wincolor"
version = "1.0.1"
dependencies = [
 "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 = [
]
[[package]]
name = "winutil"
version = "0.1.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
]
[[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"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "mac 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "xmpp-parsers"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "chrono 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "xmpp-parsers"
version = "0.13.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "base64 0.10.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "blake2 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "chrono 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "digest 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "jid 0.5.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "minidom 0.10.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "sha-1 0.8.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "sha2 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "sha3 0.8.1 (registry+https://github.com/rust-lang/crates.io-index)",
[[package]]
name = "xmpp-parsers"
version = "0.13.0"
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)",
]
"checksum MacTypes-sys 1.3.0 (registry+https://github.com/rust-lang/crates.io-index)" = "7dbbe033994ae2198a18517c7132d952a29fb1db44249a1234779da7c50f4698"
"checksum arc-swap 0.3.4 (registry+https://github.com/rust-lang/crates.io-index)" = "af192669a9f44d2fb63c691a04183c8e12428f34041449270b08c0456587f5a5"
"checksum arrayvec 0.4.7 (registry+https://github.com/rust-lang/crates.io-index)" = "a1e964f9e24d588183fcb43503abda40d288c8657dfc27311516ce2f05675aef"
"checksum backtrace 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)" = "346d7644f0b5f9bc73082d3b2236b69a05fd35cce0cfa3724e184e6a5c9e2a2f"
"checksum backtrace 0.3.9 (registry+https://github.com/rust-lang/crates.io-index)" = "89a47830402e9981c5c41223151efcced65a0510c13097c769cede7efb34782a"
"checksum backtrace-sys 0.1.24 (registry+https://github.com/rust-lang/crates.io-index)" = "c66d56ac8dabd07f6aacdaf633f4b8262f5b3601a810a0dcddffd5c22c69daa0"
"checksum base64 0.9.3 (registry+https://github.com/rust-lang/crates.io-index)" = "489d6c0ed21b11d038c31b6ceccca973e65d73ba3bd8ecb9a2babf5546164643"
"checksum blake2 0.7.1 (registry+https://github.com/rust-lang/crates.io-index)" = "73b77e29dbd0115e43938be2d5128ecf81c0353e00acaa65339a1242586951d9"
"checksum block-buffer 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)" = "a076c298b9ecdb530ed9d967e74a6027d6a7478924520acddcddc24c1c8ab3ab"
"checksum byte-tools 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)" = "560c32574a12a89ecd91f5e742165893f86e3ab98d21f8ea548658eb9eef5f40"
"checksum byteorder 1.2.7 (registry+https://github.com/rust-lang/crates.io-index)" = "94f88df23a25417badc922ab0f5716cc1330e87f71ddd9203b3a3ccd9cedf75d"
"checksum cc 1.0.25 (registry+https://github.com/rust-lang/crates.io-index)" = "f159dfd43363c4d08055a07703eb7a3406b0dac4d0584d96965a3262db3c9d16"
"checksum clap 2.33.0 (registry+https://github.com/rust-lang/crates.io-index)" = "5067f5bb2d80ef5d68b4c87db81601f0b75bca627bc2ef76b141d7b846a3c6d9"
"checksum constant_time_eq 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)" = "8ff012e225ce166d4422e0e78419d901719760f62ae2b7969ca6b564d1b54a9e"
"checksum crossbeam-deque 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)" = "3486aefc4c0487b9cb52372c97df0a48b8c249514af1ee99703bf70d2f2ceda1"
"checksum crossbeam-epoch 0.5.2 (registry+https://github.com/rust-lang/crates.io-index)" = "30fecfcac6abfef8771151f8be4abc9e4edc112c2bcb233314cafde2680536e9"
"checksum crossbeam-utils 0.5.0 (registry+https://github.com/rust-lang/crates.io-index)" = "677d453a17e8bd2b913fa38e8b9cf04bcdbb5be790aa294f2389661d72036015"
"checksum digest 0.7.6 (registry+https://github.com/rust-lang/crates.io-index)" = "03b072242a8cbaf9c145665af9d250c59af3b958f83ed6824e13533cf76d5b90"
"checksum error-chain 0.1.12 (registry+https://github.com/rust-lang/crates.io-index)" = "faa976b4fd2e4c2b2f3f486874b19e61944d3de3de8b61c9fcf835d583871bcc"
"checksum failure 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)" = "6dd377bcc1b1b7ce911967e3ec24fa19c3224394ec05b54aa7b083d498341ac7"
"checksum failure_derive 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)" = "64c2d913fe8ed3b6c6518eedf4538255b989945c14c2a7d5cbff62a5e2120596"
"checksum fuchsia-cprng 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "a06f77d526c1a601b7c4cdd98f54b5eaabffc14d5f2f0296febdc7f357c6d3ba"
"checksum futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)" = "62941eff9507c8177d448bd83a44d9b9760856e184081d8cd79ba9f03dd24981"
"checksum generic-array 0.9.0 (registry+https://github.com/rust-lang/crates.io-index)" = "ef25c5683767570c2bbd7deba372926a55eaae9982d7726ee2a1050239d45b9d"
"checksum http 0.1.13 (registry+https://github.com/rust-lang/crates.io-index)" = "24f58e8c2d8e886055c3ead7b28793e1455270b5fb39650984c224bc538ba581"
"checksum hyper 0.12.13 (registry+https://github.com/rust-lang/crates.io-index)" = "95ffee0d1d30de4313fdaaa485891ce924991d45bbc18adfc8ac5b1639e62fbb"
"checksum ipconfig 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)" = "fccb81dd962b29a25de46c4f46e497b75117aa816468b6fff7a63a598a192394"
"checksum jid 0.5.2 (registry+https://github.com/rust-lang/crates.io-index)" = "6c4cee633b7ce95e71202ecb99e632d15ad468de7753e616a924c93842f1a3d0"
"checksum lazy_static 1.1.0 (registry+https://github.com/rust-lang/crates.io-index)" = "ca488b89a5657b0a2ecd45b95609b3e848cf1755da332a0da46e2b2b1cb371a7"
"checksum lazycell 1.2.0 (registry+https://github.com/rust-lang/crates.io-index)" = "ddba4c30a78328befecec92fc94970e53b3ae385827d28620f0f5bb2493081e0"
"checksum libc 0.2.43 (registry+https://github.com/rust-lang/crates.io-index)" = "76e3a3ef172f1a0b9a9ff0dd1491ae5e6c948b94479a3021819ba7d860c8645d"
"checksum lock_api 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)" = "775751a3e69bde4df9b38dd00a1b5d6ac13791e4223d4a0506577f0dd27cfb7a"
"checksum log 0.3.9 (registry+https://github.com/rust-lang/crates.io-index)" = "e19e8d5c34a3e0e2223db8e060f9e8264aeeb5c5fc64a4ee9965c062211c024b"
"checksum log 0.4.5 (registry+https://github.com/rust-lang/crates.io-index)" = "d4fcce5fa49cc693c312001daf1d13411c4a5283796bac1084299ea3e567113f"
"checksum markup5ever 0.7.3 (registry+https://github.com/rust-lang/crates.io-index)" = "a87c4100d614080c8ab43334fb028ebe387f273fb61ed4ff0eae9189b94b6be8"
"checksum memchr 2.1.0 (registry+https://github.com/rust-lang/crates.io-index)" = "4b3629fe9fdbff6daa6c33b90f7c08355c1aca05a3d01fa8063b822fcf185f3b"
"checksum minidom 0.9.1 (registry+https://github.com/rust-lang/crates.io-index)" = "c0a5296bf9d0ac9e4a6e4cb844e3ee84bf33f841c7b3ae2cc87f05ceb81b50ae"
"checksum new_debug_unreachable 1.0.2 (registry+https://github.com/rust-lang/crates.io-index)" = "fe2deb65e9f08f6540e6766481b9dc3a36e73d2fdb96e82bc3cd56353fafe90a"
"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 opaque-debug 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)" = "93f5bb2e8e8dec81642920ccff6b61f1eb94fa3020c5a325c9851ff604152409"
"checksum openssl 0.10.20 (registry+https://github.com/rust-lang/crates.io-index)" = "5a0d6b781aac4ac1bd6cafe2a2f0ad8c16ae8e1dd5184822a16c50139f8838d9"
"checksum openssl-sys 0.9.39 (registry+https://github.com/rust-lang/crates.io-index)" = "278c1ad40a89aa1e741a1eed089a2f60b18fab8089c3139b542140fc7d674106"
"checksum parking_lot 0.6.4 (registry+https://github.com/rust-lang/crates.io-index)" = "f0802bff09003b291ba756dc7e79313e51cc31667e94afbe847def490424cde5"
"checksum parking_lot_core 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)" = "ad7f7e6ebdc79edff6fdcb87a55b620174f7a989e3eb31b65231f4af57f00b8c"
"checksum phf 0.7.23 (registry+https://github.com/rust-lang/crates.io-index)" = "cec29da322b242f4c3098852c77a0ca261c9c01b806cae85a5572a1eb94db9a6"
"checksum phf_codegen 0.7.23 (registry+https://github.com/rust-lang/crates.io-index)" = "7d187f00cd98d5afbcd8898f6cf181743a449162aeb329dcd2f3849009e605ad"
"checksum phf_generator 0.7.23 (registry+https://github.com/rust-lang/crates.io-index)" = "03dc191feb9b08b0dc1330d6549b795b9d81aec19efe6b4a45aec8d4caee0c4b"
"checksum phf_shared 0.7.23 (registry+https://github.com/rust-lang/crates.io-index)" = "b539898d22d4273ded07f64a05737649dc69095d92cb87c7097ec68e3f150b93"
"checksum proc-macro2 0.4.20 (registry+https://github.com/rust-lang/crates.io-index)" = "3d7b7eaaa90b4a90a932a9ea6666c95a389e424eff347f0f793979289429feee"
"checksum quick-xml 0.12.4 (registry+https://github.com/rust-lang/crates.io-index)" = "1d8065cbb01701c11cc195cde85cbf39d1c6a80705b67a157ebb3042e0e5777f"
"checksum quote 0.6.8 (registry+https://github.com/rust-lang/crates.io-index)" = "dd636425967c33af890042c483632d33fa7a18f19ad1d7ea72e8998c6ef8dea5"
"checksum rand 0.6.4 (registry+https://github.com/rust-lang/crates.io-index)" = "3906503e80ac6cbcacb2c2973fa8e473f24d7e2747c8c92bb230c2441cad96b5"
"checksum rand_chacha 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "556d3a1ca6600bfcbab7c7c91ccb085ac7fbbcd70e008a98742e7847f4f7bcef"
"checksum redox_syscall 0.1.40 (registry+https://github.com/rust-lang/crates.io-index)" = "c214e91d3ecf43e9a4e41e578973adeb14b474f2bee858742d127af75a0112b1"
"checksum regex 1.1.0 (registry+https://github.com/rust-lang/crates.io-index)" = "37e7cbbd370869ce2e8dff25c7018702d10b21a20ef7135316f8daecd6c25b7f"
"checksum regex-syntax 0.6.4 (registry+https://github.com/rust-lang/crates.io-index)" = "4e47a2ed29da7a9e1960e1639e7a982e6edc6d49be308a3b02daf511504a16d1"
"checksum resolv-conf 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)" = "c62bd95a41841efdf7fca2ae9951e64a8d8eae7e5da196d8ce489a2241491a92"
"checksum rustc-demangle 0.1.9 (registry+https://github.com/rust-lang/crates.io-index)" = "bcfe5b13211b4d78e5c2cadfebd7769197d95c639c35a50057eb4c05de811395"
"checksum ryu 0.2.6 (registry+https://github.com/rust-lang/crates.io-index)" = "7153dd96dade874ab973e098cb62fcdbb89a03682e46b144fd09550998d4a4a7"
"checksum schannel 0.1.14 (registry+https://github.com/rust-lang/crates.io-index)" = "0e1a231dc10abf6749cfa5d7767f25888d484201accbd919b66ab5413c502d56"
"checksum security-framework 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)" = "697d3f3c23a618272ead9e1fb259c1411102b31c6af8b93f1d64cca9c3b0e8e0"
"checksum security-framework-sys 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)" = "ab01dfbe5756785b5b4d46e0289e5a18071dfa9a7c2b24213ea00b9ef9b665bf"
"checksum serde 1.0.80 (registry+https://github.com/rust-lang/crates.io-index)" = "15c141fc7027dd265a47c090bf864cf62b42c4d228bbcf4e51a0c9e2b0d3f7ef"
"checksum serde_derive 1.0.80 (registry+https://github.com/rust-lang/crates.io-index)" = "225de307c6302bec3898c51ca302fc94a7a1697ef0845fcee6448f33c032249c"
"checksum sha-1 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)" = "51b9d1f3b5de8a167ab06834a7c883bd197f2191e1dda1a22d9ccfeedbf9aded"
"checksum sha2 0.7.1 (registry+https://github.com/rust-lang/crates.io-index)" = "9eb6be24e4c23a84d7184280d2722f7f2731fcdd4a9d886efbfe4413e4847ea0"
"checksum sha3 0.7.3 (registry+https://github.com/rust-lang/crates.io-index)" = "b64dcef59ed4290b9fb562b53df07f564690d6539e8ecdd4728cf392477530bc"
"checksum slab 0.4.1 (registry+https://github.com/rust-lang/crates.io-index)" = "5f9776d6b986f77b35c6cf846c11ad986ff128fe0b2b63a3628e3755e8d3102d"
"checksum string 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "00caf261d6f90f588f8450b8e1230fa0d5be49ee6140fdfbcb55335aff350970"
"checksum strsim 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)" = "8ea5119cdb4c55b55d432abb513a0429384878c15dde60cc77b1c99de1a95a6a"
"checksum syn 0.15.14 (registry+https://github.com/rust-lang/crates.io-index)" = "baaba45c6bf60fe29aaf241fa33306c0b75c801edea8378263a8f043b09a5634"
"checksum synstructure 0.10.0 (registry+https://github.com/rust-lang/crates.io-index)" = "ec37f4fab4bafaf6b5621c1d54e6aa5d4d059a8f84929e87abfdd7f9f04c6db2"
"checksum tempfile 3.0.4 (registry+https://github.com/rust-lang/crates.io-index)" = "55c1195ef8513f3273d55ff59fe5da6940287a0d7a98331254397f464833675b"
"checksum termcolor 1.0.4 (registry+https://github.com/rust-lang/crates.io-index)" = "4096add70612622289f2fdcdbd5086dc81c1e2675e6ae58d6c4f62a16c6d7f2f"
"checksum textwrap 0.11.0 (registry+https://github.com/rust-lang/crates.io-index)" = "d326610f408c7a4eb6f51c37c330e496b08506c9457c9d34287ecc38809fb060"
"checksum tokio 0.1.11 (registry+https://github.com/rust-lang/crates.io-index)" = "6e93c78d23cc61aa245a8acd2c4a79c4d7fa7fb5c3ca90d5737029f043a84895"
"checksum tokio-current-thread 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)" = "f90fcd90952f0a496d438a976afba8e5c205fb12123f813d8ab3aa1c8436638c"
"checksum tokio-reactor 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)" = "4b26fd37f1125738b2170c80b551f69ff6fecb277e6e5ca885e53eec2b005018"
"checksum tokio-signal 0.2.6 (registry+https://github.com/rust-lang/crates.io-index)" = "40da88e6445ed335e14746b60986a6c8b3632b09bc9097df76b4a6ddd16f1f92"
"checksum tokio-threadpool 0.1.8 (registry+https://github.com/rust-lang/crates.io-index)" = "3929aee321c9220ed838ed6c3928be7f9b69986b0e3c22c972a66dbf8a298c68"
"checksum tokio-timer 0.2.7 (registry+https://github.com/rust-lang/crates.io-index)" = "3a52f00c97fedb6d535d27f65cccb7181c8dd4c6edc3eda9ea93f6d45d05168e"
"checksum tokio-udp 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)" = "da941144b816d0dcda4db3a1ba87596e4df5e860a72b70783fe435891f80601c"
"checksum tokio-uds 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)" = "df195376b43508f01570bacc73e13a1de0854dc59e79d1ec09913e8db6dd2a70"
"checksum toml 0.4.8 (registry+https://github.com/rust-lang/crates.io-index)" = "4a2ecc31b0351ea18b3fe11274b8db6e4d82bce861bbb22e6dbed40417902c65"
"checksum try_from 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)" = "923a7ee3e97dbfe8685261beb4511cc9620a1252405d02693d43169729570111"
"checksum ucd-util 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)" = "535c204ee4d8434478593480b8f86ab45ec9aae0e83c568ca81abf0fd0e88f86"
"checksum unicode-normalization 0.1.8 (registry+https://github.com/rust-lang/crates.io-index)" = "141339a08b982d942be2ca06ff8b076563cbe223d1befd5450716790d44e2426"
"checksum unreachable 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)" = "382810877fe448991dfc7f0dd6e3ae5d58088fd0ea5e35189655f84e6814fa56"
"checksum utf-8 0.7.5 (registry+https://github.com/rust-lang/crates.io-index)" = "05e42f7c18b8f902290b009cde6d651262f956c98bc51bca4cd1d511c9cd85c7"
"checksum version_check 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)" = "914b1a6776c4c929a602fafd8bc742e06365d4bcbe48c30f9cca5824f70dc9dd"
"checksum winapi 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)" = "f10e386af2b13e47c89e7236a7a14a086791a2b88ebad6df9bf42040195cf770"
"checksum winapi-util 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)" = "7168bab6e1daee33b4557efd0e95d5ca70a03706d39fa5f3fe7a236f584b03c9"
"checksum wincolor 1.0.1 (registry+https://github.com/rust-lang/crates.io-index)" = "561ed901ae465d6185fa7864d63fbd5720d0ef718366c9a4dc83cf6170d7e9ba"
"checksum xml5ever 0.12.0 (registry+https://github.com/rust-lang/crates.io-index)" = "ead952cf8bab253fb5cb56e1fff780747bbf7a7258fb0451afe645a166050b1f"
"checksum xmpp-parsers 0.11.1 (registry+https://github.com/rust-lang/crates.io-index)" = "2e1e0a279d5af83a1dff442249f8a43214ac120267acfaac494b9d28c0027fea"
"checksum xml5ever 0.12.1 (registry+https://github.com/rust-lang/crates.io-index)" = "32cd7ebf0203c620906230ce22caa5df0b603c32b6fef72a275a48f6a2ae64b9"
"checksum xmpp-parsers 0.13.0 (registry+https://github.com/rust-lang/crates.io-index)" = "c467bb13e01718be793cb7a1c3d38d0e9ba45898db306aa43e70657a8aa3c2f2"
"checksum xmpp-parsers 0.13.1 (registry+https://github.com/rust-lang/crates.io-index)" = "5094cec449beca92f82ae4d7fe13cda058005849766d71b86c23e6217f61a357"
"checksum xmpp-parsers 0.13.1 (registry+https://github.com/rust-lang/crates.io-index)" = "5094cec449beca92f82ae4d7fe13cda058005849766d71b86c23e6217f61a357"
"checksum xmpp-parsers 0.12.2 (registry+https://github.com/rust-lang/crates.io-index)" = "58b4400e1ae0d246044db5fa7f2e693fdfe9cc6e8eaa72ef2a68c5dc1d3c96de"
"checksum xmpp-parsers 0.12.2 (registry+https://github.com/rust-lang/crates.io-index)" = "58b4400e1ae0d246044db5fa7f2e693fdfe9cc6e8eaa72ef2a68c5dc1d3c96de"
"checksum xmpp-parsers 0.12.2 (registry+https://github.com/rust-lang/crates.io-index)" = "58b4400e1ae0d246044db5fa7f2e693fdfe9cc6e8eaa72ef2a68c5dc1d3c96de"
"checksum xmpp-parsers 0.11.1 (registry+https://github.com/rust-lang/crates.io-index)" = "2e1e0a279d5af83a1dff442249f8a43214ac120267acfaac494b9d28c0027fea"
"checksum xmpp-parsers 0.11.1 (registry+https://github.com/rust-lang/crates.io-index)" = "2e1e0a279d5af83a1dff442249f8a43214ac120267acfaac494b9d28c0027fea"
"checksum xml5ever 0.12.1 (registry+https://github.com/rust-lang/crates.io-index)" = "32cd7ebf0203c620906230ce22caa5df0b603c32b6fef72a275a48f6a2ae64b9"
"checksum xmpp-parsers 0.12.2 (registry+https://github.com/rust-lang/crates.io-index)" = "58b4400e1ae0d246044db5fa7f2e693fdfe9cc6e8eaa72ef2a68c5dc1d3c96de"
"checksum xmpp-parsers 0.11.1 (registry+https://github.com/rust-lang/crates.io-index)" = "2e1e0a279d5af83a1dff442249f8a43214ac120267acfaac494b9d28c0027fea"
"checksum xmpp-parsers 0.11.1 (registry+https://github.com/rust-lang/crates.io-index)" = "2e1e0a279d5af83a1dff442249f8a43214ac120267acfaac494b9d28c0027fea"
"checksum xmpp-parsers 0.12.2 (registry+https://github.com/rust-lang/crates.io-index)" = "58b4400e1ae0d246044db5fa7f2e693fdfe9cc6e8eaa72ef2a68c5dc1d3c96de"
"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 winapi-util 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)" = "7168bab6e1daee33b4557efd0e95d5ca70a03706d39fa5f3fe7a236f584b03c9"
"checksum winapi-util 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "afc5508759c5bf4285e61feb862b6083c8480aec864fa17a81fdec6f69b461ab"
"checksum winapi-util 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "afc5508759c5bf4285e61feb862b6083c8480aec864fa17a81fdec6f69b461ab"
"checksum winapi-util 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "afc5508759c5bf4285e61feb862b6083c8480aec864fa17a81fdec6f69b461ab"
"checksum winapi-x86_64-pc-windows-gnu 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)" = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
"checksum winapi 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)" = "92c1eb33641e276cfa214a0522acad57be5c56b10cb348b3c5117db75f3ac4b0"
"checksum winapi 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)" = "f10e386af2b13e47c89e7236a7a14a086791a2b88ebad6df9bf42040195cf770"
"checksum winapi 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)" = "92c1eb33641e276cfa214a0522acad57be5c56b10cb348b3c5117db75f3ac4b0"
"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 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 void 1.0.2 (registry+https://github.com/rust-lang/crates.io-index)" = "6a02e4885ed3bc0f2de90ea6dd45ebcbb66dacffe03547fadbb0eeae2770887d"
"checksum version_check 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)" = "914b1a6776c4c929a602fafd8bc742e06365d4bcbe48c30f9cca5824f70dc9dd"
"checksum void 1.0.2 (registry+https://github.com/rust-lang/crates.io-index)" = "6a02e4885ed3bc0f2de90ea6dd45ebcbb66dacffe03547fadbb0eeae2770887d"
"checksum version_check 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)" = "914b1a6776c4c929a602fafd8bc742e06365d4bcbe48c30f9cca5824f70dc9dd"
"checksum void 1.0.2 (registry+https://github.com/rust-lang/crates.io-index)" = "6a02e4885ed3bc0f2de90ea6dd45ebcbb66dacffe03547fadbb0eeae2770887d"
"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 void 1.0.2 (registry+https://github.com/rust-lang/crates.io-index)" = "6a02e4885ed3bc0f2de90ea6dd45ebcbb66dacffe03547fadbb0eeae2770887d"
"checksum version_check 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)" = "914b1a6776c4c929a602fafd8bc742e06365d4bcbe48c30f9cca5824f70dc9dd"
"checksum version_check 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)" = "914b1a6776c4c929a602fafd8bc742e06365d4bcbe48c30f9cca5824f70dc9dd"
"checksum void 1.0.2 (registry+https://github.com/rust-lang/crates.io-index)" = "6a02e4885ed3bc0f2de90ea6dd45ebcbb66dacffe03547fadbb0eeae2770887d"
"checksum utf-8 0.7.5 (registry+https://github.com/rust-lang/crates.io-index)" = "05e42f7c18b8f902290b009cde6d651262f956c98bc51bca4cd1d511c9cd85c7"
"checksum utf-8 0.7.5 (registry+https://github.com/rust-lang/crates.io-index)" = "05e42f7c18b8f902290b009cde6d651262f956c98bc51bca4cd1d511c9cd85c7"
"checksum utf-8 0.7.4 (registry+https://github.com/rust-lang/crates.io-index)" = "bab35f71693630bb1953dce0f2bcd780e7cde025027124a202ac08a45ba25141"
"checksum utf-8 0.7.4 (registry+https://github.com/rust-lang/crates.io-index)" = "bab35f71693630bb1953dce0f2bcd780e7cde025027124a202ac08a45ba25141"
"checksum unreachable 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)" = "382810877fe448991dfc7f0dd6e3ae5d58088fd0ea5e35189655f84e6814fa56"
"checksum utf8-ranges 1.0.2 (registry+https://github.com/rust-lang/crates.io-index)" = "796f7e48bef87609f7ade7e06495a87d5cd06c7866e6a5cbfceffc558a243737"
"checksum unreachable 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)" = "382810877fe448991dfc7f0dd6e3ae5d58088fd0ea5e35189655f84e6814fa56"
"checksum utf-8 0.7.4 (registry+https://github.com/rust-lang/crates.io-index)" = "bab35f71693630bb1953dce0f2bcd780e7cde025027124a202ac08a45ba25141"
"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 utf-8 0.7.4 (registry+https://github.com/rust-lang/crates.io-index)" = "bab35f71693630bb1953dce0f2bcd780e7cde025027124a202ac08a45ba25141"
"checksum utf-8 0.7.4 (registry+https://github.com/rust-lang/crates.io-index)" = "bab35f71693630bb1953dce0f2bcd780e7cde025027124a202ac08a45ba25141"
"checksum utf-8 0.7.5 (registry+https://github.com/rust-lang/crates.io-index)" = "05e42f7c18b8f902290b009cde6d651262f956c98bc51bca4cd1d511c9cd85c7"
"checksum url 1.7.1 (registry+https://github.com/rust-lang/crates.io-index)" = "2a321979c09843d272956e73700d12c4e7d3d92b2ee112b31548aef0d4efc5a6"
"checksum url 1.7.2 (registry+https://github.com/rust-lang/crates.io-index)" = "dd4e7c0d531266369519a4aa4f399d748bd37043b00bde1e4ff1f60a120b355a"
"checksum url 1.7.2 (registry+https://github.com/rust-lang/crates.io-index)" = "dd4e7c0d531266369519a4aa4f399d748bd37043b00bde1e4ff1f60a120b355a"
"checksum unreachable 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)" = "382810877fe448991dfc7f0dd6e3ae5d58088fd0ea5e35189655f84e6814fa56"
"checksum unreachable 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)" = "382810877fe448991dfc7f0dd6e3ae5d58088fd0ea5e35189655f84e6814fa56"
"checksum unicode-normalization 0.1.8 (registry+https://github.com/rust-lang/crates.io-index)" = "141339a08b982d942be2ca06ff8b076563cbe223d1befd5450716790d44e2426"
"checksum unicode-normalization 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)" = "6a0180bc61fc5a987082bfa111f4cc95c4caff7f9799f3e46df09163a937aa25"
"checksum unicode-normalization 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)" = "6a0180bc61fc5a987082bfa111f4cc95c4caff7f9799f3e46df09163a937aa25"
"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 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 try_from 0.3.2 (registry+https://github.com/rust-lang/crates.io-index)" = "283d3b89e1368717881a9d51dad843cc435380d8109c9e47d38780a324698d8b"
"checksum try_from 0.3.2 (registry+https://github.com/rust-lang/crates.io-index)" = "283d3b89e1368717881a9d51dad843cc435380d8109c9e47d38780a324698d8b"
"checksum try_from 0.3.2 (registry+https://github.com/rust-lang/crates.io-index)" = "283d3b89e1368717881a9d51dad843cc435380d8109c9e47d38780a324698d8b"
"checksum try_from 0.3.2 (registry+https://github.com/rust-lang/crates.io-index)" = "283d3b89e1368717881a9d51dad843cc435380d8109c9e47d38780a324698d8b"
"checksum try_from 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)" = "923a7ee3e97dbfe8685261beb4511cc9620a1252405d02693d43169729570111"
"checksum try_from 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)" = "923a7ee3e97dbfe8685261beb4511cc9620a1252405d02693d43169729570111"
"checksum typenum 1.10.0 (registry+https://github.com/rust-lang/crates.io-index)" = "612d636f949607bdf9b123b4a6f6d966dedf3ff669f7f045890d3a4a73948169"
"checksum try-lock 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)" = "e604eb7b43c06650e854be16a2a03155743d3752dd1c943f6829e26b7a36e382"
"checksum try_from 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)" = "923a7ee3e97dbfe8685261beb4511cc9620a1252405d02693d43169729570111"
"checksum try_from 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)" = "923a7ee3e97dbfe8685261beb4511cc9620a1252405d02693d43169729570111"
"checksum try_from 0.3.2 (registry+https://github.com/rust-lang/crates.io-index)" = "283d3b89e1368717881a9d51dad843cc435380d8109c9e47d38780a324698d8b"
"checksum trust-dns-proto 0.4.3 (registry+https://github.com/rust-lang/crates.io-index)" = "f1525ca4e26f5a09d81b79584f19225e7dba5606ae3a416311c2751c5cea60bb"
"checksum trust-dns-resolver 0.9.1 (registry+https://github.com/rust-lang/crates.io-index)" = "4a821ad51a29816420b8cac4b026756b81c023630b97eaa4c8090637ee3508bd"
"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 trust-dns-proto 0.6.2 (registry+https://github.com/rust-lang/crates.io-index)" = "30dde452f5d142d5e316a3b32386da95280c98b7e266639f8f3bc6fdf507d279"
"checksum trust-dns-resolver 0.10.2 (registry+https://github.com/rust-lang/crates.io-index)" = "de630f95a192f793436ffae5137e88253cc4142a97d9a8e73c8d804fa85ddf0a"
"checksum trust-dns-proto 0.4.3 (registry+https://github.com/rust-lang/crates.io-index)" = "f1525ca4e26f5a09d81b79584f19225e7dba5606ae3a416311c2751c5cea60bb"
"checksum trust-dns-resolver 0.9.1 (registry+https://github.com/rust-lang/crates.io-index)" = "4a821ad51a29816420b8cac4b026756b81c023630b97eaa4c8090637ee3508bd"
"checksum tokio-xmpp 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)" = "c27385c4781afc851c61ac66d79463c511bf073d3a5d71b8bfd13a816e475989"
"checksum tokio-udp 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)" = "66268575b80f4a4a710ef83d087fdfeeabdce9b74c797535fbac18a2cb906e92"
"checksum toml 0.5.0 (registry+https://github.com/rust-lang/crates.io-index)" = "87c5890a989fa47ecdc7bcb4c63a77a82c18f306714104b1decfd722db17b39e"
"checksum toml 0.5.0 (registry+https://github.com/rust-lang/crates.io-index)" = "87c5890a989fa47ecdc7bcb4c63a77a82c18f306714104b1decfd722db17b39e"
"checksum trust-dns-proto 0.6.3 (registry+https://github.com/rust-lang/crates.io-index)" = "09144f0992b0870fa8d2972cc069cbf1e3c0fda64d1f3d45c4d68d0e0b52ad4e"
"checksum trust-dns-resolver 0.10.3 (registry+https://github.com/rust-lang/crates.io-index)" = "8a9f877f7a1ad821ab350505e1f1b146a4960402991787191d6d8cab2ce2de2c"
"checksum toml 0.4.10 (registry+https://github.com/rust-lang/crates.io-index)" = "758664fc71a3a69038656bee8b6be6477d2a6c315a6b81f7081f591bffa4111f"
"checksum toml 0.4.10 (registry+https://github.com/rust-lang/crates.io-index)" = "758664fc71a3a69038656bee8b6be6477d2a6c315a6b81f7081f591bffa4111f"
"checksum toml 0.5.0 (registry+https://github.com/rust-lang/crates.io-index)" = "87c5890a989fa47ecdc7bcb4c63a77a82c18f306714104b1decfd722db17b39e"
"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 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 tokio-uds 0.2.4 (registry+https://github.com/rust-lang/crates.io-index)" = "99ce87382f6c1a24b513a72c048b2c8efe66cb5161c9061d00bee510f08dc168"
"checksum tokio-uds 0.2.5 (registry+https://github.com/rust-lang/crates.io-index)" = "037ffc3ba0e12a0ab4aca92e5234e0dedeb48fddf6ccd260f1f150a36a9f2445"
"checksum tokio-xmpp 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)" = "838f8a47654f45fd3618288ebda6085578f783ae087d82f12c09e04f7513a690"
"checksum tokio-uds 0.2.4 (registry+https://github.com/rust-lang/crates.io-index)" = "99ce87382f6c1a24b513a72c048b2c8efe66cb5161c9061d00bee510f08dc168"
"checksum tokio-xmpp 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)" = "c27385c4781afc851c61ac66d79463c511bf073d3a5d71b8bfd13a816e475989"
"checksum toml 0.4.10 (registry+https://github.com/rust-lang/crates.io-index)" = "758664fc71a3a69038656bee8b6be6477d2a6c315a6b81f7081f591bffa4111f"
"checksum trust-dns-proto 0.4.3 (registry+https://github.com/rust-lang/crates.io-index)" = "f1525ca4e26f5a09d81b79584f19225e7dba5606ae3a416311c2751c5cea60bb"
"checksum trust-dns-resolver 0.9.1 (registry+https://github.com/rust-lang/crates.io-index)" = "4a821ad51a29816420b8cac4b026756b81c023630b97eaa4c8090637ee3508bd"
"checksum tokio-uds 0.2.4 (registry+https://github.com/rust-lang/crates.io-index)" = "99ce87382f6c1a24b513a72c048b2c8efe66cb5161c9061d00bee510f08dc168"
"checksum tokio-xmpp 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)" = "c27385c4781afc851c61ac66d79463c511bf073d3a5d71b8bfd13a816e475989"
"checksum tokio-tls 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)" = "e53fdbf3156f588be1676022fe794232b24922d426e8c14f4e46891c1e31c440"
"checksum tokio-threadpool 0.1.9 (registry+https://github.com/rust-lang/crates.io-index)" = "56c5556262383032878afad66943926a1d1f0967f17e94bd7764ceceb3b70e7f"
"checksum tokio-tls 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)" = "354b8cd83825b3c20217a9dc174d6a0c67441a2fae5c41bcb1ea6679f6ae0f7c"
"checksum tokio-tls 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)" = "e53fdbf3156f588be1676022fe794232b24922d426e8c14f4e46891c1e31c440"
"checksum tokio-timer 0.2.8 (registry+https://github.com/rust-lang/crates.io-index)" = "4f37f0111d76cc5da132fe9bc0590b9b9cfd079bc7e75ac3846278430a299ff8"
"checksum tokio-tcp 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)" = "7ad235e9dadd126b2d47f6736f65aa1fdcd6420e66ca63f44177bc78df89f912"
"checksum tokio-reactor 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)" = "502b625acb4ee13cbb3b90b8ca80e0addd263ddacf6931666ef751e610b07fb5"
"checksum tokio-sync 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)" = "fda385df506bf7546e70872767f71e81640f1f251bdf2fd8eb81a0eaec5fe022"
"checksum tokio-threadpool 0.1.12 (registry+https://github.com/rust-lang/crates.io-index)" = "742e511f6ce2298aeb86fc9ea0d8df81c2388c6ebae3dc8a7316e8c9df0df801"
"checksum tokio-trace-core 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)" = "350c9edade9830dc185ae48ba45667a445ab59f6167ef6d0254ec9d2430d9dd3"
"checksum tokio-trace-core 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)" = "350c9edade9830dc185ae48ba45667a445ab59f6167ef6d0254ec9d2430d9dd3"
"checksum tokio-threadpool 0.1.11 (registry+https://github.com/rust-lang/crates.io-index)" = "c3fd86cb15547d02daa2b21aadaf4e37dee3368df38a526178a5afa3c034d2fb"
"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-threadpool 0.1.11 (registry+https://github.com/rust-lang/crates.io-index)" = "c3fd86cb15547d02daa2b21aadaf4e37dee3368df38a526178a5afa3c034d2fb"
"checksum tokio-threadpool 0.1.13 (registry+https://github.com/rust-lang/crates.io-index)" = "ec5759cf26cf9659555f36c431b515e3d05f66831741c85b4b5d5dfb9cf1323c"
"checksum tokio-threadpool 0.1.11 (registry+https://github.com/rust-lang/crates.io-index)" = "c3fd86cb15547d02daa2b21aadaf4e37dee3368df38a526178a5afa3c034d2fb"
"checksum tokio-threadpool 0.1.12 (registry+https://github.com/rust-lang/crates.io-index)" = "742e511f6ce2298aeb86fc9ea0d8df81c2388c6ebae3dc8a7316e8c9df0df801"
"checksum tokio-sync 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)" = "1bf2b9dac2a0509b5cfd1df5aa25eafacb616a42a491a13604d6bbeab4486363"
"checksum tokio-sync 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "3742b64166c1ee9121f1921aea5a726098458926a6b732d906ef23b1f3ef6f4f"
"checksum tokio-tcp 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)" = "1d14b10654be682ac43efee27401d792507e30fd8d26389e1da3b185de2e4119"
"checksum tokio-tcp 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)" = "1d14b10654be682ac43efee27401d792507e30fd8d26389e1da3b185de2e4119"
"checksum tokio-timer 0.2.10 (registry+https://github.com/rust-lang/crates.io-index)" = "2910970404ba6fa78c5539126a9ae2045d62e3713041e447f695f41405a120c6"
"checksum tokio-tls 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)" = "354b8cd83825b3c20217a9dc174d6a0c67441a2fae5c41bcb1ea6679f6ae0f7c"
"checksum tokio-trace-core 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)" = "350c9edade9830dc185ae48ba45667a445ab59f6167ef6d0254ec9d2430d9dd3"
"checksum tokio-threadpool 0.1.13 (registry+https://github.com/rust-lang/crates.io-index)" = "ec5759cf26cf9659555f36c431b515e3d05f66831741c85b4b5d5dfb9cf1323c"
"checksum tokio-threadpool 0.1.12 (registry+https://github.com/rust-lang/crates.io-index)" = "742e511f6ce2298aeb86fc9ea0d8df81c2388c6ebae3dc8a7316e8c9df0df801"
"checksum tokio-sync 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)" = "fda385df506bf7546e70872767f71e81640f1f251bdf2fd8eb81a0eaec5fe022"
"checksum tokio-sync 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)" = "1bf2b9dac2a0509b5cfd1df5aa25eafacb616a42a491a13604d6bbeab4486363"
"checksum tokio-sync 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "3742b64166c1ee9121f1921aea5a726098458926a6b732d906ef23b1f3ef6f4f"
"checksum tokio-tcp 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)" = "1d14b10654be682ac43efee27401d792507e30fd8d26389e1da3b185de2e4119"
"checksum tokio-threadpool 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)" = "17465013014410310f9f61fa10bf4724803c149ea1d51efece131c38efca93aa"
"checksum tokio-sync 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)" = "fda385df506bf7546e70872767f71e81640f1f251bdf2fd8eb81a0eaec5fe022"
"checksum tokio-tcp 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)" = "7ad235e9dadd126b2d47f6736f65aa1fdcd6420e66ca63f44177bc78df89f912"
"checksum tokio-threadpool 0.1.9 (registry+https://github.com/rust-lang/crates.io-index)" = "56c5556262383032878afad66943926a1d1f0967f17e94bd7764ceceb3b70e7f"
"checksum tokio-timer 0.2.8 (registry+https://github.com/rust-lang/crates.io-index)" = "4f37f0111d76cc5da132fe9bc0590b9b9cfd079bc7e75ac3846278430a299ff8"
"checksum tokio-tls 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)" = "e53fdbf3156f588be1676022fe794232b24922d426e8c14f4e46891c1e31c440"
"checksum tokio-sync 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "3742b64166c1ee9121f1921aea5a726098458926a6b732d906ef23b1f3ef6f4f"
"checksum tokio-sync 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)" = "1bf2b9dac2a0509b5cfd1df5aa25eafacb616a42a491a13604d6bbeab4486363"
"checksum tokio-tcp 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)" = "7ad235e9dadd126b2d47f6736f65aa1fdcd6420e66ca63f44177bc78df89f912"
"checksum tokio-threadpool 0.1.9 (registry+https://github.com/rust-lang/crates.io-index)" = "56c5556262383032878afad66943926a1d1f0967f17e94bd7764ceceb3b70e7f"
"checksum tokio-signal 0.2.7 (registry+https://github.com/rust-lang/crates.io-index)" = "dd6dc5276ea05ce379a16de90083ec80836440d5ef8a6a39545a3207373b8296"
"checksum tokio-executor 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)" = "c117b6cf86bb730aab4834f10df96e4dd586eff2c3c27d3781348da49e255bde"
"checksum tokio-fs 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)" = "60ae25f6b17d25116d2cba342083abe5255d3c2c79cb21ea11aa049c53bf7c75"
"checksum tokio-io 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)" = "7392fe0a70d5ce0c882c4778116c519bd5dbaa8a7c3ae3d04578b3afafdcda21"
"checksum tokio-current-thread 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)" = "c756b04680eea21902a46fca4e9f410a2332c04995af590e07ff262e2193a9a3"
"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-fs 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)" = "0e9cbbc8a3698b7ab652340f46633364f9eaa928ddaaee79d8b8f356dd79a09d"
"checksum tokio-io 0.1.11 (registry+https://github.com/rust-lang/crates.io-index)" = "b53aeb9d3f5ccf2ebb29e19788f96987fa1355f8fe45ea193928eaaaf3ae820f"
"checksum tokio-reactor 0.1.8 (registry+https://github.com/rust-lang/crates.io-index)" = "afbcdb0f0d2a1e4c440af82d7bbf0bf91a8a8c0575bcd20c05d15be7e9d3a02f"
"checksum tokio-fs 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)" = "0e9cbbc8a3698b7ab652340f46633364f9eaa928ddaaee79d8b8f356dd79a09d"
"checksum tokio-io 0.1.11 (registry+https://github.com/rust-lang/crates.io-index)" = "b53aeb9d3f5ccf2ebb29e19788f96987fa1355f8fe45ea193928eaaaf3ae820f"
"checksum tokio-reactor 0.1.8 (registry+https://github.com/rust-lang/crates.io-index)" = "afbcdb0f0d2a1e4c440af82d7bbf0bf91a8a8c0575bcd20c05d15be7e9d3a02f"
"checksum tokio-fs 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)" = "0e9cbbc8a3698b7ab652340f46633364f9eaa928ddaaee79d8b8f356dd79a09d"
"checksum tokio-io 0.1.11 (registry+https://github.com/rust-lang/crates.io-index)" = "b53aeb9d3f5ccf2ebb29e19788f96987fa1355f8fe45ea193928eaaaf3ae820f"
"checksum tokio-reactor 0.1.8 (registry+https://github.com/rust-lang/crates.io-index)" = "afbcdb0f0d2a1e4c440af82d7bbf0bf91a8a8c0575bcd20c05d15be7e9d3a02f"
"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-current-thread 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)" = "d16217cad7f1b840c5a97dfb3c43b0c871fef423a6e8d2118c604e843662a443"
"checksum tokio-executor 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)" = "83ea44c6c0773cc034771693711c35c677b4b5a4b21b9e7071704c54de7d555e"
"checksum tokio-fs 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)" = "3fe6dc22b08d6993916647d108a1a7d15b9cd29c4f4496c62b92c45b5041b7af"
"checksum tokio-io 0.1.12 (registry+https://github.com/rust-lang/crates.io-index)" = "5090db468dad16e1a7a54c8c67280c5e4b544f3d3e018f0b913b400261f85926"
"checksum tokio-reactor 0.1.9 (registry+https://github.com/rust-lang/crates.io-index)" = "6af16bfac7e112bea8b0442542161bfc41cbfa4466b580bdda7d18cb88b911ce"
"checksum tokio-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-current-thread 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)" = "331c8acc267855ec06eb0c94618dcbbfea45bed2d20b77252940095273fb58f6"
"checksum tokio-current-thread 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)" = "331c8acc267855ec06eb0c94618dcbbfea45bed2d20b77252940095273fb58f6"
"checksum tokio-executor 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)" = "30c6dbf2d1ad1de300b393910e8a3aa272b724a400b6531da03eed99e329fbf0"
"checksum tokio-executor 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)" = "30c6dbf2d1ad1de300b393910e8a3aa272b724a400b6531da03eed99e329fbf0"
"checksum tokio-fs 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)" = "0e9cbbc8a3698b7ab652340f46633364f9eaa928ddaaee79d8b8f356dd79a09d"
"checksum tokio-io 0.1.11 (registry+https://github.com/rust-lang/crates.io-index)" = "b53aeb9d3f5ccf2ebb29e19788f96987fa1355f8fe45ea193928eaaaf3ae820f"
"checksum tokio-reactor 0.1.8 (registry+https://github.com/rust-lang/crates.io-index)" = "afbcdb0f0d2a1e4c440af82d7bbf0bf91a8a8c0575bcd20c05d15be7e9d3a02f"
"checksum tokio-executor 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)" = "c117b6cf86bb730aab4834f10df96e4dd586eff2c3c27d3781348da49e255bde"
"checksum tokio-fs 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)" = "60ae25f6b17d25116d2cba342083abe5255d3c2c79cb21ea11aa049c53bf7c75"
"checksum tokio-io 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)" = "7392fe0a70d5ce0c882c4778116c519bd5dbaa8a7c3ae3d04578b3afafdcda21"
"checksum tokio-reactor 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)" = "502b625acb4ee13cbb3b90b8ca80e0addd263ddacf6931666ef751e610b07fb5"
"checksum tokio-current-thread 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)" = "d16217cad7f1b840c5a97dfb3c43b0c871fef423a6e8d2118c604e843662a443"
"checksum tokio-executor 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)" = "83ea44c6c0773cc034771693711c35c677b4b5a4b21b9e7071704c54de7d555e"
"checksum tokio-fs 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)" = "3fe6dc22b08d6993916647d108a1a7d15b9cd29c4f4496c62b92c45b5041b7af"
"checksum tokio-io 0.1.12 (registry+https://github.com/rust-lang/crates.io-index)" = "5090db468dad16e1a7a54c8c67280c5e4b544f3d3e018f0b913b400261f85926"
"checksum tokio-reactor 0.1.9 (registry+https://github.com/rust-lang/crates.io-index)" = "6af16bfac7e112bea8b0442542161bfc41cbfa4466b580bdda7d18cb88b911ce"
"checksum tokio-current-thread 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)" = "331c8acc267855ec06eb0c94618dcbbfea45bed2d20b77252940095273fb58f6"
"checksum tokio-executor 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)" = "c117b6cf86bb730aab4834f10df96e4dd586eff2c3c27d3781348da49e255bde"
"checksum tokio-fs 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)" = "60ae25f6b17d25116d2cba342083abe5255d3c2c79cb21ea11aa049c53bf7c75"
"checksum tokio-io 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)" = "7392fe0a70d5ce0c882c4778116c519bd5dbaa8a7c3ae3d04578b3afafdcda21"
"checksum tokio-reactor 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)" = "502b625acb4ee13cbb3b90b8ca80e0addd263ddacf6931666ef751e610b07fb5"
"checksum tokio-current-thread 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)" = "331c8acc267855ec06eb0c94618dcbbfea45bed2d20b77252940095273fb58f6"
"checksum tokio-signal 0.2.7 (registry+https://github.com/rust-lang/crates.io-index)" = "dd6dc5276ea05ce379a16de90083ec80836440d5ef8a6a39545a3207373b8296"
"checksum tokio-timer 0.2.8 (registry+https://github.com/rust-lang/crates.io-index)" = "4f37f0111d76cc5da132fe9bc0590b9b9cfd079bc7e75ac3846278430a299ff8"
"checksum tokio-udp 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)" = "66268575b80f4a4a710ef83d087fdfeeabdce9b74c797535fbac18a2cb906e92"
"checksum tokio-xmpp 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)" = "f6583920d10a72bd1605adec50f5efb298e0ba5dcad1ff987560675a7280013b"
"checksum trust-dns-proto 0.6.2 (registry+https://github.com/rust-lang/crates.io-index)" = "30dde452f5d142d5e316a3b32386da95280c98b7e266639f8f3bc6fdf507d279"
"checksum trust-dns-resolver 0.10.2 (registry+https://github.com/rust-lang/crates.io-index)" = "de630f95a192f793436ffae5137e88253cc4142a97d9a8e73c8d804fa85ddf0a"
"checksum trust-dns-proto 0.4.3 (registry+https://github.com/rust-lang/crates.io-index)" = "f1525ca4e26f5a09d81b79584f19225e7dba5606ae3a416311c2751c5cea60bb"
"checksum trust-dns-resolver 0.9.1 (registry+https://github.com/rust-lang/crates.io-index)" = "4a821ad51a29816420b8cac4b026756b81c023630b97eaa4c8090637ee3508bd"
"checksum trust-dns-proto 0.4.3 (registry+https://github.com/rust-lang/crates.io-index)" = "f1525ca4e26f5a09d81b79584f19225e7dba5606ae3a416311c2751c5cea60bb"
"checksum trust-dns-resolver 0.9.1 (registry+https://github.com/rust-lang/crates.io-index)" = "4a821ad51a29816420b8cac4b026756b81c023630b97eaa4c8090637ee3508bd"
"checksum trust-dns-proto 0.6.2 (registry+https://github.com/rust-lang/crates.io-index)" = "30dde452f5d142d5e316a3b32386da95280c98b7e266639f8f3bc6fdf507d279"
"checksum trust-dns-resolver 0.10.2 (registry+https://github.com/rust-lang/crates.io-index)" = "de630f95a192f793436ffae5137e88253cc4142a97d9a8e73c8d804fa85ddf0a"
"checksum tokio-xmpp 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)" = "c27385c4781afc851c61ac66d79463c511bf073d3a5d71b8bfd13a816e475989"
"checksum tokio-xmpp 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)" = "f6583920d10a72bd1605adec50f5efb298e0ba5dcad1ff987560675a7280013b"
"checksum tokio-xmpp 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)" = "f6583920d10a72bd1605adec50f5efb298e0ba5dcad1ff987560675a7280013b"
"checksum tokio-xmpp 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)" = "c27385c4781afc851c61ac66d79463c511bf073d3a5d71b8bfd13a816e475989"
"checksum toml 0.4.10 (registry+https://github.com/rust-lang/crates.io-index)" = "758664fc71a3a69038656bee8b6be6477d2a6c315a6b81f7081f591bffa4111f"
"checksum tokio-xmpp 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)" = "c27385c4781afc851c61ac66d79463c511bf073d3a5d71b8bfd13a816e475989"
"checksum tokio-xmpp 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)" = "c27385c4781afc851c61ac66d79463c511bf073d3a5d71b8bfd13a816e475989"
"checksum tokio-uds 0.2.5 (registry+https://github.com/rust-lang/crates.io-index)" = "037ffc3ba0e12a0ab4aca92e5234e0dedeb48fddf6ccd260f1f150a36a9f2445"
"checksum tokio-xmpp 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)" = "838f8a47654f45fd3618288ebda6085578f783ae087d82f12c09e04f7513a690"
"checksum tokio-uds 0.2.4 (registry+https://github.com/rust-lang/crates.io-index)" = "99ce87382f6c1a24b513a72c048b2c8efe66cb5161c9061d00bee510f08dc168"
"checksum tokio-uds 0.2.4 (registry+https://github.com/rust-lang/crates.io-index)" = "99ce87382f6c1a24b513a72c048b2c8efe66cb5161c9061d00bee510f08dc168"
"checksum tokio-xmpp 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)" = "c27385c4781afc851c61ac66d79463c511bf073d3a5d71b8bfd13a816e475989"
"checksum tokio-uds 0.2.5 (registry+https://github.com/rust-lang/crates.io-index)" = "037ffc3ba0e12a0ab4aca92e5234e0dedeb48fddf6ccd260f1f150a36a9f2445"
"checksum tokio-xmpp 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)" = "838f8a47654f45fd3618288ebda6085578f783ae087d82f12c09e04f7513a690"
"checksum tokio-tls 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)" = "354b8cd83825b3c20217a9dc174d6a0c67441a2fae5c41bcb1ea6679f6ae0f7c"
"checksum tokio-tls 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)" = "e53fdbf3156f588be1676022fe794232b24922d426e8c14f4e46891c1e31c440"
"checksum tokio-tls 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)" = "e53fdbf3156f588be1676022fe794232b24922d426e8c14f4e46891c1e31c440"
"checksum tokio-tls 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)" = "354b8cd83825b3c20217a9dc174d6a0c67441a2fae5c41bcb1ea6679f6ae0f7c"
"checksum tokio-tcp 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)" = "1d14b10654be682ac43efee27401d792507e30fd8d26389e1da3b185de2e4119"
"checksum tokio-threadpool 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)" = "17465013014410310f9f61fa10bf4724803c149ea1d51efece131c38efca93aa"
"checksum tokio-tcp 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)" = "7ad235e9dadd126b2d47f6736f65aa1fdcd6420e66ca63f44177bc78df89f912"
"checksum tokio-threadpool 0.1.9 (registry+https://github.com/rust-lang/crates.io-index)" = "56c5556262383032878afad66943926a1d1f0967f17e94bd7764ceceb3b70e7f"
"checksum tokio-tcp 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)" = "7ad235e9dadd126b2d47f6736f65aa1fdcd6420e66ca63f44177bc78df89f912"
"checksum tokio-threadpool 0.1.9 (registry+https://github.com/rust-lang/crates.io-index)" = "56c5556262383032878afad66943926a1d1f0967f17e94bd7764ceceb3b70e7f"
"checksum tokio-tcp 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)" = "1d14b10654be682ac43efee27401d792507e30fd8d26389e1da3b185de2e4119"
"checksum tokio-threadpool 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)" = "17465013014410310f9f61fa10bf4724803c149ea1d51efece131c38efca93aa"
"checksum tokio-executor 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)" = "30c6dbf2d1ad1de300b393910e8a3aa272b724a400b6531da03eed99e329fbf0"
"checksum tokio-fs 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)" = "0e9cbbc8a3698b7ab652340f46633364f9eaa928ddaaee79d8b8f356dd79a09d"
"checksum tokio-io 0.1.11 (registry+https://github.com/rust-lang/crates.io-index)" = "b53aeb9d3f5ccf2ebb29e19788f96987fa1355f8fe45ea193928eaaaf3ae820f"
"checksum tokio-reactor 0.1.8 (registry+https://github.com/rust-lang/crates.io-index)" = "afbcdb0f0d2a1e4c440af82d7bbf0bf91a8a8c0575bcd20c05d15be7e9d3a02f"
"checksum tokio-executor 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)" = "c117b6cf86bb730aab4834f10df96e4dd586eff2c3c27d3781348da49e255bde"
"checksum tokio-fs 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)" = "60ae25f6b17d25116d2cba342083abe5255d3c2c79cb21ea11aa049c53bf7c75"
"checksum tokio-io 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)" = "7392fe0a70d5ce0c882c4778116c519bd5dbaa8a7c3ae3d04578b3afafdcda21"
"checksum tokio-reactor 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)" = "502b625acb4ee13cbb3b90b8ca80e0addd263ddacf6931666ef751e610b07fb5"
"checksum tokio-executor 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)" = "c117b6cf86bb730aab4834f10df96e4dd586eff2c3c27d3781348da49e255bde"
"checksum tokio-fs 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)" = "60ae25f6b17d25116d2cba342083abe5255d3c2c79cb21ea11aa049c53bf7c75"
"checksum tokio-io 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)" = "7392fe0a70d5ce0c882c4778116c519bd5dbaa8a7c3ae3d04578b3afafdcda21"
"checksum tokio-reactor 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)" = "502b625acb4ee13cbb3b90b8ca80e0addd263ddacf6931666ef751e610b07fb5"
"checksum tokio-executor 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)" = "30c6dbf2d1ad1de300b393910e8a3aa272b724a400b6531da03eed99e329fbf0"
"checksum tokio-fs 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)" = "0e9cbbc8a3698b7ab652340f46633364f9eaa928ddaaee79d8b8f356dd79a09d"
"checksum tokio-io 0.1.11 (registry+https://github.com/rust-lang/crates.io-index)" = "b53aeb9d3f5ccf2ebb29e19788f96987fa1355f8fe45ea193928eaaaf3ae820f"
"checksum tokio-reactor 0.1.8 (registry+https://github.com/rust-lang/crates.io-index)" = "afbcdb0f0d2a1e4c440af82d7bbf0bf91a8a8c0575bcd20c05d15be7e9d3a02f"
"checksum tokio-current-thread 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)" = "331c8acc267855ec06eb0c94618dcbbfea45bed2d20b77252940095273fb58f6"
"checksum tokio-current-thread 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)" = "c756b04680eea21902a46fca4e9f410a2332c04995af590e07ff262e2193a9a3"
"checksum time 0.1.42 (registry+https://github.com/rust-lang/crates.io-index)" = "db8dcfca086c1143c9270ac42a2bbd8a7ee477b78ac8e45b19abfb0cbede4b6f"
"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 0.1.17 (registry+https://github.com/rust-lang/crates.io-index)" = "1021bb1f4150435ab8f222eb7ed37c60b2d57037def63ba43085a79f387512d7"
"checksum tokio 0.1.16 (registry+https://github.com/rust-lang/crates.io-index)" = "fcaabb3cec70485d0df6e9454fe514393ad1c4070dee8915f11041e95630b230"
"checksum tokio 0.1.15 (registry+https://github.com/rust-lang/crates.io-index)" = "e0500b88064f08bebddd0c0bed39e19f5c567a5f30975bee52b0c0d3e2eeb38c"
"checksum tokio 0.1.15 (registry+https://github.com/rust-lang/crates.io-index)" = "e0500b88064f08bebddd0c0bed39e19f5c567a5f30975bee52b0c0d3e2eeb38c"
"checksum tokio 0.1.18 (registry+https://github.com/rust-lang/crates.io-index)" = "65641e515a437b308ab131a82ce3042ff9795bef5d6c5a9be4eb24195c417fd9"
"checksum tokio 0.1.15 (registry+https://github.com/rust-lang/crates.io-index)" = "e0500b88064f08bebddd0c0bed39e19f5c567a5f30975bee52b0c0d3e2eeb38c"
"checksum tokio 0.1.16 (registry+https://github.com/rust-lang/crates.io-index)" = "fcaabb3cec70485d0df6e9454fe514393ad1c4070dee8915f11041e95630b230"
"checksum time 0.1.42 (registry+https://github.com/rust-lang/crates.io-index)" = "db8dcfca086c1143c9270ac42a2bbd8a7ee477b78ac8e45b19abfb0cbede4b6f"
"checksum tokio 0.1.18 (registry+https://github.com/rust-lang/crates.io-index)" = "65641e515a437b308ab131a82ce3042ff9795bef5d6c5a9be4eb24195c417fd9"
"checksum tokio 0.1.16 (registry+https://github.com/rust-lang/crates.io-index)" = "fcaabb3cec70485d0df6e9454fe514393ad1c4070dee8915f11041e95630b230"
"checksum tokio 0.1.13 (registry+https://github.com/rust-lang/crates.io-index)" = "a7817d4c98cc5be21360b3b37d6036fe9b7aefa5b7a201b7b16ff33423822f7d"
"checksum time 0.1.42 (registry+https://github.com/rust-lang/crates.io-index)" = "db8dcfca086c1143c9270ac42a2bbd8a7ee477b78ac8e45b19abfb0cbede4b6f"
"checksum tokio 0.1.14 (registry+https://github.com/rust-lang/crates.io-index)" = "4790d0be6f4ba6ae4f48190efa2ed7780c9e3567796abdb285003cf39840d9c5"
"checksum time 0.1.40 (registry+https://github.com/rust-lang/crates.io-index)" = "d825be0eb33fda1a7e68012d51e9c7f451dc1a69391e7fdc197060bb8c56667b"
"checksum tokio 0.1.13 (registry+https://github.com/rust-lang/crates.io-index)" = "a7817d4c98cc5be21360b3b37d6036fe9b7aefa5b7a201b7b16ff33423822f7d"
"checksum time 0.1.40 (registry+https://github.com/rust-lang/crates.io-index)" = "d825be0eb33fda1a7e68012d51e9c7f451dc1a69391e7fdc197060bb8c56667b"
"checksum tokio 0.1.13 (registry+https://github.com/rust-lang/crates.io-index)" = "a7817d4c98cc5be21360b3b37d6036fe9b7aefa5b7a201b7b16ff33423822f7d"
"checksum textwrap 0.10.0 (registry+https://github.com/rust-lang/crates.io-index)" = "307686869c93e71f94da64286f9a9524c0f308a9e1c87a583de8e9c9039ad3f6"
"checksum textwrap 0.11.0 (registry+https://github.com/rust-lang/crates.io-index)" = "d326610f408c7a4eb6f51c37c330e496b08506c9457c9d34287ecc38809fb060"
"checksum textwrap 0.10.0 (registry+https://github.com/rust-lang/crates.io-index)" = "307686869c93e71f94da64286f9a9524c0f308a9e1c87a583de8e9c9039ad3f6"
"checksum textwrap 0.10.0 (registry+https://github.com/rust-lang/crates.io-index)" = "307686869c93e71f94da64286f9a9524c0f308a9e1c87a583de8e9c9039ad3f6"
"checksum time 0.1.41 (registry+https://github.com/rust-lang/crates.io-index)" = "847da467bf0db05882a9e2375934a8a55cffdc9db0d128af1518200260ba1f6c"
"checksum tokio-channel 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)" = "530d0fb87416dd531600f7cccc438bb35c5b91883065c9e6dca7cdecee991cfa"
"checksum time 0.1.40 (registry+https://github.com/rust-lang/crates.io-index)" = "d825be0eb33fda1a7e68012d51e9c7f451dc1a69391e7fdc197060bb8c56667b"
"checksum time 0.1.41 (registry+https://github.com/rust-lang/crates.io-index)" = "847da467bf0db05882a9e2375934a8a55cffdc9db0d128af1518200260ba1f6c"
"checksum time 0.1.42 (registry+https://github.com/rust-lang/crates.io-index)" = "db8dcfca086c1143c9270ac42a2bbd8a7ee477b78ac8e45b19abfb0cbede4b6f"
"checksum tokio 0.1.14 (registry+https://github.com/rust-lang/crates.io-index)" = "4790d0be6f4ba6ae4f48190efa2ed7780c9e3567796abdb285003cf39840d9c5"
"checksum time 0.1.41 (registry+https://github.com/rust-lang/crates.io-index)" = "847da467bf0db05882a9e2375934a8a55cffdc9db0d128af1518200260ba1f6c"
"checksum time 0.1.41 (registry+https://github.com/rust-lang/crates.io-index)" = "847da467bf0db05882a9e2375934a8a55cffdc9db0d128af1518200260ba1f6c"
"checksum time 0.1.40 (registry+https://github.com/rust-lang/crates.io-index)" = "d825be0eb33fda1a7e68012d51e9c7f451dc1a69391e7fdc197060bb8c56667b"
"checksum time 0.1.40 (registry+https://github.com/rust-lang/crates.io-index)" = "d825be0eb33fda1a7e68012d51e9c7f451dc1a69391e7fdc197060bb8c56667b"
"checksum time 0.1.40 (registry+https://github.com/rust-lang/crates.io-index)" = "d825be0eb33fda1a7e68012d51e9c7f451dc1a69391e7fdc197060bb8c56667b"
"checksum tokio 0.1.13 (registry+https://github.com/rust-lang/crates.io-index)" = "a7817d4c98cc5be21360b3b37d6036fe9b7aefa5b7a201b7b16ff33423822f7d"
"checksum time 0.1.40 (registry+https://github.com/rust-lang/crates.io-index)" = "d825be0eb33fda1a7e68012d51e9c7f451dc1a69391e7fdc197060bb8c56667b"
"checksum tokio 0.1.13 (registry+https://github.com/rust-lang/crates.io-index)" = "a7817d4c98cc5be21360b3b37d6036fe9b7aefa5b7a201b7b16ff33423822f7d"
"checksum time 0.1.42 (registry+https://github.com/rust-lang/crates.io-index)" = "db8dcfca086c1143c9270ac42a2bbd8a7ee477b78ac8e45b19abfb0cbede4b6f"
"checksum tokio 0.1.14 (registry+https://github.com/rust-lang/crates.io-index)" = "4790d0be6f4ba6ae4f48190efa2ed7780c9e3567796abdb285003cf39840d9c5"
"checksum time 0.1.40 (registry+https://github.com/rust-lang/crates.io-index)" = "d825be0eb33fda1a7e68012d51e9c7f451dc1a69391e7fdc197060bb8c56667b"
"checksum time 0.1.40 (registry+https://github.com/rust-lang/crates.io-index)" = "d825be0eb33fda1a7e68012d51e9c7f451dc1a69391e7fdc197060bb8c56667b"
"checksum thread_local 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)" = "c6b53e329000edc2b34dbe8545fd20e55a333362d0a321909685a19bd28c3f1b"
"checksum thread_local 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)" = "c6b53e329000edc2b34dbe8545fd20e55a333362d0a321909685a19bd28c3f1b"
"checksum tendril 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)" = "9de21546595a0873061940d994bbbc5c35f024ae4fd61ec5c5b159115684f508"
"checksum termion 1.5.1 (registry+https://github.com/rust-lang/crates.io-index)" = "689a3bdfaab439fd92bc87df5c4c78417d3cbe537487274e9b0b2dce76e92096"
"checksum synstructure 0.10.1 (registry+https://github.com/rust-lang/crates.io-index)" = "73687139bf99285483c96ac0add482c3776528beac1d97d444f6e91f203a2015"
"checksum tendril 0.4.1 (registry+https://github.com/rust-lang/crates.io-index)" = "707feda9f2582d5d680d733e38755547a3e8fb471e7ba11452ecfd9ce93a5d3b"
"checksum tendril 0.4.1 (registry+https://github.com/rust-lang/crates.io-index)" = "707feda9f2582d5d680d733e38755547a3e8fb471e7ba11452ecfd9ce93a5d3b"
"checksum tendril 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)" = "9de21546595a0873061940d994bbbc5c35f024ae4fd61ec5c5b159115684f508"
"checksum tempfile 3.0.7 (registry+https://github.com/rust-lang/crates.io-index)" = "b86c784c88d98c801132806dadd3819ed29d8600836c4088e855cdf3e178ed8a"
"checksum tempfile 3.0.7 (registry+https://github.com/rust-lang/crates.io-index)" = "b86c784c88d98c801132806dadd3819ed29d8600836c4088e855cdf3e178ed8a"
"checksum tempfile 3.0.6 (registry+https://github.com/rust-lang/crates.io-index)" = "37daa55a7240c4931c84559f03b3cad7d19535840d1c4a0cc4e9b2fb0dcf70ff"
"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 tempfile 3.0.6 (registry+https://github.com/rust-lang/crates.io-index)" = "37daa55a7240c4931c84559f03b3cad7d19535840d1c4a0cc4e9b2fb0dcf70ff"
"checksum tempfile 3.0.5 (registry+https://github.com/rust-lang/crates.io-index)" = "7e91405c14320e5c79b3d148e1c86f40749a36e490642202a31689cb1a3452b2"
"checksum tempfile 3.0.7 (registry+https://github.com/rust-lang/crates.io-index)" = "b86c784c88d98c801132806dadd3819ed29d8600836c4088e855cdf3e178ed8a"
"checksum tempfile 3.0.5 (registry+https://github.com/rust-lang/crates.io-index)" = "7e91405c14320e5c79b3d148e1c86f40749a36e490642202a31689cb1a3452b2"
"checksum tendril 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)" = "9de21546595a0873061940d994bbbc5c35f024ae4fd61ec5c5b159115684f508"
"checksum tempfile 3.0.6 (registry+https://github.com/rust-lang/crates.io-index)" = "37daa55a7240c4931c84559f03b3cad7d19535840d1c4a0cc4e9b2fb0dcf70ff"
"checksum tempfile 3.0.7 (registry+https://github.com/rust-lang/crates.io-index)" = "b86c784c88d98c801132806dadd3819ed29d8600836c4088e855cdf3e178ed8a"
"checksum tempfile 3.0.6 (registry+https://github.com/rust-lang/crates.io-index)" = "37daa55a7240c4931c84559f03b3cad7d19535840d1c4a0cc4e9b2fb0dcf70ff"
"checksum synstructure 0.10.1 (registry+https://github.com/rust-lang/crates.io-index)" = "73687139bf99285483c96ac0add482c3776528beac1d97d444f6e91f203a2015"
"checksum tempfile 3.0.5 (registry+https://github.com/rust-lang/crates.io-index)" = "7e91405c14320e5c79b3d148e1c86f40749a36e490642202a31689cb1a3452b2"
"checksum termcolor 1.0.4 (registry+https://github.com/rust-lang/crates.io-index)" = "4096add70612622289f2fdcdbd5086dc81c1e2675e6ae58d6c4f62a16c6d7f2f"
"checksum tendril 0.4.1 (registry+https://github.com/rust-lang/crates.io-index)" = "707feda9f2582d5d680d733e38755547a3e8fb471e7ba11452ecfd9ce93a5d3b"
"checksum tendril 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)" = "9de21546595a0873061940d994bbbc5c35f024ae4fd61ec5c5b159115684f508"
"checksum tendril 0.4.1 (registry+https://github.com/rust-lang/crates.io-index)" = "707feda9f2582d5d680d733e38755547a3e8fb471e7ba11452ecfd9ce93a5d3b"
"checksum tendril 0.4.1 (registry+https://github.com/rust-lang/crates.io-index)" = "707feda9f2582d5d680d733e38755547a3e8fb471e7ba11452ecfd9ce93a5d3b"
"checksum tendril 0.4.1 (registry+https://github.com/rust-lang/crates.io-index)" = "707feda9f2582d5d680d733e38755547a3e8fb471e7ba11452ecfd9ce93a5d3b"
"checksum tendril 0.4.1 (registry+https://github.com/rust-lang/crates.io-index)" = "707feda9f2582d5d680d733e38755547a3e8fb471e7ba11452ecfd9ce93a5d3b"
"checksum tendril 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)" = "9de21546595a0873061940d994bbbc5c35f024ae4fd61ec5c5b159115684f508"
"checksum tendril 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)" = "9de21546595a0873061940d994bbbc5c35f024ae4fd61ec5c5b159115684f508"
"checksum tendril 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)" = "9de21546595a0873061940d994bbbc5c35f024ae4fd61ec5c5b159115684f508"
"checksum tendril 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)" = "9de21546595a0873061940d994bbbc5c35f024ae4fd61ec5c5b159115684f508"
"checksum tendril 0.4.1 (registry+https://github.com/rust-lang/crates.io-index)" = "707feda9f2582d5d680d733e38755547a3e8fb471e7ba11452ecfd9ce93a5d3b"
"checksum tendril 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)" = "9de21546595a0873061940d994bbbc5c35f024ae4fd61ec5c5b159115684f508"
"checksum syn 0.15.23 (registry+https://github.com/rust-lang/crates.io-index)" = "9545a6a093a3f0bd59adb472700acc08cad3776f860f16a897dfce8c88721cbc"
"checksum syn 0.15.22 (registry+https://github.com/rust-lang/crates.io-index)" = "ae8b29eb5210bc5cf63ed6149cbf9adfc82ac0be023d8735c176ee74a2db4da7"
"checksum syn 0.15.29 (registry+https://github.com/rust-lang/crates.io-index)" = "1825685f977249735d510a242a6727b46efe914bb67e38d30c071b1b72b1d5c2"
"checksum syn 0.15.28 (registry+https://github.com/rust-lang/crates.io-index)" = "218aa5a01ab9805df6e9e48074c8d88f317cc9660b1ad6c3dabac2d627d185d6"
"checksum syn 0.15.23 (registry+https://github.com/rust-lang/crates.io-index)" = "9545a6a093a3f0bd59adb472700acc08cad3776f860f16a897dfce8c88721cbc"
"checksum syn 0.15.26 (registry+https://github.com/rust-lang/crates.io-index)" = "f92e629aa1d9c827b2bb8297046c1ccffc57c99b947a680d3ccff1f136a3bee9"
"checksum syn 0.15.26 (registry+https://github.com/rust-lang/crates.io-index)" = "f92e629aa1d9c827b2bb8297046c1ccffc57c99b947a680d3ccff1f136a3bee9"
"checksum syn 0.15.30 (registry+https://github.com/rust-lang/crates.io-index)" = "66c8865bf5a7cbb662d8b011950060b3c8743dca141b054bf7195b20d314d8e2"
"checksum syn 0.15.23 (registry+https://github.com/rust-lang/crates.io-index)" = "9545a6a093a3f0bd59adb472700acc08cad3776f860f16a897dfce8c88721cbc"
"checksum syn 0.15.27 (registry+https://github.com/rust-lang/crates.io-index)" = "525bd55255f03c816e5d7f615587bd13030c7103354fadb104993dcee6a788ec"
"checksum syn 0.15.26 (registry+https://github.com/rust-lang/crates.io-index)" = "f92e629aa1d9c827b2bb8297046c1ccffc57c99b947a680d3ccff1f136a3bee9"
"checksum syn 0.15.22 (registry+https://github.com/rust-lang/crates.io-index)" = "ae8b29eb5210bc5cf63ed6149cbf9adfc82ac0be023d8735c176ee74a2db4da7"
"checksum syn 0.15.23 (registry+https://github.com/rust-lang/crates.io-index)" = "9545a6a093a3f0bd59adb472700acc08cad3776f860f16a897dfce8c88721cbc"
"checksum syn 0.15.26 (registry+https://github.com/rust-lang/crates.io-index)" = "f92e629aa1d9c827b2bb8297046c1ccffc57c99b947a680d3ccff1f136a3bee9"
"checksum syn 0.15.30 (registry+https://github.com/rust-lang/crates.io-index)" = "66c8865bf5a7cbb662d8b011950060b3c8743dca141b054bf7195b20d314d8e2"
"checksum syn 0.15.22 (registry+https://github.com/rust-lang/crates.io-index)" = "ae8b29eb5210bc5cf63ed6149cbf9adfc82ac0be023d8735c176ee74a2db4da7"
"checksum syn 0.15.22 (registry+https://github.com/rust-lang/crates.io-index)" = "ae8b29eb5210bc5cf63ed6149cbf9adfc82ac0be023d8735c176ee74a2db4da7"
"checksum syn 0.15.22 (registry+https://github.com/rust-lang/crates.io-index)" = "ae8b29eb5210bc5cf63ed6149cbf9adfc82ac0be023d8735c176ee74a2db4da7"
"checksum syn 0.15.22 (registry+https://github.com/rust-lang/crates.io-index)" = "ae8b29eb5210bc5cf63ed6149cbf9adfc82ac0be023d8735c176ee74a2db4da7"
"checksum synom 0.11.3 (registry+https://github.com/rust-lang/crates.io-index)" = "a393066ed9010ebaed60b9eafa373d4b1baac186dd7e008555b0f702b51945b6"
"checksum syn 0.11.11 (registry+https://github.com/rust-lang/crates.io-index)" = "d3b891b9015c88c576343b9b3e41c2c11a51c219ef067b264bd9c8aa9b441dad"
"checksum syn 0.15.26 (registry+https://github.com/rust-lang/crates.io-index)" = "f92e629aa1d9c827b2bb8297046c1ccffc57c99b947a680d3ccff1f136a3bee9"
"checksum syn 0.15.27 (registry+https://github.com/rust-lang/crates.io-index)" = "525bd55255f03c816e5d7f615587bd13030c7103354fadb104993dcee6a788ec"
"checksum syn 0.15.22 (registry+https://github.com/rust-lang/crates.io-index)" = "ae8b29eb5210bc5cf63ed6149cbf9adfc82ac0be023d8735c176ee74a2db4da7"
"checksum syn 0.15.22 (registry+https://github.com/rust-lang/crates.io-index)" = "ae8b29eb5210bc5cf63ed6149cbf9adfc82ac0be023d8735c176ee74a2db4da7"
"checksum syn 0.15.26 (registry+https://github.com/rust-lang/crates.io-index)" = "f92e629aa1d9c827b2bb8297046c1ccffc57c99b947a680d3ccff1f136a3bee9"
"checksum syn 0.15.22 (registry+https://github.com/rust-lang/crates.io-index)" = "ae8b29eb5210bc5cf63ed6149cbf9adfc82ac0be023d8735c176ee74a2db4da7"
"checksum syn 0.15.27 (registry+https://github.com/rust-lang/crates.io-index)" = "525bd55255f03c816e5d7f615587bd13030c7103354fadb104993dcee6a788ec"
"checksum subtle 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)" = "2d67a5a62ba6e01cb2192ff309324cb4875d0c451d55fe2319433abe7a05a8ee"
"checksum strsim 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)" = "bb4f380125926a99e52bc279241539c018323fab05ad6368b56f93d9369ff550"
"checksum strsim 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)" = "8ea5119cdb4c55b55d432abb513a0429384878c15dde60cc77b1c99de1a95a6a"
"checksum strsim 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)" = "bb4f380125926a99e52bc279241539c018323fab05ad6368b56f93d9369ff550"
"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 subtle 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)" = "2d67a5a62ba6e01cb2192ff309324cb4875d0c451d55fe2319433abe7a05a8ee"
"checksum subtle 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)" = "2d67a5a62ba6e01cb2192ff309324cb4875d0c451d55fe2319433abe7a05a8ee"
"checksum subtle 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)" = "2d67a5a62ba6e01cb2192ff309324cb4875d0c451d55fe2319433abe7a05a8ee"
"checksum string 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)" = "b639411d0b9c738748b5397d5ceba08e648f4f1992231aa859af1a017f31f60b"
"checksum string 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)" = "b639411d0b9c738748b5397d5ceba08e648f4f1992231aa859af1a017f31f60b"
"checksum string 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)" = "b639411d0b9c738748b5397d5ceba08e648f4f1992231aa859af1a017f31f60b"
"checksum string 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)" = "98998cced76115b1da46f63388b909d118a37ae0be0f82ad35773d4a4bc9d18d"
"checksum string 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)" = "b639411d0b9c738748b5397d5ceba08e648f4f1992231aa859af1a017f31f60b"
"checksum string 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)" = "98998cced76115b1da46f63388b909d118a37ae0be0f82ad35773d4a4bc9d18d"
"checksum string 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)" = "98998cced76115b1da46f63388b909d118a37ae0be0f82ad35773d4a4bc9d18d"
"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 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.2 (registry+https://github.com/rust-lang/crates.io-index)" = "98998cced76115b1da46f63388b909d118a37ae0be0f82ad35773d4a4bc9d18d"
"checksum string 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)" = "98998cced76115b1da46f63388b909d118a37ae0be0f82ad35773d4a4bc9d18d"
"checksum string 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)" = "b639411d0b9c738748b5397d5ceba08e648f4f1992231aa859af1a017f31f60b"
"checksum smallvec 0.6.5 (registry+https://github.com/rust-lang/crates.io-index)" = "153ffa32fd170e9944f7e0838edf824a754ec4c1fc64746fcc9fe1f8fa602e5d"
"checksum smallvec 0.6.6 (registry+https://github.com/rust-lang/crates.io-index)" = "622df2d454c29a4d89b30dc3b27b42d7d90d6b9e587dbf8f67652eb7514da484"
"checksum slab 0.4.2 (registry+https://github.com/rust-lang/crates.io-index)" = "c111b5bd5695e56cffe5129854aa230b39c93a305372fdbb2668ca2394eea9f8"
"checksum smallvec 0.6.8 (registry+https://github.com/rust-lang/crates.io-index)" = "88aea073965ab29f6edb5493faf96ad662fb18aa9eeb186a3b7057951605ed15"
"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 smallvec 0.6.9 (registry+https://github.com/rust-lang/crates.io-index)" = "c4488ae950c49d403731982257768f48fada354a5203fe81f9bb6f43ca9002be"
"checksum smallvec 0.6.8 (registry+https://github.com/rust-lang/crates.io-index)" = "88aea073965ab29f6edb5493faf96ad662fb18aa9eeb186a3b7057951605ed15"
"checksum smallvec 0.6.8 (registry+https://github.com/rust-lang/crates.io-index)" = "88aea073965ab29f6edb5493faf96ad662fb18aa9eeb186a3b7057951605ed15"
"checksum smallvec 0.6.9 (registry+https://github.com/rust-lang/crates.io-index)" = "c4488ae950c49d403731982257768f48fada354a5203fe81f9bb6f43ca9002be"
"checksum smallvec 0.6.8 (registry+https://github.com/rust-lang/crates.io-index)" = "88aea073965ab29f6edb5493faf96ad662fb18aa9eeb186a3b7057951605ed15"
"checksum smallvec 0.6.9 (registry+https://github.com/rust-lang/crates.io-index)" = "c4488ae950c49d403731982257768f48fada354a5203fe81f9bb6f43ca9002be"
"checksum smallvec 0.6.8 (registry+https://github.com/rust-lang/crates.io-index)" = "88aea073965ab29f6edb5493faf96ad662fb18aa9eeb186a3b7057951605ed15"
"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 slab 0.4.2 (registry+https://github.com/rust-lang/crates.io-index)" = "c111b5bd5695e56cffe5129854aa230b39c93a305372fdbb2668ca2394eea9f8"
"checksum smallvec 0.6.8 (registry+https://github.com/rust-lang/crates.io-index)" = "88aea073965ab29f6edb5493faf96ad662fb18aa9eeb186a3b7057951605ed15"
"checksum slab 0.4.1 (registry+https://github.com/rust-lang/crates.io-index)" = "5f9776d6b986f77b35c6cf846c11ad986ff128fe0b2b63a3628e3755e8d3102d"
"checksum smallvec 0.6.6 (registry+https://github.com/rust-lang/crates.io-index)" = "622df2d454c29a4d89b30dc3b27b42d7d90d6b9e587dbf8f67652eb7514da484"
"checksum slab 0.4.1 (registry+https://github.com/rust-lang/crates.io-index)" = "5f9776d6b986f77b35c6cf846c11ad986ff128fe0b2b63a3628e3755e8d3102d"
"checksum smallvec 0.6.7 (registry+https://github.com/rust-lang/crates.io-index)" = "b73ea3738b47563803ef814925e69be00799a8c07420be8b996f8e98fb2336db"
"checksum smallvec 0.6.6 (registry+https://github.com/rust-lang/crates.io-index)" = "622df2d454c29a4d89b30dc3b27b42d7d90d6b9e587dbf8f67652eb7514da484"
"checksum smallvec 0.6.7 (registry+https://github.com/rust-lang/crates.io-index)" = "b73ea3738b47563803ef814925e69be00799a8c07420be8b996f8e98fb2336db"
"checksum smallvec 0.6.7 (registry+https://github.com/rust-lang/crates.io-index)" = "b73ea3738b47563803ef814925e69be00799a8c07420be8b996f8e98fb2336db"
"checksum smallvec 0.6.7 (registry+https://github.com/rust-lang/crates.io-index)" = "b73ea3738b47563803ef814925e69be00799a8c07420be8b996f8e98fb2336db"
"checksum smallvec 0.6.6 (registry+https://github.com/rust-lang/crates.io-index)" = "622df2d454c29a4d89b30dc3b27b42d7d90d6b9e587dbf8f67652eb7514da484"
"checksum smallvec 0.6.6 (registry+https://github.com/rust-lang/crates.io-index)" = "622df2d454c29a4d89b30dc3b27b42d7d90d6b9e587dbf8f67652eb7514da484"
"checksum smallvec 0.6.6 (registry+https://github.com/rust-lang/crates.io-index)" = "622df2d454c29a4d89b30dc3b27b42d7d90d6b9e587dbf8f67652eb7514da484"
"checksum smallvec 0.6.6 (registry+https://github.com/rust-lang/crates.io-index)" = "622df2d454c29a4d89b30dc3b27b42d7d90d6b9e587dbf8f67652eb7514da484"
"checksum siphasher 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)" = "0b8de496cf83d4ed58b6be86c3a275b8602f6ffe98d3024a869e124147a9a3ac"
"checksum slab 0.4.1 (registry+https://github.com/rust-lang/crates.io-index)" = "5f9776d6b986f77b35c6cf846c11ad986ff128fe0b2b63a3628e3755e8d3102d"
"checksum smallvec 0.6.6 (registry+https://github.com/rust-lang/crates.io-index)" = "622df2d454c29a4d89b30dc3b27b42d7d90d6b9e587dbf8f67652eb7514da484"
"checksum slab 0.4.1 (registry+https://github.com/rust-lang/crates.io-index)" = "5f9776d6b986f77b35c6cf846c11ad986ff128fe0b2b63a3628e3755e8d3102d"
"checksum smallvec 0.6.6 (registry+https://github.com/rust-lang/crates.io-index)" = "622df2d454c29a4d89b30dc3b27b42d7d90d6b9e587dbf8f67652eb7514da484"
"checksum slab 0.4.2 (registry+https://github.com/rust-lang/crates.io-index)" = "c111b5bd5695e56cffe5129854aa230b39c93a305372fdbb2668ca2394eea9f8"
"checksum smallvec 0.6.8 (registry+https://github.com/rust-lang/crates.io-index)" = "88aea073965ab29f6edb5493faf96ad662fb18aa9eeb186a3b7057951605ed15"
"checksum signal-hook 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)" = "f7ca1f1c0ed6c8beaab713ad902c041e4f09d06e1b4bb74c5fc553c078ed0110"
"checksum signal-hook 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)" = "8941ae94fa73d0f73b422774b3a40a7195cecd88d1c090f4b37ade7dc795ab66"
"checksum serde_json 1.0.32 (registry+https://github.com/rust-lang/crates.io-index)" = "43344e7ce05d0d8280c5940cabb4964bea626aa58b1ec0e8c73fa2a8512a38ce"
"checksum serde_json 1.0.33 (registry+https://github.com/rust-lang/crates.io-index)" = "c37ccd6be3ed1fdf419ee848f7c758eb31b054d7cd3ae3600e3bae0adf569811"
"checksum serde 1.0.83 (registry+https://github.com/rust-lang/crates.io-index)" = "157e12af46859e968da75dea9845530e13d03bcab2009a41b9b7bb3cf4eb3ec2"
"checksum serde_derive 1.0.83 (registry+https://github.com/rust-lang/crates.io-index)" = "9469829702497daf2daf3c190e130c3fa72f719920f73c86160d43e8f8d76951"
"checksum signal-hook 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)" = "1f272d1b7586bec132ed427f532dd418d8beca1ca7f2caf7df35569b1415a4b4"
"checksum signal-hook 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)" = "8941ae94fa73d0f73b422774b3a40a7195cecd88d1c090f4b37ade7dc795ab66"
"checksum signal-hook 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)" = "1f272d1b7586bec132ed427f532dd418d8beca1ca7f2caf7df35569b1415a4b4"
"checksum signal-hook 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)" = "1f272d1b7586bec132ed427f532dd418d8beca1ca7f2caf7df35569b1415a4b4"
"checksum signal-hook 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)" = "8941ae94fa73d0f73b422774b3a40a7195cecd88d1c090f4b37ade7dc795ab66"
"checksum signal-hook 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)" = "8941ae94fa73d0f73b422774b3a40a7195cecd88d1c090f4b37ade7dc795ab66"
"checksum sha-1 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)" = "51b9d1f3b5de8a167ab06834a7c883bd197f2191e1dda1a22d9ccfeedbf9aded"
"checksum sha2 0.7.1 (registry+https://github.com/rust-lang/crates.io-index)" = "9eb6be24e4c23a84d7184280d2722f7f2731fcdd4a9d886efbfe4413e4847ea0"
"checksum sha3 0.7.3 (registry+https://github.com/rust-lang/crates.io-index)" = "b64dcef59ed4290b9fb562b53df07f564690d6539e8ecdd4728cf392477530bc"
"checksum signal-hook 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)" = "8941ae94fa73d0f73b422774b3a40a7195cecd88d1c090f4b37ade7dc795ab66"
"checksum serde_json 1.0.34 (registry+https://github.com/rust-lang/crates.io-index)" = "bdf540260cfee6da923831f4776ddc495ada940c30117977c70f1313a6130545"
"checksum serde 1.0.80 (registry+https://github.com/rust-lang/crates.io-index)" = "15c141fc7027dd265a47c090bf864cf62b42c4d228bbcf4e51a0c9e2b0d3f7ef"
"checksum serde_derive 1.0.80 (registry+https://github.com/rust-lang/crates.io-index)" = "225de307c6302bec3898c51ca302fc94a7a1697ef0845fcee6448f33c032249c"
"checksum serde 1.0.88 (registry+https://github.com/rust-lang/crates.io-index)" = "9f301d728f2b94c9a7691c90f07b0b4e8a4517181d9461be94c04bddeb4bd850"
"checksum serde_derive 1.0.88 (registry+https://github.com/rust-lang/crates.io-index)" = "beed18e6f5175aef3ba670e57c60ef3b1b74d250d962a26604bff4c80e970dd4"
"checksum signal-hook 0.1.8 (registry+https://github.com/rust-lang/crates.io-index)" = "97a47ae722318beceb0294e6f3d601205a1e6abaa4437d9d33e3a212233e3021"
"checksum signal-hook 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)" = "1f272d1b7586bec132ed427f532dd418d8beca1ca7f2caf7df35569b1415a4b4"
"checksum sha-1 0.8.1 (registry+https://github.com/rust-lang/crates.io-index)" = "23962131a91661d643c98940b20fcaffe62d776a823247be80a48fcb8b6fce68"
"checksum sha2 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)" = "7b4d8bfd0e469f417657573d8451fb33d16cfe0989359b93baf3a1ffc639543d"
"checksum sha3 0.8.1 (registry+https://github.com/rust-lang/crates.io-index)" = "34a5e54083ce2b934bf059fdf38e7330a154177e029ab6c4e18638f2f624053a"
"checksum signal-hook 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)" = "1f272d1b7586bec132ed427f532dd418d8beca1ca7f2caf7df35569b1415a4b4"
"checksum signal-hook 0.1.8 (registry+https://github.com/rust-lang/crates.io-index)" = "97a47ae722318beceb0294e6f3d601205a1e6abaa4437d9d33e3a212233e3021"
"checksum signal-hook 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)" = "1f272d1b7586bec132ed427f532dd418d8beca1ca7f2caf7df35569b1415a4b4"
"checksum signal-hook 0.1.8 (registry+https://github.com/rust-lang/crates.io-index)" = "97a47ae722318beceb0294e6f3d601205a1e6abaa4437d9d33e3a212233e3021"
"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 serde 1.0.82 (registry+https://github.com/rust-lang/crates.io-index)" = "6fa52f19aee12441d5ad11c9a00459122bd8f98707cadf9778c540674f1935b6"
"checksum serde_derive 1.0.82 (registry+https://github.com/rust-lang/crates.io-index)" = "96a7f9496ac65a2db5929afa087b54f8fc5008dcfbe48a8874ed20049b0d6154"
"checksum serde 1.0.85 (registry+https://github.com/rust-lang/crates.io-index)" = "534b8b91a95e0f71bca3ed5824752d558da048d4248c91af873b63bd60519752"
"checksum serde_derive 1.0.85 (registry+https://github.com/rust-lang/crates.io-index)" = "a915306b0f1ac5607797697148c223bedeaa36bcc2e28a01441cd638cc6567b4"
"checksum serde_json 1.0.36 (registry+https://github.com/rust-lang/crates.io-index)" = "574378d957d6dcdf1bbb5d562a15cbd5e644159432f84634b94e485267abbcc7"
"checksum sha-1 0.8.1 (registry+https://github.com/rust-lang/crates.io-index)" = "23962131a91661d643c98940b20fcaffe62d776a823247be80a48fcb8b6fce68"
"checksum sha2 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)" = "7b4d8bfd0e469f417657573d8451fb33d16cfe0989359b93baf3a1ffc639543d"
"checksum sha3 0.8.1 (registry+https://github.com/rust-lang/crates.io-index)" = "34a5e54083ce2b934bf059fdf38e7330a154177e029ab6c4e18638f2f624053a"
"checksum signal-hook 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)" = "1f272d1b7586bec132ed427f532dd418d8beca1ca7f2caf7df35569b1415a4b4"
"checksum serde 1.0.87 (registry+https://github.com/rust-lang/crates.io-index)" = "2e20fde37801e83c891a2dc4ebd3b81f0da4d1fb67a9e0a2a3b921e2536a58ee"
"checksum serde_derive 1.0.87 (registry+https://github.com/rust-lang/crates.io-index)" = "633e97856567e518b59ffb2ad7c7a4fd4c5d91d9c7f32dd38a27b2bf7e8114ea"
"checksum serde_json 1.0.38 (registry+https://github.com/rust-lang/crates.io-index)" = "27dce848e7467aa0e2fcaf0a413641499c0b745452aaca1194d24dedde9e13c9"
"checksum serde 1.0.90 (registry+https://github.com/rust-lang/crates.io-index)" = "aa5f7c20820475babd2c077c3ab5f8c77a31c15e16ea38687b4c02d3e48680f4"
"checksum serde_derive 1.0.90 (registry+https://github.com/rust-lang/crates.io-index)" = "58fc82bec244f168b23d1963b45c8bf5726e9a15a9d146a067f9081aeed2de79"
"checksum serde_json 1.0.39 (registry+https://github.com/rust-lang/crates.io-index)" = "5a23aa71d4a4d43fdbfaac00eff68ba8a06a51759a89ac3304323e800c4dd40d"
"checksum sha-1 0.8.1 (registry+https://github.com/rust-lang/crates.io-index)" = "23962131a91661d643c98940b20fcaffe62d776a823247be80a48fcb8b6fce68"
"checksum sha2 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)" = "7b4d8bfd0e469f417657573d8451fb33d16cfe0989359b93baf3a1ffc639543d"
"checksum sha3 0.8.1 (registry+https://github.com/rust-lang/crates.io-index)" = "34a5e54083ce2b934bf059fdf38e7330a154177e029ab6c4e18638f2f624053a"
"checksum signal-hook 0.1.8 (registry+https://github.com/rust-lang/crates.io-index)" = "97a47ae722318beceb0294e6f3d601205a1e6abaa4437d9d33e3a212233e3021"
"checksum serde 1.0.83 (registry+https://github.com/rust-lang/crates.io-index)" = "157e12af46859e968da75dea9845530e13d03bcab2009a41b9b7bb3cf4eb3ec2"
"checksum serde_derive 1.0.83 (registry+https://github.com/rust-lang/crates.io-index)" = "9469829702497daf2daf3c190e130c3fa72f719920f73c86160d43e8f8d76951"
"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 1.0.87 (registry+https://github.com/rust-lang/crates.io-index)" = "2e20fde37801e83c891a2dc4ebd3b81f0da4d1fb67a9e0a2a3b921e2536a58ee"
"checksum serde_derive 1.0.87 (registry+https://github.com/rust-lang/crates.io-index)" = "633e97856567e518b59ffb2ad7c7a4fd4c5d91d9c7f32dd38a27b2bf7e8114ea"
"checksum serde_json 1.0.38 (registry+https://github.com/rust-lang/crates.io-index)" = "27dce848e7467aa0e2fcaf0a413641499c0b745452aaca1194d24dedde9e13c9"
"checksum serde 1.0.83 (registry+https://github.com/rust-lang/crates.io-index)" = "157e12af46859e968da75dea9845530e13d03bcab2009a41b9b7bb3cf4eb3ec2"
"checksum serde_derive 1.0.83 (registry+https://github.com/rust-lang/crates.io-index)" = "9469829702497daf2daf3c190e130c3fa72f719920f73c86160d43e8f8d76951"
"checksum serde 1.0.85 (registry+https://github.com/rust-lang/crates.io-index)" = "534b8b91a95e0f71bca3ed5824752d558da048d4248c91af873b63bd60519752"
"checksum serde_derive 1.0.85 (registry+https://github.com/rust-lang/crates.io-index)" = "a915306b0f1ac5607797697148c223bedeaa36bcc2e28a01441cd638cc6567b4"
"checksum serde_json 1.0.36 (registry+https://github.com/rust-lang/crates.io-index)" = "574378d957d6dcdf1bbb5d562a15cbd5e644159432f84634b94e485267abbcc7"
"checksum sha-1 0.8.1 (registry+https://github.com/rust-lang/crates.io-index)" = "23962131a91661d643c98940b20fcaffe62d776a823247be80a48fcb8b6fce68"
"checksum sha2 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)" = "7b4d8bfd0e469f417657573d8451fb33d16cfe0989359b93baf3a1ffc639543d"
"checksum sha3 0.8.1 (registry+https://github.com/rust-lang/crates.io-index)" = "34a5e54083ce2b934bf059fdf38e7330a154177e029ab6c4e18638f2f624053a"
"checksum signal-hook 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)" = "1f272d1b7586bec132ed427f532dd418d8beca1ca7f2caf7df35569b1415a4b4"
"checksum serde 1.0.90 (registry+https://github.com/rust-lang/crates.io-index)" = "aa5f7c20820475babd2c077c3ab5f8c77a31c15e16ea38687b4c02d3e48680f4"
"checksum serde_derive 1.0.90 (registry+https://github.com/rust-lang/crates.io-index)" = "58fc82bec244f168b23d1963b45c8bf5726e9a15a9d146a067f9081aeed2de79"
"checksum serde_json 1.0.39 (registry+https://github.com/rust-lang/crates.io-index)" = "5a23aa71d4a4d43fdbfaac00eff68ba8a06a51759a89ac3304323e800c4dd40d"
"checksum serde 1.0.80 (registry+https://github.com/rust-lang/crates.io-index)" = "15c141fc7027dd265a47c090bf864cf62b42c4d228bbcf4e51a0c9e2b0d3f7ef"
"checksum serde_derive 1.0.80 (registry+https://github.com/rust-lang/crates.io-index)" = "225de307c6302bec3898c51ca302fc94a7a1697ef0845fcee6448f33c032249c"
"checksum serde_json 1.0.33 (registry+https://github.com/rust-lang/crates.io-index)" = "c37ccd6be3ed1fdf419ee848f7c758eb31b054d7cd3ae3600e3bae0adf569811"
"checksum sha-1 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)" = "51b9d1f3b5de8a167ab06834a7c883bd197f2191e1dda1a22d9ccfeedbf9aded"
"checksum sha2 0.7.1 (registry+https://github.com/rust-lang/crates.io-index)" = "9eb6be24e4c23a84d7184280d2722f7f2731fcdd4a9d886efbfe4413e4847ea0"
"checksum sha3 0.7.3 (registry+https://github.com/rust-lang/crates.io-index)" = "b64dcef59ed4290b9fb562b53df07f564690d6539e8ecdd4728cf392477530bc"
"checksum signal-hook 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)" = "8941ae94fa73d0f73b422774b3a40a7195cecd88d1c090f4b37ade7dc795ab66"
"checksum serde 1.0.80 (registry+https://github.com/rust-lang/crates.io-index)" = "15c141fc7027dd265a47c090bf864cf62b42c4d228bbcf4e51a0c9e2b0d3f7ef"
"checksum serde_derive 1.0.80 (registry+https://github.com/rust-lang/crates.io-index)" = "225de307c6302bec3898c51ca302fc94a7a1697ef0845fcee6448f33c032249c"
"checksum serde 1.0.80 (registry+https://github.com/rust-lang/crates.io-index)" = "15c141fc7027dd265a47c090bf864cf62b42c4d228bbcf4e51a0c9e2b0d3f7ef"
"checksum serde_derive 1.0.80 (registry+https://github.com/rust-lang/crates.io-index)" = "225de307c6302bec3898c51ca302fc94a7a1697ef0845fcee6448f33c032249c"
"checksum serde 1.0.80 (registry+https://github.com/rust-lang/crates.io-index)" = "15c141fc7027dd265a47c090bf864cf62b42c4d228bbcf4e51a0c9e2b0d3f7ef"
"checksum serde_derive 1.0.80 (registry+https://github.com/rust-lang/crates.io-index)" = "225de307c6302bec3898c51ca302fc94a7a1697ef0845fcee6448f33c032249c"
"checksum serde_json 1.0.33 (registry+https://github.com/rust-lang/crates.io-index)" = "c37ccd6be3ed1fdf419ee848f7c758eb31b054d7cd3ae3600e3bae0adf569811"
"checksum serde 1.0.87 (registry+https://github.com/rust-lang/crates.io-index)" = "2e20fde37801e83c891a2dc4ebd3b81f0da4d1fb67a9e0a2a3b921e2536a58ee"
"checksum serde_derive 1.0.87 (registry+https://github.com/rust-lang/crates.io-index)" = "633e97856567e518b59ffb2ad7c7a4fd4c5d91d9c7f32dd38a27b2bf7e8114ea"
"checksum serde_json 1.0.38 (registry+https://github.com/rust-lang/crates.io-index)" = "27dce848e7467aa0e2fcaf0a413641499c0b745452aaca1194d24dedde9e13c9"
"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 serde 1.0.80 (registry+https://github.com/rust-lang/crates.io-index)" = "15c141fc7027dd265a47c090bf864cf62b42c4d228bbcf4e51a0c9e2b0d3f7ef"
"checksum serde_derive 1.0.80 (registry+https://github.com/rust-lang/crates.io-index)" = "225de307c6302bec3898c51ca302fc94a7a1697ef0845fcee6448f33c032249c"
"checksum serde_json 1.0.33 (registry+https://github.com/rust-lang/crates.io-index)" = "c37ccd6be3ed1fdf419ee848f7c758eb31b054d7cd3ae3600e3bae0adf569811"
"checksum sha-1 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)" = "51b9d1f3b5de8a167ab06834a7c883bd197f2191e1dda1a22d9ccfeedbf9aded"
"checksum sha2 0.7.1 (registry+https://github.com/rust-lang/crates.io-index)" = "9eb6be24e4c23a84d7184280d2722f7f2731fcdd4a9d886efbfe4413e4847ea0"
"checksum sha3 0.7.3 (registry+https://github.com/rust-lang/crates.io-index)" = "b64dcef59ed4290b9fb562b53df07f564690d6539e8ecdd4728cf392477530bc"
"checksum signal-hook 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)" = "8941ae94fa73d0f73b422774b3a40a7195cecd88d1c090f4b37ade7dc795ab66"
"checksum serde 1.0.80 (registry+https://github.com/rust-lang/crates.io-index)" = "15c141fc7027dd265a47c090bf864cf62b42c4d228bbcf4e51a0c9e2b0d3f7ef"
"checksum serde_derive 1.0.80 (registry+https://github.com/rust-lang/crates.io-index)" = "225de307c6302bec3898c51ca302fc94a7a1697ef0845fcee6448f33c032249c"
"checksum serde_json 1.0.33 (registry+https://github.com/rust-lang/crates.io-index)" = "c37ccd6be3ed1fdf419ee848f7c758eb31b054d7cd3ae3600e3bae0adf569811"
"checksum sha-1 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)" = "51b9d1f3b5de8a167ab06834a7c883bd197f2191e1dda1a22d9ccfeedbf9aded"
"checksum sha2 0.7.1 (registry+https://github.com/rust-lang/crates.io-index)" = "9eb6be24e4c23a84d7184280d2722f7f2731fcdd4a9d886efbfe4413e4847ea0"
"checksum sha3 0.7.3 (registry+https://github.com/rust-lang/crates.io-index)" = "b64dcef59ed4290b9fb562b53df07f564690d6539e8ecdd4728cf392477530bc"
"checksum signal-hook 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)" = "8941ae94fa73d0f73b422774b3a40a7195cecd88d1c090f4b37ade7dc795ab66"
"checksum serde 1.0.85 (registry+https://github.com/rust-lang/crates.io-index)" = "534b8b91a95e0f71bca3ed5824752d558da048d4248c91af873b63bd60519752"
"checksum serde_derive 1.0.85 (registry+https://github.com/rust-lang/crates.io-index)" = "a915306b0f1ac5607797697148c223bedeaa36bcc2e28a01441cd638cc6567b4"
"checksum serde_json 1.0.36 (registry+https://github.com/rust-lang/crates.io-index)" = "574378d957d6dcdf1bbb5d562a15cbd5e644159432f84634b94e485267abbcc7"
"checksum sha-1 0.8.1 (registry+https://github.com/rust-lang/crates.io-index)" = "23962131a91661d643c98940b20fcaffe62d776a823247be80a48fcb8b6fce68"
"checksum sha2 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)" = "7b4d8bfd0e469f417657573d8451fb33d16cfe0989359b93baf3a1ffc639543d"
"checksum sha3 0.8.1 (registry+https://github.com/rust-lang/crates.io-index)" = "34a5e54083ce2b934bf059fdf38e7330a154177e029ab6c4e18638f2f624053a"
"checksum signal-hook 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)" = "1f272d1b7586bec132ed427f532dd418d8beca1ca7f2caf7df35569b1415a4b4"
"checksum serde 1.0.80 (registry+https://github.com/rust-lang/crates.io-index)" = "15c141fc7027dd265a47c090bf864cf62b42c4d228bbcf4e51a0c9e2b0d3f7ef"
"checksum serde_derive 1.0.80 (registry+https://github.com/rust-lang/crates.io-index)" = "225de307c6302bec3898c51ca302fc94a7a1697ef0845fcee6448f33c032249c"
"checksum serde_json 1.0.33 (registry+https://github.com/rust-lang/crates.io-index)" = "c37ccd6be3ed1fdf419ee848f7c758eb31b054d7cd3ae3600e3bae0adf569811"
"checksum serde 1.0.87 (registry+https://github.com/rust-lang/crates.io-index)" = "2e20fde37801e83c891a2dc4ebd3b81f0da4d1fb67a9e0a2a3b921e2536a58ee"
"checksum serde_derive 1.0.87 (registry+https://github.com/rust-lang/crates.io-index)" = "633e97856567e518b59ffb2ad7c7a4fd4c5d91d9c7f32dd38a27b2bf7e8114ea"
"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 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 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 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 security-framework 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)" = "697d3f3c23a618272ead9e1fb259c1411102b31c6af8b93f1d64cca9c3b0e8e0"
"checksum security-framework-sys 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)" = "ab01dfbe5756785b5b4d46e0289e5a18071dfa9a7c2b24213ea00b9ef9b665bf"
"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 security-framework 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)" = "697d3f3c23a618272ead9e1fb259c1411102b31c6af8b93f1d64cca9c3b0e8e0"
"checksum security-framework-sys 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)" = "40d95f3d7da09612affe897f320d78264f0d2320f3e8eea27d12bd1bd94445e2"
"checksum security-framework-sys 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)" = "ab01dfbe5756785b5b4d46e0289e5a18071dfa9a7c2b24213ea00b9ef9b665bf"
"checksum security-framework-sys 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)" = "40d95f3d7da09612affe897f320d78264f0d2320f3e8eea27d12bd1bd94445e2"
"checksum security-framework-sys 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)" = "40d95f3d7da09612affe897f320d78264f0d2320f3e8eea27d12bd1bd94445e2"
"checksum security-framework-sys 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)" = "ab01dfbe5756785b5b4d46e0289e5a18071dfa9a7c2b24213ea00b9ef9b665bf"
"checksum security-framework-sys 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)" = "ab01dfbe5756785b5b4d46e0289e5a18071dfa9a7c2b24213ea00b9ef9b665bf"
"checksum security-framework-sys 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)" = "ab01dfbe5756785b5b4d46e0289e5a18071dfa9a7c2b24213ea00b9ef9b665bf"
"checksum security-framework 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)" = "697d3f3c23a618272ead9e1fb259c1411102b31c6af8b93f1d64cca9c3b0e8e0"
"checksum security-framework-sys 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)" = "ab01dfbe5756785b5b4d46e0289e5a18071dfa9a7c2b24213ea00b9ef9b665bf"
"checksum security-framework 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)" = "697d3f3c23a618272ead9e1fb259c1411102b31c6af8b93f1d64cca9c3b0e8e0"
"checksum security-framework-sys 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)" = "ab01dfbe5756785b5b4d46e0289e5a18071dfa9a7c2b24213ea00b9ef9b665bf"
"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 scopeguard 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)" = "94258f53601af11e6a49f722422f6e3425c52b06245a5cf9bc09908b174f5e27"
"checksum safemem 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)" = "8dca453248a96cb0749e36ccdfe2b0b4e54a61bfef89fb97ec621eb8e0a93dd9"
"checksum sasl 0.4.2 (registry+https://github.com/rust-lang/crates.io-index)" = "4dbda5436dcd059da44fbf84b87a7164c5e3cad354efd0630c1f2be3c51c8859"
"checksum ryu 0.2.7 (registry+https://github.com/rust-lang/crates.io-index)" = "eb9e9b8cde282a9fe6a42dd4681319bfb63f121b8a8ee9439c6f4107e58a46f7"
"checksum schannel 0.1.15 (registry+https://github.com/rust-lang/crates.io-index)" = "f2f6abf258d99c3c1c5c2131d99d064e94b7b3dd5f416483057f308fea253339"
"checksum schannel 0.1.14 (registry+https://github.com/rust-lang/crates.io-index)" = "0e1a231dc10abf6749cfa5d7767f25888d484201accbd919b66ab5413c502d56"
"checksum schannel 0.1.15 (registry+https://github.com/rust-lang/crates.io-index)" = "f2f6abf258d99c3c1c5c2131d99d064e94b7b3dd5f416483057f308fea253339"
"checksum schannel 0.1.14 (registry+https://github.com/rust-lang/crates.io-index)" = "0e1a231dc10abf6749cfa5d7767f25888d484201accbd919b66ab5413c502d56"
"checksum schannel 0.1.15 (registry+https://github.com/rust-lang/crates.io-index)" = "f2f6abf258d99c3c1c5c2131d99d064e94b7b3dd5f416483057f308fea253339"
"checksum sasl 0.4.3 (registry+https://github.com/rust-lang/crates.io-index)" = "e457758c85b736bbad56dc099406cd2a9c19554cf81880dba7a51d092929e600"
"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 sasl 0.4.3 (registry+https://github.com/rust-lang/crates.io-index)" = "e457758c85b736bbad56dc099406cd2a9c19554cf81880dba7a51d092929e600"
"checksum safemem 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)" = "8dca453248a96cb0749e36ccdfe2b0b4e54a61bfef89fb97ec621eb8e0a93dd9"
"checksum sasl 0.4.2 (registry+https://github.com/rust-lang/crates.io-index)" = "4dbda5436dcd059da44fbf84b87a7164c5e3cad354efd0630c1f2be3c51c8859"
"checksum schannel 0.1.14 (registry+https://github.com/rust-lang/crates.io-index)" = "0e1a231dc10abf6749cfa5d7767f25888d484201accbd919b66ab5413c502d56"
"checksum safemem 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)" = "8dca453248a96cb0749e36ccdfe2b0b4e54a61bfef89fb97ec621eb8e0a93dd9"
"checksum sasl 0.4.2 (registry+https://github.com/rust-lang/crates.io-index)" = "4dbda5436dcd059da44fbf84b87a7164c5e3cad354efd0630c1f2be3c51c8859"
"checksum 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 safemem 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)" = "8dca453248a96cb0749e36ccdfe2b0b4e54a61bfef89fb97ec621eb8e0a93dd9"
"checksum sasl 0.4.2 (registry+https://github.com/rust-lang/crates.io-index)" = "4dbda5436dcd059da44fbf84b87a7164c5e3cad354efd0630c1f2be3c51c8859"
"checksum safemem 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)" = "8dca453248a96cb0749e36ccdfe2b0b4e54a61bfef89fb97ec621eb8e0a93dd9"
"checksum sasl 0.4.2 (registry+https://github.com/rust-lang/crates.io-index)" = "4dbda5436dcd059da44fbf84b87a7164c5e3cad354efd0630c1f2be3c51c8859"
"checksum sasl 0.4.3 (registry+https://github.com/rust-lang/crates.io-index)" = "e457758c85b736bbad56dc099406cd2a9c19554cf81880dba7a51d092929e600"
"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 resolv-conf 0.6.2 (registry+https://github.com/rust-lang/crates.io-index)" = "b263b4aa1b5de9ffc0054a2386f96992058bb6870aab516f8cdeb8a667d56dcb"
"checksum rustc_version 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)" = "138e3e0acb6c9fb258b19b67cb8abd63c00679d2851805ea151465464fe9030a"
"checksum rustc-demangle 0.1.13 (registry+https://github.com/rust-lang/crates.io-index)" = "adacaae16d02b6ec37fdc7acfcddf365978de76d1983d3ee22afc260e1ca9619"
"checksum rustc-demangle 0.1.14 (registry+https://github.com/rust-lang/crates.io-index)" = "ccc78bfd5acd7bf3e89cffcf899e5cb1a52d6fafa8dec2739ad70c9577a57288"
"checksum resolv-conf 0.6.2 (registry+https://github.com/rust-lang/crates.io-index)" = "b263b4aa1b5de9ffc0054a2386f96992058bb6870aab516f8cdeb8a667d56dcb"
"checksum rustc-demangle 0.1.14 (registry+https://github.com/rust-lang/crates.io-index)" = "ccc78bfd5acd7bf3e89cffcf899e5cb1a52d6fafa8dec2739ad70c9577a57288"
"checksum rustc-demangle 0.1.13 (registry+https://github.com/rust-lang/crates.io-index)" = "adacaae16d02b6ec37fdc7acfcddf365978de76d1983d3ee22afc260e1ca9619"
"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 resolv-conf 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)" = "c62bd95a41841efdf7fca2ae9951e64a8d8eae7e5da196d8ce489a2241491a92"
"checksum rustc-demangle 0.1.9 (registry+https://github.com/rust-lang/crates.io-index)" = "bcfe5b13211b4d78e5c2cadfebd7769197d95c639c35a50057eb4c05de811395"
"checksum resolv-conf 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)" = "c62bd95a41841efdf7fca2ae9951e64a8d8eae7e5da196d8ce489a2241491a92"
"checksum rustc-demangle 0.1.11 (registry+https://github.com/rust-lang/crates.io-index)" = "01b90379b8664dd83460d59bdc5dd1fd3172b8913788db483ed1325171eab2f7"
"checksum rustc-demangle 0.1.9 (registry+https://github.com/rust-lang/crates.io-index)" = "bcfe5b13211b4d78e5c2cadfebd7769197d95c639c35a50057eb4c05de811395"
"checksum rustc-demangle 0.1.11 (registry+https://github.com/rust-lang/crates.io-index)" = "01b90379b8664dd83460d59bdc5dd1fd3172b8913788db483ed1325171eab2f7"
"checksum rustc-demangle 0.1.11 (registry+https://github.com/rust-lang/crates.io-index)" = "01b90379b8664dd83460d59bdc5dd1fd3172b8913788db483ed1325171eab2f7"
"checksum rustc-demangle 0.1.11 (registry+https://github.com/rust-lang/crates.io-index)" = "01b90379b8664dd83460d59bdc5dd1fd3172b8913788db483ed1325171eab2f7"
"checksum rustc-demangle 0.1.9 (registry+https://github.com/rust-lang/crates.io-index)" = "bcfe5b13211b4d78e5c2cadfebd7769197d95c639c35a50057eb4c05de811395"
"checksum rustc-demangle 0.1.9 (registry+https://github.com/rust-lang/crates.io-index)" = "bcfe5b13211b4d78e5c2cadfebd7769197d95c639c35a50057eb4c05de811395"
"checksum rustc-demangle 0.1.9 (registry+https://github.com/rust-lang/crates.io-index)" = "bcfe5b13211b4d78e5c2cadfebd7769197d95c639c35a50057eb4c05de811395"
"checksum rustc-demangle 0.1.9 (registry+https://github.com/rust-lang/crates.io-index)" = "bcfe5b13211b4d78e5c2cadfebd7769197d95c639c35a50057eb4c05de811395"
"checksum resolv-conf 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)" = "c62bd95a41841efdf7fca2ae9951e64a8d8eae7e5da196d8ce489a2241491a92"
"checksum rustc-demangle 0.1.9 (registry+https://github.com/rust-lang/crates.io-index)" = "bcfe5b13211b4d78e5c2cadfebd7769197d95c639c35a50057eb4c05de811395"
"checksum resolv-conf 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)" = "c62bd95a41841efdf7fca2ae9951e64a8d8eae7e5da196d8ce489a2241491a92"
"checksum rustc-demangle 0.1.9 (registry+https://github.com/rust-lang/crates.io-index)" = "bcfe5b13211b4d78e5c2cadfebd7769197d95c639c35a50057eb4c05de811395"
"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 regex 1.0.6 (registry+https://github.com/rust-lang/crates.io-index)" = "ee84f70c8c08744ea9641a731c7fadb475bf2ecc52d7f627feb833e0b3990467"
"checksum regex-syntax 0.6.3 (registry+https://github.com/rust-lang/crates.io-index)" = "fbc557aac2b708fe84121caf261346cc2eed71978024337e42eb46b8a252ac6e"
"checksum regex 1.1.2 (registry+https://github.com/rust-lang/crates.io-index)" = "53ee8cfdddb2e0291adfb9f13d31d3bbe0a03c9a402c01b1e24188d86c35b24f"
"checksum remove_dir_all 0.5.1 (registry+https://github.com/rust-lang/crates.io-index)" = "3488ba1b9a2084d38645c4c08276a1752dcbf2c7130d74f1569681ad5d2799c5"
"checksum regex 1.1.0 (registry+https://github.com/rust-lang/crates.io-index)" = "37e7cbbd370869ce2e8dff25c7018702d10b21a20ef7135316f8daecd6c25b7f"
"checksum regex-syntax 0.6.4 (registry+https://github.com/rust-lang/crates.io-index)" = "4e47a2ed29da7a9e1960e1639e7a982e6edc6d49be308a3b02daf511504a16d1"
"checksum regex 1.1.0 (registry+https://github.com/rust-lang/crates.io-index)" = "37e7cbbd370869ce2e8dff25c7018702d10b21a20ef7135316f8daecd6c25b7f"
"checksum regex-syntax 0.6.4 (registry+https://github.com/rust-lang/crates.io-index)" = "4e47a2ed29da7a9e1960e1639e7a982e6edc6d49be308a3b02daf511504a16d1"
"checksum regex 1.1.0 (registry+https://github.com/rust-lang/crates.io-index)" = "37e7cbbd370869ce2e8dff25c7018702d10b21a20ef7135316f8daecd6c25b7f"
"checksum regex-syntax 0.6.5 (registry+https://github.com/rust-lang/crates.io-index)" = "8c2f35eedad5295fdf00a63d7d4b238135723f92b434ec06774dad15c7ab0861"
"checksum regex 1.1.5 (registry+https://github.com/rust-lang/crates.io-index)" = "559008764a17de49a3146b234641644ed37d118d1ef641a0bb573d146edc6ce0"
"checksum regex-syntax 0.6.6 (registry+https://github.com/rust-lang/crates.io-index)" = "dcfd8681eebe297b81d98498869d4aae052137651ad7b96822f09ceb690d0a96"
"checksum regex 1.1.0 (registry+https://github.com/rust-lang/crates.io-index)" = "37e7cbbd370869ce2e8dff25c7018702d10b21a20ef7135316f8daecd6c25b7f"
"checksum regex-syntax 0.6.4 (registry+https://github.com/rust-lang/crates.io-index)" = "4e47a2ed29da7a9e1960e1639e7a982e6edc6d49be308a3b02daf511504a16d1"
"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 regex 1.1.0 (registry+https://github.com/rust-lang/crates.io-index)" = "37e7cbbd370869ce2e8dff25c7018702d10b21a20ef7135316f8daecd6c25b7f"
"checksum regex 1.0.6 (registry+https://github.com/rust-lang/crates.io-index)" = "ee84f70c8c08744ea9641a731c7fadb475bf2ecc52d7f627feb833e0b3990467"
"checksum regex-syntax 0.6.3 (registry+https://github.com/rust-lang/crates.io-index)" = "fbc557aac2b708fe84121caf261346cc2eed71978024337e42eb46b8a252ac6e"
"checksum regex 1.1.0 (registry+https://github.com/rust-lang/crates.io-index)" = "37e7cbbd370869ce2e8dff25c7018702d10b21a20ef7135316f8daecd6c25b7f"
"checksum regex-syntax 0.6.4 (registry+https://github.com/rust-lang/crates.io-index)" = "4e47a2ed29da7a9e1960e1639e7a982e6edc6d49be308a3b02daf511504a16d1"
"checksum regex 1.1.0 (registry+https://github.com/rust-lang/crates.io-index)" = "37e7cbbd370869ce2e8dff25c7018702d10b21a20ef7135316f8daecd6c25b7f"
"checksum regex-syntax 0.6.4 (registry+https://github.com/rust-lang/crates.io-index)" = "4e47a2ed29da7a9e1960e1639e7a982e6edc6d49be308a3b02daf511504a16d1"
"checksum regex 1.1.5 (registry+https://github.com/rust-lang/crates.io-index)" = "559008764a17de49a3146b234641644ed37d118d1ef641a0bb573d146edc6ce0"
"checksum regex-syntax 0.6.6 (registry+https://github.com/rust-lang/crates.io-index)" = "dcfd8681eebe297b81d98498869d4aae052137651ad7b96822f09ceb690d0a96"
"checksum regex 1.0.6 (registry+https://github.com/rust-lang/crates.io-index)" = "ee84f70c8c08744ea9641a731c7fadb475bf2ecc52d7f627feb833e0b3990467"
"checksum regex-syntax 0.6.3 (registry+https://github.com/rust-lang/crates.io-index)" = "fbc557aac2b708fe84121caf261346cc2eed71978024337e42eb46b8a252ac6e"
"checksum regex 1.0.6 (registry+https://github.com/rust-lang/crates.io-index)" = "ee84f70c8c08744ea9641a731c7fadb475bf2ecc52d7f627feb833e0b3990467"
"checksum regex-syntax 0.6.3 (registry+https://github.com/rust-lang/crates.io-index)" = "fbc557aac2b708fe84121caf261346cc2eed71978024337e42eb46b8a252ac6e"
"checksum regex 1.0.6 (registry+https://github.com/rust-lang/crates.io-index)" = "ee84f70c8c08744ea9641a731c7fadb475bf2ecc52d7f627feb833e0b3990467"
"checksum regex-syntax 0.6.3 (registry+https://github.com/rust-lang/crates.io-index)" = "fbc557aac2b708fe84121caf261346cc2eed71978024337e42eb46b8a252ac6e"
"checksum regex 1.0.6 (registry+https://github.com/rust-lang/crates.io-index)" = "ee84f70c8c08744ea9641a731c7fadb475bf2ecc52d7f627feb833e0b3990467"
"checksum regex-syntax 0.6.3 (registry+https://github.com/rust-lang/crates.io-index)" = "fbc557aac2b708fe84121caf261346cc2eed71978024337e42eb46b8a252ac6e"
"checksum regex 1.1.0 (registry+https://github.com/rust-lang/crates.io-index)" = "37e7cbbd370869ce2e8dff25c7018702d10b21a20ef7135316f8daecd6c25b7f"
"checksum regex 1.1.2 (registry+https://github.com/rust-lang/crates.io-index)" = "53ee8cfdddb2e0291adfb9f13d31d3bbe0a03c9a402c01b1e24188d86c35b24f"
"checksum regex 1.0.6 (registry+https://github.com/rust-lang/crates.io-index)" = "ee84f70c8c08744ea9641a731c7fadb475bf2ecc52d7f627feb833e0b3990467"
"checksum regex-syntax 0.6.3 (registry+https://github.com/rust-lang/crates.io-index)" = "fbc557aac2b708fe84121caf261346cc2eed71978024337e42eb46b8a252ac6e"
"checksum regex 1.0.6 (registry+https://github.com/rust-lang/crates.io-index)" = "ee84f70c8c08744ea9641a731c7fadb475bf2ecc52d7f627feb833e0b3990467"
"checksum regex-syntax 0.6.3 (registry+https://github.com/rust-lang/crates.io-index)" = "fbc557aac2b708fe84121caf261346cc2eed71978024337e42eb46b8a252ac6e"
"checksum regex 1.1.0 (registry+https://github.com/rust-lang/crates.io-index)" = "37e7cbbd370869ce2e8dff25c7018702d10b21a20ef7135316f8daecd6c25b7f"
"checksum regex-syntax 0.6.4 (registry+https://github.com/rust-lang/crates.io-index)" = "4e47a2ed29da7a9e1960e1639e7a982e6edc6d49be308a3b02daf511504a16d1"
"checksum regex 1.0.6 (registry+https://github.com/rust-lang/crates.io-index)" = "ee84f70c8c08744ea9641a731c7fadb475bf2ecc52d7f627feb833e0b3990467"
"checksum regex-syntax 0.6.3 (registry+https://github.com/rust-lang/crates.io-index)" = "fbc557aac2b708fe84121caf261346cc2eed71978024337e42eb46b8a252ac6e"
"checksum rand_jitter 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)" = "7b9ea758282efe12823e0d952ddb269d2e1897227e464919a554f2a03ef1b832"
"checksum rand_pcg 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)" = "abf9b09b01790cfe0364f52bf32995ea3c39f4d2dd011eac241d2914146d0b44"
"checksum redox_syscall 0.1.51 (registry+https://github.com/rust-lang/crates.io-index)" = "423e376fffca3dfa06c9e9790a9ccd282fafb3cc6e6397d01dbf64f9bacc6b85"
"checksum redox_syscall 0.1.54 (registry+https://github.com/rust-lang/crates.io-index)" = "12229c14a0f65c4f1cb046a3b52047cdd9da1f4b30f8a39c5063c8bae515e252"
"checksum redox_termios 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "7e891cfe48e9100a70a3b6eb652fef28920c117d366339687bd5576160db0f76"
"checksum 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 rand_pcg 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "086bd09a33c7044e56bb44d5bdde5a60e7f119a9e95b0775f545de759a32fe05"
"checksum rand_xorshift 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)" = "effa3fcaa47e18db002bdde6060944b6d2f9cfd8db471c30e873448ad9187be3"
"checksum redox_syscall 0.1.43 (registry+https://github.com/rust-lang/crates.io-index)" = "679da7508e9a6390aeaf7fbd02a800fdc64b73fe2204dd2c8ae66d22d9d5ad5d"
"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 rand_xorshift 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)" = "effa3fcaa47e18db002bdde6060944b6d2f9cfd8db471c30e873448ad9187be3"
"checksum redox_syscall 0.1.43 (registry+https://github.com/rust-lang/crates.io-index)" = "679da7508e9a6390aeaf7fbd02a800fdc64b73fe2204dd2c8ae66d22d9d5ad5d"
"checksum rand_pcg 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "086bd09a33c7044e56bb44d5bdde5a60e7f119a9e95b0775f545de759a32fe05"
"checksum rand_pcg 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)" = "abf9b09b01790cfe0364f52bf32995ea3c39f4d2dd011eac241d2914146d0b44"
"checksum rand_os 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)" = "7b75f676a1e053fc562eafbb47838d67c84801e38fc1ba459e8f180deabd5071"
"checksum rand_os 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)" = "7b75f676a1e053fc562eafbb47838d67c84801e38fc1ba459e8f180deabd5071"
"checksum rand_os 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)" = "b7c690732391ae0abafced5015ffb53656abfaec61b342290e5eb56b286a679d"
"checksum rand_os 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)" = "b7c690732391ae0abafced5015ffb53656abfaec61b342290e5eb56b286a679d"
"checksum rand_pcg 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "086bd09a33c7044e56bb44d5bdde5a60e7f119a9e95b0775f545de759a32fe05"
"checksum rand_os 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)" = "7b75f676a1e053fc562eafbb47838d67c84801e38fc1ba459e8f180deabd5071"
"checksum rand_pcg 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)" = "abf9b09b01790cfe0364f52bf32995ea3c39f4d2dd011eac241d2914146d0b44"
"checksum rand_os 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)" = "b7c690732391ae0abafced5015ffb53656abfaec61b342290e5eb56b286a679d"
"checksum rand_os 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)" = "7b75f676a1e053fc562eafbb47838d67c84801e38fc1ba459e8f180deabd5071"
"checksum redox_syscall 0.1.54 (registry+https://github.com/rust-lang/crates.io-index)" = "12229c14a0f65c4f1cb046a3b52047cdd9da1f4b30f8a39c5063c8bae515e252"
"checksum redox_syscall 0.1.51 (registry+https://github.com/rust-lang/crates.io-index)" = "423e376fffca3dfa06c9e9790a9ccd282fafb3cc6e6397d01dbf64f9bacc6b85"
"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 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_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_os 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "f46fbd5550acf75b0c2730f5dd1873751daf9beb8f11b44027778fae50d7feca"
"checksum rand_pcg 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "086bd09a33c7044e56bb44d5bdde5a60e7f119a9e95b0775f545de759a32fe05"
"checksum rand_xorshift 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)" = "effa3fcaa47e18db002bdde6060944b6d2f9cfd8db471c30e873448ad9187be3"
"checksum redox_syscall 0.1.43 (registry+https://github.com/rust-lang/crates.io-index)" = "679da7508e9a6390aeaf7fbd02a800fdc64b73fe2204dd2c8ae66d22d9d5ad5d"
"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_os 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "f46fbd5550acf75b0c2730f5dd1873751daf9beb8f11b44027778fae50d7feca"
"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 rand_xorshift 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)" = "effa3fcaa47e18db002bdde6060944b6d2f9cfd8db471c30e873448ad9187be3"
"checksum redox_syscall 0.1.44 (registry+https://github.com/rust-lang/crates.io-index)" = "a84bcd297b87a545980a2d25a0beb72a1f490c31f0a9fde52fca35bfbb1ceb70"
"checksum redox_syscall 0.1.43 (registry+https://github.com/rust-lang/crates.io-index)" = "679da7508e9a6390aeaf7fbd02a800fdc64b73fe2204dd2c8ae66d22d9d5ad5d"
"checksum redox_syscall 0.1.44 (registry+https://github.com/rust-lang/crates.io-index)" = "a84bcd297b87a545980a2d25a0beb72a1f490c31f0a9fde52fca35bfbb1ceb70"
"checksum redox_syscall 0.1.44 (registry+https://github.com/rust-lang/crates.io-index)" = "a84bcd297b87a545980a2d25a0beb72a1f490c31f0a9fde52fca35bfbb1ceb70"
"checksum redox_syscall 0.1.49 (registry+https://github.com/rust-lang/crates.io-index)" = "f22c50afdcf3f0a31ebb6b47697f6a7c5e5a24967e842858118bce0615f0afad"
"checksum redox_syscall 0.1.43 (registry+https://github.com/rust-lang/crates.io-index)" = "679da7508e9a6390aeaf7fbd02a800fdc64b73fe2204dd2c8ae66d22d9d5ad5d"
"checksum redox_syscall 0.1.43 (registry+https://github.com/rust-lang/crates.io-index)" = "679da7508e9a6390aeaf7fbd02a800fdc64b73fe2204dd2c8ae66d22d9d5ad5d"
"checksum redox_syscall 0.1.43 (registry+https://github.com/rust-lang/crates.io-index)" = "679da7508e9a6390aeaf7fbd02a800fdc64b73fe2204dd2c8ae66d22d9d5ad5d"
"checksum redox_syscall 0.1.43 (registry+https://github.com/rust-lang/crates.io-index)" = "679da7508e9a6390aeaf7fbd02a800fdc64b73fe2204dd2c8ae66d22d9d5ad5d"
"checksum rand_xorshift 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)" = "effa3fcaa47e18db002bdde6060944b6d2f9cfd8db471c30e873448ad9187be3"
"checksum redox_syscall 0.1.43 (registry+https://github.com/rust-lang/crates.io-index)" = "679da7508e9a6390aeaf7fbd02a800fdc64b73fe2204dd2c8ae66d22d9d5ad5d"
"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 rand_pcg 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "086bd09a33c7044e56bb44d5bdde5a60e7f119a9e95b0775f545de759a32fe05"
"checksum rand_os 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "f46fbd5550acf75b0c2730f5dd1873751daf9beb8f11b44027778fae50d7feca"
"checksum rand 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)" = "ae9d223d52ae411a33cf7e54ec6034ec165df296ccd23533d671a28252b6f66a"
"checksum rand_chacha 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)" = "771b009e3a508cb67e8823dda454aaa5368c7bc1c16829fb77d3e980440dd34a"
"checksum rand 0.6.4 (registry+https://github.com/rust-lang/crates.io-index)" = "3906503e80ac6cbcacb2c2973fa8e473f24d7e2747c8c92bb230c2441cad96b5"
"checksum rand_chacha 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "556d3a1ca6600bfcbab7c7c91ccb085ac7fbbcd70e008a98742e7847f4f7bcef"
"checksum rand 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)" = "ae9d223d52ae411a33cf7e54ec6034ec165df296ccd23533d671a28252b6f66a"
"checksum rand_chacha 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)" = "771b009e3a508cb67e8823dda454aaa5368c7bc1c16829fb77d3e980440dd34a"
"checksum rand_core 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)" = "1961a422c4d189dfb50ffa9320bf1f2a9bd54ecb92792fb9477f99a1045f3372"
"checksum rand_core 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)" = "0905b6b7079ec73b314d4c748701f6931eb79fd97c668caa3f1899b22b32c6db"
"checksum rand 0.5.5 (registry+https://github.com/rust-lang/crates.io-index)" = "e464cd887e869cddcae8792a4ee31d23c7edd516700695608f5b98c67ee0131c"
"checksum rand 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)" = "ae9d223d52ae411a33cf7e54ec6034ec165df296ccd23533d671a28252b6f66a"
"checksum rand_chacha 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)" = "771b009e3a508cb67e8823dda454aaa5368c7bc1c16829fb77d3e980440dd34a"
"checksum rand 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)" = "ae9d223d52ae411a33cf7e54ec6034ec165df296ccd23533d671a28252b6f66a"
"checksum rand_chacha 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)" = "771b009e3a508cb67e8823dda454aaa5368c7bc1c16829fb77d3e980440dd34a"
"checksum rand 0.6.4 (registry+https://github.com/rust-lang/crates.io-index)" = "3906503e80ac6cbcacb2c2973fa8e473f24d7e2747c8c92bb230c2441cad96b5"
"checksum rand_chacha 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "556d3a1ca6600bfcbab7c7c91ccb085ac7fbbcd70e008a98742e7847f4f7bcef"
"checksum rand 0.4.3 (registry+https://github.com/rust-lang/crates.io-index)" = "8356f47b32624fef5b3301c1be97e5944ecdd595409cc5da11d05f211db6cfbd"
"checksum quote 0.6.11 (registry+https://github.com/rust-lang/crates.io-index)" = "cdd8e04bd9c52e0342b406469d494fcb033be4bdbe5c606016defbb1681411e1"
"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 quote 0.6.12 (registry+https://github.com/rust-lang/crates.io-index)" = "faf4799c5d274f3868a4aae320a0a182cbd2baee377b378f080e16a23e9d80db"
"checksum rand 0.5.6 (registry+https://github.com/rust-lang/crates.io-index)" = "c618c47cd3ebd209790115ab837de41425723956ad3ce2e6a7f09890947cacb9"
"checksum rand 0.6.5 (registry+https://github.com/rust-lang/crates.io-index)" = "6d71dacdc3c88c1fde3885a3be3fbab9f35724e6ce99467f7d9c5026132184ca"
"checksum rand_chacha 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "556d3a1ca6600bfcbab7c7c91ccb085ac7fbbcd70e008a98742e7847f4f7bcef"
"checksum rand_core 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)" = "7a6fdeb83b075e8266dcc8762c22776f6877a63111121f5f8c7411e5be7eed4b"
"checksum rand_core 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)" = "d0e7a549d590831370895ab7ba4ea0c1b6b011d106b5ff2da6eee112615e6dc0"
"checksum quote 0.6.11 (registry+https://github.com/rust-lang/crates.io-index)" = "cdd8e04bd9c52e0342b406469d494fcb033be4bdbe5c606016defbb1681411e1"
"checksum quote 0.6.10 (registry+https://github.com/rust-lang/crates.io-index)" = "53fa22a1994bd0f9372d7a816207d8a2677ad0325b073f5c5332760f0fb62b5c"
"checksum quote 0.6.11 (registry+https://github.com/rust-lang/crates.io-index)" = "cdd8e04bd9c52e0342b406469d494fcb033be4bdbe5c606016defbb1681411e1"
"checksum quote 0.6.12 (registry+https://github.com/rust-lang/crates.io-index)" = "faf4799c5d274f3868a4aae320a0a182cbd2baee377b378f080e16a23e9d80db"
"checksum quote 0.6.10 (registry+https://github.com/rust-lang/crates.io-index)" = "53fa22a1994bd0f9372d7a816207d8a2677ad0325b073f5c5332760f0fb62b5c"
"checksum rand 0.4.3 (registry+https://github.com/rust-lang/crates.io-index)" = "8356f47b32624fef5b3301c1be97e5944ecdd595409cc5da11d05f211db6cfbd"
"checksum rand 0.5.5 (registry+https://github.com/rust-lang/crates.io-index)" = "e464cd887e869cddcae8792a4ee31d23c7edd516700695608f5b98c67ee0131c"
"checksum rand 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)" = "ae9d223d52ae411a33cf7e54ec6034ec165df296ccd23533d671a28252b6f66a"
"checksum rand_chacha 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)" = "771b009e3a508cb67e8823dda454aaa5368c7bc1c16829fb77d3e980440dd34a"
"checksum rand_core 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)" = "1961a422c4d189dfb50ffa9320bf1f2a9bd54ecb92792fb9477f99a1045f3372"
"checksum rand_core 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)" = "0905b6b7079ec73b314d4c748701f6931eb79fd97c668caa3f1899b22b32c6db"
"checksum quote 0.6.10 (registry+https://github.com/rust-lang/crates.io-index)" = "53fa22a1994bd0f9372d7a816207d8a2677ad0325b073f5c5332760f0fb62b5c"
"checksum rand 0.4.3 (registry+https://github.com/rust-lang/crates.io-index)" = "8356f47b32624fef5b3301c1be97e5944ecdd595409cc5da11d05f211db6cfbd"
"checksum quote 0.6.10 (registry+https://github.com/rust-lang/crates.io-index)" = "53fa22a1994bd0f9372d7a816207d8a2677ad0325b073f5c5332760f0fb62b5c"
"checksum rand 0.4.3 (registry+https://github.com/rust-lang/crates.io-index)" = "8356f47b32624fef5b3301c1be97e5944ecdd595409cc5da11d05f211db6cfbd"
"checksum quote 0.6.10 (registry+https://github.com/rust-lang/crates.io-index)" = "53fa22a1994bd0f9372d7a816207d8a2677ad0325b073f5c5332760f0fb62b5c"
"checksum rand 0.4.3 (registry+https://github.com/rust-lang/crates.io-index)" = "8356f47b32624fef5b3301c1be97e5944ecdd595409cc5da11d05f211db6cfbd"
"checksum quote 0.6.11 (registry+https://github.com/rust-lang/crates.io-index)" = "cdd8e04bd9c52e0342b406469d494fcb033be4bdbe5c606016defbb1681411e1"
"checksum quick-xml 0.13.3 (registry+https://github.com/rust-lang/crates.io-index)" = "22fcc48ecef4609b243e8c01ff4695d08ee0fc9d5bdbc54630e1a5fe8bb40953"
"checksum quick-xml 0.13.2 (registry+https://github.com/rust-lang/crates.io-index)" = "98d8d2d671bd29c6122a98b45ce3106391e89ba378f731274de677f1eff06e5f"
"checksum quick-xml 0.13.2 (registry+https://github.com/rust-lang/crates.io-index)" = "98d8d2d671bd29c6122a98b45ce3106391e89ba378f731274de677f1eff06e5f"
"checksum quick-xml 0.13.3 (registry+https://github.com/rust-lang/crates.io-index)" = "22fcc48ecef4609b243e8c01ff4695d08ee0fc9d5bdbc54630e1a5fe8bb40953"
"checksum quick-xml 0.13.2 (registry+https://github.com/rust-lang/crates.io-index)" = "98d8d2d671bd29c6122a98b45ce3106391e89ba378f731274de677f1eff06e5f"
"checksum quick-xml 0.13.2 (registry+https://github.com/rust-lang/crates.io-index)" = "98d8d2d671bd29c6122a98b45ce3106391e89ba378f731274de677f1eff06e5f"
"checksum quick-xml 0.13.3 (registry+https://github.com/rust-lang/crates.io-index)" = "22fcc48ecef4609b243e8c01ff4695d08ee0fc9d5bdbc54630e1a5fe8bb40953"
"checksum quick-xml 0.12.4 (registry+https://github.com/rust-lang/crates.io-index)" = "1d8065cbb01701c11cc195cde85cbf39d1c6a80705b67a157ebb3042e0e5777f"
"checksum quick-xml 0.12.4 (registry+https://github.com/rust-lang/crates.io-index)" = "1d8065cbb01701c11cc195cde85cbf39d1c6a80705b67a157ebb3042e0e5777f"
"checksum quote 0.3.15 (registry+https://github.com/rust-lang/crates.io-index)" = "7a6e920b65c65f10b2ae65c831a81a073a89edd28c7cce89475bff467ab4167a"
"checksum quick-xml 0.13.2 (registry+https://github.com/rust-lang/crates.io-index)" = "98d8d2d671bd29c6122a98b45ce3106391e89ba378f731274de677f1eff06e5f"
"checksum quick-xml 0.13.3 (registry+https://github.com/rust-lang/crates.io-index)" = "22fcc48ecef4609b243e8c01ff4695d08ee0fc9d5bdbc54630e1a5fe8bb40953"
"checksum quick-xml 0.12.4 (registry+https://github.com/rust-lang/crates.io-index)" = "1d8065cbb01701c11cc195cde85cbf39d1c6a80705b67a157ebb3042e0e5777f"
"checksum quick-xml 0.12.4 (registry+https://github.com/rust-lang/crates.io-index)" = "1d8065cbb01701c11cc195cde85cbf39d1c6a80705b67a157ebb3042e0e5777f"
"checksum quick-xml 0.13.2 (registry+https://github.com/rust-lang/crates.io-index)" = "98d8d2d671bd29c6122a98b45ce3106391e89ba378f731274de677f1eff06e5f"
"checksum proc-macro2 0.4.26 (registry+https://github.com/rust-lang/crates.io-index)" = "38fddd23d98b2144d197c0eca5705632d4fe2667d14a6be5df8934f8d74f1978"
"checksum proc-macro2 0.4.27 (registry+https://github.com/rust-lang/crates.io-index)" = "4d317f9caece796be1980837fd5cb3dfec5613ebdb04ad0956deea83ce168915"
"checksum proc-macro2 0.4.27 (registry+https://github.com/rust-lang/crates.io-index)" = "4d317f9caece796be1980837fd5cb3dfec5613ebdb04ad0956deea83ce168915"
"checksum proc-macro2 0.4.24 (registry+https://github.com/rust-lang/crates.io-index)" = "77619697826f31a02ae974457af0b29b723e5619e113e9397b8b82c6bd253f09"
"checksum proc-macro2 0.4.26 (registry+https://github.com/rust-lang/crates.io-index)" = "38fddd23d98b2144d197c0eca5705632d4fe2667d14a6be5df8934f8d74f1978"
"checksum proc-macro2 0.4.24 (registry+https://github.com/rust-lang/crates.io-index)" = "77619697826f31a02ae974457af0b29b723e5619e113e9397b8b82c6bd253f09"
"checksum proc-macro2 0.4.24 (registry+https://github.com/rust-lang/crates.io-index)" = "77619697826f31a02ae974457af0b29b723e5619e113e9397b8b82c6bd253f09"
"checksum quick-error 1.2.2 (registry+https://github.com/rust-lang/crates.io-index)" = "9274b940887ce9addde99c4eee6b5c44cc494b182b97e73dc8ffdcb3397fd3f0"
"checksum proc-macro2 0.4.24 (registry+https://github.com/rust-lang/crates.io-index)" = "77619697826f31a02ae974457af0b29b723e5619e113e9397b8b82c6bd253f09"
"checksum proc-macro2 0.4.24 (registry+https://github.com/rust-lang/crates.io-index)" = "77619697826f31a02ae974457af0b29b723e5619e113e9397b8b82c6bd253f09"
"checksum proc-macro2 0.4.26 (registry+https://github.com/rust-lang/crates.io-index)" = "38fddd23d98b2144d197c0eca5705632d4fe2667d14a6be5df8934f8d74f1978"
"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 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 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 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 phf 0.7.23 (registry+https://github.com/rust-lang/crates.io-index)" = "cec29da322b242f4c3098852c77a0ca261c9c01b806cae85a5572a1eb94db9a6"
"checksum phf_codegen 0.7.23 (registry+https://github.com/rust-lang/crates.io-index)" = "7d187f00cd98d5afbcd8898f6cf181743a449162aeb329dcd2f3849009e605ad"
"checksum phf_generator 0.7.23 (registry+https://github.com/rust-lang/crates.io-index)" = "03dc191feb9b08b0dc1330d6549b795b9d81aec19efe6b4a45aec8d4caee0c4b"
"checksum phf_shared 0.7.23 (registry+https://github.com/rust-lang/crates.io-index)" = "b539898d22d4273ded07f64a05737649dc69095d92cb87c7097ec68e3f150b93"
"checksum phf 0.7.23 (registry+https://github.com/rust-lang/crates.io-index)" = "cec29da322b242f4c3098852c77a0ca261c9c01b806cae85a5572a1eb94db9a6"
"checksum phf_codegen 0.7.23 (registry+https://github.com/rust-lang/crates.io-index)" = "7d187f00cd98d5afbcd8898f6cf181743a449162aeb329dcd2f3849009e605ad"
"checksum phf_generator 0.7.23 (registry+https://github.com/rust-lang/crates.io-index)" = "03dc191feb9b08b0dc1330d6549b795b9d81aec19efe6b4a45aec8d4caee0c4b"
"checksum phf_shared 0.7.23 (registry+https://github.com/rust-lang/crates.io-index)" = "b539898d22d4273ded07f64a05737649dc69095d92cb87c7097ec68e3f150b93"
"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 phf 0.7.23 (registry+https://github.com/rust-lang/crates.io-index)" = "cec29da322b242f4c3098852c77a0ca261c9c01b806cae85a5572a1eb94db9a6"
"checksum phf_codegen 0.7.23 (registry+https://github.com/rust-lang/crates.io-index)" = "7d187f00cd98d5afbcd8898f6cf181743a449162aeb329dcd2f3849009e605ad"
"checksum phf_generator 0.7.23 (registry+https://github.com/rust-lang/crates.io-index)" = "03dc191feb9b08b0dc1330d6549b795b9d81aec19efe6b4a45aec8d4caee0c4b"
"checksum phf_shared 0.7.23 (registry+https://github.com/rust-lang/crates.io-index)" = "b539898d22d4273ded07f64a05737649dc69095d92cb87c7097ec68e3f150b93"
"checksum phf 0.7.23 (registry+https://github.com/rust-lang/crates.io-index)" = "cec29da322b242f4c3098852c77a0ca261c9c01b806cae85a5572a1eb94db9a6"
"checksum phf_codegen 0.7.23 (registry+https://github.com/rust-lang/crates.io-index)" = "7d187f00cd98d5afbcd8898f6cf181743a449162aeb329dcd2f3849009e605ad"
"checksum phf_generator 0.7.23 (registry+https://github.com/rust-lang/crates.io-index)" = "03dc191feb9b08b0dc1330d6549b795b9d81aec19efe6b4a45aec8d4caee0c4b"
"checksum phf_shared 0.7.23 (registry+https://github.com/rust-lang/crates.io-index)" = "b539898d22d4273ded07f64a05737649dc69095d92cb87c7097ec68e3f150b93"
"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 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 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 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 parking_lot 0.6.4 (registry+https://github.com/rust-lang/crates.io-index)" = "f0802bff09003b291ba756dc7e79313e51cc31667e94afbe847def490424cde5"
"checksum parking_lot_core 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)" = "ad7f7e6ebdc79edff6fdcb87a55b620174f7a989e3eb31b65231f4af57f00b8c"
"checksum parking_lot 0.6.4 (registry+https://github.com/rust-lang/crates.io-index)" = "f0802bff09003b291ba756dc7e79313e51cc31667e94afbe847def490424cde5"
"checksum parking_lot_core 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)" = "ad7f7e6ebdc79edff6fdcb87a55b620174f7a989e3eb31b65231f4af57f00b8c"
"checksum owning_ref 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)" = "cdf84f41639e037b484f93433aa3897863b561ed65c6e59c7073d7c561710f37"
"checksum percent-encoding 1.0.1 (registry+https://github.com/rust-lang/crates.io-index)" = "31010dd2e1ac33d5b46a5b413495239882813e0369f8ed8a5e266f173602f831"
"checksum openssl-sys 0.9.40 (registry+https://github.com/rust-lang/crates.io-index)" = "1bb974e77de925ef426b6bc82fce15fd45bdcbeb5728bffcfc7cdeeb7ce1c2d6"
"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 parking_lot 0.6.4 (registry+https://github.com/rust-lang/crates.io-index)" = "f0802bff09003b291ba756dc7e79313e51cc31667e94afbe847def490424cde5"
"checksum parking_lot_core 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)" = "ad7f7e6ebdc79edff6fdcb87a55b620174f7a989e3eb31b65231f4af57f00b8c"
"checksum parking_lot 0.6.4 (registry+https://github.com/rust-lang/crates.io-index)" = "f0802bff09003b291ba756dc7e79313e51cc31667e94afbe847def490424cde5"
"checksum parking_lot_core 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)" = "ad7f7e6ebdc79edff6fdcb87a55b620174f7a989e3eb31b65231f4af57f00b8c"
"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 openssl-sys 0.9.39 (registry+https://github.com/rust-lang/crates.io-index)" = "278c1ad40a89aa1e741a1eed089a2f60b18fab8089c3139b542140fc7d674106"
"checksum openssl-sys 0.9.43 (registry+https://github.com/rust-lang/crates.io-index)" = "33c86834957dd5b915623e94f2f4ab2c70dd8f6b70679824155d5ae21dbd495d"
"checksum openssl-sys 0.9.42 (registry+https://github.com/rust-lang/crates.io-index)" = "cb534d752bf98cf363b473950659ac2546517f9c6be9723771614ab3f03bbc9e"
"checksum openssl-sys 0.9.40 (registry+https://github.com/rust-lang/crates.io-index)" = "1bb974e77de925ef426b6bc82fce15fd45bdcbeb5728bffcfc7cdeeb7ce1c2d6"
"checksum openssl-sys 0.9.40 (registry+https://github.com/rust-lang/crates.io-index)" = "1bb974e77de925ef426b6bc82fce15fd45bdcbeb5728bffcfc7cdeeb7ce1c2d6"
"checksum openssl-sys 0.9.40 (registry+https://github.com/rust-lang/crates.io-index)" = "1bb974e77de925ef426b6bc82fce15fd45bdcbeb5728bffcfc7cdeeb7ce1c2d6"
"checksum openssl-sys 0.9.43 (registry+https://github.com/rust-lang/crates.io-index)" = "33c86834957dd5b915623e94f2f4ab2c70dd8f6b70679824155d5ae21dbd495d"
"checksum openssl-sys 0.9.40 (registry+https://github.com/rust-lang/crates.io-index)" = "1bb974e77de925ef426b6bc82fce15fd45bdcbeb5728bffcfc7cdeeb7ce1c2d6"
"checksum openssl-sys 0.9.42 (registry+https://github.com/rust-lang/crates.io-index)" = "cb534d752bf98cf363b473950659ac2546517f9c6be9723771614ab3f03bbc9e"
"checksum openssl-sys 0.9.40 (registry+https://github.com/rust-lang/crates.io-index)" = "1bb974e77de925ef426b6bc82fce15fd45bdcbeb5728bffcfc7cdeeb7ce1c2d6"
"checksum owning_ref 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)" = "49a4b8ea2179e6a2e27411d3bca09ca6dd630821cf6894c6c7c8467a8ee7ef13"
"checksum openssl-sys 0.9.40 (registry+https://github.com/rust-lang/crates.io-index)" = "1bb974e77de925ef426b6bc82fce15fd45bdcbeb5728bffcfc7cdeeb7ce1c2d6"
"checksum openssl-sys 0.9.40 (registry+https://github.com/rust-lang/crates.io-index)" = "1bb974e77de925ef426b6bc82fce15fd45bdcbeb5728bffcfc7cdeeb7ce1c2d6"
"checksum openssl-sys 0.9.43 (registry+https://github.com/rust-lang/crates.io-index)" = "33c86834957dd5b915623e94f2f4ab2c70dd8f6b70679824155d5ae21dbd495d"
"checksum openssl-sys 0.9.39 (registry+https://github.com/rust-lang/crates.io-index)" = "278c1ad40a89aa1e741a1eed089a2f60b18fab8089c3139b542140fc7d674106"
"checksum openssl-sys 0.9.39 (registry+https://github.com/rust-lang/crates.io-index)" = "278c1ad40a89aa1e741a1eed089a2f60b18fab8089c3139b542140fc7d674106"
"checksum openssl-sys 0.9.39 (registry+https://github.com/rust-lang/crates.io-index)" = "278c1ad40a89aa1e741a1eed089a2f60b18fab8089c3139b542140fc7d674106"
"checksum openssl-sys 0.9.39 (registry+https://github.com/rust-lang/crates.io-index)" = "278c1ad40a89aa1e741a1eed089a2f60b18fab8089c3139b542140fc7d674106"
"checksum owning_ref 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)" = "49a4b8ea2179e6a2e27411d3bca09ca6dd630821cf6894c6c7c8467a8ee7ef13"
"checksum openssl-sys 0.9.40 (registry+https://github.com/rust-lang/crates.io-index)" = "1bb974e77de925ef426b6bc82fce15fd45bdcbeb5728bffcfc7cdeeb7ce1c2d6"
"checksum openssl-sys 0.9.42 (registry+https://github.com/rust-lang/crates.io-index)" = "cb534d752bf98cf363b473950659ac2546517f9c6be9723771614ab3f03bbc9e"
"checksum openssl-sys 0.9.39 (registry+https://github.com/rust-lang/crates.io-index)" = "278c1ad40a89aa1e741a1eed089a2f60b18fab8089c3139b542140fc7d674106"
"checksum openssl-sys 0.9.39 (registry+https://github.com/rust-lang/crates.io-index)" = "278c1ad40a89aa1e741a1eed089a2f60b18fab8089c3139b542140fc7d674106"
"checksum openssl-sys 0.9.40 (registry+https://github.com/rust-lang/crates.io-index)" = "1bb974e77de925ef426b6bc82fce15fd45bdcbeb5728bffcfc7cdeeb7ce1c2d6"
"checksum openssl-sys 0.9.39 (registry+https://github.com/rust-lang/crates.io-index)" = "278c1ad40a89aa1e741a1eed089a2f60b18fab8089c3139b542140fc7d674106"
"checksum openssl 0.10.19 (registry+https://github.com/rust-lang/crates.io-index)" = "84321fb9004c3bce5611188a644d6171f895fa2889d155927d528782edb21c5d"
"checksum openssl 0.10.16 (registry+https://github.com/rust-lang/crates.io-index)" = "ec7bd7ca4cce6dbdc77e7c1230682740d307d1218a87fb0349a571272be749f9"
"checksum openssl 0.10.16 (registry+https://github.com/rust-lang/crates.io-index)" = "ec7bd7ca4cce6dbdc77e7c1230682740d307d1218a87fb0349a571272be749f9"
"checksum openssl 0.10.20 (registry+https://github.com/rust-lang/crates.io-index)" = "5a0d6b781aac4ac1bd6cafe2a2f0ad8c16ae8e1dd5184822a16c50139f8838d9"
"checksum openssl 0.10.16 (registry+https://github.com/rust-lang/crates.io-index)" = "ec7bd7ca4cce6dbdc77e7c1230682740d307d1218a87fb0349a571272be749f9"
"checksum openssl 0.10.19 (registry+https://github.com/rust-lang/crates.io-index)" = "84321fb9004c3bce5611188a644d6171f895fa2889d155927d528782edb21c5d"
"checksum openssl 0.10.20 (registry+https://github.com/rust-lang/crates.io-index)" = "5a0d6b781aac4ac1bd6cafe2a2f0ad8c16ae8e1dd5184822a16c50139f8838d9"
"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 num_cpus 1.8.0 (registry+https://github.com/rust-lang/crates.io-index)" = "c51a3322e4bca9d212ad9a158a02abc6934d005490c054a2778df73a70aa0a30"
"checksum openssl 0.10.15 (registry+https://github.com/rust-lang/crates.io-index)" = "5e1309181cdcbdb51bc3b6bedb33dfac2a83b3d585033d3f6d9e22e8c1928613"
"checksum num_cpus 1.9.0 (registry+https://github.com/rust-lang/crates.io-index)" = "5a69d464bdc213aaaff628444e99578ede64e9c854025aa43b9796530afa9238"
"checksum openssl 0.10.16 (registry+https://github.com/rust-lang/crates.io-index)" = "ec7bd7ca4cce6dbdc77e7c1230682740d307d1218a87fb0349a571272be749f9"
"checksum num_cpus 1.8.0 (registry+https://github.com/rust-lang/crates.io-index)" = "c51a3322e4bca9d212ad9a158a02abc6934d005490c054a2778df73a70aa0a30"
"checksum openssl 0.10.15 (registry+https://github.com/rust-lang/crates.io-index)" = "5e1309181cdcbdb51bc3b6bedb33dfac2a83b3d585033d3f6d9e22e8c1928613"
"checksum num_cpus 1.10.0 (registry+https://github.com/rust-lang/crates.io-index)" = "1a23f0ed30a54abaa0c7e83b1d2d87ada7c3c23078d1d87815af3e3b6385fbba"
"checksum num_cpus 1.10.0 (registry+https://github.com/rust-lang/crates.io-index)" = "1a23f0ed30a54abaa0c7e83b1d2d87ada7c3c23078d1d87815af3e3b6385fbba"
"checksum num_cpus 1.9.0 (registry+https://github.com/rust-lang/crates.io-index)" = "5a69d464bdc213aaaff628444e99578ede64e9c854025aa43b9796530afa9238"
"checksum openssl 0.10.16 (registry+https://github.com/rust-lang/crates.io-index)" = "ec7bd7ca4cce6dbdc77e7c1230682740d307d1218a87fb0349a571272be749f9"
"checksum num_cpus 1.9.0 (registry+https://github.com/rust-lang/crates.io-index)" = "5a69d464bdc213aaaff628444e99578ede64e9c854025aa43b9796530afa9238"
"checksum opaque-debug 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)" = "51ecbcb821e1bd256d456fe858aaa7f380b63863eab2eb86eee1bd9f33dd6682"
"checksum openssl 0.10.16 (registry+https://github.com/rust-lang/crates.io-index)" = "ec7bd7ca4cce6dbdc77e7c1230682740d307d1218a87fb0349a571272be749f9"
"checksum num_cpus 1.9.0 (registry+https://github.com/rust-lang/crates.io-index)" = "5a69d464bdc213aaaff628444e99578ede64e9c854025aa43b9796530afa9238"
"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 num_cpus 1.9.0 (registry+https://github.com/rust-lang/crates.io-index)" = "5a69d464bdc213aaaff628444e99578ede64e9c854025aa43b9796530afa9238"
"checksum openssl 0.10.16 (registry+https://github.com/rust-lang/crates.io-index)" = "ec7bd7ca4cce6dbdc77e7c1230682740d307d1218a87fb0349a571272be749f9"
"checksum num_cpus 1.9.0 (registry+https://github.com/rust-lang/crates.io-index)" = "5a69d464bdc213aaaff628444e99578ede64e9c854025aa43b9796530afa9238"
"checksum num_cpus 1.9.0 (registry+https://github.com/rust-lang/crates.io-index)" = "5a69d464bdc213aaaff628444e99578ede64e9c854025aa43b9796530afa9238"
"checksum openssl 0.10.16 (registry+https://github.com/rust-lang/crates.io-index)" = "ec7bd7ca4cce6dbdc77e7c1230682740d307d1218a87fb0349a571272be749f9"
"checksum num_cpus 1.9.0 (registry+https://github.com/rust-lang/crates.io-index)" = "5a69d464bdc213aaaff628444e99578ede64e9c854025aa43b9796530afa9238"
"checksum opaque-debug 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)" = "51ecbcb821e1bd256d456fe858aaa7f380b63863eab2eb86eee1bd9f33dd6682"
"checksum openssl 0.10.16 (registry+https://github.com/rust-lang/crates.io-index)" = "ec7bd7ca4cce6dbdc77e7c1230682740d307d1218a87fb0349a571272be749f9"
"checksum num_cpus 1.10.0 (registry+https://github.com/rust-lang/crates.io-index)" = "1a23f0ed30a54abaa0c7e83b1d2d87ada7c3c23078d1d87815af3e3b6385fbba"
"checksum num_cpus 1.8.0 (registry+https://github.com/rust-lang/crates.io-index)" = "c51a3322e4bca9d212ad9a158a02abc6934d005490c054a2778df73a70aa0a30"
"checksum openssl 0.10.15 (registry+https://github.com/rust-lang/crates.io-index)" = "5e1309181cdcbdb51bc3b6bedb33dfac2a83b3d585033d3f6d9e22e8c1928613"
"checksum num_cpus 1.8.0 (registry+https://github.com/rust-lang/crates.io-index)" = "c51a3322e4bca9d212ad9a158a02abc6934d005490c054a2778df73a70aa0a30"
"checksum openssl 0.10.15 (registry+https://github.com/rust-lang/crates.io-index)" = "5e1309181cdcbdb51bc3b6bedb33dfac2a83b3d585033d3f6d9e22e8c1928613"
"checksum num_cpus 1.8.0 (registry+https://github.com/rust-lang/crates.io-index)" = "c51a3322e4bca9d212ad9a158a02abc6934d005490c054a2778df73a70aa0a30"
"checksum openssl 0.10.15 (registry+https://github.com/rust-lang/crates.io-index)" = "5e1309181cdcbdb51bc3b6bedb33dfac2a83b3d585033d3f6d9e22e8c1928613"
"checksum num_cpus 1.8.0 (registry+https://github.com/rust-lang/crates.io-index)" = "c51a3322e4bca9d212ad9a158a02abc6934d005490c054a2778df73a70aa0a30"
"checksum openssl 0.10.15 (registry+https://github.com/rust-lang/crates.io-index)" = "5e1309181cdcbdb51bc3b6bedb33dfac2a83b3d585033d3f6d9e22e8c1928613"
"checksum num_cpus 1.9.0 (registry+https://github.com/rust-lang/crates.io-index)" = "5a69d464bdc213aaaff628444e99578ede64e9c854025aa43b9796530afa9238"
"checksum num_cpus 1.10.0 (registry+https://github.com/rust-lang/crates.io-index)" = "1a23f0ed30a54abaa0c7e83b1d2d87ada7c3c23078d1d87815af3e3b6385fbba"
"checksum num_cpus 1.8.0 (registry+https://github.com/rust-lang/crates.io-index)" = "c51a3322e4bca9d212ad9a158a02abc6934d005490c054a2778df73a70aa0a30"
"checksum openssl 0.10.15 (registry+https://github.com/rust-lang/crates.io-index)" = "5e1309181cdcbdb51bc3b6bedb33dfac2a83b3d585033d3f6d9e22e8c1928613"
"checksum num_cpus 1.8.0 (registry+https://github.com/rust-lang/crates.io-index)" = "c51a3322e4bca9d212ad9a158a02abc6934d005490c054a2778df73a70aa0a30"
"checksum openssl 0.10.15 (registry+https://github.com/rust-lang/crates.io-index)" = "5e1309181cdcbdb51bc3b6bedb33dfac2a83b3d585033d3f6d9e22e8c1928613"
"checksum num_cpus 1.9.0 (registry+https://github.com/rust-lang/crates.io-index)" = "5a69d464bdc213aaaff628444e99578ede64e9c854025aa43b9796530afa9238"
"checksum opaque-debug 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)" = "51ecbcb821e1bd256d456fe858aaa7f380b63863eab2eb86eee1bd9f33dd6682"
"checksum openssl 0.10.16 (registry+https://github.com/rust-lang/crates.io-index)" = "ec7bd7ca4cce6dbdc77e7c1230682740d307d1218a87fb0349a571272be749f9"
"checksum num_cpus 1.8.0 (registry+https://github.com/rust-lang/crates.io-index)" = "c51a3322e4bca9d212ad9a158a02abc6934d005490c054a2778df73a70aa0a30"
"checksum openssl 0.10.15 (registry+https://github.com/rust-lang/crates.io-index)" = "5e1309181cdcbdb51bc3b6bedb33dfac2a83b3d585033d3f6d9e22e8c1928613"
"checksum num_cpus 1.9.0 (registry+https://github.com/rust-lang/crates.io-index)" = "5a69d464bdc213aaaff628444e99578ede64e9c854025aa43b9796530afa9238"
"checksum new_debug_unreachable 1.0.3 (registry+https://github.com/rust-lang/crates.io-index)" = "f40f005c60db6e03bae699e414c58bf9aa7ea02a2d0b9bfbcf19286cc4c82b30"
"checksum new_debug_unreachable 1.0.3 (registry+https://github.com/rust-lang/crates.io-index)" = "f40f005c60db6e03bae699e414c58bf9aa7ea02a2d0b9bfbcf19286cc4c82b30"
"checksum new_debug_unreachable 1.0.1 (registry+https://github.com/rust-lang/crates.io-index)" = "0cdc457076c78ab54d5e0d6fa7c47981757f1e34dc39ff92787f217dede586c4"
"checksum new_debug_unreachable 1.0.3 (registry+https://github.com/rust-lang/crates.io-index)" = "f40f005c60db6e03bae699e414c58bf9aa7ea02a2d0b9bfbcf19286cc4c82b30"
"checksum new_debug_unreachable 1.0.1 (registry+https://github.com/rust-lang/crates.io-index)" = "0cdc457076c78ab54d5e0d6fa7c47981757f1e34dc39ff92787f217dede586c4"
"checksum new_debug_unreachable 1.0.1 (registry+https://github.com/rust-lang/crates.io-index)" = "0cdc457076c78ab54d5e0d6fa7c47981757f1e34dc39ff92787f217dede586c4"
"checksum nodrop 0.1.12 (registry+https://github.com/rust-lang/crates.io-index)" = "9a2228dca57108069a5262f2ed8bd2e82496d2e074a06d1ccc7ce1687b6ae0a2"
"checksum nodrop 0.1.13 (registry+https://github.com/rust-lang/crates.io-index)" = "2f9667ddcc6cc8a43afc9b7917599d7216aa09c463919ea32c59ed6cac8bc945"
"checksum nodrop 0.1.13 (registry+https://github.com/rust-lang/crates.io-index)" = "2f9667ddcc6cc8a43afc9b7917599d7216aa09c463919ea32c59ed6cac8bc945"
"checksum new_debug_unreachable 1.0.1 (registry+https://github.com/rust-lang/crates.io-index)" = "0cdc457076c78ab54d5e0d6fa7c47981757f1e34dc39ff92787f217dede586c4"
"checksum new_debug_unreachable 1.0.3 (registry+https://github.com/rust-lang/crates.io-index)" = "f40f005c60db6e03bae699e414c58bf9aa7ea02a2d0b9bfbcf19286cc4c82b30"
"checksum new_debug_unreachable 1.0.1 (registry+https://github.com/rust-lang/crates.io-index)" = "0cdc457076c78ab54d5e0d6fa7c47981757f1e34dc39ff92787f217dede586c4"
"checksum minidom 0.10.0 (registry+https://github.com/rust-lang/crates.io-index)" = "275024eea6c6ff4ace22f2750843831183785288eec1cff91a4e6b8898cf94f9"
"checksum minidom 0.10.0 (registry+https://github.com/rust-lang/crates.io-index)" = "275024eea6c6ff4ace22f2750843831183785288eec1cff91a4e6b8898cf94f9"
"checksum minidom 0.10.0 (registry+https://github.com/rust-lang/crates.io-index)" = "275024eea6c6ff4ace22f2750843831183785288eec1cff91a4e6b8898cf94f9"
"checksum minidom 0.10.0 (registry+https://github.com/rust-lang/crates.io-index)" = "275024eea6c6ff4ace22f2750843831183785288eec1cff91a4e6b8898cf94f9"
"checksum minidom 0.9.1 (registry+https://github.com/rust-lang/crates.io-index)" = "c0a5296bf9d0ac9e4a6e4cb844e3ee84bf33f841c7b3ae2cc87f05ceb81b50ae"
"checksum minidom 0.9.1 (registry+https://github.com/rust-lang/crates.io-index)" = "c0a5296bf9d0ac9e4a6e4cb844e3ee84bf33f841c7b3ae2cc87f05ceb81b50ae"
"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 minidom 0.9.1 (registry+https://github.com/rust-lang/crates.io-index)" = "c0a5296bf9d0ac9e4a6e4cb844e3ee84bf33f841c7b3ae2cc87f05ceb81b50ae"
"checksum minidom 0.9.1 (registry+https://github.com/rust-lang/crates.io-index)" = "c0a5296bf9d0ac9e4a6e4cb844e3ee84bf33f841c7b3ae2cc87f05ceb81b50ae"
"checksum minidom 0.10.0 (registry+https://github.com/rust-lang/crates.io-index)" = "275024eea6c6ff4ace22f2750843831183785288eec1cff91a4e6b8898cf94f9"
"checksum memchr 2.1.2 (registry+https://github.com/rust-lang/crates.io-index)" = "db4c41318937f6e76648f42826b1d9ade5c09cafb5aef7e351240a70f39206e9"
"checksum memchr 2.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "0a3eb002f0535929f1199681417029ebea04aadc0c7a4224b46be99c7f5d6a16"
"checksum memchr 2.2.0 (registry+https://github.com/rust-lang/crates.io-index)" = "2efc7bc57c883d4a4d6e3246905283d8dae951bb3bd32f49d6ef297f546e1c39"
"checksum memchr 2.2.0 (registry+https://github.com/rust-lang/crates.io-index)" = "2efc7bc57c883d4a4d6e3246905283d8dae951bb3bd32f49d6ef297f546e1c39"
"checksum memchr 2.1.2 (registry+https://github.com/rust-lang/crates.io-index)" = "db4c41318937f6e76648f42826b1d9ade5c09cafb5aef7e351240a70f39206e9"
"checksum memchr 2.1.3 (registry+https://github.com/rust-lang/crates.io-index)" = "e1dd4eaac298c32ce07eb6ed9242eda7d82955b9170b7d6db59b2e02cc63fcb8"
"checksum memchr 2.1.3 (registry+https://github.com/rust-lang/crates.io-index)" = "e1dd4eaac298c32ce07eb6ed9242eda7d82955b9170b7d6db59b2e02cc63fcb8"
"checksum memchr 2.2.0 (registry+https://github.com/rust-lang/crates.io-index)" = "2efc7bc57c883d4a4d6e3246905283d8dae951bb3bd32f49d6ef297f546e1c39"
"checksum memchr 2.1.2 (registry+https://github.com/rust-lang/crates.io-index)" = "db4c41318937f6e76648f42826b1d9ade5c09cafb5aef7e351240a70f39206e9"
"checksum memchr 2.1.3 (registry+https://github.com/rust-lang/crates.io-index)" = "e1dd4eaac298c32ce07eb6ed9242eda7d82955b9170b7d6db59b2e02cc63fcb8"
"checksum memchr 2.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "0a3eb002f0535929f1199681417029ebea04aadc0c7a4224b46be99c7f5d6a16"
"checksum memchr 2.1.2 (registry+https://github.com/rust-lang/crates.io-index)" = "db4c41318937f6e76648f42826b1d9ade5c09cafb5aef7e351240a70f39206e9"
"checksum memchr 2.1.3 (registry+https://github.com/rust-lang/crates.io-index)" = "e1dd4eaac298c32ce07eb6ed9242eda7d82955b9170b7d6db59b2e02cc63fcb8"
"checksum memchr 2.2.0 (registry+https://github.com/rust-lang/crates.io-index)" = "2efc7bc57c883d4a4d6e3246905283d8dae951bb3bd32f49d6ef297f546e1c39"
"checksum memchr 2.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "0a3eb002f0535929f1199681417029ebea04aadc0c7a4224b46be99c7f5d6a16"
"checksum memchr 2.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "0a3eb002f0535929f1199681417029ebea04aadc0c7a4224b46be99c7f5d6a16"
"checksum memchr 2.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "0a3eb002f0535929f1199681417029ebea04aadc0c7a4224b46be99c7f5d6a16"
"checksum memchr 2.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "0a3eb002f0535929f1199681417029ebea04aadc0c7a4224b46be99c7f5d6a16"
"checksum memoffset 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)" = "0f9dc261e2b62d7a622bf416ea3c5245cdd5d9a7fcc428c0d06804dfce1775b3"
"checksum memchr 2.1.3 (registry+https://github.com/rust-lang/crates.io-index)" = "e1dd4eaac298c32ce07eb6ed9242eda7d82955b9170b7d6db59b2e02cc63fcb8"
"checksum memchr 2.2.0 (registry+https://github.com/rust-lang/crates.io-index)" = "2efc7bc57c883d4a4d6e3246905283d8dae951bb3bd32f49d6ef297f546e1c39"
"checksum memchr 2.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "0a3eb002f0535929f1199681417029ebea04aadc0c7a4224b46be99c7f5d6a16"
"checksum memchr 2.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "0a3eb002f0535929f1199681417029ebea04aadc0c7a4224b46be99c7f5d6a16"
"checksum memchr 2.1.3 (registry+https://github.com/rust-lang/crates.io-index)" = "e1dd4eaac298c32ce07eb6ed9242eda7d82955b9170b7d6db59b2e02cc63fcb8"
"checksum memchr 2.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "0a3eb002f0535929f1199681417029ebea04aadc0c7a4224b46be99c7f5d6a16"
"checksum memchr 2.1.3 (registry+https://github.com/rust-lang/crates.io-index)" = "e1dd4eaac298c32ce07eb6ed9242eda7d82955b9170b7d6db59b2e02cc63fcb8"
"checksum markup5ever 0.7.5 (registry+https://github.com/rust-lang/crates.io-index)" = "897636f9850c3eef4905a5540683ed53dc9393860f0846cab2c2ddf9939862ff"
"checksum markup5ever 0.7.3 (registry+https://github.com/rust-lang/crates.io-index)" = "a87c4100d614080c8ab43334fb028ebe387f273fb61ed4ff0eae9189b94b6be8"
"checksum markup5ever 0.7.5 (registry+https://github.com/rust-lang/crates.io-index)" = "897636f9850c3eef4905a5540683ed53dc9393860f0846cab2c2ddf9939862ff"
"checksum markup5ever 0.7.5 (registry+https://github.com/rust-lang/crates.io-index)" = "897636f9850c3eef4905a5540683ed53dc9393860f0846cab2c2ddf9939862ff"
"checksum markup5ever 0.7.5 (registry+https://github.com/rust-lang/crates.io-index)" = "897636f9850c3eef4905a5540683ed53dc9393860f0846cab2c2ddf9939862ff"
"checksum markup5ever 0.7.5 (registry+https://github.com/rust-lang/crates.io-index)" = "897636f9850c3eef4905a5540683ed53dc9393860f0846cab2c2ddf9939862ff"
"checksum markup5ever 0.7.5 (registry+https://github.com/rust-lang/crates.io-index)" = "897636f9850c3eef4905a5540683ed53dc9393860f0846cab2c2ddf9939862ff"
"checksum markup5ever 0.7.5 (registry+https://github.com/rust-lang/crates.io-index)" = "897636f9850c3eef4905a5540683ed53dc9393860f0846cab2c2ddf9939862ff"
"checksum markup5ever 0.7.5 (registry+https://github.com/rust-lang/crates.io-index)" = "897636f9850c3eef4905a5540683ed53dc9393860f0846cab2c2ddf9939862ff"
"checksum markup5ever 0.7.3 (registry+https://github.com/rust-lang/crates.io-index)" = "a87c4100d614080c8ab43334fb028ebe387f273fb61ed4ff0eae9189b94b6be8"
"checksum markup5ever 0.7.3 (registry+https://github.com/rust-lang/crates.io-index)" = "a87c4100d614080c8ab43334fb028ebe387f273fb61ed4ff0eae9189b94b6be8"
"checksum markup5ever 0.7.3 (registry+https://github.com/rust-lang/crates.io-index)" = "a87c4100d614080c8ab43334fb028ebe387f273fb61ed4ff0eae9189b94b6be8"
"checksum markup5ever 0.7.3 (registry+https://github.com/rust-lang/crates.io-index)" = "a87c4100d614080c8ab43334fb028ebe387f273fb61ed4ff0eae9189b94b6be8"
"checksum matches 0.1.8 (registry+https://github.com/rust-lang/crates.io-index)" = "7ffc5c5338469d4d3ea17d269fa8ea3512ad247247c30bd2df69e68309ed0a08"
"checksum mac 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "c41e0c4fef86961ac6d6f8a82609f55f31b05e4fce149ac5710e439df7619ba4"
"checksum markup5ever 0.7.3 (registry+https://github.com/rust-lang/crates.io-index)" = "a87c4100d614080c8ab43334fb028ebe387f273fb61ed4ff0eae9189b94b6be8"
"checksum markup5ever 0.7.3 (registry+https://github.com/rust-lang/crates.io-index)" = "a87c4100d614080c8ab43334fb028ebe387f273fb61ed4ff0eae9189b94b6be8"
"checksum markup5ever 0.7.5 (registry+https://github.com/rust-lang/crates.io-index)" = "897636f9850c3eef4905a5540683ed53dc9393860f0846cab2c2ddf9939862ff"
"checksum markup5ever 0.7.3 (registry+https://github.com/rust-lang/crates.io-index)" = "a87c4100d614080c8ab43334fb028ebe387f273fb61ed4ff0eae9189b94b6be8"
"checksum lru-cache 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)" = "31e24f1ad8321ca0e8a1e0ac13f23cb668e6f5466c2c57319f6a5cf1cc8e3b1c"
"checksum lru-cache 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)" = "31e24f1ad8321ca0e8a1e0ac13f23cb668e6f5466c2c57319f6a5cf1cc8e3b1c"
"checksum lru-cache 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "4d06ff7ff06f729ce5f4e227876cb88d10bc59cd4ae1e09fbb2bde15c850dc21"
"checksum lru-cache 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "4d06ff7ff06f729ce5f4e227876cb88d10bc59cd4ae1e09fbb2bde15c850dc21"
"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.2 (registry+https://github.com/rust-lang/crates.io-index)" = "31e24f1ad8321ca0e8a1e0ac13f23cb668e6f5466c2c57319f6a5cf1cc8e3b1c"
"checksum lru-cache 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "4d06ff7ff06f729ce5f4e227876cb88d10bc59cd4ae1e09fbb2bde15c850dc21"
"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 lazy_static 1.3.0 (registry+https://github.com/rust-lang/crates.io-index)" = "bc5729f27f159ddd61f4df6228e827e86643d4d3e7c32183cb30a1c08f604a14"
"checksum libc 0.2.50 (registry+https://github.com/rust-lang/crates.io-index)" = "aab692d7759f5cd8c859e169db98ae5b52c924add2af5fbbca11d12fefb567c1"
"checksum linked-hash-map 0.5.2 (registry+https://github.com/rust-lang/crates.io-index)" = "ae91b68aebc4ddb91978b11a1b02ddd8602a05ec19002801c5666000e05e0f83"
"checksum libc 0.2.50 (registry+https://github.com/rust-lang/crates.io-index)" = "aab692d7759f5cd8c859e169db98ae5b52c924add2af5fbbca11d12fefb567c1"
"checksum libc 0.2.48 (registry+https://github.com/rust-lang/crates.io-index)" = "e962c7641008ac010fa60a7dfdc1712449f29c44ef2d4702394aea943ee75047"
"checksum libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)" = "bedcc7a809076656486ffe045abeeac163da1b558e963a31e29fbfbeba916917"
"checksum linked-hash-map 0.5.2 (registry+https://github.com/rust-lang/crates.io-index)" = "ae91b68aebc4ddb91978b11a1b02ddd8602a05ec19002801c5666000e05e0f83"
"checksum 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 libc 0.2.48 (registry+https://github.com/rust-lang/crates.io-index)" = "e962c7641008ac010fa60a7dfdc1712449f29c44ef2d4702394aea943ee75047"
"checksum linked-hash-map 0.4.2 (registry+https://github.com/rust-lang/crates.io-index)" = "7860ec297f7008ff7a1e3382d7f7e1dcd69efc94751a2284bafc3d013c2aa939"
"checksum libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)" = "10923947f84a519a45c8fefb7dd1b3e8c08747993381adee176d7a82b4195311"
"checksum libc 0.2.47 (registry+https://github.com/rust-lang/crates.io-index)" = "48450664a984b25d5b479554c29cc04e3150c97aa4c01da5604a2d4ed9151476"
"checksum libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)" = "bedcc7a809076656486ffe045abeeac163da1b558e963a31e29fbfbeba916917"
"checksum linked-hash-map 0.5.2 (registry+https://github.com/rust-lang/crates.io-index)" = "ae91b68aebc4ddb91978b11a1b02ddd8602a05ec19002801c5666000e05e0f83"
"checksum libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)" = "10923947f84a519a45c8fefb7dd1b3e8c08747993381adee176d7a82b4195311"
"checksum linked-hash-map 0.4.2 (registry+https://github.com/rust-lang/crates.io-index)" = "7860ec297f7008ff7a1e3382d7f7e1dcd69efc94751a2284bafc3d013c2aa939"
"checksum linked-hash-map 0.4.2 (registry+https://github.com/rust-lang/crates.io-index)" = "7860ec297f7008ff7a1e3382d7f7e1dcd69efc94751a2284bafc3d013c2aa939"
"checksum libc 0.2.48 (registry+https://github.com/rust-lang/crates.io-index)" = "e962c7641008ac010fa60a7dfdc1712449f29c44ef2d4702394aea943ee75047"
"checksum libc 0.2.49 (registry+https://github.com/rust-lang/crates.io-index)" = "413f3dfc802c5dc91dc570b05125b6cda9855edfaa9825c9849807876376e70e"
"checksum libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)" = "10923947f84a519a45c8fefb7dd1b3e8c08747993381adee176d7a82b4195311"
"checksum libc 0.2.49 (registry+https://github.com/rust-lang/crates.io-index)" = "413f3dfc802c5dc91dc570b05125b6cda9855edfaa9825c9849807876376e70e"
"checksum lazy_static 1.3.0 (registry+https://github.com/rust-lang/crates.io-index)" = "bc5729f27f159ddd61f4df6228e827e86643d4d3e7c32183cb30a1c08f604a14"
"checksum lazy_static 1.2.0 (registry+https://github.com/rust-lang/crates.io-index)" = "a374c89b9db55895453a74c1e38861d9deec0b01b405a82516e9d5de4820dea1"
"checksum lazy_static 1.2.0 (registry+https://github.com/rust-lang/crates.io-index)" = "a374c89b9db55895453a74c1e38861d9deec0b01b405a82516e9d5de4820dea1"
"checksum lazycell 1.2.1 (registry+https://github.com/rust-lang/crates.io-index)" = "b294d6fa9ee409a054354afc4352b0b9ef7ca222c69b8812cbea9e7d2bf3783f"
"checksum lazy_static 1.3.0 (registry+https://github.com/rust-lang/crates.io-index)" = "bc5729f27f159ddd61f4df6228e827e86643d4d3e7c32183cb30a1c08f604a14"
"checksum lazy_static 1.2.0 (registry+https://github.com/rust-lang/crates.io-index)" = "a374c89b9db55895453a74c1e38861d9deec0b01b405a82516e9d5de4820dea1"
"checksum lazy_static 1.2.0 (registry+https://github.com/rust-lang/crates.io-index)" = "a374c89b9db55895453a74c1e38861d9deec0b01b405a82516e9d5de4820dea1"
"checksum lazycell 1.2.1 (registry+https://github.com/rust-lang/crates.io-index)" = "b294d6fa9ee409a054354afc4352b0b9ef7ca222c69b8812cbea9e7d2bf3783f"
"checksum libc 0.2.45 (registry+https://github.com/rust-lang/crates.io-index)" = "2d2857ec59fadc0773853c664d2d18e7198e83883e7060b63c924cb077bd5c74"
"checksum libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)" = "10923947f84a519a45c8fefb7dd1b3e8c08747993381adee176d7a82b4195311"
"checksum libc 0.2.45 (registry+https://github.com/rust-lang/crates.io-index)" = "2d2857ec59fadc0773853c664d2d18e7198e83883e7060b63c924cb077bd5c74"
"checksum libc 0.2.47 (registry+https://github.com/rust-lang/crates.io-index)" = "48450664a984b25d5b479554c29cc04e3150c97aa4c01da5604a2d4ed9151476"
"checksum libc 0.2.45 (registry+https://github.com/rust-lang/crates.io-index)" = "2d2857ec59fadc0773853c664d2d18e7198e83883e7060b63c924cb077bd5c74"
"checksum libc 0.2.45 (registry+https://github.com/rust-lang/crates.io-index)" = "2d2857ec59fadc0773853c664d2d18e7198e83883e7060b63c924cb077bd5c74"
"checksum libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)" = "10923947f84a519a45c8fefb7dd1b3e8c08747993381adee176d7a82b4195311"
"checksum libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)" = "10923947f84a519a45c8fefb7dd1b3e8c08747993381adee176d7a82b4195311"
"checksum libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)" = "10923947f84a519a45c8fefb7dd1b3e8c08747993381adee176d7a82b4195311"
"checksum libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)" = "10923947f84a519a45c8fefb7dd1b3e8c08747993381adee176d7a82b4195311"
"checksum libc 0.2.47 (registry+https://github.com/rust-lang/crates.io-index)" = "48450664a984b25d5b479554c29cc04e3150c97aa4c01da5604a2d4ed9151476"
"checksum libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)" = "10923947f84a519a45c8fefb7dd1b3e8c08747993381adee176d7a82b4195311"
"checksum lazy_static 1.2.0 (registry+https://github.com/rust-lang/crates.io-index)" = "a374c89b9db55895453a74c1e38861d9deec0b01b405a82516e9d5de4820dea1"
"checksum lazy_static 1.3.0 (registry+https://github.com/rust-lang/crates.io-index)" = "bc5729f27f159ddd61f4df6228e827e86643d4d3e7c32183cb30a1c08f604a14"
"checksum jid 0.5.3 (registry+https://github.com/rust-lang/crates.io-index)" = "24e8a3f2ab860aa08074136e3144a2425e678d8823206e5adcc6145dc136503a"
"checksum jid 0.5.3 (registry+https://github.com/rust-lang/crates.io-index)" = "24e8a3f2ab860aa08074136e3144a2425e678d8823206e5adcc6145dc136503a"
"checksum jid 0.5.3 (registry+https://github.com/rust-lang/crates.io-index)" = "24e8a3f2ab860aa08074136e3144a2425e678d8823206e5adcc6145dc136503a"
"checksum jid 0.5.3 (registry+https://github.com/rust-lang/crates.io-index)" = "24e8a3f2ab860aa08074136e3144a2425e678d8823206e5adcc6145dc136503a"
"checksum jid 0.5.2 (registry+https://github.com/rust-lang/crates.io-index)" = "6c4cee633b7ce95e71202ecb99e632d15ad468de7753e616a924c93842f1a3d0"
"checksum jid 0.5.2 (registry+https://github.com/rust-lang/crates.io-index)" = "6c4cee633b7ce95e71202ecb99e632d15ad468de7753e616a924c93842f1a3d0"
"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 jid 0.5.2 (registry+https://github.com/rust-lang/crates.io-index)" = "6c4cee633b7ce95e71202ecb99e632d15ad468de7753e616a924c93842f1a3d0"
"checksum jid 0.5.2 (registry+https://github.com/rust-lang/crates.io-index)" = "6c4cee633b7ce95e71202ecb99e632d15ad468de7753e616a924c93842f1a3d0"
"checksum jid 0.5.3 (registry+https://github.com/rust-lang/crates.io-index)" = "24e8a3f2ab860aa08074136e3144a2425e678d8823206e5adcc6145dc136503a"
"checksum ipconfig 0.1.9 (registry+https://github.com/rust-lang/crates.io-index)" = "08f7eadeaf4b52700de180d147c4805f199854600b36faa963d91114827b2ffc"
"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 humantime 1.2.0 (registry+https://github.com/rust-lang/crates.io-index)" = "3ca7e5f2e110db35f93b837c81797f3714500b81d517bf20c431b16d3ca4f114"
"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 hyper 0.12.24 (registry+https://github.com/rust-lang/crates.io-index)" = "fdfa9b401ef6c4229745bb6e9b2529192d07b920eed624cdee2a82348cd550af"
"checksum hyper 0.12.25 (registry+https://github.com/rust-lang/crates.io-index)" = "7d5b6658b016965ae301fa995306db965c93677880ea70765a84235a96eae896"
"checksum hyper 0.12.23 (registry+https://github.com/rust-lang/crates.io-index)" = "860faf61a9957c9cb0e23e69f1c8290e92f6eb660fcdd1f2d6777043a2ae1a46"
"checksum hyper 0.12.27 (registry+https://github.com/rust-lang/crates.io-index)" = "4f2777434f26af6e4ce4fdcdccd3bed9d861d11e87bcbe72c0f51ddaca8ff848"
"checksum hyper 0.12.25 (registry+https://github.com/rust-lang/crates.io-index)" = "7d5b6658b016965ae301fa995306db965c93677880ea70765a84235a96eae896"
"checksum hyper 0.12.23 (registry+https://github.com/rust-lang/crates.io-index)" = "860faf61a9957c9cb0e23e69f1c8290e92f6eb660fcdd1f2d6777043a2ae1a46"
"checksum hyper 0.12.17 (registry+https://github.com/rust-lang/crates.io-index)" = "c49a75385d35ff5e9202755f09beb0b878a05c4c363fcc52b23eeb5dcb6782cc"
"checksum hyper 0.12.21 (registry+https://github.com/rust-lang/crates.io-index)" = "6d6b1a3d01ac8035b8d2d94e0e5254eab82746f09046baed763751b00253232b"
"checksum hyper 0.12.27 (registry+https://github.com/rust-lang/crates.io-index)" = "4f2777434f26af6e4ce4fdcdccd3bed9d861d11e87bcbe72c0f51ddaca8ff848"
"checksum hyper 0.12.17 (registry+https://github.com/rust-lang/crates.io-index)" = "c49a75385d35ff5e9202755f09beb0b878a05c4c363fcc52b23eeb5dcb6782cc"
"checksum hyper 0.12.23 (registry+https://github.com/rust-lang/crates.io-index)" = "860faf61a9957c9cb0e23e69f1c8290e92f6eb660fcdd1f2d6777043a2ae1a46"
"checksum hyper 0.12.25 (registry+https://github.com/rust-lang/crates.io-index)" = "7d5b6658b016965ae301fa995306db965c93677880ea70765a84235a96eae896"
"checksum hyper 0.12.17 (registry+https://github.com/rust-lang/crates.io-index)" = "c49a75385d35ff5e9202755f09beb0b878a05c4c363fcc52b23eeb5dcb6782cc"
"checksum hyper 0.12.23 (registry+https://github.com/rust-lang/crates.io-index)" = "860faf61a9957c9cb0e23e69f1c8290e92f6eb660fcdd1f2d6777043a2ae1a46"
"checksum humantime 1.2.0 (registry+https://github.com/rust-lang/crates.io-index)" = "3ca7e5f2e110db35f93b837c81797f3714500b81d517bf20c431b16d3ca4f114"
"checksum hyper 0.12.19 (registry+https://github.com/rust-lang/crates.io-index)" = "f1ebec079129e43af5e234ef36ee3d7e6085687d145b7ea653b262d16c6b65f1"
"checksum hyper 0.12.17 (registry+https://github.com/rust-lang/crates.io-index)" = "c49a75385d35ff5e9202755f09beb0b878a05c4c363fcc52b23eeb5dcb6782cc"
"checksum hyper 0.12.18 (registry+https://github.com/rust-lang/crates.io-index)" = "8dd7729fc83d88353415f6816fd4bb00897aa47c7f1506b69060e74e6e3d8e8b"
"checksum hyper 0.12.21 (registry+https://github.com/rust-lang/crates.io-index)" = "6d6b1a3d01ac8035b8d2d94e0e5254eab82746f09046baed763751b00253232b"
"checksum hyper 0.12.19 (registry+https://github.com/rust-lang/crates.io-index)" = "f1ebec079129e43af5e234ef36ee3d7e6085687d145b7ea653b262d16c6b65f1"
"checksum hyper 0.12.19 (registry+https://github.com/rust-lang/crates.io-index)" = "f1ebec079129e43af5e234ef36ee3d7e6085687d145b7ea653b262d16c6b65f1"
"checksum hyper 0.12.17 (registry+https://github.com/rust-lang/crates.io-index)" = "c49a75385d35ff5e9202755f09beb0b878a05c4c363fcc52b23eeb5dcb6782cc"
"checksum hyper 0.12.17 (registry+https://github.com/rust-lang/crates.io-index)" = "c49a75385d35ff5e9202755f09beb0b878a05c4c363fcc52b23eeb5dcb6782cc"
"checksum hyper 0.12.17 (registry+https://github.com/rust-lang/crates.io-index)" = "c49a75385d35ff5e9202755f09beb0b878a05c4c363fcc52b23eeb5dcb6782cc"
"checksum hyper 0.12.17 (registry+https://github.com/rust-lang/crates.io-index)" = "c49a75385d35ff5e9202755f09beb0b878a05c4c363fcc52b23eeb5dcb6782cc"
"checksum hyper 0.12.21 (registry+https://github.com/rust-lang/crates.io-index)" = "6d6b1a3d01ac8035b8d2d94e0e5254eab82746f09046baed763751b00253232b"
"checksum hyper 0.12.17 (registry+https://github.com/rust-lang/crates.io-index)" = "c49a75385d35ff5e9202755f09beb0b878a05c4c363fcc52b23eeb5dcb6782cc"
"checksum http 0.1.16 (registry+https://github.com/rust-lang/crates.io-index)" = "fe67e3678f2827030e89cc4b9e7ecd16d52f132c0b940ab5005f88e821500f6a"
"checksum http 0.1.15 (registry+https://github.com/rust-lang/crates.io-index)" = "1a10e5b573b9a0146545010f50772b9e8b1dd0a256564cc4307694c68832a2f5"
"checksum http 0.1.17 (registry+https://github.com/rust-lang/crates.io-index)" = "eed324f0f0daf6ec10c474f150505af2c143f251722bf9dbd1261bd1f2ee2c1a"
"checksum http 0.1.16 (registry+https://github.com/rust-lang/crates.io-index)" = "fe67e3678f2827030e89cc4b9e7ecd16d52f132c0b940ab5005f88e821500f6a"
"checksum http 0.1.15 (registry+https://github.com/rust-lang/crates.io-index)" = "1a10e5b573b9a0146545010f50772b9e8b1dd0a256564cc4307694c68832a2f5"
"checksum http 0.1.14 (registry+https://github.com/rust-lang/crates.io-index)" = "02096a6d2c55e63f7fcb800690e4f889a25f6ec342e3adb4594e293b625215ab"
"checksum http 0.1.17 (registry+https://github.com/rust-lang/crates.io-index)" = "eed324f0f0daf6ec10c474f150505af2c143f251722bf9dbd1261bd1f2ee2c1a"
"checksum http 0.1.14 (registry+https://github.com/rust-lang/crates.io-index)" = "02096a6d2c55e63f7fcb800690e4f889a25f6ec342e3adb4594e293b625215ab"
"checksum http 0.1.14 (registry+https://github.com/rust-lang/crates.io-index)" = "02096a6d2c55e63f7fcb800690e4f889a25f6ec342e3adb4594e293b625215ab"
"checksum httparse 1.3.3 (registry+https://github.com/rust-lang/crates.io-index)" = "e8734b0cfd3bc3e101ec59100e101c2eecd19282202e87808b3037b442777a83"
"checksum hostname 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)" = "21ceb46a83a85e824ef93669c8b390009623863b5c195d1ba747292c0c72f94e"
"checksum http 0.1.15 (registry+https://github.com/rust-lang/crates.io-index)" = "1a10e5b573b9a0146545010f50772b9e8b1dd0a256564cc4307694c68832a2f5"
"checksum http 0.1.16 (registry+https://github.com/rust-lang/crates.io-index)" = "fe67e3678f2827030e89cc4b9e7ecd16d52f132c0b940ab5005f88e821500f6a"
"checksum h2 0.1.13 (registry+https://github.com/rust-lang/crates.io-index)" = "7dd33bafe2e6370e6c8eb0cf1b8c5f93390b90acde7e9b03723f166b28b648ed"
"checksum h2 0.1.14 (registry+https://github.com/rust-lang/crates.io-index)" = "1ac030ae20dee464c5d0f36544d8b914a6bc606da44a57e052d2b0f5dae129e0"
"checksum generic-array 0.12.0 (registry+https://github.com/rust-lang/crates.io-index)" = "3c0f28c2f5bfb5960175af447a2da7c18900693738343dc896ffbcabd9839592"
"checksum h2 0.1.15 (registry+https://github.com/rust-lang/crates.io-index)" = "30e0b8e55b4d7ffedade2b9605851f8e85f5010663e7ad170ef3c0f0681bc43f"
"checksum hmac 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)" = "f127a908633569f208325f86f71255d3363c79721d7f9fe31cd5569908819771"
"checksum generic-array 0.12.0 (registry+https://github.com/rust-lang/crates.io-index)" = "3c0f28c2f5bfb5960175af447a2da7c18900693738343dc896ffbcabd9839592"
"checksum hmac 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)" = "f127a908633569f208325f86f71255d3363c79721d7f9fe31cd5569908819771"
"checksum h2 0.1.17 (registry+https://github.com/rust-lang/crates.io-index)" = "910a5e7be6283a9c91b3982fa5188368c8719cce2a3cf3b86048673bf9d9c36b"
"checksum h2 0.1.16 (registry+https://github.com/rust-lang/crates.io-index)" = "ddb2b25a33e231484694267af28fec74ac63b5ccf51ee2065a5e313b834d836e"
"checksum h2 0.1.16 (registry+https://github.com/rust-lang/crates.io-index)" = "ddb2b25a33e231484694267af28fec74ac63b5ccf51ee2065a5e313b834d836e"
"checksum h2 0.1.18 (registry+https://github.com/rust-lang/crates.io-index)" = "85ab6286db06040ddefb71641b50017c06874614001a134b423783e2db2920bd"
"checksum generic-array 0.12.0 (registry+https://github.com/rust-lang/crates.io-index)" = "3c0f28c2f5bfb5960175af447a2da7c18900693738343dc896ffbcabd9839592"
"checksum hmac 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)" = "f127a908633569f208325f86f71255d3363c79721d7f9fe31cd5569908819771"
"checksum h2 0.1.18 (registry+https://github.com/rust-lang/crates.io-index)" = "85ab6286db06040ddefb71641b50017c06874614001a134b423783e2db2920bd"
"checksum h2 0.1.16 (registry+https://github.com/rust-lang/crates.io-index)" = "ddb2b25a33e231484694267af28fec74ac63b5ccf51ee2065a5e313b834d836e"
"checksum generic-array 0.12.0 (registry+https://github.com/rust-lang/crates.io-index)" = "3c0f28c2f5bfb5960175af447a2da7c18900693738343dc896ffbcabd9839592"
"checksum h2 0.1.15 (registry+https://github.com/rust-lang/crates.io-index)" = "30e0b8e55b4d7ffedade2b9605851f8e85f5010663e7ad170ef3c0f0681bc43f"
"checksum hmac 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)" = "f127a908633569f208325f86f71255d3363c79721d7f9fe31cd5569908819771"
"checksum generic-array 0.9.0 (registry+https://github.com/rust-lang/crates.io-index)" = "ef25c5683767570c2bbd7deba372926a55eaae9982d7726ee2a1050239d45b9d"
"checksum h2 0.1.14 (registry+https://github.com/rust-lang/crates.io-index)" = "1ac030ae20dee464c5d0f36544d8b914a6bc606da44a57e052d2b0f5dae129e0"
"checksum generic-array 0.9.0 (registry+https://github.com/rust-lang/crates.io-index)" = "ef25c5683767570c2bbd7deba372926a55eaae9982d7726ee2a1050239d45b9d"
"checksum h2 0.1.14 (registry+https://github.com/rust-lang/crates.io-index)" = "1ac030ae20dee464c5d0f36544d8b914a6bc606da44a57e052d2b0f5dae129e0"
"checksum generic-array 0.9.0 (registry+https://github.com/rust-lang/crates.io-index)" = "ef25c5683767570c2bbd7deba372926a55eaae9982d7726ee2a1050239d45b9d"
"checksum h2 0.1.14 (registry+https://github.com/rust-lang/crates.io-index)" = "1ac030ae20dee464c5d0f36544d8b914a6bc606da44a57e052d2b0f5dae129e0"
"checksum generic-array 0.9.0 (registry+https://github.com/rust-lang/crates.io-index)" = "ef25c5683767570c2bbd7deba372926a55eaae9982d7726ee2a1050239d45b9d"
"checksum h2 0.1.14 (registry+https://github.com/rust-lang/crates.io-index)" = "1ac030ae20dee464c5d0f36544d8b914a6bc606da44a57e052d2b0f5dae129e0"
"checksum generic-array 0.12.0 (registry+https://github.com/rust-lang/crates.io-index)" = "3c0f28c2f5bfb5960175af447a2da7c18900693738343dc896ffbcabd9839592"
"checksum h2 0.1.15 (registry+https://github.com/rust-lang/crates.io-index)" = "30e0b8e55b4d7ffedade2b9605851f8e85f5010663e7ad170ef3c0f0681bc43f"
"checksum hmac 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)" = "f127a908633569f208325f86f71255d3363c79721d7f9fe31cd5569908819771"
"checksum futures 0.1.25 (registry+https://github.com/rust-lang/crates.io-index)" = "49e7653e374fe0d0c12de4250f0bdb60680b8c80eed558c5c7538eec9c89e21b"
"checksum futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)" = "62941eff9507c8177d448bd83a44d9b9760856e184081d8cd79ba9f03dd24981"
"checksum futures 0.1.25 (registry+https://github.com/rust-lang/crates.io-index)" = "49e7653e374fe0d0c12de4250f0bdb60680b8c80eed558c5c7538eec9c89e21b"
"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 fuchsia-cprng 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "a06f77d526c1a601b7c4cdd98f54b5eaabffc14d5f2f0296febdc7f357c6d3ba"
"checksum failure 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)" = "6dd377bcc1b1b7ce911967e3ec24fa19c3224394ec05b54aa7b083d498341ac7"
"checksum failure_derive 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)" = "64c2d913fe8ed3b6c6518eedf4538255b989945c14c2a7d5cbff62a5e2120596"
"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 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 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 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 failure 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)" = "e945b93ec214c6e97b520ec6c5d80267fc97af327658ee5b9f35984626e51fbf"
"checksum failure_derive 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)" = "7c395a14ab27b42704e85bf2435c5c51f334ad7a96e16fe23c6e63a1cad6cc12"
"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 failure 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)" = "6dd377bcc1b1b7ce911967e3ec24fa19c3224394ec05b54aa7b083d498341ac7"
"checksum failure_derive 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)" = "64c2d913fe8ed3b6c6518eedf4538255b989945c14c2a7d5cbff62a5e2120596"
"checksum failure 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)" = "6dd377bcc1b1b7ce911967e3ec24fa19c3224394ec05b54aa7b083d498341ac7"
"checksum failure_derive 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)" = "64c2d913fe8ed3b6c6518eedf4538255b989945c14c2a7d5cbff62a5e2120596"
"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 failure 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)" = "6dd377bcc1b1b7ce911967e3ec24fa19c3224394ec05b54aa7b083d498341ac7"
"checksum failure_derive 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)" = "64c2d913fe8ed3b6c6518eedf4538255b989945c14c2a7d5cbff62a5e2120596"
"checksum failure 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)" = "6dd377bcc1b1b7ce911967e3ec24fa19c3224394ec05b54aa7b083d498341ac7"
"checksum failure_derive 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)" = "64c2d913fe8ed3b6c6518eedf4538255b989945c14c2a7d5cbff62a5e2120596"
"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 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 error-chain 0.1.12 (registry+https://github.com/rust-lang/crates.io-index)" = "faa976b4fd2e4c2b2f3f486874b19e61944d3de3de8b61c9fcf835d583871bcc"
"checksum encoding_rs 0.8.10 (registry+https://github.com/rust-lang/crates.io-index)" = "065f4d0c826fdaef059ac45487169d918558e3cf86c9d89f6e81cf52369126e5"
"checksum encoding_rs 0.8.12 (registry+https://github.com/rust-lang/crates.io-index)" = "ca20350a7cb5aab5b9034731123d6d412caf3e92d4985e739e411ba0955fd0eb"
"checksum digest 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)" = "05f47366984d3ad862010e22c7ce81a7dbcaebbdfb37241a620f8b6596ee135c"
"checksum encoding_rs 0.8.14 (registry+https://github.com/rust-lang/crates.io-index)" = "a69d152eaa438a291636c1971b0a370212165ca8a75759eb66818c5ce9b538f7"
"checksum error-chain 0.1.12 (registry+https://github.com/rust-lang/crates.io-index)" = "faa976b4fd2e4c2b2f3f486874b19e61944d3de3de8b61c9fcf835d583871bcc"
"checksum error-chain 0.1.12 (registry+https://github.com/rust-lang/crates.io-index)" = "faa976b4fd2e4c2b2f3f486874b19e61944d3de3de8b61c9fcf835d583871bcc"
"checksum digest 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)" = "05f47366984d3ad862010e22c7ce81a7dbcaebbdfb37241a620f8b6596ee135c"
"checksum env_logger 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)" = "b61fa891024a945da30a9581546e8cfaf5602c7b3f4c137a2805cf388f92075a"
"checksum env_logger 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)" = "b61fa891024a945da30a9581546e8cfaf5602c7b3f4c137a2805cf388f92075a"
"checksum env_logger 0.6.0 (registry+https://github.com/rust-lang/crates.io-index)" = "afb070faf94c85d17d50ca44f6ad076bce18ae92f0037d350947240a36e9d42e"
"checksum encoding_rs 0.8.16 (registry+https://github.com/rust-lang/crates.io-index)" = "0535f350c60aac0b87ccf28319abc749391e912192255b0c00a2c12c6917bd73"
"checksum encoding_rs 0.8.17 (registry+https://github.com/rust-lang/crates.io-index)" = "4155785c79f2f6701f185eb2e6b4caf0555ec03477cb4c70db67b465311620ed"
"checksum encoding_rs 0.8.15 (registry+https://github.com/rust-lang/crates.io-index)" = "fd251508d65030820f3a4317af2248180db337fdb25d89967956242580277813"
"checksum encoding_rs 0.8.15 (registry+https://github.com/rust-lang/crates.io-index)" = "fd251508d65030820f3a4317af2248180db337fdb25d89967956242580277813"
"checksum env_logger 0.6.0 (registry+https://github.com/rust-lang/crates.io-index)" = "afb070faf94c85d17d50ca44f6ad076bce18ae92f0037d350947240a36e9d42e"
"checksum encoding_rs 0.8.17 (registry+https://github.com/rust-lang/crates.io-index)" = "4155785c79f2f6701f185eb2e6b4caf0555ec03477cb4c70db67b465311620ed"
"checksum env_logger 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)" = "b61fa891024a945da30a9581546e8cfaf5602c7b3f4c137a2805cf388f92075a"
"checksum encoding_rs 0.8.15 (registry+https://github.com/rust-lang/crates.io-index)" = "fd251508d65030820f3a4317af2248180db337fdb25d89967956242580277813"
"checksum encoding_rs 0.8.17 (registry+https://github.com/rust-lang/crates.io-index)" = "4155785c79f2f6701f185eb2e6b4caf0555ec03477cb4c70db67b465311620ed"
"checksum encoding_rs 0.8.15 (registry+https://github.com/rust-lang/crates.io-index)" = "fd251508d65030820f3a4317af2248180db337fdb25d89967956242580277813"
"checksum digest 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)" = "05f47366984d3ad862010e22c7ce81a7dbcaebbdfb37241a620f8b6596ee135c"
"checksum encoding_rs 0.8.17 (registry+https://github.com/rust-lang/crates.io-index)" = "4155785c79f2f6701f185eb2e6b4caf0555ec03477cb4c70db67b465311620ed"
"checksum env_logger 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)" = "b61fa891024a945da30a9581546e8cfaf5602c7b3f4c137a2805cf388f92075a"
"checksum env_logger 0.6.0 (registry+https://github.com/rust-lang/crates.io-index)" = "afb070faf94c85d17d50ca44f6ad076bce18ae92f0037d350947240a36e9d42e"
"checksum digest 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)" = "05f47366984d3ad862010e22c7ce81a7dbcaebbdfb37241a620f8b6596ee135c"
"checksum encoding_rs 0.8.14 (registry+https://github.com/rust-lang/crates.io-index)" = "a69d152eaa438a291636c1971b0a370212165ca8a75759eb66818c5ce9b538f7"
"checksum digest 0.7.6 (registry+https://github.com/rust-lang/crates.io-index)" = "03b072242a8cbaf9c145665af9d250c59af3b958f83ed6824e13533cf76d5b90"
"checksum encoding_rs 0.8.12 (registry+https://github.com/rust-lang/crates.io-index)" = "ca20350a7cb5aab5b9034731123d6d412caf3e92d4985e739e411ba0955fd0eb"
"checksum env_logger 0.6.0 (registry+https://github.com/rust-lang/crates.io-index)" = "afb070faf94c85d17d50ca44f6ad076bce18ae92f0037d350947240a36e9d42e"
"checksum error-chain 0.1.12 (registry+https://github.com/rust-lang/crates.io-index)" = "faa976b4fd2e4c2b2f3f486874b19e61944d3de3de8b61c9fcf835d583871bcc"
"checksum digest 0.7.6 (registry+https://github.com/rust-lang/crates.io-index)" = "03b072242a8cbaf9c145665af9d250c59af3b958f83ed6824e13533cf76d5b90"
"checksum env_logger 0.6.0 (registry+https://github.com/rust-lang/crates.io-index)" = "afb070faf94c85d17d50ca44f6ad076bce18ae92f0037d350947240a36e9d42e"
"checksum encoding_rs 0.8.13 (registry+https://github.com/rust-lang/crates.io-index)" = "1a8fa54e6689eb2549c4efed8d00d7f3b2b994a064555b0e8df4ae3764bcc4be"
"checksum encoding_rs 0.8.12 (registry+https://github.com/rust-lang/crates.io-index)" = "ca20350a7cb5aab5b9034731123d6d412caf3e92d4985e739e411ba0955fd0eb"
"checksum encoding_rs 0.8.13 (registry+https://github.com/rust-lang/crates.io-index)" = "1a8fa54e6689eb2549c4efed8d00d7f3b2b994a064555b0e8df4ae3764bcc4be"
"checksum encoding_rs 0.8.13 (registry+https://github.com/rust-lang/crates.io-index)" = "1a8fa54e6689eb2549c4efed8d00d7f3b2b994a064555b0e8df4ae3764bcc4be"
"checksum encoding_rs 0.8.13 (registry+https://github.com/rust-lang/crates.io-index)" = "1a8fa54e6689eb2549c4efed8d00d7f3b2b994a064555b0e8df4ae3764bcc4be"
"checksum encoding_rs 0.8.12 (registry+https://github.com/rust-lang/crates.io-index)" = "ca20350a7cb5aab5b9034731123d6d412caf3e92d4985e739e411ba0955fd0eb"
"checksum encoding_rs 0.8.12 (registry+https://github.com/rust-lang/crates.io-index)" = "ca20350a7cb5aab5b9034731123d6d412caf3e92d4985e739e411ba0955fd0eb"
"checksum encoding_rs 0.8.12 (registry+https://github.com/rust-lang/crates.io-index)" = "ca20350a7cb5aab5b9034731123d6d412caf3e92d4985e739e411ba0955fd0eb"
"checksum encoding_rs 0.8.12 (registry+https://github.com/rust-lang/crates.io-index)" = "ca20350a7cb5aab5b9034731123d6d412caf3e92d4985e739e411ba0955fd0eb"
"checksum derive-error 0.0.4 (registry+https://github.com/rust-lang/crates.io-index)" = "ec098440b29ea3b1ece3e641bac424c19cf996779b623c9e0f2171495425c2c8"
"checksum digest 0.7.6 (registry+https://github.com/rust-lang/crates.io-index)" = "03b072242a8cbaf9c145665af9d250c59af3b958f83ed6824e13533cf76d5b90"
"checksum encoding_rs 0.8.12 (registry+https://github.com/rust-lang/crates.io-index)" = "ca20350a7cb5aab5b9034731123d6d412caf3e92d4985e739e411ba0955fd0eb"
"checksum digest 0.7.6 (registry+https://github.com/rust-lang/crates.io-index)" = "03b072242a8cbaf9c145665af9d250c59af3b958f83ed6824e13533cf76d5b90"
"checksum encoding_rs 0.8.12 (registry+https://github.com/rust-lang/crates.io-index)" = "ca20350a7cb5aab5b9034731123d6d412caf3e92d4985e739e411ba0955fd0eb"
"checksum digest 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)" = "05f47366984d3ad862010e22c7ce81a7dbcaebbdfb37241a620f8b6596ee135c"
"checksum encoding_rs 0.8.14 (registry+https://github.com/rust-lang/crates.io-index)" = "a69d152eaa438a291636c1971b0a370212165ca8a75759eb66818c5ce9b538f7"
"checksum crypto-mac 0.5.2 (registry+https://github.com/rust-lang/crates.io-index)" = "0999b4ff4d3446d4ddb19a63e9e00c1876e75cd7000d20e57a693b4b3f08d958"
"checksum dbghelp-sys 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)" = "97590ba53bcb8ac28279161ca943a924d1fd4a8fb3fa63302591647c4fc5b850"
"checksum crossbeam-deque 0.6.3 (registry+https://github.com/rust-lang/crates.io-index)" = "05e44b8cf3e1a625844d1750e1f7820da46044ff6d28f4d43e455ba3e5bb2c13"
"checksum crossbeam-epoch 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)" = "f10a4f8f409aaac4b16a5474fb233624238fcdeefb9ba50d5ea059aab63ba31c"
"checksum crossbeam-utils 0.6.3 (registry+https://github.com/rust-lang/crates.io-index)" = "41ee4864f4797060e52044376f7d107429ce1fb43460021b126424b7180ee21a"
"checksum crossbeam-deque 0.6.2 (registry+https://github.com/rust-lang/crates.io-index)" = "4fe1b6f945f824c7a25afe44f62e25d714c0cc523f8e99d8db5cd1026e1269d3"
"checksum crossbeam-epoch 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)" = "2449aaa4ec7ef96e5fb24db16024b935df718e9ae1cec0a1e68feeca2efca7b8"
"checksum crossbeam-utils 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)" = "c55913cc2799171a550e307918c0a360e8c16004820291bf3b638969b4a01816"
"checksum crossbeam-deque 0.7.1 (registry+https://github.com/rust-lang/crates.io-index)" = "b18cd2e169ad86297e6bc0ad9aa679aee9daa4f19e8163860faf7c164e4f5a71"
"checksum crossbeam-queue 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)" = "7c979cd6cfe72335896575c6b5688da489e420d36a27a0b9eb0c73db574b4a4b"
"checksum crossbeam-queue 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)" = "7c979cd6cfe72335896575c6b5688da489e420d36a27a0b9eb0c73db574b4a4b"
"checksum crossbeam-queue 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)" = "7c979cd6cfe72335896575c6b5688da489e420d36a27a0b9eb0c73db574b4a4b"
"checksum crossbeam-deque 0.6.3 (registry+https://github.com/rust-lang/crates.io-index)" = "05e44b8cf3e1a625844d1750e1f7820da46044ff6d28f4d43e455ba3e5bb2c13"
"checksum crossbeam-epoch 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)" = "f10a4f8f409aaac4b16a5474fb233624238fcdeefb9ba50d5ea059aab63ba31c"
"checksum crossbeam-utils 0.6.3 (registry+https://github.com/rust-lang/crates.io-index)" = "41ee4864f4797060e52044376f7d107429ce1fb43460021b126424b7180ee21a"
"checksum crossbeam-channel 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)" = "137bc235f622ffaa0428e3854e24acb53291fc0b3ff6fb2cb75a8be6fb02f06b"
"checksum crossbeam-deque 0.6.3 (registry+https://github.com/rust-lang/crates.io-index)" = "05e44b8cf3e1a625844d1750e1f7820da46044ff6d28f4d43e455ba3e5bb2c13"
"checksum crossbeam-epoch 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)" = "f10a4f8f409aaac4b16a5474fb233624238fcdeefb9ba50d5ea059aab63ba31c"
"checksum crossbeam-utils 0.6.3 (registry+https://github.com/rust-lang/crates.io-index)" = "41ee4864f4797060e52044376f7d107429ce1fb43460021b126424b7180ee21a"
"checksum crypto-mac 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)" = "4434400df11d95d556bac068ddfedd482915eb18fe8bea89bc80b6e4b1c179e5"
"checksum crossbeam 0.6.0 (registry+https://github.com/rust-lang/crates.io-index)" = "ad4c7ea749d9fb09e23c5cb17e3b70650860553a0e2744e38446b1803bf7db94"
"checksum crossbeam-channel 0.3.8 (registry+https://github.com/rust-lang/crates.io-index)" = "0f0ed1a4de2235cabda8558ff5840bffb97fcb64c97827f354a451307df5f72b"
"checksum crossbeam-deque 0.6.3 (registry+https://github.com/rust-lang/crates.io-index)" = "05e44b8cf3e1a625844d1750e1f7820da46044ff6d28f4d43e455ba3e5bb2c13"
"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 crossbeam-epoch 0.7.1 (registry+https://github.com/rust-lang/crates.io-index)" = "04c9e3102cc2d69cd681412141b390abd55a362afc1540965dad0ad4d34280b4"
"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 crossbeam-deque 0.6.3 (registry+https://github.com/rust-lang/crates.io-index)" = "05e44b8cf3e1a625844d1750e1f7820da46044ff6d28f4d43e455ba3e5bb2c13"
"checksum crossbeam-epoch 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)" = "f10a4f8f409aaac4b16a5474fb233624238fcdeefb9ba50d5ea059aab63ba31c"
"checksum crossbeam-utils 0.6.3 (registry+https://github.com/rust-lang/crates.io-index)" = "41ee4864f4797060e52044376f7d107429ce1fb43460021b126424b7180ee21a"
"checksum crossbeam 0.6.0 (registry+https://github.com/rust-lang/crates.io-index)" = "ad4c7ea749d9fb09e23c5cb17e3b70650860553a0e2744e38446b1803bf7db94"
"checksum crossbeam-channel 0.3.8 (registry+https://github.com/rust-lang/crates.io-index)" = "0f0ed1a4de2235cabda8558ff5840bffb97fcb64c97827f354a451307df5f72b"
"checksum crossbeam-deque 0.6.3 (registry+https://github.com/rust-lang/crates.io-index)" = "05e44b8cf3e1a625844d1750e1f7820da46044ff6d28f4d43e455ba3e5bb2c13"
"checksum crossbeam-deque 0.6.2 (registry+https://github.com/rust-lang/crates.io-index)" = "4fe1b6f945f824c7a25afe44f62e25d714c0cc523f8e99d8db5cd1026e1269d3"
"checksum crossbeam-epoch 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)" = "2449aaa4ec7ef96e5fb24db16024b935df718e9ae1cec0a1e68feeca2efca7b8"
"checksum crossbeam-utils 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)" = "c55913cc2799171a550e307918c0a360e8c16004820291bf3b638969b4a01816"
"checksum crossbeam-deque 0.6.3 (registry+https://github.com/rust-lang/crates.io-index)" = "05e44b8cf3e1a625844d1750e1f7820da46044ff6d28f4d43e455ba3e5bb2c13"
"checksum crossbeam-epoch 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)" = "f10a4f8f409aaac4b16a5474fb233624238fcdeefb9ba50d5ea059aab63ba31c"
"checksum crossbeam-utils 0.6.3 (registry+https://github.com/rust-lang/crates.io-index)" = "41ee4864f4797060e52044376f7d107429ce1fb43460021b126424b7180ee21a"
"checksum crossbeam-channel 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)" = "137bc235f622ffaa0428e3854e24acb53291fc0b3ff6fb2cb75a8be6fb02f06b"
"checksum crossbeam-deque 0.6.3 (registry+https://github.com/rust-lang/crates.io-index)" = "05e44b8cf3e1a625844d1750e1f7820da46044ff6d28f4d43e455ba3e5bb2c13"
"checksum crossbeam-epoch 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)" = "f10a4f8f409aaac4b16a5474fb233624238fcdeefb9ba50d5ea059aab63ba31c"
"checksum crossbeam-utils 0.6.3 (registry+https://github.com/rust-lang/crates.io-index)" = "41ee4864f4797060e52044376f7d107429ce1fb43460021b126424b7180ee21a"
"checksum crypto-mac 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)" = "4434400df11d95d556bac068ddfedd482915eb18fe8bea89bc80b6e4b1c179e5"
"checksum crossbeam-deque 0.7.1 (registry+https://github.com/rust-lang/crates.io-index)" = "b18cd2e169ad86297e6bc0ad9aa679aee9daa4f19e8163860faf7c164e4f5a71"
"checksum crossbeam-deque 0.6.2 (registry+https://github.com/rust-lang/crates.io-index)" = "4fe1b6f945f824c7a25afe44f62e25d714c0cc523f8e99d8db5cd1026e1269d3"
"checksum crossbeam-epoch 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)" = "2449aaa4ec7ef96e5fb24db16024b935df718e9ae1cec0a1e68feeca2efca7b8"
"checksum crossbeam-utils 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)" = "c55913cc2799171a550e307918c0a360e8c16004820291bf3b638969b4a01816"
"checksum crypto-mac 0.5.2 (registry+https://github.com/rust-lang/crates.io-index)" = "0999b4ff4d3446d4ddb19a63e9e00c1876e75cd7000d20e57a693b4b3f08d958"
"checksum dbghelp-sys 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)" = "97590ba53bcb8ac28279161ca943a924d1fd4a8fb3fa63302591647c4fc5b850"
"checksum crossbeam-deque 0.6.2 (registry+https://github.com/rust-lang/crates.io-index)" = "4fe1b6f945f824c7a25afe44f62e25d714c0cc523f8e99d8db5cd1026e1269d3"
"checksum crossbeam-epoch 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)" = "2449aaa4ec7ef96e5fb24db16024b935df718e9ae1cec0a1e68feeca2efca7b8"
"checksum crossbeam-utils 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)" = "c55913cc2799171a550e307918c0a360e8c16004820291bf3b638969b4a01816"
"checksum crossbeam-deque 0.6.2 (registry+https://github.com/rust-lang/crates.io-index)" = "4fe1b6f945f824c7a25afe44f62e25d714c0cc523f8e99d8db5cd1026e1269d3"
"checksum crossbeam-epoch 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)" = "2449aaa4ec7ef96e5fb24db16024b935df718e9ae1cec0a1e68feeca2efca7b8"
"checksum crossbeam-utils 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)" = "c55913cc2799171a550e307918c0a360e8c16004820291bf3b638969b4a01816"
"checksum crossbeam-deque 0.6.2 (registry+https://github.com/rust-lang/crates.io-index)" = "4fe1b6f945f824c7a25afe44f62e25d714c0cc523f8e99d8db5cd1026e1269d3"
"checksum crossbeam-epoch 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)" = "2449aaa4ec7ef96e5fb24db16024b935df718e9ae1cec0a1e68feeca2efca7b8"
"checksum crossbeam-utils 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)" = "c55913cc2799171a550e307918c0a360e8c16004820291bf3b638969b4a01816"
"checksum crypto-mac 0.5.2 (registry+https://github.com/rust-lang/crates.io-index)" = "0999b4ff4d3446d4ddb19a63e9e00c1876e75cd7000d20e57a693b4b3f08d958"
"checksum dbghelp-sys 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)" = "97590ba53bcb8ac28279161ca943a924d1fd4a8fb3fa63302591647c4fc5b850"
"checksum crossbeam 0.6.0 (registry+https://github.com/rust-lang/crates.io-index)" = "ad4c7ea749d9fb09e23c5cb17e3b70650860553a0e2744e38446b1803bf7db94"
"checksum crossbeam-channel 0.3.8 (registry+https://github.com/rust-lang/crates.io-index)" = "0f0ed1a4de2235cabda8558ff5840bffb97fcb64c97827f354a451307df5f72b"
"checksum crossbeam-deque 0.6.3 (registry+https://github.com/rust-lang/crates.io-index)" = "05e44b8cf3e1a625844d1750e1f7820da46044ff6d28f4d43e455ba3e5bb2c13"
"checksum crossbeam-deque 0.7.1 (registry+https://github.com/rust-lang/crates.io-index)" = "b18cd2e169ad86297e6bc0ad9aa679aee9daa4f19e8163860faf7c164e4f5a71"
"checksum crossbeam-deque 0.6.2 (registry+https://github.com/rust-lang/crates.io-index)" = "4fe1b6f945f824c7a25afe44f62e25d714c0cc523f8e99d8db5cd1026e1269d3"
"checksum crossbeam-epoch 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)" = "2449aaa4ec7ef96e5fb24db16024b935df718e9ae1cec0a1e68feeca2efca7b8"
"checksum crossbeam-utils 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)" = "c55913cc2799171a550e307918c0a360e8c16004820291bf3b638969b4a01816"
"checksum crypto-mac 0.5.2 (registry+https://github.com/rust-lang/crates.io-index)" = "0999b4ff4d3446d4ddb19a63e9e00c1876e75cd7000d20e57a693b4b3f08d958"
"checksum dbghelp-sys 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)" = "97590ba53bcb8ac28279161ca943a924d1fd4a8fb3fa63302591647c4fc5b850"
"checksum crossbeam-deque 0.6.2 (registry+https://github.com/rust-lang/crates.io-index)" = "4fe1b6f945f824c7a25afe44f62e25d714c0cc523f8e99d8db5cd1026e1269d3"
"checksum crossbeam-epoch 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)" = "2449aaa4ec7ef96e5fb24db16024b935df718e9ae1cec0a1e68feeca2efca7b8"
"checksum crossbeam-utils 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)" = "c55913cc2799171a550e307918c0a360e8c16004820291bf3b638969b4a01816"
"checksum crypto-mac 0.5.2 (registry+https://github.com/rust-lang/crates.io-index)" = "0999b4ff4d3446d4ddb19a63e9e00c1876e75cd7000d20e57a693b4b3f08d958"
"checksum dbghelp-sys 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)" = "97590ba53bcb8ac28279161ca943a924d1fd4a8fb3fa63302591647c4fc5b850"
"checksum crossbeam-channel 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)" = "137bc235f622ffaa0428e3854e24acb53291fc0b3ff6fb2cb75a8be6fb02f06b"
"checksum crossbeam-deque 0.6.3 (registry+https://github.com/rust-lang/crates.io-index)" = "05e44b8cf3e1a625844d1750e1f7820da46044ff6d28f4d43e455ba3e5bb2c13"
"checksum crossbeam-epoch 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)" = "f10a4f8f409aaac4b16a5474fb233624238fcdeefb9ba50d5ea059aab63ba31c"
"checksum crossbeam-utils 0.6.3 (registry+https://github.com/rust-lang/crates.io-index)" = "41ee4864f4797060e52044376f7d107429ce1fb43460021b126424b7180ee21a"
"checksum crypto-mac 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)" = "4434400df11d95d556bac068ddfedd482915eb18fe8bea89bc80b6e4b1c179e5"
"checksum crossbeam-deque 0.6.2 (registry+https://github.com/rust-lang/crates.io-index)" = "4fe1b6f945f824c7a25afe44f62e25d714c0cc523f8e99d8db5cd1026e1269d3"
"checksum crossbeam-epoch 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)" = "2449aaa4ec7ef96e5fb24db16024b935df718e9ae1cec0a1e68feeca2efca7b8"
"checksum crossbeam-utils 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)" = "c55913cc2799171a550e307918c0a360e8c16004820291bf3b638969b4a01816"
"checksum constant_time_eq 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)" = "8ff012e225ce166d4422e0e78419d901719760f62ae2b7969ca6b564d1b54a9e"
"checksum constant_time_eq 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)" = "8ff012e225ce166d4422e0e78419d901719760f62ae2b7969ca6b564d1b54a9e"
"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 constant_time_eq 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)" = "8ff012e225ce166d4422e0e78419d901719760f62ae2b7969ca6b564d1b54a9e"
"checksum constant_time_eq 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)" = "8ff012e225ce166d4422e0e78419d901719760f62ae2b7969ca6b564d1b54a9e"
"checksum clap 2.32.0 (registry+https://github.com/rust-lang/crates.io-index)" = "b957d88f4b6a63b9d70d5f454ac8011819c6efa7727858f458ab71c756ce2d3e"
"checksum clap 2.33.0 (registry+https://github.com/rust-lang/crates.io-index)" = "5067f5bb2d80ef5d68b4c87db81601f0b75bca627bc2ef76b141d7b846a3c6d9"
"checksum clap 2.32.0 (registry+https://github.com/rust-lang/crates.io-index)" = "b957d88f4b6a63b9d70d5f454ac8011819c6efa7727858f458ab71c756ce2d3e"
"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 chrono 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)" = "45912881121cb26fad7c38c17ba7daa18764771836b34fab7d3fbd93ed633878"
"checksum cc 1.0.28 (registry+https://github.com/rust-lang/crates.io-index)" = "bb4a8b715cb4597106ea87c7c84b2f1d452c7492033765df7f32651e66fcf749"
"checksum cc 1.0.25 (registry+https://github.com/rust-lang/crates.io-index)" = "f159dfd43363c4d08055a07703eb7a3406b0dac4d0584d96965a3262db3c9d16"
"checksum cc 1.0.31 (registry+https://github.com/rust-lang/crates.io-index)" = "c9ce8bb087aacff865633f0bd5aeaed910fe2fe55b55f4739527f2e023a2e53d"
"checksum cfg-if 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)" = "11d43355396e872eefb45ce6342e4374ed7bc2b3a502d1b28e36d6e23c05d1f4"
"checksum cc 1.0.30 (registry+https://github.com/rust-lang/crates.io-index)" = "d01c69d08ff207f231f07196e30f84c70f1c815b04f980f8b7b01ff01f05eb92"
"checksum cfg-if 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)" = "11d43355396e872eefb45ce6342e4374ed7bc2b3a502d1b28e36d6e23c05d1f4"
"checksum cfg-if 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)" = "082bb9b28e00d3c9d39cc03e64ce4cea0f1bb9b3fde493f0cbc008472d22bdf4"
"checksum cc 1.0.26 (registry+https://github.com/rust-lang/crates.io-index)" = "389803e36973d242e7fecb092b2de44a3d35ac62524b3b9339e51d577d668e02"
"checksum cc 1.0.28 (registry+https://github.com/rust-lang/crates.io-index)" = "bb4a8b715cb4597106ea87c7c84b2f1d452c7492033765df7f32651e66fcf749"
"checksum cc 1.0.29 (registry+https://github.com/rust-lang/crates.io-index)" = "4390a3b5f4f6bce9c1d0c00128379df433e53777fdd30e92f16a529332baec4e"
"checksum cc 1.0.35 (registry+https://github.com/rust-lang/crates.io-index)" = "5e5f3fee5eeb60324c2781f1e41286bdee933850fff9b3c672587fed5ec58c83"
"checksum cfg-if 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)" = "11d43355396e872eefb45ce6342e4374ed7bc2b3a502d1b28e36d6e23c05d1f4"
"checksum cc 1.0.28 (registry+https://github.com/rust-lang/crates.io-index)" = "bb4a8b715cb4597106ea87c7c84b2f1d452c7492033765df7f32651e66fcf749"
"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 cc 1.0.29 (registry+https://github.com/rust-lang/crates.io-index)" = "4390a3b5f4f6bce9c1d0c00128379df433e53777fdd30e92f16a529332baec4e"
"checksum cfg-if 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)" = "082bb9b28e00d3c9d39cc03e64ce4cea0f1bb9b3fde493f0cbc008472d22bdf4"
"checksum cc 1.0.28 (registry+https://github.com/rust-lang/crates.io-index)" = "bb4a8b715cb4597106ea87c7c84b2f1d452c7492033765df7f32651e66fcf749"
"checksum cc 1.0.28 (registry+https://github.com/rust-lang/crates.io-index)" = "bb4a8b715cb4597106ea87c7c84b2f1d452c7492033765df7f32651e66fcf749"
"checksum cc 1.0.35 (registry+https://github.com/rust-lang/crates.io-index)" = "5e5f3fee5eeb60324c2781f1e41286bdee933850fff9b3c672587fed5ec58c83"
"checksum cfg-if 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)" = "11d43355396e872eefb45ce6342e4374ed7bc2b3a502d1b28e36d6e23c05d1f4"
"checksum cc 1.0.25 (registry+https://github.com/rust-lang/crates.io-index)" = "f159dfd43363c4d08055a07703eb7a3406b0dac4d0584d96965a3262db3c9d16"
"checksum cfg-if 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)" = "082bb9b28e00d3c9d39cc03e64ce4cea0f1bb9b3fde493f0cbc008472d22bdf4"
"checksum cc 1.0.25 (registry+https://github.com/rust-lang/crates.io-index)" = "f159dfd43363c4d08055a07703eb7a3406b0dac4d0584d96965a3262db3c9d16"
"checksum cc 1.0.25 (registry+https://github.com/rust-lang/crates.io-index)" = "f159dfd43363c4d08055a07703eb7a3406b0dac4d0584d96965a3262db3c9d16"
"checksum cc 1.0.25 (registry+https://github.com/rust-lang/crates.io-index)" = "f159dfd43363c4d08055a07703eb7a3406b0dac4d0584d96965a3262db3c9d16"
"checksum cfg-if 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)" = "082bb9b28e00d3c9d39cc03e64ce4cea0f1bb9b3fde493f0cbc008472d22bdf4"
"checksum case 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)" = "e88b166b48e29667f5443df64df3c61dc07dc2b1a0b0d231800e07f09a33ecc1"
"checksum cc 1.0.29 (registry+https://github.com/rust-lang/crates.io-index)" = "4390a3b5f4f6bce9c1d0c00128379df433e53777fdd30e92f16a529332baec4e"
"checksum cc 1.0.30 (registry+https://github.com/rust-lang/crates.io-index)" = "d01c69d08ff207f231f07196e30f84c70f1c815b04f980f8b7b01ff01f05eb92"
"checksum cc 1.0.25 (registry+https://github.com/rust-lang/crates.io-index)" = "f159dfd43363c4d08055a07703eb7a3406b0dac4d0584d96965a3262db3c9d16"
"checksum cc 1.0.25 (registry+https://github.com/rust-lang/crates.io-index)" = "f159dfd43363c4d08055a07703eb7a3406b0dac4d0584d96965a3262db3c9d16"
"checksum cc 1.0.28 (registry+https://github.com/rust-lang/crates.io-index)" = "bb4a8b715cb4597106ea87c7c84b2f1d452c7492033765df7f32651e66fcf749"
"checksum cc 1.0.25 (registry+https://github.com/rust-lang/crates.io-index)" = "f159dfd43363c4d08055a07703eb7a3406b0dac4d0584d96965a3262db3c9d16"
"checksum bytes 0.4.10 (registry+https://github.com/rust-lang/crates.io-index)" = "0ce55bd354b095246fc34caf4e9e242f5297a7fd938b090cadfea6eee614aa62"
"checksum bytes 0.4.11 (registry+https://github.com/rust-lang/crates.io-index)" = "40ade3d27603c2cb345eb0912aec461a6dec7e06a4ae48589904e808335c7afa"
"checksum blake2 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)" = "91721a6330935673395a0607df4d49a9cb90ae12d259f1b3e0a3f6e1d486872e"
"checksum block-buffer 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)" = "49665c62e0e700857531fa5d3763e91b539ff1abeebd56808d378b495870d60d"
"checksum block-padding 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)" = "4fc4358306e344bf9775d0197fd00d2603e5afb0771bb353538630f022068ea3"
"checksum byte-tools 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)" = "980479e6fde23246dfb54d47580d66b4e99202e7579c5eaa9fe10ecb5ebd2182"
"checksum byteorder 1.3.0 (registry+https://github.com/rust-lang/crates.io-index)" = "60f0b0d4c0a382d2734228fd12b5a6b5dac185c60e938026fd31b265b94f9bd2"
"checksum blake2 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)" = "91721a6330935673395a0607df4d49a9cb90ae12d259f1b3e0a3f6e1d486872e"
"checksum block-padding 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)" = "d75255892aeb580d3c566f213a2b6fdc1c66667839f45719ee1d30ebf2aea591"
"checksum byte-tools 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)" = "e3b5ca7a04898ad4bcd41c90c5285445ff5b791899bb1b0abdd2a2aa791211d7"
"checksum byteorder 1.3.1 (registry+https://github.com/rust-lang/crates.io-index)" = "a019b10a2a7cdeb292db131fc8113e57ea2a908f6e7894b0c3c671893b65dbeb"
"checksum bytes 0.4.12 (registry+https://github.com/rust-lang/crates.io-index)" = "206fdffcfa2df7cbe15601ef46c813fce0965eb3286db6b56c583b814b51c81c"
"checksum bytes 0.4.12 (registry+https://github.com/rust-lang/crates.io-index)" = "206fdffcfa2df7cbe15601ef46c813fce0965eb3286db6b56c583b814b51c81c"
"checksum bytes 0.4.11 (registry+https://github.com/rust-lang/crates.io-index)" = "40ade3d27603c2cb345eb0912aec461a6dec7e06a4ae48589904e808335c7afa"
"checksum bytes 0.4.12 (registry+https://github.com/rust-lang/crates.io-index)" = "206fdffcfa2df7cbe15601ef46c813fce0965eb3286db6b56c583b814b51c81c"
"checksum bytes 0.4.11 (registry+https://github.com/rust-lang/crates.io-index)" = "40ade3d27603c2cb345eb0912aec461a6dec7e06a4ae48589904e808335c7afa"
"checksum block-buffer 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)" = "49665c62e0e700857531fa5d3763e91b539ff1abeebd56808d378b495870d60d"
"checksum block-buffer 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)" = "49665c62e0e700857531fa5d3763e91b539ff1abeebd56808d378b495870d60d"
"checksum block-buffer 0.7.2 (registry+https://github.com/rust-lang/crates.io-index)" = "509de513cca6d92b6aacf9c61acfe7eaa160837323a81068d690cc1f8e5740da"
"checksum block-buffer 0.7.2 (registry+https://github.com/rust-lang/crates.io-index)" = "509de513cca6d92b6aacf9c61acfe7eaa160837323a81068d690cc1f8e5740da"
"checksum block-buffer 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)" = "49665c62e0e700857531fa5d3763e91b539ff1abeebd56808d378b495870d60d"
"checksum block-buffer 0.7.2 (registry+https://github.com/rust-lang/crates.io-index)" = "509de513cca6d92b6aacf9c61acfe7eaa160837323a81068d690cc1f8e5740da"
"checksum block-buffer 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)" = "49665c62e0e700857531fa5d3763e91b539ff1abeebd56808d378b495870d60d"
"checksum block-buffer 0.7.2 (registry+https://github.com/rust-lang/crates.io-index)" = "509de513cca6d92b6aacf9c61acfe7eaa160837323a81068d690cc1f8e5740da"
"checksum blake2 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)" = "91721a6330935673395a0607df4d49a9cb90ae12d259f1b3e0a3f6e1d486872e"
"checksum block-buffer 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)" = "49665c62e0e700857531fa5d3763e91b539ff1abeebd56808d378b495870d60d"
"checksum block-padding 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)" = "d75255892aeb580d3c566f213a2b6fdc1c66667839f45719ee1d30ebf2aea591"
"checksum byte-tools 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)" = "e3b5ca7a04898ad4bcd41c90c5285445ff5b791899bb1b0abdd2a2aa791211d7"
"checksum byteorder 1.3.1 (registry+https://github.com/rust-lang/crates.io-index)" = "a019b10a2a7cdeb292db131fc8113e57ea2a908f6e7894b0c3c671893b65dbeb"
"checksum bytes 0.4.12 (registry+https://github.com/rust-lang/crates.io-index)" = "206fdffcfa2df7cbe15601ef46c813fce0965eb3286db6b56c583b814b51c81c"
"checksum bytes 0.4.11 (registry+https://github.com/rust-lang/crates.io-index)" = "40ade3d27603c2cb345eb0912aec461a6dec7e06a4ae48589904e808335c7afa"
"checksum blake2 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)" = "91721a6330935673395a0607df4d49a9cb90ae12d259f1b3e0a3f6e1d486872e"
"checksum block-buffer 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)" = "49665c62e0e700857531fa5d3763e91b539ff1abeebd56808d378b495870d60d"
"checksum block-padding 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)" = "4fc4358306e344bf9775d0197fd00d2603e5afb0771bb353538630f022068ea3"
"checksum byte-tools 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)" = "980479e6fde23246dfb54d47580d66b4e99202e7579c5eaa9fe10ecb5ebd2182"
"checksum byteorder 1.3.0 (registry+https://github.com/rust-lang/crates.io-index)" = "60f0b0d4c0a382d2734228fd12b5a6b5dac185c60e938026fd31b265b94f9bd2"
"checksum blake2 0.7.1 (registry+https://github.com/rust-lang/crates.io-index)" = "73b77e29dbd0115e43938be2d5128ecf81c0353e00acaa65339a1242586951d9"
"checksum block-buffer 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)" = "a076c298b9ecdb530ed9d967e74a6027d6a7478924520acddcddc24c1c8ab3ab"
"checksum byte-tools 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)" = "560c32574a12a89ecd91f5e742165893f86e3ab98d21f8ea548658eb9eef5f40"
"checksum byteorder 1.2.7 (registry+https://github.com/rust-lang/crates.io-index)" = "94f88df23a25417badc922ab0f5716cc1330e87f71ddd9203b3a3ccd9cedf75d"
"checksum bytes 0.4.11 (registry+https://github.com/rust-lang/crates.io-index)" = "40ade3d27603c2cb345eb0912aec461a6dec7e06a4ae48589904e808335c7afa"
"checksum blake2 0.7.1 (registry+https://github.com/rust-lang/crates.io-index)" = "73b77e29dbd0115e43938be2d5128ecf81c0353e00acaa65339a1242586951d9"
"checksum block-buffer 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)" = "a076c298b9ecdb530ed9d967e74a6027d6a7478924520acddcddc24c1c8ab3ab"
"checksum byte-tools 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)" = "560c32574a12a89ecd91f5e742165893f86e3ab98d21f8ea548658eb9eef5f40"
"checksum byteorder 1.2.7 (registry+https://github.com/rust-lang/crates.io-index)" = "94f88df23a25417badc922ab0f5716cc1330e87f71ddd9203b3a3ccd9cedf75d"
"checksum bytes 0.4.11 (registry+https://github.com/rust-lang/crates.io-index)" = "40ade3d27603c2cb345eb0912aec461a6dec7e06a4ae48589904e808335c7afa"
"checksum blake2 0.7.1 (registry+https://github.com/rust-lang/crates.io-index)" = "73b77e29dbd0115e43938be2d5128ecf81c0353e00acaa65339a1242586951d9"
"checksum block-buffer 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)" = "a076c298b9ecdb530ed9d967e74a6027d6a7478924520acddcddc24c1c8ab3ab"
"checksum byte-tools 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)" = "560c32574a12a89ecd91f5e742165893f86e3ab98d21f8ea548658eb9eef5f40"
"checksum byteorder 1.2.7 (registry+https://github.com/rust-lang/crates.io-index)" = "94f88df23a25417badc922ab0f5716cc1330e87f71ddd9203b3a3ccd9cedf75d"
"checksum blake2 0.7.1 (registry+https://github.com/rust-lang/crates.io-index)" = "73b77e29dbd0115e43938be2d5128ecf81c0353e00acaa65339a1242586951d9"
"checksum block-buffer 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)" = "a076c298b9ecdb530ed9d967e74a6027d6a7478924520acddcddc24c1c8ab3ab"
"checksum byte-tools 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)" = "560c32574a12a89ecd91f5e742165893f86e3ab98d21f8ea548658eb9eef5f40"
"checksum byteorder 1.2.7 (registry+https://github.com/rust-lang/crates.io-index)" = "94f88df23a25417badc922ab0f5716cc1330e87f71ddd9203b3a3ccd9cedf75d"
"checksum blake2 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)" = "91721a6330935673395a0607df4d49a9cb90ae12d259f1b3e0a3f6e1d486872e"
"checksum block-buffer 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)" = "49665c62e0e700857531fa5d3763e91b539ff1abeebd56808d378b495870d60d"
"checksum block-padding 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)" = "4fc4358306e344bf9775d0197fd00d2603e5afb0771bb353538630f022068ea3"
"checksum byte-tools 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)" = "980479e6fde23246dfb54d47580d66b4e99202e7579c5eaa9fe10ecb5ebd2182"
"checksum byteorder 1.3.0 (registry+https://github.com/rust-lang/crates.io-index)" = "60f0b0d4c0a382d2734228fd12b5a6b5dac185c60e938026fd31b265b94f9bd2"
"checksum autocfg 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "4e5f34df7a019573fb8bdc7e24a2bfebe51a2a1d6bfdbaeccedb3c41fc574727"
"checksum backtrace 0.3.13 (registry+https://github.com/rust-lang/crates.io-index)" = "b5b493b66e03090ebc4343eb02f94ff944e0cbc9ac6571491d170ba026741eb5"
"checksum backtrace-sys 0.1.28 (registry+https://github.com/rust-lang/crates.io-index)" = "797c830ac25ccc92a7f8a7b9862bde440715531514594a6154e3d4a54dd769b6"
"checksum bitflags 1.0.4 (registry+https://github.com/rust-lang/crates.io-index)" = "228047a76f468627ca71776ecdebd732a3423081fcf5125585bcd7c49886ce12"
"checksum backtrace 0.3.9 (registry+https://github.com/rust-lang/crates.io-index)" = "89a47830402e9981c5c41223151efcced65a0510c13097c769cede7efb34782a"
"checksum backtrace-sys 0.1.24 (registry+https://github.com/rust-lang/crates.io-index)" = "c66d56ac8dabd07f6aacdaf633f4b8262f5b3601a810a0dcddffd5c22c69daa0"
"checksum backtrace 0.3.13 (registry+https://github.com/rust-lang/crates.io-index)" = "b5b493b66e03090ebc4343eb02f94ff944e0cbc9ac6571491d170ba026741eb5"
"checksum backtrace-sys 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)" = "3fcce89e5ad5c8949caa9434501f7b55415b3e7ad5270cb88c75a8d35e8f1279"
"checksum backtrace 0.3.13 (registry+https://github.com/rust-lang/crates.io-index)" = "b5b493b66e03090ebc4343eb02f94ff944e0cbc9ac6571491d170ba026741eb5"
"checksum backtrace-sys 0.1.28 (registry+https://github.com/rust-lang/crates.io-index)" = "797c830ac25ccc92a7f8a7b9862bde440715531514594a6154e3d4a54dd769b6"
"checksum backtrace 0.3.13 (registry+https://github.com/rust-lang/crates.io-index)" = "b5b493b66e03090ebc4343eb02f94ff944e0cbc9ac6571491d170ba026741eb5"
"checksum backtrace-sys 0.1.28 (registry+https://github.com/rust-lang/crates.io-index)" = "797c830ac25ccc92a7f8a7b9862bde440715531514594a6154e3d4a54dd769b6"
"checksum backtrace 0.3.9 (registry+https://github.com/rust-lang/crates.io-index)" = "89a47830402e9981c5c41223151efcced65a0510c13097c769cede7efb34782a"
"checksum backtrace-sys 0.1.24 (registry+https://github.com/rust-lang/crates.io-index)" = "c66d56ac8dabd07f6aacdaf633f4b8262f5b3601a810a0dcddffd5c22c69daa0"
"checksum backtrace 0.3.9 (registry+https://github.com/rust-lang/crates.io-index)" = "89a47830402e9981c5c41223151efcced65a0510c13097c769cede7efb34782a"
"checksum backtrace-sys 0.1.24 (registry+https://github.com/rust-lang/crates.io-index)" = "c66d56ac8dabd07f6aacdaf633f4b8262f5b3601a810a0dcddffd5c22c69daa0"
"checksum backtrace 0.3.9 (registry+https://github.com/rust-lang/crates.io-index)" = "89a47830402e9981c5c41223151efcced65a0510c13097c769cede7efb34782a"
"checksum backtrace-sys 0.1.24 (registry+https://github.com/rust-lang/crates.io-index)" = "c66d56ac8dabd07f6aacdaf633f4b8262f5b3601a810a0dcddffd5c22c69daa0"
"checksum base64 0.9.3 (registry+https://github.com/rust-lang/crates.io-index)" = "489d6c0ed21b11d038c31b6ceccca973e65d73ba3bd8ecb9a2babf5546164643"
"checksum backtrace 0.3.9 (registry+https://github.com/rust-lang/crates.io-index)" = "89a47830402e9981c5c41223151efcced65a0510c13097c769cede7efb34782a"
"checksum backtrace-sys 0.1.24 (registry+https://github.com/rust-lang/crates.io-index)" = "c66d56ac8dabd07f6aacdaf633f4b8262f5b3601a810a0dcddffd5c22c69daa0"
"checksum autocfg 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "4e5f34df7a019573fb8bdc7e24a2bfebe51a2a1d6bfdbaeccedb3c41fc574727"
"checksum autocfg 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)" = "a6d640bee2da49f60a4068a7fae53acde8982514ab7bae8b8cea9e88cbcfd799"
"checksum backtrace 0.3.13 (registry+https://github.com/rust-lang/crates.io-index)" = "b5b493b66e03090ebc4343eb02f94ff944e0cbc9ac6571491d170ba026741eb5"
"checksum backtrace-sys 0.1.28 (registry+https://github.com/rust-lang/crates.io-index)" = "797c830ac25ccc92a7f8a7b9862bde440715531514594a6154e3d4a54dd769b6"
"checksum base64 0.10.0 (registry+https://github.com/rust-lang/crates.io-index)" = "621fc7ecb8008f86d7fb9b95356cd692ce9514b80a86d85b397f32a22da7b9e2"
"checksum autocfg 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)" = "a6d640bee2da49f60a4068a7fae53acde8982514ab7bae8b8cea9e88cbcfd799"
"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 backtrace 0.3.14 (registry+https://github.com/rust-lang/crates.io-index)" = "cd5a90e2b463010cd0e0ce9a11d4a9d5d58d9f41d4a6ba3dcaf9e68b466e88b4"
"checksum backtrace 0.3.13 (registry+https://github.com/rust-lang/crates.io-index)" = "b5b493b66e03090ebc4343eb02f94ff944e0cbc9ac6571491d170ba026741eb5"
"checksum backtrace 0.3.13 (registry+https://github.com/rust-lang/crates.io-index)" = "b5b493b66e03090ebc4343eb02f94ff944e0cbc9ac6571491d170ba026741eb5"
"checksum backtrace 0.3.15 (registry+https://github.com/rust-lang/crates.io-index)" = "f106c02a3604afcdc0df5d36cc47b44b55917dbaf3d808f71c163a0ddba64637"
"checksum backtrace 0.3.13 (registry+https://github.com/rust-lang/crates.io-index)" = "b5b493b66e03090ebc4343eb02f94ff944e0cbc9ac6571491d170ba026741eb5"
"checksum backtrace 0.3.14 (registry+https://github.com/rust-lang/crates.io-index)" = "cd5a90e2b463010cd0e0ce9a11d4a9d5d58d9f41d4a6ba3dcaf9e68b466e88b4"
"checksum backtrace 0.3.15 (registry+https://github.com/rust-lang/crates.io-index)" = "f106c02a3604afcdc0df5d36cc47b44b55917dbaf3d808f71c163a0ddba64637"
"checksum backtrace-sys 0.1.28 (registry+https://github.com/rust-lang/crates.io-index)" = "797c830ac25ccc92a7f8a7b9862bde440715531514594a6154e3d4a54dd769b6"
"checksum base64 0.10.1 (registry+https://github.com/rust-lang/crates.io-index)" = "0b25d992356d2eb0ed82172f5248873db5560c4721f564b13cb5193bda5e668e"
"checksum autocfg 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)" = "a6d640bee2da49f60a4068a7fae53acde8982514ab7bae8b8cea9e88cbcfd799"
"checksum autocfg 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "4e5f34df7a019573fb8bdc7e24a2bfebe51a2a1d6bfdbaeccedb3c41fc574727"
"checksum backtrace 0.3.14 (registry+https://github.com/rust-lang/crates.io-index)" = "cd5a90e2b463010cd0e0ce9a11d4a9d5d58d9f41d4a6ba3dcaf9e68b466e88b4"
"checksum autocfg 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "4e5f34df7a019573fb8bdc7e24a2bfebe51a2a1d6bfdbaeccedb3c41fc574727"
"checksum autocfg 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)" = "a6d640bee2da49f60a4068a7fae53acde8982514ab7bae8b8cea9e88cbcfd799"
"checksum backtrace 0.3.13 (registry+https://github.com/rust-lang/crates.io-index)" = "b5b493b66e03090ebc4343eb02f94ff944e0cbc9ac6571491d170ba026741eb5"
"checksum backtrace-sys 0.1.28 (registry+https://github.com/rust-lang/crates.io-index)" = "797c830ac25ccc92a7f8a7b9862bde440715531514594a6154e3d4a54dd769b6"
"checksum base64 0.10.0 (registry+https://github.com/rust-lang/crates.io-index)" = "621fc7ecb8008f86d7fb9b95356cd692ce9514b80a86d85b397f32a22da7b9e2"
"checksum backtrace 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)" = "346d7644f0b5f9bc73082d3b2236b69a05fd35cce0cfa3724e184e6a5c9e2a2f"
"checksum backtrace 0.3.9 (registry+https://github.com/rust-lang/crates.io-index)" = "89a47830402e9981c5c41223151efcced65a0510c13097c769cede7efb34782a"
"checksum backtrace-sys 0.1.24 (registry+https://github.com/rust-lang/crates.io-index)" = "c66d56ac8dabd07f6aacdaf633f4b8262f5b3601a810a0dcddffd5c22c69daa0"
"checksum base64 0.9.3 (registry+https://github.com/rust-lang/crates.io-index)" = "489d6c0ed21b11d038c31b6ceccca973e65d73ba3bd8ecb9a2babf5546164643"
"checksum backtrace 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)" = "346d7644f0b5f9bc73082d3b2236b69a05fd35cce0cfa3724e184e6a5c9e2a2f"
"checksum backtrace 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)" = "346d7644f0b5f9bc73082d3b2236b69a05fd35cce0cfa3724e184e6a5c9e2a2f"
"checksum backtrace 0.3.9 (registry+https://github.com/rust-lang/crates.io-index)" = "89a47830402e9981c5c41223151efcced65a0510c13097c769cede7efb34782a"
"checksum backtrace-sys 0.1.24 (registry+https://github.com/rust-lang/crates.io-index)" = "c66d56ac8dabd07f6aacdaf633f4b8262f5b3601a810a0dcddffd5c22c69daa0"
"checksum base64 0.9.3 (registry+https://github.com/rust-lang/crates.io-index)" = "489d6c0ed21b11d038c31b6ceccca973e65d73ba3bd8ecb9a2babf5546164643"
"checksum backtrace 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)" = "346d7644f0b5f9bc73082d3b2236b69a05fd35cce0cfa3724e184e6a5c9e2a2f"
"checksum backtrace 0.3.9 (registry+https://github.com/rust-lang/crates.io-index)" = "89a47830402e9981c5c41223151efcced65a0510c13097c769cede7efb34782a"
"checksum backtrace-sys 0.1.24 (registry+https://github.com/rust-lang/crates.io-index)" = "c66d56ac8dabd07f6aacdaf633f4b8262f5b3601a810a0dcddffd5c22c69daa0"
"checksum base64 0.9.3 (registry+https://github.com/rust-lang/crates.io-index)" = "489d6c0ed21b11d038c31b6ceccca973e65d73ba3bd8ecb9a2babf5546164643"
"checksum autocfg 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)" = "a6d640bee2da49f60a4068a7fae53acde8982514ab7bae8b8cea9e88cbcfd799"
"checksum backtrace 0.3.13 (registry+https://github.com/rust-lang/crates.io-index)" = "b5b493b66e03090ebc4343eb02f94ff944e0cbc9ac6571491d170ba026741eb5"
"checksum backtrace-sys 0.1.28 (registry+https://github.com/rust-lang/crates.io-index)" = "797c830ac25ccc92a7f8a7b9862bde440715531514594a6154e3d4a54dd769b6"
"checksum base64 0.10.0 (registry+https://github.com/rust-lang/crates.io-index)" = "621fc7ecb8008f86d7fb9b95356cd692ce9514b80a86d85b397f32a22da7b9e2"
"checksum arrayvec 0.4.8 (registry+https://github.com/rust-lang/crates.io-index)" = "f405cc4c21cd8b784f6c8fc2adf9bc00f59558f0049b5ec21517f875963040cc"
"checksum arrayref 0.3.5 (registry+https://github.com/rust-lang/crates.io-index)" = "0d382e583f07208808f6b1249e60848879ba3543f57c32277bf52d69c2f0f0ee"
"checksum atty 0.2.11 (registry+https://github.com/rust-lang/crates.io-index)" = "9a7d5b8723950951411ee34d271d99dddcc2035a16ab25310ea2c8cfd4369652"
"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 arrayvec 0.4.8 (registry+https://github.com/rust-lang/crates.io-index)" = "f405cc4c21cd8b784f6c8fc2adf9bc00f59558f0049b5ec21517f875963040cc"
"checksum arrayvec 0.4.9 (registry+https://github.com/rust-lang/crates.io-index)" = "d18513977c2d8261c448511c5c53dc66b26dfccbc3d4446672dea1e71a7d8a26"
"checksum arrayvec 0.4.10 (registry+https://github.com/rust-lang/crates.io-index)" = "92c7fb76bc8826a8b33b4ee5bb07a247a81e76764ab4d55e8f73e3a4d8808c71"
"checksum arrayvec 0.4.10 (registry+https://github.com/rust-lang/crates.io-index)" = "92c7fb76bc8826a8b33b4ee5bb07a247a81e76764ab4d55e8f73e3a4d8808c71"
"checksum arrayvec 0.4.8 (registry+https://github.com/rust-lang/crates.io-index)" = "f405cc4c21cd8b784f6c8fc2adf9bc00f59558f0049b5ec21517f875963040cc"
"checksum arrayvec 0.4.8 (registry+https://github.com/rust-lang/crates.io-index)" = "f405cc4c21cd8b784f6c8fc2adf9bc00f59558f0049b5ec21517f875963040cc"
"checksum arrayvec 0.4.8 (registry+https://github.com/rust-lang/crates.io-index)" = "f405cc4c21cd8b784f6c8fc2adf9bc00f59558f0049b5ec21517f875963040cc"
"checksum arrayvec 0.4.8 (registry+https://github.com/rust-lang/crates.io-index)" = "f405cc4c21cd8b784f6c8fc2adf9bc00f59558f0049b5ec21517f875963040cc"
"checksum arc-swap 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)" = "5c5ed110e2537bdd3f5b9091707a8a5556a72ac49bbd7302ae0b28fdccb3246c"
"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 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 arc-swap 0.3.10 (registry+https://github.com/rust-lang/crates.io-index)" = "a57a5698f85c6fd92f19dad87ff2d822fc4ba79dd85c13914d8c4dad589cb815"
"checksum arrayvec 0.4.10 (registry+https://github.com/rust-lang/crates.io-index)" = "92c7fb76bc8826a8b33b4ee5bb07a247a81e76764ab4d55e8f73e3a4d8808c71"
"checksum arc-swap 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)" = "1025aeae2b664ca0ea726a89d574fe8f4e77dd712d443236ad1de00379450cf6"
"checksum arc-swap 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)" = "1025aeae2b664ca0ea726a89d574fe8f4e77dd712d443236ad1de00379450cf6"
"checksum arc-swap 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)" = "5c5ed110e2537bdd3f5b9091707a8a5556a72ac49bbd7302ae0b28fdccb3246c"
"checksum arc-swap 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)" = "1025aeae2b664ca0ea726a89d574fe8f4e77dd712d443236ad1de00379450cf6"
"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 arc-swap 0.3.10 (registry+https://github.com/rust-lang/crates.io-index)" = "a57a5698f85c6fd92f19dad87ff2d822fc4ba79dd85c13914d8c4dad589cb815"
"checksum arc-swap 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)" = "5c5ed110e2537bdd3f5b9091707a8a5556a72ac49bbd7302ae0b28fdccb3246c"
"checksum arrayref 0.3.5 (registry+https://github.com/rust-lang/crates.io-index)" = "0d382e583f07208808f6b1249e60848879ba3543f57c32277bf52d69c2f0f0ee"
"checksum arrayvec 0.4.8 (registry+https://github.com/rust-lang/crates.io-index)" = "f405cc4c21cd8b784f6c8fc2adf9bc00f59558f0049b5ec21517f875963040cc"
"checksum arc-swap 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)" = "5c5ed110e2537bdd3f5b9091707a8a5556a72ac49bbd7302ae0b28fdccb3246c"
"checksum arc-swap 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)" = "5c5ed110e2537bdd3f5b9091707a8a5556a72ac49bbd7302ae0b28fdccb3246c"
"checksum arrayref 0.3.5 (registry+https://github.com/rust-lang/crates.io-index)" = "0d382e583f07208808f6b1249e60848879ba3543f57c32277bf52d69c2f0f0ee"
"checksum ansi_term 0.11.0 (registry+https://github.com/rust-lang/crates.io-index)" = "ee49baf6cb617b853aa8d93bf420db2383fab46d314482ca2803b40d5fde979b"
"checksum arc-swap 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)" = "5c5ed110e2537bdd3f5b9091707a8a5556a72ac49bbd7302ae0b28fdccb3246c"
"checksum arrayref 0.3.5 (registry+https://github.com/rust-lang/crates.io-index)" = "0d382e583f07208808f6b1249e60848879ba3543f57c32277bf52d69c2f0f0ee"
"checksum arrayvec 0.4.8 (registry+https://github.com/rust-lang/crates.io-index)" = "f405cc4c21cd8b784f6c8fc2adf9bc00f59558f0049b5ec21517f875963040cc"
"checksum arc-swap 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)" = "5c5ed110e2537bdd3f5b9091707a8a5556a72ac49bbd7302ae0b28fdccb3246c"
"checksum arrayref 0.3.5 (registry+https://github.com/rust-lang/crates.io-index)" = "0d382e583f07208808f6b1249e60848879ba3543f57c32277bf52d69c2f0f0ee"
"checksum arrayvec 0.4.8 (registry+https://github.com/rust-lang/crates.io-index)" = "f405cc4c21cd8b784f6c8fc2adf9bc00f59558f0049b5ec21517f875963040cc"
"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 arc-swap 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)" = "5c5ed110e2537bdd3f5b9091707a8a5556a72ac49bbd7302ae0b28fdccb3246c"
"checksum MacTypes-sys 2.1.0 (registry+https://github.com/rust-lang/crates.io-index)" = "eaf9f0d0b1cc33a4d2aee14fb4b2eac03462ef4db29c8ac4057327d8a71ad86f"
"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 aho-corasick 0.6.10 (registry+https://github.com/rust-lang/crates.io-index)" = "81ce3d38065e618af2d7b77e10c5ad9a069859b4be3c2250f674af3840d9c8a5"
"checksum aho-corasick 0.6.9 (registry+https://github.com/rust-lang/crates.io-index)" = "1e9a933f4e58658d7b12defcf96dc5c720f20832deebe3e0a19efd3b6aaeeb9e"
"checksum aho-corasick 0.7.3 (registry+https://github.com/rust-lang/crates.io-index)" = "e6f484ae0c99fec2e858eb6134949117399f222608d84cadb3f58c1f97c2364c"
"checksum aho-corasick 0.6.9 (registry+https://github.com/rust-lang/crates.io-index)" = "1e9a933f4e58658d7b12defcf96dc5c720f20832deebe3e0a19efd3b6aaeeb9e"
"checksum aho-corasick 0.6.10 (registry+https://github.com/rust-lang/crates.io-index)" = "81ce3d38065e618af2d7b77e10c5ad9a069859b4be3c2250f674af3840d9c8a5"
"checksum aho-corasick 0.6.9 (registry+https://github.com/rust-lang/crates.io-index)" = "1e9a933f4e58658d7b12defcf96dc5c720f20832deebe3e0a19efd3b6aaeeb9e"
"checksum MacTypes-sys 2.1.0 (registry+https://github.com/rust-lang/crates.io-index)" = "eaf9f0d0b1cc33a4d2aee14fb4b2eac03462ef4db29c8ac4057327d8a71ad86f"
"checksum aho-corasick 0.7.3 (registry+https://github.com/rust-lang/crates.io-index)" = "e6f484ae0c99fec2e858eb6134949117399f222608d84cadb3f58c1f97c2364c"
"checksum aho-corasick 0.6.10 (registry+https://github.com/rust-lang/crates.io-index)" = "81ce3d38065e618af2d7b77e10c5ad9a069859b4be3c2250f674af3840d9c8a5"
"checksum MacTypes-sys 1.3.0 (registry+https://github.com/rust-lang/crates.io-index)" = "7dbbe033994ae2198a18517c7132d952a29fb1db44249a1234779da7c50f4698"
"checksum aho-corasick 0.6.9 (registry+https://github.com/rust-lang/crates.io-index)" = "1e9a933f4e58658d7b12defcf96dc5c720f20832deebe3e0a19efd3b6aaeeb9e"
"checksum MacTypes-sys 1.3.0 (registry+https://github.com/rust-lang/crates.io-index)" = "7dbbe033994ae2198a18517c7132d952a29fb1db44249a1234779da7c50f4698"
"checksum MacTypes-sys 2.1.0 (registry+https://github.com/rust-lang/crates.io-index)" = "eaf9f0d0b1cc33a4d2aee14fb4b2eac03462ef4db29c8ac4057327d8a71ad86f"
"checksum aho-corasick 0.6.9 (registry+https://github.com/rust-lang/crates.io-index)" = "1e9a933f4e58658d7b12defcf96dc5c720f20832deebe3e0a19efd3b6aaeeb9e"
"checksum aho-corasick 0.6.9 (registry+https://github.com/rust-lang/crates.io-index)" = "1e9a933f4e58658d7b12defcf96dc5c720f20832deebe3e0a19efd3b6aaeeb9e"
"checksum MacTypes-sys 2.1.0 (registry+https://github.com/rust-lang/crates.io-index)" = "eaf9f0d0b1cc33a4d2aee14fb4b2eac03462ef4db29c8ac4057327d8a71ad86f"
]
[metadata]
 "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)",
 "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)",
 "digest 0.7.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "jid 0.5.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "minidom 0.9.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "sha-1 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "sha2 0.7.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "sha3 0.7.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "try_from 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "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)",
 "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)",
 "base64 0.9.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "blake2 0.7.1 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.12.2"
version = "0.13.1"
version = "0.11.1"
]
[[package]]
name = "xmpp-parsers"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "chrono 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "digest 0.7.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "jid 0.5.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "minidom 0.9.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "sha-1 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "sha2 0.7.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "sha3 0.7.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "try_from 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "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)",
 "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)",
 "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)",
 "digest 0.7.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "jid 0.5.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "minidom 0.9.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "sha-1 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "sha2 0.7.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "sha3 0.7.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "try_from 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "digest 0.7.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "jid 0.5.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "minidom 0.9.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "sha-1 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "sha2 0.7.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "sha3 0.7.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "try_from 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "digest 0.7.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "jid 0.5.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "minidom 0.9.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "sha-1 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "sha2 0.7.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "sha3 0.7.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "try_from 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "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)",
 "base64 0.9.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "blake2 0.7.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "base64 0.10.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "blake2 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "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)",
 "base64 0.10.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "blake2 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "base64 0.9.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "blake2 0.7.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "base64 0.9.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "blake2 0.7.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "base64 0.9.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "blake2 0.7.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "base64 0.10.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "blake2 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.11.1"
version = "0.12.2"
version = "0.12.2"
version = "0.12.2"
version = "0.11.1"
version = "0.11.1"
version = "0.11.1"
version = "0.12.2"
 "markup5ever 0.7.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "time 0.1.40 (registry+https://github.com/rust-lang/crates.io-index)",
 "markup5ever 0.7.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "time 0.1.41 (registry+https://github.com/rust-lang/crates.io-index)",
 "markup5ever 0.7.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "time 0.1.40 (registry+https://github.com/rust-lang/crates.io-index)",
 "markup5ever 0.7.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "time 0.1.41 (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)",
 "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)",
 "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)",
 "markup5ever 0.7.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "time 0.1.41 (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.41 (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)",
 "markup5ever 0.7.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "time 0.1.40 (registry+https://github.com/rust-lang/crates.io-index)",
 "markup5ever 0.7.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "time 0.1.40 (registry+https://github.com/rust-lang/crates.io-index)",
 "markup5ever 0.7.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "time 0.1.40 (registry+https://github.com/rust-lang/crates.io-index)",
 "markup5ever 0.7.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "time 0.1.40 (registry+https://github.com/rust-lang/crates.io-index)",
 "markup5ever 0.7.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "time 0.1.40 (registry+https://github.com/rust-lang/crates.io-index)",
 "markup5ever 0.7.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "time 0.1.40 (registry+https://github.com/rust-lang/crates.io-index)",
 "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)",
 "markup5ever 0.7.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "time 0.1.40 (registry+https://github.com/rust-lang/crates.io-index)",
 "log 0.3.9 (registry+https://github.com/rust-lang/crates.io-index)",
 "log 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "log 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.12.0"
version = "0.12.1"
version = "0.12.1"
 "winapi 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "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)",
]
 "winapi-util 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi-util 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
[[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.1 (registry+https://github.com/rust-lang/crates.io-index)",
]
 "winapi 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
 "winapi 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.1.2"
version = "0.1.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
version = "0.1.1"
name = "winapi-x86_64-pc-windows-gnu"
version = "0.4.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
name = "winapi-util"
name = "winapi-util"
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]]
version = "0.3.7"
version = "0.3.6"
version = "0.3.7"
version = "0.3.6"
version = "0.3.6"
 "futures 0.1.25 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.25 (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.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "log 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "log 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)",
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
name = "version_check"
version = "0.1.5"
name = "version_check"
version = "0.1.5"
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 = [
name = "void"
version = "1.0.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
name = "void"
version = "1.0.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
name = "version_check"
version = "0.1.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
name = "version_check"
version = "0.1.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
name = "void"
version = "1.0.2"
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]]
version = "0.7.4"
version = "0.7.5"
version = "0.7.5"
version = "0.7.5"
version = "0.7.5"
version = "0.7.4"
version = "0.7.4"
version = "0.7.4"
version = "0.7.4"
version = "0.7.5"
version = "1.7.1"
version = "1.7.2"
version = "1.7.2"
dependencies = [
 "void 1.0.2 (registry+https://github.com/rust-lang/crates.io-index)",
]
name = "unreachable"
version = "1.0.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "void 1.0.2 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "unreachable"
version = "1.0.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "void 1.0.2 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "unreachable"
version = "1.0.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "void 1.0.2 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
[[package]]
source = "registry+https://github.com/rust-lang/crates.io-index"
name = "unreachable"
version = "1.0.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "void 1.0.2 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "unreachable"
version = "1.0.0"
 "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"
 "smallvec 0.6.9 (registry+https://github.com/rust-lang/crates.io-index)",
 "smallvec 0.6.8 (registry+https://github.com/rust-lang/crates.io-index)",
 "smallvec 0.6.8 (registry+https://github.com/rust-lang/crates.io-index)",
 "smallvec 0.6.9 (registry+https://github.com/rust-lang/crates.io-index)",
 "smallvec 0.6.8 (registry+https://github.com/rust-lang/crates.io-index)",
 "smallvec 0.6.9 (registry+https://github.com/rust-lang/crates.io-index)",
 "smallvec 0.6.8 (registry+https://github.com/rust-lang/crates.io-index)",
dependencies = [
 "smallvec 0.6.9 (registry+https://github.com/rust-lang/crates.io-index)",
]
version = "0.1.8"
version = "0.1.7"
version = "0.1.7"
source = "registry+https://github.com/rust-lang/crates.io-index"
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"
dependencies = [
]
 "cfg-if 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
[[package]]
name = "typenum"
version = "1.10.0"
 "cfg-if 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "cfg-if 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "cfg-if 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "cfg-if 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "cfg-if 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
dependencies = [
]
 "cfg-if 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "cfg-if 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
dependencies = [
 "cfg-if 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
]
dependencies = [
 "cfg-if 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
]
version = "0.3.2"
version = "0.3.2"
version = "0.3.2"
version = "0.3.2"
version = "0.2.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
version = "0.2.2"
version = "0.2.2"
version = "0.2.2"
version = "0.3.2"
 "smallvec 0.6.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio 0.1.11 (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"
 "smallvec 0.6.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio 0.1.13 (registry+https://github.com/rust-lang/crates.io-index)",
 "smallvec 0.6.9 (registry+https://github.com/rust-lang/crates.io-index)",
 "trust-dns-proto 0.6.3 (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)",
 "resolv-conf 0.6.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "smallvec 0.6.8 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio 0.1.14 (registry+https://github.com/rust-lang/crates.io-index)",
 "trust-dns-proto 0.6.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "smallvec 0.6.8 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio 0.1.15 (registry+https://github.com/rust-lang/crates.io-index)",
 "resolv-conf 0.6.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio 0.1.17 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio 0.1.16 (registry+https://github.com/rust-lang/crates.io-index)",
 "smallvec 0.6.8 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio 0.1.15 (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.8 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio 0.1.14 (registry+https://github.com/rust-lang/crates.io-index)",
 "trust-dns-proto 0.6.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "smallvec 0.6.9 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio 0.1.18 (registry+https://github.com/rust-lang/crates.io-index)",
 "resolv-conf 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio 0.1.13 (registry+https://github.com/rust-lang/crates.io-index)",
 "trust-dns-proto 0.4.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "smallvec 0.6.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "smallvec 0.6.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "smallvec 0.6.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "smallvec 0.6.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "smallvec 0.6.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "smallvec 0.6.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "smallvec 0.6.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "smallvec 0.6.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "smallvec 0.6.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "smallvec 0.6.8 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio 0.1.15 (registry+https://github.com/rust-lang/crates.io-index)",
 "smallvec 0.6.9 (registry+https://github.com/rust-lang/crates.io-index)",
 "resolv-conf 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "smallvec 0.6.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio 0.1.13 (registry+https://github.com/rust-lang/crates.io-index)",
 "trust-dns-proto 0.4.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "resolv-conf 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "smallvec 0.6.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio 0.1.13 (registry+https://github.com/rust-lang/crates.io-index)",
 "trust-dns-proto 0.4.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "resolv-conf 0.6.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "smallvec 0.6.8 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio 0.1.14 (registry+https://github.com/rust-lang/crates.io-index)",
 "trust-dns-proto 0.6.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "smallvec 0.6.8 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",
 "lazy_static 1.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "lru-cache 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "lru-cache 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio 0.1.18 (registry+https://github.com/rust-lang/crates.io-index)",
 "trust-dns-proto 0.6.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio 0.1.16 (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)",
 "lru-cache 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "lru-cache 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "lru-cache 0.1.2 (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.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "smallvec 0.6.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio 0.1.13 (registry+https://github.com/rust-lang/crates.io-index)",
 "trust-dns-proto 0.4.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "lazy_static 1.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "lazy_static 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)",
 "lazy_static 1.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "lazy_static 1.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "lazy_static 1.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "lazy_static 1.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "lazy_static 1.3.0 (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.2.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)",
 "cfg-if 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "ipconfig 0.1.9 (registry+https://github.com/rust-lang/crates.io-index)",
 "cfg-if 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.25 (registry+https://github.com/rust-lang/crates.io-index)",
 "failure 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "cfg-if 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "cfg-if 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "cfg-if 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "cfg-if 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "error-chain 0.1.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.25 (registry+https://github.com/rust-lang/crates.io-index)",
 "cfg-if 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.25 (registry+https://github.com/rust-lang/crates.io-index)",
 "error-chain 0.1.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "failure 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "failure 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "failure 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "error-chain 0.1.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "error-chain 0.1.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "error-chain 0.1.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "failure 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "cfg-if 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.10.2"
version = "0.10.3"
version = "0.10.3"
version = "0.10.2"
version = "0.9.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
version = "0.9.1"
version = "0.9.1"
version = "0.9.1"
version = "0.10.2"
]
[[package]]
name = "trust-dns-resolver"
 "tokio-timer 0.2.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-udp 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "url 1.7.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-timer 0.2.8 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-reactor 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-reactor 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-executor 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-reactor 0.1.8 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-tcp 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-executor 0.1.6 (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-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-io 0.1.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-reactor 0.1.8 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-reactor 0.1.8 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-reactor 0.1.8 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-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-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-executor 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-executor 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-executor 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-reactor 0.1.8 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-tcp 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-executor 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-reactor 0.1.9 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-executor 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-reactor 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-tcp 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-timer 0.2.8 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-executor 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-reactor 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-tcp 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-timer 0.2.8 (registry+https://github.com/rust-lang/crates.io-index)",
 "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)",
 "tokio-executor 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-reactor 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-tcp 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-executor 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-reactor 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-tcp 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-executor 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-reactor 0.1.8 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-tcp 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "smallvec 0.6.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand 0.4.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "socket2 0.3.8 (registry+https://github.com/rust-lang/crates.io-index)",
 "lazy_static 1.3.0 (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)",
 "smallvec 0.6.9 (registry+https://github.com/rust-lang/crates.io-index)",
 "smallvec 0.6.8 (registry+https://github.com/rust-lang/crates.io-index)",
 "smallvec 0.6.8 (registry+https://github.com/rust-lang/crates.io-index)",
 "smallvec 0.6.9 (registry+https://github.com/rust-lang/crates.io-index)",
 "smallvec 0.6.8 (registry+https://github.com/rust-lang/crates.io-index)",
 "smallvec 0.6.9 (registry+https://github.com/rust-lang/crates.io-index)",
 "smallvec 0.6.8 (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)",
 "rand 0.5.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "smallvec 0.6.8 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand 0.4.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "smallvec 0.6.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand 0.4.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "smallvec 0.6.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "lazy_static 1.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "lazy_static 1.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "lazy_static 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)",
 "lazy_static 1.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "lazy_static 1.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "lazy_static 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)",
 "smallvec 0.6.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "smallvec 0.6.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "smallvec 0.6.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "smallvec 0.6.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "smallvec 0.6.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "smallvec 0.6.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "smallvec 0.6.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "smallvec 0.6.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "smallvec 0.6.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand 0.5.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "smallvec 0.6.8 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand 0.4.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand 0.4.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "smallvec 0.6.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand 0.5.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "smallvec 0.6.8 (registry+https://github.com/rust-lang/crates.io-index)",
 "idna 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "lazy_static 1.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "lazy_static 1.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "byteorder 1.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "failure 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "byteorder 1.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "failure 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",
 "byteorder 1.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "failure 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.25 (registry+https://github.com/rust-lang/crates.io-index)",
 "byteorder 1.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "failure 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "byteorder 1.2.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "error-chain 0.1.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.25 (registry+https://github.com/rust-lang/crates.io-index)",
 "byteorder 1.2.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "error-chain 0.1.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.25 (registry+https://github.com/rust-lang/crates.io-index)",
 "byteorder 1.2.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "error-chain 0.1.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "byteorder 1.2.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "error-chain 0.1.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "byteorder 1.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "failure 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.6.2"
version = "0.6.3"
version = "0.6.3"
version = "0.6.2"
version = "0.4.3"
version = "0.4.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
version = "0.4.3"
version = "0.4.3"
version = "0.6.2"
 "serde 1.0.83 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde 1.0.80 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde 1.0.88 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde 1.0.89 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde 1.0.82 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde 1.0.85 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde 1.0.87 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde 1.0.90 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde 1.0.83 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde 1.0.89 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde 1.0.87 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde 1.0.83 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde 1.0.85 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde 1.0.90 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde 1.0.80 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde 1.0.80 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde 1.0.80 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde 1.0.80 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "trust-dns-proto"
 "serde 1.0.87 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde 1.0.89 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde 1.0.80 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde 1.0.80 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde 1.0.85 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde 1.0.80 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde 1.0.87 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.5.0"
version = "0.5.0"
version = "0.4.10"
version = "0.4.10"
version = "0.4.10"
version = "0.5.0"
version = "0.4.10"
version = "0.4.10"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "xmpp-parsers 0.12.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "xmpp-parsers 0.12.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "xmpp-parsers 0.12.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "xmpp-parsers 0.11.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "xmpp-parsers 0.11.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "xml5ever 0.12.0 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "toml"
 "tokio-io 0.1.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-tls 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "trust-dns-proto 0.6.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "trust-dns-resolver 0.10.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "xmpp-parsers 0.12.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "xmpp-parsers 0.11.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "xmpp-parsers 0.11.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "xmpp-parsers 0.12.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-tls 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "trust-dns-proto 0.6.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)",
 "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)",
 "tokio-io 0.1.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "xml5ever 0.12.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-tls 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "trust-dns-proto 0.6.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "trust-dns-resolver 0.10.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-tls 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "trust-dns-proto 0.4.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "trust-dns-resolver 0.9.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "try_from 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-tls 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "trust-dns-proto 0.4.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "trust-dns-resolver 0.9.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "try_from 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "xml5ever 0.12.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-tls 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "trust-dns-proto 0.4.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "trust-dns-resolver 0.9.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "try_from 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-tls 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "trust-dns-proto 0.4.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "trust-dns-resolver 0.9.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "try_from 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-tls 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "trust-dns-proto 0.6.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "trust-dns-resolver 0.10.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "sasl 0.4.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio 0.1.17 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio 0.1.16 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio 0.1.15 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio 0.1.15 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio 0.1.18 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio 0.1.15 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio 0.1.16 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio 0.1.18 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio 0.1.16 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio 0.1.13 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-codec 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "quick-xml 0.12.4 (registry+https://github.com/rust-lang/crates.io-index)",
 "sasl 0.4.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "quick-xml 0.13.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "quick-xml 0.13.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "sasl 0.4.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio 0.1.14 (registry+https://github.com/rust-lang/crates.io-index)",
 "quick-xml 0.13.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)",
 "quick-xml 0.13.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "quick-xml 0.13.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "sasl 0.4.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio 0.1.14 (registry+https://github.com/rust-lang/crates.io-index)",
 "quick-xml 0.13.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "quick-xml 0.12.4 (registry+https://github.com/rust-lang/crates.io-index)",
 "sasl 0.4.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio 0.1.13 (registry+https://github.com/rust-lang/crates.io-index)",
 "quick-xml 0.12.4 (registry+https://github.com/rust-lang/crates.io-index)",
 "sasl 0.4.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio 0.1.13 (registry+https://github.com/rust-lang/crates.io-index)",
 "quick-xml 0.13.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "quick-xml 0.13.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "quick-xml 0.12.4 (registry+https://github.com/rust-lang/crates.io-index)",
 "sasl 0.4.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio 0.1.13 (registry+https://github.com/rust-lang/crates.io-index)",
 "quick-xml 0.12.4 (registry+https://github.com/rust-lang/crates.io-index)",
 "sasl 0.4.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio 0.1.13 (registry+https://github.com/rust-lang/crates.io-index)",
 "quick-xml 0.13.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "sasl 0.4.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio 0.1.14 (registry+https://github.com/rust-lang/crates.io-index)",
 "jid 0.5.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "minidom 0.9.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "jid 0.5.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "minidom 0.9.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "jid 0.5.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "minidom 0.9.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "jid 0.5.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "minidom 0.9.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "jid 0.5.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "minidom 0.9.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.25 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.25 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.25 (registry+https://github.com/rust-lang/crates.io-index)",
 "bytes 0.4.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "bytes 0.4.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "bytes 0.4.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "bytes 0.4.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "bytes 0.4.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "bytes 0.4.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "bytes 0.4.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "bytes 0.4.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "bytes 0.4.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "bytes 0.4.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "bytes 0.4.11 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.2.0"
version = "0.2.1"
version = "0.2.0"
version = "0.2.3"
version = "1.0.0"
version = "1.0.0"
version = "0.2.1"
version = "0.2.1"
version = "0.2.3"
version = "0.2.0"
version = "0.2.0"
version = "0.2.0"
version = "0.2.0"
version = "0.2.0"
version = "0.2.3"
version = "0.2.0"
 "tokio-reactor 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-reactor 0.1.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)",
 "tokio-io 0.1.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-reactor 0.1.8 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-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-io 0.1.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-reactor 0.1.8 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-reactor 0.1.8 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-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-io 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-reactor 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-reactor 0.1.8 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-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-io 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-reactor 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-codec 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-reactor 0.1.8 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-reactor 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-reactor 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-reactor 0.1.8 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.45 (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)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.50 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.50 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.45 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.47 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.48 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.45 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.49 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.48 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "log 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.45 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.47 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "log 0.4.6 (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.48 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.49 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.47 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.49 (registry+https://github.com/rust-lang/crates.io-index)",
 "bytes 0.4.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "bytes 0.4.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "bytes 0.4.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",
 "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)",
 "bytes 0.4.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "bytes 0.4.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "bytes 0.4.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",
 "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)",
 "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)",
 "bytes 0.4.11 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.2.5"
version = "0.2.5"
version = "0.2.5"
version = "0.2.4"
version = "0.2.5"
version = "0.2.4"
version = "0.2.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
]
[[package]]
name = "tokio-uds"
version = "0.2.4"
version = "0.2.4"
version = "0.2.5"
 "tokio-reactor 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-reactor 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-reactor 0.1.9 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-reactor 0.1.8 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-reactor 0.1.8 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-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-io 0.1.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-reactor 0.1.8 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-reactor 0.1.8 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-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-io 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-reactor 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-reactor 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-reactor 0.1.8 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-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-io 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-reactor 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-reactor 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-reactor 0.1.8 (registry+https://github.com/rust-lang/crates.io-index)",
 "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)",
 "log 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "bytes 0.4.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "bytes 0.4.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "bytes 0.4.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",
 "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)",
 "bytes 0.4.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "bytes 0.4.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "bytes 0.4.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",
 "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)",
 "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)",
 "bytes 0.4.11 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.1.3"
version = "0.1.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "tokio-io 0.1.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.11 (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"
]
[[package]]
name = "tokio-trace-core"
version = "0.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "lazy_static 1.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.11 (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-trace-core"
version = "0.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "lazy_static 1.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.25 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.25 (registry+https://github.com/rust-lang/crates.io-index)",
 "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)",
version = "0.2.1"
version = "0.2.1"
version = "0.2.1"
version = "0.2.1"
version = "0.2.0"
version = "0.2.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
version = "0.2.0"
version = "0.2.0"
version = "0.2.1"
 "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-executor 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "slab 0.4.2 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "tokio-tls"
 "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-executor 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "slab 0.4.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-executor 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "slab 0.4.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-executor 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "slab 0.4.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-executor 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "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)",
 "crossbeam-utils 0.6.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "crossbeam-utils 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "crossbeam-utils 0.6.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "crossbeam-utils 0.6.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "crossbeam-utils 0.6.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",
 "crossbeam-utils 0.6.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "slab 0.4.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-executor 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-executor 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.25 (registry+https://github.com/rust-lang/crates.io-index)",
 "crossbeam-utils 0.6.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "crossbeam-utils 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "crossbeam-utils 0.6.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "crossbeam-utils 0.6.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "crossbeam-utils 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.25 (registry+https://github.com/rust-lang/crates.io-index)",
 "slab 0.4.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-executor 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "crossbeam-utils 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "crossbeam-utils 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "crossbeam-utils 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.25 (registry+https://github.com/rust-lang/crates.io-index)",
 "crossbeam-utils 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "crossbeam-utils 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "crossbeam-utils 0.6.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "crossbeam-utils 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.2.10"
version = "0.2.10"
version = "0.2.8"
version = "0.2.8"
version = "0.2.8"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
]
[[package]]
name = "tokio-timer"
 "tokio-executor 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "log 0.4.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "num_cpus 1.8.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "num_cpus 1.10.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-executor 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-executor 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "num_cpus 1.10.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "num_cpus 1.9.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)",
 "num_cpus 1.10.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand 0.6.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "slab 0.4.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-executor 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-executor 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "num_cpus 1.9.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand 0.6.1 (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.9.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand 0.6.4 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-executor 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "num_cpus 1.10.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "num_cpus 1.8.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-executor 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "log 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-executor 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "num_cpus 1.9.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "num_cpus 1.8.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "num_cpus 1.9.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "num_cpus 1.9.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand 0.6.4 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-executor 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "num_cpus 1.9.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "num_cpus 1.9.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "num_cpus 1.8.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "num_cpus 1.8.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "num_cpus 1.8.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "num_cpus 1.8.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-executor 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "num_cpus 1.9.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand 0.6.4 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-executor 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "num_cpus 1.8.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "num_cpus 1.9.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "num_cpus 1.10.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "num_cpus 1.8.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-executor 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "num_cpus 1.9.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "crossbeam-deque 0.6.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "crossbeam-utils 0.6.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "crossbeam-deque 0.6.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "crossbeam-utils 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "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)",
 "futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",
 "crossbeam-deque 0.6.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "crossbeam-utils 0.6.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "crossbeam-channel 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "crossbeam-deque 0.6.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "crossbeam-utils 0.6.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "crossbeam 0.6.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "crossbeam-channel 0.3.8 (registry+https://github.com/rust-lang/crates.io-index)",
 "crossbeam-deque 0.6.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "crossbeam-utils 0.6.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "crossbeam-deque 0.7.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "crossbeam-queue 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "crossbeam-utils 0.6.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.25 (registry+https://github.com/rust-lang/crates.io-index)",
 "crossbeam-deque 0.6.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "crossbeam-utils 0.6.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "crossbeam 0.6.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "crossbeam-channel 0.3.8 (registry+https://github.com/rust-lang/crates.io-index)",
 "crossbeam-deque 0.6.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "crossbeam-deque 0.6.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "crossbeam-utils 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "crossbeam-deque 0.6.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "crossbeam-utils 0.6.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "crossbeam-channel 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "crossbeam-deque 0.6.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "crossbeam-utils 0.6.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "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-deque 0.6.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "crossbeam-utils 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.25 (registry+https://github.com/rust-lang/crates.io-index)",
 "crossbeam-deque 0.6.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "crossbeam-utils 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "crossbeam-deque 0.6.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "crossbeam-utils 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "crossbeam-deque 0.6.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "crossbeam-utils 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.25 (registry+https://github.com/rust-lang/crates.io-index)",
 "crossbeam 0.6.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "crossbeam-channel 0.3.8 (registry+https://github.com/rust-lang/crates.io-index)",
 "crossbeam-deque 0.6.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "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-deque 0.6.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "crossbeam-utils 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "crossbeam-deque 0.6.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "crossbeam-utils 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "crossbeam-channel 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "crossbeam-deque 0.6.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "crossbeam-utils 0.6.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "crossbeam-deque 0.6.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "crossbeam-utils 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.1.12"
version = "0.1.10"
version = "0.1.11"
version = "0.1.13"
version = "0.1.12"
version = "0.1.11"
version = "0.1.9"
version = "0.1.10"
version = "0.1.13"
version = "0.1.9"
version = "0.1.9"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
]
[[package]]
name = "tokio-threadpool"
version = "0.1.11"
version = "0.1.12"
version = "0.1.9"
version = "0.1.9"
version = "0.1.10"
 "tokio-reactor 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-reactor 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-reactor 0.1.9 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-reactor 0.1.8 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-reactor 0.1.8 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-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-io 0.1.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-reactor 0.1.8 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-reactor 0.1.8 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-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-io 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-reactor 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-reactor 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "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.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-reactor 0.1.8 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-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-io 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-reactor 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-reactor 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-reactor 0.1.8 (registry+https://github.com/rust-lang/crates.io-index)",
 "bytes 0.4.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "bytes 0.4.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "bytes 0.4.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",
 "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)",
 "bytes 0.4.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "bytes 0.4.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "bytes 0.4.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",
 "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)",
 "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)",
 "bytes 0.4.11 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.1.3"
version = "0.1.3"
version = "0.1.3"
version = "0.1.3"
version = "0.1.2"
version = "0.1.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
version = "0.1.2"
version = "0.1.2"
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.26 (registry+https://github.com/rust-lang/crates.io-index)",
name = "tokio-tcp"
]
[[package]]
 "fnv 1.0.6 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.1.4"
version = "0.1.3"
version = "0.1.1"
version = "0.1.1"
version = "0.1.4"
version = "0.1.1"
version = "0.1.3"
]
[[package]]
 "tokio-reactor 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-executor 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "signal-hook 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "signal-hook 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "signal-hook 0.1.8 (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-io 0.1.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-reactor 0.1.8 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-reactor 0.1.8 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-reactor 0.1.8 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-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)",
 "signal-hook 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-executor 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-reactor 0.1.8 (registry+https://github.com/rust-lang/crates.io-index)",
 "signal-hook 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-executor 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "signal-hook 0.1.8 (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-sync"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "fnv 1.0.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.25 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.1.4"
version = "0.1.3"
 "winapi 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-executor 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-executor 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "signal-hook 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "signal-hook 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "signal-hook 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "signal-hook 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "signal-hook 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-executor 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-reactor 0.1.8 (registry+https://github.com/rust-lang/crates.io-index)",
 "signal-hook 0.1.8 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-executor 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-reactor 0.1.9 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "signal-hook 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-executor 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-reactor 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "signal-hook 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "signal-hook 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-executor 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-reactor 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "signal-hook 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "signal-hook 0.1.8 (registry+https://github.com/rust-lang/crates.io-index)",
 "signal-hook 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-executor 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-reactor 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "signal-hook 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-executor 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-reactor 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "signal-hook 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-executor 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-reactor 0.1.8 (registry+https://github.com/rust-lang/crates.io-index)",
 "signal-hook 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "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)",
 "futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.25 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "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)",
 "mio-uds 0.6.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.43 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.45 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.50 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.50 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.45 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.47 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.48 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.45 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.48 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.45 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.47 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.48 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.49 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.47 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.49 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.2.7"
version = "0.2.7"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "num_cpus 1.9.0 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "tokio-signal"
 "num_cpus 1.8.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "num_cpus 1.10.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-executor 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-sync 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-sync 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)",
 "tokio-sync 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-executor 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-sync 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)",
 "num_cpus 1.10.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "num_cpus 1.9.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "num_cpus 1.9.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "parking_lot 0.7.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "slab 0.4.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-executor 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "num_cpus 1.9.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "parking_lot 0.7.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "slab 0.4.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-executor 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-sync 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-sync 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)",
 "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)",
 "num_cpus 1.9.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-executor 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "num_cpus 1.9.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "num_cpus 1.9.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "num_cpus 1.9.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "parking_lot 0.7.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "slab 0.4.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-executor 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "num_cpus 1.10.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "num_cpus 1.8.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "parking_lot 0.6.4 (registry+https://github.com/rust-lang/crates.io-index)",
 "slab 0.4.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-executor 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "num_cpus 1.8.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "num_cpus 1.8.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "num_cpus 1.8.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "parking_lot 0.6.4 (registry+https://github.com/rust-lang/crates.io-index)",
 "slab 0.4.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-executor 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "num_cpus 1.9.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "num_cpus 1.10.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "num_cpus 1.8.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "parking_lot 0.6.4 (registry+https://github.com/rust-lang/crates.io-index)",
 "slab 0.4.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-executor 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "num_cpus 1.8.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "parking_lot 0.6.4 (registry+https://github.com/rust-lang/crates.io-index)",
 "slab 0.4.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-executor 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "num_cpus 1.9.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "parking_lot 0.7.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "slab 0.4.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-executor 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "num_cpus 1.8.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "num_cpus 1.9.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "lazy_static 1.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "mio 0.6.16 (registry+https://github.com/rust-lang/crates.io-index)",
 "lazy_static 1.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "lazy_static 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)",
 "lazy_static 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)",
 "lazy_static 1.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "lazy_static 1.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "crossbeam-utils 0.6.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "crossbeam-utils 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "crossbeam-utils 0.6.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "crossbeam-utils 0.6.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "crossbeam-utils 0.6.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",
 "lazy_static 1.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "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)",
 "futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.25 (registry+https://github.com/rust-lang/crates.io-index)",
 "crossbeam-utils 0.6.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "crossbeam-utils 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "crossbeam-utils 0.6.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "crossbeam-utils 0.6.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "crossbeam-utils 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.25 (registry+https://github.com/rust-lang/crates.io-index)",
 "lazy_static 1.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "crossbeam-utils 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "crossbeam-utils 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "crossbeam-utils 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.25 (registry+https://github.com/rust-lang/crates.io-index)",
 "crossbeam-utils 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "crossbeam-utils 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "crossbeam-utils 0.6.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "crossbeam-utils 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.1.9"
version = "0.1.8"
version = "0.1.8"
version = "0.1.9"
version = "0.1.8"
version = "0.1.7"
version = "0.1.8"
version = "0.1.9"
version = "0.1.7"
version = "0.1.7"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
version = "0.1.8"
version = "0.1.9"
version = "0.1.7"
version = "0.1.7"
version = "0.1.8"
 "log 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "tokio-reactor"
 "log 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "bytes 0.4.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "bytes 0.4.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "bytes 0.4.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",
 "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)",
 "bytes 0.4.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "bytes 0.4.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "bytes 0.4.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",
 "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)",
 "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)",
 "bytes 0.4.11 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.1.12"
version = "0.1.11"
version = "0.1.11"
version = "0.1.12"
version = "0.1.11"
version = "0.1.11"
version = "0.1.12"
version = "0.1.10"
version = "0.1.10"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
version = "0.1.11"
version = "0.1.12"
version = "0.1.10"
version = "0.1.10"
version = "0.1.11"
 "tokio-threadpool 0.1.12 (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-io"
 "futures 0.1.25 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-threadpool 0.1.13 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.25 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-threadpool 0.1.9 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.25 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-threadpool 0.1.8 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-threadpool 0.1.9 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.10 (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)",
 "tokio-io 0.1.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-threadpool 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-threadpool 0.1.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-threadpool 0.1.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-threadpool 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-threadpool 0.1.9 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-threadpool 0.1.11 (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)",
 "tokio-io 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-threadpool 0.1.9 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-threadpool 0.1.9 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-threadpool 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.1.6"
version = "0.1.5"
version = "0.1.5"
version = "0.1.6"
version = "0.1.5"
version = "0.1.5"
version = "0.1.6"
version = "0.1.4"
version = "0.1.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
]
[[package]]
name = "tokio-fs"
version = "0.1.5"
version = "0.1.6"
version = "0.1.4"
version = "0.1.4"
version = "0.1.5"
 "crossbeam-utils 0.6.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",
 "crossbeam-utils 0.6.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.25 (registry+https://github.com/rust-lang/crates.io-index)",
 "crossbeam-utils 0.6.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.25 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.25 (registry+https://github.com/rust-lang/crates.io-index)",
 "crossbeam-utils 0.6.3 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.1.6"
version = "0.1.6"
version = "0.1.7"
version = "0.1.6"
version = "0.1.6"
version = "0.1.7"
version = "0.1.5"
version = "0.1.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
version = "0.1.5"
version = "0.1.5"
version = "0.1.6"
 "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)",
 "futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-executor 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.25 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-executor 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.25 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "tokio-executor"
 "tokio-executor 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-executor 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-executor 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-executor 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-executor 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-executor 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)",
version = "0.1.5"
version = "0.1.6"
version = "0.1.5"
version = "0.1.4"
version = "0.1.4"
version = "0.1.6"
version = "0.1.4"
version = "0.1.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
version = "0.1.4"
version = "0.1.5"
 "futures 0.1.25 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "tokio-current-thread"
 "bytes 0.4.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "bytes 0.4.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "bytes 0.4.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "bytes 0.4.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "bytes 0.4.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "bytes 0.4.11 (registry+https://github.com/rust-lang/crates.io-index)",
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "futures 0.1.25 (registry+https://github.com/rust-lang/crates.io-index)",
 "bytes 0.4.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)",
]
 "tokio-io 0.1.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "bytes 0.4.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "bytes 0.4.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "bytes 0.4.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",
 "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)",
 "bytes 0.4.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "bytes 0.4.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "bytes 0.4.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "bytes 0.4.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.25 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "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)",
 "bytes 0.4.11 (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 = [
version = "0.1.0"
 "tokio-threadpool 0.1.8 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-timer 0.2.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-udp 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-uds 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-threadpool 0.1.9 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-timer 0.2.8 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-udp 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-uds 0.2.4 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-threadpool 0.1.8 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-timer 0.2.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-udp 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-uds 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-threadpool 0.1.8 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-timer 0.2.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-udp 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-uds 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-threadpool 0.1.9 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-timer 0.2.8 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-udp 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-uds 0.2.4 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-threadpool 0.1.9 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-timer 0.2.8 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-udp 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-uds 0.2.4 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-reactor 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-reactor 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-reactor 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-reactor 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-reactor 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-reactor 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-current-thread 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-current-thread 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-current-thread 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-current-thread 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-current-thread 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-current-thread 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)",
 "num_cpus 1.8.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "num_cpus 1.8.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "num_cpus 1.9.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "num_cpus 1.8.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "bytes 0.4.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "bytes 0.4.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "bytes 0.4.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "bytes 0.4.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "bytes 0.4.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "bytes 0.4.11 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.1.11"
version = "0.1.13"
version = "0.1.11"
version = "0.1.11"
version = "0.1.13"
version = "0.1.13"
 "redox_syscall 0.1.43 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.43 (registry+https://github.com/rust-lang/crates.io-index)",
 "redox_syscall 0.1.40 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "redox_syscall 0.1.43 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.43 (registry+https://github.com/rust-lang/crates.io-index)",
 "redox_syscall 0.1.40 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.43 (registry+https://github.com/rust-lang/crates.io-index)",
 "redox_syscall 0.1.40 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "redox_syscall 0.1.43 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.45 (registry+https://github.com/rust-lang/crates.io-index)",
 "redox_syscall 0.1.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.45 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.1.40"
version = "0.1.40"
version = "0.1.41"
 "lazy_static 1.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "lazy_static 1.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "lazy_static 1.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "lazy_static 1.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "lazy_static 1.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "lazy_static 1.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "redox_syscall 0.1.43 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.43 (registry+https://github.com/rust-lang/crates.io-index)",
 "redox_syscall 0.1.40 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "redox_syscall 0.1.43 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.43 (registry+https://github.com/rust-lang/crates.io-index)",
 "redox_syscall 0.1.40 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.43 (registry+https://github.com/rust-lang/crates.io-index)",
 "redox_syscall 0.1.40 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "redox_syscall 0.1.43 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.45 (registry+https://github.com/rust-lang/crates.io-index)",
 "redox_syscall 0.1.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.45 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.4.0"
version = "0.4.0"
version = "0.4.0"
version = "0.4.1"
version = "0.4.1"
 "rand 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "redox_syscall 0.1.43 (registry+https://github.com/rust-lang/crates.io-index)",
 "redox_syscall 0.1.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "redox_syscall 0.1.43 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.43 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand 0.5.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "redox_syscall 0.1.40 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "redox_syscall 0.1.43 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.43 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand 0.5.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "redox_syscall 0.1.40 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.43 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand 0.5.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "redox_syscall 0.1.40 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.45 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.45 (registry+https://github.com/rust-lang/crates.io-index)",
version = "3.0.4"
version = "3.0.5"
version = "3.0.4"
version = "3.0.4"
version = "3.0.5"
version = "3.0.5"
 "syn 0.15.22 (registry+https://github.com/rust-lang/crates.io-index)",
 "syn 0.15.23 (registry+https://github.com/rust-lang/crates.io-index)",
 "proc-macro2 0.4.20 (registry+https://github.com/rust-lang/crates.io-index)",
 "quote 0.6.8 (registry+https://github.com/rust-lang/crates.io-index)",
 "syn 0.15.14 (registry+https://github.com/rust-lang/crates.io-index)",
 "proc-macro2 0.4.24 (registry+https://github.com/rust-lang/crates.io-index)",
 "quote 0.6.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "syn 0.15.22 (registry+https://github.com/rust-lang/crates.io-index)",
 "proc-macro2 0.4.20 (registry+https://github.com/rust-lang/crates.io-index)",
 "quote 0.6.8 (registry+https://github.com/rust-lang/crates.io-index)",
 "syn 0.15.14 (registry+https://github.com/rust-lang/crates.io-index)",
 "proc-macro2 0.4.20 (registry+https://github.com/rust-lang/crates.io-index)",
 "quote 0.6.8 (registry+https://github.com/rust-lang/crates.io-index)",
 "syn 0.15.14 (registry+https://github.com/rust-lang/crates.io-index)",
 "proc-macro2 0.4.24 (registry+https://github.com/rust-lang/crates.io-index)",
 "quote 0.6.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "proc-macro2 0.4.24 (registry+https://github.com/rust-lang/crates.io-index)",
 "quote 0.6.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "syn 0.15.22 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.10.0"
version = "0.10.1"
version = "0.10.0"
version = "0.10.0"
version = "0.10.1"
version = "0.10.1"
[[package]]
name = "xmpp-parsers"
version = "0.11.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "base64 0.9.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "blake2 0.7.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "chrono 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "digest 0.7.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "jid 0.5.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "minidom 0.9.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "sha-1 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "sha2 0.7.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "sha3 0.7.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "try_from 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)",
]
[metadata]
"checksum quick-xml 0.13.1 (registry+https://github.com/rust-lang/crates.io-index)" = "1b62a38216952bff95085ad664b772492288a96a25544f48d25e7200de1d7db7"
"checksum minidom 0.10.0 (registry+https://github.com/rust-lang/crates.io-index)" = "275024eea6c6ff4ace22f2750843831183785288eec1cff91a4e6b8898cf94f9"
"checksum tokio-channel 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)" = "530d0fb87416dd531600f7cccc438bb35c5b91883065c9e6dca7cdecee991cfa"
"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.0 (registry+https://github.com/rust-lang/crates.io-index)" = "ead952cf8bab253fb5cb56e1fff780747bbf7a7258fb0451afe645a166050b1f"
"checksum xmpp-parsers 0.11.1 (registry+https://github.com/rust-lang/crates.io-index)" = "2e1e0a279d5af83a1dff442249f8a43214ac120267acfaac494b9d28c0027fea"
"checksum winapi-x86_64-pc-windows-gnu 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)" = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
"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 version_check 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)" = "914b1a6776c4c929a602fafd8bc742e06365d4bcbe48c30f9cca5824f70dc9dd"
"checksum void 1.0.2 (registry+https://github.com/rust-lang/crates.io-index)" = "6a02e4885ed3bc0f2de90ea6dd45ebcbb66dacffe03547fadbb0eeae2770887d"
"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 unicode-bidi 0.3.4 (registry+https://github.com/rust-lang/crates.io-index)" = "49f2bd0c6468a8230e1db229cff8029217cf623c767ea5d60bfbd42729ea54d5"
"checksum unicode-normalization 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)" = "6a0180bc61fc5a987082bfa111f4cc95c4caff7f9799f3e46df09163a937aa25"
"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 unreachable 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)" = "382810877fe448991dfc7f0dd6e3ae5d58088fd0ea5e35189655f84e6814fa56"
"checksum url 1.7.1 (registry+https://github.com/rust-lang/crates.io-index)" = "2a321979c09843d272956e73700d12c4e7d3d92b2ee112b31548aef0d4efc5a6"
"checksum utf-8 0.7.4 (registry+https://github.com/rust-lang/crates.io-index)" = "bab35f71693630bb1953dce0f2bcd780e7cde025027124a202ac08a45ba25141"
"checksum tokio-codec 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "5c501eceaf96f0e1793cf26beb63da3d11c738c4a943fdf3746d81d64684c39f"
"checksum tokio-current-thread 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)" = "f90fcd90952f0a496d438a976afba8e5c205fb12123f813d8ab3aa1c8436638c"
"checksum tokio-executor 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)" = "c117b6cf86bb730aab4834f10df96e4dd586eff2c3c27d3781348da49e255bde"
"checksum tokio-fs 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)" = "60ae25f6b17d25116d2cba342083abe5255d3c2c79cb21ea11aa049c53bf7c75"
"checksum tokio-io 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)" = "7392fe0a70d5ce0c882c4778116c519bd5dbaa8a7c3ae3d04578b3afafdcda21"
"checksum tokio-reactor 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)" = "4b26fd37f1125738b2170c80b551f69ff6fecb277e6e5ca885e53eec2b005018"
"checksum tokio-signal 0.2.6 (registry+https://github.com/rust-lang/crates.io-index)" = "40da88e6445ed335e14746b60986a6c8b3632b09bc9097df76b4a6ddd16f1f92"
"checksum tokio-tcp 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)" = "7ad235e9dadd126b2d47f6736f65aa1fdcd6420e66ca63f44177bc78df89f912"
"checksum tokio-threadpool 0.1.8 (registry+https://github.com/rust-lang/crates.io-index)" = "3929aee321c9220ed838ed6c3928be7f9b69986b0e3c22c972a66dbf8a298c68"
"checksum tokio-timer 0.2.7 (registry+https://github.com/rust-lang/crates.io-index)" = "3a52f00c97fedb6d535d27f65cccb7181c8dd4c6edc3eda9ea93f6d45d05168e"
"checksum tokio-tls 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)" = "e53fdbf3156f588be1676022fe794232b24922d426e8c14f4e46891c1e31c440"
"checksum tokio-udp 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)" = "da941144b816d0dcda4db3a1ba87596e4df5e860a72b70783fe435891f80601c"
"checksum tokio-uds 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)" = "df195376b43508f01570bacc73e13a1de0854dc59e79d1ec09913e8db6dd2a70"
"checksum tokio-xmpp 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)" = "c27385c4781afc851c61ac66d79463c511bf073d3a5d71b8bfd13a816e475989"
"checksum toml 0.4.8 (registry+https://github.com/rust-lang/crates.io-index)" = "4a2ecc31b0351ea18b3fe11274b8db6e4d82bce861bbb22e6dbed40417902c65"
"checksum trust-dns-proto 0.4.3 (registry+https://github.com/rust-lang/crates.io-index)" = "f1525ca4e26f5a09d81b79584f19225e7dba5606ae3a416311c2751c5cea60bb"
"checksum trust-dns-resolver 0.9.1 (registry+https://github.com/rust-lang/crates.io-index)" = "4a821ad51a29816420b8cac4b026756b81c023630b97eaa4c8090637ee3508bd"
"checksum try-lock 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)" = "e604eb7b43c06650e854be16a2a03155743d3752dd1c943f6829e26b7a36e382"
"checksum try_from 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)" = "923a7ee3e97dbfe8685261beb4511cc9620a1252405d02693d43169729570111"
"checksum typenum 1.10.0 (registry+https://github.com/rust-lang/crates.io-index)" = "612d636f949607bdf9b123b4a6f6d966dedf3ff669f7f045890d3a4a73948169"
"checksum time 0.1.40 (registry+https://github.com/rust-lang/crates.io-index)" = "d825be0eb33fda1a7e68012d51e9c7f451dc1a69391e7fdc197060bb8c56667b"
"checksum tokio 0.1.11 (registry+https://github.com/rust-lang/crates.io-index)" = "6e93c78d23cc61aa245a8acd2c4a79c4d7fa7fb5c3ca90d5737029f043a84895"
"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 remove_dir_all 0.5.1 (registry+https://github.com/rust-lang/crates.io-index)" = "3488ba1b9a2084d38645c4c08276a1752dcbf2c7130d74f1569681ad5d2799c5"
"checksum resolv-conf 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)" = "c62bd95a41841efdf7fca2ae9951e64a8d8eae7e5da196d8ce489a2241491a92"
"checksum rustc-demangle 0.1.9 (registry+https://github.com/rust-lang/crates.io-index)" = "bcfe5b13211b4d78e5c2cadfebd7769197d95c639c35a50057eb4c05de811395"
"checksum rustc_version 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)" = "138e3e0acb6c9fb258b19b67cb8abd63c00679d2851805ea151465464fe9030a"
"checksum ryu 0.2.6 (registry+https://github.com/rust-lang/crates.io-index)" = "7153dd96dade874ab973e098cb62fcdbb89a03682e46b144fd09550998d4a4a7"
"checksum safemem 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)" = "8dca453248a96cb0749e36ccdfe2b0b4e54a61bfef89fb97ec621eb8e0a93dd9"
"checksum sasl 0.4.2 (registry+https://github.com/rust-lang/crates.io-index)" = "4dbda5436dcd059da44fbf84b87a7164c5e3cad354efd0630c1f2be3c51c8859"
"checksum schannel 0.1.14 (registry+https://github.com/rust-lang/crates.io-index)" = "0e1a231dc10abf6749cfa5d7767f25888d484201accbd919b66ab5413c502d56"
"checksum scopeguard 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)" = "94258f53601af11e6a49f722422f6e3425c52b06245a5cf9bc09908b174f5e27"
"checksum security-framework 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)" = "697d3f3c23a618272ead9e1fb259c1411102b31c6af8b93f1d64cca9c3b0e8e0"
"checksum security-framework-sys 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)" = "ab01dfbe5756785b5b4d46e0289e5a18071dfa9a7c2b24213ea00b9ef9b665bf"
"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.80 (registry+https://github.com/rust-lang/crates.io-index)" = "15c141fc7027dd265a47c090bf864cf62b42c4d228bbcf4e51a0c9e2b0d3f7ef"
"checksum serde_derive 1.0.80 (registry+https://github.com/rust-lang/crates.io-index)" = "225de307c6302bec3898c51ca302fc94a7a1697ef0845fcee6448f33c032249c"
"checksum serde_json 1.0.32 (registry+https://github.com/rust-lang/crates.io-index)" = "43344e7ce05d0d8280c5940cabb4964bea626aa58b1ec0e8c73fa2a8512a38ce"
"checksum sha-1 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)" = "51b9d1f3b5de8a167ab06834a7c883bd197f2191e1dda1a22d9ccfeedbf9aded"
"checksum sha2 0.7.1 (registry+https://github.com/rust-lang/crates.io-index)" = "9eb6be24e4c23a84d7184280d2722f7f2731fcdd4a9d886efbfe4413e4847ea0"
"checksum sha3 0.7.3 (registry+https://github.com/rust-lang/crates.io-index)" = "b64dcef59ed4290b9fb562b53df07f564690d6539e8ecdd4728cf392477530bc"
"checksum signal-hook 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)" = "f7ca1f1c0ed6c8beaab713ad902c041e4f09d06e1b4bb74c5fc553c078ed0110"
"checksum siphasher 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)" = "0b8de496cf83d4ed58b6be86c3a275b8602f6ffe98d3024a869e124147a9a3ac"
"checksum slab 0.4.1 (registry+https://github.com/rust-lang/crates.io-index)" = "5f9776d6b986f77b35c6cf846c11ad986ff128fe0b2b63a3628e3755e8d3102d"
"checksum smallvec 0.6.5 (registry+https://github.com/rust-lang/crates.io-index)" = "153ffa32fd170e9944f7e0838edf824a754ec4c1fc64746fcc9fe1f8fa602e5d"
"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.1 (registry+https://github.com/rust-lang/crates.io-index)" = "00caf261d6f90f588f8450b8e1230fa0d5be49ee6140fdfbcb55335aff350970"
"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 syn 0.11.11 (registry+https://github.com/rust-lang/crates.io-index)" = "d3b891b9015c88c576343b9b3e41c2c11a51c219ef067b264bd9c8aa9b441dad"
"checksum syn 0.15.14 (registry+https://github.com/rust-lang/crates.io-index)" = "baaba45c6bf60fe29aaf241fa33306c0b75c801edea8378263a8f043b09a5634"
"checksum synom 0.11.3 (registry+https://github.com/rust-lang/crates.io-index)" = "a393066ed9010ebaed60b9eafa373d4b1baac186dd7e008555b0f702b51945b6"
"checksum synstructure 0.10.0 (registry+https://github.com/rust-lang/crates.io-index)" = "ec37f4fab4bafaf6b5621c1d54e6aa5d4d059a8f84929e87abfdd7f9f04c6db2"
"checksum tempfile 3.0.4 (registry+https://github.com/rust-lang/crates.io-index)" = "55c1195ef8513f3273d55ff59fe5da6940287a0d7a98331254397f464833675b"
"checksum tendril 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)" = "9de21546595a0873061940d994bbbc5c35f024ae4fd61ec5c5b159115684f508"
"checksum quote 0.3.15 (registry+https://github.com/rust-lang/crates.io-index)" = "7a6e920b65c65f10b2ae65c831a81a073a89edd28c7cce89475bff467ab4167a"
"checksum quote 0.6.8 (registry+https://github.com/rust-lang/crates.io-index)" = "dd636425967c33af890042c483632d33fa7a18f19ad1d7ea72e8998c6ef8dea5"
"checksum rand 0.4.3 (registry+https://github.com/rust-lang/crates.io-index)" = "8356f47b32624fef5b3301c1be97e5944ecdd595409cc5da11d05f211db6cfbd"
"checksum rand 0.5.5 (registry+https://github.com/rust-lang/crates.io-index)" = "e464cd887e869cddcae8792a4ee31d23c7edd516700695608f5b98c67ee0131c"
"checksum rand_core 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)" = "1961a422c4d189dfb50ffa9320bf1f2a9bd54ecb92792fb9477f99a1045f3372"
"checksum rand_core 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)" = "0905b6b7079ec73b314d4c748701f6931eb79fd97c668caa3f1899b22b32c6db"
"checksum redox_syscall 0.1.40 (registry+https://github.com/rust-lang/crates.io-index)" = "c214e91d3ecf43e9a4e41e578973adeb14b474f2bee858742d127af75a0112b1"
"checksum redox_termios 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "7e891cfe48e9100a70a3b6eb652fef28920c117d366339687bd5576160db0f76"
"checksum minidom 0.9.1 (registry+https://github.com/rust-lang/crates.io-index)" = "c0a5296bf9d0ac9e4a6e4cb844e3ee84bf33f841c7b3ae2cc87f05ceb81b50ae"
"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.1 (registry+https://github.com/rust-lang/crates.io-index)" = "0cdc457076c78ab54d5e0d6fa7c47981757f1e34dc39ff92787f217dede586c4"
"checksum nodrop 0.1.12 (registry+https://github.com/rust-lang/crates.io-index)" = "9a2228dca57108069a5262f2ed8bd2e82496d2e074a06d1ccc7ce1687b6ae0a2"
"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.8.0 (registry+https://github.com/rust-lang/crates.io-index)" = "c51a3322e4bca9d212ad9a158a02abc6934d005490c054a2778df73a70aa0a30"
"checksum openssl 0.10.15 (registry+https://github.com/rust-lang/crates.io-index)" = "5e1309181cdcbdb51bc3b6bedb33dfac2a83b3d585033d3f6d9e22e8c1928613"
"checksum openssl-probe 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)" = "77af24da69f9d9341038eba93a073b1fdaaa1b788221b00a69bce9e762cb32de"
"checksum openssl-sys 0.9.39 (registry+https://github.com/rust-lang/crates.io-index)" = "278c1ad40a89aa1e741a1eed089a2f60b18fab8089c3139b542140fc7d674106"
"checksum owning_ref 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)" = "cdf84f41639e037b484f93433aa3897863b561ed65c6e59c7073d7c561710f37"
"checksum parking_lot 0.6.4 (registry+https://github.com/rust-lang/crates.io-index)" = "f0802bff09003b291ba756dc7e79313e51cc31667e94afbe847def490424cde5"
"checksum parking_lot_core 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)" = "ad7f7e6ebdc79edff6fdcb87a55b620174f7a989e3eb31b65231f4af57f00b8c"
"checksum percent-encoding 1.0.1 (registry+https://github.com/rust-lang/crates.io-index)" = "31010dd2e1ac33d5b46a5b413495239882813e0369f8ed8a5e266f173602f831"
"checksum phf 0.7.23 (registry+https://github.com/rust-lang/crates.io-index)" = "cec29da322b242f4c3098852c77a0ca261c9c01b806cae85a5572a1eb94db9a6"
"checksum phf_codegen 0.7.23 (registry+https://github.com/rust-lang/crates.io-index)" = "7d187f00cd98d5afbcd8898f6cf181743a449162aeb329dcd2f3849009e605ad"
"checksum phf_generator 0.7.23 (registry+https://github.com/rust-lang/crates.io-index)" = "03dc191feb9b08b0dc1330d6549b795b9d81aec19efe6b4a45aec8d4caee0c4b"
"checksum phf_shared 0.7.23 (registry+https://github.com/rust-lang/crates.io-index)" = "b539898d22d4273ded07f64a05737649dc69095d92cb87c7097ec68e3f150b93"
"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.20 (registry+https://github.com/rust-lang/crates.io-index)" = "3d7b7eaaa90b4a90a932a9ea6666c95a389e424eff347f0f793979289429feee"
"checksum quick-error 1.2.2 (registry+https://github.com/rust-lang/crates.io-index)" = "9274b940887ce9addde99c4eee6b5c44cc494b182b97e73dc8ffdcb3397fd3f0"
"checksum quick-xml 0.12.4 (registry+https://github.com/rust-lang/crates.io-index)" = "1d8065cbb01701c11cc195cde85cbf39d1c6a80705b67a157ebb3042e0e5777f"
"checksum hyper 0.12.13 (registry+https://github.com/rust-lang/crates.io-index)" = "95ffee0d1d30de4313fdaaa485891ce924991d45bbc18adfc8ac5b1639e62fbb"
"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.7 (registry+https://github.com/rust-lang/crates.io-index)" = "fccb81dd962b29a25de46c4f46e497b75117aa816468b6fff7a63a598a192394"
"checksum itoa 0.4.3 (registry+https://github.com/rust-lang/crates.io-index)" = "1306f3464951f30e30d12373d31c79fbd52d236e5e896fd92f96ec7babbbe60b"
"checksum jid 0.5.2 (registry+https://github.com/rust-lang/crates.io-index)" = "6c4cee633b7ce95e71202ecb99e632d15ad468de7753e616a924c93842f1a3d0"
"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.1.0 (registry+https://github.com/rust-lang/crates.io-index)" = "ca488b89a5657b0a2ecd45b95609b3e848cf1755da332a0da46e2b2b1cb371a7"
"checksum lazycell 1.2.0 (registry+https://github.com/rust-lang/crates.io-index)" = "ddba4c30a78328befecec92fc94970e53b3ae385827d28620f0f5bb2493081e0"
"checksum libc 0.2.43 (registry+https://github.com/rust-lang/crates.io-index)" = "76e3a3ef172f1a0b9a9ff0dd1491ae5e6c948b94479a3021819ba7d860c8645d"
"checksum linked-hash-map 0.4.2 (registry+https://github.com/rust-lang/crates.io-index)" = "7860ec297f7008ff7a1e3382d7f7e1dcd69efc94751a2284bafc3d013c2aa939"
"checksum lock_api 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)" = "775751a3e69bde4df9b38dd00a1b5d6ac13791e4223d4a0506577f0dd27cfb7a"
"checksum log 0.3.9 (registry+https://github.com/rust-lang/crates.io-index)" = "e19e8d5c34a3e0e2223db8e060f9e8264aeeb5c5fc64a4ee9965c062211c024b"
"checksum log 0.4.5 (registry+https://github.com/rust-lang/crates.io-index)" = "d4fcce5fa49cc693c312001daf1d13411c4a5283796bac1084299ea3e567113f"
"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.3 (registry+https://github.com/rust-lang/crates.io-index)" = "a87c4100d614080c8ab43334fb028ebe387f273fb61ed4ff0eae9189b94b6be8"
"checksum matches 0.1.8 (registry+https://github.com/rust-lang/crates.io-index)" = "7ffc5c5338469d4d3ea17d269fa8ea3512ad247247c30bd2df69e68309ed0a08"
"checksum memchr 2.1.0 (registry+https://github.com/rust-lang/crates.io-index)" = "4b3629fe9fdbff6daa6c33b90f7c08355c1aca05a3d01fa8063b822fcf185f3b"
"checksum memoffset 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)" = "0f9dc261e2b62d7a622bf416ea3c5245cdd5d9a7fcc428c0d06804dfce1775b3"
"checksum error-chain 0.1.12 (registry+https://github.com/rust-lang/crates.io-index)" = "faa976b4fd2e4c2b2f3f486874b19e61944d3de3de8b61c9fcf835d583871bcc"
"checksum error-chain 0.8.1 (registry+https://github.com/rust-lang/crates.io-index)" = "6930e04918388a9a2e41d518c25cf679ccafe26733fb4127dbf21993f2575d46"
"checksum failure 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)" = "6dd377bcc1b1b7ce911967e3ec24fa19c3224394ec05b54aa7b083d498341ac7"
"checksum failure_derive 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)" = "64c2d913fe8ed3b6c6518eedf4538255b989945c14c2a7d5cbff62a5e2120596"
"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-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.9.0 (registry+https://github.com/rust-lang/crates.io-index)" = "ef25c5683767570c2bbd7deba372926a55eaae9982d7726ee2a1050239d45b9d"
"checksum h2 0.1.13 (registry+https://github.com/rust-lang/crates.io-index)" = "7dd33bafe2e6370e6c8eb0cf1b8c5f93390b90acde7e9b03723f166b28b648ed"
"checksum hostname 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)" = "21ceb46a83a85e824ef93669c8b390009623863b5c195d1ba747292c0c72f94e"
"checksum http 0.1.13 (registry+https://github.com/rust-lang/crates.io-index)" = "24f58e8c2d8e886055c3ead7b28793e1455270b5fb39650984c224bc538ba581"
"checksum httparse 1.3.3 (registry+https://github.com/rust-lang/crates.io-index)" = "e8734b0cfd3bc3e101ec59100e101c2eecd19282202e87808b3037b442777a83"
"checksum wincolor 1.0.1 (registry+https://github.com/rust-lang/crates.io-index)" = "561ed901ae465d6185fa7864d63fbd5720d0ef718366c9a4dc83cf6170d7e9ba"
"checksum winapi-util 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "afc5508759c5bf4285e61feb862b6083c8480aec864fa17a81fdec6f69b461ab"
"checksum utf8-ranges 1.0.1 (registry+https://github.com/rust-lang/crates.io-index)" = "fd70f467df6810094968e2fce0ee1bd0e87157aceb026a8c083bcf5e25b9efe4"
"checksum ucd-util 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "fd2be2d6639d0f8fe6cdda291ad456e23629558d466e2789d2c3e9892bda285d"
"checksum thread_local 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)" = "c6b53e329000edc2b34dbe8545fd20e55a333362d0a321909685a19bd28c3f1b"
"checksum termcolor 1.0.4 (registry+https://github.com/rust-lang/crates.io-index)" = "4096add70612622289f2fdcdbd5086dc81c1e2675e6ae58d6c4f62a16c6d7f2f"
"checksum regex 1.0.5 (registry+https://github.com/rust-lang/crates.io-index)" = "2069749032ea3ec200ca51e4a31df41759190a88edca0d2d86ee8bedf7073341"
"checksum regex-syntax 0.6.2 (registry+https://github.com/rust-lang/crates.io-index)" = "747ba3b235651f6e2f67dfa8bcdcd073ddb7c243cb21c442fc12395dfcac212d"
"checksum humantime 1.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "0484fda3e7007f2a4a0d9c3a703ca38c71c54c55602ce4660c419fd32e188c9e"
"checksum env_logger 0.5.13 (registry+https://github.com/rust-lang/crates.io-index)" = "15b0a4d2e39f8420210be8b27eeda28029729e2fd4291019455016c348240c38"
"checksum ansi_term 0.11.0 (registry+https://github.com/rust-lang/crates.io-index)" = "ee49baf6cb617b853aa8d93bf420db2383fab46d314482ca2803b40d5fde979b"
"checksum arc-swap 0.3.4 (registry+https://github.com/rust-lang/crates.io-index)" = "af192669a9f44d2fb63c691a04183c8e12428f34041449270b08c0456587f5a5"
"checksum arrayref 0.3.5 (registry+https://github.com/rust-lang/crates.io-index)" = "0d382e583f07208808f6b1249e60848879ba3543f57c32277bf52d69c2f0f0ee"
"checksum arrayvec 0.4.7 (registry+https://github.com/rust-lang/crates.io-index)" = "a1e964f9e24d588183fcb43503abda40d288c8657dfc27311516ce2f05675aef"
"checksum atty 0.2.11 (registry+https://github.com/rust-lang/crates.io-index)" = "9a7d5b8723950951411ee34d271d99dddcc2035a16ab25310ea2c8cfd4369652"
"checksum backtrace 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)" = "346d7644f0b5f9bc73082d3b2236b69a05fd35cce0cfa3724e184e6a5c9e2a2f"
"checksum backtrace 0.3.9 (registry+https://github.com/rust-lang/crates.io-index)" = "89a47830402e9981c5c41223151efcced65a0510c13097c769cede7efb34782a"
"checksum backtrace-sys 0.1.24 (registry+https://github.com/rust-lang/crates.io-index)" = "c66d56ac8dabd07f6aacdaf633f4b8262f5b3601a810a0dcddffd5c22c69daa0"
"checksum base64 0.9.3 (registry+https://github.com/rust-lang/crates.io-index)" = "489d6c0ed21b11d038c31b6ceccca973e65d73ba3bd8ecb9a2babf5546164643"
"checksum bitflags 1.0.4 (registry+https://github.com/rust-lang/crates.io-index)" = "228047a76f468627ca71776ecdebd732a3423081fcf5125585bcd7c49886ce12"
"checksum blake2 0.7.1 (registry+https://github.com/rust-lang/crates.io-index)" = "73b77e29dbd0115e43938be2d5128ecf81c0353e00acaa65339a1242586951d9"
"checksum block-buffer 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)" = "a076c298b9ecdb530ed9d967e74a6027d6a7478924520acddcddc24c1c8ab3ab"
"checksum byte-tools 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)" = "560c32574a12a89ecd91f5e742165893f86e3ab98d21f8ea548658eb9eef5f40"
"checksum byteorder 1.2.7 (registry+https://github.com/rust-lang/crates.io-index)" = "94f88df23a25417badc922ab0f5716cc1330e87f71ddd9203b3a3ccd9cedf75d"
"checksum bytes 0.4.10 (registry+https://github.com/rust-lang/crates.io-index)" = "0ce55bd354b095246fc34caf4e9e242f5297a7fd938b090cadfea6eee614aa62"
"checksum case 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)" = "e88b166b48e29667f5443df64df3c61dc07dc2b1a0b0d231800e07f09a33ecc1"
"checksum cc 1.0.25 (registry+https://github.com/rust-lang/crates.io-index)" = "f159dfd43363c4d08055a07703eb7a3406b0dac4d0584d96965a3262db3c9d16"
"checksum cfg-if 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)" = "082bb9b28e00d3c9d39cc03e64ce4cea0f1bb9b3fde493f0cbc008472d22bdf4"
"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 constant_time_eq 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)" = "8ff012e225ce166d4422e0e78419d901719760f62ae2b7969ca6b564d1b54a9e"
"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.6.1 (registry+https://github.com/rust-lang/crates.io-index)" = "3486aefc4c0487b9cb52372c97df0a48b8c249514af1ee99703bf70d2f2ceda1"
"checksum crossbeam-epoch 0.5.2 (registry+https://github.com/rust-lang/crates.io-index)" = "30fecfcac6abfef8771151f8be4abc9e4edc112c2bcb233314cafde2680536e9"
"checksum crossbeam-utils 0.5.0 (registry+https://github.com/rust-lang/crates.io-index)" = "677d453a17e8bd2b913fa38e8b9cf04bcdbb5be790aa294f2389661d72036015"
"checksum crypto-mac 0.5.2 (registry+https://github.com/rust-lang/crates.io-index)" = "0999b4ff4d3446d4ddb19a63e9e00c1876e75cd7000d20e57a693b4b3f08d958"
"checksum dbghelp-sys 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)" = "97590ba53bcb8ac28279161ca943a924d1fd4a8fb3fa63302591647c4fc5b850"
"checksum derive-error 0.0.4 (registry+https://github.com/rust-lang/crates.io-index)" = "ec098440b29ea3b1ece3e641bac424c19cf996779b623c9e0f2171495425c2c8"
"checksum digest 0.7.6 (registry+https://github.com/rust-lang/crates.io-index)" = "03b072242a8cbaf9c145665af9d250c59af3b958f83ed6824e13533cf76d5b90"
"checksum encoding_rs 0.8.10 (registry+https://github.com/rust-lang/crates.io-index)" = "065f4d0c826fdaef059ac45487169d918558e3cf86c9d89f6e81cf52369126e5"
"checksum aho-corasick 0.6.8 (registry+https://github.com/rust-lang/crates.io-index)" = "68f56c7353e5a9547cbd76ed90f7bb5ffc3ba09d4ea9bd1d8c06c8b1142eeb5a"
 "unicode-xid 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
]
 "proc-macro2 0.4.24 (registry+https://github.com/rust-lang/crates.io-index)",
 "quote 0.6.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "proc-macro2 0.4.20 (registry+https://github.com/rust-lang/crates.io-index)",
 "quote 0.6.8 (registry+https://github.com/rust-lang/crates.io-index)",
 "proc-macro2 0.4.20 (registry+https://github.com/rust-lang/crates.io-index)",
 "quote 0.6.8 (registry+https://github.com/rust-lang/crates.io-index)",
 "proc-macro2 0.4.24 (registry+https://github.com/rust-lang/crates.io-index)",
 "quote 0.6.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "proc-macro2 0.4.24 (registry+https://github.com/rust-lang/crates.io-index)",
 "quote 0.6.10 (registry+https://github.com/rust-lang/crates.io-index)",
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
version = "0.15.22"
version = "0.15.14"
version = "0.15.14"
version = "0.15.22"
version = "0.15.23"
version = "0.15.22"
 "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 = "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"
 "proc-macro2 0.4.24 (registry+https://github.com/rust-lang/crates.io-index)",
 "quote 0.6.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "proc-macro2 0.4.20 (registry+https://github.com/rust-lang/crates.io-index)",
 "quote 0.6.8 (registry+https://github.com/rust-lang/crates.io-index)",
 "proc-macro2 0.4.20 (registry+https://github.com/rust-lang/crates.io-index)",
 "quote 0.6.8 (registry+https://github.com/rust-lang/crates.io-index)",
 "proc-macro2 0.4.24 (registry+https://github.com/rust-lang/crates.io-index)",
 "quote 0.6.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "proc-macro2 0.4.24 (registry+https://github.com/rust-lang/crates.io-index)",
 "quote 0.6.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "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.23 (registry+https://github.com/rust-lang/crates.io-index)",
 "phf_shared 0.7.23 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde 1.0.80 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde 1.0.80 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde 1.0.82 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde 1.0.82 (registry+https://github.com/rust-lang/crates.io-index)",
 "new_debug_unreachable 1.0.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "phf_shared 0.7.23 (registry+https://github.com/rust-lang/crates.io-index)",
 "precomputed-hash 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "lazy_static 1.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "lazy_static 1.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "lazy_static 1.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "lazy_static 1.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "lazy_static 1.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
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 = [
version = "0.1.2"
version = "0.1.1"
version = "0.1.1"
version = "0.1.2"
version = "0.1.2"
 "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"
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "redox_syscall 0.1.43 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.43 (registry+https://github.com/rust-lang/crates.io-index)",
 "redox_syscall 0.1.40 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.43 (registry+https://github.com/rust-lang/crates.io-index)",
 "redox_syscall 0.1.40 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "redox_syscall 0.1.43 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.45 (registry+https://github.com/rust-lang/crates.io-index)",
 "redox_syscall 0.1.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "redox_syscall 0.1.43 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.45 (registry+https://github.com/rust-lang/crates.io-index)",
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "unreachable 1.0.0 (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)",
version = "0.6.7"
version = "0.6.6"
version = "0.6.5"
version = "0.6.5"
version = "0.6.6"
version = "0.6.7"
version = "0.6.6"
]
[[package]]
name = "siphasher"
version = "0.2.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
name = "slab"
version = "0.4.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
name = "smallvec"
 "arc-swap 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "arc-swap 0.3.4 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.43 (registry+https://github.com/rust-lang/crates.io-index)",
 "arc-swap 0.3.4 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.43 (registry+https://github.com/rust-lang/crates.io-index)",
 "arc-swap 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.45 (registry+https://github.com/rust-lang/crates.io-index)",
 "arc-swap 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.45 (registry+https://github.com/rust-lang/crates.io-index)",
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
]
[[package]]
name = "sha-1"
version = "0.7.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "block-buffer 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "byte-tools 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "digest 0.7.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "fake-simd 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "sha2"
version = "0.7.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "block-buffer 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "byte-tools 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "digest 0.7.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "fake-simd 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "sha3"
version = "0.7.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "block-buffer 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "byte-tools 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "digest 0.7.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "keccak 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "signal-hook"
version = "0.1.6"
version = "0.1.5"
version = "0.1.5"
version = "0.1.6"
version = "0.1.6"
 "serde 1.0.80 (registry+https://github.com/rust-lang/crates.io-index)",
 "ryu 0.2.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "ryu 0.2.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde 1.0.80 (registry+https://github.com/rust-lang/crates.io-index)",
 "ryu 0.2.6 (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.80 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde 1.0.82 (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.82 (registry+https://github.com/rust-lang/crates.io-index)",
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "itoa 0.4.3 (registry+https://github.com/rust-lang/crates.io-index)",
version = "1.0.33"
version = "1.0.32"
version = "1.0.32"
version = "1.0.33"
version = "1.0.33"
]
[[package]]
name = "serde_json"
 "proc-macro2 0.4.24 (registry+https://github.com/rust-lang/crates.io-index)",
 "quote 0.6.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "syn 0.15.22 (registry+https://github.com/rust-lang/crates.io-index)",
 "proc-macro2 0.4.20 (registry+https://github.com/rust-lang/crates.io-index)",
 "quote 0.6.8 (registry+https://github.com/rust-lang/crates.io-index)",
 "syn 0.15.14 (registry+https://github.com/rust-lang/crates.io-index)",
 "proc-macro2 0.4.20 (registry+https://github.com/rust-lang/crates.io-index)",
 "quote 0.6.8 (registry+https://github.com/rust-lang/crates.io-index)",
 "syn 0.15.14 (registry+https://github.com/rust-lang/crates.io-index)",
 "proc-macro2 0.4.24 (registry+https://github.com/rust-lang/crates.io-index)",
 "quote 0.6.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "syn 0.15.22 (registry+https://github.com/rust-lang/crates.io-index)",
 "syn 0.15.23 (registry+https://github.com/rust-lang/crates.io-index)",
 "proc-macro2 0.4.24 (registry+https://github.com/rust-lang/crates.io-index)",
 "quote 0.6.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "syn 0.15.22 (registry+https://github.com/rust-lang/crates.io-index)",
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
version = "1.0.80"
version = "1.0.80"
version = "1.0.82"
version = "1.0.82"
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
name = "serde_derive"
version = "1.0.80"
version = "1.0.80"
version = "1.0.82"
version = "1.0.82"
 "xmpp-parsers 0.11.1 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "serde"
 "toml 0.4.9 (registry+https://github.com/rust-lang/crates.io-index)",
 "toml 0.4.8 (registry+https://github.com/rust-lang/crates.io-index)",
 "toml 0.4.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "toml 0.4.8 (registry+https://github.com/rust-lang/crates.io-index)",
 "toml 0.4.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "toml 0.4.9 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-xmpp 0.2.0 (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-signal 0.2.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-signal 0.2.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-signal 0.2.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-signal 0.2.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio 0.1.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio 0.1.13 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio 0.1.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio 0.1.13 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde 1.0.80 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde_derive 1.0.80 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio 0.1.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde 1.0.80 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde_derive 1.0.80 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde 1.0.82 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde_derive 1.0.82 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio 0.1.13 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde 1.0.82 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde_derive 1.0.82 (registry+https://github.com/rust-lang/crates.io-index)",
 "minidom 0.9.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "env_logger 0.6.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "hyper 0.12.16 (registry+https://github.com/rust-lang/crates.io-index)",
 "log 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "env_logger 0.5.13 (registry+https://github.com/rust-lang/crates.io-index)",
 "hyper 0.12.13 (registry+https://github.com/rust-lang/crates.io-index)",
 "log 0.4.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "env_logger 0.5.13 (registry+https://github.com/rust-lang/crates.io-index)",
 "hyper 0.12.13 (registry+https://github.com/rust-lang/crates.io-index)",
 "log 0.4.5 (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.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "log 0.3.9 (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.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "time 0.1.40 (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"
source = "registry+https://github.com/rust-lang/crates.io-index"
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 = "version_check"
version = "0.1.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
name = "void"
version = "1.0.2"
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.5 (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"
 "env_logger 0.6.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "failure 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "log 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "hyper 0.12.17 (registry+https://github.com/rust-lang/crates.io-index)",
 "hyper 0.12.18 (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.1 (registry+https://github.com/rust-lang/crates.io-index)",
]
dependencies = [
 "winapi 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",
]
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
name = "winapi-util"
version = "0.1.1"
name = "utf8-ranges"
version = "1.0.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
 "env_logger 0.6.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "failure 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "log 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "hyper 0.12.17 (registry+https://github.com/rust-lang/crates.io-index)",
 "hyper 0.12.16 (registry+https://github.com/rust-lang/crates.io-index)",
dependencies = [
 "clap 2.32.0 (registry+https://github.com/rust-lang/crates.io-index)",
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
name = "unreachable"
version = "1.0.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "void 1.0.2 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "url"
version = "1.7.1"
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.4"
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.7"
source = "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"
]
[[package]]
name = "tokio-codec"
version = "0.1.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "bytes 0.4.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.25 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "tokio-current-thread"
version = "0.1.3"
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.5 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "tokio-executor"
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)",
]
[[package]]
name = "tokio-fs"
version = "0.1.4"
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.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-threadpool 0.1.8 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "tokio-io"
version = "0.1.10"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "bytes 0.4.10 (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.5 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "tokio-reactor"
version = "0.1.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "crossbeam-utils 0.5.0 (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.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "log 0.4.5 (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.8.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "parking_lot 0.6.4 (registry+https://github.com/rust-lang/crates.io-index)",
 "slab 0.4.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-executor 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "tokio-signal"
version = "0.2.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)",
 "libc 0.2.43 (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.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-executor 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-reactor 0.1.6 (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-tcp"
version = "0.1.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "bytes 0.4.10 (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.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-reactor 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "tokio-threadpool"
version = "0.1.8"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "crossbeam-deque 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "crossbeam-utils 0.5.0 (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.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "num_cpus 1.8.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand 0.5.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-executor 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "tokio-timer"
version = "0.2.7"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "crossbeam-utils 0.5.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.25 (registry+https://github.com/rust-lang/crates.io-index)",
 "slab 0.4.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-executor 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "tokio-tls"
version = "0.2.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)",
 "native-tls 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "tokio-udp"
version = "0.1.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "bytes 0.4.10 (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.5 (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.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-reactor 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "tokio-uds"
version = "0.2.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "bytes 0.4.10 (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.43 (registry+https://github.com/rust-lang/crates.io-index)",
 "log 0.4.5 (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-io 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-reactor 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "tokio-xmpp"
version = "0.2.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "bytes 0.4.10 (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)",
 "jid 0.5.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "minidom 0.9.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "native-tls 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "quick-xml 0.12.4 (registry+https://github.com/rust-lang/crates.io-index)",
 "sasl 0.4.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio 0.1.11 (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.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-tls 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "trust-dns-proto 0.4.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "trust-dns-resolver 0.9.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "try_from 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "xml5ever 0.12.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "xmpp-parsers 0.11.1 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "toml"
version = "0.4.8"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "serde 1.0.80 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "trust-dns-proto"
version = "0.4.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "byteorder 1.2.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "error-chain 0.1.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.25 (registry+https://github.com/rust-lang/crates.io-index)",
 "idna 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "lazy_static 1.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "log 0.4.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand 0.4.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "smallvec 0.6.5 (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.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-reactor 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-tcp 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-timer 0.2.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-udp 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "url 1.7.1 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "trust-dns-resolver"
version = "0.9.1"
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)",
 "error-chain 0.1.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.25 (registry+https://github.com/rust-lang/crates.io-index)",
 "ipconfig 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "lazy_static 1.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "log 0.4.5 (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.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "smallvec 0.6.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio 0.1.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "trust-dns-proto 0.4.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.2.2"
source = "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]]
]
[[package]]
name = "time"
version = "0.1.40"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "libc 0.2.43 (registry+https://github.com/rust-lang/crates.io-index)",
 "redox_syscall 0.1.40 (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.11"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "bytes 0.4.10 (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)",
 "tokio-codec 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-current-thread 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-executor 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-fs 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-reactor 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-tcp 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-threadpool 0.1.8 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-timer 0.2.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-udp 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-uds 0.2.3 (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.43 (registry+https://github.com/rust-lang/crates.io-index)",
 "redox_syscall 0.1.40 (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 = "tempfile"
version = "3.0.4"
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.43 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand 0.5.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "redox_syscall 0.1.40 (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.0"
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.4 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-signal 0.2.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-xmpp 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "toml 0.4.8 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "serde"
version = "1.0.80"
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
name = "serde_derive"
version = "1.0.80"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "proc-macro2 0.4.20 (registry+https://github.com/rust-lang/crates.io-index)",
 "quote 0.6.8 (registry+https://github.com/rust-lang/crates.io-index)",
 "syn 0.15.14 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "serde_json"
version = "1.0.32"
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.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde 1.0.80 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "sha-1"
version = "0.7.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "block-buffer 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "byte-tools 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "digest 0.7.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "fake-simd 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "sha2"
version = "0.7.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "block-buffer 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "byte-tools 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "digest 0.7.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "fake-simd 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "sha3"
version = "0.7.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "block-buffer 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "byte-tools 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "digest 0.7.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "keccak 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "signal-hook"
version = "0.1.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "arc-swap 0.3.4 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.43 (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.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
name = "smallvec"
version = "0.6.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "unreachable 1.0.0 (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.43 (registry+https://github.com/rust-lang/crates.io-index)",
 "redox_syscall 0.1.40 (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.1"
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.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "new_debug_unreachable 1.0.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "phf_shared 0.7.23 (registry+https://github.com/rust-lang/crates.io-index)",
 "precomputed-hash 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde 1.0.80 (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.23 (registry+https://github.com/rust-lang/crates.io-index)",
 "phf_shared 0.7.23 (registry+https://github.com/rust-lang/crates.io-index)",
 "proc-macro2 0.4.20 (registry+https://github.com/rust-lang/crates.io-index)",
 "quote 0.6.8 (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 = "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.14"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "proc-macro2 0.4.20 (registry+https://github.com/rust-lang/crates.io-index)",
 "quote 0.6.8 (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.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "proc-macro2 0.4.20 (registry+https://github.com/rust-lang/crates.io-index)",
 "quote 0.6.8 (registry+https://github.com/rust-lang/crates.io-index)",
 "syn 0.15.14 (registry+https://github.com/rust-lang/crates.io-index)",
 "unicode-xid 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
]
 "serde 1.0.80 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde_derive 1.0.80 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio 0.1.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "hyper 0.12.13 (registry+https://github.com/rust-lang/crates.io-index)",
dependencies = [
 "clap 2.32.0 (registry+https://github.com/rust-lang/crates.io-index)",
name = "ucd-util"
version = "0.1.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
]
[[package]]
name = "thread_local"
version = "0.3.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "lazy_static 1.1.0 (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)",
 "log 0.4.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "env_logger 0.5.13 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.1.0"
version = "0.1.0"
 "ryu 0.2.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde 1.0.80 (registry+https://github.com/rust-lang/crates.io-index)",
version = "1.0.32"
 "proc-macro2 0.4.20 (registry+https://github.com/rust-lang/crates.io-index)",
 "quote 0.6.8 (registry+https://github.com/rust-lang/crates.io-index)",
 "syn 0.15.14 (registry+https://github.com/rust-lang/crates.io-index)",
version = "1.0.80"
version = "1.0.80"
 "toml 0.4.8 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde 1.0.80 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde_derive 1.0.80 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-xmpp 0.2.0 (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.13.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "xmpp-parsers 0.12.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "xmpp-parsers 0.12.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "try_from 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "xmpp-parsers 0.11.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "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)",
 "try_from 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "xmpp-parsers 0.11.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio 0.1.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-signal 0.2.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio 0.1.13 (registry+https://github.com/rust-lang/crates.io-index)",
version = "1.0.83"
version = "1.0.83"
version = "1.0.80"
version = "1.0.80"
version = "1.0.34"
 "serde 1.0.88 (registry+https://github.com/rust-lang/crates.io-index)",
version = "1.0.88"
version = "1.0.88"
 "serde 1.0.89 (registry+https://github.com/rust-lang/crates.io-index)",
version = "1.0.39"
version = "1.0.89"
version = "1.0.89"
version = "1.0.82"
version = "1.0.82"
version = "1.0.36"
 "proc-macro2 0.4.26 (registry+https://github.com/rust-lang/crates.io-index)",
 "quote 0.6.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "syn 0.15.26 (registry+https://github.com/rust-lang/crates.io-index)",
version = "1.0.85"
version = "1.0.85"
 "serde 1.0.87 (registry+https://github.com/rust-lang/crates.io-index)",
version = "1.0.38"
 "proc-macro2 0.4.27 (registry+https://github.com/rust-lang/crates.io-index)",
 "syn 0.15.29 (registry+https://github.com/rust-lang/crates.io-index)",
 "syn 0.15.28 (registry+https://github.com/rust-lang/crates.io-index)",
 "syn 0.15.26 (registry+https://github.com/rust-lang/crates.io-index)",
 "syn 0.15.26 (registry+https://github.com/rust-lang/crates.io-index)",
 "syn 0.15.26 (registry+https://github.com/rust-lang/crates.io-index)",
 "syn 0.15.27 (registry+https://github.com/rust-lang/crates.io-index)",
 "syn 0.15.27 (registry+https://github.com/rust-lang/crates.io-index)",
 "quote 0.6.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "quote 0.6.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "syn 0.15.30 (registry+https://github.com/rust-lang/crates.io-index)",
version = "1.0.87"
version = "1.0.87"
 "tokio-xmpp 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "toml 0.5.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "toml 0.4.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "toml 0.5.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "xmpp-parsers 0.13.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "minidom 0.10.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio 0.1.17 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio 0.1.15 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio 0.1.16 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde 1.0.88 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde_derive 1.0.88 (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)",
 "serde 1.0.87 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde_derive 1.0.87 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde 1.0.87 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde_derive 1.0.87 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio 0.1.15 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde 1.0.90 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde_derive 1.0.90 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio 0.1.18 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde 1.0.87 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde_derive 1.0.87 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio 0.1.15 (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 1.0.87 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde_derive 1.0.87 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde 1.0.90 (registry+https://github.com/rust-lang/crates.io-index)",
version = "1.0.39"
 "quote 0.6.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "syn 0.15.30 (registry+https://github.com/rust-lang/crates.io-index)",
 "proc-macro2 0.4.27 (registry+https://github.com/rust-lang/crates.io-index)",
version = "1.0.90"
version = "1.0.90"
 "toml 0.5.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "xmpp-parsers 0.13.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-xmpp 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde 1.0.90 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde_derive 1.0.90 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio 0.1.18 (registry+https://github.com/rust-lang/crates.io-index)",
 "minidom 0.10.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "hyper 0.12.27 (registry+https://github.com/rust-lang/crates.io-index)",
 "failure 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "clap 2.33.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "env_logger 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)",
version = "1.0.83"
version = "1.0.83"
 "serde 1.0.89 (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)",
version = "1.0.89"
version = "1.0.89"
 "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)",
 "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)",
 "hyper 0.12.25 (registry+https://github.com/rust-lang/crates.io-index)",
 "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)",
 "serde 1.0.87 (registry+https://github.com/rust-lang/crates.io-index)",
version = "1.0.38"
version = "1.0.87"
version = "1.0.87"
 "ryu 0.2.7 (registry+https://github.com/rust-lang/crates.io-index)",
version = "1.0.33"
 "proc-macro2 0.4.24 (registry+https://github.com/rust-lang/crates.io-index)",
 "quote 0.6.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "syn 0.15.22 (registry+https://github.com/rust-lang/crates.io-index)",
 "toml 0.4.10 (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)",
 "minidom 0.9.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "log 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)",
version = "1.0.83"
version = "1.0.83"
 "serde 1.0.85 (registry+https://github.com/rust-lang/crates.io-index)",
version = "1.0.36"
 "proc-macro2 0.4.26 (registry+https://github.com/rust-lang/crates.io-index)",
 "quote 0.6.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "syn 0.15.26 (registry+https://github.com/rust-lang/crates.io-index)",
version = "1.0.85"
version = "1.0.85"
 "tokio-xmpp 0.2.3 (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.85 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde_derive 1.0.85 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio 0.1.14 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde 1.0.90 (registry+https://github.com/rust-lang/crates.io-index)",
version = "1.0.39"
version = "1.0.90"
version = "1.0.90"
 "clap 2.33.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "env_logger 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "hyper 0.12.24 (registry+https://github.com/rust-lang/crates.io-index)",
 "hyper 0.12.25 (registry+https://github.com/rust-lang/crates.io-index)",
 "hyper 0.12.23 (registry+https://github.com/rust-lang/crates.io-index)",
 "hyper 0.12.23 (registry+https://github.com/rust-lang/crates.io-index)",
 "hyper 0.12.27 (registry+https://github.com/rust-lang/crates.io-index)",
 "hyper 0.12.23 (registry+https://github.com/rust-lang/crates.io-index)",
 "hyper 0.12.25 (registry+https://github.com/rust-lang/crates.io-index)",
 "hyper 0.12.23 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde 1.0.80 (registry+https://github.com/rust-lang/crates.io-index)",
version = "1.0.33"
 "proc-macro2 0.4.24 (registry+https://github.com/rust-lang/crates.io-index)",
 "quote 0.6.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "syn 0.15.22 (registry+https://github.com/rust-lang/crates.io-index)",
version = "1.0.80"
version = "1.0.80"
 "tokio-xmpp 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "toml 0.4.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "try_from 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "xmpp-parsers 0.11.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "minidom 0.9.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde 1.0.80 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde_derive 1.0.80 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio 0.1.13 (registry+https://github.com/rust-lang/crates.io-index)",
 "clap 2.32.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "env_logger 0.6.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "failure 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "hyper 0.12.17 (registry+https://github.com/rust-lang/crates.io-index)",
version = "1.0.80"
version = "1.0.80"
version = "1.0.80"
version = "1.0.80"
version = "0.6.5"
version = "0.4.1"
 "arc-swap 0.3.4 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.43 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.1.5"
 "block-buffer 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "byte-tools 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "digest 0.7.6 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.7.3"
 "block-buffer 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "byte-tools 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "digest 0.7.6 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.7.1"
 "block-buffer 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "byte-tools 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "digest 0.7.6 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.7.0"
version = "0.6.7"
 "arc-swap 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.45 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.1.7"
version = "0.6.6"
 "arc-swap 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.1.6"
version = "0.6.9"
 "block-buffer 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "block-buffer 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "block-buffer 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.6.9"
version = "0.1.8"
 "block-buffer 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "block-buffer 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "block-buffer 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.6.7"
version = "0.6.8"
version = "0.4.2"
 "arc-swap 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.47 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.1.7"
 "opaque-debug 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "block-buffer 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "byte-tools 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "digest 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.8.1"
 "opaque-debug 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "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)",
version = "0.8.0"
 "opaque-debug 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "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)",
version = "0.8.1"
version = "0.6.8"
version = "0.4.2"
 "arc-swap 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.50 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.50 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.48 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.48 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.48 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.49 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.49 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.1.7"
 "opaque-debug 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "block-buffer 0.7.2 (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)",
version = "0.8.1"
 "opaque-debug 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "block-buffer 0.7.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "digest 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.8.0"
 "opaque-debug 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "block-buffer 0.7.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "digest 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.8.1"
version = "0.6.9"
version = "0.4.2"
 "arc-swap 0.3.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.1.8"
 "opaque-debug 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "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)",
version = "0.8.1"
 "opaque-debug 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "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)",
version = "0.8.0"
 "opaque-debug 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "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)",
version = "0.8.1"
version = "0.6.7"
 "arc-swap 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.45 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.1.7"
 "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)",
dependencies = [
 "unreachable 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)",
]
 "cfg-if 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.50 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.1.1"
 "lazy_static 1.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde 1.0.80 (registry+https://github.com/rust-lang/crates.io-index)",
 "phf_generator 0.7.23 (registry+https://github.com/rust-lang/crates.io-index)",
 "phf_shared 0.7.23 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.8.0"
name = "subtle"
version = "1.0.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
version = "0.15.14"
 "proc-macro2 0.4.20 (registry+https://github.com/rust-lang/crates.io-index)",
 "quote 0.6.8 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.10.0"
 "proc-macro2 0.4.20 (registry+https://github.com/rust-lang/crates.io-index)",
 "quote 0.6.8 (registry+https://github.com/rust-lang/crates.io-index)",
 "syn 0.15.14 (registry+https://github.com/rust-lang/crates.io-index)",
version = "3.0.4"
 "cfg-if 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.50 (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.7 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.4.0"
 "utf-8 0.7.4 (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 = [
 "redox_syscall 0.1.51 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.11.0"
]
[[package]]
name = "thread_local"
version = "0.3.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
]
[[package]]
name = "time"
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)",
version = "0.1.11"
 "bytes 0.4.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "num_cpus 1.9.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-current-thread 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-reactor 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-threadpool 0.1.8 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-timer 0.2.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-udp 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-uds 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-threadpool 0.1.9 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-udp 0.1.3 (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.26 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.25 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.25 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.25 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-uds 0.2.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-uds 0.2.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-uds 0.2.4 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-uds 0.2.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-uds 0.2.4 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-uds 0.2.4 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-timer 0.2.8 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-tcp 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-reactor 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-executor 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-fs 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-current-thread 0.1.5 (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-threadpool 0.1.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-trace-core 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-trace-core 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-threadpool 0.1.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-timer 0.2.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-threadpool 0.1.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-threadpool 0.1.13 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-threadpool 0.1.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-threadpool 0.1.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-fs 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-reactor 0.1.8 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-sync 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-tcp 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-fs 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-reactor 0.1.8 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-sync 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-fs 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-reactor 0.1.8 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-sync 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-fs 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-reactor 0.1.9 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-sync 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-sync 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-current-thread 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-executor 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-sync 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-threadpool 0.1.13 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-trace-core 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-timer 0.2.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-threadpool 0.1.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-tcp 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-sync 0.1.3 (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-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-current-thread 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-current-thread 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-executor 0.1.6 (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.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-reactor 0.1.8 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-tcp 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-threadpool 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-executor 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-fs 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-reactor 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-tcp 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-threadpool 0.1.9 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-current-thread 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-executor 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-fs 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-reactor 0.1.9 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-sync 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-current-thread 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-executor 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-fs 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-reactor 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-tcp 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-threadpool 0.1.9 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-timer 0.2.8 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-current-thread 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-timer 0.2.8 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-udp 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "tokio-channel"
 "tokio-uds 0.2.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-uds 0.2.4 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-uds 0.2.4 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-uds 0.2.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.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-reactor 0.1.8 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-tcp 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-threadpool 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-executor 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-fs 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-reactor 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-tcp 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-threadpool 0.1.9 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-executor 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-fs 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-reactor 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-tcp 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-threadpool 0.1.9 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-executor 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-fs 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-reactor 0.1.8 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-tcp 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-threadpool 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-current-thread 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-current-thread 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "num_cpus 1.8.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "num_cpus 1.10.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "num_cpus 1.10.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "num_cpus 1.9.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "num_cpus 1.9.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "num_cpus 1.9.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "num_cpus 1.10.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "num_cpus 1.9.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "num_cpus 1.9.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "num_cpus 1.8.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "num_cpus 1.9.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "num_cpus 1.9.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "num_cpus 1.10.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "num_cpus 1.8.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "num_cpus 1.8.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "num_cpus 1.8.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "num_cpus 1.8.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-codec 0.1.1 (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.9.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "num_cpus 1.10.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "num_cpus 1.8.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "num_cpus 1.8.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "num_cpus 1.9.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "num_cpus 1.8.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "num_cpus 1.9.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "bytes 0.4.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "bytes 0.4.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "bytes 0.4.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",
 "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)",
 "bytes 0.4.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "bytes 0.4.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "bytes 0.4.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",
 "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)",
 "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)",
 "bytes 0.4.11 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.1.17"
version = "0.1.16"
version = "0.1.14"
version = "0.1.15"
version = "0.1.18"
version = "0.1.16"
version = "0.1.15"
version = "0.1.13"
version = "0.1.14"
version = "0.1.18"
version = "0.1.13"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
version = "0.1.13"
version = "0.1.15"
version = "0.1.16"
version = "0.1.13"
version = "0.1.13"
version = "0.1.14"
]
[[package]]
name = "tokio"
 "winapi 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.43 (registry+https://github.com/rust-lang/crates.io-index)",
 "redox_syscall 0.1.40 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.45 (registry+https://github.com/rust-lang/crates.io-index)",
 "redox_syscall 0.1.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "redox_syscall 0.1.43 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.50 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.50 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.45 (registry+https://github.com/rust-lang/crates.io-index)",
 "redox_syscall 0.1.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.47 (registry+https://github.com/rust-lang/crates.io-index)",
 "redox_syscall 0.1.51 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.48 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
 "redox_syscall 0.1.54 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.45 (registry+https://github.com/rust-lang/crates.io-index)",
 "redox_syscall 0.1.44 (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)",
 "libc 0.2.48 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "redox_syscall 0.1.43 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.45 (registry+https://github.com/rust-lang/crates.io-index)",
 "redox_syscall 0.1.49 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.47 (registry+https://github.com/rust-lang/crates.io-index)",
 "redox_syscall 0.1.51 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
 "redox_syscall 0.1.54 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "redox_syscall 0.1.43 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "redox_syscall 0.1.43 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "redox_syscall 0.1.43 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "redox_syscall 0.1.43 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.48 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.49 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "redox_syscall 0.1.43 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "redox_syscall 0.1.43 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.47 (registry+https://github.com/rust-lang/crates.io-index)",
 "redox_syscall 0.1.51 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "redox_syscall 0.1.43 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.49 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.1.40"
version = "0.1.41"
version = "0.1.40"
version = "0.1.41"
version = "0.1.42"
version = "0.1.42"
version = "0.1.42"
version = "0.1.41"
version = "0.1.41"
version = "0.1.42"
version = "0.1.40"
version = "0.1.40"
version = "0.1.40"
version = "0.1.40"
version = "0.1.40"
version = "0.1.40"
version = "0.1.42"
version = "0.1.40"
name = "thread_local"
version = "0.3.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "lazy_static 1.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
 "lazy_static 1.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "lazy_static 1.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "lazy_static 1.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "lazy_static 1.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "lazy_static 1.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "lazy_static 1.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "lazy_static 1.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "lazy_static 1.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.10.0"
version = "0.11.0"
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)",
version = "0.10.0"
 "redox_termios 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "textwrap"
 "libc 0.2.43 (registry+https://github.com/rust-lang/crates.io-index)",
 "redox_syscall 0.1.40 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.45 (registry+https://github.com/rust-lang/crates.io-index)",
 "redox_syscall 0.1.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "redox_syscall 0.1.43 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.50 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.50 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.45 (registry+https://github.com/rust-lang/crates.io-index)",
 "redox_syscall 0.1.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.47 (registry+https://github.com/rust-lang/crates.io-index)",
 "redox_syscall 0.1.51 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.48 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
 "redox_syscall 0.1.54 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.45 (registry+https://github.com/rust-lang/crates.io-index)",
 "redox_syscall 0.1.44 (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)",
 "libc 0.2.48 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "redox_syscall 0.1.43 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.45 (registry+https://github.com/rust-lang/crates.io-index)",
 "redox_syscall 0.1.49 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.47 (registry+https://github.com/rust-lang/crates.io-index)",
 "redox_syscall 0.1.51 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
 "redox_syscall 0.1.54 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "redox_syscall 0.1.43 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "redox_syscall 0.1.43 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "redox_syscall 0.1.43 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "redox_syscall 0.1.43 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.48 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.49 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "redox_syscall 0.1.43 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "redox_syscall 0.1.43 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.47 (registry+https://github.com/rust-lang/crates.io-index)",
 "redox_syscall 0.1.51 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "redox_syscall 0.1.43 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.49 (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)",
 "utf-8 0.7.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "utf-8 0.7.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "utf-8 0.7.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "utf-8 0.7.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "utf-8 0.7.4 (registry+https://github.com/rust-lang/crates.io-index)",
 "utf-8 0.7.4 (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)",
 "utf-8 0.7.4 (registry+https://github.com/rust-lang/crates.io-index)",
 "utf-8 0.7.4 (registry+https://github.com/rust-lang/crates.io-index)",
 "utf-8 0.7.5 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.4.1"
version = "0.4.0"
version = "0.4.1"
version = "0.4.1"
version = "0.4.1"
version = "0.4.1"
version = "0.4.1"
version = "0.4.1"
version = "0.4.1"
version = "0.4.0"
version = "0.4.0"
version = "0.4.0"
version = "0.4.0"
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)",
version = "0.4.0"
version = "0.4.0"
version = "0.4.1"
version = "0.4.0"
 "winapi 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.6 (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"
 "redox_syscall 0.1.54 (registry+https://github.com/rust-lang/crates.io-index)",
 "cfg-if 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.50 (registry+https://github.com/rust-lang/crates.io-index)",
 "remove_dir_all 0.5.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "cfg-if 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
 "redox_syscall 0.1.54 (registry+https://github.com/rust-lang/crates.io-index)",
 "redox_syscall 0.1.51 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand 0.6.5 (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)",
 "cfg-if 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.48 (registry+https://github.com/rust-lang/crates.io-index)",
 "cfg-if 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
 "cfg-if 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "redox_syscall 0.1.43 (registry+https://github.com/rust-lang/crates.io-index)",
 "cfg-if 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand 0.6.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "redox_syscall 0.1.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "redox_syscall 0.1.43 (registry+https://github.com/rust-lang/crates.io-index)",
 "redox_syscall 0.1.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "redox_syscall 0.1.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "redox_syscall 0.1.49 (registry+https://github.com/rust-lang/crates.io-index)",
 "redox_syscall 0.1.43 (registry+https://github.com/rust-lang/crates.io-index)",
 "redox_syscall 0.1.43 (registry+https://github.com/rust-lang/crates.io-index)",
 "redox_syscall 0.1.43 (registry+https://github.com/rust-lang/crates.io-index)",
 "redox_syscall 0.1.43 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.43 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand 0.5.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "redox_syscall 0.1.40 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.45 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.45 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.47 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand 0.6.4 (registry+https://github.com/rust-lang/crates.io-index)",
 "redox_syscall 0.1.51 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.48 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.45 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "redox_syscall 0.1.43 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.45 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.47 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand 0.6.4 (registry+https://github.com/rust-lang/crates.io-index)",
 "redox_syscall 0.1.51 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "redox_syscall 0.1.43 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "redox_syscall 0.1.43 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.47 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand 0.6.4 (registry+https://github.com/rust-lang/crates.io-index)",
 "redox_syscall 0.1.51 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (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.48 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.49 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.49 (registry+https://github.com/rust-lang/crates.io-index)",
version = "3.0.7"
version = "3.0.7"
version = "3.0.6"
version = "3.0.7"
version = "3.0.6"
version = "3.0.5"
version = "3.0.7"
version = "3.0.5"
version = "3.0.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
version = "3.0.6"
version = "3.0.7"
version = "3.0.6"
 "proc-macro2 0.4.26 (registry+https://github.com/rust-lang/crates.io-index)",
 "quote 0.6.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "syn 0.15.26 (registry+https://github.com/rust-lang/crates.io-index)",
 "proc-macro2 0.4.27 (registry+https://github.com/rust-lang/crates.io-index)",
 "syn 0.15.29 (registry+https://github.com/rust-lang/crates.io-index)",
 "syn 0.15.28 (registry+https://github.com/rust-lang/crates.io-index)",
 "syn 0.15.26 (registry+https://github.com/rust-lang/crates.io-index)",
 "syn 0.15.26 (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"
 "syn 0.15.26 (registry+https://github.com/rust-lang/crates.io-index)",
 "syn 0.15.27 (registry+https://github.com/rust-lang/crates.io-index)",
 "syn 0.15.27 (registry+https://github.com/rust-lang/crates.io-index)",
 "quote 0.6.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "quote 0.6.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "syn 0.15.30 (registry+https://github.com/rust-lang/crates.io-index)",
 "proc-macro2 0.4.27 (registry+https://github.com/rust-lang/crates.io-index)",
 "quote 0.6.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "syn 0.15.30 (registry+https://github.com/rust-lang/crates.io-index)",
 "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)",
 "proc-macro2 0.4.24 (registry+https://github.com/rust-lang/crates.io-index)",
 "quote 0.6.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "syn 0.15.22 (registry+https://github.com/rust-lang/crates.io-index)",
 "proc-macro2 0.4.26 (registry+https://github.com/rust-lang/crates.io-index)",
 "quote 0.6.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "syn 0.15.26 (registry+https://github.com/rust-lang/crates.io-index)",
 "proc-macro2 0.4.24 (registry+https://github.com/rust-lang/crates.io-index)",
 "quote 0.6.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "syn 0.15.22 (registry+https://github.com/rust-lang/crates.io-index)",
 "proc-macro2 0.4.24 (registry+https://github.com/rust-lang/crates.io-index)",
 "quote 0.6.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "syn 0.15.23 (registry+https://github.com/rust-lang/crates.io-index)",
 "syn 0.15.22 (registry+https://github.com/rust-lang/crates.io-index)",
 "syn 0.15.23 (registry+https://github.com/rust-lang/crates.io-index)",
 "syn 0.15.23 (registry+https://github.com/rust-lang/crates.io-index)",
 "syn 0.15.23 (registry+https://github.com/rust-lang/crates.io-index)",
 "syn 0.15.22 (registry+https://github.com/rust-lang/crates.io-index)",
 "syn 0.15.22 (registry+https://github.com/rust-lang/crates.io-index)",
 "syn 0.15.22 (registry+https://github.com/rust-lang/crates.io-index)",
 "syn 0.15.22 (registry+https://github.com/rust-lang/crates.io-index)",
 "proc-macro2 0.4.24 (registry+https://github.com/rust-lang/crates.io-index)",
 "quote 0.6.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "syn 0.15.22 (registry+https://github.com/rust-lang/crates.io-index)",
 "proc-macro2 0.4.24 (registry+https://github.com/rust-lang/crates.io-index)",
 "quote 0.6.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "syn 0.15.22 (registry+https://github.com/rust-lang/crates.io-index)",
 "proc-macro2 0.4.26 (registry+https://github.com/rust-lang/crates.io-index)",
 "quote 0.6.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "syn 0.15.26 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.10.1"
version = "0.10.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "proc-macro2 0.4.26 (registry+https://github.com/rust-lang/crates.io-index)",
 "quote 0.6.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "proc-macro2 0.4.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 = "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"
 "quote 0.6.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "quote 0.6.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "proc-macro2 0.4.27 (registry+https://github.com/rust-lang/crates.io-index)",
 "quote 0.6.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "quote 0.6.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "proc-macro2 0.4.24 (registry+https://github.com/rust-lang/crates.io-index)",
 "quote 0.6.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "proc-macro2 0.4.26 (registry+https://github.com/rust-lang/crates.io-index)",
 "quote 0.6.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "proc-macro2 0.4.24 (registry+https://github.com/rust-lang/crates.io-index)",
 "quote 0.6.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "proc-macro2 0.4.24 (registry+https://github.com/rust-lang/crates.io-index)",
 "quote 0.6.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "proc-macro2 0.4.24 (registry+https://github.com/rust-lang/crates.io-index)",
 "quote 0.6.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "proc-macro2 0.4.24 (registry+https://github.com/rust-lang/crates.io-index)",
 "quote 0.6.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "proc-macro2 0.4.26 (registry+https://github.com/rust-lang/crates.io-index)",
 "quote 0.6.11 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.15.23"
version = "0.15.22"
version = "0.15.29"
version = "0.15.28"
version = "0.15.23"
version = "0.15.26"
version = "0.15.26"
version = "0.15.30"
version = "0.15.23"
version = "0.15.27"
version = "0.15.26"
version = "0.15.22"
version = "0.15.23"
version = "0.15.26"
version = "0.15.30"
version = "0.15.22"
version = "0.15.22"
version = "0.15.22"
version = "0.15.22"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
version = "0.15.26"
version = "0.15.27"
version = "0.15.22"
version = "0.15.22"
version = "0.15.26"
version = "0.15.22"
version = "0.15.27"
name = "subtle"
version = "1.0.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
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"
name = "subtle"
version = "1.0.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
name = "subtle"
version = "1.0.0"
version = "0.7.0"
version = "0.8.0"
version = "0.7.0"
version = "0.7.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
name = "subtle"
version = "1.0.0"
 "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"
 "proc-macro2 0.4.20 (registry+https://github.com/rust-lang/crates.io-index)",
 "quote 0.6.8 (registry+https://github.com/rust-lang/crates.io-index)",
 "proc-macro2 0.4.24 (registry+https://github.com/rust-lang/crates.io-index)",
 "quote 0.6.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "phf_generator 0.7.24 (registry+https://github.com/rust-lang/crates.io-index)",
 "phf_shared 0.7.24 (registry+https://github.com/rust-lang/crates.io-index)",
 "proc-macro2 0.4.26 (registry+https://github.com/rust-lang/crates.io-index)",
 "quote 0.6.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "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)",
 "quote 0.6.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "phf_generator 0.7.24 (registry+https://github.com/rust-lang/crates.io-index)",
 "phf_shared 0.7.24 (registry+https://github.com/rust-lang/crates.io-index)",
 "proc-macro2 0.4.27 (registry+https://github.com/rust-lang/crates.io-index)",
 "quote 0.6.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "quote 0.6.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "phf_generator 0.7.24 (registry+https://github.com/rust-lang/crates.io-index)",
 "phf_shared 0.7.24 (registry+https://github.com/rust-lang/crates.io-index)",
 "proc-macro2 0.4.26 (registry+https://github.com/rust-lang/crates.io-index)",
 "quote 0.6.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "phf_generator 0.7.23 (registry+https://github.com/rust-lang/crates.io-index)",
 "phf_shared 0.7.23 (registry+https://github.com/rust-lang/crates.io-index)",
 "proc-macro2 0.4.24 (registry+https://github.com/rust-lang/crates.io-index)",
 "quote 0.6.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "phf_generator 0.7.23 (registry+https://github.com/rust-lang/crates.io-index)",
 "phf_shared 0.7.23 (registry+https://github.com/rust-lang/crates.io-index)",
 "proc-macro2 0.4.24 (registry+https://github.com/rust-lang/crates.io-index)",
 "quote 0.6.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "phf_generator 0.7.23 (registry+https://github.com/rust-lang/crates.io-index)",
 "phf_shared 0.7.23 (registry+https://github.com/rust-lang/crates.io-index)",
 "proc-macro2 0.4.24 (registry+https://github.com/rust-lang/crates.io-index)",
 "quote 0.6.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "phf_generator 0.7.23 (registry+https://github.com/rust-lang/crates.io-index)",
 "phf_shared 0.7.23 (registry+https://github.com/rust-lang/crates.io-index)",
 "proc-macro2 0.4.24 (registry+https://github.com/rust-lang/crates.io-index)",
 "quote 0.6.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "phf_generator 0.7.24 (registry+https://github.com/rust-lang/crates.io-index)",
 "phf_shared 0.7.24 (registry+https://github.com/rust-lang/crates.io-index)",
 "proc-macro2 0.4.26 (registry+https://github.com/rust-lang/crates.io-index)",
 "quote 0.6.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "phf_shared 0.7.23 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde 1.0.83 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde 1.0.80 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde 1.0.88 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde 1.0.89 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde 1.0.82 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde 1.0.85 (registry+https://github.com/rust-lang/crates.io-index)",
 "phf_shared 0.7.24 (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 = [
 "serde 1.0.87 (registry+https://github.com/rust-lang/crates.io-index)",
 "phf_shared 0.7.24 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde 1.0.90 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde 1.0.83 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde 1.0.89 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde 1.0.87 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde 1.0.83 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde 1.0.85 (registry+https://github.com/rust-lang/crates.io-index)",
 "phf_shared 0.7.24 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde 1.0.90 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde 1.0.80 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde 1.0.80 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde 1.0.80 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde 1.0.80 (registry+https://github.com/rust-lang/crates.io-index)",
 "precomputed-hash 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "phf_shared 0.7.23 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde 1.0.87 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde 1.0.89 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde 1.0.80 (registry+https://github.com/rust-lang/crates.io-index)",
 "phf_shared 0.7.23 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde 1.0.80 (registry+https://github.com/rust-lang/crates.io-index)",
 "phf_shared 0.7.23 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde 1.0.85 (registry+https://github.com/rust-lang/crates.io-index)",
 "phf_shared 0.7.24 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde 1.0.80 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde 1.0.87 (registry+https://github.com/rust-lang/crates.io-index)",
 "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)",
 "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)",
 "lazy_static 1.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "new_debug_unreachable 1.0.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "lazy_static 1.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "new_debug_unreachable 1.0.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "new_debug_unreachable 1.0.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "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)",
 "lazy_static 1.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "new_debug_unreachable 1.0.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "phf_shared 0.7.23 (registry+https://github.com/rust-lang/crates.io-index)",
 "lazy_static 1.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "new_debug_unreachable 1.0.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "lazy_static 1.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "new_debug_unreachable 1.0.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "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)",
version = "0.1.3"
version = "0.1.3"
version = "0.1.3"
version = "0.1.2"
version = "0.1.3"
version = "0.1.2"
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 = [
version = "0.1.2"
version = "0.1.2"
version = "0.1.2"
version = "0.1.3"
]
[[package]]
name = "stable_deref_trait"
version = "1.1.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
name = "string"
 "cfg-if 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.50 (registry+https://github.com/rust-lang/crates.io-index)",
 "cfg-if 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
 "redox_syscall 0.1.54 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "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)",
 "cfg-if 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.48 (registry+https://github.com/rust-lang/crates.io-index)",
 "cfg-if 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
 "redox_syscall 0.1.54 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "cfg-if 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "redox_syscall 0.1.43 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "cfg-if 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "redox_syscall 0.1.51 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.43 (registry+https://github.com/rust-lang/crates.io-index)",
 "redox_syscall 0.1.40 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.45 (registry+https://github.com/rust-lang/crates.io-index)",
 "redox_syscall 0.1.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "redox_syscall 0.1.43 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.45 (registry+https://github.com/rust-lang/crates.io-index)",
 "redox_syscall 0.1.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.47 (registry+https://github.com/rust-lang/crates.io-index)",
 "redox_syscall 0.1.51 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.48 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.45 (registry+https://github.com/rust-lang/crates.io-index)",
 "redox_syscall 0.1.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "redox_syscall 0.1.43 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.45 (registry+https://github.com/rust-lang/crates.io-index)",
 "redox_syscall 0.1.49 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.47 (registry+https://github.com/rust-lang/crates.io-index)",
 "redox_syscall 0.1.51 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "redox_syscall 0.1.43 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "redox_syscall 0.1.43 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "redox_syscall 0.1.43 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "redox_syscall 0.1.43 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "redox_syscall 0.1.43 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.47 (registry+https://github.com/rust-lang/crates.io-index)",
 "redox_syscall 0.1.51 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "redox_syscall 0.1.43 (registry+https://github.com/rust-lang/crates.io-index)",
 "cfg-if 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.48 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.49 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.49 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.6.8"
version = "0.1.7"
 "block-buffer 0.7.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "block-buffer 0.7.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "block-buffer 0.7.2 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.6.6"
 "arc-swap 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.1.6"
version = "0.6.7"
 "arc-swap 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.45 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.1.7"
version = "0.6.8"
version = "0.4.2"
 "arc-swap 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.47 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.1.7"
 "opaque-debug 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "block-buffer 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "byte-tools 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "digest 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.8.1"
 "opaque-debug 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "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)",
version = "0.8.0"
 "opaque-debug 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "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)",
version = "0.8.1"
version = "0.6.9"
 "arc-swap 0.3.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.1.8"
 "block-buffer 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "block-buffer 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "block-buffer 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)",
dependencies = [
 "unreachable 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)",
]
version = "0.6.6"
version = "0.4.1"
 "arc-swap 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.1.6"
 "block-buffer 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "byte-tools 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "digest 0.7.6 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.7.3"
 "block-buffer 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "byte-tools 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "digest 0.7.6 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.7.1"
 "block-buffer 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "byte-tools 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "digest 0.7.6 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.7.0"
version = "0.6.6"
version = "0.6.6"
 "arc-swap 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.1.6"
dependencies = [
 "unreachable 1.0.0 (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 = [
source = "registry+https://github.com/rust-lang/crates.io-index"
version = "0.6.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
name = "smallvec"
version = "0.4.1"
]
[[package]]
name = "siphasher"
version = "0.2.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
name = "slab"
 "arc-swap 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.45 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
version = "0.1.6"
]
[[package]]
name = "signal-hook"
 "keccak 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "block-buffer 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "byte-tools 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "digest 0.7.6 (registry+https://github.com/rust-lang/crates.io-index)",
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
version = "0.7.3"
]
[[package]]
name = "sha3"
 "fake-simd 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "block-buffer 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "byte-tools 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "digest 0.7.6 (registry+https://github.com/rust-lang/crates.io-index)",
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
version = "0.7.1"
]
[[package]]
name = "sha2"
 "fake-simd 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "block-buffer 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "byte-tools 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "digest 0.7.6 (registry+https://github.com/rust-lang/crates.io-index)",
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
version = "0.7.0"
dependencies = [
 "unreachable 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)",
]
version = "0.6.8"
version = "0.1.7"
 "block-buffer 0.7.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "block-buffer 0.7.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "block-buffer 0.7.2 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.6.9"
version = "0.1.8"
 "block-buffer 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "block-buffer 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "block-buffer 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.6.6"
version = "0.4.1"
 "arc-swap 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.1.6"
 "block-buffer 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "byte-tools 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "digest 0.7.6 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.7.3"
 "block-buffer 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "byte-tools 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "digest 0.7.6 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.7.1"
 "block-buffer 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "byte-tools 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "digest 0.7.6 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.7.0"
version = "0.6.6"
version = "0.4.1"
 "arc-swap 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.1.6"
 "block-buffer 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "byte-tools 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "digest 0.7.6 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.7.3"
 "block-buffer 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "byte-tools 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "digest 0.7.6 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.7.1"
 "block-buffer 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "byte-tools 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "digest 0.7.6 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.7.0"
version = "0.6.8"
version = "0.4.2"
 "arc-swap 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.47 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.1.7"
 "opaque-debug 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "block-buffer 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "byte-tools 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "digest 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.8.1"
 "opaque-debug 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "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)",
version = "0.8.0"
 "opaque-debug 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "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)",
version = "0.8.1"
version = "0.6.6"
 "arc-swap 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.1.6"
dependencies = [
 "unreachable 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)",
]
version = "0.6.8"
 "block-buffer 0.7.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "block-buffer 0.7.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "block-buffer 0.7.2 (registry+https://github.com/rust-lang/crates.io-index)",
[[package]]
name = "sha-1"
[[package]]
 "winapi 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi-util 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "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)",
 "winapi 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)",
name = "winreg"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "b2986deb581c4fe11b621998a5e53361efe6b48a151178d0cd9eeffa4dc6acc9"
dependencies = [
]
[[package]]
 "winapi 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)",
name = "ws2_32-sys"
version = "0.2.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d59cefebd0c892fa2dd6de581e937301d8552cb44489cdff035c6187cb63fa5e"
dependencies = [
]
[[package]]
name = "xml5ever"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "0b1b52e6e8614d4a58b8e70cf51ec0cc21b256ad8206708bcff8139b5bbd6a59"
dependencies = [
 "mac 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "xmpp-parsers"
dependencies = [
 "sha3 0.8.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "sha3 0.8.2 (registry+https://github.com/rust-lang/crates.io-index)",
]
"checksum xml5ever 0.12.0 (registry+https://github.com/rust-lang/crates.io-index)" = "ead952cf8bab253fb5cb56e1fff780747bbf7a7258fb0451afe645a166050b1f"
"checksum xmpp-parsers 0.11.1 (registry+https://github.com/rust-lang/crates.io-index)" = "2e1e0a279d5af83a1dff442249f8a43214ac120267acfaac494b9d28c0027fea"
"checksum winapi-util 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "afc5508759c5bf4285e61feb862b6083c8480aec864fa17a81fdec6f69b461ab"
"checksum winapi 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)" = "92c1eb33641e276cfa214a0522acad57be5c56b10cb348b3c5117db75f3ac4b0"
"checksum unicode-normalization 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)" = "6a0180bc61fc5a987082bfa111f4cc95c4caff7f9799f3e46df09163a937aa25"
"checksum unreachable 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)" = "382810877fe448991dfc7f0dd6e3ae5d58088fd0ea5e35189655f84e6814fa56"
"checksum url 1.7.1 (registry+https://github.com/rust-lang/crates.io-index)" = "2a321979c09843d272956e73700d12c4e7d3d92b2ee112b31548aef0d4efc5a6"
"checksum utf-8 0.7.4 (registry+https://github.com/rust-lang/crates.io-index)" = "bab35f71693630bb1953dce0f2bcd780e7cde025027124a202ac08a45ba25141"
"checksum utf8-ranges 1.0.1 (registry+https://github.com/rust-lang/crates.io-index)" = "fd70f467df6810094968e2fce0ee1bd0e87157aceb026a8c083bcf5e25b9efe4"
"checksum version_check 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)" = "914b1a6776c4c929a602fafd8bc742e06365d4bcbe48c30f9cca5824f70dc9dd"
"checksum void 1.0.2 (registry+https://github.com/rust-lang/crates.io-index)" = "6a02e4885ed3bc0f2de90ea6dd45ebcbb66dacffe03547fadbb0eeae2770887d"
"checksum void 1.0.2 (registry+https://github.com/rust-lang/crates.io-index)" = "6a02e4885ed3bc0f2de90ea6dd45ebcbb66dacffe03547fadbb0eeae2770887d"
"checksum unreachable 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)" = "382810877fe448991dfc7f0dd6e3ae5d58088fd0ea5e35189655f84e6814fa56"
"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 time 0.1.40 (registry+https://github.com/rust-lang/crates.io-index)" = "d825be0eb33fda1a7e68012d51e9c7f451dc1a69391e7fdc197060bb8c56667b"
"checksum tokio 0.1.11 (registry+https://github.com/rust-lang/crates.io-index)" = "6e93c78d23cc61aa245a8acd2c4a79c4d7fa7fb5c3ca90d5737029f043a84895"
"checksum tokio-current-thread 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)" = "f90fcd90952f0a496d438a976afba8e5c205fb12123f813d8ab3aa1c8436638c"
"checksum tokio-executor 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)" = "c117b6cf86bb730aab4834f10df96e4dd586eff2c3c27d3781348da49e255bde"
"checksum tokio-fs 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)" = "60ae25f6b17d25116d2cba342083abe5255d3c2c79cb21ea11aa049c53bf7c75"
"checksum tokio-io 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)" = "7392fe0a70d5ce0c882c4778116c519bd5dbaa8a7c3ae3d04578b3afafdcda21"
"checksum tokio-reactor 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)" = "4b26fd37f1125738b2170c80b551f69ff6fecb277e6e5ca885e53eec2b005018"
"checksum tokio-signal 0.2.6 (registry+https://github.com/rust-lang/crates.io-index)" = "40da88e6445ed335e14746b60986a6c8b3632b09bc9097df76b4a6ddd16f1f92"
"checksum tokio-tcp 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)" = "7ad235e9dadd126b2d47f6736f65aa1fdcd6420e66ca63f44177bc78df89f912"
"checksum tokio-threadpool 0.1.8 (registry+https://github.com/rust-lang/crates.io-index)" = "3929aee321c9220ed838ed6c3928be7f9b69986b0e3c22c972a66dbf8a298c68"
"checksum tokio-timer 0.2.7 (registry+https://github.com/rust-lang/crates.io-index)" = "3a52f00c97fedb6d535d27f65cccb7181c8dd4c6edc3eda9ea93f6d45d05168e"
"checksum tokio-tls 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)" = "e53fdbf3156f588be1676022fe794232b24922d426e8c14f4e46891c1e31c440"
"checksum tokio-udp 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)" = "da941144b816d0dcda4db3a1ba87596e4df5e860a72b70783fe435891f80601c"
"checksum tokio-uds 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)" = "df195376b43508f01570bacc73e13a1de0854dc59e79d1ec09913e8db6dd2a70"
"checksum tokio-xmpp 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)" = "c27385c4781afc851c61ac66d79463c511bf073d3a5d71b8bfd13a816e475989"
"checksum toml 0.4.8 (registry+https://github.com/rust-lang/crates.io-index)" = "4a2ecc31b0351ea18b3fe11274b8db6e4d82bce861bbb22e6dbed40417902c65"
"checksum trust-dns-proto 0.4.3 (registry+https://github.com/rust-lang/crates.io-index)" = "f1525ca4e26f5a09d81b79584f19225e7dba5606ae3a416311c2751c5cea60bb"
"checksum trust-dns-resolver 0.9.1 (registry+https://github.com/rust-lang/crates.io-index)" = "4a821ad51a29816420b8cac4b026756b81c023630b97eaa4c8090637ee3508bd"
"checksum try_from 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)" = "923a7ee3e97dbfe8685261beb4511cc9620a1252405d02693d43169729570111"
"checksum ucd-util 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "fd2be2d6639d0f8fe6cdda291ad456e23629558d466e2789d2c3e9892bda285d"
"checksum ucd-util 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)" = "535c204ee4d8434478593480b8f86ab45ec9aae0e83c568ca81abf0fd0e88f86"
"checksum ucd-util 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)" = "535c204ee4d8434478593480b8f86ab45ec9aae0e83c568ca81abf0fd0e88f86"
"checksum try_from 0.3.2 (registry+https://github.com/rust-lang/crates.io-index)" = "283d3b89e1368717881a9d51dad843cc435380d8109c9e47d38780a324698d8b"
"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 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-sync 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)" = "5b2f843ffdf8d6e1f90bddd48da43f99ab071660cd92b7ec560ef3cdfd7a409a"
"checksum tokio-threadpool 0.1.14 (registry+https://github.com/rust-lang/crates.io-index)" = "72558af20be886ea124595ea0f806dd5703b8958e4705429dd58b3d8231f72f2"
"checksum tokio-trace-core 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)" = "350c9edade9830dc185ae48ba45667a445ab59f6167ef6d0254ec9d2430d9dd3"
"checksum toml 0.4.10 (registry+https://github.com/rust-lang/crates.io-index)" = "758664fc71a3a69038656bee8b6be6477d2a6c315a6b81f7081f591bffa4111f"
"checksum try-lock 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)" = "e604eb7b43c06650e854be16a2a03155743d3752dd1c943f6829e26b7a36e382"
"checksum toml 0.5.0 (registry+https://github.com/rust-lang/crates.io-index)" = "87c5890a989fa47ecdc7bcb4c63a77a82c18f306714104b1decfd722db17b39e"
"checksum toml 0.5.0 (registry+https://github.com/rust-lang/crates.io-index)" = "87c5890a989fa47ecdc7bcb4c63a77a82c18f306714104b1decfd722db17b39e"
"checksum trust-dns-proto 0.6.3 (registry+https://github.com/rust-lang/crates.io-index)" = "09144f0992b0870fa8d2972cc069cbf1e3c0fda64d1f3d45c4d68d0e0b52ad4e"
"checksum trust-dns-resolver 0.10.3 (registry+https://github.com/rust-lang/crates.io-index)" = "8a9f877f7a1ad821ab350505e1f1b146a4960402991787191d6d8cab2ce2de2c"
"checksum toml 0.4.10 (registry+https://github.com/rust-lang/crates.io-index)" = "758664fc71a3a69038656bee8b6be6477d2a6c315a6b81f7081f591bffa4111f"
"checksum toml 0.5.1 (registry+https://github.com/rust-lang/crates.io-index)" = "b8c96d7873fa7ef8bdeb3a9cda3ac48389b4154f32b9803b4bc26220b677b039"
"checksum toml 0.5.0 (registry+https://github.com/rust-lang/crates.io-index)" = "87c5890a989fa47ecdc7bcb4c63a77a82c18f306714104b1decfd722db17b39e"
"checksum tokio-trace-core 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)" = "350c9edade9830dc185ae48ba45667a445ab59f6167ef6d0254ec9d2430d9dd3"
"checksum tokio-udp 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)" = "66268575b80f4a4a710ef83d087fdfeeabdce9b74c797535fbac18a2cb906e92"
"checksum tokio-uds 0.2.5 (registry+https://github.com/rust-lang/crates.io-index)" = "037ffc3ba0e12a0ab4aca92e5234e0dedeb48fddf6ccd260f1f150a36a9f2445"
"checksum tokio-xmpp 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)" = "952074d50e2a9907e714d28bb988232cc2f8c64542d3a97822e6d6afdd7a105f"
"checksum tokio-tls 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)" = "354b8cd83825b3c20217a9dc174d6a0c67441a2fae5c41bcb1ea6679f6ae0f7c"
"checksum tokio-trace-core 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)" = "a9c8a256d6956f7cb5e2bdfe8b1e8022f1a09206c6c2b1ba00f3b746b260c613"
"checksum tokio-trace-core 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)" = "350c9edade9830dc185ae48ba45667a445ab59f6167ef6d0254ec9d2430d9dd3"
"checksum tokio-threadpool 0.1.12 (registry+https://github.com/rust-lang/crates.io-index)" = "742e511f6ce2298aeb86fc9ea0d8df81c2388c6ebae3dc8a7316e8c9df0df801"
"checksum tokio-threadpool 0.1.13 (registry+https://github.com/rust-lang/crates.io-index)" = "ec5759cf26cf9659555f36c431b515e3d05f66831741c85b4b5d5dfb9cf1323c"
"checksum tokio-timer 0.2.10 (registry+https://github.com/rust-lang/crates.io-index)" = "2910970404ba6fa78c5539126a9ae2045d62e3713041e447f695f41405a120c6"
"checksum tokio-threadpool 0.1.13 (registry+https://github.com/rust-lang/crates.io-index)" = "ec5759cf26cf9659555f36c431b515e3d05f66831741c85b4b5d5dfb9cf1323c"
"checksum tokio-timer 0.2.10 (registry+https://github.com/rust-lang/crates.io-index)" = "2910970404ba6fa78c5539126a9ae2045d62e3713041e447f695f41405a120c6"
"checksum tokio-threadpool 0.1.11 (registry+https://github.com/rust-lang/crates.io-index)" = "c3fd86cb15547d02daa2b21aadaf4e37dee3368df38a526178a5afa3c034d2fb"
"checksum tokio-threadpool 0.1.14 (registry+https://github.com/rust-lang/crates.io-index)" = "72558af20be886ea124595ea0f806dd5703b8958e4705429dd58b3d8231f72f2"
"checksum tokio-timer 0.2.11 (registry+https://github.com/rust-lang/crates.io-index)" = "f2106812d500ed25a4f38235b9cae8f78a09edf43203e16e59c3b769a342a60e"
"checksum tokio-threadpool 0.1.13 (registry+https://github.com/rust-lang/crates.io-index)" = "ec5759cf26cf9659555f36c431b515e3d05f66831741c85b4b5d5dfb9cf1323c"
"checksum tokio-sync 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)" = "1bf2b9dac2a0509b5cfd1df5aa25eafacb616a42a491a13604d6bbeab4486363"
"checksum tokio-sync 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)" = "fda385df506bf7546e70872767f71e81640f1f251bdf2fd8eb81a0eaec5fe022"
"checksum tokio-sync 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)" = "fda385df506bf7546e70872767f71e81640f1f251bdf2fd8eb81a0eaec5fe022"
"checksum tokio-tcp 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)" = "1d14b10654be682ac43efee27401d792507e30fd8d26389e1da3b185de2e4119"
"checksum tokio-signal 0.2.7 (registry+https://github.com/rust-lang/crates.io-index)" = "dd6dc5276ea05ce379a16de90083ec80836440d5ef8a6a39545a3207373b8296"
"checksum tokio-sync 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "3742b64166c1ee9121f1921aea5a726098458926a6b732d906ef23b1f3ef6f4f"
"checksum tokio-sync 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)" = "2162248ff317e2bc713b261f242b69dbb838b85248ed20bb21df56d60ea4cae7"
"checksum tokio-sync 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)" = "fda385df506bf7546e70872767f71e81640f1f251bdf2fd8eb81a0eaec5fe022"
"checksum tokio-current-thread 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)" = "d16217cad7f1b840c5a97dfb3c43b0c871fef423a6e8d2118c604e843662a443"
"checksum tokio-executor 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)" = "83ea44c6c0773cc034771693711c35c677b4b5a4b21b9e7071704c54de7d555e"
"checksum tokio-fs 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)" = "3fe6dc22b08d6993916647d108a1a7d15b9cd29c4f4496c62b92c45b5041b7af"
"checksum tokio-io 0.1.12 (registry+https://github.com/rust-lang/crates.io-index)" = "5090db468dad16e1a7a54c8c67280c5e4b544f3d3e018f0b913b400261f85926"
"checksum tokio-reactor 0.1.9 (registry+https://github.com/rust-lang/crates.io-index)" = "6af16bfac7e112bea8b0442542161bfc41cbfa4466b580bdda7d18cb88b911ce"
"checksum tokio-current-thread 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)" = "331c8acc267855ec06eb0c94618dcbbfea45bed2d20b77252940095273fb58f6"
"checksum tokio-executor 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)" = "30c6dbf2d1ad1de300b393910e8a3aa272b724a400b6531da03eed99e329fbf0"
"checksum tokio-fs 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)" = "0e9cbbc8a3698b7ab652340f46633364f9eaa928ddaaee79d8b8f356dd79a09d"
"checksum tokio-io 0.1.11 (registry+https://github.com/rust-lang/crates.io-index)" = "b53aeb9d3f5ccf2ebb29e19788f96987fa1355f8fe45ea193928eaaaf3ae820f"
"checksum tokio-reactor 0.1.8 (registry+https://github.com/rust-lang/crates.io-index)" = "afbcdb0f0d2a1e4c440af82d7bbf0bf91a8a8c0575bcd20c05d15be7e9d3a02f"
"checksum tokio-current-thread 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)" = "d16217cad7f1b840c5a97dfb3c43b0c871fef423a6e8d2118c604e843662a443"
"checksum tokio-executor 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)" = "83ea44c6c0773cc034771693711c35c677b4b5a4b21b9e7071704c54de7d555e"
"checksum tokio-current-thread 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)" = "d16217cad7f1b840c5a97dfb3c43b0c871fef423a6e8d2118c604e843662a443"
"checksum tokio-executor 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)" = "83ea44c6c0773cc034771693711c35c677b4b5a4b21b9e7071704c54de7d555e"
"checksum tokio-fs 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)" = "3fe6dc22b08d6993916647d108a1a7d15b9cd29c4f4496c62b92c45b5041b7af"
"checksum tokio-io 0.1.12 (registry+https://github.com/rust-lang/crates.io-index)" = "5090db468dad16e1a7a54c8c67280c5e4b544f3d3e018f0b913b400261f85926"
"checksum tokio-reactor 0.1.9 (registry+https://github.com/rust-lang/crates.io-index)" = "6af16bfac7e112bea8b0442542161bfc41cbfa4466b580bdda7d18cb88b911ce"
"checksum tokio-current-thread 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)" = "d16217cad7f1b840c5a97dfb3c43b0c871fef423a6e8d2118c604e843662a443"
"checksum tokio-executor 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)" = "83ea44c6c0773cc034771693711c35c677b4b5a4b21b9e7071704c54de7d555e"
"checksum tokio-fs 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)" = "3fe6dc22b08d6993916647d108a1a7d15b9cd29c4f4496c62b92c45b5041b7af"
"checksum tokio-io 0.1.12 (registry+https://github.com/rust-lang/crates.io-index)" = "5090db468dad16e1a7a54c8c67280c5e4b544f3d3e018f0b913b400261f85926"
"checksum tokio-reactor 0.1.9 (registry+https://github.com/rust-lang/crates.io-index)" = "6af16bfac7e112bea8b0442542161bfc41cbfa4466b580bdda7d18cb88b911ce"
"checksum tokio-signal 0.2.7 (registry+https://github.com/rust-lang/crates.io-index)" = "dd6dc5276ea05ce379a16de90083ec80836440d5ef8a6a39545a3207373b8296"
"checksum tokio-sync 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)" = "fda385df506bf7546e70872767f71e81640f1f251bdf2fd8eb81a0eaec5fe022"
"checksum tokio-tcp 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)" = "1d14b10654be682ac43efee27401d792507e30fd8d26389e1da3b185de2e4119"
"checksum tokio-threadpool 0.1.13 (registry+https://github.com/rust-lang/crates.io-index)" = "ec5759cf26cf9659555f36c431b515e3d05f66831741c85b4b5d5dfb9cf1323c"
"checksum tokio-timer 0.2.10 (registry+https://github.com/rust-lang/crates.io-index)" = "2910970404ba6fa78c5539126a9ae2045d62e3713041e447f695f41405a120c6"
"checksum tokio-tls 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)" = "354b8cd83825b3c20217a9dc174d6a0c67441a2fae5c41bcb1ea6679f6ae0f7c"
"checksum tokio-trace-core 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)" = "350c9edade9830dc185ae48ba45667a445ab59f6167ef6d0254ec9d2430d9dd3"
"checksum tokio-udp 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)" = "66268575b80f4a4a710ef83d087fdfeeabdce9b74c797535fbac18a2cb906e92"
"checksum tokio-uds 0.2.5 (registry+https://github.com/rust-lang/crates.io-index)" = "037ffc3ba0e12a0ab4aca92e5234e0dedeb48fddf6ccd260f1f150a36a9f2445"
"checksum tokio-xmpp 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)" = "952074d50e2a9907e714d28bb988232cc2f8c64542d3a97822e6d6afdd7a105f"
"checksum toml 0.5.0 (registry+https://github.com/rust-lang/crates.io-index)" = "87c5890a989fa47ecdc7bcb4c63a77a82c18f306714104b1decfd722db17b39e"
"checksum trust-dns-proto 0.6.3 (registry+https://github.com/rust-lang/crates.io-index)" = "09144f0992b0870fa8d2972cc069cbf1e3c0fda64d1f3d45c4d68d0e0b52ad4e"
"checksum trust-dns-resolver 0.10.3 (registry+https://github.com/rust-lang/crates.io-index)" = "8a9f877f7a1ad821ab350505e1f1b146a4960402991787191d6d8cab2ce2de2c"
"checksum syn 0.15.14 (registry+https://github.com/rust-lang/crates.io-index)" = "baaba45c6bf60fe29aaf241fa33306c0b75c801edea8378263a8f043b09a5634"
"checksum synstructure 0.10.0 (registry+https://github.com/rust-lang/crates.io-index)" = "ec37f4fab4bafaf6b5621c1d54e6aa5d4d059a8f84929e87abfdd7f9f04c6db2"
"checksum tempfile 3.0.4 (registry+https://github.com/rust-lang/crates.io-index)" = "55c1195ef8513f3273d55ff59fe5da6940287a0d7a98331254397f464833675b"
"checksum tendril 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)" = "9de21546595a0873061940d994bbbc5c35f024ae4fd61ec5c5b159115684f508"
"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 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 tempfile 3.0.6 (registry+https://github.com/rust-lang/crates.io-index)" = "37daa55a7240c4931c84559f03b3cad7d19535840d1c4a0cc4e9b2fb0dcf70ff"
"checksum tempfile 3.0.7 (registry+https://github.com/rust-lang/crates.io-index)" = "b86c784c88d98c801132806dadd3819ed29d8600836c4088e855cdf3e178ed8a"
"checksum synstructure 0.10.2 (registry+https://github.com/rust-lang/crates.io-index)" = "02353edf96d6e4dc81aea2d8490a7e9db177bf8acb0e951c24940bf866cb313f"
"checksum tempfile 3.0.8 (registry+https://github.com/rust-lang/crates.io-index)" = "7dc4738f2e68ed2855de5ac9cdbe05c9216773ecde4739b2f095002ab03a13ef"
"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 thread_local 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)" = "c6b53e329000edc2b34dbe8545fd20e55a333362d0a321909685a19bd28c3f1b"
"checksum tokio 0.1.19 (registry+https://github.com/rust-lang/crates.io-index)" = "cec6c34409089be085de9403ba2010b80e36938c9ca992c4f67f407bb13db0b1"
"checksum tokio 0.1.16 (registry+https://github.com/rust-lang/crates.io-index)" = "fcaabb3cec70485d0df6e9454fe514393ad1c4070dee8915f11041e95630b230"
"checksum tokio 0.1.18 (registry+https://github.com/rust-lang/crates.io-index)" = "65641e515a437b308ab131a82ce3042ff9795bef5d6c5a9be4eb24195c417fd9"
"checksum tokio 0.1.18 (registry+https://github.com/rust-lang/crates.io-index)" = "65641e515a437b308ab131a82ce3042ff9795bef5d6c5a9be4eb24195c417fd9"
"checksum tokio 0.1.15 (registry+https://github.com/rust-lang/crates.io-index)" = "e0500b88064f08bebddd0c0bed39e19f5c567a5f30975bee52b0c0d3e2eeb38c"
"checksum tokio 0.1.21 (registry+https://github.com/rust-lang/crates.io-index)" = "ec2ffcf4bcfc641413fa0f1427bf8f91dfc78f56a6559cbf50e04837ae442a87"
"checksum tokio-buf 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "8fb220f46c53859a4b7ec083e41dec9778ff0b1851c0942b211edb89e0ccdc46"
"checksum tokio 0.1.18 (registry+https://github.com/rust-lang/crates.io-index)" = "65641e515a437b308ab131a82ce3042ff9795bef5d6c5a9be4eb24195c417fd9"
"checksum tokio-channel 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)" = "530d0fb87416dd531600f7cccc438bb35c5b91883065c9e6dca7cdecee991cfa"
"checksum tokio-codec 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "5c501eceaf96f0e1793cf26beb63da3d11c738c4a943fdf3746d81d64684c39f"
"checksum termcolor 1.0.4 (registry+https://github.com/rust-lang/crates.io-index)" = "4096add70612622289f2fdcdbd5086dc81c1e2675e6ae58d6c4f62a16c6d7f2f"
"checksum textwrap 0.10.0 (registry+https://github.com/rust-lang/crates.io-index)" = "307686869c93e71f94da64286f9a9524c0f308a9e1c87a583de8e9c9039ad3f6"
"checksum textwrap 0.11.0 (registry+https://github.com/rust-lang/crates.io-index)" = "d326610f408c7a4eb6f51c37c330e496b08506c9457c9d34287ecc38809fb060"
"checksum textwrap 0.10.0 (registry+https://github.com/rust-lang/crates.io-index)" = "307686869c93e71f94da64286f9a9524c0f308a9e1c87a583de8e9c9039ad3f6"
"checksum textwrap 0.11.0 (registry+https://github.com/rust-lang/crates.io-index)" = "d326610f408c7a4eb6f51c37c330e496b08506c9457c9d34287ecc38809fb060"
"checksum textwrap 0.11.0 (registry+https://github.com/rust-lang/crates.io-index)" = "d326610f408c7a4eb6f51c37c330e496b08506c9457c9d34287ecc38809fb060"
"checksum proc-macro2 0.4.20 (registry+https://github.com/rust-lang/crates.io-index)" = "3d7b7eaaa90b4a90a932a9ea6666c95a389e424eff347f0f793979289429feee"
"checksum quick-xml 0.12.4 (registry+https://github.com/rust-lang/crates.io-index)" = "1d8065cbb01701c11cc195cde85cbf39d1c6a80705b67a157ebb3042e0e5777f"
"checksum quote 0.6.8 (registry+https://github.com/rust-lang/crates.io-index)" = "dd636425967c33af890042c483632d33fa7a18f19ad1d7ea72e8998c6ef8dea5"
"checksum rand 0.4.3 (registry+https://github.com/rust-lang/crates.io-index)" = "8356f47b32624fef5b3301c1be97e5944ecdd595409cc5da11d05f211db6cfbd"
"checksum rand 0.5.5 (registry+https://github.com/rust-lang/crates.io-index)" = "e464cd887e869cddcae8792a4ee31d23c7edd516700695608f5b98c67ee0131c"
"checksum rand_core 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)" = "1961a422c4d189dfb50ffa9320bf1f2a9bd54ecb92792fb9477f99a1045f3372"
"checksum rand_core 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)" = "0905b6b7079ec73b314d4c748701f6931eb79fd97c668caa3f1899b22b32c6db"
"checksum redox_syscall 0.1.40 (registry+https://github.com/rust-lang/crates.io-index)" = "c214e91d3ecf43e9a4e41e578973adeb14b474f2bee858742d127af75a0112b1"
"checksum regex 1.0.5 (registry+https://github.com/rust-lang/crates.io-index)" = "2069749032ea3ec200ca51e4a31df41759190a88edca0d2d86ee8bedf7073341"
"checksum regex-syntax 0.6.2 (registry+https://github.com/rust-lang/crates.io-index)" = "747ba3b235651f6e2f67dfa8bcdcd073ddb7c243cb21c442fc12395dfcac212d"
"checksum resolv-conf 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)" = "c62bd95a41841efdf7fca2ae9951e64a8d8eae7e5da196d8ce489a2241491a92"
"checksum rustc-demangle 0.1.9 (registry+https://github.com/rust-lang/crates.io-index)" = "bcfe5b13211b4d78e5c2cadfebd7769197d95c639c35a50057eb4c05de811395"
"checksum ryu 0.2.6 (registry+https://github.com/rust-lang/crates.io-index)" = "7153dd96dade874ab973e098cb62fcdbb89a03682e46b144fd09550998d4a4a7"
"checksum safemem 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)" = "8dca453248a96cb0749e36ccdfe2b0b4e54a61bfef89fb97ec621eb8e0a93dd9"
"checksum sasl 0.4.2 (registry+https://github.com/rust-lang/crates.io-index)" = "4dbda5436dcd059da44fbf84b87a7164c5e3cad354efd0630c1f2be3c51c8859"
"checksum schannel 0.1.14 (registry+https://github.com/rust-lang/crates.io-index)" = "0e1a231dc10abf6749cfa5d7767f25888d484201accbd919b66ab5413c502d56"
"checksum security-framework 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)" = "697d3f3c23a618272ead9e1fb259c1411102b31c6af8b93f1d64cca9c3b0e8e0"
"checksum security-framework-sys 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)" = "ab01dfbe5756785b5b4d46e0289e5a18071dfa9a7c2b24213ea00b9ef9b665bf"
"checksum serde 1.0.80 (registry+https://github.com/rust-lang/crates.io-index)" = "15c141fc7027dd265a47c090bf864cf62b42c4d228bbcf4e51a0c9e2b0d3f7ef"
"checksum serde_derive 1.0.80 (registry+https://github.com/rust-lang/crates.io-index)" = "225de307c6302bec3898c51ca302fc94a7a1697ef0845fcee6448f33c032249c"
"checksum serde_json 1.0.32 (registry+https://github.com/rust-lang/crates.io-index)" = "43344e7ce05d0d8280c5940cabb4964bea626aa58b1ec0e8c73fa2a8512a38ce"
"checksum sha-1 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)" = "51b9d1f3b5de8a167ab06834a7c883bd197f2191e1dda1a22d9ccfeedbf9aded"
"checksum sha2 0.7.1 (registry+https://github.com/rust-lang/crates.io-index)" = "9eb6be24e4c23a84d7184280d2722f7f2731fcdd4a9d886efbfe4413e4847ea0"
"checksum sha3 0.7.3 (registry+https://github.com/rust-lang/crates.io-index)" = "b64dcef59ed4290b9fb562b53df07f564690d6539e8ecdd4728cf392477530bc"
"checksum signal-hook 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)" = "f7ca1f1c0ed6c8beaab713ad902c041e4f09d06e1b4bb74c5fc553c078ed0110"
"checksum slab 0.4.1 (registry+https://github.com/rust-lang/crates.io-index)" = "5f9776d6b986f77b35c6cf846c11ad986ff128fe0b2b63a3628e3755e8d3102d"
"checksum smallvec 0.6.5 (registry+https://github.com/rust-lang/crates.io-index)" = "153ffa32fd170e9944f7e0838edf824a754ec4c1fc64746fcc9fe1f8fa602e5d"
"checksum string 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "00caf261d6f90f588f8450b8e1230fa0d5be49ee6140fdfbcb55335aff350970"
"checksum strsim 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)" = "bb4f380125926a99e52bc279241539c018323fab05ad6368b56f93d9369ff550"
"checksum strsim 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)" = "bb4f380125926a99e52bc279241539c018323fab05ad6368b56f93d9369ff550"
"checksum strsim 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)" = "8ea5119cdb4c55b55d432abb513a0429384878c15dde60cc77b1c99de1a95a6a"
"checksum strsim 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)" = "bb4f380125926a99e52bc279241539c018323fab05ad6368b56f93d9369ff550"
"checksum strsim 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)" = "8ea5119cdb4c55b55d432abb513a0429384878c15dde60cc77b1c99de1a95a6a"
"checksum strsim 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)" = "8ea5119cdb4c55b55d432abb513a0429384878c15dde60cc77b1c99de1a95a6a"
"checksum subtle 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)" = "2d67a5a62ba6e01cb2192ff309324cb4875d0c451d55fe2319433abe7a05a8ee"
"checksum synom 0.11.3 (registry+https://github.com/rust-lang/crates.io-index)" = "a393066ed9010ebaed60b9eafa373d4b1baac186dd7e008555b0f702b51945b6"
"checksum syn 0.11.11 (registry+https://github.com/rust-lang/crates.io-index)" = "d3b891b9015c88c576343b9b3e41c2c11a51c219ef067b264bd9c8aa9b441dad"
"checksum string 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)" = "b639411d0b9c738748b5397d5ceba08e648f4f1992231aa859af1a017f31f60b"
"checksum string 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)" = "b639411d0b9c738748b5397d5ceba08e648f4f1992231aa859af1a017f31f60b"
"checksum string 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)" = "d0bbfb8937e38e34c3444ff00afb28b0811d9554f15c5ad64d12b0308d1d1995"
"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 stable_deref_trait 1.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "dba1a27d3efae4351c8051072d619e3ade2820635c3958d826bfea39d59b54c8"
"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 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 sha3 0.8.2 (registry+https://github.com/rust-lang/crates.io-index)" = "dd26bc0e7a2e3a7c959bc494caf58b72ee0c71d67704e9520f736ca7e4853ecf"
"checksum signal-hook 0.1.9 (registry+https://github.com/rust-lang/crates.io-index)" = "72ab58f1fda436857e6337dcb6a5aaa34f16c5ddc87b3a8b6ef7a212f90b9c5a"
"checksum signal-hook-registry 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)" = "591fe2ee5a2412968f63a008a190d99918c2cda3f616411026f0975715e1cf62"
"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 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 sha3 0.8.1 (registry+https://github.com/rust-lang/crates.io-index)" = "34a5e54083ce2b934bf059fdf38e7330a154177e029ab6c4e18638f2f624053a"
"checksum siphasher 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)" = "0b8de496cf83d4ed58b6be86c3a275b8602f6ffe98d3024a869e124147a9a3ac"
"checksum signal-hook 0.1.8 (registry+https://github.com/rust-lang/crates.io-index)" = "97a47ae722318beceb0294e6f3d601205a1e6abaa4437d9d33e3a212233e3021"
"checksum signal-hook 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)" = "1f272d1b7586bec132ed427f532dd418d8beca1ca7f2caf7df35569b1415a4b4"
"checksum signal-hook 0.1.8 (registry+https://github.com/rust-lang/crates.io-index)" = "97a47ae722318beceb0294e6f3d601205a1e6abaa4437d9d33e3a212233e3021"
"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.2 (registry+https://github.com/rust-lang/crates.io-index)" = "dd26bc0e7a2e3a7c959bc494caf58b72ee0c71d67704e9520f736ca7e4853ecf"
"checksum signal-hook 0.1.9 (registry+https://github.com/rust-lang/crates.io-index)" = "72ab58f1fda436857e6337dcb6a5aaa34f16c5ddc87b3a8b6ef7a212f90b9c5a"
"checksum signal-hook-registry 1.0.1 (registry+https://github.com/rust-lang/crates.io-index)" = "cded4ffa32146722ec54ab1f16320568465aa922aa9ab4708129599740da85d7"
"checksum serde 1.0.90 (registry+https://github.com/rust-lang/crates.io-index)" = "aa5f7c20820475babd2c077c3ab5f8c77a31c15e16ea38687b4c02d3e48680f4"
"checksum serde_derive 1.0.90 (registry+https://github.com/rust-lang/crates.io-index)" = "58fc82bec244f168b23d1963b45c8bf5726e9a15a9d146a067f9081aeed2de79"
"checksum serde 1.0.90 (registry+https://github.com/rust-lang/crates.io-index)" = "aa5f7c20820475babd2c077c3ab5f8c77a31c15e16ea38687b4c02d3e48680f4"
"checksum serde_derive 1.0.90 (registry+https://github.com/rust-lang/crates.io-index)" = "58fc82bec244f168b23d1963b45c8bf5726e9a15a9d146a067f9081aeed2de79"
"checksum serde_json 1.0.39 (registry+https://github.com/rust-lang/crates.io-index)" = "5a23aa71d4a4d43fdbfaac00eff68ba8a06a51759a89ac3304323e800c4dd40d"
"checksum serde 1.0.87 (registry+https://github.com/rust-lang/crates.io-index)" = "2e20fde37801e83c891a2dc4ebd3b81f0da4d1fb67a9e0a2a3b921e2536a58ee"
"checksum serde_derive 1.0.87 (registry+https://github.com/rust-lang/crates.io-index)" = "633e97856567e518b59ffb2ad7c7a4fd4c5d91d9c7f32dd38a27b2bf7e8114ea"
"checksum serde_json 1.0.38 (registry+https://github.com/rust-lang/crates.io-index)" = "27dce848e7467aa0e2fcaf0a413641499c0b745452aaca1194d24dedde9e13c9"
"checksum serde 1.0.92 (registry+https://github.com/rust-lang/crates.io-index)" = "32746bf0f26eab52f06af0d0aa1984f641341d06d8d673c693871da2d188c9be"
"checksum serde_derive 1.0.92 (registry+https://github.com/rust-lang/crates.io-index)" = "46a3223d0c9ba936b61c0d2e3e559e3217dbfb8d65d06d26e8b3c25de38bae3e"
"checksum serde 1.0.90 (registry+https://github.com/rust-lang/crates.io-index)" = "aa5f7c20820475babd2c077c3ab5f8c77a31c15e16ea38687b4c02d3e48680f4"
"checksum serde_derive 1.0.90 (registry+https://github.com/rust-lang/crates.io-index)" = "58fc82bec244f168b23d1963b45c8bf5726e9a15a9d146a067f9081aeed2de79"
"checksum serde_json 1.0.39 (registry+https://github.com/rust-lang/crates.io-index)" = "5a23aa71d4a4d43fdbfaac00eff68ba8a06a51759a89ac3304323e800c4dd40d"
"checksum serde 1.0.90 (registry+https://github.com/rust-lang/crates.io-index)" = "aa5f7c20820475babd2c077c3ab5f8c77a31c15e16ea38687b4c02d3e48680f4"
"checksum serde_derive 1.0.90 (registry+https://github.com/rust-lang/crates.io-index)" = "58fc82bec244f168b23d1963b45c8bf5726e9a15a9d146a067f9081aeed2de79"
"checksum serde_json 1.0.39 (registry+https://github.com/rust-lang/crates.io-index)" = "5a23aa71d4a4d43fdbfaac00eff68ba8a06a51759a89ac3304323e800c4dd40d"
"checksum sha-1 0.8.1 (registry+https://github.com/rust-lang/crates.io-index)" = "23962131a91661d643c98940b20fcaffe62d776a823247be80a48fcb8b6fce68"
"checksum sha2 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)" = "7b4d8bfd0e469f417657573d8451fb33d16cfe0989359b93baf3a1ffc639543d"
"checksum sha3 0.8.1 (registry+https://github.com/rust-lang/crates.io-index)" = "34a5e54083ce2b934bf059fdf38e7330a154177e029ab6c4e18638f2f624053a"
"checksum signal-hook 0.1.8 (registry+https://github.com/rust-lang/crates.io-index)" = "97a47ae722318beceb0294e6f3d601205a1e6abaa4437d9d33e3a212233e3021"
"checksum security-framework 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)" = "eee63d0f4a9ec776eeb30e220f0bc1e092c3ad744b2a379e3993070364d3adc2"
"checksum security-framework-sys 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)" = "9636f8989cbf61385ae4824b98c1aaa54c994d7d8b41f11c601ed799f0549a56"
"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 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 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 security-framework 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)" = "eee63d0f4a9ec776eeb30e220f0bc1e092c3ad744b2a379e3993070364d3adc2"
"checksum security-framework-sys 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)" = "9636f8989cbf61385ae4824b98c1aaa54c994d7d8b41f11c601ed799f0549a56"
"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 ryu 0.2.7 (registry+https://github.com/rust-lang/crates.io-index)" = "eb9e9b8cde282a9fe6a42dd4681319bfb63f121b8a8ee9439c6f4107e58a46f7"
"checksum ryu 0.2.7 (registry+https://github.com/rust-lang/crates.io-index)" = "eb9e9b8cde282a9fe6a42dd4681319bfb63f121b8a8ee9439c6f4107e58a46f7"
"checksum ryu 0.2.8 (registry+https://github.com/rust-lang/crates.io-index)" = "b96a9549dc8d48f2c283938303c4b5a77aa29bfbc5b54b084fb1630408899a8f"
"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 rustc-demangle 0.1.13 (registry+https://github.com/rust-lang/crates.io-index)" = "adacaae16d02b6ec37fdc7acfcddf365978de76d1983d3ee22afc260e1ca9619"
"checksum rustc-demangle 0.1.14 (registry+https://github.com/rust-lang/crates.io-index)" = "ccc78bfd5acd7bf3e89cffcf899e5cb1a52d6fafa8dec2739ad70c9577a57288"
"checksum rustc-demangle 0.1.14 (registry+https://github.com/rust-lang/crates.io-index)" = "ccc78bfd5acd7bf3e89cffcf899e5cb1a52d6fafa8dec2739ad70c9577a57288"
"checksum resolv-conf 0.6.2 (registry+https://github.com/rust-lang/crates.io-index)" = "b263b4aa1b5de9ffc0054a2386f96992058bb6870aab516f8cdeb8a667d56dcb"
"checksum rustc_version 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)" = "138e3e0acb6c9fb258b19b67cb8abd63c00679d2851805ea151465464fe9030a"
"checksum rustc-demangle 0.1.13 (registry+https://github.com/rust-lang/crates.io-index)" = "adacaae16d02b6ec37fdc7acfcddf365978de76d1983d3ee22afc260e1ca9619"
"checksum rustc-demangle 0.1.15 (registry+https://github.com/rust-lang/crates.io-index)" = "a7f4dccf6f4891ebcc0c39f9b6eb1a83b9bf5d747cb439ec6fba4f3b977038af"
"checksum rustc-demangle 0.1.14 (registry+https://github.com/rust-lang/crates.io-index)" = "ccc78bfd5acd7bf3e89cffcf899e5cb1a52d6fafa8dec2739ad70c9577a57288"
"checksum resolv-conf 0.6.2 (registry+https://github.com/rust-lang/crates.io-index)" = "b263b4aa1b5de9ffc0054a2386f96992058bb6870aab516f8cdeb8a667d56dcb"
"checksum rustc-demangle 0.1.14 (registry+https://github.com/rust-lang/crates.io-index)" = "ccc78bfd5acd7bf3e89cffcf899e5cb1a52d6fafa8dec2739ad70c9577a57288"
"checksum regex 1.1.6 (registry+https://github.com/rust-lang/crates.io-index)" = "8f0a0bcab2fd7d1d7c54fa9eae6f43eddeb9ce2e7352f8518a814a4f65d60c58"
"checksum remove_dir_all 0.5.1 (registry+https://github.com/rust-lang/crates.io-index)" = "3488ba1b9a2084d38645c4c08276a1752dcbf2c7130d74f1569681ad5d2799c5"
"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 regex 1.1.5 (registry+https://github.com/rust-lang/crates.io-index)" = "559008764a17de49a3146b234641644ed37d118d1ef641a0bb573d146edc6ce0"
"checksum regex-syntax 0.6.6 (registry+https://github.com/rust-lang/crates.io-index)" = "dcfd8681eebe297b81d98498869d4aae052137651ad7b96822f09ceb690d0a96"
"checksum remove_dir_all 0.5.1 (registry+https://github.com/rust-lang/crates.io-index)" = "3488ba1b9a2084d38645c4c08276a1752dcbf2c7130d74f1569681ad5d2799c5"
"checksum regex 1.1.5 (registry+https://github.com/rust-lang/crates.io-index)" = "559008764a17de49a3146b234641644ed37d118d1ef641a0bb573d146edc6ce0"
"checksum regex-syntax 0.6.6 (registry+https://github.com/rust-lang/crates.io-index)" = "dcfd8681eebe297b81d98498869d4aae052137651ad7b96822f09ceb690d0a96"
"checksum regex 1.1.0 (registry+https://github.com/rust-lang/crates.io-index)" = "37e7cbbd370869ce2e8dff25c7018702d10b21a20ef7135316f8daecd6c25b7f"
"checksum regex-syntax 0.6.5 (registry+https://github.com/rust-lang/crates.io-index)" = "8c2f35eedad5295fdf00a63d7d4b238135723f92b434ec06774dad15c7ab0861"
"checksum regex 1.1.5 (registry+https://github.com/rust-lang/crates.io-index)" = "559008764a17de49a3146b234641644ed37d118d1ef641a0bb573d146edc6ce0"
"checksum regex 1.1.7 (registry+https://github.com/rust-lang/crates.io-index)" = "0b2f0808e7d7e4fb1cb07feb6ff2f4bc827938f24f8c2e6a3beb7370af544bdd"
"checksum regex-syntax 0.6.7 (registry+https://github.com/rust-lang/crates.io-index)" = "9d76410686f9e3a17f06128962e0ecc5755870bb890c34820c7af7f1db2e1d48"
"checksum remove_dir_all 0.5.2 (registry+https://github.com/rust-lang/crates.io-index)" = "4a83fa3702a688b9359eccba92d153ac33fd2e8462f9e0e3fdf155239ea7792e"
"checksum regex 1.1.5 (registry+https://github.com/rust-lang/crates.io-index)" = "559008764a17de49a3146b234641644ed37d118d1ef641a0bb573d146edc6ce0"
"checksum regex-syntax 0.6.6 (registry+https://github.com/rust-lang/crates.io-index)" = "dcfd8681eebe297b81d98498869d4aae052137651ad7b96822f09ceb690d0a96"
"checksum regex 1.1.5 (registry+https://github.com/rust-lang/crates.io-index)" = "559008764a17de49a3146b234641644ed37d118d1ef641a0bb573d146edc6ce0"
"checksum regex-syntax 0.6.6 (registry+https://github.com/rust-lang/crates.io-index)" = "dcfd8681eebe297b81d98498869d4aae052137651ad7b96822f09ceb690d0a96"
"checksum regex 1.1.6 (registry+https://github.com/rust-lang/crates.io-index)" = "8f0a0bcab2fd7d1d7c54fa9eae6f43eddeb9ce2e7352f8518a814a4f65d60c58"
"checksum quote 0.6.11 (registry+https://github.com/rust-lang/crates.io-index)" = "cdd8e04bd9c52e0342b406469d494fcb033be4bdbe5c606016defbb1681411e1"
"checksum quote 0.6.12 (registry+https://github.com/rust-lang/crates.io-index)" = "faf4799c5d274f3868a4aae320a0a182cbd2baee377b378f080e16a23e9d80db"
"checksum rand 0.5.6 (registry+https://github.com/rust-lang/crates.io-index)" = "c618c47cd3ebd209790115ab837de41425723956ad3ce2e6a7f09890947cacb9"
"checksum rand 0.6.5 (registry+https://github.com/rust-lang/crates.io-index)" = "6d71dacdc3c88c1fde3885a3be3fbab9f35724e6ce99467f7d9c5026132184ca"
"checksum rand_chacha 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "556d3a1ca6600bfcbab7c7c91ccb085ac7fbbcd70e008a98742e7847f4f7bcef"
"checksum quote 0.6.11 (registry+https://github.com/rust-lang/crates.io-index)" = "cdd8e04bd9c52e0342b406469d494fcb033be4bdbe5c606016defbb1681411e1"
"checksum quote 0.6.12 (registry+https://github.com/rust-lang/crates.io-index)" = "faf4799c5d274f3868a4aae320a0a182cbd2baee377b378f080e16a23e9d80db"
"checksum quote 0.6.12 (registry+https://github.com/rust-lang/crates.io-index)" = "faf4799c5d274f3868a4aae320a0a182cbd2baee377b378f080e16a23e9d80db"
"checksum quote 0.6.12 (registry+https://github.com/rust-lang/crates.io-index)" = "faf4799c5d274f3868a4aae320a0a182cbd2baee377b378f080e16a23e9d80db"
"checksum rand 0.5.6 (registry+https://github.com/rust-lang/crates.io-index)" = "c618c47cd3ebd209790115ab837de41425723956ad3ce2e6a7f09890947cacb9"
"checksum rand 0.6.5 (registry+https://github.com/rust-lang/crates.io-index)" = "6d71dacdc3c88c1fde3885a3be3fbab9f35724e6ce99467f7d9c5026132184ca"
"checksum rand_chacha 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "556d3a1ca6600bfcbab7c7c91ccb085ac7fbbcd70e008a98742e7847f4f7bcef"
"checksum rand_core 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)" = "7a6fdeb83b075e8266dcc8762c22776f6877a63111121f5f8c7411e5be7eed4b"
"checksum rand_core 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)" = "d0e7a549d590831370895ab7ba4ea0c1b6b011d106b5ff2da6eee112615e6dc0"
"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.3 (registry+https://github.com/rust-lang/crates.io-index)" = "7b75f676a1e053fc562eafbb47838d67c84801e38fc1ba459e8f180deabd5071"
"checksum rand_pcg 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)" = "abf9b09b01790cfe0364f52bf32995ea3c39f4d2dd011eac241d2914146d0b44"
"checksum rand_xorshift 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "cbf7e9e623549b0e21f6e97cf8ecf247c1a8fd2e8a992ae265314300b2455d5c"
"checksum rdrand 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)" = "678054eb77286b51581ba43620cc911abf02758c91f93f479767aed0f90458b2"
"checksum redox_syscall 0.1.54 (registry+https://github.com/rust-lang/crates.io-index)" = "12229c14a0f65c4f1cb046a3b52047cdd9da1f4b30f8a39c5063c8bae515e252"
"checksum quick-xml 0.13.3 (registry+https://github.com/rust-lang/crates.io-index)" = "22fcc48ecef4609b243e8c01ff4695d08ee0fc9d5bdbc54630e1a5fe8bb40953"
"checksum quick-xml 0.13.2 (registry+https://github.com/rust-lang/crates.io-index)" = "98d8d2d671bd29c6122a98b45ce3106391e89ba378f731274de677f1eff06e5f"
"checksum quick-xml 0.13.3 (registry+https://github.com/rust-lang/crates.io-index)" = "22fcc48ecef4609b243e8c01ff4695d08ee0fc9d5bdbc54630e1a5fe8bb40953"
"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 phf 0.7.23 (registry+https://github.com/rust-lang/crates.io-index)" = "cec29da322b242f4c3098852c77a0ca261c9c01b806cae85a5572a1eb94db9a6"
"checksum phf_codegen 0.7.23 (registry+https://github.com/rust-lang/crates.io-index)" = "7d187f00cd98d5afbcd8898f6cf181743a449162aeb329dcd2f3849009e605ad"
"checksum phf_generator 0.7.23 (registry+https://github.com/rust-lang/crates.io-index)" = "03dc191feb9b08b0dc1330d6549b795b9d81aec19efe6b4a45aec8d4caee0c4b"
"checksum phf_shared 0.7.23 (registry+https://github.com/rust-lang/crates.io-index)" = "b539898d22d4273ded07f64a05737649dc69095d92cb87c7097ec68e3f150b93"
"checksum openssl-sys 0.9.39 (registry+https://github.com/rust-lang/crates.io-index)" = "278c1ad40a89aa1e741a1eed089a2f60b18fab8089c3139b542140fc7d674106"
"checksum owning_ref 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)" = "cdf84f41639e037b484f93433aa3897863b561ed65c6e59c7073d7c561710f37"
"checksum parking_lot 0.6.4 (registry+https://github.com/rust-lang/crates.io-index)" = "f0802bff09003b291ba756dc7e79313e51cc31667e94afbe847def490424cde5"
"checksum parking_lot_core 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)" = "ad7f7e6ebdc79edff6fdcb87a55b620174f7a989e3eb31b65231f4af57f00b8c"
"checksum memchr 2.1.0 (registry+https://github.com/rust-lang/crates.io-index)" = "4b3629fe9fdbff6daa6c33b90f7c08355c1aca05a3d01fa8063b822fcf185f3b"
"checksum minidom 0.9.1 (registry+https://github.com/rust-lang/crates.io-index)" = "c0a5296bf9d0ac9e4a6e4cb844e3ee84bf33f841c7b3ae2cc87f05ceb81b50ae"
"checksum mio-uds 0.6.7 (registry+https://github.com/rust-lang/crates.io-index)" = "966257a94e196b11bb43aca423754d87429960a768de9414f3691d6957abf125"
"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 0.6.19 (registry+https://github.com/rust-lang/crates.io-index)" = "83f51996a3ed004ef184e16818edc51fadffe8e7ca68be67f9dee67d84d0ff23"
"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 markup5ever 0.7.3 (registry+https://github.com/rust-lang/crates.io-index)" = "a87c4100d614080c8ab43334fb028ebe387f273fb61ed4ff0eae9189b94b6be8"
"checksum lazy_static 1.1.0 (registry+https://github.com/rust-lang/crates.io-index)" = "ca488b89a5657b0a2ecd45b95609b3e848cf1755da332a0da46e2b2b1cb371a7"
"checksum lazycell 1.2.0 (registry+https://github.com/rust-lang/crates.io-index)" = "ddba4c30a78328befecec92fc94970e53b3ae385827d28620f0f5bb2493081e0"
"checksum libc 0.2.43 (registry+https://github.com/rust-lang/crates.io-index)" = "76e3a3ef172f1a0b9a9ff0dd1491ae5e6c948b94479a3021819ba7d860c8645d"
"checksum linked-hash-map 0.4.2 (registry+https://github.com/rust-lang/crates.io-index)" = "7860ec297f7008ff7a1e3382d7f7e1dcd69efc94751a2284bafc3d013c2aa939"
"checksum lock_api 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)" = "775751a3e69bde4df9b38dd00a1b5d6ac13791e4223d4a0506577f0dd27cfb7a"
"checksum log 0.3.9 (registry+https://github.com/rust-lang/crates.io-index)" = "e19e8d5c34a3e0e2223db8e060f9e8264aeeb5c5fc64a4ee9965c062211c024b"
"checksum log 0.4.5 (registry+https://github.com/rust-lang/crates.io-index)" = "d4fcce5fa49cc693c312001daf1d13411c4a5283796bac1084299ea3e567113f"
"checksum lru-cache 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "4d06ff7ff06f729ce5f4e227876cb88d10bc59cd4ae1e09fbb2bde15c850dc21"
"checksum futures 0.1.25 (registry+https://github.com/rust-lang/crates.io-index)" = "49e7653e374fe0d0c12de4250f0bdb60680b8c80eed558c5c7538eec9c89e21b"
"checksum generic-array 0.9.0 (registry+https://github.com/rust-lang/crates.io-index)" = "ef25c5683767570c2bbd7deba372926a55eaae9982d7726ee2a1050239d45b9d"
"checksum h2 0.1.13 (registry+https://github.com/rust-lang/crates.io-index)" = "7dd33bafe2e6370e6c8eb0cf1b8c5f93390b90acde7e9b03723f166b28b648ed"
"checksum http 0.1.13 (registry+https://github.com/rust-lang/crates.io-index)" = "24f58e8c2d8e886055c3ead7b28793e1455270b5fb39650984c224bc538ba581"
"checksum humantime 1.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "0484fda3e7007f2a4a0d9c3a703ca38c71c54c55602ce4660c419fd32e188c9e"
"checksum hyper 0.12.13 (registry+https://github.com/rust-lang/crates.io-index)" = "95ffee0d1d30de4313fdaaa485891ce924991d45bbc18adfc8ac5b1639e62fbb"
"checksum ipconfig 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)" = "fccb81dd962b29a25de46c4f46e497b75117aa816468b6fff7a63a598a192394"
"checksum jid 0.5.2 (registry+https://github.com/rust-lang/crates.io-index)" = "6c4cee633b7ce95e71202ecb99e632d15ad468de7753e616a924c93842f1a3d0"
"checksum jid 0.5.3 (registry+https://github.com/rust-lang/crates.io-index)" = "24e8a3f2ab860aa08074136e3144a2425e678d8823206e5adcc6145dc136503a"
"checksum jid 0.5.3 (registry+https://github.com/rust-lang/crates.io-index)" = "24e8a3f2ab860aa08074136e3144a2425e678d8823206e5adcc6145dc136503a"
"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 itoa 0.4.4 (registry+https://github.com/rust-lang/crates.io-index)" = "501266b7edd0174f8530248f87f99c88fbe60ca4ef3dd486835b8d8d53136f7f"
"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 humantime 1.2.0 (registry+https://github.com/rust-lang/crates.io-index)" = "3ca7e5f2e110db35f93b837c81797f3714500b81d517bf20c431b16d3ca4f114"
"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 hyper 0.12.25 (registry+https://github.com/rust-lang/crates.io-index)" = "7d5b6658b016965ae301fa995306db965c93677880ea70765a84235a96eae896"
"checksum hyper 0.12.27 (registry+https://github.com/rust-lang/crates.io-index)" = "4f2777434f26af6e4ce4fdcdccd3bed9d861d11e87bcbe72c0f51ddaca8ff848"
"checksum hyper 0.12.27 (registry+https://github.com/rust-lang/crates.io-index)" = "4f2777434f26af6e4ce4fdcdccd3bed9d861d11e87bcbe72c0f51ddaca8ff848"
"checksum hyper 0.12.23 (registry+https://github.com/rust-lang/crates.io-index)" = "860faf61a9957c9cb0e23e69f1c8290e92f6eb660fcdd1f2d6777043a2ae1a46"
"checksum hyper 0.12.30 (registry+https://github.com/rust-lang/crates.io-index)" = "40e7692b2009a70b1e9b362284add4d8b75880fefddb4acaa5e67194e843f219"
"checksum hyper 0.12.27 (registry+https://github.com/rust-lang/crates.io-index)" = "4f2777434f26af6e4ce4fdcdccd3bed9d861d11e87bcbe72c0f51ddaca8ff848"
"checksum humantime 1.2.0 (registry+https://github.com/rust-lang/crates.io-index)" = "3ca7e5f2e110db35f93b837c81797f3714500b81d517bf20c431b16d3ca4f114"
"checksum hyper 0.12.27 (registry+https://github.com/rust-lang/crates.io-index)" = "4f2777434f26af6e4ce4fdcdccd3bed9d861d11e87bcbe72c0f51ddaca8ff848"
"checksum http 0.1.16 (registry+https://github.com/rust-lang/crates.io-index)" = "fe67e3678f2827030e89cc4b9e7ecd16d52f132c0b940ab5005f88e821500f6a"
"checksum http 0.1.17 (registry+https://github.com/rust-lang/crates.io-index)" = "eed324f0f0daf6ec10c474f150505af2c143f251722bf9dbd1261bd1f2ee2c1a"
"checksum http 0.1.15 (registry+https://github.com/rust-lang/crates.io-index)" = "1a10e5b573b9a0146545010f50772b9e8b1dd0a256564cc4307694c68832a2f5"
"checksum http 0.1.17 (registry+https://github.com/rust-lang/crates.io-index)" = "eed324f0f0daf6ec10c474f150505af2c143f251722bf9dbd1261bd1f2ee2c1a"
"checksum httparse 1.3.3 (registry+https://github.com/rust-lang/crates.io-index)" = "e8734b0cfd3bc3e101ec59100e101c2eecd19282202e87808b3037b442777a83"
"checksum http-body 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)" = "6741c859c1b2463a423a1dbce98d418e6c3c3fc720fb0d45528657320920292d"
"checksum http 0.1.17 (registry+https://github.com/rust-lang/crates.io-index)" = "eed324f0f0daf6ec10c474f150505af2c143f251722bf9dbd1261bd1f2ee2c1a"
"checksum http 0.1.17 (registry+https://github.com/rust-lang/crates.io-index)" = "eed324f0f0daf6ec10c474f150505af2c143f251722bf9dbd1261bd1f2ee2c1a"
"checksum generic-array 0.12.0 (registry+https://github.com/rust-lang/crates.io-index)" = "3c0f28c2f5bfb5960175af447a2da7c18900693738343dc896ffbcabd9839592"
"checksum hmac 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)" = "f127a908633569f208325f86f71255d3363c79721d7f9fe31cd5569908819771"
"checksum h2 0.1.16 (registry+https://github.com/rust-lang/crates.io-index)" = "ddb2b25a33e231484694267af28fec74ac63b5ccf51ee2065a5e313b834d836e"
"checksum hostname 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)" = "21ceb46a83a85e824ef93669c8b390009623863b5c195d1ba747292c0c72f94e"
"checksum h2 0.1.18 (registry+https://github.com/rust-lang/crates.io-index)" = "85ab6286db06040ddefb71641b50017c06874614001a134b423783e2db2920bd"
"checksum h2 0.1.18 (registry+https://github.com/rust-lang/crates.io-index)" = "85ab6286db06040ddefb71641b50017c06874614001a134b423783e2db2920bd"
"checksum h2 0.1.16 (registry+https://github.com/rust-lang/crates.io-index)" = "ddb2b25a33e231484694267af28fec74ac63b5ccf51ee2065a5e313b834d836e"
"checksum h2 0.1.23 (registry+https://github.com/rust-lang/crates.io-index)" = "1e42e3daed5a7e17b12a0c23b5b2fbff23a925a570938ebee4baca1a9a1a2240"
"checksum h2 0.1.18 (registry+https://github.com/rust-lang/crates.io-index)" = "85ab6286db06040ddefb71641b50017c06874614001a134b423783e2db2920bd"
"checksum generic-array 0.12.0 (registry+https://github.com/rust-lang/crates.io-index)" = "3c0f28c2f5bfb5960175af447a2da7c18900693738343dc896ffbcabd9839592"
"checksum h2 0.1.18 (registry+https://github.com/rust-lang/crates.io-index)" = "85ab6286db06040ddefb71641b50017c06874614001a134b423783e2db2920bd"
"checksum hmac 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)" = "f127a908633569f208325f86f71255d3363c79721d7f9fe31cd5569908819771"
"checksum digest 0.7.6 (registry+https://github.com/rust-lang/crates.io-index)" = "03b072242a8cbaf9c145665af9d250c59af3b958f83ed6824e13533cf76d5b90"
"checksum encoding_rs 0.8.10 (registry+https://github.com/rust-lang/crates.io-index)" = "065f4d0c826fdaef059ac45487169d918558e3cf86c9d89f6e81cf52369126e5"
"checksum env_logger 0.5.13 (registry+https://github.com/rust-lang/crates.io-index)" = "15b0a4d2e39f8420210be8b27eeda28029729e2fd4291019455016c348240c38"
"checksum error-chain 0.1.12 (registry+https://github.com/rust-lang/crates.io-index)" = "faa976b4fd2e4c2b2f3f486874b19e61944d3de3de8b61c9fcf835d583871bcc"
"checksum failure 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)" = "6dd377bcc1b1b7ce911967e3ec24fa19c3224394ec05b54aa7b083d498341ac7"
"checksum failure_derive 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)" = "64c2d913fe8ed3b6c6518eedf4538255b989945c14c2a7d5cbff62a5e2120596"
"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 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 constant_time_eq 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)" = "8ff012e225ce166d4422e0e78419d901719760f62ae2b7969ca6b564d1b54a9e"
"checksum crossbeam-deque 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)" = "3486aefc4c0487b9cb52372c97df0a48b8c249514af1ee99703bf70d2f2ceda1"
"checksum crossbeam-epoch 0.5.2 (registry+https://github.com/rust-lang/crates.io-index)" = "30fecfcac6abfef8771151f8be4abc9e4edc112c2bcb233314cafde2680536e9"
"checksum crossbeam-utils 0.5.0 (registry+https://github.com/rust-lang/crates.io-index)" = "677d453a17e8bd2b913fa38e8b9cf04bcdbb5be790aa294f2389661d72036015"
"checksum crypto-mac 0.5.2 (registry+https://github.com/rust-lang/crates.io-index)" = "0999b4ff4d3446d4ddb19a63e9e00c1876e75cd7000d20e57a693b4b3f08d958"
"checksum dbghelp-sys 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)" = "97590ba53bcb8ac28279161ca943a924d1fd4a8fb3fa63302591647c4fc5b850"
"checksum crossbeam-epoch 0.7.1 (registry+https://github.com/rust-lang/crates.io-index)" = "04c9e3102cc2d69cd681412141b390abd55a362afc1540965dad0ad4d34280b4"
"checksum crossbeam-utils 0.6.5 (registry+https://github.com/rust-lang/crates.io-index)" = "f8306fcef4a7b563b76b7dd949ca48f52bc1141aa067d2ea09565f3e2652aa5c"
"checksum crossbeam-queue 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)" = "7c979cd6cfe72335896575c6b5688da489e420d36a27a0b9eb0c73db574b4a4b"
"checksum crossbeam-queue 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)" = "7c979cd6cfe72335896575c6b5688da489e420d36a27a0b9eb0c73db574b4a4b"
"checksum crossbeam-deque 0.7.1 (registry+https://github.com/rust-lang/crates.io-index)" = "b18cd2e169ad86297e6bc0ad9aa679aee9daa4f19e8163860faf7c164e4f5a71"
"checksum crossbeam 0.6.0 (registry+https://github.com/rust-lang/crates.io-index)" = "ad4c7ea749d9fb09e23c5cb17e3b70650860553a0e2744e38446b1803bf7db94"
"checksum crossbeam-channel 0.3.8 (registry+https://github.com/rust-lang/crates.io-index)" = "0f0ed1a4de2235cabda8558ff5840bffb97fcb64c97827f354a451307df5f72b"
"checksum crossbeam-deque 0.6.3 (registry+https://github.com/rust-lang/crates.io-index)" = "05e44b8cf3e1a625844d1750e1f7820da46044ff6d28f4d43e455ba3e5bb2c13"
"checksum crossbeam-deque 0.7.1 (registry+https://github.com/rust-lang/crates.io-index)" = "b18cd2e169ad86297e6bc0ad9aa679aee9daa4f19e8163860faf7c164e4f5a71"
"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 encoding_rs 0.8.17 (registry+https://github.com/rust-lang/crates.io-index)" = "4155785c79f2f6701f185eb2e6b4caf0555ec03477cb4c70db67b465311620ed"
"checksum env_logger 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)" = "b61fa891024a945da30a9581546e8cfaf5602c7b3f4c137a2805cf388f92075a"
"checksum encoding_rs 0.8.15 (registry+https://github.com/rust-lang/crates.io-index)" = "fd251508d65030820f3a4317af2248180db337fdb25d89967956242580277813"
"checksum env_logger 0.6.0 (registry+https://github.com/rust-lang/crates.io-index)" = "afb070faf94c85d17d50ca44f6ad076bce18ae92f0037d350947240a36e9d42e"
"checksum either 1.5.2 (registry+https://github.com/rust-lang/crates.io-index)" = "5527cfe0d098f36e3f8839852688e63c8fff1c90b2b405aef730615f9a7bcf7b"
"checksum env_logger 0.6.0 (registry+https://github.com/rust-lang/crates.io-index)" = "afb070faf94c85d17d50ca44f6ad076bce18ae92f0037d350947240a36e9d42e"
"checksum env_logger 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)" = "b61fa891024a945da30a9581546e8cfaf5602c7b3f4c137a2805cf388f92075a"
"checksum env_logger 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)" = "b61fa891024a945da30a9581546e8cfaf5602c7b3f4c137a2805cf388f92075a"
"checksum derive-error 0.0.4 (registry+https://github.com/rust-lang/crates.io-index)" = "ec098440b29ea3b1ece3e641bac424c19cf996779b623c9e0f2171495425c2c8"
"checksum error-chain 0.8.1 (registry+https://github.com/rust-lang/crates.io-index)" = "6930e04918388a9a2e41d518c25cf679ccafe26733fb4127dbf21993f2575d46"
"checksum blake2 0.7.1 (registry+https://github.com/rust-lang/crates.io-index)" = "73b77e29dbd0115e43938be2d5128ecf81c0353e00acaa65339a1242586951d9"
"checksum block-buffer 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)" = "a076c298b9ecdb530ed9d967e74a6027d6a7478924520acddcddc24c1c8ab3ab"
"checksum byte-tools 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)" = "560c32574a12a89ecd91f5e742165893f86e3ab98d21f8ea548658eb9eef5f40"
"checksum byteorder 1.2.7 (registry+https://github.com/rust-lang/crates.io-index)" = "94f88df23a25417badc922ab0f5716cc1330e87f71ddd9203b3a3ccd9cedf75d"
"checksum bytes 0.4.10 (registry+https://github.com/rust-lang/crates.io-index)" = "0ce55bd354b095246fc34caf4e9e242f5297a7fd938b090cadfea6eee614aa62"
"checksum cc 1.0.25 (registry+https://github.com/rust-lang/crates.io-index)" = "f159dfd43363c4d08055a07703eb7a3406b0dac4d0584d96965a3262db3c9d16"
"checksum cfg-if 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)" = "082bb9b28e00d3c9d39cc03e64ce4cea0f1bb9b3fde493f0cbc008472d22bdf4"
"checksum clap 2.32.0 (registry+https://github.com/rust-lang/crates.io-index)" = "b957d88f4b6a63b9d70d5f454ac8011819c6efa7727858f458ab71c756ce2d3e"
"checksum clap 2.32.0 (registry+https://github.com/rust-lang/crates.io-index)" = "b957d88f4b6a63b9d70d5f454ac8011819c6efa7727858f458ab71c756ce2d3e"
"checksum clap 2.33.0 (registry+https://github.com/rust-lang/crates.io-index)" = "5067f5bb2d80ef5d68b4c87db81601f0b75bca627bc2ef76b141d7b846a3c6d9"
"checksum clap 2.32.0 (registry+https://github.com/rust-lang/crates.io-index)" = "b957d88f4b6a63b9d70d5f454ac8011819c6efa7727858f458ab71c756ce2d3e"
"checksum clap 2.33.0 (registry+https://github.com/rust-lang/crates.io-index)" = "5067f5bb2d80ef5d68b4c87db81601f0b75bca627bc2ef76b141d7b846a3c6d9"
"checksum clap 2.33.0 (registry+https://github.com/rust-lang/crates.io-index)" = "5067f5bb2d80ef5d68b4c87db81601f0b75bca627bc2ef76b141d7b846a3c6d9"
"checksum clap 2.33.0 (registry+https://github.com/rust-lang/crates.io-index)" = "5067f5bb2d80ef5d68b4c87db81601f0b75bca627bc2ef76b141d7b846a3c6d9"
"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 cc 1.0.35 (registry+https://github.com/rust-lang/crates.io-index)" = "5e5f3fee5eeb60324c2781f1e41286bdee933850fff9b3c672587fed5ec58c83"
"checksum cfg-if 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)" = "11d43355396e872eefb45ce6342e4374ed7bc2b3a502d1b28e36d6e23c05d1f4"
"checksum cc 1.0.35 (registry+https://github.com/rust-lang/crates.io-index)" = "5e5f3fee5eeb60324c2781f1e41286bdee933850fff9b3c672587fed5ec58c83"
"checksum cfg-if 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)" = "11d43355396e872eefb45ce6342e4374ed7bc2b3a502d1b28e36d6e23c05d1f4"
"checksum cc 1.0.29 (registry+https://github.com/rust-lang/crates.io-index)" = "4390a3b5f4f6bce9c1d0c00128379df433e53777fdd30e92f16a529332baec4e"
"checksum cfg-if 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)" = "082bb9b28e00d3c9d39cc03e64ce4cea0f1bb9b3fde493f0cbc008472d22bdf4"
"checksum cc 1.0.37 (registry+https://github.com/rust-lang/crates.io-index)" = "39f75544d7bbaf57560d2168f28fd649ff9c76153874db88bdbdfd839b1a7e7d"
"checksum cfg-if 0.1.9 (registry+https://github.com/rust-lang/crates.io-index)" = "b486ce3ccf7ffd79fdeb678eac06a9e6c09fc88d33836340becb8fffe87c5e33"
"checksum cc 1.0.35 (registry+https://github.com/rust-lang/crates.io-index)" = "5e5f3fee5eeb60324c2781f1e41286bdee933850fff9b3c672587fed5ec58c83"
"checksum cfg-if 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)" = "11d43355396e872eefb45ce6342e4374ed7bc2b3a502d1b28e36d6e23c05d1f4"
"checksum cc 1.0.35 (registry+https://github.com/rust-lang/crates.io-index)" = "5e5f3fee5eeb60324c2781f1e41286bdee933850fff9b3c672587fed5ec58c83"
"checksum cfg-if 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)" = "11d43355396e872eefb45ce6342e4374ed7bc2b3a502d1b28e36d6e23c05d1f4"
"checksum chrono 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)" = "45912881121cb26fad7c38c17ba7daa18764771836b34fab7d3fbd93ed633878"
"checksum arc-swap 0.3.4 (registry+https://github.com/rust-lang/crates.io-index)" = "af192669a9f44d2fb63c691a04183c8e12428f34041449270b08c0456587f5a5"
"checksum arrayref 0.3.5 (registry+https://github.com/rust-lang/crates.io-index)" = "0d382e583f07208808f6b1249e60848879ba3543f57c32277bf52d69c2f0f0ee"
"checksum arrayvec 0.4.7 (registry+https://github.com/rust-lang/crates.io-index)" = "a1e964f9e24d588183fcb43503abda40d288c8657dfc27311516ce2f05675aef"
"checksum backtrace 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)" = "346d7644f0b5f9bc73082d3b2236b69a05fd35cce0cfa3724e184e6a5c9e2a2f"
"checksum backtrace 0.3.9 (registry+https://github.com/rust-lang/crates.io-index)" = "89a47830402e9981c5c41223151efcced65a0510c13097c769cede7efb34782a"
"checksum backtrace-sys 0.1.24 (registry+https://github.com/rust-lang/crates.io-index)" = "c66d56ac8dabd07f6aacdaf633f4b8262f5b3601a810a0dcddffd5c22c69daa0"
"checksum base64 0.9.3 (registry+https://github.com/rust-lang/crates.io-index)" = "489d6c0ed21b11d038c31b6ceccca973e65d73ba3bd8ecb9a2babf5546164643"
"checksum block-buffer 0.7.3 (registry+https://github.com/rust-lang/crates.io-index)" = "c0940dc441f31689269e10ac70eb1002a3a1d3ad1390e030043662eb7fe4688b"
"checksum block-padding 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)" = "6d4dc3af3ee2e12f3e5d224e5e1e3d73668abbeb69e566d361f7d5563a4fdf09"
"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 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 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 block-buffer 0.7.2 (registry+https://github.com/rust-lang/crates.io-index)" = "509de513cca6d92b6aacf9c61acfe7eaa160837323a81068d690cc1f8e5740da"
"checksum block-buffer 0.7.3 (registry+https://github.com/rust-lang/crates.io-index)" = "c0940dc441f31689269e10ac70eb1002a3a1d3ad1390e030043662eb7fe4688b"
"checksum block-padding 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)" = "6d4dc3af3ee2e12f3e5d224e5e1e3d73668abbeb69e566d361f7d5563a4fdf09"
"checksum block-buffer 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)" = "49665c62e0e700857531fa5d3763e91b539ff1abeebd56808d378b495870d60d"
"checksum autocfg 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)" = "a6d640bee2da49f60a4068a7fae53acde8982514ab7bae8b8cea9e88cbcfd799"
"checksum backtrace 0.3.15 (registry+https://github.com/rust-lang/crates.io-index)" = "f106c02a3604afcdc0df5d36cc47b44b55917dbaf3d808f71c163a0ddba64637"
"checksum autocfg 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)" = "a6d640bee2da49f60a4068a7fae53acde8982514ab7bae8b8cea9e88cbcfd799"
"checksum backtrace-sys 0.1.28 (registry+https://github.com/rust-lang/crates.io-index)" = "797c830ac25ccc92a7f8a7b9862bde440715531514594a6154e3d4a54dd769b6"
"checksum backtrace 0.3.14 (registry+https://github.com/rust-lang/crates.io-index)" = "cd5a90e2b463010cd0e0ce9a11d4a9d5d58d9f41d4a6ba3dcaf9e68b466e88b4"
"checksum backtrace 0.3.15 (registry+https://github.com/rust-lang/crates.io-index)" = "f106c02a3604afcdc0df5d36cc47b44b55917dbaf3d808f71c163a0ddba64637"
"checksum backtrace 0.3.13 (registry+https://github.com/rust-lang/crates.io-index)" = "b5b493b66e03090ebc4343eb02f94ff944e0cbc9ac6571491d170ba026741eb5"
"checksum backtrace 0.3.15 (registry+https://github.com/rust-lang/crates.io-index)" = "f106c02a3604afcdc0df5d36cc47b44b55917dbaf3d808f71c163a0ddba64637"
"checksum autocfg 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)" = "0e49efa51329a5fd37e7c79db4621af617cd4e3e5bc224939808d076077077bf"
"checksum backtrace 0.3.30 (registry+https://github.com/rust-lang/crates.io-index)" = "ada4c783bb7e7443c14e0480f429ae2cc99da95065aeab7ee1b81ada0419404f"
"checksum autocfg 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)" = "a6d640bee2da49f60a4068a7fae53acde8982514ab7bae8b8cea9e88cbcfd799"
"checksum backtrace 0.3.15 (registry+https://github.com/rust-lang/crates.io-index)" = "f106c02a3604afcdc0df5d36cc47b44b55917dbaf3d808f71c163a0ddba64637"
"checksum backtrace-sys 0.1.28 (registry+https://github.com/rust-lang/crates.io-index)" = "797c830ac25ccc92a7f8a7b9862bde440715531514594a6154e3d4a54dd769b6"
"checksum base64 0.10.1 (registry+https://github.com/rust-lang/crates.io-index)" = "0b25d992356d2eb0ed82172f5248873db5560c4721f564b13cb5193bda5e668e"
"checksum bitflags 1.0.4 (registry+https://github.com/rust-lang/crates.io-index)" = "228047a76f468627ca71776ecdebd732a3423081fcf5125585bcd7c49886ce12"
"checksum block-buffer 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)" = "49665c62e0e700857531fa5d3763e91b539ff1abeebd56808d378b495870d60d"
"checksum case 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)" = "e88b166b48e29667f5443df64df3c61dc07dc2b1a0b0d231800e07f09a33ecc1"
"checksum block-buffer 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)" = "49665c62e0e700857531fa5d3763e91b539ff1abeebd56808d378b495870d60d"
"checksum block-padding 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)" = "d75255892aeb580d3c566f213a2b6fdc1c66667839f45719ee1d30ebf2aea591"
"checksum byte-tools 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)" = "e3b5ca7a04898ad4bcd41c90c5285445ff5b791899bb1b0abdd2a2aa791211d7"
"checksum byteorder 1.3.1 (registry+https://github.com/rust-lang/crates.io-index)" = "a019b10a2a7cdeb292db131fc8113e57ea2a908f6e7894b0c3c671893b65dbeb"
"checksum bytes 0.4.12 (registry+https://github.com/rust-lang/crates.io-index)" = "206fdffcfa2df7cbe15601ef46c813fce0965eb3286db6b56c583b814b51c81c"
"checksum block-buffer 0.7.3 (registry+https://github.com/rust-lang/crates.io-index)" = "c0940dc441f31689269e10ac70eb1002a3a1d3ad1390e030043662eb7fe4688b"
"checksum aho-corasick 0.6.8 (registry+https://github.com/rust-lang/crates.io-index)" = "68f56c7353e5a9547cbd76ed90f7bb5ffc3ba09d4ea9bd1d8c06c8b1142eeb5a"
"checksum termion 1.5.2 (registry+https://github.com/rust-lang/crates.io-index)" = "dde0593aeb8d47accea5392b39350015b5eccb12c0d98044d856983d89548dea"
"checksum syn 0.15.33 (registry+https://github.com/rust-lang/crates.io-index)" = "ec52cd796e5f01d0067225a5392e70084acc4c0013fa71d55166d38a8b307836"
"checksum proc-macro2 0.4.29 (registry+https://github.com/rust-lang/crates.io-index)" = "64c827cea7a7ab30ce4593e5e04d7a11617ad6ece2fa230605a78b00ff965316"
"checksum native-tls 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)" = "4b2df1a4c22fd44a62147fd8f13dd0f95c9d8ca7b2610299b2a2f9cf8964274e"
"checksum new_debug_unreachable 1.0.1 (registry+https://github.com/rust-lang/crates.io-index)" = "0cdc457076c78ab54d5e0d6fa7c47981757f1e34dc39ff92787f217dede586c4"
"checksum nodrop 0.1.12 (registry+https://github.com/rust-lang/crates.io-index)" = "9a2228dca57108069a5262f2ed8bd2e82496d2e074a06d1ccc7ce1687b6ae0a2"
"checksum num_cpus 1.8.0 (registry+https://github.com/rust-lang/crates.io-index)" = "c51a3322e4bca9d212ad9a158a02abc6934d005490c054a2778df73a70aa0a30"
"checksum openssl 0.10.15 (registry+https://github.com/rust-lang/crates.io-index)" = "5e1309181cdcbdb51bc3b6bedb33dfac2a83b3d585033d3f6d9e22e8c1928613"
"checksum num_cpus 1.10.0 (registry+https://github.com/rust-lang/crates.io-index)" = "1a23f0ed30a54abaa0c7e83b1d2d87ada7c3c23078d1d87815af3e3b6385fbba"
"checksum openssl 0.10.19 (registry+https://github.com/rust-lang/crates.io-index)" = "84321fb9004c3bce5611188a644d6171f895fa2889d155927d528782edb21c5d"
"checksum openssl 0.10.20 (registry+https://github.com/rust-lang/crates.io-index)" = "5a0d6b781aac4ac1bd6cafe2a2f0ad8c16ae8e1dd5184822a16c50139f8838d9"
"checksum openssl 0.10.20 (registry+https://github.com/rust-lang/crates.io-index)" = "5a0d6b781aac4ac1bd6cafe2a2f0ad8c16ae8e1dd5184822a16c50139f8838d9"
"checksum openssl 0.10.16 (registry+https://github.com/rust-lang/crates.io-index)" = "ec7bd7ca4cce6dbdc77e7c1230682740d307d1218a87fb0349a571272be749f9"
"checksum openssl 0.10.23 (registry+https://github.com/rust-lang/crates.io-index)" = "97c140cbb82f3b3468193dd14c1b88def39f341f68257f8a7fe8ed9ed3f628a5"
"checksum openssl 0.10.20 (registry+https://github.com/rust-lang/crates.io-index)" = "5a0d6b781aac4ac1bd6cafe2a2f0ad8c16ae8e1dd5184822a16c50139f8838d9"
"checksum opaque-debug 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)" = "93f5bb2e8e8dec81642920ccff6b61f1eb94fa3020c5a325c9851ff604152409"
"checksum num_cpus 1.9.0 (registry+https://github.com/rust-lang/crates.io-index)" = "5a69d464bdc213aaaff628444e99578ede64e9c854025aa43b9796530afa9238"
"checksum num_cpus 1.10.0 (registry+https://github.com/rust-lang/crates.io-index)" = "1a23f0ed30a54abaa0c7e83b1d2d87ada7c3c23078d1d87815af3e3b6385fbba"
"checksum numtoa 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)" = "b8f8bdf33df195859076e54ab11ee78a1b208382d3a26ec40d142ffc1ecc49ef"
"checksum num_cpus 1.10.0 (registry+https://github.com/rust-lang/crates.io-index)" = "1a23f0ed30a54abaa0c7e83b1d2d87ada7c3c23078d1d87815af3e3b6385fbba"
"checksum opaque-debug 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)" = "93f5bb2e8e8dec81642920ccff6b61f1eb94fa3020c5a325c9851ff604152409"
"checksum openssl 0.10.20 (registry+https://github.com/rust-lang/crates.io-index)" = "5a0d6b781aac4ac1bd6cafe2a2f0ad8c16ae8e1dd5184822a16c50139f8838d9"
"checksum new_debug_unreachable 1.0.3 (registry+https://github.com/rust-lang/crates.io-index)" = "f40f005c60db6e03bae699e414c58bf9aa7ea02a2d0b9bfbcf19286cc4c82b30"
"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 num-integer 0.1.41 (registry+https://github.com/rust-lang/crates.io-index)" = "b85e541ef8255f6cf42bbfe4ef361305c6c135d10919ecc26126c4e5ae94bc09"
"checksum num-traits 0.2.8 (registry+https://github.com/rust-lang/crates.io-index)" = "6ba9a427cfca2be13aa6f6403b0b7e7368fe982bfa16fccc450ce74c46cd9b32"
"checksum num_cpus 1.10.1 (registry+https://github.com/rust-lang/crates.io-index)" = "bcef43580c035376c0705c42792c294b66974abbfd2789b511784023f71f3273"
"checksum numtoa 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)" = "b8f8bdf33df195859076e54ab11ee78a1b208382d3a26ec40d142ffc1ecc49ef"
"checksum nodrop 0.1.13 (registry+https://github.com/rust-lang/crates.io-index)" = "2f9667ddcc6cc8a43afc9b7917599d7216aa09c463919ea32c59ed6cac8bc945"
"checksum new_debug_unreachable 1.0.1 (registry+https://github.com/rust-lang/crates.io-index)" = "0cdc457076c78ab54d5e0d6fa7c47981757f1e34dc39ff92787f217dede586c4"
"checksum new_debug_unreachable 1.0.3 (registry+https://github.com/rust-lang/crates.io-index)" = "f40f005c60db6e03bae699e414c58bf9aa7ea02a2d0b9bfbcf19286cc4c82b30"
"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 core-foundation 0.6.4 (registry+https://github.com/rust-lang/crates.io-index)" = "25b9e03f145fd4f2bf705e07b900cd41fc636598fe5dc452fd0db1441c3f496d"
"checksum core-foundation-sys 0.6.2 (registry+https://github.com/rust-lang/crates.io-index)" = "e7ca8a5221364ef15ce201e8ed2f609fc312682a8f4e0e3d4aa5879764e0fa3b"
"checksum arc-swap 0.3.11 (registry+https://github.com/rust-lang/crates.io-index)" = "bc4662175ead9cd84451d5c35070517777949a2ed84551764129cedb88384841"
"checksum atty 0.2.11 (registry+https://github.com/rust-lang/crates.io-index)" = "9a7d5b8723950951411ee34d271d99dddcc2035a16ab25310ea2c8cfd4369652"
"checksum winapi 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)" = "92c1eb33641e276cfa214a0522acad57be5c56b10cb348b3c5117db75f3ac4b0"
"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 syn 0.15.27 (registry+https://github.com/rust-lang/crates.io-index)" = "525bd55255f03c816e5d7f615587bd13030c7103354fadb104993dcee6a788ec"
"checksum redox_syscall 0.1.51 (registry+https://github.com/rust-lang/crates.io-index)" = "423e376fffca3dfa06c9e9790a9ccd282fafb3cc6e6397d01dbf64f9bacc6b85"
"checksum proc-macro2 0.4.27 (registry+https://github.com/rust-lang/crates.io-index)" = "4d317f9caece796be1980837fd5cb3dfec5613ebdb04ad0956deea83ce168915"
"checksum openssl-sys 0.9.42 (registry+https://github.com/rust-lang/crates.io-index)" = "cb534d752bf98cf363b473950659ac2546517f9c6be9723771614ab3f03bbc9e"
"checksum native-tls 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)" = "ff8e08de0070bbf4c31f452ea2a70db092f36f6f2e4d897adf5674477d488fb2"
"checksum futures 0.1.25 (registry+https://github.com/rust-lang/crates.io-index)" = "49e7653e374fe0d0c12de4250f0bdb60680b8c80eed558c5c7538eec9c89e21b"
"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 arc-swap 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)" = "1025aeae2b664ca0ea726a89d574fe8f4e77dd712d443236ad1de00379450cf6"
"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 syn 0.15.30 (registry+https://github.com/rust-lang/crates.io-index)" = "66c8865bf5a7cbb662d8b011950060b3c8743dca141b054bf7195b20d314d8e2"
"checksum arc-swap 0.3.10 (registry+https://github.com/rust-lang/crates.io-index)" = "a57a5698f85c6fd92f19dad87ff2d822fc4ba79dd85c13914d8c4dad589cb815"
"checksum utf8-ranges 1.0.2 (registry+https://github.com/rust-lang/crates.io-index)" = "796f7e48bef87609f7ade7e06495a87d5cd06c7866e6a5cbfceffc558a243737"
"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 syn 0.15.30 (registry+https://github.com/rust-lang/crates.io-index)" = "66c8865bf5a7cbb662d8b011950060b3c8743dca141b054bf7195b20d314d8e2"
"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 proc-macro2 0.4.27 (registry+https://github.com/rust-lang/crates.io-index)" = "4d317f9caece796be1980837fd5cb3dfec5613ebdb04ad0956deea83ce168915"
"checksum openssl-sys 0.9.43 (registry+https://github.com/rust-lang/crates.io-index)" = "33c86834957dd5b915623e94f2f4ab2c70dd8f6b70679824155d5ae21dbd495d"
"checksum native-tls 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)" = "ff8e08de0070bbf4c31f452ea2a70db092f36f6f2e4d897adf5674477d488fb2"
"checksum futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)" = "62941eff9507c8177d448bd83a44d9b9760856e184081d8cd79ba9f03dd24981"
"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 byteorder 1.3.1 (registry+https://github.com/rust-lang/crates.io-index)" = "a019b10a2a7cdeb292db131fc8113e57ea2a908f6e7894b0c3c671893b65dbeb"
"checksum bitflags 1.0.4 (registry+https://github.com/rust-lang/crates.io-index)" = "228047a76f468627ca71776ecdebd732a3423081fcf5125585bcd7c49886ce12"
"checksum arc-swap 0.3.10 (registry+https://github.com/rust-lang/crates.io-index)" = "a57a5698f85c6fd92f19dad87ff2d822fc4ba79dd85c13914d8c4dad589cb815"
"checksum MacTypes-sys 2.1.0 (registry+https://github.com/rust-lang/crates.io-index)" = "eaf9f0d0b1cc33a4d2aee14fb4b2eac03462ef4db29c8ac4057327d8a71ad86f"
"checksum xml5ever 0.12.1 (registry+https://github.com/rust-lang/crates.io-index)" = "32cd7ebf0203c620906230ce22caa5df0b603c32b6fef72a275a48f6a2ae64b9"
"checksum xmpp-parsers 0.12.2 (registry+https://github.com/rust-lang/crates.io-index)" = "58b4400e1ae0d246044db5fa7f2e693fdfe9cc6e8eaa72ef2a68c5dc1d3c96de"
"checksum xmpp-parsers 0.13.1 (registry+https://github.com/rust-lang/crates.io-index)" = "5094cec449beca92f82ae4d7fe13cda058005849766d71b86c23e6217f61a357"
"checksum xmpp-parsers 0.13.1 (registry+https://github.com/rust-lang/crates.io-index)" = "5094cec449beca92f82ae4d7fe13cda058005849766d71b86c23e6217f61a357"
"checksum xmpp-parsers 0.13.1 (registry+https://github.com/rust-lang/crates.io-index)" = "5094cec449beca92f82ae4d7fe13cda058005849766d71b86c23e6217f61a357"
"checksum winapi-util 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)" = "7168bab6e1daee33b4557efd0e95d5ca70a03706d39fa5f3fe7a236f584b03c9"
"checksum winapi 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)" = "f10e386af2b13e47c89e7236a7a14a086791a2b88ebad6df9bf42040195cf770"
"checksum utf8-ranges 1.0.2 (registry+https://github.com/rust-lang/crates.io-index)" = "796f7e48bef87609f7ade7e06495a87d5cd06c7866e6a5cbfceffc558a243737"
"checksum utf-8 0.7.5 (registry+https://github.com/rust-lang/crates.io-index)" = "05e42f7c18b8f902290b009cde6d651262f956c98bc51bca4cd1d511c9cd85c7"
"checksum unicode-normalization 0.1.8 (registry+https://github.com/rust-lang/crates.io-index)" = "141339a08b982d942be2ca06ff8b076563cbe223d1befd5450716790d44e2426"
"checksum time 0.1.42 (registry+https://github.com/rust-lang/crates.io-index)" = "db8dcfca086c1143c9270ac42a2bbd8a7ee477b78ac8e45b19abfb0cbede4b6f"
"checksum tendril 0.4.1 (registry+https://github.com/rust-lang/crates.io-index)" = "707feda9f2582d5d680d733e38755547a3e8fb471e7ba11452ecfd9ce93a5d3b"
"checksum syn 0.15.30 (registry+https://github.com/rust-lang/crates.io-index)" = "66c8865bf5a7cbb662d8b011950060b3c8743dca141b054bf7195b20d314d8e2"
"checksum subtle 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)" = "2d67a5a62ba6e01cb2192ff309324cb4875d0c451d55fe2319433abe7a05a8ee"
"checksum smallvec 0.6.9 (registry+https://github.com/rust-lang/crates.io-index)" = "c4488ae950c49d403731982257768f48fada354a5203fe81f9bb6f43ca9002be"
"checksum slab 0.4.2 (registry+https://github.com/rust-lang/crates.io-index)" = "c111b5bd5695e56cffe5129854aa230b39c93a305372fdbb2668ca2394eea9f8"
"checksum schannel 0.1.15 (registry+https://github.com/rust-lang/crates.io-index)" = "f2f6abf258d99c3c1c5c2131d99d064e94b7b3dd5f416483057f308fea253339"
"checksum sasl 0.4.3 (registry+https://github.com/rust-lang/crates.io-index)" = "e457758c85b736bbad56dc099406cd2a9c19554cf81880dba7a51d092929e600"
"checksum redox_syscall 0.1.54 (registry+https://github.com/rust-lang/crates.io-index)" = "12229c14a0f65c4f1cb046a3b52047cdd9da1f4b30f8a39c5063c8bae515e252"
"checksum rdrand 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)" = "678054eb77286b51581ba43620cc911abf02758c91f93f479767aed0f90458b2"
"checksum rand_xorshift 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "cbf7e9e623549b0e21f6e97cf8ecf247c1a8fd2e8a992ae265314300b2455d5c"
"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_os 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)" = "b7c690732391ae0abafced5015ffb53656abfaec61b342290e5eb56b286a679d"
"checksum rand_os 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)" = "7b75f676a1e053fc562eafbb47838d67c84801e38fc1ba459e8f180deabd5071"
"checksum rand_pcg 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)" = "abf9b09b01790cfe0364f52bf32995ea3c39f4d2dd011eac241d2914146d0b44"
"checksum rand_os 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)" = "b7c690732391ae0abafced5015ffb53656abfaec61b342290e5eb56b286a679d"
"checksum rand_pcg 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "086bd09a33c7044e56bb44d5bdde5a60e7f119a9e95b0775f545de759a32fe05"
"checksum rand_os 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)" = "7b75f676a1e053fc562eafbb47838d67c84801e38fc1ba459e8f180deabd5071"
"checksum rand_pcg 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)" = "abf9b09b01790cfe0364f52bf32995ea3c39f4d2dd011eac241d2914146d0b44"
"checksum rand_jitter 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)" = "7b9ea758282efe12823e0d952ddb269d2e1897227e464919a554f2a03ef1b832"
"checksum rand_jitter 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)" = "7b9ea758282efe12823e0d952ddb269d2e1897227e464919a554f2a03ef1b832"
"checksum rand_jitter 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)" = "1166d5c91dc97b88d1decc3285bb0a99ed84b05cfd0bc2341bdf2d43fc41e39b"
"checksum rand_core 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)" = "7a6fdeb83b075e8266dcc8762c22776f6877a63111121f5f8c7411e5be7eed4b"
"checksum proc-macro2 0.4.27 (registry+https://github.com/rust-lang/crates.io-index)" = "4d317f9caece796be1980837fd5cb3dfec5613ebdb04ad0956deea83ce168915"
"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 pbkdf2 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)" = "006c038a43a45995a9670da19e67600114740e8511d4333bf97a56e66a7542d9"
"checksum pkg-config 0.3.14 (registry+https://github.com/rust-lang/crates.io-index)" = "676e8eb2b1b4c9043511a9b7bea0915320d7e502b0a079fb03f9635a5252b18c"
"checksum openssl-sys 0.9.43 (registry+https://github.com/rust-lang/crates.io-index)" = "33c86834957dd5b915623e94f2f4ab2c70dd8f6b70679824155d5ae21dbd495d"
"checksum owning_ref 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)" = "49a4b8ea2179e6a2e27411d3bca09ca6dd630821cf6894c6c7c8467a8ee7ef13"
"checksum parking_lot 0.7.1 (registry+https://github.com/rust-lang/crates.io-index)" = "ab41b4aed082705d1056416ae4468b6ea99d52599ecf3169b00088d43113e337"
"checksum parking_lot_core 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)" = "94c8c7923936b28d546dfd14d4472eaf34c99b14e1c973a32b3e6d4eb04298c9"
"checksum memchr 2.2.0 (registry+https://github.com/rust-lang/crates.io-index)" = "2efc7bc57c883d4a4d6e3246905283d8dae951bb3bd32f49d6ef297f546e1c39"
"checksum markup5ever 0.7.5 (registry+https://github.com/rust-lang/crates.io-index)" = "897636f9850c3eef4905a5540683ed53dc9393860f0846cab2c2ddf9939862ff"
"checksum lazy_static 1.3.0 (registry+https://github.com/rust-lang/crates.io-index)" = "bc5729f27f159ddd61f4df6228e827e86643d4d3e7c32183cb30a1c08f604a14"
"checksum libc 0.2.53 (registry+https://github.com/rust-lang/crates.io-index)" = "ec350a9417dfd244dc9a6c4a71e13895a4db6b92f0b106f07ebbc3f3bc580cee"
"checksum lru-cache 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "4d06ff7ff06f729ce5f4e227876cb88d10bc59cd4ae1e09fbb2bde15c850dc21"
"checksum lru-cache 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)" = "31e24f1ad8321ca0e8a1e0ac13f23cb668e6f5466c2c57319f6a5cf1cc8e3b1c"
"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 lru-cache 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)" = "31e24f1ad8321ca0e8a1e0ac13f23cb668e6f5466c2c57319f6a5cf1cc8e3b1c"
"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 libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)" = "bedcc7a809076656486ffe045abeeac163da1b558e963a31e29fbfbeba916917"
"checksum linked-hash-map 0.5.2 (registry+https://github.com/rust-lang/crates.io-index)" = "ae91b68aebc4ddb91978b11a1b02ddd8602a05ec19002801c5666000e05e0f83"
"checksum libc 0.2.48 (registry+https://github.com/rust-lang/crates.io-index)" = "e962c7641008ac010fa60a7dfdc1712449f29c44ef2d4702394aea943ee75047"
"checksum linked-hash-map 0.4.2 (registry+https://github.com/rust-lang/crates.io-index)" = "7860ec297f7008ff7a1e3382d7f7e1dcd69efc94751a2284bafc3d013c2aa939"
"checksum libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)" = "bedcc7a809076656486ffe045abeeac163da1b558e963a31e29fbfbeba916917"
"checksum linked-hash-map 0.5.2 (registry+https://github.com/rust-lang/crates.io-index)" = "ae91b68aebc4ddb91978b11a1b02ddd8602a05ec19002801c5666000e05e0f83"
"checksum lazycell 1.2.1 (registry+https://github.com/rust-lang/crates.io-index)" = "b294d6fa9ee409a054354afc4352b0b9ef7ca222c69b8812cbea9e7d2bf3783f"
"checksum futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)" = "62941eff9507c8177d448bd83a44d9b9760856e184081d8cd79ba9f03dd24981"
"checksum fuchsia-cprng 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "a06f77d526c1a601b7c4cdd98f54b5eaabffc14d5f2f0296febdc7f357c6d3ba"
"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 crypto-mac 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)" = "4434400df11d95d556bac068ddfedd482915eb18fe8bea89bc80b6e4b1c179e5"
"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 bytes 0.4.12 (registry+https://github.com/rust-lang/crates.io-index)" = "206fdffcfa2df7cbe15601ef46c813fce0965eb3286db6b56c583b814b51c81c"
"checksum bytes 0.4.11 (registry+https://github.com/rust-lang/crates.io-index)" = "40ade3d27603c2cb345eb0912aec461a6dec7e06a4ae48589904e808335c7afa"
"checksum bytes 0.4.12 (registry+https://github.com/rust-lang/crates.io-index)" = "206fdffcfa2df7cbe15601ef46c813fce0965eb3286db6b56c583b814b51c81c"
"checksum byte-tools 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)" = "e3b5ca7a04898ad4bcd41c90c5285445ff5b791899bb1b0abdd2a2aa791211d7"
"checksum bytes 0.4.12 (registry+https://github.com/rust-lang/crates.io-index)" = "206fdffcfa2df7cbe15601ef46c813fce0965eb3286db6b56c583b814b51c81c"
"checksum blake2 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)" = "91721a6330935673395a0607df4d49a9cb90ae12d259f1b3e0a3f6e1d486872e"
"checksum base64 0.10.1 (registry+https://github.com/rust-lang/crates.io-index)" = "0b25d992356d2eb0ed82172f5248873db5560c4721f564b13cb5193bda5e668e"
"checksum arc-swap 0.3.10 (registry+https://github.com/rust-lang/crates.io-index)" = "a57a5698f85c6fd92f19dad87ff2d822fc4ba79dd85c13914d8c4dad589cb815"
"checksum arrayvec 0.4.10 (registry+https://github.com/rust-lang/crates.io-index)" = "92c7fb76bc8826a8b33b4ee5bb07a247a81e76764ab4d55e8f73e3a4d8808c71"
"checksum MacTypes-sys 2.1.0 (registry+https://github.com/rust-lang/crates.io-index)" = "eaf9f0d0b1cc33a4d2aee14fb4b2eac03462ef4db29c8ac4057327d8a71ad86f"
"checksum aho-corasick 0.7.3 (registry+https://github.com/rust-lang/crates.io-index)" = "e6f484ae0c99fec2e858eb6134949117399f222608d84cadb3f58c1f97c2364c"
"checksum aho-corasick 0.6.9 (registry+https://github.com/rust-lang/crates.io-index)" = "1e9a933f4e58658d7b12defcf96dc5c720f20832deebe3e0a19efd3b6aaeeb9e"
"checksum aho-corasick 0.7.3 (registry+https://github.com/rust-lang/crates.io-index)" = "e6f484ae0c99fec2e858eb6134949117399f222608d84cadb3f58c1f97c2364c"
"checksum winapi 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)" = "92c1eb33641e276cfa214a0522acad57be5c56b10cb348b3c5117db75f3ac4b0"
"checksum syn 0.15.26 (registry+https://github.com/rust-lang/crates.io-index)" = "f92e629aa1d9c827b2bb8297046c1ccffc57c99b947a680d3ccff1f136a3bee9"
"checksum smallvec 0.6.8 (registry+https://github.com/rust-lang/crates.io-index)" = "88aea073965ab29f6edb5493faf96ad662fb18aa9eeb186a3b7057951605ed15"
"checksum schannel 0.1.14 (registry+https://github.com/rust-lang/crates.io-index)" = "0e1a231dc10abf6749cfa5d7767f25888d484201accbd919b66ab5413c502d56"
"checksum redox_syscall 0.1.51 (registry+https://github.com/rust-lang/crates.io-index)" = "423e376fffca3dfa06c9e9790a9ccd282fafb3cc6e6397d01dbf64f9bacc6b85"
"checksum openssl-sys 0.9.40 (registry+https://github.com/rust-lang/crates.io-index)" = "1bb974e77de925ef426b6bc82fce15fd45bdcbeb5728bffcfc7cdeeb7ce1c2d6"
"checksum memchr 2.1.3 (registry+https://github.com/rust-lang/crates.io-index)" = "e1dd4eaac298c32ce07eb6ed9242eda7d82955b9170b7d6db59b2e02cc63fcb8"
"checksum lazy_static 1.2.0 (registry+https://github.com/rust-lang/crates.io-index)" = "a374c89b9db55895453a74c1e38861d9deec0b01b405a82516e9d5de4820dea1"
"checksum futures 0.1.25 (registry+https://github.com/rust-lang/crates.io-index)" = "49e7653e374fe0d0c12de4250f0bdb60680b8c80eed558c5c7538eec9c89e21b"
"checksum arc-swap 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)" = "1025aeae2b664ca0ea726a89d574fe8f4e77dd712d443236ad1de00379450cf6"
"checksum xml5ever 0.16.1 (registry+https://github.com/rust-lang/crates.io-index)" = "0b1b52e6e8614d4a58b8e70cf51ec0cc21b256ad8206708bcff8139b5bbd6a59"
"checksum xmpp-parsers 0.17.0 (git+https://gitlab.com/xmpp-rs/xmpp-rs)" = "<none>"
"checksum winreg 0.6.2 (registry+https://github.com/rust-lang/crates.io-index)" = "b2986deb581c4fe11b621998a5e53361efe6b48a151178d0cd9eeffa4dc6acc9"
"checksum winapi-util 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)" = "70ec6ce85bb158151cae5e5c87f95a8e97d2c0c4b001223f33a334e3ce5de178"
"checksum winapi 0.3.9 (registry+https://github.com/rust-lang/crates.io-index)" = "5c839a674fcd7a98952e593242ea400abe93992746761e38641405d28b00f419"
"checksum vcpkg 0.2.10 (registry+https://github.com/rust-lang/crates.io-index)" = "6454029bf181f092ad1b853286f23e2c507d8e8194d01d92da4a55c274a5508c"
"checksum vec_map 0.8.2 (registry+https://github.com/rust-lang/crates.io-index)" = "f1bddf1187be692e79c5ffeab891132dfb0f236ed36a43c7ed39f1165ee20191"
"checksum want 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)" = "1ce8a968cb1cd110d136ff8b819a556d6fb6d919363c61534f6860c7eb172ba0"
"checksum wasi 0.10.0+wasi-snapshot-preview1 (registry+https://github.com/rust-lang/crates.io-index)" = "1a143597ca7c7793eff794def352d41792a93c481eb1042423ff7ff72ba2c31f"
"checksum wasi 0.9.0+wasi-snapshot-preview1 (registry+https://github.com/rust-lang/crates.io-index)" = "cccddf32554fecc6acb585f82a32a72e28b48f8c4c1883ddfeeeaa96f7d8e519"
"checksum widestring 0.4.2 (registry+https://github.com/rust-lang/crates.io-index)" = "a763e303c0e0f23b0da40888724762e802a8ffefbc22de4127ef42493c2ea68c"
"checksum unicode-normalization 0.1.13 (registry+https://github.com/rust-lang/crates.io-index)" = "6fb19cf769fa8c6a80a162df694621ebeb4dafb606470b2b2fce0be40a98a977"
"checksum unicode-segmentation 1.6.0 (registry+https://github.com/rust-lang/crates.io-index)" = "e83e153d1053cbb5a118eeff7fd5be06ed99153f00dbcd8ae310c5fb2b22edc0"
"checksum unicode-width 0.1.8 (registry+https://github.com/rust-lang/crates.io-index)" = "9337591893a19b88d8d87f2cec1e73fad5cdfd10e5a6f349f498ad6ea2ffb1e3"
"checksum unicode-xid 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)" = "f7fe0bb3479651439c9112f72b6c505038574c9fbb575ed1bf3b797fa39dd564"
"checksum url 2.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "829d4a8476c35c9bf0bbce5a3b23f4106f79728039b726d292bb93bc106787cb"
"checksum thiserror 1.0.20 (registry+https://github.com/rust-lang/crates.io-index)" = "7dfdd070ccd8ccb78f4ad66bf1982dc37f620ef696c6b5028fe2ed83dd3d0d08"
"checksum thiserror-impl 1.0.20 (registry+https://github.com/rust-lang/crates.io-index)" = "bd80fc12f73063ac132ac92aceea36734f04a1d93c1240c6944e23a3b8841793"
"checksum thread_local 1.0.1 (registry+https://github.com/rust-lang/crates.io-index)" = "d40c6d1b69745a6ec6fb1ca717914848da4b44ae29d9b3080cbee91d72a69b14"
"checksum time 0.1.44 (registry+https://github.com/rust-lang/crates.io-index)" = "6db9e6914ab8b1ae1c260a4ae7a49b6c5611b40328a735b21862567685e73255"
"checksum tinyvec 0.3.4 (registry+https://github.com/rust-lang/crates.io-index)" = "238ce071d267c5710f9d31451efec16c5ee22de34df17cc05e56cbc92e967117"
"checksum tokio 0.2.22 (registry+https://github.com/rust-lang/crates.io-index)" = "5d34ca54d84bf2b5b4d7d31e901a8464f7b60ac145a284fba25ceb801f2ddccd"
"checksum tokio-macros 0.2.5 (registry+https://github.com/rust-lang/crates.io-index)" = "f0c3acc6aa564495a0f2e1d59fab677cd7f81a19994cfc7f3ad0e64301560389"
"checksum tokio-tls 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)" = "9a70f4fcd7b3b24fb194f837560168208f669ca8cb70d0c4b862944452396343"
"checksum tokio-util 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)" = "571da51182ec208780505a32528fc5512a8fe1443ab960b3f2f3ef093cd16930"
"checksum tokio-util 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)" = "be8242891f2b6cbef26a2d7e8605133c2c554cd35b3e4948ea892d6d68436499"
"checksum tokio-xmpp 2.0.0 (git+https://gitlab.com/xmpp-rs/xmpp-rs)" = "<none>"
"checksum toml 0.5.6 (registry+https://github.com/rust-lang/crates.io-index)" = "ffc92d160b1eef40665be3a05630d003936a3bc7da7421277846c2613e92c71a"
"checksum tower-service 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)" = "e987b6bf443f4b5b3b6f38704195592cca41c5bb7aedd3c3693c7081f8289860"
"checksum tracing 0.1.19 (registry+https://github.com/rust-lang/crates.io-index)" = "6d79ca061b032d6ce30c660fded31189ca0b9922bf483cd70759f13a2d86786c"
"checksum tracing-core 0.1.15 (registry+https://github.com/rust-lang/crates.io-index)" = "4f0e00789804e99b20f12bc7003ca416309d28a6f495d6af58d1e2c2842461b5"
"checksum trust-dns-proto 0.19.5 (registry+https://github.com/rust-lang/crates.io-index)" = "cdd7061ba6f4d4d9721afedffbfd403f20f39a4301fee1b70d6fcd09cca69f28"
"checksum trust-dns-resolver 0.19.5 (registry+https://github.com/rust-lang/crates.io-index)" = "0f23cdfdc3d8300b3c50c9e84302d3bd6d860fb9529af84ace6cf9665f181b77"
"checksum try-lock 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)" = "59547bce71d9c38b83d9c0e92b6066c4253371f15005def0c30d9657f50c7642"
"checksum typenum 1.12.0 (registry+https://github.com/rust-lang/crates.io-index)" = "373c8a200f9e67a0c95e62a4f52fbf80c23b4381c05a17845531982fa99e6b33"
"checksum termcolor 1.1.0 (registry+https://github.com/rust-lang/crates.io-index)" = "bb6bfa289a4d7c5766392812c0a1f4c1ba45afa1ad47803c11e1f407d846d75f"
"checksum syn 1.0.40 (registry+https://github.com/rust-lang/crates.io-index)" = "963f7d3cc59b59b9325165add223142bbf1df27655d07789f109896d353d8350"
"checksum synstructure 0.12.4 (registry+https://github.com/rust-lang/crates.io-index)" = "b834f2d66f734cb897113e34aaff2f1ab4719ca946f9a7358dba8f8064148701"
"checksum tempfile 3.1.0 (registry+https://github.com/rust-lang/crates.io-index)" = "7a6e24d9338a0a5be79593e2fa15a648add6138caa803e2d5bc782c371732ca9"
"checksum smallvec 1.4.2 (registry+https://github.com/rust-lang/crates.io-index)" = "fbee7696b84bbf3d89a1c2eccff0850e3047ed46bfcd2e92c29a2d074d57e252"
"checksum socket2 0.3.12 (registry+https://github.com/rust-lang/crates.io-index)" = "03088793f677dce356f3ccc2edb1b314ad191ab702a5de3faf49304f7e104918"
"checksum string_cache 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)" = "2940c75beb4e3bf3a494cef919a747a2cb81e52571e212bfbd185074add7208a"
"checksum string_cache_codegen 0.5.1 (registry+https://github.com/rust-lang/crates.io-index)" = "f24c8e5e19d22a726626f1a5e16fe15b132dcf21d10177fa5a45ce7962996b97"
"checksum schannel 0.1.19 (registry+https://github.com/rust-lang/crates.io-index)" = "8f05ba609c234e60bee0d547fe94a4c7e9da733d1c962cf6e59efa4cd9c8bc75"
"checksum security-framework 0.4.4 (registry+https://github.com/rust-lang/crates.io-index)" = "64808902d7d99f78eaddd2b4e2509713babc3dc3c85ad6f4c447680f3c01e535"
"checksum security-framework-sys 0.4.3 (registry+https://github.com/rust-lang/crates.io-index)" = "17bf11d99252f512695eb468de5516e5cf75455521e69dfe343f3b74e4748405"
"checksum serde 1.0.115 (registry+https://github.com/rust-lang/crates.io-index)" = "e54c9a88f2da7238af84b5101443f0c0d0a3bbdc455e34a5c9497b1903ed55d5"
"checksum serde_derive 1.0.115 (registry+https://github.com/rust-lang/crates.io-index)" = "609feed1d0a73cc36a0182a840a9b37b4a82f0b1150369f0536a9e3f2a31dc48"
"checksum serde_json 1.0.57 (registry+https://github.com/rust-lang/crates.io-index)" = "164eacbdb13512ec2745fb09d51fd5b22b0d65ed294a1dcf7285a360c80a675c"
"checksum sha-1 0.8.2 (registry+https://github.com/rust-lang/crates.io-index)" = "f7d94d0bede923b3cea61f3f1ff57ff8cdfd77b400fb8f9998949e0cf04163df"
"checksum sha2 0.8.2 (registry+https://github.com/rust-lang/crates.io-index)" = "a256f46ea78a0c0d9ff00077504903ac881a1dafdc20da66545699e7776b3e69"
"checksum sha3 0.8.2 (registry+https://github.com/rust-lang/crates.io-index)" = "dd26bc0e7a2e3a7c959bc494caf58b72ee0c71d67704e9520f736ca7e4853ecf"
"checksum signal-hook-registry 1.2.1 (registry+https://github.com/rust-lang/crates.io-index)" = "a3e12110bc539e657a646068aaf5eb5b63af9d0c1f7b29c97113fad80e15f035"
"checksum siphasher 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)" = "fa8f3741c7372e75519bd9346068370c9cdaabcc1f9599cbcf2a2719352286b7"
"checksum redox_syscall 0.1.57 (registry+https://github.com/rust-lang/crates.io-index)" = "41cc0f7e4d5d4544e8861606a285bb08d3e70712ccc7d2b84d7c0ccfaf4b05ce"
"checksum regex 1.3.9 (registry+https://github.com/rust-lang/crates.io-index)" = "9c3780fcf44b193bc4d09f36d2a3c87b251da4a046c87795a0d35f4f927ad8e6"
"checksum regex-syntax 0.6.18 (registry+https://github.com/rust-lang/crates.io-index)" = "26412eb97c6b088a6997e05f69403a802a92d520de2f8e63c2b65f9e0f47c4e8"
"checksum remove_dir_all 0.5.3 (registry+https://github.com/rust-lang/crates.io-index)" = "3acd125665422973a33ac9d3dd2df85edad0f4ae9b00dafb1a05e43a9f5ef8e7"
"checksum resolv-conf 0.6.3 (registry+https://github.com/rust-lang/crates.io-index)" = "11834e137f3b14e309437a8276714eed3a80d1ef894869e510f2c0c0b98b9f4a"
"checksum rustc-demangle 0.1.16 (registry+https://github.com/rust-lang/crates.io-index)" = "4c691c0e608126e00913e33f0ccf3727d5fc84573623b8d65b2df340b5201783"
"checksum ryu 1.0.5 (registry+https://github.com/rust-lang/crates.io-index)" = "71d301d4193d031abdd79ff7e3dd721168a9572ef3fe51a1517aba235bd8f86e"
"checksum rand_pcg 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)" = "16abd0c1b639e9eb4d7c50c0b8100b0d0f849be2349829c740fe8e6eb4816429"
"checksum rand_core 0.4.2 (registry+https://github.com/rust-lang/crates.io-index)" = "9c33a3c44ca05fa6f1807d8e6743f3824e8509beca625669633be0acbdf509dc"
"checksum rand_core 0.5.1 (registry+https://github.com/rust-lang/crates.io-index)" = "90bde5296fc891b0cef12a6d03ddccc162ce7b2aff54160af9338f8d40df6d19"
"checksum rand_hc 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)" = "ca3129af7b92a17112d59ad498c6f81eaf463253766b90396d39ea7a39d6613c"
"checksum proc-macro-hack 0.5.18 (registry+https://github.com/rust-lang/crates.io-index)" = "99c605b9a0adc77b7211c6b1f722dcb613d68d66859a44f3d485a6da332b0598"
"checksum proc-macro-nested 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)" = "eba180dafb9038b050a4c280019bbedf9f2467b61e5d892dcad585bb57aadc5a"
"checksum proc-macro2 1.0.20 (registry+https://github.com/rust-lang/crates.io-index)" = "175c513d55719db99da20232b06cda8bab6b83ec2d04e3283edf0213c37c1a29"
"checksum quick-error 1.2.3 (registry+https://github.com/rust-lang/crates.io-index)" = "a1d01941d82fa2ab50be1e79e6714289dd7cde78eba4c074bc5a4374f650dfe0"
"checksum quick-xml 0.18.1 (registry+https://github.com/rust-lang/crates.io-index)" = "3cc440ee4802a86e357165021e3e255a9143724da31db1e2ea540214c96a0f82"
"checksum quote 1.0.7 (registry+https://github.com/rust-lang/crates.io-index)" = "aa563d17ecb180e500da1cfd2b028310ac758de548efdd203e18f283af693f37"
"checksum rand 0.7.3 (registry+https://github.com/rust-lang/crates.io-index)" = "6a6b1679d49b24bbfe0c803429aa1874472f50d9b363131f0e89fc356b544d03"
"checksum rand_chacha 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)" = "f4c8ed856279c9737206bf725bf36935d8666ead7aa69b52be55af369d193402"
"checksum percent-encoding 2.1.0 (registry+https://github.com/rust-lang/crates.io-index)" = "d4fd5641d01c8f18a23da7b6fe29298ff4b55afcccdf78973b24cf3175fee32e"
"checksum phf 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)" = "3dfb61232e34fcb633f43d12c58f83c1df82962dcdfa565a4e866ffc17dafe12"
"checksum phf_codegen 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)" = "cbffee61585b0411840d3ece935cce9cb6321f01c45477d30066498cd5e1a815"
"checksum phf_generator 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)" = "17367f0cc86f2d25802b2c26ee58a7b23faeccf78a396094c13dced0d0182526"
"checksum phf_shared 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)" = "c00cf8b9eafe68dde5e9eaa2cef8ee84a9336a47d566ec55ca16589633b65af7"
"checksum pin-project 0.4.23 (registry+https://github.com/rust-lang/crates.io-index)" = "ca4433fff2ae79342e497d9f8ee990d174071408f28f726d6d83af93e58e48aa"
"checksum pin-project-internal 0.4.23 (registry+https://github.com/rust-lang/crates.io-index)" = "2c0e815c3ee9a031fdf5af21c10aa17c573c9c6a566328d99e3936c34e36461f"
"checksum pin-project-lite 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)" = "282adbf10f2698a7a77f8e983a74b2d18176c19a7fd32a45446139ae7b02b715"
"checksum pin-utils 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)" = "8b870d8c151b6f2fb93e84a13146138f05d02ed11c7e7c54f8826aaaf7c9f184"
"checksum pkg-config 0.3.18 (registry+https://github.com/rust-lang/crates.io-index)" = "d36492546b6af1463394d46f0c834346f31548646f6ba10849802c9c9a27ac33"
"checksum ppv-lite86 0.2.9 (registry+https://github.com/rust-lang/crates.io-index)" = "c36fa947111f5c62a733b652544dd0016a43ce89619538a8ef92724a6f501a20"
"checksum openssl-sys 0.9.58 (registry+https://github.com/rust-lang/crates.io-index)" = "a842db4709b604f0fe5d1170ae3565899be2ad3d9cbc72dedc789ac0511f78de"
"checksum native-tls 0.2.4 (registry+https://github.com/rust-lang/crates.io-index)" = "2b0d88c06fe90d5ee94048ba40409ef1d9315d86f6f38c2efdaad4fb50c58b2d"
"checksum net2 0.2.35 (registry+https://github.com/rust-lang/crates.io-index)" = "3ebc3ec692ed7c9a255596c67808dee269f64655d8baf7b4f0638e51ba1d6853"
"checksum new_debug_unreachable 1.0.4 (registry+https://github.com/rust-lang/crates.io-index)" = "e4a24736216ec316047a1fc4252e27dabb04218aa4a3f37c6e7ddbf1f9782b54"
"checksum num-integer 0.1.43 (registry+https://github.com/rust-lang/crates.io-index)" = "8d59457e662d541ba17869cf51cf177c0b5f0cbf476c66bdc90bf1edac4f875b"
"checksum num-traits 0.2.12 (registry+https://github.com/rust-lang/crates.io-index)" = "ac267bcc07f48ee5f8935ab0d24f316fb722d7a1292e2913f0cc196b29ffd611"
"checksum num_cpus 1.13.0 (registry+https://github.com/rust-lang/crates.io-index)" = "05499f3756671c15885fee9034446956fff3f243d6077b91e5767df161f766b3"
"checksum object 0.20.0 (registry+https://github.com/rust-lang/crates.io-index)" = "1ab52be62400ca80aa00285d25253d7f7c437b7375c4de678f5405d3afe82ca5"
"checksum once_cell 1.4.1 (registry+https://github.com/rust-lang/crates.io-index)" = "260e51e7efe62b592207e9e13a68e43692a7a279171d6ba57abd208bf23645ad"
"checksum opaque-debug 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)" = "2839e79665f131bdb5782e51f2c6c9599c133c6098982a54c794358bf432529c"
"checksum openssl 0.10.30 (registry+https://github.com/rust-lang/crates.io-index)" = "8d575eff3665419f9b83678ff2815858ad9d11567e082f5ac1814baba4e2bcb4"
"checksum memchr 2.3.3 (registry+https://github.com/rust-lang/crates.io-index)" = "3728d817d99e5ac407411fa471ff9800a778d88a24685968b36824eaf4bee400"
"checksum minidom 0.12.0 (git+https://gitlab.com/xmpp-rs/xmpp-rs)" = "<none>"
"checksum miniz_oxide 0.4.1 (registry+https://github.com/rust-lang/crates.io-index)" = "4d7559a8a40d0f97e1edea3220f698f78b1c5ab67532e49f68fde3910323b722"
"checksum mio 0.6.22 (registry+https://github.com/rust-lang/crates.io-index)" = "fce347092656428bc8eaf6201042cb551b8d67855af7374542a92a0fbfcac430"
"checksum mio-uds 0.6.8 (registry+https://github.com/rust-lang/crates.io-index)" = "afcb699eb26d4332647cc848492bbc15eafb26f08d0304550d5aa1f612e066f0"
"checksum markup5ever 0.10.0 (registry+https://github.com/rust-lang/crates.io-index)" = "aae38d669396ca9b707bfc3db254bc382ddb94f57cc5c235f34623a669a01dab"
"checksum match_cfg 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)" = "ffbee8634e0d45d258acb448e7eaab3fce7a0a467395d4d9f228e3c1f01fb2e4"
"checksum lazy_static 1.4.0 (registry+https://github.com/rust-lang/crates.io-index)" = "e2abad23fbc42b3700f2f279844dc832adb2b2eb069b2df918f455c4e18cc646"
"checksum libc 0.2.76 (registry+https://github.com/rust-lang/crates.io-index)" = "755456fae044e6fa1ebbbd1b3e902ae19e73097ed4ed87bb79934a867c007bc3"
"checksum linked-hash-map 0.5.3 (registry+https://github.com/rust-lang/crates.io-index)" = "8dd5a6d5999d9907cda8ed67bbd137d3af8085216c2ac62de5be860bd41f304a"
"checksum log 0.4.11 (registry+https://github.com/rust-lang/crates.io-index)" = "4fabed175da42fed1fa0746b0ea71f412aa9d35e76e95e59b192c64b9dc2bf8b"
"checksum futures 0.3.5 (registry+https://github.com/rust-lang/crates.io-index)" = "1e05b85ec287aac0dc34db7d4a569323df697f9c55b99b15d6b4ef8cde49f613"
"checksum futures-channel 0.3.5 (registry+https://github.com/rust-lang/crates.io-index)" = "f366ad74c28cca6ba456d95e6422883cfb4b252a83bed929c83abfdbbf2967d5"
"checksum futures-core 0.3.5 (registry+https://github.com/rust-lang/crates.io-index)" = "59f5fff90fd5d971f936ad674802482ba441b6f09ba5e15fd8b39145582ca399"
"checksum futures-executor 0.3.5 (registry+https://github.com/rust-lang/crates.io-index)" = "10d6bb888be1153d3abeb9006b11b02cf5e9b209fda28693c31ae1e4e012e314"
"checksum futures-io 0.3.5 (registry+https://github.com/rust-lang/crates.io-index)" = "de27142b013a8e869c14957e6d2edeef89e97c289e69d042ee3a49acd8b51789"
"checksum futures-macro 0.3.5 (registry+https://github.com/rust-lang/crates.io-index)" = "d0b5a30a4328ab5473878237c447333c093297bded83a4983d10f4deea240d39"
"checksum futures-sink 0.3.5 (registry+https://github.com/rust-lang/crates.io-index)" = "3f2032893cb734c7a05d85ce0cc8b8c4075278e93b24b66f9de99d6eb0fa8acc"
"checksum futures-task 0.3.5 (registry+https://github.com/rust-lang/crates.io-index)" = "bdb66b5f09e22019b1ab0830f7785bcea8e7a42148683f99214f73f8ec21a626"
"checksum futures-util 0.3.5 (registry+https://github.com/rust-lang/crates.io-index)" = "8764574ff08b701a084482c3c7031349104b07ac897393010494beaa18ce32c6"
"checksum generic-array 0.12.3 (registry+https://github.com/rust-lang/crates.io-index)" = "c68f0274ae0e023facc3c97b2e00f076be70e254bc851d972503b328db79b2ec"
"checksum getrandom 0.1.14 (registry+https://github.com/rust-lang/crates.io-index)" = "7abc8dd8451921606d809ba32e95b6111925cd2906060d2dcc29c070220503eb"
"checksum gimli 0.22.0 (registry+https://github.com/rust-lang/crates.io-index)" = "aaf91faf136cb47367fa430cd46e37a788775e7fa104f8b4bcb3861dc389b724"
"checksum h2 0.2.6 (registry+https://github.com/rust-lang/crates.io-index)" = "993f9e0baeed60001cf565546b0d3dbe6a6ad23f2bd31644a133c641eccf6d53"
"checksum hashbrown 0.9.0 (registry+https://github.com/rust-lang/crates.io-index)" = "00d63df3d41950fb462ed38308eea019113ad1508da725bbedcd0fa5a85ef5f7"
"checksum heck 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)" = "20564e78d53d2bb135c343b3f47714a56af2061f1c928fdb541dc7b9fdd94205"
"checksum hermit-abi 0.1.15 (registry+https://github.com/rust-lang/crates.io-index)" = "3deed196b6e7f9e44a2ae8d94225d80302d81208b1bb673fd21fe634645c85a9"
"checksum hmac 0.7.1 (registry+https://github.com/rust-lang/crates.io-index)" = "5dcb5e64cda4c23119ab41ba960d1e170a774c8e4b9d9e6a9bc18aabf5e59695"
"checksum hostname 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)" = "3c731c3e10504cc8ed35cfe2f1db4c9274c3d35fa486e3b31df46f068ef3e867"
"checksum http 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)" = "28d569972648b2c512421b5f2a405ad6ac9666547189d0c5477a3f200f3e02f9"
"checksum http-body 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)" = "13d5ff830006f7646652e057693569bfe0d51760c0085a071769d142a205111b"
"checksum httparse 1.3.4 (registry+https://github.com/rust-lang/crates.io-index)" = "cd179ae861f0c2e53da70d892f5f3029f9594be0c41dc5269cd371691b1dc2f9"
"checksum humantime 1.3.0 (registry+https://github.com/rust-lang/crates.io-index)" = "df004cfca50ef23c36850aaaa59ad52cc70d0e90243c3c7737a4dd32dc7a3c4f"
"checksum hyper 0.13.7 (registry+https://github.com/rust-lang/crates.io-index)" = "3e68a8dd9716185d9e64ea473ea6ef63529252e3e27623295a0378a19665d5eb"
"checksum idna 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)" = "02e2673c30ee86b5b96a9cb52ad15718aa1f966f5ab9ad54a8b95d5ca33120a9"
"checksum indexmap 1.6.0 (registry+https://github.com/rust-lang/crates.io-index)" = "55e2e4c765aa53a0424761bf9f41aa7a6ac1efa87238f59560640e27fca028f2"
"checksum iovec 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)" = "b2b3ea6ff95e175473f8ffe6a7eb7c00d054240321b84c57051175fe3c1e075e"
"checksum ipconfig 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)" = "f7e2f18aece9709094573a9f24f483c4f65caa4298e2f7ae1b71cc65d853fad7"
"checksum itoa 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)" = "dc6f3ad7b9d11a0c00842ff8de1b60ee58661048eb8049ed33c73594f359d7e6"
"checksum jid 0.9.0 (registry+https://github.com/rust-lang/crates.io-index)" = "3d9f987c3ff1c2c7d477c9e0a3dc25cc58ea97692b19a53018089109445b4ab3"
"checksum fnv 1.0.7 (registry+https://github.com/rust-lang/crates.io-index)" = "3f9eec918d3f24069decb9af1554cad7c880e2da24a9afd88aca000531ab82c1"
"checksum digest 0.8.1 (registry+https://github.com/rust-lang/crates.io-index)" = "f3d0c8c8752312f9713efd397ff63acb9f85585afbf179282e720e7704954dd5"
"checksum enum-as-inner 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)" = "7c5f0096a91d210159eceb2ff5e1c4da18388a170e1e3ce948aac9c8fdbbf595"
"checksum env_logger 0.7.1 (registry+https://github.com/rust-lang/crates.io-index)" = "44533bbbb3bb3c1fa17d9f2e4e38bbbaf8396ba82193c4cb1b6445d711445d36"
"checksum failure 0.1.8 (registry+https://github.com/rust-lang/crates.io-index)" = "d32e9bd16cc02eae7db7ef620b392808b89f6a5e16bb3497d159c6b92a0f4f86"
"checksum failure_derive 0.1.8 (registry+https://github.com/rust-lang/crates.io-index)" = "aa4da3c766cd7a0db8242e326e9e4e081edd567072893ed320008189715366a4"
"checksum core-foundation 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)" = "57d24c7a13c43e870e37c1556b74555437870a04514f7685f5b354e090567171"
"checksum core-foundation-sys 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)" = "b3a71ab494c0b5b860bdc8407ae08978052417070c2ced38573a9157ad75b8ac"
"checksum byteorder 1.3.4 (registry+https://github.com/rust-lang/crates.io-index)" = "08c48aae112d48ed9f069b33538ea9e3e90aa263cfa3d1c24309612b1f7472de"
"checksum bytes 0.5.6 (registry+https://github.com/rust-lang/crates.io-index)" = "0e4cec68f03f32e44924783795810fa50a7035d8c8ebe78580ad7e6c703fba38"
"checksum cc 1.0.59 (registry+https://github.com/rust-lang/crates.io-index)" = "66120af515773fb005778dc07c261bd201ec8ce50bd6e7144c927753fe013381"
"checksum cfg-if 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)" = "4785bdd1c96b2a846b2bd7cc02e86b6b3dbf14e7e53446c4f54c92a361040822"
"checksum chrono 0.4.15 (registry+https://github.com/rust-lang/crates.io-index)" = "942f72db697d8767c22d46a598e01f2d3b475501ea43d0db4f16d90259182d0b"
"checksum clap 2.33.3 (registry+https://github.com/rust-lang/crates.io-index)" = "37e58ac78573c40708d45522f0d80fa2f01cc4f9b4e2bf749807255454312002"
"checksum base64 0.12.3 (registry+https://github.com/rust-lang/crates.io-index)" = "3441f0f7b02788e948e47f457ca01f1d7e6d92c693bc132c22b087d3141c03ff"
"checksum bitflags 1.2.1 (registry+https://github.com/rust-lang/crates.io-index)" = "cf1de2fe8c75bc145a2f577add951f8134889b4795d47466a54a5c846d691693"
"checksum blake2 0.8.1 (registry+https://github.com/rust-lang/crates.io-index)" = "94cb07b0da6a73955f8fb85d24c466778e70cda767a568229b104f0264089330"
"checksum block-buffer 0.7.3 (registry+https://github.com/rust-lang/crates.io-index)" = "c0940dc441f31689269e10ac70eb1002a3a1d3ad1390e030043662eb7fe4688b"
"checksum block-padding 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)" = "fa79dedbb091f449f1f39e53edf88d5dbe95f895dae6135a8d7b881fb5af73f5"
"checksum arc-swap 0.4.7 (registry+https://github.com/rust-lang/crates.io-index)" = "4d25d88fd6b8041580a654f9d0c581a047baee2b3efee13275f2fc392fc75034"
"checksum async-trait 0.1.40 (registry+https://github.com/rust-lang/crates.io-index)" = "687c230d85c0a52504709705fc8a53e4a692b83a2184f03dae73e38e1e93a783"
"checksum atty 0.2.14 (registry+https://github.com/rust-lang/crates.io-index)" = "d9b39be18770d11421cdb1b9947a45dd3f37e93092cbf377614828a319d5fee8"
"checksum autocfg 1.0.1 (registry+https://github.com/rust-lang/crates.io-index)" = "cdb031dd78e28731d87d56cc8ffef4a8f36ca26c38fe2de700543e627f8a464a"
"checksum backtrace 0.3.50 (registry+https://github.com/rust-lang/crates.io-index)" = "46254cf2fdcdf1badb5934448c1bcbe046a56537b3987d96c51a7afc5d03f293"
"checksum addr2line 0.13.0 (registry+https://github.com/rust-lang/crates.io-index)" = "1b6a2d3371669ab3ca9797670853d61402b03d0b4b9ebf33d677dfa720203072"
"checksum adler 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)" = "ee2a4ec343196209d6594e19543ae87a39f96d5534d7174822a3ad825dd6ed7e"
"checksum aho-corasick 0.7.13 (registry+https://github.com/rust-lang/crates.io-index)" = "043164d8ba5c4c3035fec9bbee8647c0261d788f3474306f93bb65901cae0e86"
"checksum winapi 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)" = "f10e386af2b13e47c89e7236a7a14a086791a2b88ebad6df9bf42040195cf770"
"checksum utf8-ranges 1.0.3 (registry+https://github.com/rust-lang/crates.io-index)" = "9d50aa7650df78abf942826607c62468ce18d9019673d4a2ebe1865dbb96ffde"
"checksum textwrap 0.11.0 (registry+https://github.com/rust-lang/crates.io-index)" = "d326610f408c7a4eb6f51c37c330e496b08506c9457c9d34287ecc38809fb060"
"checksum termcolor 1.0.5 (registry+https://github.com/rust-lang/crates.io-index)" = "96d6098003bde162e4277c70665bd87c326f5a0c3f3fbfb285787fa482d54e6e"
"checksum termion 1.5.3 (registry+https://github.com/rust-lang/crates.io-index)" = "6a8fb22f7cde82c8220e5aeacb3258ed7ce996142c77cba193f203515e26c330"
"checksum syn 0.15.36 (registry+https://github.com/rust-lang/crates.io-index)" = "8b4f551a91e2e3848aeef8751d0d4eec9489b6474c720fd4c55958d8d31a430c"
"checksum strsim 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)" = "8ea5119cdb4c55b55d432abb513a0429384878c15dde60cc77b1c99de1a95a6a"
"checksum smallvec 0.6.10 (registry+https://github.com/rust-lang/crates.io-index)" = "ab606a9c5e214920bb66c458cd7be8ef094f813f20fe77a54cc7dbfff220d4b7"
"checksum socket2 0.3.9 (registry+https://github.com/rust-lang/crates.io-index)" = "4e626972d3593207547f14bf5fc9efa4d0e7283deb73fef1dff313dae9ab8878"
"checksum redox_syscall 0.1.54 (registry+https://github.com/rust-lang/crates.io-index)" = "12229c14a0f65c4f1cb046a3b52047cdd9da1f4b30f8a39c5063c8bae515e252"
"checksum rand_os 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)" = "7b75f676a1e053fc562eafbb47838d67c84801e38fc1ba459e8f180deabd5071"
"checksum proc-macro2 0.4.30 (registry+https://github.com/rust-lang/crates.io-index)" = "cf3d2011ab5c909338f7887f4fc896d35932e29146c12c8d01da6b22a80ba759"
"checksum openssl-sys 0.9.47 (registry+https://github.com/rust-lang/crates.io-index)" = "75bdd6dbbb4958d38e47a1d2348847ad1eb4dc205dc5d37473ae504391865acc"
"checksum native-tls 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)" = "4b2df1a4c22fd44a62147fd8f13dd0f95c9d8ca7b2610299b2a2f9cf8964274e"
"checksum lru-cache 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)" = "31e24f1ad8321ca0e8a1e0ac13f23cb668e6f5466c2c57319f6a5cf1cc8e3b1c"
"checksum futures 0.1.27 (registry+https://github.com/rust-lang/crates.io-index)" = "a2037ec1c6c1c4f79557762eab1f7eae1f64f6cb418ace90fae88f0942b60139"
"checksum core-foundation 0.6.4 (registry+https://github.com/rust-lang/crates.io-index)" = "25b9e03f145fd4f2bf705e07b900cd41fc636598fe5dc452fd0db1441c3f496d"
"checksum core-foundation-sys 0.6.2 (registry+https://github.com/rust-lang/crates.io-index)" = "e7ca8a5221364ef15ce201e8ed2f609fc312682a8f4e0e3d4aa5879764e0fa3b"
"checksum byteorder 1.3.2 (registry+https://github.com/rust-lang/crates.io-index)" = "a7c3dd8985a7111efc5c80b44e23ecdd8c007de8ade3b96595387e812b957cf5"
"checksum bitflags 1.1.0 (registry+https://github.com/rust-lang/crates.io-index)" = "3d155346769a6855b86399e9bc3814ab343cd3d62c7e985113d46a0ec3c281fd"
"checksum arc-swap 0.3.11 (registry+https://github.com/rust-lang/crates.io-index)" = "bc4662175ead9cd84451d5c35070517777949a2ed84551764129cedb88384841"
"checksum aho-corasick 0.7.3 (registry+https://github.com/rust-lang/crates.io-index)" = "e6f484ae0c99fec2e858eb6134949117399f222608d84cadb3f58c1f97c2364c"
"checksum winapi 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)" = "f10e386af2b13e47c89e7236a7a14a086791a2b88ebad6df9bf42040195cf770"
"checksum syn 0.15.30 (registry+https://github.com/rust-lang/crates.io-index)" = "66c8865bf5a7cbb662d8b011950060b3c8743dca141b054bf7195b20d314d8e2"
"checksum smallvec 0.6.9 (registry+https://github.com/rust-lang/crates.io-index)" = "c4488ae950c49d403731982257768f48fada354a5203fe81f9bb6f43ca9002be"
"checksum schannel 0.1.15 (registry+https://github.com/rust-lang/crates.io-index)" = "f2f6abf258d99c3c1c5c2131d99d064e94b7b3dd5f416483057f308fea253339"
"checksum redox_syscall 0.1.54 (registry+https://github.com/rust-lang/crates.io-index)" = "12229c14a0f65c4f1cb046a3b52047cdd9da1f4b30f8a39c5063c8bae515e252"
"checksum openssl-sys 0.9.43 (registry+https://github.com/rust-lang/crates.io-index)" = "33c86834957dd5b915623e94f2f4ab2c70dd8f6b70679824155d5ae21dbd495d"
"checksum memchr 2.2.0 (registry+https://github.com/rust-lang/crates.io-index)" = "2efc7bc57c883d4a4d6e3246905283d8dae951bb3bd32f49d6ef297f546e1c39"
"checksum lazy_static 1.3.0 (registry+https://github.com/rust-lang/crates.io-index)" = "bc5729f27f159ddd61f4df6228e827e86643d4d3e7c32183cb30a1c08f604a14"
"checksum linked-hash-map 0.5.2 (registry+https://github.com/rust-lang/crates.io-index)" = "ae91b68aebc4ddb91978b11a1b02ddd8602a05ec19002801c5666000e05e0f83"
"checksum lazycell 1.2.1 (registry+https://github.com/rust-lang/crates.io-index)" = "b294d6fa9ee409a054354afc4352b0b9ef7ca222c69b8812cbea9e7d2bf3783f"
"checksum libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)" = "bedcc7a809076656486ffe045abeeac163da1b558e963a31e29fbfbeba916917"
"checksum libc 0.2.58 (registry+https://github.com/rust-lang/crates.io-index)" = "6281b86796ba5e4366000be6e9e18bf35580adf9e63fbe2294aadb587613a319"
"checksum futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)" = "62941eff9507c8177d448bd83a44d9b9760856e184081d8cd79ba9f03dd24981"
"checksum arc-swap 0.3.10 (registry+https://github.com/rust-lang/crates.io-index)" = "a57a5698f85c6fd92f19dad87ff2d822fc4ba79dd85c13914d8c4dad589cb815"
"checksum xml5ever 0.12.1 (registry+https://github.com/rust-lang/crates.io-index)" = "32cd7ebf0203c620906230ce22caa5df0b603c32b6fef72a275a48f6a2ae64b9"
"checksum xmpp-parsers 0.12.2 (registry+https://github.com/rust-lang/crates.io-index)" = "58b4400e1ae0d246044db5fa7f2e693fdfe9cc6e8eaa72ef2a68c5dc1d3c96de"
"checksum xmpp-parsers 0.13.1 (registry+https://github.com/rust-lang/crates.io-index)" = "5094cec449beca92f82ae4d7fe13cda058005849766d71b86c23e6217f61a357"
"checksum ws2_32-sys 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)" = "d59cefebd0c892fa2dd6de581e937301d8552cb44489cdff035c6187cb63fa5e"
"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 winapi-x86_64-pc-windows-gnu 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)" = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
"checksum winapi-util 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)" = "7168bab6e1daee33b4557efd0e95d5ca70a03706d39fa5f3fe7a236f584b03c9"
"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 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)" = "f10e386af2b13e47c89e7236a7a14a086791a2b88ebad6df9bf42040195cf770"
"checksum winapi 0.2.8 (registry+https://github.com/rust-lang/crates.io-index)" = "167dc9d6949a9b857f3451275e911c3f44255842c1f7a76f33c55103a909087a"
"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 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 unicode-bidi 0.3.4 (registry+https://github.com/rust-lang/crates.io-index)" = "49f2bd0c6468a8230e1db229cff8029217cf623c767ea5d60bfbd42729ea54d5"
"checksum time 0.1.42 (registry+https://github.com/rust-lang/crates.io-index)" = "db8dcfca086c1143c9270ac42a2bbd8a7ee477b78ac8e45b19abfb0cbede4b6f"
"checksum tokio 0.1.18 (registry+https://github.com/rust-lang/crates.io-index)" = "65641e515a437b308ab131a82ce3042ff9795bef5d6c5a9be4eb24195c417fd9"
"checksum termion 1.5.1 (registry+https://github.com/rust-lang/crates.io-index)" = "689a3bdfaab439fd92bc87df5c4c78417d3cbe537487274e9b0b2dce76e92096"
"checksum syn 0.15.31 (registry+https://github.com/rust-lang/crates.io-index)" = "d2b4cfac95805274c6afdb12d8f770fa2d27c045953e7b630a81801953699a9a"
"checksum socket2 0.3.8 (registry+https://github.com/rust-lang/crates.io-index)" = "c4d11a52082057d87cb5caa31ad812f4504b97ab44732cd8359df2e9ff9f48e7"
"checksum scopeguard 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)" = "94258f53601af11e6a49f722422f6e3425c52b06245a5cf9bc09908b174f5e27"
"checksum redox_termios 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "7e891cfe48e9100a70a3b6eb652fef28920c117d366339687bd5576160db0f76"
"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 precomputed-hash 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "925383efa346730478fb4838dbe9137d2a47675ad789c546d150a6e1dd4ab31c"
"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 openssl-sys 0.9.43 (registry+https://github.com/rust-lang/crates.io-index)" = "33c86834957dd5b915623e94f2f4ab2c70dd8f6b70679824155d5ae21dbd495d"
"checksum owning_ref 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)" = "49a4b8ea2179e6a2e27411d3bca09ca6dd630821cf6894c6c7c8467a8ee7ef13"
"checksum parking_lot 0.7.1 (registry+https://github.com/rust-lang/crates.io-index)" = "ab41b4aed082705d1056416ae4468b6ea99d52599ecf3169b00088d43113e337"
"checksum parking_lot_core 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)" = "94c8c7923936b28d546dfd14d4472eaf34c99b14e1c973a32b3e6d4eb04298c9"
"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 openssl-probe 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)" = "77af24da69f9d9341038eba93a073b1fdaaa1b788221b00a69bce9e762cb32de"
"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 miow 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)" = "8c1f2f3b1cf331de6896aabf6e9d55dca90356cc9960cca7eaaf408a355ae919"
"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 matches 0.1.8 (registry+https://github.com/rust-lang/crates.io-index)" = "7ffc5c5338469d4d3ea17d269fa8ea3512ad247247c30bd2df69e68309ed0a08"
"checksum markup5ever 0.7.5 (registry+https://github.com/rust-lang/crates.io-index)" = "897636f9850c3eef4905a5540683ed53dc9393860f0846cab2c2ddf9939862ff"
"checksum mac 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "c41e0c4fef86961ac6d6f8a82609f55f31b05e4fce149ac5710e439df7619ba4"
"checksum lazy_static 1.3.0 (registry+https://github.com/rust-lang/crates.io-index)" = "bc5729f27f159ddd61f4df6228e827e86643d4d3e7c32183cb30a1c08f604a14"
"checksum lazycell 1.2.1 (registry+https://github.com/rust-lang/crates.io-index)" = "b294d6fa9ee409a054354afc4352b0b9ef7ca222c69b8812cbea9e7d2bf3783f"
"checksum libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)" = "bedcc7a809076656486ffe045abeeac163da1b558e963a31e29fbfbeba916917"
"checksum linked-hash-map 0.5.2 (registry+https://github.com/rust-lang/crates.io-index)" = "ae91b68aebc4ddb91978b11a1b02ddd8602a05ec19002801c5666000e05e0f83"
"checksum lock_api 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)" = "62ebf1391f6acad60e5c8b43706dde4582df75c06698ab44511d15016bc2442c"
"checksum log 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)" = "c84ec4b527950aa83a329754b01dbe3f58361d1c5efacd1f6d68c494d08a17c6"
"checksum lru-cache 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)" = "31e24f1ad8321ca0e8a1e0ac13f23cb668e6f5466c2c57319f6a5cf1cc8e3b1c"
"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 futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)" = "62941eff9507c8177d448bd83a44d9b9760856e184081d8cd79ba9f03dd24981"
"checksum futures-cpupool 0.1.8 (registry+https://github.com/rust-lang/crates.io-index)" = "ab90cde24b3319636588d0c35fe03b1333857621051837ed769faefb4c2162e4"
"checksum 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 fuchsia-cprng 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "a06f77d526c1a601b7c4cdd98f54b5eaabffc14d5f2f0296febdc7f357c6d3ba"
"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 fnv 1.0.6 (registry+https://github.com/rust-lang/crates.io-index)" = "2fad85553e09a6f881f739c29f0b00b0f01357c743266d478b68951ce23285f3"
"checksum fake-simd 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)" = "e88a8acf291dafb59c2d96e8f59828f3838bb1a70398823ade51a84de6a6deed"
"checksum digest 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)" = "05f47366984d3ad862010e22c7ce81a7dbcaebbdfb37241a620f8b6596ee135c"
"checksum encoding_rs 0.8.17 (registry+https://github.com/rust-lang/crates.io-index)" = "4155785c79f2f6701f185eb2e6b4caf0555ec03477cb4c70db67b465311620ed"
"checksum env_logger 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)" = "b61fa891024a945da30a9581546e8cfaf5602c7b3f4c137a2805cf388f92075a"
"checksum 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 cloudabi 0.0.3 (registry+https://github.com/rust-lang/crates.io-index)" = "ddfc5b9aa5d4507acaf872de71051dfd0e309860e88966e1051e462a077aac4f"
"checksum blake2 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)" = "91721a6330935673395a0607df4d49a9cb90ae12d259f1b3e0a3f6e1d486872e"
"checksum arc-swap 0.3.11 (registry+https://github.com/rust-lang/crates.io-index)" = "bc4662175ead9cd84451d5c35070517777949a2ed84551764129cedb88384841"
"checksum arrayvec 0.4.10 (registry+https://github.com/rust-lang/crates.io-index)" = "92c7fb76bc8826a8b33b4ee5bb07a247a81e76764ab4d55e8f73e3a4d8808c71"
"checksum ansi_term 0.11.0 (registry+https://github.com/rust-lang/crates.io-index)" = "ee49baf6cb617b853aa8d93bf420db2383fab46d314482ca2803b40d5fde979b"
"checksum MacTypes-sys 2.1.0 (registry+https://github.com/rust-lang/crates.io-index)" = "eaf9f0d0b1cc33a4d2aee14fb4b2eac03462ef4db29c8ac4057327d8a71ad86f"
"checksum aho-corasick 0.7.3 (registry+https://github.com/rust-lang/crates.io-index)" = "e6f484ae0c99fec2e858eb6134949117399f222608d84cadb3f58c1f97c2364c"
[metadata]
 "base64 0.12.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "blake2 0.8.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "chrono 0.4.15 (registry+https://github.com/rust-lang/crates.io-index)",
 "digest 0.8.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "jid 0.9.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "minidom 0.12.0 (git+https://gitlab.com/xmpp-rs/xmpp-rs)",
 "sha-1 0.8.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "sha2 0.8.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "sha3 0.8.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "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)",
 "base64 0.12.3",
 "blake2",
 "chrono",
 "digest 0.9.0",
 "jid",
 "minidom",
 "sha-1 0.9.1",
 "sha2 0.9.1",
 "sha3",
version = "0.17.0"
source = "git+https://gitlab.com/xmpp-rs/xmpp-rs#b85aa293770d22cca11fd7ca3802b5920e1ab6fa"
source = "git+https://gitlab.com/xmpp-rs/xmpp-rs?branch=main#e1f2e2653a9c14409a04bc4fcd7b10ce842871ea"
version = "0.13.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
]
[[package]]
name = "xmpp-parsers"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "chrono 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "sha3 0.8.2 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "xmpp-parsers"
version = "0.13.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "base64 0.10.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "blake2 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "chrono 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "digest 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "jid 0.5.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "minidom 0.10.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "sha-1 0.8.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "sha2 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "sha3 0.8.1 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "xmpp-parsers"
version = "0.13.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "base64 0.10.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "blake2 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "chrono 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "digest 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "jid 0.5.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "minidom 0.10.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "sha-1 0.8.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "sha2 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "sha3 0.8.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "sha3 0.8.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "sha3 0.8.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "sha3 0.8.1 (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)",
 "sha3 0.8.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "digest 0.7.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "jid 0.5.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "minidom 0.9.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "sha-1 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "sha2 0.7.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "sha3 0.7.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "try_from 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "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)",
 "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)",
 "base64 0.9.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "blake2 0.7.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "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)",
 "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)",
]
[[package]]
name = "xmpp-parsers"
version = "0.13.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "base64 0.10.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "blake2 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.11.1"
version = "0.12.2"
version = "0.12.2"
 "markup5ever 0.7.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "time 0.1.40 (registry+https://github.com/rust-lang/crates.io-index)",
 "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)",
 "markup5ever 0.10.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "time 0.1.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "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)",
 "log 0.3.9 (registry+https://github.com/rust-lang/crates.io-index)",
 "log 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "log 0.4.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "log",
 "mac",
 "markup5ever",
 "time",
 "log 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.12.0"
version = "0.12.1"
version = "0.16.1"
version = "0.12.1"
 "winapi 0.2.8",
 "winapi-build",
 "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]]
 "winapi 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)",
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)",
 "winapi 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.9 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.9",
 "winapi 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.6.2"
version = "0.5.1"
]
[[package]]
 "winapi 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi-util 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
name = "wincolor"
version = "1.0.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
]
 "ryu 0.2.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde 1.0.83 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde 1.0.80 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde 1.0.82 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde 1.0.85 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde 1.0.83 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde 1.0.83 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde 1.0.80 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde 1.0.80 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde 1.0.80 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde 1.0.80 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde 1.0.85 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde 1.0.80 (registry+https://github.com/rust-lang/crates.io-index)",
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "itoa 0.4.3 (registry+https://github.com/rust-lang/crates.io-index)",
version = "1.0.33"
]
[[package]]
name = "serde_json"
 "proc-macro2 0.4.24 (registry+https://github.com/rust-lang/crates.io-index)",
 "quote 0.6.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "syn 0.15.23 (registry+https://github.com/rust-lang/crates.io-index)",
 "syn 0.15.22 (registry+https://github.com/rust-lang/crates.io-index)",
 "syn 0.15.23 (registry+https://github.com/rust-lang/crates.io-index)",
 "syn 0.15.23 (registry+https://github.com/rust-lang/crates.io-index)",
 "syn 0.15.23 (registry+https://github.com/rust-lang/crates.io-index)",
 "syn 0.15.22 (registry+https://github.com/rust-lang/crates.io-index)",
 "syn 0.15.22 (registry+https://github.com/rust-lang/crates.io-index)",
 "syn 0.15.22 (registry+https://github.com/rust-lang/crates.io-index)",
 "syn 0.15.22 (registry+https://github.com/rust-lang/crates.io-index)",
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
version = "1.0.80"
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
name = "serde_derive"
version = "1.0.80"
]
[[package]]
name = "serde"
 "clap 2.32.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "failure 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "jid 0.5.2 (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.85 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde_derive 1.0.85 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio 0.1.14 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-xmpp 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "try_from 0.2.2 (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)",
 "try_from 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "xmpp-parsers 0.11.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "try_from 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "try_from 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "xmpp-parsers 0.11.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "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)",
 "try_from 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-xmpp 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-xmpp 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-xmpp 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-xmpp 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-xmpp 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-xmpp 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "toml 0.4.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-xmpp 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-xmpp 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-xmpp 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "minidom 0.9.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio 0.1.13 (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)",
 "serde 1.0.83 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde_derive 1.0.83 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde 1.0.80 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde_derive 1.0.80 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde 1.0.82 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde_derive 1.0.82 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde 1.0.83 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde_derive 1.0.83 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde 1.0.83 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde_derive 1.0.83 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde 1.0.80 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde_derive 1.0.80 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde 1.0.80 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde_derive 1.0.80 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde 1.0.80 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde_derive 1.0.80 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde 1.0.80 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde_derive 1.0.80 (registry+https://github.com/rust-lang/crates.io-index)",
 "minidom 0.9.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde 1.0.80 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde_derive 1.0.80 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio 0.1.13 (registry+https://github.com/rust-lang/crates.io-index)",
 "minidom 0.10.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde 1.0.85 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde_derive 1.0.85 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio 0.1.14 (registry+https://github.com/rust-lang/crates.io-index)",
 "log 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "hyper 0.12.19 (registry+https://github.com/rust-lang/crates.io-index)",
 "hyper 0.12.17 (registry+https://github.com/rust-lang/crates.io-index)",
 "hyper 0.12.17 (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.21 (registry+https://github.com/rust-lang/crates.io-index)",
 "failure 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "failure 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "hyper 0.12.17 (registry+https://github.com/rust-lang/crates.io-index)",
 "failure 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)",
 "hyper 0.12.19 (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.21 (registry+https://github.com/rust-lang/crates.io-index)",
 "failure 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "hyper 0.12.18 (registry+https://github.com/rust-lang/crates.io-index)",
 "hyper 0.12.19 (registry+https://github.com/rust-lang/crates.io-index)",
 "hyper 0.12.17 (registry+https://github.com/rust-lang/crates.io-index)",
 "hyper 0.12.17 (registry+https://github.com/rust-lang/crates.io-index)",
 "hyper 0.12.17 (registry+https://github.com/rust-lang/crates.io-index)",
 "failure 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "hyper 0.12.17 (registry+https://github.com/rust-lang/crates.io-index)",
 "failure 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "hyper 0.12.17 (registry+https://github.com/rust-lang/crates.io-index)",
 "failure 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "hyper 0.12.21 (registry+https://github.com/rust-lang/crates.io-index)",
 "hyper 0.12.13 (registry+https://github.com/rust-lang/crates.io-index)",
 "env_logger 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "env_logger 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "env_logger 0.6.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "env_logger 0.6.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "env_logger 0.6.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "env_logger 0.6.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde 1.0.87 (registry+https://github.com/rust-lang/crates.io-index)",
version = "1.0.38"
version = "1.0.87"
version = "1.0.87"
 "serde 1.0.89 (registry+https://github.com/rust-lang/crates.io-index)",
version = "1.0.39"
version = "1.0.89"
version = "1.0.89"
 "serde 1.0.80 (registry+https://github.com/rust-lang/crates.io-index)",
version = "1.0.33"
 "proc-macro2 0.4.24 (registry+https://github.com/rust-lang/crates.io-index)",
 "quote 0.6.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "syn 0.15.22 (registry+https://github.com/rust-lang/crates.io-index)",
version = "1.0.80"
version = "1.0.80"
 "tokio-xmpp 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "minidom 0.9.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde 1.0.80 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde_derive 1.0.80 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio 0.1.13 (registry+https://github.com/rust-lang/crates.io-index)",
version = "1.0.33"
 "proc-macro2 0.4.24 (registry+https://github.com/rust-lang/crates.io-index)",
 "quote 0.6.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "syn 0.15.22 (registry+https://github.com/rust-lang/crates.io-index)",
version = "1.0.80"
version = "1.0.80"
version = "1.0.36"
 "proc-macro2 0.4.26 (registry+https://github.com/rust-lang/crates.io-index)",
 "quote 0.6.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "syn 0.15.26 (registry+https://github.com/rust-lang/crates.io-index)",
version = "1.0.85"
version = "1.0.85"
version = "1.0.33"
version = "1.0.80"
version = "1.0.80"
 "serde 1.0.87 (registry+https://github.com/rust-lang/crates.io-index)",
version = "1.0.87"
version = "1.0.87"
dependencies = [
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f7fe0bb3479651439c9112f72b6c505038574c9fbb575ed1bf3b797fa39dd564"
[[package]]
name = "unreachable"
version = "1.0.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "void 1.0.2 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "unreachable"
version = "1.0.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "void 1.0.2 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "url"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "829d4a8476c35c9bf0bbce5a3b23f4106f79728039b726d292bb93bc106787cb"
dependencies = [
 "matches 0.1.8 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "utf-8"
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
name = "utf8-ranges"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "05e42f7c18b8f902290b009cde6d651262f956c98bc51bca4cd1d511c9cd85c7"
[[package]]
name = "vcpkg"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "6454029bf181f092ad1b853286f23e2c507d8e8194d01d92da4a55c274a5508c"
[[package]]
name = "vec_map"
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
name = "version_check"
version = "0.1.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
name = "void"
version = "1.0.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f1bddf1187be692e79c5ffeab891132dfb0f236ed36a43c7ed39f1165ee20191"
[[package]]
name = "void"
version = "1.0.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
name = "version_check"
version = "0.9.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "b5a972e5669d67ba988ce3dc826706fb0a8b01471c088cb0b6110b805cc36aed"
[[package]]
name = "want"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "1ce8a968cb1cd110d136ff8b819a556d6fb6d919363c61534f6860c7eb172ba0"
dependencies = [
 "log 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "wasi"
version = "0.9.0+wasi-snapshot-preview1"
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
name = "wasi"
version = "0.10.0+wasi-snapshot-preview1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "1a143597ca7c7793eff794def352d41792a93c481eb1042423ff7ff72ba2c31f"
checksum = "cccddf32554fecc6acb585f82a32a72e28b48f8c4c1883ddfeeeaa96f7d8e519"
[[package]]
name = "widestring"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "c168940144dd21fd8046987c16a46a33d5fc84eec29ef9dcddc2ac9e31526b7c"
[[package]]
name = "winapi"
version = "0.2.8"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "167dc9d6949a9b857f3451275e911c3f44255842c1f7a76f33c55103a909087a"
[[package]]
name = "winapi"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "5c839a674fcd7a98952e593242ea400abe93992746761e38641405d28b00f419"
dependencies = [
]
[[package]]
name = "winapi-build"
version = "0.1.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "2d315eee3b34aca4797b2da6b13ed88266e6d612562a0c46390af8299fc699bc"
[[package]]
name = "winapi-i686-pc-windows-gnu"
version = "0.4.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6"
[[package]]
name = "winapi-util"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "70ec6ce85bb158151cae5e5c87f95a8e97d2c0c4b001223f33a334e3ce5de178"
dependencies = [
]
[[package]]
name = "winapi-x86_64-pc-windows-gnu"
version = "0.4.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
 "winapi 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.9 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.9",
 "winapi 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.1.1"
version = "0.1.2"
version = "0.1.5"
version = "0.1.2"
 "winapi-i686-pc-windows-gnu",
 "winapi-x86_64-pc-windows-gnu",
 "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)",
version = "0.3.6"
version = "0.3.6"
version = "0.3.7"
version = "0.3.6"
version = "0.3.9"
version = "0.3.7"
version = "0.3.7"
version = "0.3.7"
version = "0.4.2"
version = "0.4.3"
version = "0.2.2"
 "try-lock 0.2.2 (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.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.25 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.26 (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.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "try-lock 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.27 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",
 "log",
 "try-lock",
 "futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",
 "log 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.3.0"
version = "0.0.6"
version = "0.8.2"
version = "0.8.1"
version = "0.2.10"
version = "0.2.6"
version = "1.0.1"
version = "1.0.2"
version = "1.0.2"
version = "1.0.3"
version = "1.0.2"
version = "0.7.4"
version = "0.7.5"
version = "0.7.5"
 "percent-encoding 2.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "percent-encoding 1.0.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "idna 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "idna",
 "matches",
 "percent-encoding",
 "idna 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
version = "1.7.1"
version = "1.7.2"
version = "2.1.1"
version = "1.7.2"
version = "0.1.0"
dependencies = [
 "lazy_static 1.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-signal 0.2.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-xmpp 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "toml 0.4.8 (registry+https://github.com/rust-lang/crates.io-index)",
 "xmpp-parsers 0.11.1 (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)",
 "toml 0.5.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "toml 0.5.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "xmpp-parsers 0.13.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "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)",
 "xmpp-parsers 0.13.1 (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)",
 "toml 0.5.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "toml 0.5.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "xmpp-parsers 0.13.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-signal 0.2.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-xmpp 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "toml 0.5.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "xmpp-parsers 0.13.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "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)",
 "minidom 0.10.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio 0.1.19 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio 0.1.18 (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)",
 "serde 1.0.90 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde_derive 1.0.90 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio 0.1.18 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde 1.0.90 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde_derive 1.0.90 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio 0.1.18 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde 1.0.87 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde_derive 1.0.87 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio 0.1.15 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde 1.0.92 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde_derive 1.0.92 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio 0.1.21 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde 1.0.90 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde_derive 1.0.90 (registry+https://github.com/rust-lang/crates.io-index)",
 "lazy_static 1.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "hyper 0.12.25 (registry+https://github.com/rust-lang/crates.io-index)",
 "hyper 0.12.27 (registry+https://github.com/rust-lang/crates.io-index)",
 "hyper 0.12.27 (registry+https://github.com/rust-lang/crates.io-index)",
 "lazy_static 1.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "hyper 0.12.23 (registry+https://github.com/rust-lang/crates.io-index)",
 "hyper 0.12.30 (registry+https://github.com/rust-lang/crates.io-index)",
 "lazy_static 1.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "hyper 0.12.27 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "serde"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "96fe57af81d28386a513cbc6858332abc6117cfdb5999647c6444b8f43a370a5"
[[package]]
name = "serde_derive"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f630a6370fd8e457873b4bd2ffdae75408bc291ba72be773772a4c2a065d9ae8"
dependencies = [
 "syn 0.15.30 (registry+https://github.com/rust-lang/crates.io-index)",
 "quote 0.6.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "syn 0.15.30 (registry+https://github.com/rust-lang/crates.io-index)",
 "quote 0.6.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "syn 0.15.26 (registry+https://github.com/rust-lang/crates.io-index)",
 "quote 0.6.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "syn 0.15.30 (registry+https://github.com/rust-lang/crates.io-index)",
 "syn 0.15.36 (registry+https://github.com/rust-lang/crates.io-index)",
 "quote 0.6.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "syn 0.15.33 (registry+https://github.com/rust-lang/crates.io-index)",
 "syn 0.15.30 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "serde_json"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "a230ea9107ca2220eea9d46de97eddcb04cd00e92d13dda78e478dd33fa82bd4"
dependencies = [
 "ryu 0.2.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde 1.0.80 (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)",
 "serde 1.0.90 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde 1.0.87 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde 1.0.90 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "sha-1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f7d94d0bede923b3cea61f3f1ff57ff8cdfd77b400fb8f9998949e0cf04163df"
dependencies = [
 "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)",
 "opaque-debug 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "sha2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "a256f46ea78a0c0d9ff00077504903ac881a1dafdc20da66545699e7776b3e69"
dependencies = [
 "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)",
 "opaque-debug 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "sha3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f81199417d4e5de3f04b1e871023acea7389672c4135918f05aa9cbf2f2fa809"
dependencies = [
 "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)",
 "opaque-debug 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "opaque-debug 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
version = "0.1.5"
 "arc-swap 0.3.4 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.43 (registry+https://github.com/rust-lang/crates.io-index)",
name = "siphasher"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "fa8f3741c7372e75519bd9346068370c9cdaabcc1f9599cbcf2a2719352286b7"
[[package]]
name = "slab"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "c111b5bd5695e56cffe5129854aa230b39c93a305372fdbb2668ca2394eea9f8"
[[package]]
name = "smallvec"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "unreachable 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)",
]
dependencies = [
 "unreachable 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)",
]
checksum = "fbee7696b84bbf3d89a1c2eccff0850e3047ed46bfcd2e92c29a2d074d57e252"
[[package]]
name = "socket2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "b1fa70dc5c8104ec096f4fe7ede7a221d35ae13dcd19ba1ad9a81d2cab9a1c44"
dependencies = [
 "libc 0.2.53 (registry+https://github.com/rust-lang/crates.io-index)",
 "redox_syscall 0.1.54 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
 "redox_syscall 0.1.54 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)",
]
version = "0.1.1"
version = "0.1.3"
version = "0.1.3"
dependencies = [
 "bytes 0.4.12 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "string_cache"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "2940c75beb4e3bf3a494cef919a747a2cb81e52571e212bfbd185074add7208a"
dependencies = [
 "phf_shared 0.7.24 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde 1.0.80 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde 1.0.89 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde 1.0.90 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde 1.0.90 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde 1.0.87 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde 1.0.115 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde 1.0.92 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde 1.0.90 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "string_cache_codegen"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f24c8e5e19d22a726626f1a5e16fe15b132dcf21d10177fa5a45ce7962996b97"
dependencies = [
 "proc-macro2 0.4.29 (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)",
 "proc-macro2 0.4.27 (registry+https://github.com/rust-lang/crates.io-index)",
 "proc-macro2 0.4.27 (registry+https://github.com/rust-lang/crates.io-index)",
 "quote 0.6.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "quote 0.6.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "quote 0.6.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "proc-macro2 0.4.30 (registry+https://github.com/rust-lang/crates.io-index)",
 "quote 0.6.12 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "strsim"
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"
checksum = "2d67a5a62ba6e01cb2192ff309324cb4875d0c451d55fe2319433abe7a05a8ee"
[[package]]
name = "subtle"
version = "2.3.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
name = "syn"
 "proc-macro2 0.4.20 (registry+https://github.com/rust-lang/crates.io-index)",
 "quote 0.6.8 (registry+https://github.com/rust-lang/crates.io-index)",
 "proc-macro2 0.4.29 (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)",
 "proc-macro2 0.4.27 (registry+https://github.com/rust-lang/crates.io-index)",
 "proc-macro2 0.4.27 (registry+https://github.com/rust-lang/crates.io-index)",
 "quote 0.6.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "quote 0.6.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "quote 0.6.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "quote 0.6.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "proc-macro2 0.4.30 (registry+https://github.com/rust-lang/crates.io-index)",
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "1e2e59c50ed8f6b050b071aa7b6865293957a9af6b58b94f97c1c9434ad440ea"
dependencies = [
]
[[package]]
name = "synstructure"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "b834f2d66f734cb897113e34aaff2f1ab4719ca946f9a7358dba8f8064148701"
dependencies = [
 "syn 0.15.30 (registry+https://github.com/rust-lang/crates.io-index)",
 "quote 0.6.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "syn 0.15.30 (registry+https://github.com/rust-lang/crates.io-index)",
 "quote 0.6.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "syn 0.15.26 (registry+https://github.com/rust-lang/crates.io-index)",
 "quote 0.6.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "syn 0.15.30 (registry+https://github.com/rust-lang/crates.io-index)",
 "syn 0.15.36 (registry+https://github.com/rust-lang/crates.io-index)",
 "quote 0.6.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "syn 0.15.33 (registry+https://github.com/rust-lang/crates.io-index)",
 "syn 0.15.30 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "tempfile"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "7a6e24d9338a0a5be79593e2fa15a648add6138caa803e2d5bc782c371732ca9"
dependencies = [
 "libc 0.2.53 (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)",
 "winapi 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "remove_dir_all 0.5.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "redox_syscall 0.1.54 (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.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "redox_syscall 0.1.54 (registry+https://github.com/rust-lang/crates.io-index)",
 "redox_syscall 0.1.54 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand 0.6.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "tendril"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "707feda9f2582d5d680d733e38755547a3e8fb471e7ba11452ecfd9ce93a5d3b"
dependencies = [
 "utf-8 0.7.4 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "termcolor"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "bb6bfa289a4d7c5766392812c0a1f4c1ba45afa1ad47803c11e1f407d846d75f"
dependencies = [
]
[[package]]
 "libc 0.2.43 (registry+https://github.com/rust-lang/crates.io-index)",
 "redox_syscall 0.1.40 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.53 (registry+https://github.com/rust-lang/crates.io-index)",
 "numtoa 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
version = "1.5.2"
 "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)",
version = "1.5.1"
 "libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
version = "1.5.1"
 "libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
 "redox_syscall 0.1.54 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.48 (registry+https://github.com/rust-lang/crates.io-index)",
 "redox_syscall 0.1.51 (registry+https://github.com/rust-lang/crates.io-index)",
 "redox_syscall 0.1.54 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.58 (registry+https://github.com/rust-lang/crates.io-index)",
 "numtoa 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
version = "1.5.3"
 "libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
 "redox_syscall 0.1.54 (registry+https://github.com/rust-lang/crates.io-index)",
name = "textwrap"
version = "0.1.11"
 "libc 0.2.43 (registry+https://github.com/rust-lang/crates.io-index)",
 "redox_syscall 0.1.40 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.1.40"
 "lazy_static 1.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.1.19"
 "libc 0.2.53 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.1.16"
 "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)",
version = "0.1.18"
 "libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.1.18"
 "libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
 "redox_syscall 0.1.54 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.1.42"
 "lazy_static 1.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.1.15"
 "libc 0.2.48 (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)",
 "lazy_static 1.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.1.21"
 "redox_syscall 0.1.54 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.58 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.1.18"
 "libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
 "redox_syscall 0.1.54 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "lazy_static 1.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d326610f408c7a4eb6f51c37c330e496b08506c9457c9d34287ecc38809fb060"
dependencies = [
 "futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",
 "mio 0.6.16 (registry+https://github.com/rust-lang/crates.io-index)",
 "num_cpus 1.10.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-current-thread 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-executor 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-fs 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-reactor 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-tcp 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-threadpool 0.1.8 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-timer 0.2.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-udp 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-uds 0.2.3 (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-sync 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-threadpool 0.1.14 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-trace-core 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "tokio-buf"
version = "0.1.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "bytes 0.4.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "either 1.5.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.27 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-trace-core 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-threadpool 0.1.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-threadpool 0.1.13 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-timer 0.2.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-trace-core 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-udp 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-uds 0.2.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-threadpool 0.1.13 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-timer 0.2.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-threadpool 0.1.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-threadpool 0.1.14 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-timer 0.2.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-trace-core 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-threadpool 0.1.13 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-sync 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-sync 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-sync 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-sync 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-current-thread 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-executor 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-fs 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-reactor 0.1.9 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-sync 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-tcp 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-current-thread 0.1.4 (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.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-reactor 0.1.8 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-sync 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-current-thread 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-executor 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-fs 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-reactor 0.1.9 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-current-thread 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-executor 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-current-thread 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-executor 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-fs 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-reactor 0.1.9 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-sync 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-tcp 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-threadpool 0.1.13 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-timer 0.2.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-trace-core 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-udp 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-uds 0.2.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.27 (registry+https://github.com/rust-lang/crates.io-index)",
 "mio 0.6.19 (registry+https://github.com/rust-lang/crates.io-index)",
 "num_cpus 1.10.1 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "318234ffa22e0920fe9a40d7b8369b5f649d490980cf7aadcf1eb91594869b42"
dependencies = [
]
[[package]]
 "bytes 0.4.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.25 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.1.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "cae2447b6282786c3493999f40a9be2a6ad20cb8bd268b0a0dbf5a065535c0ab"
dependencies = [
 "tokio-executor 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
version = "0.1.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d40c6d1b69745a6ec6fb1ca717914848da4b44ae29d9b3080cbee91d72a69b14"
dependencies = [
 "futures 0.1.25 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.25 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.27 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
version = "0.1.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "6db9e6914ab8b1ae1c260a4ae7a49b6c5611b40328a735b21862567685e73255"
dependencies = [
 "tokio-io 0.1.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-threadpool 0.1.14 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-threadpool 0.1.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-threadpool 0.1.13 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-threadpool 0.1.14 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-threadpool 0.1.13 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
version = "0.1.10"
source = "registry+https://github.com/rust-lang/crates.io-index"
 "bytes 0.4.10 (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.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "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 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",
 "log 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "bytes 0.4.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",
 "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 0.1.27 (registry+https://github.com/rust-lang/crates.io-index)",
 "bytes 0.4.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "bytes 0.4.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",
[[package]]
version = "0.1.6"
version = "0.1.9"
version = "0.1.8"
version = "0.1.9"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "5d34ca54d84bf2b5b4d7d31e901a8464f7b60ac145a284fba25ceb801f2ddccd"
dependencies = [
 "futures 0.1.25 (registry+https://github.com/rust-lang/crates.io-index)",
 "num_cpus 1.8.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "parking_lot 0.6.4 (registry+https://github.com/rust-lang/crates.io-index)",
 "slab 0.4.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-executor 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.2.6"
 "futures 0.1.25 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.43 (registry+https://github.com/rust-lang/crates.io-index)",
 "signal-hook 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-executor 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-reactor 0.1.6 (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-tcp"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f0c3acc6aa564495a0f2e1d59fab677cd7f81a19994cfc7f3ad0e64301560389"
dependencies = [
 "futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",
 "mio 0.6.16 (registry+https://github.com/rust-lang/crates.io-index)",
 "mio 0.6.19 (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)",
 "mio 0.6.16 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-reactor 0.1.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-io 0.1.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-reactor 0.1.8 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-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)",
 "futures 0.1.27 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
version = "0.1.8"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "9a70f4fcd7b3b24fb194f837560168208f669ca8cb70d0c4b862944452396343"
dependencies = [
 "crossbeam-utils 0.6.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "log 0.4.6 (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)",
 "tokio-executor 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-executor 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-executor 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-executor 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "num_cpus 1.10.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "num_cpus 1.10.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "num_cpus 1.9.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "num_cpus 1.10.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "num_cpus 1.10.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.25 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.25 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.27 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
version = "0.2.7"
 "crossbeam-utils 0.5.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.25 (registry+https://github.com/rust-lang/crates.io-index)",
 "slab 0.4.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-executor 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.3.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "be8242891f2b6cbef26a2d7e8605133c2c554cd35b3e4948ea892d6d68436499"
dependencies = [
 "tokio-io 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)",
name = "tokio-trace-core"
version = "0.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "lazy_static 1.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
version = "0.1.2"
version = "0.1.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ffc92d160b1eef40665be3a05630d003936a3bc7da7421277846c2613e92c71a"
dependencies = [
 "futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",
 "mio 0.6.16 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-reactor 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-io 0.1.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-reactor 0.1.8 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-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-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)",
 "mio 0.6.19 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-codec 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "log 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.27 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
version = "0.2.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
 "tokio-io 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-reactor 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.43 (registry+https://github.com/rust-lang/crates.io-index)",
 "log 0.4.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "bytes 0.4.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.25 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.53 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.49 (registry+https://github.com/rust-lang/crates.io-index)",
 "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)",
 "libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-reactor 0.1.9 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-codec 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "log 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
 "bytes 0.4.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-reactor 0.1.8 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.48 (registry+https://github.com/rust-lang/crates.io-index)",
 "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.19 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.58 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.27 (registry+https://github.com/rust-lang/crates.io-index)",
 "bytes 0.4.12 (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)",
 "libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
 "bytes 0.4.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",
[[package]]
version = "0.2.0"
version = "1.0.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "b0987850db3733619253fe60e17cb59b82d37c7e6c0236bb81e4d6b87c879f27"
dependencies = [
]
[[package]]
version = "0.4.8"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f50de3927f93d202783f4513cda820ab47ef17f624b03c096e86ef00c67e6b5f"
dependencies = [
]
[[package]]
name = "trust-dns-proto"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "cdd7061ba6f4d4d9721afedffbfd403f20f39a4301fee1b70d6fcd09cca69f28"
dependencies = [
 "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)",
 "lazy_static 1.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "log 0.4.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand 0.4.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "smallvec 0.6.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-executor 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-reactor 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-tcp 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-timer 0.2.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-udp 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "url 1.7.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-executor 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-tcp 0.1.3 (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)",
 "tokio-timer 0.2.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-timer 0.2.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-timer 0.2.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-executor 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-reactor 0.1.9 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-executor 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-reactor 0.1.8 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-executor 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-reactor 0.1.9 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-executor 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-reactor 0.1.9 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-tcp 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-timer 0.2.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-udp 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "url 1.7.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "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)",
 "tokio-executor 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "socket2 0.3.8 (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)",
 "smallvec 0.6.9 (registry+https://github.com/rust-lang/crates.io-index)",
 "smallvec 0.6.8 (registry+https://github.com/rust-lang/crates.io-index)",
 "smallvec 0.6.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "socket2 0.3.9 (registry+https://github.com/rust-lang/crates.io-index)",
 "smallvec 0.6.9 (registry+https://github.com/rust-lang/crates.io-index)",
 "lazy_static 1.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "lazy_static 1.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "lazy_static 1.3.0 (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)",
 "futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.25 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.27 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "trust-dns-resolver"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "0f23cdfdc3d8300b3c50c9e84302d3bd6d860fb9529af84ace6cf9665f181b77"
dependencies = [
 "failure 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "ipconfig 0.1.9 (registry+https://github.com/rust-lang/crates.io-index)",
 "log 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "smallvec 0.6.9 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio 0.1.18 (registry+https://github.com/rust-lang/crates.io-index)",
 "smallvec 0.6.9 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio 0.1.18 (registry+https://github.com/rust-lang/crates.io-index)",
 "trust-dns-proto 0.6.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "resolv-conf 0.6.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio 0.1.19 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio 0.1.16 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio 0.1.18 (registry+https://github.com/rust-lang/crates.io-index)",
 "smallvec 0.6.8 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio 0.1.15 (registry+https://github.com/rust-lang/crates.io-index)",
 "resolv-conf 0.6.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "smallvec 1.4.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "thiserror 1.0.20 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio 0.2.22 (registry+https://github.com/rust-lang/crates.io-index)",
 "trust-dns-proto 0.19.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "smallvec 0.6.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio 0.1.21 (registry+https://github.com/rust-lang/crates.io-index)",
 "smallvec 0.6.9 (registry+https://github.com/rust-lang/crates.io-index)",
 "lru-cache 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "lru-cache 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "lru-cache 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "lru-cache 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "lazy_static 1.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "lazy_static 1.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "lazy_static 1.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.25 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.25 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.27 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",
 "lru-cache 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "try-lock"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "59547bce71d9c38b83d9c0e92b6066c4253371f15005def0c30d9657f50c7642"
[[package]]
version = "0.2.2"
 "cfg-if 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "cfg-if 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
]
 "cfg-if 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
dependencies = [
version = "0.3.2"
 "cfg-if 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "cfg-if 0.1.9 (registry+https://github.com/rust-lang/crates.io-index)",
 "cfg-if 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
name = "typenum"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "373c8a200f9e67a0c95e62a4f52fbf80c23b4381c05a17845531982fa99e6b33"
[[package]]
version = "0.1.1"
version = "0.1.3"
name = "unicode-bidi"
version = "0.3.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "49f2bd0c6468a8230e1db229cff8029217cf623c767ea5d60bfbd42729ea54d5"
dependencies = [
]
[[package]]
name = "unicode-normalization"
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "e83e153d1053cbb5a118eeff7fd5be06ed99153f00dbcd8ae310c5fb2b22edc0"
[[package]]
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "9337591893a19b88d8d87f2cec1e73fad5cdfd10e5a6f349f498ad6ea2ffb1e3"
[[package]]
name = "unicode-xid"
version = "0.2.1"
name = "unicode-width"
version = "0.1.8"
name = "unicode-xid"
version = "0.0.4"
name = "unicode-segmentation"
version = "1.6.0"
name = "unicode-width"
version = "0.1.5"
dependencies = [
]
 "smallvec 0.6.9 (registry+https://github.com/rust-lang/crates.io-index)",
 "smallvec 0.6.9 (registry+https://github.com/rust-lang/crates.io-index)",
 "smallvec 0.6.8 (registry+https://github.com/rust-lang/crates.io-index)",
 "tinyvec 0.3.4 (registry+https://github.com/rust-lang/crates.io-index)",
 "smallvec 0.6.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "smallvec 0.6.9 (registry+https://github.com/rust-lang/crates.io-index)",
 "tinyvec",
checksum = "6fb19cf769fa8c6a80a162df694621ebeb4dafb606470b2b2fce0be40a98a977"
dependencies = [
 "smallvec 0.6.9 (registry+https://github.com/rust-lang/crates.io-index)",
]
version = "0.1.7"
version = "0.1.8"
version = "0.1.13"
version = "0.1.8"
 "matches",
 "matches 0.1.8 (registry+https://github.com/rust-lang/crates.io-index)",
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
version = "0.1.3"
name = "ucd-util"
version = "1.12.0"
version = "1.10.0"
[[package]]
dependencies = [
 "cfg-if 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
]
source = "registry+https://github.com/rust-lang/crates.io-index"
version = "0.3.2"
name = "try_from"
version = "0.2.3"
version = "0.2.2"
 "cfg-if 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "error-chain 0.1.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.25 (registry+https://github.com/rust-lang/crates.io-index)",
 "ipconfig 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "lazy_static 1.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "log 0.4.5 (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.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "smallvec 0.6.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio 0.1.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "trust-dns-proto 0.4.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "cfg-if 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "cfg-if 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "cfg-if 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "cfg-if 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "backtrace 0.3.50 (registry+https://github.com/rust-lang/crates.io-index)",
 "cfg-if 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.3.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "ipconfig 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "lazy_static 1.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "log 0.4.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "cfg-if 0.1.9 (registry+https://github.com/rust-lang/crates.io-index)",
 "cfg-if 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "backtrace",
 "cfg-if",
 "futures",
 "ipconfig",
 "lazy_static",
 "log",
 "lru-cache",
 "resolv-conf",
 "smallvec",
 "thiserror",
 "tokio",
 "trust-dns-proto",
 "cfg-if 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "failure 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",
 "ipconfig 0.1.9 (registry+https://github.com/rust-lang/crates.io-index)",
 "lazy_static 1.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "log 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "lru-cache 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "resolv-conf 0.6.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "smallvec 0.6.9 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio 0.1.18 (registry+https://github.com/rust-lang/crates.io-index)",
 "trust-dns-proto 0.6.3 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.9.1"
version = "0.10.3"
version = "0.19.5"
version = "0.10.3"
 "idna 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "byteorder 1.2.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "error-chain 0.1.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.25 (registry+https://github.com/rust-lang/crates.io-index)",
 "byteorder 1.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "byteorder 1.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "async-trait 0.1.40 (registry+https://github.com/rust-lang/crates.io-index)",
 "backtrace 0.3.50 (registry+https://github.com/rust-lang/crates.io-index)",
 "enum-as-inner 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.3.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "idna 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "lazy_static 1.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "log 0.4.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand 0.7.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "smallvec 1.4.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "thiserror 1.0.20 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio 0.2.22 (registry+https://github.com/rust-lang/crates.io-index)",
 "url 2.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "byteorder 1.3.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "async-trait",
 "backtrace",
 "enum-as-inner",
 "futures",
 "idna",
 "lazy_static",
 "log",
 "rand",
 "smallvec",
 "thiserror",
 "tokio",
 "url",
 "byteorder 1.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "failure 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.4.3"
version = "0.6.3"
version = "0.19.5"
version = "0.6.3"
 "serde 1.0.80 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde 1.0.89 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde 1.0.90 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde 1.0.90 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde 1.0.87 (registry+https://github.com/rust-lang/crates.io-index)",
 "lazy_static 1.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde 1.0.92 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde 1.0.90 (registry+https://github.com/rust-lang/crates.io-index)",
 "lazy_static",
 "serde 1.0.90 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.4.10"
version = "0.5.0"
version = "0.5.0"
version = "0.4.10"
version = "0.5.1"
version = "0.5.0"
version = "0.5.0"
name = "tracing-core"
version = "0.1.15"
version = "0.1.17"
name = "toml"
 "derive-error 0.0.4 (registry+https://github.com/rust-lang/crates.io-index)",
 "idna 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)",
 "tokio 0.1.19 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-tls 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "trust-dns-proto 0.4.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "trust-dns-resolver 0.9.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "try_from 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "xml5ever 0.12.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "xmpp-parsers 0.11.1 (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)",
 "tokio-io 0.1.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.12 (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)",
 "tokio 0.1.16 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio 0.1.18 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio 0.1.18 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio 0.1.15 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio 0.1.21 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio 0.1.18 (registry+https://github.com/rust-lang/crates.io-index)",
 "jid 0.5.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "minidom 0.9.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "quick-xml 0.12.4 (registry+https://github.com/rust-lang/crates.io-index)",
 "sasl 0.4.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio 0.1.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "sasl 0.4.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-codec 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "quick-xml 0.13.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "quick-xml 0.13.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "quick-xml 0.13.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "sasl 0.4.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio 0.1.18 (registry+https://github.com/rust-lang/crates.io-index)",
 "native-tls 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "native-tls 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "native-tls 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "native-tls 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "native-tls 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.25 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.25 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.25 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.27 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",
 "bytes 0.4.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "bytes 0.4.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "bytes 0.4.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "bytes 0.4.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "cfg-if 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "log 0.4.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "tracing-core 0.1.15 (registry+https://github.com/rust-lang/crates.io-index)",
 "bytes 0.4.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "bytes 0.4.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "cfg-if",
 "log",
 "pin-project-lite",
 "tracing-core",
 "bytes 0.4.12 (registry+https://github.com/rust-lang/crates.io-index)",
version = "1.0.0"
name = "tracing"
version = "0.1.19"
version = "0.1.21"
name = "tokio-xmpp"
]
 "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)",
 "mio-uds 0.6.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
 "log 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "mio 0.6.16 (registry+https://github.com/rust-lang/crates.io-index)",
 "iovec 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "bytes 0.4.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",
checksum = "e987b6bf443f4b5b3b6f38704195592cca41c5bb7aedd3c3693c7081f8289860"
dependencies = [
version = "0.2.5"
version = "0.2.5"
name = "tower-service"
version = "0.3.0"
name = "tokio-uds"
 "mio 0.6.16 (registry+https://github.com/rust-lang/crates.io-index)",
 "bytes 0.4.10 (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.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "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)",
 "bytes 0.4.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",
 "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)",
 "serde 1.0.115 (registry+https://github.com/rust-lang/crates.io-index)",
 "bytes 0.4.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "bytes 0.4.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde",
 "bytes 0.4.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",
 "log 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.1.3"
name = "tokio-udp"
 "native-tls 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.12 (registry+https://github.com/rust-lang/crates.io-index)",
name = "tokio-trace-core"
version = "0.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "lazy_static 1.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
]
[[package]]
 "tokio-io 0.1.11 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
version = "0.1.0"
dependencies = [
]
[[package]]
name = "toml"
version = "0.5.6"
 "bytes 0.5.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.3.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "idna 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "log 0.4.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "native-tls 0.2.4 (registry+https://github.com/rust-lang/crates.io-index)",
 "sasl 0.4.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio 0.2.22 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-tls 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-util 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "trust-dns-proto 0.19.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "trust-dns-resolver 0.19.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "xml5ever 0.16.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "xmpp-parsers 0.17.0 (git+https://gitlab.com/xmpp-rs/xmpp-rs)",
 "lazy_static 1.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "bytes",
 "futures",
 "idna",
 "log",
 "native-tls",
 "sasl",
 "tokio",
 "tokio-tls",
 "tokio-util",
 "trust-dns-proto",
 "trust-dns-resolver",
 "xml5ever",
 "xmpp-parsers",
version = "0.2.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
name = "tokio-xmpp"
version = "2.0.0"
source = "git+https://gitlab.com/xmpp-rs/xmpp-rs#b85aa293770d22cca11fd7ca3802b5920e1ab6fa"
source = "git+https://gitlab.com/xmpp-rs/xmpp-rs?branch=main#e1f2e2653a9c14409a04bc4fcd7b10ce842871ea"
name = "tokio-trace-core"
name = "tokio-trace-core"
version = "0.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "lazy_static 1.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "native-tls 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.25 (registry+https://github.com/rust-lang/crates.io-index)",
 "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)",
 "futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",
 "native-tls 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.25 (registry+https://github.com/rust-lang/crates.io-index)",
 "bytes 0.5.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures-core 0.3.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures-sink 0.3.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "log 0.4.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "pin-project-lite 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio 0.2.22 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.27 (registry+https://github.com/rust-lang/crates.io-index)",
 "native-tls 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",
 "bytes",
 "futures-core",
 "futures-sink",
 "log",
 "pin-project-lite",
 "tokio",
 "futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",
name = "tokio-util"
name = "tokio-tls"
version = "0.2.0"
version = "0.2.1"
version = "0.2.1"
 "crossbeam-utils 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)",
 "tokio-executor 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-executor 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-executor 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-executor 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.25 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.25 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.27 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",
 "bytes 0.5.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures-core 0.3.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures-sink 0.3.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "log 0.4.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "pin-project-lite 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio 0.2.22 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
 "crossbeam-utils 0.6.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",
 "slab 0.4.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-executor 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.2.10"
version = "0.2.10"
version = "0.2.11"
version = "0.2.10"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
name = "tokio-util"
version = "0.2.0"
name = "tokio-timer"
 "crossbeam-deque 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "crossbeam-utils 0.5.0 (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.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "num_cpus 1.8.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand 0.5.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-executor 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "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 0.6.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "crossbeam-channel 0.3.8 (registry+https://github.com/rust-lang/crates.io-index)",
 "crossbeam-deque 0.6.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "native-tls 0.2.4 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio 0.2.22 (registry+https://github.com/rust-lang/crates.io-index)",
 "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)",
 "native-tls",
 "tokio",
 "crossbeam-deque 0.7.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "crossbeam-queue 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "crossbeam-utils 0.6.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",
 "log 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "num_cpus 1.10.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand 0.6.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "slab 0.4.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-executor 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.1.14"
version = "0.1.12"
version = "0.1.13"
version = "0.1.13"
version = "0.1.11"
version = "0.1.14"
version = "0.1.13"
version = "0.1.13"
name = "tokio-tls"
version = "0.3.1"
name = "tokio-threadpool"
 "iovec 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "bytes 0.4.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.25 (registry+https://github.com/rust-lang/crates.io-index)",
 "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)",
 "bytes 0.4.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",
 "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)",
 "proc-macro2 1.0.20 (registry+https://github.com/rust-lang/crates.io-index)",
 "quote 1.0.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "syn 1.0.40 (registry+https://github.com/rust-lang/crates.io-index)",
 "bytes 0.4.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "bytes 0.4.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",
 "proc-macro2",
 "quote",
 "syn",
 "bytes 0.4.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.1.2"
version = "0.1.3"
version = "0.1.3"
name = "tokio-macros"
version = "0.2.5"
name = "tokio-sync"
version = "0.1.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "fnv 1.0.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
 "signal-hook 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)",
version = "0.1.5"
 "fnv 1.0.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.25 (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)",
 "futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.27 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.1.3"
version = "0.1.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
version = "0.1.4"
version = "0.1.1"
version = "0.1.6"
version = "0.1.4"
 "winapi 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-reactor 0.1.9 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "tokio-sync"
 "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)",
 "signal-hook 0.1.8 (registry+https://github.com/rust-lang/crates.io-index)",
 "signal-hook 0.1.8 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-executor 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-reactor 0.1.9 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "signal-hook 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-executor 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-reactor 0.1.8 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "signal-hook 0.1.9 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-executor 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "signal-hook 0.1.8 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-executor 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "signal-hook 0.1.8 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-executor 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-reactor 0.1.9 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "mio-uds 0.6.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "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)",
 "futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
 "mio 0.6.16 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.25 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.48 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.27 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.58 (registry+https://github.com/rust-lang/crates.io-index)",
 "mio 0.6.19 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",
 "mio 0.6.16 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.53 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.2.7"
version = "0.2.7"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "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-executor 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-sync 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-sync 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-sync 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-sync 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-sync 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-executor 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-sync 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-executor 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-macros 0.2.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.9 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-executor 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "tokio-signal"
 "tokio-executor 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "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)",
 "log 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "num_cpus 1.9.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "mio 0.6.19 (registry+https://github.com/rust-lang/crates.io-index)",
 "num_cpus 1.10.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "num_cpus 1.10.0 (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.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-sync 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",
 "slab 0.4.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",
 "lazy_static 1.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.25 (registry+https://github.com/rust-lang/crates.io-index)",
 "lazy_static 1.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.27 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",
 "lazy_static 1.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "mio 0.6.16 (registry+https://github.com/rust-lang/crates.io-index)",
 "crossbeam-utils 0.5.0 (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.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "log 0.4.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "crossbeam-utils 0.6.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "bytes 0.5.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "fnv 1.0.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures-core 0.3.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "iovec 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)",
 "lazy_static 1.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.76 (registry+https://github.com/rust-lang/crates.io-index)",
 "memchr 2.3.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "mio 0.6.22 (registry+https://github.com/rust-lang/crates.io-index)",
 "mio-uds 0.6.8 (registry+https://github.com/rust-lang/crates.io-index)",
 "num_cpus 1.13.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "pin-project-lite 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "signal-hook-registry 1.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "bytes",
 "fnv",
 "futures-core",
 "iovec",
 "lazy_static",
 "libc",
 "memchr",
 "mio",
 "mio-uds",
 "num_cpus",
 "pin-project-lite",
 "signal-hook-registry",
 "slab",
 "tokio-macros",
 "winapi 0.3.9",
 "crossbeam-utils 0.6.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",
 "lazy_static 1.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "log 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.1.9"
name = "tokio"
version = "0.2.22"
name = "tokio-reactor"
]
 "bytes 0.4.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",
 "log 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)",
checksum = "238ce071d267c5710f9d31451efec16c5ee22de34df17cc05e56cbc92e967117"
dependencies = [
version = "0.1.12"
version = "0.1.11"
version = "0.1.12"
version = "0.1.12"
name = "tinyvec"
version = "0.3.4"
name = "tokio-io"
 "futures 0.1.25 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-threadpool 0.1.8 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.25 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-threadpool 0.1.13 (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.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-threadpool 0.1.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.76 (registry+https://github.com/rust-lang/crates.io-index)",
 "wasi 0.10.0+wasi-snapshot-preview1 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.9 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.27 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc",
 "wasi 0.10.0+wasi-snapshot-preview1",
 "winapi 0.3.9",
 "futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-threadpool 0.1.13 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.1.6"
version = "0.1.5"
version = "0.1.6"
version = "0.1.6"
name = "time"
version = "0.1.44"
name = "tokio-fs"
 "futures 0.1.25 (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.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "lazy_static",
 "crossbeam-utils 0.6.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.1.6"
version = "0.1.7"
version = "0.1.6"
version = "0.1.7"
version = "0.1.7"
version = "0.1.7"
name = "thread_local"
version = "1.0.1"
name = "tokio-executor"
 "futures 0.1.25 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-executor 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "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)",
 "futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-executor 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "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)",
 "proc-macro2 1.0.20 (registry+https://github.com/rust-lang/crates.io-index)",
 "quote 1.0.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "syn 1.0.40 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.27 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-executor 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "proc-macro2",
 "quote",
 "syn",
 "futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-executor 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.1.5"
version = "0.1.6"
version = "0.1.4"
version = "0.1.6"
version = "0.1.6"
version = "0.1.6"
 "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)",
]
[[package]]
name = "tokio-current-thread"
 "bytes 0.4.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "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.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "bytes 0.4.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.27 (registry+https://github.com/rust-lang/crates.io-index)",
 "bytes 0.4.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",
 "bytes 0.4.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.12 (registry+https://github.com/rust-lang/crates.io-index)",
name = "thiserror-impl"
version = "1.0.20"
version = "1.0.21"
name = "tokio-codec"
version = "0.1.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)",
 "futures 0.1.25 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.25 (registry+https://github.com/rust-lang/crates.io-index)",
 "thiserror-impl 1.0.20 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.27 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",
 "thiserror-impl",
 "futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",
name = "thiserror"
version = "1.0.20"
version = "1.0.21"
name = "tokio-channel"
version = "0.1.0"
 "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)",
 "num_cpus 1.10.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "num_cpus 1.9.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "num_cpus 1.10.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "num_cpus 1.10.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "bytes 0.4.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.25 (registry+https://github.com/rust-lang/crates.io-index)",
 "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)",
 "bytes 0.4.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",
 "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)",
 "unicode-width 0.1.8 (registry+https://github.com/rust-lang/crates.io-index)",
 "bytes 0.4.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "bytes 0.4.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",
 "unicode-width",
 "bytes 0.4.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.1.18"
]
[[package]]
name = "tokio"
 "libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
 "redox_syscall 0.1.54 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)",
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
version = "0.1.42"
]
[[package]]
name = "time"
 "lazy_static 1.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
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 = [
version = "0.10.0"
version = "0.10.0"
version = "0.11.0"
version = "0.10.0"
version = "0.11.0"
version = "0.11.0"
version = "0.11.0"
 "redox_termios 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
 "libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
 "redox_syscall 0.1.54 (registry+https://github.com/rust-lang/crates.io-index)",
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
version = "1.5.1"
name = "termion"
 "winapi-util 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi-util",
 "wincolor 1.0.1 (registry+https://github.com/rust-lang/crates.io-index)",
version = "1.0.4"
version = "1.1.0"
version = "1.0.5"
version = "1.0.4"
 "utf-8 0.7.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "utf-8 0.7.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "futf",
 "mac",
 "utf-8",
 "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)",
version = "0.4.0"
version = "0.4.1"
version = "0.4.1"
 "remove_dir_all 0.5.1 (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.43 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand 0.5.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "redox_syscall 0.1.40 (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)",
 "cfg-if 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
 "cfg-if 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
 "cfg-if 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.48 (registry+https://github.com/rust-lang/crates.io-index)",
 "cfg-if 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.76 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand 0.7.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "redox_syscall 0.1.57 (registry+https://github.com/rust-lang/crates.io-index)",
 "remove_dir_all 0.5.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.9 (registry+https://github.com/rust-lang/crates.io-index)",
 "cfg-if 0.1.9 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.58 (registry+https://github.com/rust-lang/crates.io-index)",
 "cfg-if 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "cfg-if",
 "libc",
 "rand",
 "redox_syscall",
 "remove_dir_all",
 "winapi 0.3.9",
 "cfg-if 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand 0.6.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "redox_syscall 0.1.54 (registry+https://github.com/rust-lang/crates.io-index)",
version = "3.0.4"
version = "3.0.7"
version = "3.0.7"
version = "3.0.6"
version = "3.1.0"
version = "3.0.8"
version = "3.0.7"
version = "3.0.7"
 "unicode-xid 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "syn 0.15.31 (registry+https://github.com/rust-lang/crates.io-index)",
 "proc-macro2 0.4.20 (registry+https://github.com/rust-lang/crates.io-index)",
 "quote 0.6.8 (registry+https://github.com/rust-lang/crates.io-index)",
 "syn 0.15.14 (registry+https://github.com/rust-lang/crates.io-index)",
 "proc-macro2 0.4.29 (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)",
 "syn 0.15.27 (registry+https://github.com/rust-lang/crates.io-index)",
 "proc-macro2 0.4.27 (registry+https://github.com/rust-lang/crates.io-index)",
 "proc-macro2 0.4.27 (registry+https://github.com/rust-lang/crates.io-index)",
 "proc-macro2 1.0.20 (registry+https://github.com/rust-lang/crates.io-index)",
 "quote 1.0.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "syn 1.0.40 (registry+https://github.com/rust-lang/crates.io-index)",
 "unicode-xid 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "proc-macro2 0.4.30 (registry+https://github.com/rust-lang/crates.io-index)",
 "proc-macro2",
 "quote",
 "syn",
 "unicode-xid",
 "proc-macro2 0.4.27 (registry+https://github.com/rust-lang/crates.io-index)",
 "quote 0.6.12 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.10.0"
version = "0.10.1"
version = "0.10.1"
version = "0.12.4"
version = "0.10.2"
version = "0.10.1"
 "proc-macro2 1.0.20 (registry+https://github.com/rust-lang/crates.io-index)",
 "quote 1.0.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "unicode-xid 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "proc-macro2",
 "quote",
 "unicode-xid",
 "unicode-xid 0.0.4 (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"
 "proc-macro2 0.4.27 (registry+https://github.com/rust-lang/crates.io-index)",
 "quote 0.6.12 (registry+https://github.com/rust-lang/crates.io-index)",
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
version = "0.15.14"
version = "0.15.33"
version = "0.15.27"
version = "0.15.30"
version = "0.15.30"
version = "0.15.30"
version = "0.15.26"
version = "1.0.40"
version = "0.15.36"
version = "0.15.30"
version = "1.0.43"
version = "0.15.31"
checksum = "343f3f510c2915908f155e94f17220b19ccfacf2a64a2a5d8004f2c3e311e7fd"
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)",
]
checksum = "8ea5119cdb4c55b55d432abb513a0429384878c15dde60cc77b1c99de1a95a6a"
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"
[[package]]
version = "0.7.0"
version = "0.7.0"
version = "0.8.0"
version = "0.7.0"
version = "0.8.0"
version = "0.8.0"
version = "0.8.0"
name = "string_cache_shared"
version = "0.3.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
 "string_cache_shared 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "phf_generator 0.7.23 (registry+https://github.com/rust-lang/crates.io-index)",
 "phf_shared 0.7.23 (registry+https://github.com/rust-lang/crates.io-index)",
 "proc-macro2 0.4.20 (registry+https://github.com/rust-lang/crates.io-index)",
 "quote 0.6.8 (registry+https://github.com/rust-lang/crates.io-index)",
 "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)",
 "phf_generator 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "phf_shared 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "proc-macro2 1.0.20 (registry+https://github.com/rust-lang/crates.io-index)",
 "quote 1.0.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "phf_generator",
 "phf_shared",
 "proc-macro2",
 "quote",
 "phf_generator 0.7.24 (registry+https://github.com/rust-lang/crates.io-index)",
 "phf_shared 0.7.24 (registry+https://github.com/rust-lang/crates.io-index)",
 "proc-macro2 0.4.27 (registry+https://github.com/rust-lang/crates.io-index)",
 "quote 0.6.12 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.5.1"
version = "0.4.2"
 "serde 1.0.90 (registry+https://github.com/rust-lang/crates.io-index)",
 "string_cache_codegen 0.4.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "string_cache_shared 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "precomputed-hash 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "lazy_static 1.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "new_debug_unreachable 1.0.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "phf_shared 0.7.23 (registry+https://github.com/rust-lang/crates.io-index)",
 "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)",
 "lazy_static 1.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "new_debug_unreachable 1.0.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "lazy_static 1.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "new_debug_unreachable 1.0.4 (registry+https://github.com/rust-lang/crates.io-index)",
 "phf_shared 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "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)",
 "lazy_static",
 "new_debug_unreachable",
 "phf_shared",
 "precomputed-hash",
 "serde",
 "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)",
version = "0.8.0"
version = "0.7.3"
version = "0.2.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
version = "0.1.3"
[[package]]
name = "stable_deref_trait"
version = "1.1.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
name = "string"
 "cfg-if 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.43 (registry+https://github.com/rust-lang/crates.io-index)",
 "redox_syscall 0.1.40 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.6 (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)",
 "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)",
 "cfg-if 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
 "cfg-if 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
 "redox_syscall 0.1.54 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "cfg-if 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.48 (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)",
 "cfg-if 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.76 (registry+https://github.com/rust-lang/crates.io-index)",
 "redox_syscall 0.1.57 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.9 (registry+https://github.com/rust-lang/crates.io-index)",
 "cfg-if 0.1.9 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.58 (registry+https://github.com/rust-lang/crates.io-index)",
 "cfg-if 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "cfg-if",
 "libc",
 "redox_syscall",
 "winapi 0.3.9",
 "cfg-if 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
 "redox_syscall 0.1.54 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.3.8"
version = "0.3.12"
version = "0.3.9"
version = "0.3.15"
version = "0.3.8"
version = "0.6.5"
version = "0.6.9"
version = "0.6.9"
version = "0.6.8"
version = "1.4.2"
version = "0.6.10"
version = "0.6.9"
version = "0.6.9"
version = "0.4.1"
version = "0.4.2"
version = "0.4.2"
version = "0.3.3"
version = "0.2.3"
 "arc-swap 0.3.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.53 (registry+https://github.com/rust-lang/crates.io-index)",
 "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)",
 "arc-swap 0.3.10 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
 "arc-swap 0.3.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
 "arc-swap 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.48 (registry+https://github.com/rust-lang/crates.io-index)",
 "arc-swap 0.3.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.58 (registry+https://github.com/rust-lang/crates.io-index)",
 "arc-swap 0.3.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
 "arc-swap 0.3.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.1.9"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "libc 0.2.53 (registry+https://github.com/rust-lang/crates.io-index)",
 "signal-hook-registry 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "signal-hook-registry"
version = "1.0.0"
version = "0.1.8"
version = "0.1.8"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
]
[[package]]
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
name = "signal-hook-registry"
version = "1.0.1"
 "arc-swap 0.3.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
 "arc-swap 0.4.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.76 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.58 (registry+https://github.com/rust-lang/crates.io-index)",
 "signal-hook-registry 1.0.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "arc-swap",
 "libc",
checksum = "a3e12110bc539e657a646068aaf5eb5b63af9d0c1f7b29c97113fad80e15f035"
version = "0.1.8"
version = "0.1.7"
version = "0.1.9"
version = "0.1.8"
version = "0.1.8"
name = "signal-hook-registry"
version = "1.2.1"
name = "signal-hook"
 "opaque-debug 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "digest 0.8.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "keccak 0.1.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)",
 "block-buffer 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "byte-tools 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "digest 0.7.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "block-buffer 0.7.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "block-buffer 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "block-buffer 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "block-buffer 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "block-buffer 0.7.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "block-buffer 0.7.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "block-buffer 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "block-buffer 0.7.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "block-buffer 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "block-buffer 0.9.0",
 "digest 0.9.0",
 "keccak",
 "opaque-debug 0.3.0",
 "block-buffer 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "block-buffer 0.7.3 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.7.3"
version = "0.8.2"
version = "0.8.1"
version = "0.8.1"
version = "0.8.1"
version = "0.8.2"
version = "0.8.2"
version = "0.9.1"
version = "0.8.1"
 "opaque-debug 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "fake-simd 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "digest 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "block-buffer 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "byte-tools 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "digest 0.7.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "block-buffer 0.7.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "block-buffer 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "block-buffer 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "block-buffer 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "block-buffer 0.7.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "block-buffer 0.7.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "digest 0.8.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "block-buffer 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "block-buffer 0.7.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "block-buffer 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "block-buffer 0.7.3",
 "digest 0.8.1",
 "fake-simd",
 "opaque-debug 0.2.3",
]
[[package]]
name = "sha2"
version = "0.9.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "2933378ddfeda7ea26f48c555bdad8bb446bf8a3d17832dc83e380d444cfb8c1"
dependencies = [
 "block-buffer 0.9.0",
 "cfg-if",
 "cpuid-bool",
 "digest 0.9.0",
 "opaque-debug 0.3.0",
 "block-buffer 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "block-buffer 0.7.3 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.7.1"
version = "0.8.0"
version = "0.8.2"
version = "0.8.0"
 "opaque-debug 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "fake-simd 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "digest 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "block-buffer 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "byte-tools 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "digest 0.7.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "block-buffer 0.7.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "block-buffer 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "block-buffer 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "block-buffer 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "block-buffer 0.7.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "block-buffer 0.7.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "digest 0.8.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "block-buffer 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "block-buffer 0.7.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "block-buffer 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "block-buffer 0.7.3",
 "digest 0.8.1",
 "fake-simd",
 "opaque-debug 0.2.3",
]
[[package]]
name = "sha-1"
version = "0.9.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "170a36ea86c864a3f16dd2687712dd6646f7019f301e57537c7f4dc9f5916770"
dependencies = [
 "block-buffer 0.9.0",
 "cfg-if",
 "cpuid-bool",
 "digest 0.9.0",
 "opaque-debug 0.3.0",
 "block-buffer 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "block-buffer 0.7.3 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.7.0"
version = "0.8.1"
version = "0.8.2"
version = "0.8.1"
 "ryu 0.2.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde 1.0.90 (registry+https://github.com/rust-lang/crates.io-index)",
 "itoa 0.4.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "ryu 0.2.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde 1.0.90 (registry+https://github.com/rust-lang/crates.io-index)",
 "itoa 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "ryu 1.0.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde 1.0.115 (registry+https://github.com/rust-lang/crates.io-index)",
 "itoa 0.4.4 (registry+https://github.com/rust-lang/crates.io-index)",
 "ryu 0.2.8 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde 1.0.92 (registry+https://github.com/rust-lang/crates.io-index)",
 "itoa",
 "ryu",
 "serde",
 "itoa 0.4.3 (registry+https://github.com/rust-lang/crates.io-index)",
version = "1.0.32"
version = "1.0.39"
version = "1.0.38"
version = "1.0.57"
version = "1.0.39"
version = "1.0.58"
version = "1.0.39"
 "syn 0.15.31 (registry+https://github.com/rust-lang/crates.io-index)",
 "proc-macro2 0.4.20 (registry+https://github.com/rust-lang/crates.io-index)",
 "quote 0.6.8 (registry+https://github.com/rust-lang/crates.io-index)",
 "syn 0.15.14 (registry+https://github.com/rust-lang/crates.io-index)",
 "proc-macro2 0.4.29 (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)",
 "syn 0.15.27 (registry+https://github.com/rust-lang/crates.io-index)",
 "proc-macro2 0.4.27 (registry+https://github.com/rust-lang/crates.io-index)",
 "proc-macro2 0.4.27 (registry+https://github.com/rust-lang/crates.io-index)",
 "proc-macro2 1.0.20 (registry+https://github.com/rust-lang/crates.io-index)",
 "quote 1.0.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "syn 1.0.40 (registry+https://github.com/rust-lang/crates.io-index)",
 "proc-macro2 0.4.30 (registry+https://github.com/rust-lang/crates.io-index)",
 "proc-macro2",
 "quote",
 "syn",
 "proc-macro2 0.4.27 (registry+https://github.com/rust-lang/crates.io-index)",
 "quote 0.6.12 (registry+https://github.com/rust-lang/crates.io-index)",
version = "1.0.80"
version = "1.0.89"
version = "1.0.90"
version = "1.0.90"
version = "1.0.87"
version = "1.0.115"
version = "1.0.92"
version = "1.0.90"
version = "1.0.116"
version = "1.0.90"
version = "1.0.80"
version = "1.0.89"
version = "1.0.90"
version = "1.0.90"
version = "1.0.87"
version = "1.0.115"
version = "1.0.92"
version = "1.0.90"
version = "1.0.116"
version = "1.0.90"
 "tokio-channel 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "clap 2.32.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "env_logger 0.5.13 (registry+https://github.com/rust-lang/crates.io-index)",
 "hyper 0.12.13 (registry+https://github.com/rust-lang/crates.io-index)",
 "log 0.4.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "minidom 0.9.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde 1.0.80 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde_derive 1.0.80 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio 0.1.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "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)",
 "clap 2.33.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "env_logger 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "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)",
 "clap 2.33.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "env_logger 0.7.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "failure 0.1.8 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures-util 0.3.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "hyper 0.13.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "lazy_static 1.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "log 0.4.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "minidom 0.12.0 (git+https://gitlab.com/xmpp-rs/xmpp-rs)",
 "pin-project 0.4.23 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde 1.0.115 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde_derive 1.0.115 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio 0.2.22 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-xmpp 2.0.0 (git+https://gitlab.com/xmpp-rs/xmpp-rs)",
 "toml 0.5.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "xmpp-parsers 0.17.0 (git+https://gitlab.com/xmpp-rs/xmpp-rs)",
 "clap 2.33.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "env_logger 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "clap 2.33.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "env_logger 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "clap",
 "env_logger",
 "failure",
 "futures-util",
 "hyper",
 "lazy_static",
 "log",
 "minidom",
 "pin-project",
 "serde",
 "serde_derive",
 "tokio",
 "tokio-xmpp",
 "toml",
 "xmpp-parsers",
 "clap 2.33.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "env_logger 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "failure 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "hyper 0.12.27 (registry+https://github.com/rust-lang/crates.io-index)",
 "log 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "minidom 0.10.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde 1.0.90 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde_derive 1.0.90 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio 0.1.18 (registry+https://github.com/rust-lang/crates.io-index)",
name = "schannel"
 "libc 0.2.43 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.2.1"
 "libc 0.2.43 (registry+https://github.com/rust-lang/crates.io-index)",
 "security-framework-sys 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.2.1"
 "lazy_static 1.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.45 (registry+https://github.com/rust-lang/crates.io-index)",
 "MacTypes-sys 1.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.2.2"
 "libc 0.2.45 (registry+https://github.com/rust-lang/crates.io-index)",
 "security-framework-sys 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.2.1"
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "security-framework-sys 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.50 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.50 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.50 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.50 (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.45 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.45 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.47 (registry+https://github.com/rust-lang/crates.io-index)",
 "MacTypes-sys 2.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.2.3"
 "libc 0.2.47 (registry+https://github.com/rust-lang/crates.io-index)",
 "security-framework-sys 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.2.2"
 "libc 0.2.48 (registry+https://github.com/rust-lang/crates.io-index)",
 "MacTypes-sys 2.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.2.3"
 "libc 0.2.48 (registry+https://github.com/rust-lang/crates.io-index)",
 "security-framework-sys 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.2.2"
 "libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
 "MacTypes-sys 2.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.2.3"
 "security-framework-sys 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.2.2"
 "winapi 0.3.7 (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.45 (registry+https://github.com/rust-lang/crates.io-index)",
 "MacTypes-sys 1.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.2.2"
 "libc 0.2.45 (registry+https://github.com/rust-lang/crates.io-index)",
 "security-framework-sys 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.49 (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)",
 "libc 0.2.48 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.48 (registry+https://github.com/rust-lang/crates.io-index)",
 "lazy_static 1.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "lazy_static 1.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.45 (registry+https://github.com/rust-lang/crates.io-index)",
 "MacTypes-sys 1.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.2.2"
 "libc 0.2.45 (registry+https://github.com/rust-lang/crates.io-index)",
 "security-framework-sys 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.47 (registry+https://github.com/rust-lang/crates.io-index)",
 "MacTypes-sys 2.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.2.3"
 "libc 0.2.47 (registry+https://github.com/rust-lang/crates.io-index)",
 "security-framework-sys 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.2.2"
 "libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
 "lazy_static 1.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.2.1"
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "security-framework-sys 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.2.1"
 "lazy_static 1.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.2.1"
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "security-framework-sys 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[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]]
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "core-foundation-sys 0.5.1 (registry+https://github.com/rust-lang/crates.io-index)",
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
version = "0.2.1"
]
[[package]]
name = "security-framework-sys"
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "security-framework-sys 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
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)",
version = "0.2.1"
]
[[package]]
name = "scopeguard"
version = "0.3.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
name = "security-framework"
 "lazy_static 1.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "libc 0.2.48 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.48 (registry+https://github.com/rust-lang/crates.io-index)",
 "lazy_static 1.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.49 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.49 (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.44 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.2.1"
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "security-framework-sys 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.2.1"
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.2.1"
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "security-framework-sys 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.2.1"
 "libc 0.2.47 (registry+https://github.com/rust-lang/crates.io-index)",
 "MacTypes-sys 2.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.2.3"
 "libc 0.2.47 (registry+https://github.com/rust-lang/crates.io-index)",
 "security-framework-sys 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.2.2"
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.2.1"
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "security-framework-sys 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.49 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.49 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.1.15"
version = "0.1.15"
version = "0.1.14"
version = "0.1.15"
version = "0.1.14"
version = "0.1.14"
version = "0.1.14"
version = "0.1.15"
[[package]]
name = "semver-parser"
version = "0.7.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
 "base64 0.10.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "hmac 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "pbkdf2 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand_os 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "sha-1 0.8.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "sha2 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "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)",
 "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)",
 "rand_os 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
]
 "rand_os 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand_os 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand_os 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand_os 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)",
 "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)",
 "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)",
 "rand_os 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)",
 "base64 0.10.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "hmac 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "pbkdf2 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand_os 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "sha-1 0.8.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "sha2 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "base64 0.9.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "openssl 0.10.15 (registry+https://github.com/rust-lang/crates.io-index)",
 "base64 0.9.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "openssl 0.10.16 (registry+https://github.com/rust-lang/crates.io-index)",
 "openssl 0.10.15 (registry+https://github.com/rust-lang/crates.io-index)",
 "openssl 0.10.16 (registry+https://github.com/rust-lang/crates.io-index)",
 "openssl 0.10.16 (registry+https://github.com/rust-lang/crates.io-index)",
 "openssl 0.10.16 (registry+https://github.com/rust-lang/crates.io-index)",
 "openssl 0.10.15 (registry+https://github.com/rust-lang/crates.io-index)",
 "openssl 0.10.15 (registry+https://github.com/rust-lang/crates.io-index)",
 "openssl 0.10.15 (registry+https://github.com/rust-lang/crates.io-index)",
 "openssl 0.10.15 (registry+https://github.com/rust-lang/crates.io-index)",
 "base64 0.9.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "openssl 0.10.15 (registry+https://github.com/rust-lang/crates.io-index)",
 "base64 0.9.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "openssl 0.10.15 (registry+https://github.com/rust-lang/crates.io-index)",
 "base64 0.10.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "hmac 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "pbkdf2 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand_os 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "sha-1 0.8.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "sha2 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.4.3"
version = "0.4.3"
version = "0.4.3"
version = "0.4.3"
version = "0.4.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
version = "0.4.2"
version = "0.4.2"
version = "0.4.2"
version = "0.4.3"
name = "sasl"
name = "safemem"
version = "0.3.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
name = "safemem"
version = "0.3.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
version = "0.2.7"
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
name = "safemem"
version = "0.3.0"
version = "0.2.7"
version = "0.1.11"
version = "0.1.9"
version = "0.1.11"
version = "0.1.13"
version = "0.1.13"
version = "0.1.14"
version = "0.1.11"
version = "0.1.13"
version = "0.1.11"
version = "0.1.13"
version = "0.1.14"
version = "0.1.9"
version = "0.1.9"
version = "0.1.9"
version = "0.1.9"
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.1.9"
version = "0.1.9"
version = "0.1.13"
version = "0.1.9"
version = "0.6.2"
version = "0.6.2"
version = "0.6.2"
version = "0.6.2"
version = "0.6.1"
version = "0.6.1"
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.6.1"
version = "0.6.1"
version = "0.6.2"
 "winapi 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "resolv-conf"
name = "remove_dir_all"
version = "0.5.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
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]]
version = "0.6.4"
version = "0.6.3"
version = "0.6.4"
version = "0.6.4"
version = "0.6.4"
version = "0.6.4"
version = "0.6.3"
version = "0.6.3"
version = "0.6.3"
version = "0.6.3"
version = "0.6.4"
version = "0.6.3"
 "ucd-util 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "aho-corasick 0.6.9 (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]]
 "memchr 2.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "regex-syntax 0.6.4 (registry+https://github.com/rust-lang/crates.io-index)",
 "memchr 2.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "regex-syntax 0.6.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "memchr 2.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "regex-syntax 0.6.4 (registry+https://github.com/rust-lang/crates.io-index)",
 "memchr 2.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "regex-syntax 0.6.4 (registry+https://github.com/rust-lang/crates.io-index)",
 "memchr 2.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "regex-syntax 0.6.4 (registry+https://github.com/rust-lang/crates.io-index)",
 "memchr 2.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "regex-syntax 0.6.4 (registry+https://github.com/rust-lang/crates.io-index)",
 "memchr 2.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "regex-syntax 0.6.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "memchr 2.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "regex-syntax 0.6.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "memchr 2.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "regex-syntax 0.6.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "memchr 2.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "regex-syntax 0.6.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "memchr 2.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "regex-syntax 0.6.4 (registry+https://github.com/rust-lang/crates.io-index)",
 "memchr 2.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "regex-syntax 0.6.3 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.6.6"
version = "0.6.5"
version = "0.6.3"
version = "0.6.4"
version = "0.6.6"
version = "0.6.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
version = "0.6.3"
 "memchr 2.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "memchr 2.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "regex-syntax 0.6.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "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"
 "memchr 2.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "regex-syntax 0.6.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "memchr 2.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "regex-syntax 0.6.4 (registry+https://github.com/rust-lang/crates.io-index)",
 "memchr 2.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "regex-syntax 0.6.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "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)",
 "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)",
 "aho-corasick 0.7.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "aho-corasick 0.6.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "aho-corasick 0.6.9 (registry+https://github.com/rust-lang/crates.io-index)",
 "memchr 2.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "aho-corasick 0.6.9 (registry+https://github.com/rust-lang/crates.io-index)",
 "aho-corasick 0.7.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "memchr 2.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "regex-syntax 0.6.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "aho-corasick 0.6.9 (registry+https://github.com/rust-lang/crates.io-index)",
 "memchr 2.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "regex-syntax 0.6.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "aho-corasick 0.6.9 (registry+https://github.com/rust-lang/crates.io-index)",
 "memchr 2.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "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)",
 "aho-corasick 0.6.9 (registry+https://github.com/rust-lang/crates.io-index)",
 "memchr 2.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
version = "1.1.2"
version = "1.1.0"
version = "1.1.5"
version = "1.1.2"
version = "1.1.0"
version = "1.0.6"
version = "1.1.0"
version = "1.1.5"
version = "1.0.6"
version = "1.1.0"
version = "1.1.2"
version = "1.0.6"
 "redox_syscall 0.1.51 (registry+https://github.com/rust-lang/crates.io-index)",
 "redox_syscall 0.1.54 (registry+https://github.com/rust-lang/crates.io-index)",
 "redox_syscall 0.1.51 (registry+https://github.com/rust-lang/crates.io-index)",
 "redox_syscall 0.1.43 (registry+https://github.com/rust-lang/crates.io-index)",
 "redox_syscall 0.1.51 (registry+https://github.com/rust-lang/crates.io-index)",
 "redox_syscall 0.1.54 (registry+https://github.com/rust-lang/crates.io-index)",
 "redox_syscall 0.1.43 (registry+https://github.com/rust-lang/crates.io-index)",
 "redox_syscall 0.1.43 (registry+https://github.com/rust-lang/crates.io-index)",
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
version = "1.1.0"
version = "1.0.6"
version = "1.1.0"
version = "1.1.0"
version = "1.1.0"
version = "1.1.0"
version = "1.0.6"
version = "1.0.6"
version = "1.0.6"
]
[[package]]
name = "regex"
version = "1.0.6"
version = "1.1.0"
version = "1.0.6"
 "redox_syscall 0.1.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "redox_syscall 0.1.43 (registry+https://github.com/rust-lang/crates.io-index)",
 "redox_syscall 0.1.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "redox_syscall 0.1.51 (registry+https://github.com/rust-lang/crates.io-index)",
 "redox_syscall 0.1.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "redox_syscall 0.1.49 (registry+https://github.com/rust-lang/crates.io-index)",
 "redox_syscall 0.1.43 (registry+https://github.com/rust-lang/crates.io-index)",
 "redox_syscall 0.1.43 (registry+https://github.com/rust-lang/crates.io-index)",
 "redox_syscall 0.1.43 (registry+https://github.com/rust-lang/crates.io-index)",
 "redox_syscall 0.1.43 (registry+https://github.com/rust-lang/crates.io-index)",
 "redox_syscall 0.1.51 (registry+https://github.com/rust-lang/crates.io-index)",
 "redox_syscall 0.1.43 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.1.44"
version = "0.1.43"
version = "0.1.44"
version = "0.1.51"
version = "0.1.51"
version = "0.1.54"
version = "0.1.44"
version = "0.1.51"
version = "0.1.43"
version = "0.1.49"
version = "0.1.51"
version = "0.1.54"
version = "0.1.43"
version = "0.1.43"
version = "0.1.43"
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
name = "redox_termios"
version = "0.1.1"
version = "0.1.43"
version = "0.1.43"
version = "0.1.43"
version = "0.1.51"
version = "0.1.43"
name = "rdrand"
version = "0.4.0"
name = "redox_syscall"
]
[[package]]
 "rand_core 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
]
[[package]]
 "rand_core 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand_core 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
name = "rand_xorshift"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
version = "0.1.1"
version = "0.1.0"
version = "0.1.1"
version = "0.1.0"
version = "0.1.0"
 "rand_core 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
 "rand_core 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand_core 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "rustc_version 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand_core 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "rustc_version 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "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)",
 "rand_core 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "rustc_version 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand_core 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "rustc_version 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "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)",
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"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
version = "0.1.1"
version = "0.1.1"
version = "0.1.2"
version = "0.1.1"
version = "0.1.2"
 "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)",
 "libc 0.2.48 (registry+https://github.com/rust-lang/crates.io-index)",
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)",
version = "0.1.2"
]
[[package]]
name = "rand_os"
 "winapi 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand_core 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.48 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.48 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.1.2"
 "libc 0.2.48 (registry+https://github.com/rust-lang/crates.io-index)",
name = "rand_pcg"
version = "0.1.1"
]
 "winapi 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.1.3"
 "winapi 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
name = "rand_hc"
version = "0.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "rand_core 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "rand_isaac"
version = "0.1.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "rand_core 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "rdrand"
version = "0.4.0"
 "cloudabi 0.0.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "fuchsia-zircon 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.47 (registry+https://github.com/rust-lang/crates.io-index)",
 "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)",
name = "rand_os"
]
[[package]]
 "rand_core 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "rand_core 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
version = "0.1.0"
name = "rand_pcg"
version = "0.1.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "rand_core 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "rustc_version 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "rand_xorshift"
version = "0.1.0"
version = "0.1.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "rand_core 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "rdrand"
version = "0.4.0"
name = "rand_os"
version = "0.1.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "cloudabi 0.0.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "fuchsia-zircon 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.47 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand_core 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "rdrand 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
version = "0.1.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "rand_core 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
version = "0.1.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
[[package]]
 "libc 0.2.48 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.48 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.49 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.49 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.49 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.1.2"
 "libc 0.2.49 (registry+https://github.com/rust-lang/crates.io-index)",
name = "rand_jitter"
version = "0.1.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.1.3"
 "libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.6 (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)",
 "libc 0.2.49 (registry+https://github.com/rust-lang/crates.io-index)",
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)",
version = "0.1.2"
]
[[package]]
name = "rand_os"
 "winapi 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand_core 0.4.0 (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)",
 "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 = [
 "rand_core 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "rdrand 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "cloudabi 0.0.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "fuchsia-zircon 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.47 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand_core 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.1.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "rand_core 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "rand_os"
source = "registry+https://github.com/rust-lang/crates.io-index"
 "rand_core 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand_core 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand_core 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand_core 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.4.0"
version = "0.4.0"
version = "0.3.0"
version = "0.3.0"
 "rand_core 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand_core 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand_core 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand_core 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.3.1"
version = "0.3.1"
version = "0.2.2"
version = "0.2.2"
]
[[package]]
 "rand_core 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "rustc_version 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "autocfg 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.1.1"
version = "0.1.0"
version = "0.1.0"
version = "0.1.1"
 "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)",
 "rand_core 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
 "rustc_version 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "rustc_version 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "autocfg 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand_core 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "rustc_version 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.1.1"
version = "0.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
]
[[package]]
name = "rand_chacha"
version = "0.1.1"
 "winapi 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.1.0"
version = "0.1.0"
 "rand_xorshift 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand_pcg 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)",
 "rand_xorshift 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "rustc_version 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand_xorshift 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand_xorshift 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "rustc_version 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand_pcg 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand_pcg 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand_os 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand_os 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand_os 0.1.2 (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.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand_os 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand_pcg 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand_os 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand_os 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.6 (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)",
 "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_os 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand_pcg 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand_xorshift 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "rustc_version 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.50 (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)",
 "libc 0.2.50 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.48 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.48 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.48 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.49 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.49 (registry+https://github.com/rust-lang/crates.io-index)",
 "autocfg 0.1.2 (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)",
 "libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.49 (registry+https://github.com/rust-lang/crates.io-index)",
 "cloudabi 0.0.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "fuchsia-zircon 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand_chacha 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand_core 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "autocfg 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.47 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand_chacha 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "cloudabi 0.0.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "fuchsia-zircon 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand_chacha 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand_core 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "cloudabi 0.0.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "fuchsia-zircon 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand_chacha 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.6.5"
version = "0.6.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
]
[[package]]
name = "rand"
version = "0.6.4"
version = "0.6.1"
version = "0.6.1"
 "winapi 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.43 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.47 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.45 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand_os 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand_xorshift 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand_xorshift 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "rustc_version 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand_xorshift 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "rustc_version 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand_xorshift 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand_pcg 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand_os 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.45 (registry+https://github.com/rust-lang/crates.io-index)",
 "fuchsia-cprng 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand_core 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.50 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.50 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.48 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.48 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.48 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.49 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.49 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand_core 0.3.1 (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.45 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.49 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.45 (registry+https://github.com/rust-lang/crates.io-index)",
 "fuchsia-zircon 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand_core 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand_core 0.3.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)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand_chacha 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "cloudabi 0.0.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "autocfg 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.47 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand_chacha 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "cloudabi 0.0.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "fuchsia-zircon 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "cloudabi 0.0.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "fuchsia-zircon 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand_chacha 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "autocfg 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.47 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand_chacha 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.5.5"
version = "0.6.4"
version = "0.5.6"
version = "0.5.5"
version = "0.6.1"
version = "0.6.1"
version = "0.6.4"
name = "rand"
version = "0.6.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "cloudabi 0.0.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "fuchsia-zircon 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand_chacha 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand_core 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "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_pcg 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand_xorshift 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "rustc_version 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "rand_chacha"
version = "0.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "rand_core 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "rustc_version 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)",
name = "rand"
version = "0.6.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "cloudabi 0.0.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "fuchsia-zircon 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)",
name = "rand_core"
version = "0.2.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "rand_core 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "rand_core"
version = "0.3.0"
name = "rand_hc"
version = "0.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "rand_core 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "rand_isaac"
version = "0.1.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "rand_core 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "rand_pcg"
version = "0.1.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "rand_core 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "rustc_version 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "rand_xorshift"
version = "0.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "rand_core 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
version = "0.1.40"
 "redox_syscall 0.1.40 (registry+https://github.com/rust-lang/crates.io-index)",
version = "1.0.5"
 "aho-corasick 0.6.8 (registry+https://github.com/rust-lang/crates.io-index)",
 "memchr 2.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "regex-syntax 0.6.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "utf8-ranges 1.0.1 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.6.2"
 "ucd-util 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.1.9"
version = "0.2.6"
 "lazy_static 1.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.43 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.43 (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]]
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.43 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.43 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.45 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.45 (registry+https://github.com/rust-lang/crates.io-index)",
 "security-framework-sys 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "security-framework-sys"
version = "0.2.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.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.43 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.43 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.45 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.45 (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.1"
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)",
 "lazy_static 1.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "lazy_static 1.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "lazy_static 1.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "lazy_static 1.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "lazy_static 1.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
name = "safemem"
version = "0.3.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
name = "sasl"
version = "0.4.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "base64 0.9.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "openssl 0.10.15 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "schannel"
version = "0.1.14"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
version = "0.2.7"
version = "0.2.6"
version = "0.2.6"
version = "0.2.7"
version = "0.2.7"
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.1.9"
version = "0.1.11"
]
[[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.1"
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"
 "ucd-util 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "ucd-util 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "ucd-util 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "ucd-util 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "ucd-util 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
version = "0.6.4"
version = "0.6.3"
version = "0.6.2"
version = "0.6.2"
version = "0.6.3"
version = "0.6.4"
version = "0.6.3"
]
[[package]]
name = "regex-syntax"
 "utf8-ranges 1.0.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "utf8-ranges 1.0.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "utf8-ranges 1.0.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "utf8-ranges 1.0.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "utf8-ranges 1.0.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "thread_local 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "aho-corasick 0.6.9 (registry+https://github.com/rust-lang/crates.io-index)",
 "memchr 2.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "regex-syntax 0.6.4 (registry+https://github.com/rust-lang/crates.io-index)",
 "regex-syntax 0.6.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "aho-corasick 0.6.8 (registry+https://github.com/rust-lang/crates.io-index)",
 "memchr 2.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "regex-syntax 0.6.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "aho-corasick 0.6.8 (registry+https://github.com/rust-lang/crates.io-index)",
 "memchr 2.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "regex-syntax 0.6.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "aho-corasick 0.6.9 (registry+https://github.com/rust-lang/crates.io-index)",
 "memchr 2.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "regex-syntax 0.6.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "memchr 2.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "regex-syntax 0.6.4 (registry+https://github.com/rust-lang/crates.io-index)",
 "aho-corasick 0.6.9 (registry+https://github.com/rust-lang/crates.io-index)",
 "memchr 2.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "regex-syntax 0.6.3 (registry+https://github.com/rust-lang/crates.io-index)",
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
version = "1.1.0"
version = "1.0.6"
version = "1.0.5"
version = "1.0.5"
version = "1.0.6"
version = "1.1.0"
version = "1.0.6"
]
[[package]]
name = "regex"
 "redox_syscall 0.1.43 (registry+https://github.com/rust-lang/crates.io-index)",
 "redox_syscall 0.1.40 (registry+https://github.com/rust-lang/crates.io-index)",
 "redox_syscall 0.1.40 (registry+https://github.com/rust-lang/crates.io-index)",
 "redox_syscall 0.1.43 (registry+https://github.com/rust-lang/crates.io-index)",
 "redox_syscall 0.1.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "redox_syscall 0.1.43 (registry+https://github.com/rust-lang/crates.io-index)",
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 = [
version = "0.1.43"
version = "0.1.40"
version = "0.1.40"
version = "0.1.43"
version = "0.1.44"
version = "0.1.43"
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
name = "redox_syscall"
name = "rand_xorshift"
version = "0.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "rand_core 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "rand_isaac"
version = "0.1.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "rand_core 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "rand_pcg"
version = "0.1.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "rand_core 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "rustc_version 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "rand_xorshift"
version = "0.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "rand_core 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
dependencies = [
 "rand_core 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "rustc_version 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)",
]
dependencies = [
 "rand_core 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
]
name = "rand_hc"
version = "0.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
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.0 (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.0 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "rand_pcg"
version = "0.1.1"
name = "rand_chacha"
version = "0.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "rand_core 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "rustc_version 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "rand_chacha"
version = "0.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "rand_core 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "rustc_version 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
 "rand_chacha 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand_core 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "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_pcg 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand_xorshift 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "rustc_version 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.45 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.45 (registry+https://github.com/rust-lang/crates.io-index)",
[[package]]
 "winapi 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
 "winapi 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "rand"
version = "0.6.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "cloudabi 0.0.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "fuchsia-zircon 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand_chacha 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand_core 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "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_pcg 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand_xorshift 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "rustc_version 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.43 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.43 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.43 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.45 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.45 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.43 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.43 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.43 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.45 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.45 (registry+https://github.com/rust-lang/crates.io-index)",
 "proc-macro2 0.4.20 (registry+https://github.com/rust-lang/crates.io-index)",
 "proc-macro2 0.4.24 (registry+https://github.com/rust-lang/crates.io-index)",
 "proc-macro2 0.4.20 (registry+https://github.com/rust-lang/crates.io-index)",
 "proc-macro2 0.4.20 (registry+https://github.com/rust-lang/crates.io-index)",
 "proc-macro2 0.4.24 (registry+https://github.com/rust-lang/crates.io-index)",
 "proc-macro2 0.4.24 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.6.8"
version = "0.6.10"
version = "0.6.8"
version = "0.6.8"
version = "0.6.10"
version = "0.6.10"
 "memchr 2.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "memchr 2.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "log 0.4.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "memchr 2.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "log 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "memchr 2.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "log 0.4.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "memchr 2.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "log 0.4.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "memchr 2.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "log 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "log 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "memchr 2.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "encoding_rs 0.8.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "encoding_rs 0.8.13 (registry+https://github.com/rust-lang/crates.io-index)",
 "encoding_rs 0.8.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "encoding_rs 0.8.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "encoding_rs 0.8.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "encoding_rs 0.8.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "encoding_rs 0.8.13 (registry+https://github.com/rust-lang/crates.io-index)",
 "encoding_rs 0.8.12 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.4.20"
version = "0.4.24"
version = "0.4.20"
version = "0.4.20"
version = "0.4.24"
version = "0.4.24"
 "smallvec 0.6.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "smallvec 0.6.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "smallvec 0.6.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "smallvec 0.6.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "smallvec 0.6.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "smallvec 0.6.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "smallvec 0.6.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "smallvec 0.6.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.43 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.43 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.43 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.45 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.45 (registry+https://github.com/rust-lang/crates.io-index)",
 "lock_api 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)",
 "lock_api 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "lock_api 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)",
 "lock_api 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)",
 "lock_api 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "lock_api 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.3.3"
version = "0.4.0"
version = "0.3.3"
version = "0.3.3"
version = "0.4.0"
version = "0.4.0"
 "libc 0.2.43 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.43 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.43 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.45 (registry+https://github.com/rust-lang/crates.io-index)",
 "cc 1.0.25 (registry+https://github.com/rust-lang/crates.io-index)",
 "cc 1.0.25 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "cc 1.0.26 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.45 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.45 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.45 (registry+https://github.com/rust-lang/crates.io-index)",
 "lazy_static 1.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.43 (registry+https://github.com/rust-lang/crates.io-index)",
 "lazy_static 1.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "lazy_static 1.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.43 (registry+https://github.com/rust-lang/crates.io-index)",
 "lazy_static 1.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.43 (registry+https://github.com/rust-lang/crates.io-index)",
 "lazy_static 1.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "lazy_static 1.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.43 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.43 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.43 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.45 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.45 (registry+https://github.com/rust-lang/crates.io-index)",
version = "1.8.0"
version = "1.8.0"
version = "1.9.0"
name = "blake2"
version = "0.7.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "byte-tools 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "crypto-mac 0.5.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "digest 0.7.6 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "block-buffer"
version = "0.3.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "arrayref 0.3.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "byte-tools 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "byte-tools"
version = "0.2.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
name = "byteorder"
version = "1.2.7"
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
name = "bytes"
version = "0.4.10"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "byteorder 1.2.7 (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.25"
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.40 (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 = "constant_time_eq"
version = "0.1.3"
source = "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.43 (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.43 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "crossbeam-deque"
version = "0.6.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "crossbeam-epoch 0.5.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "crossbeam-utils 0.5.0 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "crossbeam-epoch"
version = "0.5.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "arrayvec 0.4.7 (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.5.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "lazy_static 1.1.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-utils"
version = "0.5.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
name = "crypto-mac"
version = "0.5.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "constant_time_eq 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "generic-array 0.9.0 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "dbghelp-sys"
version = "0.2.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "winapi 0.2.8 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi-build 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
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.7.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "generic-array 0.9.0 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "encoding_rs"
version = "0.8.10"
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)",
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "encoding_rs 0.8.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "failure 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "log 0.4.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "memchr 2.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "quick-xml"
version = "0.13.1"
]
[[package]]
name = "minidom"
version = "0.10.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "failure 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "failure_derive 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "quick-xml 0.13.1 (registry+https://github.com/rust-lang/crates.io-index)",
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.1"
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.9"
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.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
name = "safemem"
version = "0.3.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
name = "sasl"
version = "0.4.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "base64 0.9.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "openssl 0.10.15 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "schannel"
version = "0.1.14"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "lazy_static 1.1.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.1"
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.43 (registry+https://github.com/rust-lang/crates.io-index)",
 "security-framework-sys 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "security-framework-sys"
version = "0.2.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.43 (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]]
]
[[package]]
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "encoding_rs 0.8.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "failure 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "log 0.4.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "memchr 2.1.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.8"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "proc-macro2 0.4.20 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "rand"
version = "0.4.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "fuchsia-zircon 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.43 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "rand"
version = "0.5.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "cloudabi 0.0.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "fuchsia-zircon 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.43 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand_core 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "rand_core"
version = "0.2.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "rand_core 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "rand_core"
version = "0.3.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
name = "redox_syscall"
version = "0.1.40"
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.40 (registry+https://github.com/rust-lang/crates.io-index)",
name = "openssl-probe"
version = "0.1.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
name = "openssl-sys"
version = "0.9.39"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "cc 1.0.25 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.43 (registry+https://github.com/rust-lang/crates.io-index)",
 "pkg-config 0.3.14 (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.3.3"
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.6.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "lock_api 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)",
 "parking_lot_core 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "parking_lot_core"
version = "0.3.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "libc 0.2.43 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand 0.5.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.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.6 (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.23"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "phf_shared 0.7.23 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "phf_codegen"
version = "0.7.23"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "phf_generator 0.7.23 (registry+https://github.com/rust-lang/crates.io-index)",
 "phf_shared 0.7.23 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "phf_generator"
version = "0.7.23"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "phf_shared 0.7.23 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand 0.5.5 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "phf_shared"
version = "0.7.23"
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.20"
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.12.4"
]
[[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.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.43 (registry+https://github.com/rust-lang/crates.io-index)",
 "log 0.4.5 (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.1 (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.43 (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.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.43 (registry+https://github.com/rust-lang/crates.io-index)",
 "log 0.4.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "openssl 0.10.15 (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.39 (registry+https://github.com/rust-lang/crates.io-index)",
 "schannel 0.1.14 (registry+https://github.com/rust-lang/crates.io-index)",
 "security-framework 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "security-framework-sys 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "tempfile 3.0.4 (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.43 (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.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "unreachable 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "nodrop"
version = "0.1.12"
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.8.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "libc 0.2.43 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "openssl"
version = "0.10.15"
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.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.43 (registry+https://github.com/rust-lang/crates.io-index)",
 "openssl-sys 0.9.39 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "hyper"
version = "0.12.13"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "bytes 0.4.10 (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.13 (registry+https://github.com/rust-lang/crates.io-index)",
 "http 0.1.13 (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.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "net2 0.2.33 (registry+https://github.com/rust-lang/crates.io-index)",
 "time 0.1.40 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio 0.1.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-executor 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-reactor 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-tcp 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-threadpool 0.1.8 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-timer 0.2.7 (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.7 (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.43 (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.7"
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.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "failure 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "failure_derive 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "minidom 0.9.1 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[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.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "version_check 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "lazycell"
version = "1.2.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
name = "libc"
version = "0.2.43"
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.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "owning_ref 0.3.3 (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.3.9"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "log 0.4.5 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "log"
version = "0.4.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)",
]
[[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.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "phf 0.7.23 (registry+https://github.com/rust-lang/crates.io-index)",
 "phf_codegen 0.7.23 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde 1.0.80 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde_derive 1.0.80 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde_json 1.0.32 (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.0 (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.1.0"
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.43 (registry+https://github.com/rust-lang/crates.io-index)",
 "version_check 0.1.5 (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.9.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "failure 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "failure_derive 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "quick-xml 0.12.4 (registry+https://github.com/rust-lang/crates.io-index)",
name = "regex-syntax"
version = "0.6.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "ucd-util 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
]
[[package]]
name = "regex"
version = "1.0.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "aho-corasick 0.6.8 (registry+https://github.com/rust-lang/crates.io-index)",
 "memchr 2.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "regex-syntax 0.6.2 (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.1 (registry+https://github.com/rust-lang/crates.io-index)",
[[package]]
name = "humantime"
version = "1.1.1"
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 = "error-chain"
version = "0.1.12"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "backtrace 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "error-chain"
version = "0.8.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "backtrace 0.3.9 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "failure"
version = "0.1.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "backtrace 0.3.9 (registry+https://github.com/rust-lang/crates.io-index)",
 "failure_derive 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "failure_derive"
version = "0.1.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "proc-macro2 0.4.20 (registry+https://github.com/rust-lang/crates.io-index)",
 "quote 0.6.8 (registry+https://github.com/rust-lang/crates.io-index)",
 "syn 0.15.14 (registry+https://github.com/rust-lang/crates.io-index)",
 "synstructure 0.10.0 (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-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.1 (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.8.0 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "generic-array"
version = "0.9.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.13"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "byteorder 1.2.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "bytes 0.4.10 (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.13 (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.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "slab 0.4.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "string 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.10 (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.43 (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.13"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "bytes 0.4.10 (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 = "env_logger"
version = "0.5.13"
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.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "log 0.4.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "regex 1.0.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "termcolor 1.0.4 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.1.12"
[[package]]
version = "0.1.13"
version = "0.1.12"
version = "0.1.12"
version = "0.1.13"
version = "0.1.13"
 "libc 0.2.43 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.43 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.43 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.45 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.45 (registry+https://github.com/rust-lang/crates.io-index)",
 "tempfile 3.0.4 (registry+https://github.com/rust-lang/crates.io-index)",
 "tempfile 3.0.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "tempfile 3.0.4 (registry+https://github.com/rust-lang/crates.io-index)",
 "tempfile 3.0.4 (registry+https://github.com/rust-lang/crates.io-index)",
 "tempfile 3.0.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "tempfile 3.0.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.45 (registry+https://github.com/rust-lang/crates.io-index)",
 "log 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "log 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.45 (registry+https://github.com/rust-lang/crates.io-index)",
 "lazy_static 1.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.43 (registry+https://github.com/rust-lang/crates.io-index)",
 "log 0.4.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "lazy_static 1.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "log 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "lazy_static 1.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.43 (registry+https://github.com/rust-lang/crates.io-index)",
 "log 0.4.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "lazy_static 1.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.43 (registry+https://github.com/rust-lang/crates.io-index)",
 "log 0.4.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "lazy_static 1.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "lazy_static 1.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.43 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.43 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.43 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.45 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.45 (registry+https://github.com/rust-lang/crates.io-index)",
 "log 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.43 (registry+https://github.com/rust-lang/crates.io-index)",
 "log 0.4.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "log 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.43 (registry+https://github.com/rust-lang/crates.io-index)",
 "log 0.4.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "lazycell 1.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.43 (registry+https://github.com/rust-lang/crates.io-index)",
 "log 0.4.5 (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.45 (registry+https://github.com/rust-lang/crates.io-index)",
 "lazycell 1.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "log 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.45 (registry+https://github.com/rust-lang/crates.io-index)",
 "version_check 0.1.5 (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.9.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "failure 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "failure_derive 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "quick-xml 0.12.4 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[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)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.43 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.43 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.45 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.45 (registry+https://github.com/rust-lang/crates.io-index)",
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)",
version = "2.1.1"
version = "2.1.0"
version = "2.1.0"
version = "2.1.1"
version = "2.1.2"
version = "2.1.1"
]
[[package]]
name = "matches"
version = "0.1.8"
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
name = "memchr"
 "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.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "tendril 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "tendril 0.4.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "tendril 0.4.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde_json 1.0.32 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde_json 1.0.33 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde_json 1.0.32 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde_json 1.0.33 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde 1.0.80 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde_derive 1.0.80 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde_json 1.0.32 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde 1.0.80 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde_derive 1.0.80 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde 1.0.82 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde_derive 1.0.82 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde_json 1.0.33 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde 1.0.82 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde_derive 1.0.82 (registry+https://github.com/rust-lang/crates.io-index)",
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "phf 0.7.23 (registry+https://github.com/rust-lang/crates.io-index)",
 "phf_codegen 0.7.23 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.7.3"
version = "0.7.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)",
]
[[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.4.6"
version = "0.3.9"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "log 0.4.5 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.4.5"
version = "0.4.5"
version = "0.4.6"
]
[[package]]
name = "log"
]
[[package]]
name = "log"
]
[[package]]
name = "log"
version = "0.3.9"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "log 0.4.5 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.4.6"
 "scopeguard 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "owning_ref 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "owning_ref 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "owning_ref 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "owning_ref 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "owning_ref 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
version = "0.1.5"
version = "0.1.4"
version = "0.1.4"
version = "0.1.5"
version = "0.1.5"
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.2.44"
version = "0.2.43"
version = "0.2.43"
version = "0.2.44"
version = "0.2.45"
version = "0.2.44"
version = "0.2.45"
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
name = "libc"
version = "1.2.0"
version = "1.2.1"
version = "1.2.1"
[[package]]
name = "lazycell"
dependencies = [
 "version_check 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
]
dependencies = [
 "version_check 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
]
source = "registry+https://github.com/rust-lang/crates.io-index"
version = "1.2.0"
version = "1.1.0"
version = "1.1.0"
version = "1.2.0"
version = "1.2.0"
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.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "failure 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "failure_derive 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "minidom 0.9.1 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[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 = "0.1.9"
version = "0.1.7"
version = "0.1.7"
version = "0.1.9"
version = "0.1.9"
 "winapi 0.2.8 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "ipconfig"
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.43 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.43 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.45 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.45 (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.7 (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 = [
 "tokio-threadpool 0.1.9 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-timer 0.2.8 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-threadpool 0.1.8 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-timer 0.2.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-threadpool 0.1.8 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-timer 0.2.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-threadpool 0.1.9 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-timer 0.2.8 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-threadpool 0.1.9 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-timer 0.2.8 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-tcp 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-reactor 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-reactor 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-reactor 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-reactor 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-reactor 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-executor 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio 0.1.13 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio 0.1.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio 0.1.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio 0.1.13 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio 0.1.13 (registry+https://github.com/rust-lang/crates.io-index)",
 "time 0.1.40 (registry+https://github.com/rust-lang/crates.io-index)",
 "time 0.1.40 (registry+https://github.com/rust-lang/crates.io-index)",
 "time 0.1.41 (registry+https://github.com/rust-lang/crates.io-index)",
 "log 0.4.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "log 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "log 0.4.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "log 0.4.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "log 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "log 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "http 0.1.13 (registry+https://github.com/rust-lang/crates.io-index)",
 "http 0.1.14 (registry+https://github.com/rust-lang/crates.io-index)",
 "http 0.1.13 (registry+https://github.com/rust-lang/crates.io-index)",
 "http 0.1.14 (registry+https://github.com/rust-lang/crates.io-index)",
 "h2 0.1.13 (registry+https://github.com/rust-lang/crates.io-index)",
 "h2 0.1.13 (registry+https://github.com/rust-lang/crates.io-index)",
 "http 0.1.13 (registry+https://github.com/rust-lang/crates.io-index)",
 "h2 0.1.14 (registry+https://github.com/rust-lang/crates.io-index)",
 "h2 0.1.14 (registry+https://github.com/rust-lang/crates.io-index)",
 "http 0.1.14 (registry+https://github.com/rust-lang/crates.io-index)",
 "bytes 0.4.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "bytes 0.4.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "bytes 0.4.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "bytes 0.4.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "bytes 0.4.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "bytes 0.4.11 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.12.13"
version = "0.12.16"
version = "0.12.13"
version = "0.12.17"
version = "0.12.13"
version = "0.12.17"
version = "0.12.18"
version = "0.12.16"
version = "1.1.1"
version = "1.2.0"
version = "1.1.1"
version = "1.1.1"
version = "1.2.0"
version = "1.2.0"
 "bytes 0.4.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "bytes 0.4.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "bytes 0.4.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "bytes 0.4.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "bytes 0.4.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "bytes 0.4.11 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.1.13"
version = "0.1.14"
version = "0.1.13"
version = "0.1.13"
version = "0.1.14"
version = "0.1.14"
 "libc 0.2.43 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.43 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.43 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.45 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.45 (registry+https://github.com/rust-lang/crates.io-index)",
 "string 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "string 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "string 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "string 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "string 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "string 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "log 0.4.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "log 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "log 0.4.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "log 0.4.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "log 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "log 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "http 0.1.13 (registry+https://github.com/rust-lang/crates.io-index)",
 "http 0.1.14 (registry+https://github.com/rust-lang/crates.io-index)",
 "http 0.1.13 (registry+https://github.com/rust-lang/crates.io-index)",
 "http 0.1.13 (registry+https://github.com/rust-lang/crates.io-index)",
 "http 0.1.14 (registry+https://github.com/rust-lang/crates.io-index)",
 "http 0.1.14 (registry+https://github.com/rust-lang/crates.io-index)",
 "bytes 0.4.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "bytes 0.4.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "bytes 0.4.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "bytes 0.4.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "bytes 0.4.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "bytes 0.4.11 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.1.13"
version = "0.1.13"
version = "0.1.14"
version = "0.1.14"
 "num_cpus 1.8.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "num_cpus 1.8.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "num_cpus 1.9.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "syn 0.15.22 (registry+https://github.com/rust-lang/crates.io-index)",
 "syn 0.15.23 (registry+https://github.com/rust-lang/crates.io-index)",
 "synstructure 0.10.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "proc-macro2 0.4.20 (registry+https://github.com/rust-lang/crates.io-index)",
 "quote 0.6.8 (registry+https://github.com/rust-lang/crates.io-index)",
 "syn 0.15.14 (registry+https://github.com/rust-lang/crates.io-index)",
 "synstructure 0.10.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "proc-macro2 0.4.24 (registry+https://github.com/rust-lang/crates.io-index)",
 "quote 0.6.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "syn 0.15.22 (registry+https://github.com/rust-lang/crates.io-index)",
 "synstructure 0.10.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "proc-macro2 0.4.20 (registry+https://github.com/rust-lang/crates.io-index)",
 "quote 0.6.8 (registry+https://github.com/rust-lang/crates.io-index)",
 "syn 0.15.14 (registry+https://github.com/rust-lang/crates.io-index)",
 "synstructure 0.10.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "proc-macro2 0.4.20 (registry+https://github.com/rust-lang/crates.io-index)",
 "quote 0.6.8 (registry+https://github.com/rust-lang/crates.io-index)",
 "syn 0.15.14 (registry+https://github.com/rust-lang/crates.io-index)",
 "synstructure 0.10.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "proc-macro2 0.4.24 (registry+https://github.com/rust-lang/crates.io-index)",
 "quote 0.6.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "proc-macro2 0.4.24 (registry+https://github.com/rust-lang/crates.io-index)",
 "quote 0.6.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "syn 0.15.22 (registry+https://github.com/rust-lang/crates.io-index)",
 "synstructure 0.10.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "backtrace 0.3.9 (registry+https://github.com/rust-lang/crates.io-index)",
 "backtrace 0.3.9 (registry+https://github.com/rust-lang/crates.io-index)",
 "backtrace 0.3.13 (registry+https://github.com/rust-lang/crates.io-index)",
 "backtrace 0.3.9 (registry+https://github.com/rust-lang/crates.io-index)",
 "backtrace 0.3.9 (registry+https://github.com/rust-lang/crates.io-index)",
 "backtrace 0.3.13 (registry+https://github.com/rust-lang/crates.io-index)",
 "regex 1.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "regex 1.0.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "regex 1.0.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "regex 1.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "humantime 1.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "log 0.4.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "regex 1.0.5 (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)",
 "humantime 1.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "log 0.4.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "regex 1.0.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "humantime 1.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "log 0.4.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "regex 1.0.5 (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)",
 "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.0.6 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.5.13"
version = "0.6.0"
version = "0.5.13"
version = "0.5.13"
version = "0.6.0"
version = "0.6.0"
version = "0.8.10"
version = "0.8.13"
version = "0.8.12"
version = "0.8.10"
version = "0.8.10"
version = "0.8.12"
version = "0.8.13"
version = "0.8.12"
dependencies = [
 "cfg-if 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
]
dependencies = [
 "cfg-if 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
]
dependencies = [
 "cfg-if 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
]
version = "0.5.0"
version = "0.6.1"
version = "0.5.0"
version = "0.5.0"
version = "0.6.1"
version = "0.6.3"
version = "0.6.1"
version = "0.6.2"
 "lazy_static 1.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "lazy_static 1.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "crossbeam-utils 0.5.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "lazy_static 1.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "crossbeam-utils 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "lazy_static 1.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "crossbeam-utils 0.5.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "lazy_static 1.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "crossbeam-utils 0.5.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "lazy_static 1.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "crossbeam-utils 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "crossbeam-utils 0.6.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "crossbeam-utils 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "crossbeam-utils 0.6.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "arrayvec 0.4.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "arrayvec 0.4.8 (registry+https://github.com/rust-lang/crates.io-index)",
 "arrayvec 0.4.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "arrayvec 0.4.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "arrayvec 0.4.8 (registry+https://github.com/rust-lang/crates.io-index)",
 "arrayvec 0.4.8 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.5.2"
version = "0.6.1"
version = "0.5.2"
version = "0.5.2"
version = "0.6.1"
version = "0.6.1"
 "crossbeam-utils 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "crossbeam-utils 0.6.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "crossbeam-utils 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "crossbeam-utils 0.6.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "crossbeam-epoch 0.5.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "crossbeam-utils 0.5.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "crossbeam-epoch 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "crossbeam-utils 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "crossbeam-epoch 0.5.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "crossbeam-utils 0.5.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "crossbeam-epoch 0.5.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "crossbeam-utils 0.5.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "crossbeam-epoch 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "crossbeam-epoch 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.6.1"
version = "0.6.2"
version = "0.6.1"
version = "0.6.1"
version = "0.6.2"
version = "0.6.2"
 "libc 0.2.43 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.43 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.43 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.45 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.45 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.43 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.43 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.43 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.45 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.45 (registry+https://github.com/rust-lang/crates.io-index)",
 "time 0.1.40 (registry+https://github.com/rust-lang/crates.io-index)",
 "time 0.1.40 (registry+https://github.com/rust-lang/crates.io-index)",
 "time 0.1.41 (registry+https://github.com/rust-lang/crates.io-index)",
version = "1.0.25"
version = "1.0.25"
version = "1.0.26"
version = "0.4.10"
version = "0.4.11"
version = "0.4.10"
version = "0.4.10"
version = "0.4.11"
version = "0.4.11"
 "libc 0.2.43 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.43 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.43 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.45 (registry+https://github.com/rust-lang/crates.io-index)",
 "cc 1.0.25 (registry+https://github.com/rust-lang/crates.io-index)",
 "cc 1.0.25 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "cc 1.0.26 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.45 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.1.24"
version = "0.1.24"
version = "0.1.26"
 "rustc-demangle 0.1.9 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.43 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.43 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.43 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "rustc-demangle 0.1.9 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.45 (registry+https://github.com/rust-lang/crates.io-index)",
 "rustc-demangle 0.1.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.45 (registry+https://github.com/rust-lang/crates.io-index)",
 "backtrace-sys 0.1.24 (registry+https://github.com/rust-lang/crates.io-index)",
 "backtrace-sys 0.1.24 (registry+https://github.com/rust-lang/crates.io-index)",
 "autocfg 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "backtrace-sys 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.3.9"
version = "0.3.9"
version = "0.3.13"
 "rustc-demangle 0.1.9 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.43 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.43 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.43 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "rustc-demangle 0.1.9 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.45 (registry+https://github.com/rust-lang/crates.io-index)",
 "rustc-demangle 0.1.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.45 (registry+https://github.com/rust-lang/crates.io-index)",
 "backtrace-sys 0.1.24 (registry+https://github.com/rust-lang/crates.io-index)",
 "backtrace-sys 0.1.24 (registry+https://github.com/rust-lang/crates.io-index)",
 "backtrace-sys 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",
[[package]]
name = "autocfg"
version = "0.1.1"
source = "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)",
]
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.43 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.43 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.45 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.45 (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 = [
 "nodrop 0.1.13 (registry+https://github.com/rust-lang/crates.io-index)",
 "nodrop 0.1.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "nodrop 0.1.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "nodrop 0.1.13 (registry+https://github.com/rust-lang/crates.io-index)",
 "nodrop 0.1.13 (registry+https://github.com/rust-lang/crates.io-index)",
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
version = "0.4.8"
version = "0.4.7"
version = "0.4.7"
version = "0.4.8"
version = "0.4.8"
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
name = "arrayref"
version = "0.3.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
name = "arrayvec"
version = "0.3.6"
version = "0.3.4"
version = "0.3.4"
version = "0.3.6"
version = "0.3.6"
]
[[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"
 "memchr 2.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "memchr 2.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "memchr 2.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "memchr 2.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "memchr 2.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "memchr 2.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
version = "0.6.9"
[[package]]
name = "MacTypes-sys"
version = "2.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
]
name = "aho-corasick"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "043164d8ba5c4c3035fec9bbee8647c0261d788f3474306f93bb65901cae0e86"
dependencies = [
]
[[package]]
name = "ansi_term"
version = "0.11.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ee49baf6cb617b853aa8d93bf420db2383fab46d314482ca2803b40d5fde979b"
dependencies = [
]
[[package]]
name = "arc-swap"
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
name = "arrayvec"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "b246867b8b3b6ae56035f1eb1ed557c1d8eae97f0d53696138a50fa0e3a3b8c0"
dependencies = [
]
[[package]]
name = "atty"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d9b39be18770d11421cdb1b9947a45dd3f37e93092cbf377614828a319d5fee8"
dependencies = [
 "winapi 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "backtrace-sys 0.1.24 (registry+https://github.com/rust-lang/crates.io-index)",
 "cfg-if 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "dbghelp-sys 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "kernel32-sys 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.43 (registry+https://github.com/rust-lang/crates.io-index)",
 "rustc-demangle 0.1.9 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.2.8 (registry+https://github.com/rust-lang/crates.io-index)",
]
checksum = "cdb031dd78e28731d87d56cc8ffef4a8f36ca26c38fe2de700543e627f8a464a"
[[package]]
name = "backtrace"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f813291114c186a042350e787af10c26534601062603d888be110f59f85ef8fa"
dependencies = [
 "backtrace-sys 0.1.28 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.53 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
 "rustc-demangle 0.1.14 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "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)",
 "cfg-if 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
 "rustc-demangle 0.1.14 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "cfg-if 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
 "rustc-demangle 0.1.14 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "cfg-if 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.48 (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)",
 "cfg-if 0.1.9 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.58 (registry+https://github.com/rust-lang/crates.io-index)",
 "rustc-demangle 0.1.15 (registry+https://github.com/rust-lang/crates.io-index)",
 "cfg-if 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
version = "0.1.24"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "0b25d992356d2eb0ed82172f5248873db5560c4721f564b13cb5193bda5e668e"
dependencies = [
 "libc 0.2.53 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "base64"
source = "registry+https://github.com/rust-lang/crates.io-index"
 "byteorder 1.2.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "safemem 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "byteorder 1.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "byteorder 1.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "byteorder 1.3.2 (registry+https://github.com/rust-lang/crates.io-index)",
[[package]]
name = "bitflags"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "cf1de2fe8c75bc145a2f577add951f8134889b4795d47466a54a5c846d691693"
[[package]]
name = "blake2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "84ce5b6108f8e154604bd4eb76a2f726066c3464d5a552a4229262a18c9bb471"
dependencies = [
 "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)",
 "digest 0.8.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "opaque-debug 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "block-buffer"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "c0940dc441f31689269e10ac70eb1002a3a1d3ad1390e030043662eb7fe4688b"
dependencies = [
 "byte-tools 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "block-padding"
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)",
 "byte-tools",
checksum = "fa79dedbb091f449f1f39e53edf88d5dbe95f895dae6135a8d7b881fb5af73f5"
version = "0.1.4"
version = "0.1.3"
version = "0.1.3"
version = "0.1.3"
version = "0.1.5"
version = "0.1.4"
 "generic-array 0.12.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "byteorder 1.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "byteorder 1.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "byteorder 1.3.4 (registry+https://github.com/rust-lang/crates.io-index)",
 "generic-array 0.12.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "byteorder 1.3.2 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "block-padding"
version = "0.2.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "8d696c370c750c948ada61c69a0ee2cbbb9c50b1019ddb86d9317157a99c2cae"
[[package]]
name = "byte-tools"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "e3b5ca7a04898ad4bcd41c90c5285445ff5b791899bb1b0abdd2a2aa791211d7"
[[package]]
name = "byteorder"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "08c48aae112d48ed9f069b33538ea9e3e90aa263cfa3d1c24309612b1f7472de"
[[package]]
name = "bytes"
source = "registry+https://github.com/rust-lang/crates.io-index"
 "byteorder 1.2.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "byteorder 1.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "byteorder 1.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "byteorder 1.3.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "either 1.5.2 (registry+https://github.com/rust-lang/crates.io-index)",
[[package]]
name = "cc"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ed67cbde08356238e75fc4656be4749481eeffb09e19f320a25237d5221c985d"
[[package]]
name = "cfg-if"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "4785bdd1c96b2a846b2bd7cc02e86b6b3dbf14e7e53446c4f54c92a361040822"
[[package]]
name = "chrono"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "670ad68c9088c2a963aaa298cb369688cf3f9465ce5e2d4ca10e6e0098a1ce73"
dependencies = [
 "time 0.1.40 (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"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "37e58ac78573c40708d45522f0d80fa2f01cc4f9b4e2bf749807255454312002"
dependencies = [
 "atty 0.2.14 (registry+https://github.com/rust-lang/crates.io-index)",
 "bitflags 1.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "unicode-width 0.1.8 (registry+https://github.com/rust-lang/crates.io-index)",
 "vec_map 0.8.2 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "cloudabi"
version = "0.0.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ddfc5b9aa5d4507acaf872de71051dfd0e309860e88966e1051e462a077aac4f"
dependencies = [
]
[[package]]
name = "constant_time_eq"
version = "0.1.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
name = "core-foundation"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "57d24c7a13c43e870e37c1556b74555437870a04514f7685f5b354e090567171"
dependencies = [
 "libc 0.2.43 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.48 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "core-foundation-sys"
source = "registry+https://github.com/rust-lang/crates.io-index"
 "arrayvec 0.4.7 (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.5.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "lazy_static 1.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "arrayvec 0.4.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "cfg-if 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "lazy_static 1.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
name = "crossbeam-utils"
version = "0.5.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
 "crossbeam-epoch 0.7.1 (registry+https://github.com/rust-lang/crates.io-index)",
[[package]]
 "cfg-if 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "lazy_static 1.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
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]]
 "constant_time_eq 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "generic-array 0.9.0 (registry+https://github.com/rust-lang/crates.io-index)",
name = "dbghelp-sys"
version = "0.2.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "4434400df11d95d556bac068ddfedd482915eb18fe8bea89bc80b6e4b1c179e5"
dependencies = [
 "subtle 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "digest"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f3d0c8c8752312f9713efd397ff63acb9f85585afbf179282e720e7704954dd5"
dependencies = [
]
[[package]]
version = "0.8.10"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "7c5f0096a91d210159eceb2ff5e1c4da18388a170e1e3ce948aac9c8fdbbf595"
dependencies = [
]
[[package]]
name = "env_logger"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "44533bbbb3bb3c1fa17d9f2e4e38bbbaf8396ba82193c4cb1b6445d711445d36"
dependencies = [
 "humantime 1.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "log 0.4.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "regex 1.0.5 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "error-chain"
version = "0.1.12"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "backtrace 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "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)",
 "termcolor 1.0.4 (registry+https://github.com/rust-lang/crates.io-index)",
 "regex 1.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "regex 1.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "regex 1.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "termcolor 1.0.4 (registry+https://github.com/rust-lang/crates.io-index)",
 "regex 1.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "regex 1.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "regex 1.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "termcolor 1.0.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "regex 1.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
 "backtrace 0.3.9 (registry+https://github.com/rust-lang/crates.io-index)",
 "backtrace 0.3.14 (registry+https://github.com/rust-lang/crates.io-index)",
 "backtrace 0.3.15 (registry+https://github.com/rust-lang/crates.io-index)",
 "backtrace 0.3.15 (registry+https://github.com/rust-lang/crates.io-index)",
 "backtrace 0.3.13 (registry+https://github.com/rust-lang/crates.io-index)",
 "backtrace 0.3.30 (registry+https://github.com/rust-lang/crates.io-index)",
 "backtrace 0.3.15 (registry+https://github.com/rust-lang/crates.io-index)",
name = "failure"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d32e9bd16cc02eae7db7ef620b392808b89f6a5e16bb3497d159c6b92a0f4f86"
dependencies = [
 "failure_derive 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "failure_derive"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "aa4da3c766cd7a0db8242e326e9e4e081edd567072893ed320008189715366a4"
dependencies = [
 "syn 0.15.30 (registry+https://github.com/rust-lang/crates.io-index)",
 "synstructure 0.10.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "quote 0.6.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "syn 0.15.30 (registry+https://github.com/rust-lang/crates.io-index)",
 "quote 0.6.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "syn 0.15.26 (registry+https://github.com/rust-lang/crates.io-index)",
 "quote 0.6.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "syn 0.15.30 (registry+https://github.com/rust-lang/crates.io-index)",
 "synstructure 0.10.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "syn 0.15.36 (registry+https://github.com/rust-lang/crates.io-index)",
 "synstructure 0.10.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "quote 0.6.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "syn 0.15.33 (registry+https://github.com/rust-lang/crates.io-index)",
 "syn 0.15.30 (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"
checksum = "e88a8acf291dafb59c2d96e8f59828f3838bb1a70398823ade51a84de6a6deed"
[[package]]
name = "fnv"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "3f9eec918d3f24069decb9af1554cad7c880e2da24a9afd88aca000531ab82c1"
[[package]]
name = "foreign-types"
version = "0.3.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f6f339eb8adc052cd2ca78910fda869aefa38d22d5cb648e6485e4d3fc06f3b1"
dependencies = [
]
[[package]]
name = "foreign-types-shared"
version = "0.1.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "00b0228411908ca8685dba7fc2cdd70ec9990a6e753e89b6ac91a84c40fbaf4b"
[[package]]
name = "fuchsia-zircon"
version = "0.3.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "2e9763c69ebaae630ba35f74888db465e49e259ba1bc0eda7d06f4a067615d82"
dependencies = [
 "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"
checksum = "3dcaa9ae7725d12cdb85b3ad99a434db70b468c09ded17e012d86b5c1010f7a7"
[[package]]
name = "futf"
version = "0.1.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "7c9c1ce3fa9336301af935ab852c437817d14cd33690446569392e65170aac3b"
dependencies = [
 "new_debug_unreachable 1.0.1 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "futures"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
]
[[package]]
name = "futures-channel"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
]
[[package]]
name = "futures-core"
version = "0.3.5"
version = "0.3.6"
 "futures-core 0.3.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures-sink 0.3.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures-core",
 "futures-sink",
checksum = "a7a4d35f7401e948629c9c3d6638fb9bf94e0b2121e96c3b428cc4e631f3eb74"
version = "0.3.5"
version = "0.3.6"
 "futures-channel 0.3.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures-core 0.3.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures-executor 0.3.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures-io 0.3.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures-sink 0.3.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures-task 0.3.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures-util 0.3.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures-channel",
 "futures-core",
 "futures-executor",
 "futures-io",
 "futures-sink",
 "futures-task",
 "futures-util",
checksum = "5d8e3078b7b2a8a671cb7a3d17b4760e4181ea243227776ba83fd043b4ca034e"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d674eaa0056896d5ada519900dbf97ead2e46a7b6621e8160d79e2f2e1e2784b"
[[package]]
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f57ed14da4603b2554682e9f2ff3c65d7567b53188db96cb71538217fc64581b"
dependencies = [
]
[[package]]
name = "futures-sink"
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
name = "futures-task"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
]
[[package]]
name = "futures-util"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "futures-channel 0.3.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures-core 0.3.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures-io 0.3.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures-macro 0.3.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures-sink 0.3.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures-task 0.3.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "memchr 2.3.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "pin-project 0.4.23 (registry+https://github.com/rust-lang/crates.io-index)",
 "pin-utils 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "proc-macro-hack 0.5.18 (registry+https://github.com/rust-lang/crates.io-index)",
 "proc-macro-nested 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "slab 0.4.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures-channel",
 "futures-core",
 "futures-io",
 "futures-macro",
 "futures-sink",
 "futures-task",
 "memchr",
 "pin-project",
 "pin-utils",
 "proc-macro-hack",
 "proc-macro-nested",
 "slab",
checksum = "8a894a0acddba51a2d49a6f4263b1e64b8c579ece8af50fa86503d52cd1eea34"
version = "0.3.5"
version = "0.3.6"
 "once_cell 1.4.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "once_cell",
checksum = "4dd26820a9f3637f1302da8bceba3ff33adbe53464b54ca24d4e2d4f1db30f94"
version = "0.3.5"
version = "0.3.6"
checksum = "0d8764258ed64ebc5d9ed185cf86a95db5cac810269c5d20ececb32e0088abbd"
version = "0.3.5"
version = "0.3.6"
 "num_cpus 1.10.0 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "generic-array"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "fc587bc0ec293155d5bfa6b9891ec18a1e330c234f896ea47fbada4cadbe47e6"
dependencies = [
]
[[package]]
name = "gimli"
version = "0.22.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
checksum = "aaf91faf136cb47367fa430cd46e37a788775e7fa104f8b4bcb3861dc389b724"
name = "h2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "993f9e0baeed60001cf565546b0d3dbe6a6ad23f2bd31644a133c641eccf6d53"
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)",
 "http 0.1.13 (registry+https://github.com/rust-lang/crates.io-index)",
 "log 0.4.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "slab 0.4.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "string 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "hostname"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "3c731c3e10504cc8ed35cfe2f1db4c9274c3d35fa486e3b31df46f068ef3e867"
dependencies = [
]
[[package]]
name = "http"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "13d5ff830006f7646652e057693569bfe0d51760c0085a071769d142a205111b"
dependencies = [
]
[[package]]
name = "httparse"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "494b4d60369511e7dea41cf646832512a94e542f68bb9c49e54518e0f468eb47"
[[package]]
name = "humantime"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "df004cfca50ef23c36850aaaa59ad52cc70d0e90243c3c7737a4dd32dc7a3c4f"
dependencies = [
]
[[package]]
name = "hyper"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "2f3afcfae8af5ad0576a31e768415edb627824129e8e5a29b8bfccb2f234e835"
dependencies = [
 "futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",
 "h2 0.1.13 (registry+https://github.com/rust-lang/crates.io-index)",
 "http 0.1.13 (registry+https://github.com/rust-lang/crates.io-index)",
 "itoa 0.4.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "net2 0.2.33 (registry+https://github.com/rust-lang/crates.io-index)",
 "time 0.1.42 (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-threadpool 0.1.14 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-threadpool 0.1.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-threadpool 0.1.13 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-timer 0.2.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-threadpool 0.1.13 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-threadpool 0.1.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-threadpool 0.1.14 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-timer 0.2.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-threadpool 0.1.13 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-executor 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-reactor 0.1.9 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-executor 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio 0.1.19 (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 0.1.18 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio 0.1.18 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-executor 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-reactor 0.1.9 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio 0.1.15 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-executor 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-reactor 0.1.8 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio 0.1.21 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-buf 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio 0.1.18 (registry+https://github.com/rust-lang/crates.io-index)",
 "want 0.0.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "time 0.1.40 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio 0.1.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-executor 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-reactor 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-tcp 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-threadpool 0.1.8 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-timer 0.2.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "rustc_version 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "rustc_version 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "rustc_version 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "time 0.1.42 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio 0.1.18 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-executor 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-reactor 0.1.9 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-tcp 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-threadpool 0.1.13 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-timer 0.2.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "itoa 0.4.4 (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.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "log 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "log 0.4.6 (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)",
 "h2 0.1.18 (registry+https://github.com/rust-lang/crates.io-index)",
 "http-body 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "h2 0.1.18 (registry+https://github.com/rust-lang/crates.io-index)",
 "http 0.1.17 (registry+https://github.com/rust-lang/crates.io-index)",
 "h2 0.1.16 (registry+https://github.com/rust-lang/crates.io-index)",
 "http 0.1.15 (registry+https://github.com/rust-lang/crates.io-index)",
 "http 0.1.17 (registry+https://github.com/rust-lang/crates.io-index)",
 "httparse 1.3.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "iovec 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "h2 0.1.23 (registry+https://github.com/rust-lang/crates.io-index)",
 "h2 0.1.18 (registry+https://github.com/rust-lang/crates.io-index)",
 "http 0.1.17 (registry+https://github.com/rust-lang/crates.io-index)",
 "h2 0.1.18 (registry+https://github.com/rust-lang/crates.io-index)",
 "http 0.1.17 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.27 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "idna"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "02e2673c30ee86b5b96a9cb52ad15718aa1f966f5ab9ad54a8b95d5ca33120a9"
dependencies = [
 "unicode-normalization 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "indexmap"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
]
 "autocfg 1.0.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "hashbrown 0.9.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "autocfg",
 "hashbrown",
checksum = "55e2e4c765aa53a0424761bf9f41aa7a6ac1efa87238f59560640e27fca028f2"
[[package]]
name = "iovec"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "b2b3ea6ff95e175473f8ffe6a7eb7c00d054240321b84c57051175fe3c1e075e"
dependencies = [
]
[[package]]
name = "ipconfig"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f7e2f18aece9709094573a9f24f483c4f65caa4298e2f7ae1b71cc65d853fad7"
dependencies = [
 "socket2 0.3.8 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "winreg 0.5.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "socket2 0.3.9 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "itoa"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "dc6f3ad7b9d11a0c00842ff8de1b60ee58661048eb8049ed33c73594f359d7e6"
[[package]]
name = "jid"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "3d9f987c3ff1c2c7d477c9e0a3dc25cc58ea97692b19a53018089109445b4ab3"
dependencies = [
]
[[package]]
name = "keccak"
version = "0.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "67c21572b4949434e4fc1e1978b99c5f77064153c59d998bf13ecd96fb5ecba7"
[[package]]
name = "kernel32-sys"
version = "0.2.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "7507624b29483431c0ba2d82aece8ca6cdba9382bff4ddd0f7490560c056098d"
dependencies = [
]
[[package]]
name = "lazy_static"
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"
dependencies = [
 "version_check 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
]
checksum = "e2abad23fbc42b3700f2f279844dc832adb2b2eb069b2df918f455c4e18cc646"
[[package]]
version = "1.2.0"
version = "1.2.1"
name = "libc"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "2448f6066e80e3bfc792e9c98bf705b4b0fc6e8ef5b43e5889aff0eaa9c58743"
[[package]]
name = "linked-hash-map"
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
name = "lock_api"
source = "registry+https://github.com/rust-lang/crates.io-index"
 "owning_ref 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "owning_ref 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "log"
[[package]]
name = "log"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
]
[[package]]
name = "lru-cache"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "31e24f1ad8321ca0e8a1e0ac13f23cb668e6f5466c2c57319f6a5cf1cc8e3b1c"
dependencies = [
]
[[package]]
name = "mac"
version = "0.1.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "c41e0c4fef86961ac6d6f8a82609f55f31b05e4fce149ac5710e439df7619ba4"
[[package]]
name = "markup5ever"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "aae38d669396ca9b707bfc3db254bc382ddb94f57cc5c235f34623a669a01dab"
dependencies = [
 "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)",
 "tendril 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "match_cfg"
version = "0.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
checksum = "ffbee8634e0d45d258acb448e7eaab3fce7a0a467395d4d9f228e3c1f01fb2e4"
name = "matches"
version = "0.1.8"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "7ffc5c5338469d4d3ea17d269fa8ea3512ad247247c30bd2df69e68309ed0a08"
[[package]]
name = "memchr"
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.43 (registry+https://github.com/rust-lang/crates.io-index)",
 "version_check 0.1.5 (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.48 (registry+https://github.com/rust-lang/crates.io-index)",
]
checksum = "3728d817d99e5ac407411fa471ff9800a778d88a24685968b36824eaf4bee400"
[[package]]
[[package]]
version = "0.9.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "0f2d26ec3309788e423cfbf68ad1800f061638098d76a83681af979dc4eda19d"
dependencies = [
 "quick-xml 0.13.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "quick-xml 0.13.2 (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"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "fce347092656428bc8eaf6201042cb551b8d67855af7374542a92a0fbfcac430"
dependencies = [
 "cfg-if 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "iovec 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)",
 "lazycell 1.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.43 (registry+https://github.com/rust-lang/crates.io-index)",
 "log 0.4.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "net2 0.2.35 (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"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "afcb699eb26d4332647cc848492bbc15eafb26f08d0304550d5aa1f612e066f0"
dependencies = [
 "libc 0.2.43 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.53 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.49 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
 "mio 0.6.16 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.48 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.58 (registry+https://github.com/rust-lang/crates.io-index)",
 "mio 0.6.19 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.51 (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"
checksum = "8c1f2f3b1cf331de6896aabf6e9d55dca90356cc9960cca7eaaf408a355ae919"
dependencies = [
 "net2 0.2.35 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "native-tls"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "2b0d88c06fe90d5ee94048ba40409ef1d9315d86f6f38c2efdaad4fb50c58b2d"
dependencies = [
 "libc 0.2.53 (registry+https://github.com/rust-lang/crates.io-index)",
 "openssl 0.10.19 (registry+https://github.com/rust-lang/crates.io-index)",
 "openssl-sys 0.9.39 (registry+https://github.com/rust-lang/crates.io-index)",
 "schannel 0.1.14 (registry+https://github.com/rust-lang/crates.io-index)",
 "security-framework 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "security-framework-sys 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "tempfile 3.0.4 (registry+https://github.com/rust-lang/crates.io-index)",
 "openssl-sys 0.9.42 (registry+https://github.com/rust-lang/crates.io-index)",
 "security-framework 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "security-framework-sys 0.3.1 (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)",
 "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)",
 "tempfile 3.0.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "tempfile 3.0.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "security-framework 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "security-framework-sys 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "tempfile 3.0.8 (registry+https://github.com/rust-lang/crates.io-index)",
 "tempfile 3.0.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "openssl-sys 0.9.43 (registry+https://github.com/rust-lang/crates.io-index)",
 "openssl-sys 0.9.43 (registry+https://github.com/rust-lang/crates.io-index)",
 "schannel 0.1.15 (registry+https://github.com/rust-lang/crates.io-index)",
 "security-framework 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "security-framework-sys 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "openssl-sys 0.9.40 (registry+https://github.com/rust-lang/crates.io-index)",
 "schannel 0.1.14 (registry+https://github.com/rust-lang/crates.io-index)",
 "openssl-sys 0.9.58 (registry+https://github.com/rust-lang/crates.io-index)",
 "schannel 0.1.19 (registry+https://github.com/rust-lang/crates.io-index)",
 "security-framework 0.4.4 (registry+https://github.com/rust-lang/crates.io-index)",
 "security-framework-sys 0.4.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "tempfile 3.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "openssl-sys 0.9.47 (registry+https://github.com/rust-lang/crates.io-index)",
 "openssl-sys 0.9.43 (registry+https://github.com/rust-lang/crates.io-index)",
 "schannel 0.1.15 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "net2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "3ebc3ec692ed7c9a255596c67808dee269f64655d8baf7b4f0638e51ba1d6853"
dependencies = [
 "libc 0.2.53 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "new_debug_unreachable"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "unreachable 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)",
]
dependencies = [
 "unreachable 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)",
]
checksum = "e4a24736216ec316047a1fc4252e27dabb04218aa4a3f37c6e7ddbf1f9782b54"
[[package]]
version = "0.1.12"
version = "0.1.13"
name = "num-integer"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "8d59457e662d541ba17869cf51cf177c0b5f0cbf476c66bdc90bf1edac4f875b"
dependencies = [
]
[[package]]
name = "num-traits"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
]
 "autocfg 1.0.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "autocfg",
dependencies = [
 "autocfg 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)",
]
checksum = "ac267bcc07f48ee5f8935ab0d24f316fb722d7a1292e2913f0cc196b29ffd611"
[[package]]
name = "num_cpus"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "05499f3756671c15885fee9034446956fff3f243d6077b91e5767df161f766b3"
dependencies = [
]
name = "numtoa"
version = "0.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
name = "opaque-debug"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "2839e79665f131bdb5782e51f2c6c9599c133c6098982a54c794358bf432529c"
version = "0.2.2"
version = "0.2.3"
[[package]]
name = "opaque-debug"
version = "0.3.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "624a8340c38c1b80fd549087862da4ba43e08858af025b236e509b6649fc13d5"
[[package]]
name = "openssl"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "8d575eff3665419f9b83678ff2815858ad9d11567e082f5ac1814baba4e2bcb4"
dependencies = [
 "cfg-if 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "lazy_static 1.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.43 (registry+https://github.com/rust-lang/crates.io-index)",
 "openssl-sys 0.9.39 (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.51 (registry+https://github.com/rust-lang/crates.io-index)",
 "openssl-sys 0.9.43 (registry+https://github.com/rust-lang/crates.io-index)",
 "lazy_static 1.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.48 (registry+https://github.com/rust-lang/crates.io-index)",
 "openssl-sys 0.9.40 (registry+https://github.com/rust-lang/crates.io-index)",
 "lazy_static 1.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.76 (registry+https://github.com/rust-lang/crates.io-index)",
 "openssl-sys 0.9.58 (registry+https://github.com/rust-lang/crates.io-index)",
 "lazy_static 1.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "openssl-sys 0.9.43 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.53 (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)",
 "libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
 "openssl-sys 0.9.43 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.58 (registry+https://github.com/rust-lang/crates.io-index)",
 "openssl-sys 0.9.47 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.51 (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"
checksum = "77af24da69f9d9341038eba93a073b1fdaaa1b788221b00a69bce9e762cb32de"
[[package]]
name = "openssl-sys"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "a842db4709b604f0fe5d1170ae3565899be2ad3d9cbc72dedc789ac0511f78de"
dependencies = [
 "libc 0.2.53 (registry+https://github.com/rust-lang/crates.io-index)",
 "rustc_version 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "rustc_version 0.2.3 (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)",
 "rustc_version 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
version = "0.3.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "006c038a43a45995a9670da19e67600114740e8511d4333bf97a56e66a7542d9"
dependencies = [
]
[[package]]
version = "0.6.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
 "lock_api 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)",
 "parking_lot_core 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "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]]
version = "0.3.1"
version = "0.4.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "3dfb61232e34fcb633f43d12c58f83c1df82962dcdfa565a4e866ffc17dafe12"
dependencies = [
]
[[package]]
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)",
]
[[package]]
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
]
 "phf_shared 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand 0.7.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "phf_shared",
 "rand",
checksum = "17367f0cc86f2d25802b2c26ee58a7b23faeccf78a396094c13dced0d0182526"
[[package]]
version = "0.7.23"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "c00cf8b9eafe68dde5e9eaa2cef8ee84a9336a47d566ec55ca16589633b65af7"
dependencies = [
]
[[package]]
version = "0.7.23"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "13fbdfd6bdee3dc9be46452f86af4a4072975899cf8592466668620bebfbcc17"
dependencies = [
]
[[package]]
version = "0.7.23"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "c82fb1329f632c3552cf352d14427d57a511b1cf41db93b3a7d77906a82dcc8e"
dependencies = [
]
[[package]]
version = "0.7.23"
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
name = "pkg-config"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "c36fa947111f5c62a733b652544dd0016a43ce89619538a8ef92724a6f501a20"
[[package]]
name = "precomputed-hash"
version = "0.1.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "925383efa346730478fb4838dbe9137d2a47675ad789c546d150a6e1dd4ab31c"
[[package]]
version = "0.4.20"
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "eba180dafb9038b050a4c280019bbedf9f2467b61e5d892dcad585bb57aadc5a"
[[package]]
version = "0.12.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "1e0704ee1a7e00d7bb417d0770ea303c1bccbabf0ef1667dae92b5967f5f8a71"
dependencies = [
 "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)",
 "memchr 2.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "memchr 2.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "a1d01941d82fa2ab50be1e79e6714289dd7cde78eba4c074bc5a4374f650dfe0"
[[package]]
version = "0.6.8"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "3cc440ee4802a86e357165021e3e255a9143724da31db1e2ea540214c96a0f82"
dependencies = [
]
[[package]]
version = "0.4.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "aa563d17ecb180e500da1cfd2b028310ac758de548efdd203e18f283af693f37"
dependencies = [
 "libc 0.2.53 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 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)",
 "libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand_core 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.48 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.58 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "rand"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "libc 0.2.53 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand_jitter 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand_pcg 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand_jitter 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand_xorshift 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand_os 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand_os 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand_pcg 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand_os 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand_pcg 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand_os 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand_os 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand_jitter 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.49 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "rand_chacha"
version = "0.1.1"
version = "0.2.2"
 "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)",
 "libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.48 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
 "autocfg 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
 "autocfg 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "getrandom 0.1.14 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.76 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand_chacha 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand_core 0.5.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand_hc 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand_pcg 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "autocfg 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.58 (registry+https://github.com/rust-lang/crates.io-index)",
 "getrandom",
 "libc",
 "rand_chacha",
 "rand_core 0.5.1",
 "rand_hc",
 "rand_pcg",
checksum = "6a6b1679d49b24bbfe0c803429aa1874472f50d9b363131f0e89fc356b544d03"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f4c8ed856279c9737206bf725bf36935d8666ead7aa69b52be55af369d193402"
dependencies = [
 "rand_core 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "rand_core"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "7a6fdeb83b075e8266dcc8762c22776f6877a63111121f5f8c7411e5be7eed4b"
dependencies = [
]
[[package]]
name = "rand_core"
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
]
[[package]]
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
]
[[package]]
 "libc 0.2.53 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.49 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.1.3"
name = "rand_os"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "libc 0.2.53 (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"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
]
[[package]]
name = "rdrand"
version = "0.4.0"
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]]
 "rand_core 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "autocfg 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "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)",
 "rand_core 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "rustc_version 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand_core 0.5.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "autocfg 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)",
 "autocfg 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand_core 0.5.1",
checksum = "16abd0c1b639e9eb4d7c50c0b8100b0d0f849be2349829c740fe8e6eb4816429"
version = "0.1.2"
version = "0.1.1"
version = "0.2.1"
version = "0.1.2"
 "winapi 0.3.7 (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)",
 "winapi 0.3.9 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 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)",
 "libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand_core 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.48 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.76 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand_core 0.4.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.58 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
 "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)",
 "cloudabi",
 "fuchsia-cprng",
 "libc",
 "rand_core 0.4.2",
 "rdrand",
 "winapi 0.3.9",
checksum = "7b75f676a1e053fc562eafbb47838d67c84801e38fc1ba459e8f180deabd5071"
version = "0.1.2"
version = "0.1.3"
version = "0.1.2"
version = "0.1.3"
version = "0.1.3"
]
[[package]]
 "winapi 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand_core 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
version = "0.1.3"
 "winapi 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.48 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.58 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.1.4"
 "winapi 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
name = "rand_jitter"
 "rand_core 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand_core 0.5.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand_core 0.5.1",
checksum = "ca3129af7b92a17112d59ad498c6f81eaf463253766b90396d39ea7a39d6613c"
name = "rand_isaac"
version = "0.1.1"
name = "rand_hc"
version = "0.2.0"
 "rand_core 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "getrandom 0.1.14 (registry+https://github.com/rust-lang/crates.io-index)",
 "getrandom",
checksum = "90bde5296fc891b0cef12a6d03ddccc162ce7b2aff54160af9338f8d40df6d19"
name = "rand_hc"
version = "0.1.0"
name = "rand_core"
version = "0.5.1"
checksum = "9c33a3c44ca05fa6f1807d8e6743f3824e8509beca625669633be0acbdf509dc"
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
name = "redox_syscall"
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"
 "redox_syscall 0.1.40 (registry+https://github.com/rust-lang/crates.io-index)",
 "redox_syscall 0.1.51 (registry+https://github.com/rust-lang/crates.io-index)",
 "redox_syscall 0.1.54 (registry+https://github.com/rust-lang/crates.io-index)",
 "redox_syscall 0.1.51 (registry+https://github.com/rust-lang/crates.io-index)",
 "redox_syscall 0.1.54 (registry+https://github.com/rust-lang/crates.io-index)",
 "redox_syscall 0.1.54 (registry+https://github.com/rust-lang/crates.io-index)",
[[package]]
name = "regex"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "9c3780fcf44b193bc4d09f36d2a3c87b251da4a046c87795a0d35f4f927ad8e6"
dependencies = [
 "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)",
 "utf8-ranges 1.0.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "utf8-ranges 1.0.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "utf8-ranges 1.0.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "utf8-ranges 1.0.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "utf8-ranges 1.0.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "regex-syntax 0.6.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "regex-syntax 0.6.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "regex-syntax 0.6.6 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "regex-syntax"
source = "registry+https://github.com/rust-lang/crates.io-index"
 "ucd-util 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "ucd-util 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
[[package]]
name = "remove_dir_all"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "3acd125665422973a33ac9d3dd2df85edad0f4ae9b00dafb1a05e43a9f5ef8e7"
dependencies = [
]
[[package]]
name = "resolv-conf"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "11834e137f3b14e309437a8276714eed3a80d1ef894869e510f2c0c0b98b9f4a"
dependencies = [
]
[[package]]
name = "rustc-demangle"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "b2610b7f643d18c87dff3b489950269617e6601a51f1f05aa5daefee36f64f0b"
[[package]]
name = "ryu"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "71d301d4193d031abdd79ff7e3dd721168a9572ef3fe51a1517aba235bd8f86e"
[[package]]
name = "sasl"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "e457758c85b736bbad56dc099406cd2a9c19554cf81880dba7a51d092929e600"
dependencies = [
 "hmac 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand_os 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand_os 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "sha-1 0.8.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "sha2 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand_os 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand_os 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "sha-1 0.8.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "sha2 0.8.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand_os 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "pbkdf2 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "hmac 0.7.1 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "schannel"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "8f05ba609c234e60bee0d547fe94a4c7e9da733d1c962cf6e59efa4cd9c8bc75"
dependencies = [
 "winapi 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "security-framework"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "64808902d7d99f78eaddd2b4e2509713babc3dc3c85ad6f4c447680f3c01e535"
dependencies = [
 "libc 0.2.43 (registry+https://github.com/rust-lang/crates.io-index)",
 "security-framework-sys 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
 "security-framework-sys 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.48 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "security-framework-sys"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "17bf11d99252f512695eb468de5516e5cf75455521e69dfe343f3b74e4748405"
dependencies = [
]
[[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)",
]
 "core-foundation-sys 0.5.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.43 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.48 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
 "core-foundation-sys 0.6.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "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)",
 "MacTypes-sys 2.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "core-foundation-sys 0.5.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
 "MacTypes-sys 2.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "core-foundation-sys 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.76 (registry+https://github.com/rust-lang/crates.io-index)",
 "core-foundation-sys 0.6.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "core-foundation-sys",
 "libc",
 "MacTypes-sys 2.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.2.1"
version = "0.3.1"
version = "0.2.3"
version = "0.2.3"
version = "0.2.3"
version = "0.4.3"
version = "0.3.1"
version = "0.2.3"
 "libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
 "security-framework-sys 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "core-foundation 0.6.4 (registry+https://github.com/rust-lang/crates.io-index)",
 "core-foundation-sys 0.6.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.53 (registry+https://github.com/rust-lang/crates.io-index)",
 "security-framework-sys 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "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)",
 "core-foundation 0.5.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "core-foundation-sys 0.5.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
 "security-framework-sys 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "bitflags 1.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "core-foundation 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "core-foundation-sys 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.76 (registry+https://github.com/rust-lang/crates.io-index)",
 "security-framework-sys 0.4.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "core-foundation 0.6.4 (registry+https://github.com/rust-lang/crates.io-index)",
 "core-foundation-sys 0.6.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.58 (registry+https://github.com/rust-lang/crates.io-index)",
 "security-framework-sys 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "bitflags",
 "core-foundation",
 "core-foundation-sys",
 "libc",
 "security-framework-sys",
 "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)",
version = "0.2.1"
version = "0.3.1"
version = "0.2.2"
version = "0.2.2"
version = "0.2.2"
version = "0.4.4"
version = "0.3.1"
version = "0.2.2"
[[package]]
name = "scopeguard"
version = "0.3.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
 "lazy_static 1.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "lazy_static 1.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "lazy_static 1.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "lazy_static 1.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.9 (registry+https://github.com/rust-lang/crates.io-index)",
 "lazy_static 1.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "lazy_static",
 "winapi 0.3.9",
 "lazy_static 1.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.1.14"
version = "0.1.15"
version = "0.1.14"
version = "0.1.19"
version = "0.1.15"
version = "0.1.15"
 "base64 0.9.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "openssl 0.10.15 (registry+https://github.com/rust-lang/crates.io-index)",
 "base64 0.10.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "base64 0.10.1",
 "hmac",
 "pbkdf2",
 "rand_os",
 "sha-1 0.8.2",
 "sha2 0.8.2",
 "base64 0.10.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "hmac 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "pbkdf2 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand_os 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "sha-1 0.8.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "sha2 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.4.2"
version = "0.4.3"
version = "0.4.3"
version = "0.2.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
name = "safemem"
version = "0.3.0"
version = "0.2.7"
version = "0.2.7"
version = "1.0.5"
version = "0.2.8"
version = "0.2.7"
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]]
version = "0.1.9"
version = "0.1.13"
version = "0.1.14"
version = "0.1.14"
version = "0.1.13"
version = "0.1.16"
version = "0.1.15"
version = "0.1.14"
version = "0.1.17"
version = "0.1.14"
 "hostname 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "quick-error 1.2.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "hostname",
 "quick-error",
 "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)",
version = "0.6.1"
version = "0.6.2"
version = "0.6.3"
version = "0.6.2"
 "winapi 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.9 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.9",
 "winapi 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.5.1"
version = "0.5.3"
version = "0.5.2"
version = "0.5.1"
]
 "ucd-util 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
checksum = "26412eb97c6b088a6997e05f69403a802a92d520de2f8e63c2b65f9e0f47c4e8"
dependencies = [
version = "0.6.2"
version = "0.6.5"
version = "0.6.6"
version = "0.6.6"
version = "0.6.5"
version = "0.6.18"
version = "0.6.7"
version = "0.6.6"
version = "0.6.6"
 "thread_local 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "aho-corasick 0.6.8 (registry+https://github.com/rust-lang/crates.io-index)",
 "memchr 2.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "regex-syntax 0.6.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "aho-corasick 0.6.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "aho-corasick 0.7.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "memchr 2.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "regex-syntax 0.6.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "aho-corasick 0.6.9 (registry+https://github.com/rust-lang/crates.io-index)",
 "memchr 2.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "regex-syntax 0.6.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "aho-corasick 0.7.13 (registry+https://github.com/rust-lang/crates.io-index)",
 "memchr 2.3.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "regex-syntax 0.6.18 (registry+https://github.com/rust-lang/crates.io-index)",
 "thread_local 1.0.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "aho-corasick 0.7.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "aho-corasick 0.7.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "aho-corasick",
 "memchr",
 "regex-syntax",
 "thread_local",
 "aho-corasick 0.7.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "memchr 2.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "regex-syntax 0.6.6 (registry+https://github.com/rust-lang/crates.io-index)",
version = "1.0.5"
version = "1.1.6"
version = "1.1.2"
version = "1.1.5"
version = "1.1.5"
version = "1.1.0"
version = "1.3.9"
version = "1.1.5"
version = "1.1.7"
version = "1.1.5"
version = "1.1.5"
version = "1.1.6"
]
 "redox_syscall 0.1.54 (registry+https://github.com/rust-lang/crates.io-index)",
checksum = "41cc0f7e4d5d4544e8861606a285bb08d3e70712ccc7d2b84d7c0ccfaf4b05ce"
dependencies = [
version = "0.1.40"
version = "0.1.51"
version = "0.1.54"
version = "0.1.51"
version = "0.1.57"
version = "0.1.54"
version = "0.1.54"
version = "0.1.54"
dependencies = [
]
 "rand_core 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand_core 0.3.1",
checksum = "678054eb77286b51581ba43620cc911abf02758c91f93f479767aed0f90458b2"
dependencies = [
 "rand_core 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
]
version = "0.3.0"
version = "0.4.0"
version = "0.4.2"
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.51 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand_core 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "rand_os"
version = "0.1.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "cloudabi 0.0.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "fuchsia-cprng 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand_core 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "rdrand 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
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"
 "rand_core 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand_core 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand_core 0.4.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand_core 0.4.2",
 "rand_core 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.2.2"
version = "0.3.1"
version = "0.3.1"
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]]
 "cloudabi 0.0.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "fuchsia-zircon 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.43 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand_core 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "autocfg 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "autocfg 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "ppv-lite86 0.2.9 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand_core 0.5.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "autocfg 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)",
 "ppv-lite86",
 "rand_core 0.5.1",
 "autocfg 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand_chacha 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand_core 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand_hc 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand_isaac 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand_jitter 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand_os 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand_pcg 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand_xorshift 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.5.5"
version = "0.6.5"
version = "0.7.3"
version = "0.6.5"
 "fuchsia-zircon 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.43 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "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)",
 "proc-macro2 1.0.20 (registry+https://github.com/rust-lang/crates.io-index)",
 "proc-macro2",
 "cloudabi 0.0.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "fuchsia-cprng 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand_core 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.5.6"
version = "0.5.6"
name = "quote"
version = "1.0.7"
name = "rand"
 "proc-macro2 0.4.20 (registry+https://github.com/rust-lang/crates.io-index)",
 "proc-macro2 0.4.29 (registry+https://github.com/rust-lang/crates.io-index)",
 "proc-macro2 0.4.27 (registry+https://github.com/rust-lang/crates.io-index)",
 "proc-macro2 0.4.27 (registry+https://github.com/rust-lang/crates.io-index)",
 "proc-macro2 0.4.27 (registry+https://github.com/rust-lang/crates.io-index)",
 "memchr 2.3.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "proc-macro2 0.4.30 (registry+https://github.com/rust-lang/crates.io-index)",
 "memchr",
 "proc-macro2 0.4.27 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.6.11"
version = "0.6.12"
version = "0.6.11"
version = "0.6.12"
version = "0.6.12"
version = "0.6.12"
name = "quick-xml"
version = "0.18.1"
name = "quote"
name = "quick-error"
version = "1.2.3"
name = "quote"
version = "0.3.15"
 "encoding_rs 0.8.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "failure 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "log 0.4.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "memchr 2.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "encoding_rs 0.8.17 (registry+https://github.com/rust-lang/crates.io-index)",
 "encoding_rs 0.8.15 (registry+https://github.com/rust-lang/crates.io-index)",
 "unicode-xid 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "encoding_rs 0.8.17 (registry+https://github.com/rust-lang/crates.io-index)",
 "unicode-xid",
 "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)",
version = "0.13.3"
version = "0.13.2"
version = "0.13.3"
version = "0.13.3"
name = "proc-macro2"
version = "1.0.20"
version = "1.0.24"
name = "quick-xml"
name = "proc-macro-nested"
version = "0.1.6"
name = "quick-error"
version = "1.2.2"
checksum = "99c605b9a0adc77b7211c6b1f722dcb613d68d66859a44f3d485a6da332b0598"
dependencies = [
 "unicode-xid 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
]
version = "0.4.29"
version = "0.4.27"
version = "0.4.27"
version = "0.4.27"
version = "0.4.30"
version = "0.4.27"
name = "proc-macro-hack"
version = "0.5.18"
name = "proc-macro2"
version = "0.3.18"
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
name = "ppv-lite86"
version = "0.2.9"
checksum = "d36492546b6af1463394d46f0c834346f31548646f6ba10849802c9c9a27ac33"
version = "0.3.14"
[[package]]
name = "pin-utils"
version = "0.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "8b870d8c151b6f2fb93e84a13146138f05d02ed11c7e7c54f8826aaaf7c9f184"
checksum = "e555d9e657502182ac97b539fb3dae8b79cda19e3e4f8ffb5e8de4f18df93c95"
dependencies = [
 "siphasher 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)",
]
version = "0.7.24"
version = "0.7.24"
name = "pin-project-lite"
version = "0.1.7"
version = "0.1.10"
name = "phf_shared"
 "phf_shared 0.7.23 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand 0.5.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "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)",
 "proc-macro2 1.0.20 (registry+https://github.com/rust-lang/crates.io-index)",
 "quote 1.0.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "syn 1.0.40 (registry+https://github.com/rust-lang/crates.io-index)",
 "proc-macro2",
 "quote",
 "syn",
 "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)",
version = "0.7.24"
version = "0.7.24"
name = "pin-project-internal"
version = "0.4.23"
version = "0.4.26"
name = "phf_generator"
 "phf_generator 0.7.23 (registry+https://github.com/rust-lang/crates.io-index)",
 "phf_shared 0.7.23 (registry+https://github.com/rust-lang/crates.io-index)",
 "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)",
 "pin-project-internal 0.4.23 (registry+https://github.com/rust-lang/crates.io-index)",
 "pin-project-internal",
 "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)",
version = "0.7.24"
version = "0.7.24"
name = "pin-project"
version = "0.4.23"
version = "0.4.26"
name = "phf_codegen"
 "phf_shared 0.7.23 (registry+https://github.com/rust-lang/crates.io-index)",
 "phf_shared 0.7.24 (registry+https://github.com/rust-lang/crates.io-index)",
 "siphasher 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "siphasher",
 "phf_shared 0.7.24 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.7.24"
version = "0.7.24"
name = "phf_shared"
version = "0.8.0"
name = "phf"
name = "phf_generator"
version = "0.8.0"
name = "percent-encoding"
version = "1.0.1"
 "byteorder 1.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "byteorder 1.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "phf_generator 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "phf_shared 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "byteorder 1.3.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "phf_generator",
 "phf_shared",
checksum = "cbffee61585b0411840d3ece935cce9cb6321f01c45477d30066498cd5e1a815"
name = "pbkdf2"
version = "0.3.0"
name = "phf_codegen"
version = "0.8.0"
 "rand 0.6.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "smallvec 0.6.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "smallvec 0.6.9 (registry+https://github.com/rust-lang/crates.io-index)",
 "smallvec 0.6.9 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "smallvec 0.6.8 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "smallvec 0.6.10 (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)",
 "winapi 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "smallvec 0.6.9 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[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)",
 "rustc_version 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.43 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand 0.5.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.53 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.49 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.48 (registry+https://github.com/rust-lang/crates.io-index)",
 "phf_shared 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.58 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
 "phf_shared",
 "libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand 0.6.5 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.4.0"
name = "phf"
version = "0.8.0"
name = "parking_lot_core"
]
 "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)",
checksum = "d4fd5641d01c8f18a23da7b6fe29298ff4b55afcccdf78973b24cf3175fee32e"
dependencies = [
version = "0.7.1"
version = "0.7.1"
name = "percent-encoding"
version = "2.1.0"
name = "parking_lot"
 "byteorder 1.3.4 (registry+https://github.com/rust-lang/crates.io-index)",
 "crypto-mac 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "byteorder",
 "crypto-mac 0.7.0",
 "stable_deref_trait 1.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.4.0"
version = "0.4.0"
name = "pbkdf2"
version = "0.3.0"
name = "owning_ref"
 "pkg-config 0.3.14 (registry+https://github.com/rust-lang/crates.io-index)",
 "cc 1.0.25 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.43 (registry+https://github.com/rust-lang/crates.io-index)",
 "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)",
 "cc 1.0.35 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
 "cc 1.0.35 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
 "cc 1.0.29 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.48 (registry+https://github.com/rust-lang/crates.io-index)",
 "autocfg 1.0.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "cc 1.0.59 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.76 (registry+https://github.com/rust-lang/crates.io-index)",
 "pkg-config 0.3.18 (registry+https://github.com/rust-lang/crates.io-index)",
 "vcpkg 0.2.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "autocfg 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)",
 "cc 1.0.37 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.58 (registry+https://github.com/rust-lang/crates.io-index)",
 "cc 1.0.35 (registry+https://github.com/rust-lang/crates.io-index)",
 "autocfg",
 "cc",
 "libc",
 "pkg-config",
 "vcpkg",
 "cc 1.0.35 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.9.39"
version = "0.9.42"
version = "0.9.43"
version = "0.9.43"
version = "0.9.40"
version = "0.9.58"
version = "0.9.47"
version = "0.9.43"
version = "0.9.43"
 "lazy_static 1.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
 "openssl-sys 0.9.43 (registry+https://github.com/rust-lang/crates.io-index)",
 "cfg-if 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "cfg-if 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "cfg-if 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "cfg-if 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "foreign-types 0.3.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "cfg-if 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "bitflags 1.0.4 (registry+https://github.com/rust-lang/crates.io-index)",
 "cfg-if 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "bitflags 1.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "cfg-if 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "bitflags 1.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "cfg-if 0.1.9 (registry+https://github.com/rust-lang/crates.io-index)",
 "bitflags",
 "cfg-if",
 "foreign-types",
 "lazy_static",
 "libc",
 "openssl-sys",
 "bitflags 1.0.4 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.10.15"
version = "0.10.19"
version = "0.10.20"
version = "0.10.20"
version = "0.10.16"
version = "0.10.30"
version = "0.10.23"
version = "0.10.20"
version = "0.10.20"
[[package]]
[[package]]
name = "object"
version = "0.20.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
name = "once_cell"
version = "1.4.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
checksum = "260e51e7efe62b592207e9e13a68e43692a7a279171d6ba57abd208bf23645ad"
checksum = "1ab52be62400ca80aa00285d25253d7f7c437b7375c4de678f5405d3afe82ca5"
name = "numtoa"
version = "0.1.0"
source = "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"
 "libc 0.2.43 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.53 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.49 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.48 (registry+https://github.com/rust-lang/crates.io-index)",
 "hermit-abi 0.1.15 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.76 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.58 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
 "hermit-abi",
 "libc",
 "libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
version = "1.8.0"
version = "1.10.0"
version = "1.10.0"
version = "1.9.0"
version = "1.13.0"
version = "1.10.1"
version = "1.10.0"
version = "1.10.0"
version = "0.2.6"
version = "0.2.12"
version = "0.2.8"
version = "0.2.6"
 "num-traits 0.2.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "autocfg 1.0.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "num-traits 0.2.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "autocfg 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)",
 "num-traits 0.2.8 (registry+https://github.com/rust-lang/crates.io-index)",
 "autocfg",
 "num-traits",
 "num-traits 0.2.6 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.1.39"
version = "0.1.43"
version = "0.1.41"
version = "0.1.39"
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
version = "0.1.13"
name = "nodrop"
version = "1.0.1"
version = "1.0.3"
version = "1.0.1"
version = "1.0.4"
version = "1.0.3"
version = "1.0.3"
 "cfg-if 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.43 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.6 (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)",
 "winapi 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "cfg-if 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
 "cfg-if 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "cfg-if 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.48 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "cfg-if 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.76 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.9 (registry+https://github.com/rust-lang/crates.io-index)",
 "cfg-if 0.1.9 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.58 (registry+https://github.com/rust-lang/crates.io-index)",
 "cfg-if 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "cfg-if",
 "libc",
 "winapi 0.3.9",
 "cfg-if 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.2.35"
version = "0.2.33"
 "openssl-sys 0.9.43 (registry+https://github.com/rust-lang/crates.io-index)",
 "schannel 0.1.15 (registry+https://github.com/rust-lang/crates.io-index)",
 "security-framework 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "security-framework-sys 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "tempfile 3.0.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "openssl 0.10.20 (registry+https://github.com/rust-lang/crates.io-index)",
 "openssl 0.10.20 (registry+https://github.com/rust-lang/crates.io-index)",
 "openssl 0.10.16 (registry+https://github.com/rust-lang/crates.io-index)",
 "openssl 0.10.23 (registry+https://github.com/rust-lang/crates.io-index)",
 "openssl 0.10.20 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.49 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
 "log 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.58 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
 "openssl-probe 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "lazy_static 1.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.43 (registry+https://github.com/rust-lang/crates.io-index)",
 "log 0.4.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "openssl 0.10.15 (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.51 (registry+https://github.com/rust-lang/crates.io-index)",
 "lazy_static 1.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.48 (registry+https://github.com/rust-lang/crates.io-index)",
 "lazy_static 1.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.76 (registry+https://github.com/rust-lang/crates.io-index)",
 "log 0.4.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "openssl 0.10.30 (registry+https://github.com/rust-lang/crates.io-index)",
 "lazy_static 1.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "lazy_static",
 "libc",
 "log",
 "openssl",
 "openssl-probe",
 "openssl-sys",
 "schannel",
 "security-framework",
 "security-framework-sys",
 "tempfile",
 "lazy_static 1.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
 "log 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "openssl 0.10.20 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.2.3"
version = "0.2.2"
version = "0.2.2"
version = "0.2.4"
version = "0.2.3"
version = "0.2.2"
 "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)",
 "kernel32-sys",
 "net2",
 "winapi 0.2.8",
 "ws2_32-sys",
 "kernel32-sys 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
 "mio 0.6.16 (registry+https://github.com/rust-lang/crates.io-index)",
 "iovec 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.76 (registry+https://github.com/rust-lang/crates.io-index)",
 "mio 0.6.22 (registry+https://github.com/rust-lang/crates.io-index)",
 "iovec",
 "libc",
 "mio",
 "iovec 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.6.8"
version = "0.6.7"
 "net2 0.2.33 (registry+https://github.com/rust-lang/crates.io-index)",
 "slab 0.4.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "slab 0.4.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "slab 0.4.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.51 (registry+https://github.com/rust-lang/crates.io-index)",
 "miow 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "lazycell 1.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "log 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.53 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.49 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.48 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.76 (registry+https://github.com/rust-lang/crates.io-index)",
 "log 0.4.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.58 (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.51 (registry+https://github.com/rust-lang/crates.io-index)",
 "log 0.4.6 (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)",
 "cfg-if",
 "fuchsia-zircon",
 "fuchsia-zircon-sys",
 "iovec",
 "kernel32-sys",
 "libc",
 "log",
 "miow",
 "net2",
 "slab",
 "winapi 0.2.8",
 "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)",
version = "0.6.16"
version = "0.6.22"
version = "0.6.19"
version = "0.6.16"
 "failure 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "failure_derive 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "quick-xml 0.12.4 (registry+https://github.com/rust-lang/crates.io-index)",
 "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)",
 "adler 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "adler",
 "autocfg",
 "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)",
version = "0.10.0"
version = "0.10.0"
name = "miniz_oxide"
version = "0.4.1"
version = "0.4.3"
name = "minidom"
name = "minidom"
version = "0.12.0"
dependencies = [
]
 "quick-xml 0.18.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "quick-xml",
source = "git+https://gitlab.com/xmpp-rs/xmpp-rs#b85aa293770d22cca11fd7ca3802b5920e1ab6fa"
source = "git+https://gitlab.com/xmpp-rs/xmpp-rs?branch=main#e1f2e2653a9c14409a04bc4fcd7b10ce842871ea"
name = "memoffset"
version = "0.2.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
version = "2.1.0"
version = "2.2.0"
version = "2.1.3"
version = "2.3.3"
version = "2.2.0"
version = "2.2.0"
 "tendril 0.4.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde 1.0.90 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde_derive 1.0.90 (registry+https://github.com/rust-lang/crates.io-index)",
 "tendril 0.4.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde 1.0.90 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde_derive 1.0.90 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde_json 1.0.39 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde 1.0.87 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde_derive 1.0.87 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde_json 1.0.38 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde 1.0.92 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde_derive 1.0.92 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde 1.0.90 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde_derive 1.0.90 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde_json 1.0.39 (registry+https://github.com/rust-lang/crates.io-index)",
 "string_cache 0.7.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "string_cache_codegen 0.4.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "phf 0.7.23 (registry+https://github.com/rust-lang/crates.io-index)",
 "phf_codegen 0.7.23 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde 1.0.80 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde_derive 1.0.80 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde_json 1.0.32 (registry+https://github.com/rust-lang/crates.io-index)",
 "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)",
 "log 0.4.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "phf 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "phf_codegen 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde 1.0.115 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde_derive 1.0.115 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde_json 1.0.57 (registry+https://github.com/rust-lang/crates.io-index)",
 "string_cache 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "string_cache_codegen 0.5.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "log",
 "phf",
 "phf_codegen",
 "serde",
 "serde_derive",
 "serde_json",
 "string_cache",
 "string_cache_codegen",
 "tendril",
 "phf 0.7.24 (registry+https://github.com/rust-lang/crates.io-index)",
 "phf_codegen 0.7.24 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde 1.0.90 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde_derive 1.0.90 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde_json 1.0.39 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.7.3"
version = "0.7.5"
version = "0.10.0"
version = "0.7.5"
 "linked-hash-map 0.4.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "linked-hash-map 0.4.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "linked-hash-map 0.5.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "linked-hash-map 0.4.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "linked-hash-map 0.5.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "linked-hash-map 0.5.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "linked-hash-map 0.5.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "linked-hash-map",
 "linked-hash-map 0.5.2 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.1.1"
version = "0.1.1"
version = "0.1.2"
version = "0.1.1"
version = "0.1.2"
version = "0.1.2"
version = "0.1.2"
 "cfg-if 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "cfg-if 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "cfg-if 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "cfg-if 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "cfg-if 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "cfg-if 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "cfg-if 0.1.9 (registry+https://github.com/rust-lang/crates.io-index)",
 "cfg-if 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "cfg-if",
checksum = "4fabed175da42fed1fa0746b0ea71f412aa9d35e76e95e59b192c64b9dc2bf8b"
version = "0.4.5"
version = "0.4.6"
version = "0.4.11"
]
 "log 0.4.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "cfg-if 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
version = "0.3.9"
version = "0.4.6"
 "scopeguard 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "owning_ref 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
checksum = "8dd5a6d5999d9907cda8ed67bbd137d3af8085216c2ac62de5be860bd41f304a"
dependencies = [
version = "0.1.4"
version = "0.1.5"
version = "0.1.5"
version = "0.4.2"
version = "0.4.2"
version = "0.5.2"
version = "0.4.2"
version = "0.5.3"
version = "0.5.2"
version = "0.5.2"
version = "0.5.2"
version = "0.2.43"
version = "0.2.53"
version = "0.2.49"
version = "0.2.51"
version = "0.2.51"
version = "0.2.48"
version = "0.2.76"
version = "0.2.58"
version = "0.2.51"
version = "0.2.79"
version = "0.2.51"
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
version = "1.2.1"
name = "lazycell"
version = "1.1.0"
version = "1.3.0"
version = "1.2.0"
version = "1.4.0"
version = "1.3.0"
version = "1.3.0"
 "winapi 0.2.8",
 "winapi-build",
 "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)",
 "failure 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "failure_derive 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "minidom 0.9.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "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)",
 "minidom 0.12.0 (git+https://gitlab.com/xmpp-rs/xmpp-rs)",
 "minidom",
 "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)",
version = "0.5.2"
version = "0.5.3"
version = "0.9.0"
version = "0.5.3"
version = "0.4.3"
version = "0.4.6"
version = "0.4.4"
version = "0.4.3"
 "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)",
 "socket2 0.3.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "widestring 0.4.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.9 (registry+https://github.com/rust-lang/crates.io-index)",
 "winreg 0.6.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "socket2",
 "widestring",
 "winapi 0.3.9",
 "winreg",
 "error-chain 0.8.1 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.1.7"
version = "0.1.9"
version = "0.2.2"
version = "0.1.9"
 "winapi 0.2.8 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.43 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.53 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.49 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.48 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.76 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.58 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc",
 "libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.1.4"
version = "0.1.2"
version = "1.6.0"
version = "1.0.2"
 "unicode-normalization 0.1.8 (registry+https://github.com/rust-lang/crates.io-index)",
 "unicode-normalization 0.1.13 (registry+https://github.com/rust-lang/crates.io-index)",
 "unicode-normalization 0.1.8 (registry+https://github.com/rust-lang/crates.io-index)",
 "matches",
 "unicode-bidi",
 "unicode-normalization",
 "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)",
version = "0.2.0"
version = "0.1.5"
 "futures-cpupool 0.1.8 (registry+https://github.com/rust-lang/crates.io-index)",
 "bytes 0.4.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.25 (registry+https://github.com/rust-lang/crates.io-index)",
 "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)",
 "bytes 0.4.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",
 "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)",
 "bytes 0.5.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures-channel 0.3.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures-core 0.3.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures-util 0.3.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "h2 0.2.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "http 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "http-body 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "httparse 1.3.4 (registry+https://github.com/rust-lang/crates.io-index)",
 "itoa 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "pin-project 0.4.23 (registry+https://github.com/rust-lang/crates.io-index)",
 "socket2 0.3.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "time 0.1.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio 0.2.22 (registry+https://github.com/rust-lang/crates.io-index)",
 "tower-service 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "tracing 0.1.19 (registry+https://github.com/rust-lang/crates.io-index)",
 "want 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "bytes 0.4.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "bytes 0.4.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",
 "bytes",
 "futures-channel",
 "futures-core",
 "futures-util",
 "h2",
 "http",
 "http-body",
 "httparse",
 "httpdate",
 "itoa",
 "pin-project",
 "socket2",
 "tokio",
 "tower-service",
 "tracing",
 "want",
 "bytes 0.4.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.12.13"
version = "0.12.25"
version = "0.12.27"
version = "0.12.27"
version = "0.12.23"
version = "0.13.7"
version = "0.12.30"
version = "0.12.27"
version = "0.13.8"
version = "0.12.27"
 "quick-error 1.2.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "quick-error",
 "quick-error 1.2.2 (registry+https://github.com/rust-lang/crates.io-index)",
version = "1.1.1"
version = "1.2.0"
version = "1.3.0"
version = "1.2.0"
version = "1.3.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "cd179ae861f0c2e53da70d892f5f3029f9594be0c41dc5269cd371691b1dc2f9"
[[package]]
name = "httpdate"
version = "0.3.2"
version = "1.3.3"
]
[[package]]
name = "http-body"
version = "0.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "bytes 0.4.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.27 (registry+https://github.com/rust-lang/crates.io-index)",
 "http 0.1.17 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-buf 0.1.1 (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)",
 "itoa 0.4.4 (registry+https://github.com/rust-lang/crates.io-index)",
 "itoa 0.4.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "bytes 0.4.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "bytes 0.4.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "bytes 0.4.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "bytes 0.4.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "bytes 0.5.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "http 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "bytes 0.4.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "bytes 0.4.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "bytes",
 "http",
 "bytes 0.4.12 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.1.13"
version = "0.1.16"
version = "0.1.17"
version = "0.1.15"
version = "0.2.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
]
[[package]]
name = "http-body"
version = "0.3.1"
 "bytes 0.5.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "fnv 1.0.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "itoa 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "bytes",
 "fnv",
 "itoa",
checksum = "28d569972648b2c512421b5f2a405ad6ac9666547189d0c5477a3f200f3e02f9"
version = "0.1.17"
version = "0.1.17"
version = "0.1.17"
 "winutil 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.43 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.53 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.49 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.48 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.76 (registry+https://github.com/rust-lang/crates.io-index)",
 "match_cfg 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.9 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.58 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc",
 "match_cfg",
 "winapi 0.3.9",
 "libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.3.1"
version = "0.1.5"
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]]
 "log 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "string 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "hmac"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "digest 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "digest 0.8.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "crypto-mac 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "crypto-mac 0.7.0",
 "digest 0.8.1",
checksum = "5dcb5e64cda4c23119ab41ba960d1e170a774c8e4b9d9e6a9bc18aabf5e59695"
version = "0.7.0"
version = "0.7.1"
 "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)",
 "tokio-io 0.1.11 (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 = "hashbrown"
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
name = "heck"
version = "0.3.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
]
[[package]]
name = "hermit-abi"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "libc 0.2.76 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc",
checksum = "5aca5565f760fb5b220e499d72710ed156fdb74e631659e99377d9ebfbd13ae8"
version = "0.1.15"
version = "0.1.17"
 "unicode-segmentation 1.6.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "unicode-segmentation",
checksum = "20564e78d53d2bb135c343b3f47714a56af2061f1c928fdb541dc7b9fdd94205"
checksum = "d7afe4a420e3fe79967a00898cc1f4db7c8a49a9333a29f8a4bd76a253d5cd04"
version = "0.9.0"
version = "0.9.1"
 "tokio 0.2.22 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-util 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "tracing 0.1.19 (registry+https://github.com/rust-lang/crates.io-index)",
 "string 0.2.0 (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)",
 "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)",
 "futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",
 "indexmap 1.0.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",
 "http 0.1.17 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.25 (registry+https://github.com/rust-lang/crates.io-index)",
 "http 0.1.15 (registry+https://github.com/rust-lang/crates.io-index)",
 "http 0.1.17 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.27 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",
 "http 0.1.17 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",
 "http 0.1.17 (registry+https://github.com/rust-lang/crates.io-index)",
 "slab 0.4.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "bytes 0.4.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "bytes 0.4.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "bytes 0.4.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "bytes 0.4.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "fnv 1.0.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "byteorder 1.2.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "bytes 0.4.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "byteorder 1.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "byteorder 1.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "bytes 0.5.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "fnv 1.0.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures-core 0.3.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures-sink 0.3.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures-util 0.3.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "http 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "indexmap 1.6.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "byteorder 1.3.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "bytes",
 "fnv",
 "futures-core",
 "futures-sink",
 "futures-util",
 "http",
 "indexmap",
 "slab",
 "tokio",
 "tokio-util",
 "tracing",
 "byteorder 1.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "bytes 0.4.12 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.1.13"
version = "0.1.16"
version = "0.1.18"
version = "0.1.18"
version = "0.1.16"
version = "0.2.6"
version = "0.1.23"
version = "0.1.18"
version = "0.1.18"
 "cfg-if 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.76 (registry+https://github.com/rust-lang/crates.io-index)",
 "wasi 0.9.0+wasi-snapshot-preview1 (registry+https://github.com/rust-lang/crates.io-index)",
 "cfg-if",
 "libc",
 "wasi 0.9.0+wasi-snapshot-preview1",
 "typenum 1.10.0 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.9.0"
version = "0.12.0"
version = "0.12.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
]
[[package]]
name = "getrandom"
version = "0.1.14"
version = "0.1.15"
 "typenum 1.12.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "typenum",
]
[[package]]
name = "generic-array"
version = "0.14.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "501466ecc8a30d1d3b7fc9229b122b2ce8ed6e9d9223f1138d4babb253e51817"
dependencies = [
 "typenum",
 "version_check",
checksum = "c68f0274ae0e023facc3c97b2e00f076be70e254bc851d972503b328db79b2ec"
version = "0.12.0"
 "futures 0.1.25 (registry+https://github.com/rust-lang/crates.io-index)",
 "num_cpus 1.8.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.25 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",
 "num_cpus 1.10.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",
 "num_cpus 1.10.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.25 (registry+https://github.com/rust-lang/crates.io-index)",
 "num_cpus 1.9.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "proc-macro-hack 0.5.18 (registry+https://github.com/rust-lang/crates.io-index)",
 "proc-macro2 1.0.20 (registry+https://github.com/rust-lang/crates.io-index)",
 "quote 1.0.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "syn 1.0.40 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.27 (registry+https://github.com/rust-lang/crates.io-index)",
 "num_cpus 1.10.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",
 "proc-macro-hack",
 "proc-macro2",
 "quote",
 "syn",
 "futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",
 "num_cpus 1.10.0 (registry+https://github.com/rust-lang/crates.io-index)",
name = "futures-executor"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
]
[[package]]
name = "futures-io"
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
name = "futures-macro"
version = "0.3.5"
version = "0.3.6"
checksum = "5fc94b64bb39543b4e432f1790b6bf18e3ee3b74653c5449f63310e9a74b123c"
version = "0.3.5"
version = "0.3.6"
 "futures-core 0.3.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures-task 0.3.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures-util 0.3.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures-core",
 "futures-task",
 "futures-util",
checksum = "cc709ca1da6f66143b8c9bec8e6260181869893714e9b5a490b169b0414144ab"
version = "0.3.5"
version = "0.3.6"
name = "futures-cpupool"
version = "0.1.8"
version = "0.1.25"
version = "0.1.25"
version = "0.1.26"
version = "0.1.26"
version = "0.1.25"
version = "0.3.5"
version = "0.1.27"
version = "0.1.26"
version = "0.3.6"
version = "0.1.26"
 "new_debug_unreachable 1.0.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "new_debug_unreachable 1.0.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "new_debug_unreachable 1.0.4 (registry+https://github.com/rust-lang/crates.io-index)",
 "new_debug_unreachable 1.0.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "new_debug_unreachable 1.0.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "mac",
 "new_debug_unreachable",
 "mac 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "bitflags 1.0.4 (registry+https://github.com/rust-lang/crates.io-index)",
 "bitflags 1.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "bitflags 1.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "bitflags",
 "fuchsia-zircon-sys",
 "bitflags 1.0.4 (registry+https://github.com/rust-lang/crates.io-index)",
name = "fuchsia-cprng"
version = "0.1.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
checksum = "a06f77d526c1a601b7c4cdd98f54b5eaabffc14d5f2f0296febdc7f357c6d3ba"
name = "fuchsia-cprng"
version = "0.1.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
 "foreign-types-shared",
 "foreign-types-shared 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
version = "1.0.7"
version = "1.0.6"
 "syn 0.15.31 (registry+https://github.com/rust-lang/crates.io-index)",
 "synstructure 0.10.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "proc-macro2 0.4.20 (registry+https://github.com/rust-lang/crates.io-index)",
 "quote 0.6.8 (registry+https://github.com/rust-lang/crates.io-index)",
 "syn 0.15.14 (registry+https://github.com/rust-lang/crates.io-index)",
 "synstructure 0.10.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "proc-macro2 0.4.29 (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)",
 "syn 0.15.27 (registry+https://github.com/rust-lang/crates.io-index)",
 "proc-macro2 0.4.27 (registry+https://github.com/rust-lang/crates.io-index)",
 "proc-macro2 0.4.27 (registry+https://github.com/rust-lang/crates.io-index)",
 "proc-macro2 1.0.20 (registry+https://github.com/rust-lang/crates.io-index)",
 "quote 1.0.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "syn 1.0.40 (registry+https://github.com/rust-lang/crates.io-index)",
 "synstructure 0.12.4 (registry+https://github.com/rust-lang/crates.io-index)",
 "proc-macro2 0.4.30 (registry+https://github.com/rust-lang/crates.io-index)",
 "proc-macro2",
 "quote",
 "syn",
 "synstructure",
 "proc-macro2 0.4.27 (registry+https://github.com/rust-lang/crates.io-index)",
 "quote 0.6.12 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.1.3"
version = "0.1.5"
version = "0.1.8"
version = "0.1.5"
 "backtrace 0.3.9 (registry+https://github.com/rust-lang/crates.io-index)",
 "failure_derive 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "backtrace 0.3.14 (registry+https://github.com/rust-lang/crates.io-index)",
 "backtrace 0.3.15 (registry+https://github.com/rust-lang/crates.io-index)",
 "backtrace 0.3.15 (registry+https://github.com/rust-lang/crates.io-index)",
 "backtrace 0.3.13 (registry+https://github.com/rust-lang/crates.io-index)",
 "backtrace 0.3.50 (registry+https://github.com/rust-lang/crates.io-index)",
 "failure_derive 0.1.8 (registry+https://github.com/rust-lang/crates.io-index)",
 "backtrace 0.3.30 (registry+https://github.com/rust-lang/crates.io-index)",
 "backtrace 0.3.15 (registry+https://github.com/rust-lang/crates.io-index)",
 "backtrace",
 "failure_derive",
 "backtrace 0.3.15 (registry+https://github.com/rust-lang/crates.io-index)",
 "failure_derive 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.1.3"
version = "0.1.5"
version = "0.1.8"
version = "0.1.5"
]
[[package]]
 "backtrace 0.3.15 (registry+https://github.com/rust-lang/crates.io-index)",
name = "error-chain"
version = "0.8.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "humantime 1.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "log 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "regex 1.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "regex 1.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "regex 1.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "atty 0.2.14 (registry+https://github.com/rust-lang/crates.io-index)",
 "humantime 1.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "log 0.4.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "regex 1.3.9 (registry+https://github.com/rust-lang/crates.io-index)",
 "termcolor 1.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "atty",
 "humantime",
 "log",
 "regex",
 "termcolor",
 "atty 0.2.11 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.5.13"
version = "0.6.0"
version = "0.6.1"
version = "0.6.0"
version = "0.7.1"
version = "0.6.1"
version = "0.6.1"
version = "0.6.1"
 "cfg-if 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "cfg-if 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "cfg-if 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "cfg-if 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "cfg-if 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "heck 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "proc-macro2 1.0.20 (registry+https://github.com/rust-lang/crates.io-index)",
 "quote 1.0.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "syn 1.0.40 (registry+https://github.com/rust-lang/crates.io-index)",
 "cfg-if 0.1.9 (registry+https://github.com/rust-lang/crates.io-index)",
 "cfg-if 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "heck",
 "proc-macro2",
 "quote",
 "syn",
 "cfg-if 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.8.17"
version = "0.8.15"
version = "0.8.17"
version = "0.8.17"
name = "enum-as-inner"
version = "0.3.3"
name = "either"
version = "1.5.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
name = "encoding_rs"
 "generic-array 0.9.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "generic-array 0.12.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "generic-array 0.12.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "generic-array 0.12.3",
]
[[package]]
name = "digest"
version = "0.9.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d3dd60d1080a57a05ab032377049e0591415d2b31afd7028356dbf3cc6dcb066"
dependencies = [
 "generic-array 0.14.4",
 "generic-array 0.12.0 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.7.6"
version = "0.8.0"
version = "0.8.1"
version = "0.8.0"
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]]
 "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)",
 "generic-array 0.12.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "generic-array 0.12.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "generic-array 0.12.3",
 "subtle 1.0.0",
]
[[package]]
name = "crypto-mac"
version = "0.8.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "b584a330336237c1eecd3e94266efb216c56ed91225d634cb2991c5f3fd1aeab"
dependencies = [
 "generic-array 0.14.4",
 "subtle 2.3.0",
 "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)",
name = "crypto-mac"
version = "0.7.0"
name = "crypto-mac"
version = "0.7.0"
 "cfg-if 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
 "cfg-if 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "cfg-if 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "lazy_static 1.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "cfg-if 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "lazy_static 1.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "cfg-if 0.1.9 (registry+https://github.com/rust-lang/crates.io-index)",
 "cfg-if 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "lazy_static 1.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "cfg-if 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "lazy_static 1.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "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]]
 "lazy_static 1.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "cfg-if 0.1.7 (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)",
 "cfg-if 0.1.9 (registry+https://github.com/rust-lang/crates.io-index)",
 "cfg-if 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
name = "crypto-mac"
version = "0.5.2"
name = "crossbeam-utils"
version = "0.6.5"
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)",
name = "cpuid-bool"
version = "0.1.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "8aebca1129a03dc6dc2b127edd729435bbc4a37e1d5f4d7513165089ceb02634"
[[package]]
name = "crossbeam-utils"
version = "0.6.5"
dependencies = [
 "crossbeam-utils 0.6.5 (registry+https://github.com/rust-lang/crates.io-index)",
]
checksum = "b3a71ab494c0b5b860bdc8407ae08978052417070c2ced38573a9157ad75b8ac"
dependencies = [
 "crossbeam-utils 0.6.5 (registry+https://github.com/rust-lang/crates.io-index)",
]
name = "crossbeam-queue"
version = "0.1.2"
name = "crossbeam-deque"
version = "0.6.3"
version = "0.7.1"
name = "crossbeam-queue"
version = "0.1.2"
 "smallvec 0.6.8 (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)",
 "crossbeam-utils 0.6.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
[[package]]
]
 "arrayvec 0.4.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "cfg-if 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "crossbeam-utils 0.6.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "lazy_static 1.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
dependencies = [
 "libc 0.2.49 (registry+https://github.com/rust-lang/crates.io-index)",
]
dependencies = [
 "libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
]
dependencies = [
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "crossbeam-epoch 0.5.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "crossbeam-utils 0.5.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "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)",
name = "crossbeam-channel"
version = "0.3.8"
 "lazy_static 1.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "num_cpus 1.9.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "parking_lot 0.7.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "cfg-if 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "crossbeam-channel 0.3.8 (registry+https://github.com/rust-lang/crates.io-index)",
 "crossbeam-deque 0.6.3 (registry+https://github.com/rust-lang/crates.io-index)",
name = "crossbeam"
version = "0.6.0"
name = "crossbeam-epoch"
version = "0.5.2"
version = "0.7.1"
version = "0.7.1"
]
[[package]]
 "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)",
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
name = "crossbeam-deque"
version = "0.6.1"
version = "0.7.1"
version = "0.7.1"
]
[[package]]
 "libc 0.2.43 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.48 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.6.2"
version = "0.5.1"
version = "0.5.1"
version = "0.7.0"
version = "0.6.2"
version = "0.5.1"
 "libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
 "core-foundation-sys 0.6.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.53 (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)",
 "core-foundation-sys 0.5.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
 "core-foundation-sys 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.76 (registry+https://github.com/rust-lang/crates.io-index)",
 "core-foundation-sys 0.6.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.58 (registry+https://github.com/rust-lang/crates.io-index)",
 "core-foundation-sys",
 "libc",
 "core-foundation-sys 0.5.1 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.6.4"
version = "0.5.1"
version = "0.5.1"
version = "0.7.0"
version = "0.6.4"
version = "0.5.1"
 "bitflags 1.0.4 (registry+https://github.com/rust-lang/crates.io-index)",
 "bitflags 1.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "bitflags 1.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "bitflags",
 "bitflags 1.0.4 (registry+https://github.com/rust-lang/crates.io-index)",
 "atty 0.2.11 (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)",
 "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)",
 "strsim 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "textwrap 0.11.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "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)",
 "strsim 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "textwrap 0.11.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "strsim 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "textwrap 0.11.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "strsim 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "textwrap 0.11.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "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)",
 "bitflags 1.0.4 (registry+https://github.com/rust-lang/crates.io-index)",
 "bitflags 1.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "bitflags 1.0.4 (registry+https://github.com/rust-lang/crates.io-index)",
 "ansi_term",
 "atty",
 "bitflags",
 "strsim",
 "textwrap",
 "unicode-width",
 "vec_map",
 "ansi_term 0.11.0 (registry+https://github.com/rust-lang/crates.io-index)",
version = "2.32.0"
version = "2.32.0"
version = "2.33.0"
version = "2.32.0"
version = "2.33.3"
version = "2.33.0"
version = "2.33.0"
version = "2.33.0"
 "time 0.1.42 (registry+https://github.com/rust-lang/crates.io-index)",
 "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)",
 "num-integer 0.1.43 (registry+https://github.com/rust-lang/crates.io-index)",
 "num-traits 0.2.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "time 0.1.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "num-integer 0.1.41 (registry+https://github.com/rust-lang/crates.io-index)",
 "num-traits 0.2.8 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc",
 "num-integer",
 "num-traits",
 "time",
 "winapi 0.3.9",
 "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)",
version = "0.4.15"
version = "0.4.19"
version = "0.4.6"
version = "0.1.6"
version = "0.1.6"
version = "0.1.7"
version = "0.1.7"
version = "0.1.6"
version = "0.1.10"
version = "0.1.9"
version = "0.1.7"
version = "0.1.7"
version = "1.0.25"
version = "1.0.30"
version = "1.0.35"
version = "1.0.35"
version = "1.0.29"
version = "1.0.59"
version = "1.0.37"
version = "1.0.35"
version = "1.0.61"
version = "1.0.35"
name = "case"
version = "0.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
 "iovec 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
]
 "byteorder 1.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
checksum = "0e4cec68f03f32e44924783795810fa50a7035d8c8ebe78580ad7e6c703fba38"
dependencies = [
version = "0.4.10"
version = "0.4.11"
version = "0.4.12"
version = "0.4.11"
version = "0.5.6"
version = "0.4.12"
version = "0.4.12"
version = "0.4.12"
version = "1.2.7"
version = "1.3.1"
version = "1.3.1"
version = "1.3.4"
version = "1.3.2"
version = "1.3.1"
version = "0.2.0"
version = "0.3.1"
version = "0.3.1"
 "arrayref 0.3.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "byte-tools 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "block-padding 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)",
 "block-padding 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "block-padding 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "block-padding 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "block-padding 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "block-padding 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)",
 "block-padding 0.1.5",
 "byte-tools",
 "byteorder",
 "generic-array 0.12.3",
]
[[package]]
name = "block-buffer"
version = "0.9.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "4152116fd6e9dadb291ae18fc1ec3575ed6d84c29642d97890f4b4a3417297e4"
dependencies = [
 "block-padding 0.2.1",
 "generic-array 0.14.4",
 "byte-tools 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
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"
version = "0.3.3"
version = "0.7.3"
version = "0.7.0"
version = "0.7.0"
version = "0.7.0"
version = "0.7.2"
version = "0.7.3"
version = "0.7.0"
version = "0.7.3"
version = "0.7.0"
version = "0.7.0"
version = "0.7.3"
 "byte-tools 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "crypto-mac 0.5.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "digest 0.7.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "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)",
 "byte-tools",
 "byteorder",
 "crypto-mac 0.8.0",
 "digest 0.9.0",
 "opaque-debug 0.2.3",
 "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)",
version = "0.7.1"
version = "0.8.0"
version = "0.8.1"
version = "0.9.0"
version = "0.8.0"
version = "1.0.4"
version = "1.2.1"
version = "1.1.0"
version = "1.0.4"
]
 "byteorder 1.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
checksum = "3441f0f7b02788e948e47f457ca01f1d7e6d92c693bc132c22b087d3141c03ff"
dependencies = [
version = "0.9.3"
version = "0.10.1"
version = "0.12.3"
version = "0.10.1"
 "cc 1.0.25 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.43 (registry+https://github.com/rust-lang/crates.io-index)",
 "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)",
 "cc 1.0.35 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
 "cc 1.0.35 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
 "cc 1.0.29 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.48 (registry+https://github.com/rust-lang/crates.io-index)",
 "byteorder 1.3.4 (registry+https://github.com/rust-lang/crates.io-index)",
 "cc 1.0.37 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.58 (registry+https://github.com/rust-lang/crates.io-index)",
 "cc 1.0.35 (registry+https://github.com/rust-lang/crates.io-index)",
 "byteorder",
 "cc 1.0.35 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.1.28"
version = "0.1.28"
name = "base64"
version = "0.10.1"
name = "backtrace-sys"
 "backtrace-sys 0.1.24 (registry+https://github.com/rust-lang/crates.io-index)",
 "cfg-if 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.43 (registry+https://github.com/rust-lang/crates.io-index)",
 "rustc-demangle 0.1.9 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "autocfg 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "autocfg 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "addr2line 0.13.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "cfg-if 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.76 (registry+https://github.com/rust-lang/crates.io-index)",
 "miniz_oxide 0.4.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "object 0.20.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "rustc-demangle 0.1.16 (registry+https://github.com/rust-lang/crates.io-index)",
 "autocfg 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)",
 "addr2line",
 "cfg-if",
 "libc",
 "miniz_oxide",
 "object",
 "rustc-demangle",
 "autocfg 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "backtrace-sys 0.1.28 (registry+https://github.com/rust-lang/crates.io-index)",
 "cfg-if 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
 "rustc-demangle 0.1.14 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.3.9"
version = "0.3.14"
version = "0.3.15"
version = "0.3.15"
version = "0.3.13"
version = "0.3.50"
version = "0.3.30"
version = "0.3.15"
version = "0.3.52"
version = "0.3.15"
name = "backtrace"
version = "0.2.3"
name = "autocfg"
version = "0.1.2"
version = "0.1.2"
version = "1.0.1"
version = "0.1.4"
name = "autocfg"
version = "0.1.2"
 "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)",
 "winapi 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.43 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.53 (registry+https://github.com/rust-lang/crates.io-index)",
 "termion 1.5.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "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)",
 "libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
 "termion 1.5.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.48 (registry+https://github.com/rust-lang/crates.io-index)",
 "hermit-abi 0.1.15 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.76 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.9 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.58 (registry+https://github.com/rust-lang/crates.io-index)",
 "termion 1.5.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
 "hermit-abi",
 "libc",
 "winapi 0.3.9",
 "libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.2.14"
version = "0.2.11"
 "nodrop 0.1.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "nodrop 0.1.13 (registry+https://github.com/rust-lang/crates.io-index)",
 "proc-macro2 1.0.20 (registry+https://github.com/rust-lang/crates.io-index)",
 "quote 1.0.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "syn 1.0.40 (registry+https://github.com/rust-lang/crates.io-index)",
 "proc-macro2",
 "quote",
 "syn",
 "nodrop 0.1.13 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.4.7"
version = "0.4.10"
version = "0.4.10"
name = "arrayref"
version = "0.3.5"
name = "async-trait"
version = "0.1.40"
version = "0.1.41"
checksum = "4d25d88fd6b8041580a654f9d0c581a047baee2b3efee13275f2fc392fc75034"
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
version = "0.3.4"
version = "0.3.11"
version = "0.3.7"
version = "0.3.10"
version = "0.3.10"
version = "0.3.10"
version = "0.3.7"
version = "0.4.7"
version = "0.3.11"
version = "0.3.10"
version = "0.3.11"
 "winapi 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.9 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.9",
 "winapi 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "memchr 2.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "memchr 2.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "memchr 2.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "memchr 2.3.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "memchr 2.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "memchr",
 "memchr 2.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.6.8"
version = "0.6.10"
version = "0.7.3"
version = "0.6.9"
version = "0.7.13"
version = "0.7.3"
version = "0.7.3"
version = "0.7.3"
 "libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.48 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.6.8"
version = "0.6.8"
version = "0.6.9"
name = "aho-corasick"
version = "0.6.8"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "memchr 2.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
version = "0.6.9"
[[package]]
[[package]]
name = "MacTypes-sys"
version = "1.3.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "libc 0.2.45 (registry+https://github.com/rust-lang/crates.io-index)",
]
name = "MacTypes-sys"
version = "1.3.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "libc 0.2.45 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
 "memchr 2.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.3.4"
name = "arrayref"
version = "0.3.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
name = "arrayvec"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
]
[[package]]
name = "atty"
version = "0.2.11"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "termion 1.5.1 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "autocfg"
version = "0.1.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
name = "autocfg"
version = "0.1.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
name = "backtrace"
version = "0.2.3"
dependencies = [
 "backtrace-sys 0.1.24 (registry+https://github.com/rust-lang/crates.io-index)",
 "cfg-if 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "dbghelp-sys 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "kernel32-sys 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "rustc-demangle 0.1.9 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.2.8 (registry+https://github.com/rust-lang/crates.io-index)",
]
version = "0.3.9"
 "backtrace-sys 0.1.24 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.43 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.1.24"
 "cc 1.0.25 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.9.3"
 "byteorder 1.2.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "safemem 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.7.1"
 "byte-tools 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "crypto-mac 0.5.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "digest 0.7.6 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.3.3"
 "arrayref 0.3.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "byte-tools 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
name = "block-padding"
version = "0.1.2"
version = "0.2.0"
version = "1.2.7"
version = "0.4.10"
 "byteorder 1.2.7 (registry+https://github.com/rust-lang/crates.io-index)",
version = "1.0.25"
version = "0.1.7"
 "time 0.1.40 (registry+https://github.com/rust-lang/crates.io-index)",
version = "2.33.0"
 "strsim 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "textwrap 0.11.0 (registry+https://github.com/rust-lang/crates.io-index)",
[[package]]
name = "constant_time_eq"
version = "0.1.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
 "libc 0.2.43 (registry+https://github.com/rust-lang/crates.io-index)",
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "libc 0.2.43 (registry+https://github.com/rust-lang/crates.io-index)",
name = "crossbeam-channel"
version = "0.3.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "crossbeam-utils 0.6.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "parking_lot 0.7.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand 0.6.4 (registry+https://github.com/rust-lang/crates.io-index)",
 "smallvec 0.6.8 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.6.1"
 "crossbeam-epoch 0.5.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "crossbeam-utils 0.5.0 (registry+https://github.com/rust-lang/crates.io-index)",
name = "crossbeam-deque"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "crossbeam-utils 0.5.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "lazy_static 1.1.0 (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)",
name = "crossbeam-queue"
version = "0.1.2"
 "crossbeam-utils 0.6.5 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.5.0"
 "cfg-if 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
name = "crypto-mac"
 "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)",
name = "dbghelp-sys"
version = "0.2.0"
name = "dbghelp-sys"
version = "0.2.0"
 "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)",
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
]
[[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"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
]
[[package]]
name = "encoding_rs"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
]
[[package]]
name = "env_logger"
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)",
 "termcolor 1.0.4 (registry+https://github.com/rust-lang/crates.io-index)",
name = "error-chain"
 "backtrace 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.8.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
]
[[package]]
name = "failure"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "failure_derive 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.1.3"
 "proc-macro2 0.4.20 (registry+https://github.com/rust-lang/crates.io-index)",
 "quote 0.6.8 (registry+https://github.com/rust-lang/crates.io-index)",
 "syn 0.15.14 (registry+https://github.com/rust-lang/crates.io-index)",
 "synstructure 0.10.0 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.1.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
name = "fuchsia-cprng"
 "new_debug_unreachable 1.0.2 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.1.26"
 "futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.9.0"
version = "0.1.13"
 "byteorder 1.2.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",
 "http 0.1.17 (registry+https://github.com/rust-lang/crates.io-index)",
 "log 0.4.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "string 0.1.1 (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 = [
 "winutil 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "http"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "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"
dependencies = [
 "quick-error 1.2.2 (registry+https://github.com/rust-lang/crates.io-index)",
]
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]]
version = "0.12.13"
 "bytes 0.4.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "h2 0.1.13 (registry+https://github.com/rust-lang/crates.io-index)",
 "http 0.1.13 (registry+https://github.com/rust-lang/crates.io-index)",
 "log 0.4.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "time 0.1.40 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-executor 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-tcp 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-timer 0.2.8 (registry+https://github.com/rust-lang/crates.io-index)",
 "unicode-normalization 0.1.8 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.43 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.1.7"
 "winapi 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.5.2"
 "failure 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "failure_derive 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "minidom 0.9.1 (registry+https://github.com/rust-lang/crates.io-index)",
version = "1.1.0"
dependencies = [
 "version_check 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
]
version = "1.2.0"
version = "0.2.43"
version = "0.5.2"
version = "0.1.4"
 "owning_ref 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "log"
version = "0.4.5"
 "cfg-if 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.1.2"
 "linked-hash-map 0.5.2 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.7.3"
 "phf 0.7.23 (registry+https://github.com/rust-lang/crates.io-index)",
 "phf_codegen 0.7.23 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde 1.0.80 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde_derive 1.0.80 (registry+https://github.com/rust-lang/crates.io-index)",
 "tendril 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
version = "2.1.0"
dependencies = [
 "cfg-if 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.48 (registry+https://github.com/rust-lang/crates.io-index)",
]
version = "0.9.1"
 "failure 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "failure_derive 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "quick-xml 0.12.4 (registry+https://github.com/rust-lang/crates.io-index)",
 "lazycell 1.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.43 (registry+https://github.com/rust-lang/crates.io-index)",
 "log 0.4.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "slab 0.4.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.43 (registry+https://github.com/rust-lang/crates.io-index)",
 "lazy_static 1.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.43 (registry+https://github.com/rust-lang/crates.io-index)",
 "log 0.4.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "openssl-probe 0.1.2 (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)",
 "cfg-if 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.50 (registry+https://github.com/rust-lang/crates.io-index)",
version = "1.0.2"
dependencies = [
 "unreachable 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)",
]
version = "0.1.12"
version = "1.8.0"
 "libc 0.2.43 (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"
name = "opaque-debug"
version = "0.2.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
version = "0.10.15"
 "cfg-if 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "lazy_static 1.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.43 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.9.39"
 "cc 1.0.25 (registry+https://github.com/rust-lang/crates.io-index)",
 "rustc_version 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.3.3"
version = "0.6.4"
 "lock_api 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "parking_lot_core"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "rand 0.5.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "smallvec 0.6.5 (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)",
name = "pbkdf2"
version = "0.3.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "byteorder 1.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "crypto-mac 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
version = "0.7.23"
 "phf_shared 0.7.23 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.7.23"
 "phf_generator 0.7.23 (registry+https://github.com/rust-lang/crates.io-index)",
 "phf_shared 0.7.23 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.7.23"
 "phf_shared 0.7.23 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand 0.5.5 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.7.23"
version = "0.4.20"
version = "0.12.4"
 "encoding_rs 0.8.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "log 0.4.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "memchr 2.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.6.8"
 "proc-macro2 0.4.20 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.4.3"
 "proc-macro2 0.4.27 (registry+https://github.com/rust-lang/crates.io-index)",
 "proc-macro2 0.4.27 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.5.6"
 "fuchsia-zircon 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",
]
version = "0.4.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "proc-macro2 0.4.26 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "rand"
 "proc-macro2 0.4.24 (registry+https://github.com/rust-lang/crates.io-index)",
 "cloudabi 0.0.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.43 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.45 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.45 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.47 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.45 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.45 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand_core 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.47 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "fuchsia-zircon 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "fuchsia-zircon 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "proc-macro2 0.4.24 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "rand"
version = "0.4.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "libc 0.2.45 (registry+https://github.com/rust-lang/crates.io-index)",
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
version = "0.5.5"
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.45 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.45 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.45 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "rand"
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "proc-macro2 0.4.26 (registry+https://github.com/rust-lang/crates.io-index)",
 "fuchsia-zircon 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "fuchsia-zircon 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.4.3"
 "proc-macro2 0.4.24 (registry+https://github.com/rust-lang/crates.io-index)",
 "proc-macro2 0.4.24 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "rand"
 "proc-macro2 0.4.26 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.6.11"
version = "0.6.11"
version = "0.6.12"
version = "0.6.11"
version = "0.6.10"
version = "0.6.11"
version = "0.6.12"
version = "0.6.10"
version = "0.6.10"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "proc-macro2 0.4.24 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "rand"
version = "0.4.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
version = "0.6.10"
version = "0.6.10"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
version = "0.6.11"
 "memchr 2.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "memchr 2.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "memchr 2.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "memchr 2.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "memchr 2.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "memchr 2.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "log 0.4.6 (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"
 "memchr 2.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "memchr 2.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "memchr 2.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "memchr 2.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "memchr 2.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "memchr 2.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "memchr 2.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "failure 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "encoding_rs 0.8.13 (registry+https://github.com/rust-lang/crates.io-index)",
 "memchr 2.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "memchr 2.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "memchr 2.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "memchr 2.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "memchr 2.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "memchr 2.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "memchr 2.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "memchr 2.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "memchr 2.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "log 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "memchr 2.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "memchr 2.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "memchr 2.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "encoding_rs 0.8.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "failure 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "encoding_rs 0.8.16 (registry+https://github.com/rust-lang/crates.io-index)",
 "encoding_rs 0.8.17 (registry+https://github.com/rust-lang/crates.io-index)",
 "encoding_rs 0.8.13 (registry+https://github.com/rust-lang/crates.io-index)",
 "encoding_rs 0.8.14 (registry+https://github.com/rust-lang/crates.io-index)",
 "failure 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "encoding_rs 0.8.15 (registry+https://github.com/rust-lang/crates.io-index)",
 "failure 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "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)",
 "encoding_rs 0.8.13 (registry+https://github.com/rust-lang/crates.io-index)",
 "encoding_rs 0.8.15 (registry+https://github.com/rust-lang/crates.io-index)",
 "encoding_rs 0.8.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "encoding_rs 0.8.13 (registry+https://github.com/rust-lang/crates.io-index)",
 "failure 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)",
 "encoding_rs 0.8.14 (registry+https://github.com/rust-lang/crates.io-index)",
 "failure 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "encoding_rs 0.8.17 (registry+https://github.com/rust-lang/crates.io-index)",
 "encoding_rs 0.8.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "failure 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "encoding_rs 0.8.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "encoding_rs 0.8.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "encoding_rs 0.8.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "failure 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "encoding_rs 0.8.15 (registry+https://github.com/rust-lang/crates.io-index)",
 "encoding_rs 0.8.17 (registry+https://github.com/rust-lang/crates.io-index)",
 "encoding_rs 0.8.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "failure 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "encoding_rs 0.8.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "failure 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "encoding_rs 0.8.14 (registry+https://github.com/rust-lang/crates.io-index)",
 "failure 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "encoding_rs 0.8.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "encoding_rs 0.8.15 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.13.3"
version = "0.13.2"
version = "0.13.2"
version = "0.13.3"
version = "0.13.2"
version = "0.13.2"
version = "0.13.3"
version = "0.12.4"
version = "0.12.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
version = "0.13.2"
version = "0.13.3"
version = "0.12.4"
version = "0.12.4"
version = "0.13.2"
version = "0.4.26"
version = "0.4.27"
version = "0.4.27"
version = "0.4.24"
version = "0.4.26"
version = "0.4.24"
version = "0.4.24"
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.4.24"
version = "0.4.24"
version = "0.4.26"
version = "0.7.24"
version = "0.7.24"
version = "0.7.24"
version = "0.7.24"
version = "0.7.23"
version = "0.7.23"
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.7.23"
version = "0.7.23"
version = "0.7.24"
 "phf_shared 0.7.24 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand 0.6.4 (registry+https://github.com/rust-lang/crates.io-index)",
 "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)",
 "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)",
 "phf_shared 0.7.24 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand 0.6.4 (registry+https://github.com/rust-lang/crates.io-index)",
 "phf_shared 0.7.23 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand 0.5.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "phf_shared 0.7.23 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand 0.5.5 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "phf_shared"
 "phf_shared 0.7.23 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand 0.5.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "phf_shared 0.7.23 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand 0.5.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "phf_shared 0.7.24 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand 0.6.4 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.7.24"
version = "0.7.24"
version = "0.7.24"
version = "0.7.24"
version = "0.7.23"
version = "0.7.23"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
version = "0.7.23"
version = "0.7.23"
version = "0.7.24"
 "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)",
 "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)",
 "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)",
 "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)",
 "phf_generator 0.7.23 (registry+https://github.com/rust-lang/crates.io-index)",
 "phf_shared 0.7.23 (registry+https://github.com/rust-lang/crates.io-index)",
 "phf_generator 0.7.23 (registry+https://github.com/rust-lang/crates.io-index)",
 "phf_shared 0.7.23 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "phf_generator"
 "phf_generator 0.7.23 (registry+https://github.com/rust-lang/crates.io-index)",
 "phf_shared 0.7.23 (registry+https://github.com/rust-lang/crates.io-index)",
 "phf_generator 0.7.23 (registry+https://github.com/rust-lang/crates.io-index)",
 "phf_shared 0.7.23 (registry+https://github.com/rust-lang/crates.io-index)",
 "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)",
version = "0.7.24"
version = "0.7.24"
version = "0.7.24"
version = "0.7.24"
version = "0.7.23"
version = "0.7.23"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
version = "0.7.23"
version = "0.7.23"
version = "0.7.24"
 "phf_shared 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)",
 "phf_shared 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)",
 "phf_shared 0.7.23 (registry+https://github.com/rust-lang/crates.io-index)",
 "phf_shared 0.7.23 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "phf_codegen"
 "phf_shared 0.7.23 (registry+https://github.com/rust-lang/crates.io-index)",
 "phf_shared 0.7.23 (registry+https://github.com/rust-lang/crates.io-index)",
 "phf_shared 0.7.24 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.7.24"
version = "0.7.24"
version = "0.7.24"
version = "0.7.24"
version = "0.7.23"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
version = "0.7.23"
version = "0.7.23"
version = "0.7.23"
version = "0.7.24"
]
[[package]]
name = "pbkdf2"
version = "0.3.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "byteorder 1.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "crypto-mac 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "percent-encoding"
version = "1.0.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
name = "phf"
name = "pbkdf2"
version = "0.3.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "byteorder 1.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "crypto-mac 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
 "smallvec 0.6.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "smallvec 0.6.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "smallvec 0.6.9 (registry+https://github.com/rust-lang/crates.io-index)",
 "smallvec 0.6.9 (registry+https://github.com/rust-lang/crates.io-index)",
 "smallvec 0.6.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "smallvec 0.6.8 (registry+https://github.com/rust-lang/crates.io-index)",
 "smallvec 0.6.8 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "pbkdf2"
version = "0.3.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "byteorder 1.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "crypto-mac 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "smallvec 0.6.9 (registry+https://github.com/rust-lang/crates.io-index)",
 "smallvec 0.6.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "smallvec 0.6.8 (registry+https://github.com/rust-lang/crates.io-index)",
 "smallvec 0.6.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "smallvec 0.6.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "smallvec 0.6.8 (registry+https://github.com/rust-lang/crates.io-index)",
 "smallvec 0.6.9 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "smallvec 0.6.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "smallvec 0.6.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "smallvec 0.6.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "smallvec 0.6.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "smallvec 0.6.8 (registry+https://github.com/rust-lang/crates.io-index)",
 "smallvec 0.6.9 (registry+https://github.com/rust-lang/crates.io-index)",
 "smallvec 0.6.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "smallvec 0.6.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "smallvec 0.6.8 (registry+https://github.com/rust-lang/crates.io-index)",
 "smallvec 0.6.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "smallvec 0.6.8 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand 0.6.5 (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)",
 "rand 0.5.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.43 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.45 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.50 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.50 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.45 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.47 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand 0.6.4 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.48 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.45 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.49 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.48 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.45 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.47 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand 0.6.4 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand 0.5.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.48 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.49 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand 0.5.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand 0.5.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.47 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand 0.6.4 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.49 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.3.1"
version = "0.4.0"
version = "0.4.0"
version = "0.4.0"
version = "0.4.0"
version = "0.3.1"
version = "0.3.1"
version = "0.3.1"
version = "0.3.1"
version = "0.4.0"
 "parking_lot_core 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "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)",
 "parking_lot_core 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "parking_lot_core 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "parking_lot_core 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "parking_lot_core 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "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)",
 "parking_lot_core 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "parking_lot_core 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "parking_lot_core 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.7.1"
version = "0.7.1"
version = "0.7.1"
version = "0.7.1"
version = "0.6.4"
version = "0.6.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
version = "0.6.4"
version = "0.6.4"
version = "0.7.1"
version = "0.4.0"
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"
 "rustc_version 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "rustc_version 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "pkg-config 0.3.14 (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"
 "rustc_version 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.43 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "cc 1.0.28 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.45 (registry+https://github.com/rust-lang/crates.io-index)",
 "cc 1.0.25 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "cc 1.0.31 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.50 (registry+https://github.com/rust-lang/crates.io-index)",
 "cc 1.0.30 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.50 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.49 (registry+https://github.com/rust-lang/crates.io-index)",
 "cc 1.0.26 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.45 (registry+https://github.com/rust-lang/crates.io-index)",
 "cc 1.0.28 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.47 (registry+https://github.com/rust-lang/crates.io-index)",
 "cc 1.0.29 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.48 (registry+https://github.com/rust-lang/crates.io-index)",
 "cc 1.0.35 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
 "cc 1.0.28 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.45 (registry+https://github.com/rust-lang/crates.io-index)",
 "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)",
 "cc 1.0.29 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.48 (registry+https://github.com/rust-lang/crates.io-index)",
 "cc 1.0.28 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.45 (registry+https://github.com/rust-lang/crates.io-index)",
 "cc 1.0.28 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.47 (registry+https://github.com/rust-lang/crates.io-index)",
 "cc 1.0.35 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
 "cc 1.0.25 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "cc 1.0.25 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "cc 1.0.25 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "cc 1.0.25 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "cc 1.0.29 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.48 (registry+https://github.com/rust-lang/crates.io-index)",
 "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)",
 "cc 1.0.25 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "cc 1.0.25 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "cc 1.0.28 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.47 (registry+https://github.com/rust-lang/crates.io-index)",
 "cc 1.0.25 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.9.40"
version = "0.9.39"
version = "0.9.43"
version = "0.9.42"
version = "0.9.40"
version = "0.9.40"
version = "0.9.40"
version = "0.9.43"
version = "0.9.40"
version = "0.9.42"
version = "0.9.40"
version = "0.9.40"
version = "0.9.40"
version = "0.9.43"
version = "0.9.39"
version = "0.9.39"
version = "0.9.39"
version = "0.9.39"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
]
[[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.40"
version = "0.9.42"
version = "0.9.39"
version = "0.9.39"
version = "0.9.40"
version = "0.9.39"
 "openssl-sys 0.9.39 (registry+https://github.com/rust-lang/crates.io-index)",
 "lazy_static 1.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "openssl-sys 0.9.42 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.50 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.49 (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.51 (registry+https://github.com/rust-lang/crates.io-index)",
 "openssl-sys 0.9.43 (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)",
 "lazy_static 1.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.48 (registry+https://github.com/rust-lang/crates.io-index)",
 "openssl-sys 0.9.40 (registry+https://github.com/rust-lang/crates.io-index)",
 "lazy_static 1.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.48 (registry+https://github.com/rust-lang/crates.io-index)",
 "openssl-sys 0.9.40 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.47 (registry+https://github.com/rust-lang/crates.io-index)",
 "openssl-sys 0.9.40 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "openssl-sys 0.9.39 (registry+https://github.com/rust-lang/crates.io-index)",
 "lazy_static 1.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
 "openssl-sys 0.9.43 (registry+https://github.com/rust-lang/crates.io-index)",
 "lazy_static 1.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "openssl-sys 0.9.39 (registry+https://github.com/rust-lang/crates.io-index)",
 "lazy_static 1.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.45 (registry+https://github.com/rust-lang/crates.io-index)",
 "openssl-sys 0.9.40 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "openssl-sys 0.9.39 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.45 (registry+https://github.com/rust-lang/crates.io-index)",
 "openssl-sys 0.9.40 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.47 (registry+https://github.com/rust-lang/crates.io-index)",
 "openssl-sys 0.9.40 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.45 (registry+https://github.com/rust-lang/crates.io-index)",
 "openssl-sys 0.9.40 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.45 (registry+https://github.com/rust-lang/crates.io-index)",
 "openssl-sys 0.9.40 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "openssl-sys 0.9.39 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "openssl-sys 0.9.39 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "openssl-sys 0.9.39 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "openssl-sys 0.9.39 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.47 (registry+https://github.com/rust-lang/crates.io-index)",
 "openssl-sys 0.9.40 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "openssl-sys 0.9.39 (registry+https://github.com/rust-lang/crates.io-index)",
 "lazy_static 1.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.48 (registry+https://github.com/rust-lang/crates.io-index)",
 "openssl-sys 0.9.40 (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.50 (registry+https://github.com/rust-lang/crates.io-index)",
 "openssl-sys 0.9.43 (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)",
 "cfg-if 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "cfg-if 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "cfg-if 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "cfg-if 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "cfg-if 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "cfg-if 0.1.6 (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)",
 "cfg-if 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.10.16"
version = "0.10.15"
version = "0.10.20"
version = "0.10.19"
version = "0.10.16"
version = "0.10.16"
version = "0.10.16"
version = "0.10.20"
version = "0.10.16"
version = "0.10.19"
version = "0.10.16"
version = "0.10.16"
version = "0.10.16"
version = "0.10.20"
version = "0.10.15"
version = "0.10.15"
version = "0.10.15"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "bitflags 1.0.4 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.10.15"
version = "0.10.16"
version = "0.10.19"
version = "0.10.15"
version = "0.10.15"
version = "0.10.16"
version = "0.10.15"
[[package]]
name = "opaque-debug"
version = "0.2.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
[[package]]
name = "opaque-debug"
version = "0.2.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
name = "openssl"
name = "opaque-debug"
version = "0.2.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
 "libc 0.2.45 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.50 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.50 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.45 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.47 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.48 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.45 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.49 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.48 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.45 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.47 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
]
 "libc 0.2.48 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.49 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.47 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.49 (registry+https://github.com/rust-lang/crates.io-index)",
version = "1.9.0"
version = "1.8.0"
version = "1.10.0"
version = "1.10.0"
version = "1.9.0"
version = "1.9.0"
version = "1.9.0"
version = "1.10.0"
version = "1.9.0"
version = "1.9.0"
version = "1.9.0"
version = "1.9.0"
version = "1.10.0"
version = "1.8.0"
version = "1.8.0"
version = "1.8.0"
version = "1.8.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
version = "1.9.0"
version = "1.10.0"
version = "1.8.0"
version = "1.8.0"
version = "1.9.0"
version = "1.8.0"
version = "1.9.0"
version = "0.1.13"
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"
dependencies = [
 "unreachable 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)",
]
dependencies = [
 "unreachable 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "nodrop"
dependencies = [
 "unreachable 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)",
]
dependencies = [
 "unreachable 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)",
]
version = "1.0.3"
version = "1.0.3"
version = "1.0.1"
version = "1.0.3"
version = "1.0.1"
version = "1.0.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
]
[[package]]
name = "new_debug_unreachable"
version = "1.0.1"
version = "1.0.3"
version = "1.0.1"
 "cfg-if 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.50 (registry+https://github.com/rust-lang/crates.io-index)",
 "cfg-if 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.7 (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)",
 "winapi 0.3.6 (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.48 (registry+https://github.com/rust-lang/crates.io-index)",
 "cfg-if 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "cfg-if 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "cfg-if 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.43 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.45 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.45 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.47 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.48 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.45 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.45 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.47 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.47 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (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.48 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.49 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.49 (registry+https://github.com/rust-lang/crates.io-index)",
 "tempfile 3.0.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "tempfile 3.0.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "tempfile 3.0.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "tempfile 3.0.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "tempfile 3.0.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "tempfile 3.0.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "tempfile 3.0.6 (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 = [
 "schannel 0.1.14 (registry+https://github.com/rust-lang/crates.io-index)",
 "tempfile 3.0.4 (registry+https://github.com/rust-lang/crates.io-index)",
 "security-framework-sys 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "security-framework-sys 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "security-framework-sys 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "tempfile 3.0.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "security-framework-sys 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "security-framework-sys 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "tempfile 3.0.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "security-framework-sys 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "security-framework-sys 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "security-framework 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "security-framework-sys 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "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)",
 "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)",
 "security-framework 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "security-framework 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "security-framework-sys 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "security-framework 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "security-framework-sys 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "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)",
 "schannel 0.1.15 (registry+https://github.com/rust-lang/crates.io-index)",
 "openssl-sys 0.9.39 (registry+https://github.com/rust-lang/crates.io-index)",
 "openssl-sys 0.9.40 (registry+https://github.com/rust-lang/crates.io-index)",
 "openssl-sys 0.9.39 (registry+https://github.com/rust-lang/crates.io-index)",
 "openssl-sys 0.9.43 (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)",
 "openssl-sys 0.9.40 (registry+https://github.com/rust-lang/crates.io-index)",
 "openssl-sys 0.9.40 (registry+https://github.com/rust-lang/crates.io-index)",
 "openssl-sys 0.9.40 (registry+https://github.com/rust-lang/crates.io-index)",
 "openssl-sys 0.9.43 (registry+https://github.com/rust-lang/crates.io-index)",
 "openssl-sys 0.9.40 (registry+https://github.com/rust-lang/crates.io-index)",
 "openssl-sys 0.9.42 (registry+https://github.com/rust-lang/crates.io-index)",
 "openssl-sys 0.9.40 (registry+https://github.com/rust-lang/crates.io-index)",
 "schannel 0.1.14 (registry+https://github.com/rust-lang/crates.io-index)",
 "openssl-sys 0.9.40 (registry+https://github.com/rust-lang/crates.io-index)",
 "openssl-sys 0.9.40 (registry+https://github.com/rust-lang/crates.io-index)",
 "openssl-sys 0.9.43 (registry+https://github.com/rust-lang/crates.io-index)",
 "schannel 0.1.15 (registry+https://github.com/rust-lang/crates.io-index)",
 "openssl-sys 0.9.39 (registry+https://github.com/rust-lang/crates.io-index)",
 "schannel 0.1.14 (registry+https://github.com/rust-lang/crates.io-index)",
 "security-framework 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "security-framework-sys 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "tempfile 3.0.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "openssl-sys 0.9.39 (registry+https://github.com/rust-lang/crates.io-index)",
 "openssl-sys 0.9.39 (registry+https://github.com/rust-lang/crates.io-index)",
 "openssl-sys 0.9.39 (registry+https://github.com/rust-lang/crates.io-index)",
 "openssl-sys 0.9.40 (registry+https://github.com/rust-lang/crates.io-index)",
 "schannel 0.1.14 (registry+https://github.com/rust-lang/crates.io-index)",
 "openssl-sys 0.9.42 (registry+https://github.com/rust-lang/crates.io-index)",
 "openssl-sys 0.9.39 (registry+https://github.com/rust-lang/crates.io-index)",
 "openssl-sys 0.9.39 (registry+https://github.com/rust-lang/crates.io-index)",
 "openssl-sys 0.9.40 (registry+https://github.com/rust-lang/crates.io-index)",
 "openssl-sys 0.9.39 (registry+https://github.com/rust-lang/crates.io-index)",
 "openssl 0.10.15 (registry+https://github.com/rust-lang/crates.io-index)",
 "lazy_static 1.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "openssl 0.10.20 (registry+https://github.com/rust-lang/crates.io-index)",
 "openssl 0.10.19 (registry+https://github.com/rust-lang/crates.io-index)",
 "openssl 0.10.16 (registry+https://github.com/rust-lang/crates.io-index)",
 "openssl 0.10.20 (registry+https://github.com/rust-lang/crates.io-index)",
 "openssl 0.10.19 (registry+https://github.com/rust-lang/crates.io-index)",
 "openssl 0.10.16 (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.16 (registry+https://github.com/rust-lang/crates.io-index)",
 "openssl 0.10.20 (registry+https://github.com/rust-lang/crates.io-index)",
 "openssl 0.10.15 (registry+https://github.com/rust-lang/crates.io-index)",
 "openssl 0.10.16 (registry+https://github.com/rust-lang/crates.io-index)",
 "openssl 0.10.19 (registry+https://github.com/rust-lang/crates.io-index)",
 "openssl 0.10.15 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.50 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.49 (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.51 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.49 (registry+https://github.com/rust-lang/crates.io-index)",
 "lazy_static 1.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.48 (registry+https://github.com/rust-lang/crates.io-index)",
 "lazy_static 1.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.48 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.47 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (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.51 (registry+https://github.com/rust-lang/crates.io-index)",
 "lazy_static 1.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "lazy_static 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)",
 "openssl 0.10.16 (registry+https://github.com/rust-lang/crates.io-index)",
 "openssl 0.10.15 (registry+https://github.com/rust-lang/crates.io-index)",
 "openssl 0.10.16 (registry+https://github.com/rust-lang/crates.io-index)",
 "openssl 0.10.16 (registry+https://github.com/rust-lang/crates.io-index)",
 "openssl 0.10.16 (registry+https://github.com/rust-lang/crates.io-index)",
 "openssl 0.10.16 (registry+https://github.com/rust-lang/crates.io-index)",
 "openssl 0.10.15 (registry+https://github.com/rust-lang/crates.io-index)",
 "openssl 0.10.15 (registry+https://github.com/rust-lang/crates.io-index)",
 "openssl 0.10.15 (registry+https://github.com/rust-lang/crates.io-index)",
 "openssl 0.10.15 (registry+https://github.com/rust-lang/crates.io-index)",
 "openssl 0.10.16 (registry+https://github.com/rust-lang/crates.io-index)",
 "openssl 0.10.15 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.45 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.45 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.47 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.45 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.45 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.47 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "lazy_static 1.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.48 (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.50 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.49 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.45 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.50 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.50 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.45 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.47 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.48 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.45 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.49 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.48 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.45 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.47 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (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 = [
 "libc 0.2.48 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.49 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.47 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.49 (registry+https://github.com/rust-lang/crates.io-index)",
 "slab 0.4.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "slab 0.4.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "slab 0.4.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "slab 0.4.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "slab 0.4.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "slab 0.4.1 (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)",
 "slab 0.4.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "slab 0.4.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "slab 0.4.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "lazycell 1.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "log 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.50 (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)",
 "libc 0.2.50 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.48 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.49 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.48 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.47 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.48 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.49 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.49 (registry+https://github.com/rust-lang/crates.io-index)",
 "lazycell 1.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "log 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.45 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.45 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.47 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.45 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.45 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.47 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "failure 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "failure_derive 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[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)",
 "failure 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "failure_derive 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "quick-xml 0.13.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "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)",
 "quick-xml 0.13.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "quick-xml 0.13.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "quick-xml 0.13.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "quick-xml 0.13.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "quick-xml 0.13.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "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)",
 "failure 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)",
 "failure_derive 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)",
 "failure 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "failure_derive 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "quick-xml 0.13.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "failure 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "failure_derive 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "quick-xml 0.12.4 (registry+https://github.com/rust-lang/crates.io-index)",
 "failure 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "failure_derive 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "quick-xml 0.12.4 (registry+https://github.com/rust-lang/crates.io-index)",
 "failure 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "failure_derive 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "quick-xml 0.12.4 (registry+https://github.com/rust-lang/crates.io-index)",
 "failure 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "failure_derive 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "quick-xml 0.12.4 (registry+https://github.com/rust-lang/crates.io-index)",
 "failure 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "failure_derive 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "quick-xml 0.13.2 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.10.0"
version = "0.10.0"
version = "0.10.0"
version = "0.10.0"
version = "0.9.1"
version = "0.9.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
version = "0.9.1"
version = "0.9.1"
version = "0.10.0"
dependencies = [
 "cfg-if 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "version_check 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
]
dependencies = [
 "cfg-if 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "version_check 0.1.5 (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_check 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.43 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.45 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.45 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.47 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.48 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.45 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.45 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.47 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "version_check 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "version_check 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.47 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (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.48 (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.48 (registry+https://github.com/rust-lang/crates.io-index)",
]
version = "2.1.2"
version = "2.1.1"
version = "2.2.0"
version = "2.2.0"
version = "2.1.2"
version = "2.1.3"
version = "2.1.3"
version = "2.2.0"
version = "2.1.2"
version = "2.1.3"
version = "2.1.1"
version = "2.1.2"
version = "2.1.3"
version = "2.2.0"
version = "2.1.1"
version = "2.1.1"
version = "2.1.1"
version = "2.1.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
version = "2.1.3"
version = "2.2.0"
version = "2.1.1"
version = "2.1.1"
version = "2.1.3"
version = "2.1.1"
version = "2.1.3"
 "tendril 0.4.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "tendril 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "tendril 0.4.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "tendril 0.4.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "tendril 0.4.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "tendril 0.4.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "tendril 0.4.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "tendril 0.4.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "tendril 0.4.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "tendril 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "tendril 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "tendril 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "tendril 0.4.0 (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"
 "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.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "tendril 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "tendril 0.4.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "tendril 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde_json 1.0.32 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde_json 1.0.33 (registry+https://github.com/rust-lang/crates.io-index)",
 "phf 0.7.24 (registry+https://github.com/rust-lang/crates.io-index)",
 "phf_codegen 0.7.24 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde 1.0.85 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde_derive 1.0.85 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde_json 1.0.36 (registry+https://github.com/rust-lang/crates.io-index)",
 "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_json 1.0.38 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde 1.0.88 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde_derive 1.0.88 (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)",
 "serde 1.0.87 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde_derive 1.0.87 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde 1.0.87 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde_derive 1.0.87 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde_json 1.0.38 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde 1.0.90 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde_derive 1.0.90 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde_json 1.0.39 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde 1.0.87 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde_derive 1.0.87 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde_json 1.0.38 (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)",
 "serde 1.0.87 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde_derive 1.0.87 (registry+https://github.com/rust-lang/crates.io-index)",
 "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_json 1.0.39 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde 1.0.90 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde_derive 1.0.90 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde 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)",
 "phf 0.7.24 (registry+https://github.com/rust-lang/crates.io-index)",
 "phf_codegen 0.7.24 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde 1.0.85 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde_derive 1.0.85 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde_json 1.0.36 (registry+https://github.com/rust-lang/crates.io-index)",
 "phf 0.7.23 (registry+https://github.com/rust-lang/crates.io-index)",
 "phf_codegen 0.7.23 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde 1.0.80 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde_derive 1.0.80 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde_json 1.0.33 (registry+https://github.com/rust-lang/crates.io-index)",
 "phf 0.7.23 (registry+https://github.com/rust-lang/crates.io-index)",
 "phf_codegen 0.7.23 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde_json 1.0.34 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde_json 1.0.33 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde 1.0.83 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde_derive 1.0.83 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde 1.0.80 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde_derive 1.0.80 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde 1.0.82 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde_derive 1.0.82 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde 1.0.83 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde_derive 1.0.83 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde 1.0.83 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde_derive 1.0.83 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde 1.0.80 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde_derive 1.0.80 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde 1.0.80 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde_derive 1.0.80 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde 1.0.80 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde_derive 1.0.80 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde 1.0.80 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde_derive 1.0.80 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde_json 1.0.33 (registry+https://github.com/rust-lang/crates.io-index)",
 "phf 0.7.23 (registry+https://github.com/rust-lang/crates.io-index)",
 "phf_codegen 0.7.23 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde 1.0.80 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde_derive 1.0.80 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde_json 1.0.33 (registry+https://github.com/rust-lang/crates.io-index)",
 "phf 0.7.23 (registry+https://github.com/rust-lang/crates.io-index)",
 "phf_codegen 0.7.23 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde 1.0.80 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde_derive 1.0.80 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde_json 1.0.33 (registry+https://github.com/rust-lang/crates.io-index)",
 "phf 0.7.24 (registry+https://github.com/rust-lang/crates.io-index)",
 "phf_codegen 0.7.24 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde 1.0.85 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde_derive 1.0.85 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde_json 1.0.36 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.7.5"
version = "0.7.3"
version = "0.7.5"
version = "0.7.5"
version = "0.7.5"
version = "0.7.5"
version = "0.7.5"
version = "0.7.5"
version = "0.7.5"
version = "0.7.3"
version = "0.7.3"
version = "0.7.3"
version = "0.7.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
version = "0.7.3"
version = "0.7.3"
version = "0.7.5"
version = "0.7.3"
 "linked-hash-map 0.5.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "linked-hash-map 0.4.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "linked-hash-map 0.4.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "linked-hash-map 0.5.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "linked-hash-map 0.4.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "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.1.2"
version = "0.1.1"
version = "0.1.1"
version = "0.1.2"
version = "0.1.1"
version = "0.1.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "cfg-if 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "cfg-if 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "cfg-if 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "cfg-if 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "cfg-if 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "cfg-if 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "cfg-if 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "lru-cache"
 "cfg-if 0.1.6 (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 = [
version = "0.3.9"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "log 0.4.5 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.4.6"
 "owning_ref 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "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)",
version = "0.1.5"
version = "0.1.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
version = "0.5.2"
version = "0.4.2"
version = "0.4.2"
version = "0.5.2"
version = "0.4.2"
version = "0.4.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
name = "lock_api"
version = "0.2.45"
version = "0.2.44"
version = "0.2.50"
version = "0.2.50"
version = "0.2.45"
version = "0.2.47"
version = "0.2.48"
version = "0.2.51"
version = "0.2.45"
version = "0.2.49"
version = "0.2.48"
version = "0.2.44"
version = "0.2.45"
version = "0.2.47"
version = "0.2.51"
version = "0.2.44"
version = "0.2.44"
version = "0.2.44"
version = "0.2.44"
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
name = "linked-hash-map"
version = "0.2.48"
version = "0.2.49"
version = "0.2.44"
version = "0.2.44"
version = "0.2.47"
version = "0.2.44"
version = "0.2.49"
version = "1.2.1"
version = "1.2.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
name = "libc"
version = "1.3.0"
version = "1.3.0"
version = "1.2.0"
version = "1.2.0"
version = "1.3.0"
version = "1.2.0"
version = "1.2.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
name = "lazycell"
version = "1.2.0"
version = "1.3.0"
 "failure 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "failure_derive 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[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"
 "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)",
 "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)",
 "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)",
 "failure 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)",
 "failure_derive 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)",
 "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)",
 "failure 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "failure_derive 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "minidom 0.9.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "failure 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "failure_derive 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "minidom 0.9.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "failure 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "failure_derive 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "minidom 0.9.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "failure 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "failure_derive 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "minidom 0.9.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "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)",
version = "0.5.3"
version = "0.5.3"
version = "0.5.3"
version = "0.5.3"
version = "0.5.2"
version = "0.5.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
version = "0.5.2"
version = "0.5.2"
version = "0.5.3"
 "winapi 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.6 (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.1.9"
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)",
 "libc 0.2.45 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.50 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.50 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.45 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.47 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.48 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.45 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.49 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.48 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.45 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.47 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (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"
 "libc 0.2.48 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.49 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.47 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.49 (registry+https://github.com/rust-lang/crates.io-index)",
 "unicode-normalization 0.1.8 (registry+https://github.com/rust-lang/crates.io-index)",
 "unicode-normalization 0.1.7 (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 = [
 "unicode-normalization 0.1.7 (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)",
 "tokio-threadpool 0.1.8 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-timer 0.2.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-threadpool 0.1.9 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-reactor 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-reactor 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio 0.1.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio 0.1.13 (registry+https://github.com/rust-lang/crates.io-index)",
 "time 0.1.41 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-timer 0.2.8 (registry+https://github.com/rust-lang/crates.io-index)",
 "time 0.1.40 (registry+https://github.com/rust-lang/crates.io-index)",
 "rustc_version 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio 0.1.17 (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-threadpool 0.1.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-threadpool 0.1.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-timer 0.2.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-threadpool 0.1.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-threadpool 0.1.13 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-threadpool 0.1.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-threadpool 0.1.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-reactor 0.1.8 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-tcp 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-reactor 0.1.8 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-reactor 0.1.8 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-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 0.1.16 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio 0.1.15 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-executor 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio 0.1.15 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio 0.1.18 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-executor 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-reactor 0.1.9 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio 0.1.15 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio 0.1.16 (registry+https://github.com/rust-lang/crates.io-index)",
 "time 0.1.41 (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.14 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-executor 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-reactor 0.1.8 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-tcp 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-threadpool 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "time 0.1.42 (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-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-threadpool 0.1.13 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-threadpool 0.1.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio 0.1.18 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-executor 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio 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)",
 "time 0.1.41 (registry+https://github.com/rust-lang/crates.io-index)",
 "time 0.1.41 (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.14 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-executor 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-reactor 0.1.8 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-tcp 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-threadpool 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "rustc_version 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "time 0.1.40 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio 0.1.13 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-executor 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-reactor 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-tcp 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-threadpool 0.1.9 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-timer 0.2.8 (registry+https://github.com/rust-lang/crates.io-index)",
 "time 0.1.40 (registry+https://github.com/rust-lang/crates.io-index)",
 "time 0.1.40 (registry+https://github.com/rust-lang/crates.io-index)",
 "time 0.1.40 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio 0.1.13 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-executor 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-reactor 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-tcp 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-threadpool 0.1.9 (registry+https://github.com/rust-lang/crates.io-index)",
 "rustc_version 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "time 0.1.40 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio 0.1.13 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-executor 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-reactor 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-tcp 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-threadpool 0.1.9 (registry+https://github.com/rust-lang/crates.io-index)",
 "time 0.1.40 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio 0.1.13 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-executor 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-reactor 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-tcp 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-threadpool 0.1.9 (registry+https://github.com/rust-lang/crates.io-index)",
 "time 0.1.42 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio 0.1.14 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-executor 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-reactor 0.1.8 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-tcp 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-threadpool 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "time 0.1.40 (registry+https://github.com/rust-lang/crates.io-index)",
 "log 0.4.6 (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)",
 "h2 0.1.17 (registry+https://github.com/rust-lang/crates.io-index)",
 "httparse 1.3.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "iovec 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "itoa 0.4.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "h2 0.1.15 (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)",
 "http 0.1.15 (registry+https://github.com/rust-lang/crates.io-index)",
 "http 0.1.15 (registry+https://github.com/rust-lang/crates.io-index)",
 "http 0.1.16 (registry+https://github.com/rust-lang/crates.io-index)",
 "h2 0.1.18 (registry+https://github.com/rust-lang/crates.io-index)",
 "http 0.1.17 (registry+https://github.com/rust-lang/crates.io-index)",
 "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)",
 "h2 0.1.16 (registry+https://github.com/rust-lang/crates.io-index)",
 "http 0.1.15 (registry+https://github.com/rust-lang/crates.io-index)",
 "h2 0.1.14 (registry+https://github.com/rust-lang/crates.io-index)",
 "http 0.1.14 (registry+https://github.com/rust-lang/crates.io-index)",
 "h2 0.1.15 (registry+https://github.com/rust-lang/crates.io-index)",
 "h2 0.1.18 (registry+https://github.com/rust-lang/crates.io-index)",
 "http 0.1.17 (registry+https://github.com/rust-lang/crates.io-index)",
 "h2 0.1.14 (registry+https://github.com/rust-lang/crates.io-index)",
 "http 0.1.14 (registry+https://github.com/rust-lang/crates.io-index)",
 "h2 0.1.14 (registry+https://github.com/rust-lang/crates.io-index)",
 "http 0.1.14 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures-cpupool 0.1.8 (registry+https://github.com/rust-lang/crates.io-index)",
 "h2 0.1.14 (registry+https://github.com/rust-lang/crates.io-index)",
 "h2 0.1.14 (registry+https://github.com/rust-lang/crates.io-index)",
 "h2 0.1.15 (registry+https://github.com/rust-lang/crates.io-index)",
 "bytes 0.4.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "bytes 0.4.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "bytes 0.4.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",
 "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)",
 "bytes 0.4.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "bytes 0.4.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "bytes 0.4.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",
 "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)",
 "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)",
 "bytes 0.4.11 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.12.19"
version = "0.12.17"
version = "0.12.24"
version = "0.12.25"
version = "0.12.18"
version = "0.12.21"
version = "0.12.23"
version = "0.12.27"
version = "0.12.19"
version = "0.12.25"
version = "0.12.23"
version = "0.12.17"
version = "0.12.19"
version = "0.12.21"
version = "0.12.27"
version = "0.12.17"
version = "0.12.17"
version = "0.12.17"
version = "0.12.17"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
version = "0.12.23"
version = "0.12.25"
version = "0.12.17"
version = "0.12.17"
version = "0.12.21"
version = "0.12.17"
version = "0.12.23"
name = "hyper"
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
 "bytes 0.4.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "bytes 0.4.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "bytes 0.4.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "bytes 0.4.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "bytes 0.4.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "bytes 0.4.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "bytes 0.4.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "bytes 0.4.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "bytes 0.4.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "bytes 0.4.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "bytes 0.4.11 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.1.13"
version = "0.1.16"
version = "0.1.15"
version = "0.1.17"
version = "0.1.16"
version = "0.1.15"
version = "0.1.14"
version = "0.1.17"
version = "0.1.14"
version = "0.1.14"
version = "0.1.15"
version = "0.1.16"
 "libc 0.2.43 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.45 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.50 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.50 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.45 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.47 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.48 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.45 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.49 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.48 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.45 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.47 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.48 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.49 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.47 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.49 (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)",
 "tokio-io 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "string 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "slab 0.4.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "log 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.12 (registry+https://github.com/rust-lang/crates.io-index)",
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)",
 "tokio-io 0.1.11 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "hmac"
version = "0.7.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "crypto-mac 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "digest 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.11 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
 "tokio-io 0.1.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.12 (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)",
 "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)",
 "slab 0.4.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "string 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "slab 0.4.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "string 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "slab 0.4.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "string 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "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.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "slab 0.4.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "string 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "slab 0.4.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "string 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "slab 0.4.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "string 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.11 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "hmac"
version = "0.7.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "crypto-mac 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "digest 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "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)",
 "futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",
 "http 0.1.17 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.25 (registry+https://github.com/rust-lang/crates.io-index)",
 "http 0.1.14 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.25 (registry+https://github.com/rust-lang/crates.io-index)",
 "indexmap 1.0.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "http 0.1.13 (registry+https://github.com/rust-lang/crates.io-index)",
 "http 0.1.16 (registry+https://github.com/rust-lang/crates.io-index)",
 "http 0.1.15 (registry+https://github.com/rust-lang/crates.io-index)",
 "http 0.1.15 (registry+https://github.com/rust-lang/crates.io-index)",
 "http 0.1.14 (registry+https://github.com/rust-lang/crates.io-index)",
 "http 0.1.14 (registry+https://github.com/rust-lang/crates.io-index)",
 "http 0.1.15 (registry+https://github.com/rust-lang/crates.io-index)",
 "http 0.1.16 (registry+https://github.com/rust-lang/crates.io-index)",
 "fnv 1.0.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "bytes 0.4.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "bytes 0.4.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "byteorder 1.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "byteorder 1.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "bytes 0.4.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "bytes 0.4.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "bytes 0.4.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "bytes 0.4.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "bytes 0.4.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "byteorder 1.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "bytes 0.4.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "bytes 0.4.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "byteorder 1.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "byteorder 1.2.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "bytes 0.4.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "byteorder 1.2.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "bytes 0.4.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "byteorder 1.2.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "byteorder 1.2.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "byteorder 1.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.1.17"
version = "0.1.15"
version = "0.1.16"
version = "0.1.18"
version = "0.1.16"
version = "0.1.16"
version = "0.1.14"
version = "0.1.15"
version = "0.1.18"
version = "0.1.14"
version = "0.1.14"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
version = "0.1.14"
version = "0.1.14"
version = "0.1.15"
version = "0.12.0"
version = "0.12.0"
version = "0.12.0"
version = "0.12.0"
version = "0.9.0"
version = "0.9.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"
]
[[package]]
name = "generic-array"
version = "0.9.0"
version = "0.9.0"
version = "0.12.0"
 "num_cpus 1.10.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.25 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",
 "num_cpus 1.10.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.25 (registry+https://github.com/rust-lang/crates.io-index)",
 "num_cpus 1.8.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.25 (registry+https://github.com/rust-lang/crates.io-index)",
 "num_cpus 1.8.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "num_cpus 1.9.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "num_cpus 1.8.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "num_cpus 1.10.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "num_cpus 1.10.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "num_cpus 1.9.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "num_cpus 1.9.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "num_cpus 1.9.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "num_cpus 1.9.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "num_cpus 1.9.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "num_cpus 1.9.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "num_cpus 1.9.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "num_cpus 1.8.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "num_cpus 1.8.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "num_cpus 1.8.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "num_cpus 1.9.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "num_cpus 1.10.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "num_cpus 1.8.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "num_cpus 1.8.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "num_cpus 1.9.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "num_cpus 1.8.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "num_cpus 1.9.0 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.1.25"
version = "0.1.26"
version = "0.1.25"
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 = [
 "new_debug_unreachable 1.0.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "new_debug_unreachable 1.0.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "new_debug_unreachable 1.0.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)",
 "new_debug_unreachable 1.0.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "new_debug_unreachable 1.0.1 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "futures"
 "new_debug_unreachable 1.0.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)",
 "new_debug_unreachable 1.0.1 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.1.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
name = "fuchsia-cprng"
 "proc-macro2 0.4.26 (registry+https://github.com/rust-lang/crates.io-index)",
 "quote 0.6.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "syn 0.15.26 (registry+https://github.com/rust-lang/crates.io-index)",
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)",
]
[[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"
 "proc-macro2 0.4.27 (registry+https://github.com/rust-lang/crates.io-index)",
 "syn 0.15.29 (registry+https://github.com/rust-lang/crates.io-index)",
 "syn 0.15.28 (registry+https://github.com/rust-lang/crates.io-index)",
 "syn 0.15.26 (registry+https://github.com/rust-lang/crates.io-index)",
 "syn 0.15.26 (registry+https://github.com/rust-lang/crates.io-index)",
 "synstructure 0.10.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "syn 0.15.26 (registry+https://github.com/rust-lang/crates.io-index)",
 "syn 0.15.27 (registry+https://github.com/rust-lang/crates.io-index)",
 "syn 0.15.27 (registry+https://github.com/rust-lang/crates.io-index)",
 "quote 0.6.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "quote 0.6.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "syn 0.15.30 (registry+https://github.com/rust-lang/crates.io-index)",
 "proc-macro2 0.4.27 (registry+https://github.com/rust-lang/crates.io-index)",
 "quote 0.6.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "syn 0.15.30 (registry+https://github.com/rust-lang/crates.io-index)",
 "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)",
 "proc-macro2 0.4.24 (registry+https://github.com/rust-lang/crates.io-index)",
 "quote 0.6.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "syn 0.15.22 (registry+https://github.com/rust-lang/crates.io-index)",
 "proc-macro2 0.4.26 (registry+https://github.com/rust-lang/crates.io-index)",
 "quote 0.6.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "syn 0.15.26 (registry+https://github.com/rust-lang/crates.io-index)",
 "proc-macro2 0.4.24 (registry+https://github.com/rust-lang/crates.io-index)",
 "quote 0.6.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "syn 0.15.22 (registry+https://github.com/rust-lang/crates.io-index)",
 "proc-macro2 0.4.24 (registry+https://github.com/rust-lang/crates.io-index)",
 "quote 0.6.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "synstructure 0.10.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "syn 0.15.23 (registry+https://github.com/rust-lang/crates.io-index)",
 "syn 0.15.22 (registry+https://github.com/rust-lang/crates.io-index)",
 "syn 0.15.23 (registry+https://github.com/rust-lang/crates.io-index)",
 "syn 0.15.23 (registry+https://github.com/rust-lang/crates.io-index)",
 "syn 0.15.23 (registry+https://github.com/rust-lang/crates.io-index)",
 "syn 0.15.22 (registry+https://github.com/rust-lang/crates.io-index)",
 "syn 0.15.22 (registry+https://github.com/rust-lang/crates.io-index)",
 "syn 0.15.22 (registry+https://github.com/rust-lang/crates.io-index)",
 "syn 0.15.22 (registry+https://github.com/rust-lang/crates.io-index)",
 "proc-macro2 0.4.24 (registry+https://github.com/rust-lang/crates.io-index)",
 "quote 0.6.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "syn 0.15.22 (registry+https://github.com/rust-lang/crates.io-index)",
 "proc-macro2 0.4.24 (registry+https://github.com/rust-lang/crates.io-index)",
 "quote 0.6.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "syn 0.15.22 (registry+https://github.com/rust-lang/crates.io-index)",
 "proc-macro2 0.4.26 (registry+https://github.com/rust-lang/crates.io-index)",
 "quote 0.6.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "syn 0.15.26 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.1.3"
version = "0.1.5"
version = "0.1.5"
version = "0.1.5"
version = "0.1.4"
version = "0.1.5"
version = "0.1.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
version = "0.1.3"
version = "0.1.3"
version = "0.1.3"
version = "0.1.5"
 "failure_derive 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)",
]
[[package]]
name = "failure_derive"
 "failure_derive 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "backtrace 0.3.9 (registry+https://github.com/rust-lang/crates.io-index)",
 "failure_derive 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "backtrace 0.3.13 (registry+https://github.com/rust-lang/crates.io-index)",
 "backtrace 0.3.9 (registry+https://github.com/rust-lang/crates.io-index)",
 "backtrace 0.3.14 (registry+https://github.com/rust-lang/crates.io-index)",
 "backtrace 0.3.13 (registry+https://github.com/rust-lang/crates.io-index)",
 "backtrace 0.3.13 (registry+https://github.com/rust-lang/crates.io-index)",
 "failure_derive 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "backtrace 0.3.13 (registry+https://github.com/rust-lang/crates.io-index)",
 "backtrace 0.3.15 (registry+https://github.com/rust-lang/crates.io-index)",
 "backtrace 0.3.13 (registry+https://github.com/rust-lang/crates.io-index)",
 "backtrace 0.3.14 (registry+https://github.com/rust-lang/crates.io-index)",
 "backtrace 0.3.13 (registry+https://github.com/rust-lang/crates.io-index)",
 "backtrace 0.3.13 (registry+https://github.com/rust-lang/crates.io-index)",
 "failure_derive 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)",
 "backtrace 0.3.13 (registry+https://github.com/rust-lang/crates.io-index)",
 "failure_derive 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "backtrace 0.3.15 (registry+https://github.com/rust-lang/crates.io-index)",
 "backtrace 0.3.9 (registry+https://github.com/rust-lang/crates.io-index)",
 "failure_derive 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "backtrace 0.3.9 (registry+https://github.com/rust-lang/crates.io-index)",
 "backtrace 0.3.9 (registry+https://github.com/rust-lang/crates.io-index)",
 "backtrace 0.3.9 (registry+https://github.com/rust-lang/crates.io-index)",
 "backtrace 0.3.13 (registry+https://github.com/rust-lang/crates.io-index)",
 "backtrace 0.3.14 (registry+https://github.com/rust-lang/crates.io-index)",
 "backtrace 0.3.9 (registry+https://github.com/rust-lang/crates.io-index)",
 "failure_derive 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "backtrace 0.3.9 (registry+https://github.com/rust-lang/crates.io-index)",
 "failure_derive 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "backtrace 0.3.13 (registry+https://github.com/rust-lang/crates.io-index)",
 "failure_derive 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "backtrace 0.3.9 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.1.3"
version = "0.1.3"
version = "0.1.5"
version = "0.1.5"
version = "0.1.5"
version = "0.1.4"
version = "0.1.5"
version = "0.1.3"
version = "0.1.3"
version = "0.1.3"
version = "0.1.3"
version = "0.1.5"
 "backtrace 0.3.9 (registry+https://github.com/rust-lang/crates.io-index)",
 "backtrace 0.3.13 (registry+https://github.com/rust-lang/crates.io-index)",
 "backtrace 0.3.9 (registry+https://github.com/rust-lang/crates.io-index)",
 "backtrace 0.3.14 (registry+https://github.com/rust-lang/crates.io-index)",
 "backtrace 0.3.13 (registry+https://github.com/rust-lang/crates.io-index)",
 "backtrace 0.3.13 (registry+https://github.com/rust-lang/crates.io-index)",
 "backtrace 0.3.13 (registry+https://github.com/rust-lang/crates.io-index)",
 "backtrace 0.3.15 (registry+https://github.com/rust-lang/crates.io-index)",
 "backtrace 0.3.13 (registry+https://github.com/rust-lang/crates.io-index)",
 "backtrace 0.3.14 (registry+https://github.com/rust-lang/crates.io-index)",
 "backtrace 0.3.13 (registry+https://github.com/rust-lang/crates.io-index)",
 "backtrace 0.3.13 (registry+https://github.com/rust-lang/crates.io-index)",
 "backtrace 0.3.13 (registry+https://github.com/rust-lang/crates.io-index)",
 "backtrace 0.3.15 (registry+https://github.com/rust-lang/crates.io-index)",
 "backtrace 0.3.9 (registry+https://github.com/rust-lang/crates.io-index)",
 "backtrace 0.3.9 (registry+https://github.com/rust-lang/crates.io-index)",
 "backtrace 0.3.9 (registry+https://github.com/rust-lang/crates.io-index)",
 "backtrace 0.3.9 (registry+https://github.com/rust-lang/crates.io-index)",
 "backtrace 0.3.13 (registry+https://github.com/rust-lang/crates.io-index)",
 "backtrace 0.3.14 (registry+https://github.com/rust-lang/crates.io-index)",
 "backtrace 0.3.9 (registry+https://github.com/rust-lang/crates.io-index)",
 "backtrace 0.3.9 (registry+https://github.com/rust-lang/crates.io-index)",
 "backtrace 0.3.13 (registry+https://github.com/rust-lang/crates.io-index)",
 "backtrace 0.3.9 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.1.12"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "backtrace 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "error-chain"
]
[[package]]
name = "error-chain"
 "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)",
 "termcolor 1.0.4 (registry+https://github.com/rust-lang/crates.io-index)",
 "regex 1.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "regex 1.0.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "regex 1.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "regex 1.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "regex 1.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "regex 1.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "regex 1.0.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "regex 1.0.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "regex 1.0.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "regex 1.0.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "regex 1.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "regex 1.0.6 (registry+https://github.com/rust-lang/crates.io-index)",
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
version = "0.1.12"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "backtrace 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "error-chain"
version = "0.1.12"
version = "0.1.12"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "backtrace 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "error-chain"
version = "0.1.12"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "backtrace 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "error-chain"
name = "env_logger"
version = "0.6.0"
 "regex 1.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
 "regex 1.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "regex 1.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "regex 1.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "regex 1.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "regex 1.0.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "regex 1.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "regex 1.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "regex 1.0.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "regex 1.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "regex 1.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "regex 1.0.6 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.6.1"
version = "0.6.1"
version = "0.6.1"
version = "0.6.0"
version = "0.6.0"
version = "0.6.0"
version = "0.6.1"
version = "0.6.0"
version = "0.6.0"
 "cfg-if 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "cfg-if 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "cfg-if 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "cfg-if 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "cfg-if 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "cfg-if 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "cfg-if 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "cfg-if 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "cfg-if 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.8.10"
version = "0.8.13"
version = "0.8.12"
version = "0.8.16"
version = "0.8.17"
version = "0.8.13"
version = "0.8.14"
version = "0.8.15"
version = "0.8.17"
version = "0.8.13"
version = "0.8.15"
version = "0.8.12"
version = "0.8.13"
version = "0.8.14"
version = "0.8.17"
version = "0.8.12"
version = "0.8.12"
version = "0.8.12"
version = "0.8.12"
version = "0.8.15"
version = "0.8.17"
version = "0.8.12"
version = "0.8.12"
version = "0.8.14"
version = "0.8.12"
version = "0.8.15"
 "generic-array 0.9.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "generic-array 0.12.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "generic-array 0.12.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "generic-array 0.12.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "generic-array 0.12.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "generic-array 0.9.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "generic-array 0.9.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "generic-array 0.9.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "generic-array 0.9.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "generic-array 0.12.0 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.7.6"
version = "0.8.0"
version = "0.8.0"
version = "0.8.0"
version = "0.8.0"
version = "0.7.6"
version = "0.7.6"
version = "0.7.6"
version = "0.7.6"
version = "0.8.0"
name = "dbghelp-sys"
version = "0.2.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "winapi 0.2.8 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi-build 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
 "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)",
 "constant_time_eq 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "generic-array 0.9.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "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)",
name = "dbghelp-sys"
version = "0.2.0"
 "constant_time_eq 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "generic-array 0.9.0 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
 "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)",
 "constant_time_eq 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "generic-array 0.9.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "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)",
name = "crypto-mac"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
version = "0.7.0"
version = "0.5.2"
version = "0.5.2"
version = "0.7.0"
]
[[package]]
 "cfg-if 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "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)",
 "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)",
 "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)",
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "constant_time_eq 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "generic-array 0.9.0 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
version = "0.5.2"
version = "0.7.0"
version = "0.7.0"
version = "0.5.2"
[[package]]
name = "crypto-mac"
version = "0.7.0"
]
name = "dbghelp-sys"
version = "0.2.0"
 "cfg-if 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "lazy_static 1.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "cfg-if 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "lazy_static 1.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "cfg-if 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "cfg-if 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "lazy_static 1.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "cfg-if 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "lazy_static 1.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
dependencies = [
 "lazy_static 1.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "lazy_static 1.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "cfg-if 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "lazy_static 1.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "constant_time_eq 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "generic-array 0.9.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "cfg-if 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
source = "registry+https://github.com/rust-lang/crates.io-index"
version = "0.6.3"
version = "0.6.1"
version = "0.6.3"
version = "0.6.3"
version = "0.6.5"
name = "crossbeam-utils"
version = "0.6.5"
version = "0.6.3"
version = "0.6.1"
version = "0.6.3"
version = "0.6.3"
name = "crypto-mac"
version = "0.5.2"
version = "0.6.1"
version = "0.6.1"
version = "0.6.1"
version = "0.6.1"
version = "0.6.1"
version = "0.6.3"
version = "0.6.1"
 "crossbeam-utils 0.6.5 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
 "cfg-if 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
name = "crossbeam-queue"
version = "0.1.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
name = "crossbeam-utils"
version = "0.6.1"
name = "crossbeam-utils"
version = "0.7.1"
 "arrayvec 0.4.10 (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)",
]
[[package]]
 "cfg-if 0.1.7 (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)",
 "cfg-if 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "arrayvec 0.4.10 (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.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "lazy_static 1.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "cfg-if 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "cfg-if 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "arrayvec 0.4.8 (registry+https://github.com/rust-lang/crates.io-index)",
 "cfg-if 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "crossbeam-utils 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "lazy_static 1.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.7.1"
name = "crossbeam-epoch"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
version = "0.6.1"
name = "crossbeam-queue"
version = "0.1.2"
 "crossbeam-utils 0.6.3 (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)",
 "crossbeam-utils 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "cfg-if 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "lazy_static 1.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "lazy_static 1.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "lazy_static 1.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "cfg-if 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "crossbeam-utils 0.6.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "crossbeam-utils 0.6.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "crossbeam-utils 0.6.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "crossbeam-utils 0.6.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "crossbeam-utils 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "lazy_static 1.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "crossbeam-utils 0.6.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "crossbeam-utils 0.6.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "crossbeam-utils 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "crossbeam-utils 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "crossbeam-utils 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "lazy_static 1.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "cfg-if 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
 "crossbeam-utils 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "crossbeam-utils 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "crossbeam-utils 0.6.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "crossbeam-utils 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "cfg-if 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "arrayvec 0.4.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "arrayvec 0.4.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "arrayvec 0.4.8 (registry+https://github.com/rust-lang/crates.io-index)",
 "arrayvec 0.4.9 (registry+https://github.com/rust-lang/crates.io-index)",
 "arrayvec 0.4.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "arrayvec 0.4.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "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)",
 "arrayvec 0.4.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "crossbeam-epoch 0.7.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "arrayvec 0.4.8 (registry+https://github.com/rust-lang/crates.io-index)",
 "arrayvec 0.4.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "arrayvec 0.4.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "crossbeam-epoch 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "crossbeam-utils 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "arrayvec 0.4.8 (registry+https://github.com/rust-lang/crates.io-index)",
 "arrayvec 0.4.8 (registry+https://github.com/rust-lang/crates.io-index)",
 "arrayvec 0.4.8 (registry+https://github.com/rust-lang/crates.io-index)",
 "arrayvec 0.4.8 (registry+https://github.com/rust-lang/crates.io-index)",
 "arrayvec 0.4.8 (registry+https://github.com/rust-lang/crates.io-index)",
 "arrayvec 0.4.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "arrayvec 0.4.8 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.7.1"
version = "0.6.3"
version = "0.7.1"
version = "0.6.2"
name = "crossbeam-epoch"
version = "0.5.2"
version = "0.7.0"
version = "0.6.1"
version = "0.7.0"
version = "0.7.0"
version = "0.7.1"
version = "0.7.0"
version = "0.6.1"
version = "0.7.0"
version = "0.7.0"
version = "0.6.1"
version = "0.6.1"
version = "0.6.1"
version = "0.6.1"
version = "0.6.1"
version = "0.7.0"
version = "0.6.1"
 "crossbeam-epoch 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "crossbeam-utils 0.6.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "crossbeam-epoch 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "crossbeam-utils 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "crossbeam-epoch 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "crossbeam-utils 0.6.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "crossbeam-epoch 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "crossbeam-utils 0.6.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "crossbeam-epoch 0.7.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "smallvec 0.6.8 (registry+https://github.com/rust-lang/crates.io-index)",
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
]
[[package]]
 "libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.49 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "crossbeam-utils 0.6.5 (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.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "num_cpus 1.9.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "parking_lot 0.7.1 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "crossbeam-channel"
version = "0.3.8"
 "crossbeam-epoch 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "crossbeam-utils 0.6.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "cfg-if 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "crossbeam-channel 0.3.8 (registry+https://github.com/rust-lang/crates.io-index)",
 "crossbeam-deque 0.6.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "crossbeam-epoch 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "crossbeam-utils 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "crossbeam-epoch 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "crossbeam-utils 0.6.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "crossbeam-epoch 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "crossbeam-utils 0.6.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "crossbeam-epoch 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "crossbeam-utils 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "crossbeam-epoch 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "crossbeam-utils 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "crossbeam-epoch 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "crossbeam-utils 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "crossbeam-epoch 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "crossbeam-utils 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "crossbeam-epoch 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "crossbeam-utils 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "crossbeam-epoch 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "crossbeam-utils 0.6.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "crossbeam-epoch 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "crossbeam-utils 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.6.3"
version = "0.6.2"
version = "0.7.1"
version = "0.6.3"
version = "0.6.3"
version = "0.6.3"
version = "0.6.3"
version = "0.6.2"
version = "0.6.3"
version = "0.6.3"
version = "0.6.2"
version = "0.6.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
version = "0.6.2"
name = "crossbeam-deque"
version = "0.6.3"
version = "0.7.1"
version = "0.6.2"
version = "0.6.2"
version = "0.6.3"
version = "0.6.2"
 "crossbeam-utils 0.6.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "parking_lot 0.7.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand 0.6.4 (registry+https://github.com/rust-lang/crates.io-index)",
 "smallvec 0.6.8 (registry+https://github.com/rust-lang/crates.io-index)",
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "libc 0.2.50 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
 "smallvec 0.6.9 (registry+https://github.com/rust-lang/crates.io-index)",
 "num_cpus 1.10.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "smallvec 0.6.8 (registry+https://github.com/rust-lang/crates.io-index)",
 "parking_lot 0.7.1 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "crossbeam-channel"
version = "0.3.8"
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)",
 "num_cpus 1.9.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "smallvec 0.6.8 (registry+https://github.com/rust-lang/crates.io-index)",
 "num_cpus 1.9.0 (registry+https://github.com/rust-lang/crates.io-index)",
name = "crossbeam"
version = "0.6.0"
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)",
 "crossbeam-channel 0.3.8 (registry+https://github.com/rust-lang/crates.io-index)",
 "crossbeam-deque 0.6.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "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)",
 "lazy_static 1.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
name = "crossbeam"
version = "0.6.0"
name = "crossbeam"
version = "0.6.0"
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)",
 "crossbeam-channel 0.3.8 (registry+https://github.com/rust-lang/crates.io-index)",
 "crossbeam-deque 0.6.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "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)",
 "lazy_static 1.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "num_cpus 1.9.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "parking_lot 0.7.1 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "crossbeam-channel"
version = "0.3.8"
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)",
 "smallvec 0.6.8 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.50 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.48 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.48 (registry+https://github.com/rust-lang/crates.io-index)",
 "crossbeam-utils 0.6.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "parking_lot 0.7.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand 0.6.4 (registry+https://github.com/rust-lang/crates.io-index)",
 "smallvec 0.6.8 (registry+https://github.com/rust-lang/crates.io-index)",
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
]
[[package]]
 "libc 0.2.48 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.49 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
 "libc 0.2.49 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.47 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "crossbeam-channel"
version = "0.3.6"
]
[[package]]
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.47 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.45 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.45 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.47 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "crossbeam-channel"
version = "0.3.6"
 "libc 0.2.45 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.45 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.45 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.50 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.50 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.45 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.47 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.48 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.45 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.49 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.48 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.45 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.47 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "core-foundation-sys"
version = "0.5.1"
 "libc 0.2.48 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.49 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.47 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.49 (registry+https://github.com/rust-lang/crates.io-index)",
[[package]]
name = "constant_time_eq"
version = "0.1.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
name = "constant_time_eq"
version = "0.1.3"
source = "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)",
[[package]]
name = "constant_time_eq"
version = "0.1.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
name = "constant_time_eq"
version = "0.1.3"
source = "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)",
 "strsim 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "textwrap 0.11.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "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)",
 "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)",
]
version = "2.32.0"
version = "2.33.0"
version = "2.32.0"
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)",
 "time 0.1.41 (registry+https://github.com/rust-lang/crates.io-index)",
 "time 0.1.40 (registry+https://github.com/rust-lang/crates.io-index)",
 "time 0.1.41 (registry+https://github.com/rust-lang/crates.io-index)",
 "time 0.1.42 (registry+https://github.com/rust-lang/crates.io-index)",
 "time 0.1.42 (registry+https://github.com/rust-lang/crates.io-index)",
 "time 0.1.42 (registry+https://github.com/rust-lang/crates.io-index)",
 "time 0.1.41 (registry+https://github.com/rust-lang/crates.io-index)",
 "time 0.1.41 (registry+https://github.com/rust-lang/crates.io-index)",
 "time 0.1.42 (registry+https://github.com/rust-lang/crates.io-index)",
 "time 0.1.40 (registry+https://github.com/rust-lang/crates.io-index)",
 "time 0.1.40 (registry+https://github.com/rust-lang/crates.io-index)",
 "time 0.1.40 (registry+https://github.com/rust-lang/crates.io-index)",
 "time 0.1.40 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "clap"
 "time 0.1.40 (registry+https://github.com/rust-lang/crates.io-index)",
 "time 0.1.40 (registry+https://github.com/rust-lang/crates.io-index)",
 "time 0.1.42 (registry+https://github.com/rust-lang/crates.io-index)",
 "time 0.1.40 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.1.7"
version = "0.1.7"
version = "0.1.6"
version = "0.1.6"
version = "0.1.7"
version = "0.1.6"
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)",
version = "0.1.6"
version = "1.0.28"
version = "1.0.25"
version = "1.0.31"
version = "1.0.30"
version = "1.0.26"
version = "1.0.28"
version = "1.0.29"
version = "1.0.35"
version = "1.0.28"
version = "1.0.30"
version = "1.0.29"
version = "1.0.28"
version = "1.0.28"
version = "1.0.35"
version = "1.0.25"
version = "1.0.25"
version = "1.0.25"
version = "1.0.25"
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
name = "cfg-if"
version = "1.0.29"
version = "1.0.30"
version = "1.0.25"
version = "1.0.25"
version = "1.0.28"
version = "1.0.25"
 "byteorder 1.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "byteorder 1.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "byteorder 1.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "byteorder 1.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "byteorder 1.2.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "byteorder 1.2.7 (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"
 "byteorder 1.2.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "byteorder 1.2.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "byteorder 1.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.4.12"
version = "0.4.12"
version = "0.4.12"
version = "0.4.11"
version = "0.4.11"
version = "0.4.11"
version = "0.4.12"
version = "0.4.11"
version = "0.4.11"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
version = "0.4.11"
version = "1.3.0"
version = "1.3.1"
version = "1.3.1"
version = "1.3.0"
version = "1.2.7"
version = "1.2.7"
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
name = "bytes"
version = "1.2.7"
version = "1.2.7"
version = "1.3.0"
version = "0.3.0"
 "byte-tools 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.3.1"
version = "0.3.1"
version = "0.3.0"
version = "0.2.0"
version = "0.2.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
name = "byteorder"
name = "byte-tools"
]
[[package]]
 "arrayref 0.3.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "byte-tools 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.2.0"
version = "0.2.0"
version = "0.3.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "block-padding 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "byte-tools 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "byteorder 1.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "generic-array 0.12.0 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
 "byte-tools 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "arrayref 0.3.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "byte-tools 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "byte-tools 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.7.0"
 "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)",
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)",
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
name = "block-padding"
version = "0.1.2"
]
[[package]]
]
[[package]]
 "byte-tools 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "block-padding 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "byte-tools 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "byteorder 1.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "generic-array 0.12.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "arrayref 0.3.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "byte-tools 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "arrayref 0.3.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "byte-tools 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.7.0"
version = "0.7.0"
version = "0.7.2"
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"
version = "0.7.2"
version = "0.7.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
version = "0.7.0"
version = "0.3.3"
version = "0.3.3"
version = "0.7.2"
version = "0.7.0"
version = "0.3.3"
version = "0.3.3"
version = "0.7.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "block-padding 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "byte-tools 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "byteorder 1.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "generic-array 0.12.0 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "block-padding"
version = "0.1.2"
version = "0.7.2"
 "byte-tools 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "crypto-mac 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "digest 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "opaque-debug 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "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)",
 "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)",
 "byte-tools 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "crypto-mac 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "digest 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "opaque-debug 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "byte-tools 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "crypto-mac 0.5.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "digest 0.7.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "byte-tools 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "crypto-mac 0.5.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "digest 0.7.6 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "block-buffer"
 "byte-tools 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "crypto-mac 0.5.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "digest 0.7.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "byte-tools 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "crypto-mac 0.5.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "digest 0.7.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "byte-tools 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "crypto-mac 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "digest 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "opaque-debug 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.8.0"
version = "0.8.0"
version = "0.8.0"
version = "0.8.0"
version = "0.7.1"
version = "0.7.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
version = "0.7.1"
version = "0.7.1"
version = "0.8.0"
 "byteorder 1.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "byteorder 1.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "byteorder 1.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "byteorder 1.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "byteorder 1.2.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "safemem 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "byteorder 1.2.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "safemem 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "bitflags"
version = "1.0.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
name = "blake2"
 "byteorder 1.2.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "safemem 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "byteorder 1.2.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "safemem 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "byteorder 1.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.10.0"
version = "0.10.1"
version = "0.10.1"
version = "0.10.0"
version = "0.9.3"
version = "0.9.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
]
[[package]]
name = "base64"
version = "0.9.3"
version = "0.9.3"
version = "0.10.0"
 "libc 0.2.43 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "cc 1.0.28 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.45 (registry+https://github.com/rust-lang/crates.io-index)",
 "cc 1.0.25 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "cc 1.0.31 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.50 (registry+https://github.com/rust-lang/crates.io-index)",
 "cc 1.0.30 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.50 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.49 (registry+https://github.com/rust-lang/crates.io-index)",
 "cc 1.0.26 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.45 (registry+https://github.com/rust-lang/crates.io-index)",
 "cc 1.0.28 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.47 (registry+https://github.com/rust-lang/crates.io-index)",
 "cc 1.0.29 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.48 (registry+https://github.com/rust-lang/crates.io-index)",
 "cc 1.0.35 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
 "cc 1.0.28 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.45 (registry+https://github.com/rust-lang/crates.io-index)",
 "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)",
 "cc 1.0.29 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.48 (registry+https://github.com/rust-lang/crates.io-index)",
 "cc 1.0.28 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.45 (registry+https://github.com/rust-lang/crates.io-index)",
 "cc 1.0.28 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.47 (registry+https://github.com/rust-lang/crates.io-index)",
 "cc 1.0.35 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
 "cc 1.0.25 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "cc 1.0.25 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "cc 1.0.25 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "cc 1.0.25 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "cc 1.0.29 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.48 (registry+https://github.com/rust-lang/crates.io-index)",
 "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)",
 "cc 1.0.25 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "cc 1.0.25 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "cc 1.0.28 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.47 (registry+https://github.com/rust-lang/crates.io-index)",
 "cc 1.0.25 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.1.28"
version = "0.1.24"
version = "0.1.26"
version = "0.1.28"
version = "0.1.28"
version = "0.1.28"
version = "0.1.28"
version = "0.1.28"
version = "0.1.28"
version = "0.1.24"
version = "0.1.24"
version = "0.1.24"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
version = "0.1.24"
version = "0.1.24"
version = "0.1.24"
version = "0.1.28"
version = "0.1.24"
]
[[package]]
name = "backtrace-sys"
 "rustc-demangle 0.1.9 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.45 (registry+https://github.com/rust-lang/crates.io-index)",
 "rustc-demangle 0.1.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "rustc-demangle 0.1.9 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.45 (registry+https://github.com/rust-lang/crates.io-index)",
 "rustc-demangle 0.1.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.47 (registry+https://github.com/rust-lang/crates.io-index)",
 "rustc-demangle 0.1.13 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.48 (registry+https://github.com/rust-lang/crates.io-index)",
 "rustc-demangle 0.1.13 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.45 (registry+https://github.com/rust-lang/crates.io-index)",
 "rustc-demangle 0.1.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.45 (registry+https://github.com/rust-lang/crates.io-index)",
 "rustc-demangle 0.1.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.47 (registry+https://github.com/rust-lang/crates.io-index)",
 "rustc-demangle 0.1.13 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "rustc-demangle 0.1.9 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "rustc-demangle 0.1.9 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "rustc-demangle 0.1.9 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "rustc-demangle 0.1.9 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "rustc-demangle 0.1.9 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.47 (registry+https://github.com/rust-lang/crates.io-index)",
 "rustc-demangle 0.1.13 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "rustc-demangle 0.1.9 (registry+https://github.com/rust-lang/crates.io-index)",
 "autocfg 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "backtrace-sys 0.1.28 (registry+https://github.com/rust-lang/crates.io-index)",
 "backtrace-sys 0.1.24 (registry+https://github.com/rust-lang/crates.io-index)",
 "autocfg 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "backtrace-sys 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",
 "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)",
 "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)",
 "libc 0.2.48 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.49 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.49 (registry+https://github.com/rust-lang/crates.io-index)",
 "cfg-if 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.50 (registry+https://github.com/rust-lang/crates.io-index)",
 "cfg-if 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.50 (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.48 (registry+https://github.com/rust-lang/crates.io-index)",
 "cfg-if 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
 "rustc-demangle 0.1.14 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "cfg-if 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "autocfg 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "backtrace-sys 0.1.28 (registry+https://github.com/rust-lang/crates.io-index)",
 "cfg-if 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
 "rustc-demangle 0.1.14 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "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)",
 "autocfg 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "backtrace-sys 0.1.28 (registry+https://github.com/rust-lang/crates.io-index)",
 "autocfg 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "backtrace-sys 0.1.28 (registry+https://github.com/rust-lang/crates.io-index)",
 "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)",
 "backtrace-sys 0.1.24 (registry+https://github.com/rust-lang/crates.io-index)",
 "cfg-if 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "rustc-demangle 0.1.9 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "backtrace-sys 0.1.24 (registry+https://github.com/rust-lang/crates.io-index)",
 "backtrace-sys 0.1.24 (registry+https://github.com/rust-lang/crates.io-index)",
 "backtrace-sys 0.1.24 (registry+https://github.com/rust-lang/crates.io-index)",
 "cfg-if 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "backtrace-sys 0.1.24 (registry+https://github.com/rust-lang/crates.io-index)",
 "backtrace-sys 0.1.24 (registry+https://github.com/rust-lang/crates.io-index)",
 "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)",
 "backtrace-sys 0.1.24 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.3.13"
version = "0.3.9"
version = "0.3.14"
version = "0.3.13"
version = "0.3.13"
version = "0.3.13"
version = "0.3.15"
version = "0.3.13"
version = "0.3.14"
version = "0.3.13"
version = "0.3.13"
version = "0.3.13"
version = "0.3.15"
version = "0.3.9"
version = "0.3.9"
version = "0.3.9"
version = "0.3.9"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
version = "0.3.13"
version = "0.3.14"
version = "0.3.9"
version = "0.3.9"
version = "0.3.13"
version = "0.3.9"
 "libc 0.2.43 (registry+https://github.com/rust-lang/crates.io-index)",
[[package]]
name = "backtrace"
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
dependencies = [
 "backtrace-sys 0.1.24 (registry+https://github.com/rust-lang/crates.io-index)",
 "cfg-if 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "dbghelp-sys 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "kernel32-sys 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "rustc-demangle 0.1.9 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.2.8 (registry+https://github.com/rust-lang/crates.io-index)",
]
dependencies = [
 "libc 0.2.45 (registry+https://github.com/rust-lang/crates.io-index)",
 "rustc-demangle 0.1.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "rustc-demangle 0.1.9 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.45 (registry+https://github.com/rust-lang/crates.io-index)",
 "rustc-demangle 0.1.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.45 (registry+https://github.com/rust-lang/crates.io-index)",
 "rustc-demangle 0.1.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.45 (registry+https://github.com/rust-lang/crates.io-index)",
 "rustc-demangle 0.1.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "rustc-demangle 0.1.9 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "rustc-demangle 0.1.9 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.2.8 (registry+https://github.com/rust-lang/crates.io-index)",
]
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "rustc-demangle 0.1.9 (registry+https://github.com/rust-lang/crates.io-index)",
 "cfg-if 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "dbghelp-sys 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "kernel32-sys 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "rustc-demangle 0.1.9 (registry+https://github.com/rust-lang/crates.io-index)",
 "backtrace-sys 0.1.28 (registry+https://github.com/rust-lang/crates.io-index)",
 "backtrace-sys 0.1.24 (registry+https://github.com/rust-lang/crates.io-index)",
 "backtrace-sys 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",
 "backtrace-sys 0.1.28 (registry+https://github.com/rust-lang/crates.io-index)",
 "backtrace-sys 0.1.28 (registry+https://github.com/rust-lang/crates.io-index)",
 "backtrace-sys 0.1.24 (registry+https://github.com/rust-lang/crates.io-index)",
 "backtrace-sys 0.1.24 (registry+https://github.com/rust-lang/crates.io-index)",
 "backtrace-sys 0.1.24 (registry+https://github.com/rust-lang/crates.io-index)",
 "backtrace-sys 0.1.24 (registry+https://github.com/rust-lang/crates.io-index)",
dependencies = [
 "backtrace-sys 0.1.24 (registry+https://github.com/rust-lang/crates.io-index)",
 "cfg-if 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "dbghelp-sys 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "kernel32-sys 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "rustc-demangle 0.1.9 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.2.8 (registry+https://github.com/rust-lang/crates.io-index)",
]
dependencies = [
 "backtrace-sys 0.1.24 (registry+https://github.com/rust-lang/crates.io-index)",
 "cfg-if 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "dbghelp-sys 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "kernel32-sys 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "rustc-demangle 0.1.9 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.2.8 (registry+https://github.com/rust-lang/crates.io-index)",
]
name = "autocfg"
version = "0.1.2"
name = "autocfg"
version = "0.1.2"
name = "autocfg"
version = "0.1.2"
name = "autocfg"
version = "0.1.2"
name = "backtrace"
version = "0.2.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
name = "backtrace"
version = "0.2.3"
name = "backtrace"
version = "0.2.3"
name = "autocfg"
version = "0.1.2"
[[package]]
name = "autocfg"
version = "0.1.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
[[package]]
name = "autocfg"
version = "0.1.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
name = "backtrace"
version = "0.2.3"
 "winapi 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.43 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.45 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.50 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.50 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.45 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.47 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.48 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.45 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.49 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.48 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.45 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.47 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.48 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.49 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.47 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.49 (registry+https://github.com/rust-lang/crates.io-index)",
 "nodrop 0.1.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "nodrop 0.1.13 (registry+https://github.com/rust-lang/crates.io-index)",
 "nodrop 0.1.13 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.4.7"
version = "0.4.10"
version = "0.4.8"
version = "0.4.9"
version = "0.4.10"
version = "0.4.10"
version = "0.4.10"
version = "0.4.10"
version = "0.4.8"
version = "0.4.10"
version = "0.4.10"
version = "0.4.8"
version = "0.4.8"
version = "0.4.8"
version = "0.4.8"
version = "0.4.8"
version = "0.4.8"
version = "0.4.10"
version = "0.4.8"
name = "arrayref"
version = "0.3.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
name = "arrayref"
version = "0.3.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
version = "0.3.7"
version = "0.3.6"
version = "0.3.7"
version = "0.3.7"
version = "0.3.10"
name = "arrayref"
version = "0.3.5"
version = "0.3.7"
version = "0.3.7"
version = "0.3.6"
version = "0.3.7"
version = "0.3.7"
version = "0.3.10"
version = "0.3.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
version = "0.3.6"
version = "0.3.6"
version = "0.3.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
name = "arrayref"
version = "0.3.5"
version = "0.3.6"
version = "0.3.7"
version = "0.3.6"
 "winapi 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "arc-swap"
 "winapi 0.3.6 (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 = [
 "memchr 2.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "memchr 2.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "memchr 2.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "memchr 2.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "memchr 2.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "memchr 2.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "memchr 2.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "memchr 2.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
]
 "memchr 2.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "memchr 2.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "memchr 2.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
[[package]]
name = "aho-corasick"
[[package]]
# This file is automatically @generated by Cargo.
# It is not intended for manual editing.
name = "MacTypes-sys"
version = "2.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
]
[[package]]
version = "0.6.10"
 "memchr 2.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "memchr 2.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "memchr 2.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "memchr 2.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "memchr 2.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "memchr 2.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
]
 "memchr 2.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "memchr 2.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "memchr 2.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "memchr 2.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "memchr 2.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "memchr 2.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "memchr 2.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.6.10"
version = "0.7.3"
version = "0.6.10"
version = "0.6.9"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
version = "0.6.9"
version = "0.7.3"
version = "0.6.9"
version = "0.6.9"
version = "0.6.10"
version = "0.6.9"
 "libc 0.2.50 (registry+https://github.com/rust-lang/crates.io-index)",
name = "aho-corasick"
 "libc 0.2.50 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.48 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.48 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.48 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.49 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.49 (registry+https://github.com/rust-lang/crates.io-index)",
name = "MacTypes-sys"
version = "2.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
]
[[package]]
 "libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.49 (registry+https://github.com/rust-lang/crates.io-index)",
[[package]]
name = "MacTypes-sys"
version = "2.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "libc 0.2.47 (registry+https://github.com/rust-lang/crates.io-index)",
]
# This file is automatically @generated by Cargo.
# It is not intended for manual editing.
[[package]]
name = "MacTypes-sys"
version = "1.3.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "libc 0.2.45 (registry+https://github.com/rust-lang/crates.io-index)",
]
# This file is automatically @generated by Cargo.
# It is not intended for manual editing.
[[package]]
[[package]]
name = "MacTypes-sys"
version = "2.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "libc 0.2.47 (registry+https://github.com/rust-lang/crates.io-index)",
]
# This file is automatically @generated by Cargo.
# It is not intended for manual editing.
[[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.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
name = "arrayref"
version = "0.3.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
name = "arrayvec"
version = "0.4.7"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "nodrop 0.1.12 (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.43 (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 = "backtrace"
version = "0.2.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "backtrace-sys 0.1.24 (registry+https://github.com/rust-lang/crates.io-index)",
 "cfg-if 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "dbghelp-sys 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "kernel32-sys 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.43 (registry+https://github.com/rust-lang/crates.io-index)",
 "rustc-demangle 0.1.9 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.2.8 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "backtrace"
version = "0.3.9"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "backtrace-sys 0.1.24 (registry+https://github.com/rust-lang/crates.io-index)",
 "cfg-if 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.43 (registry+https://github.com/rust-lang/crates.io-index)",
 "rustc-demangle 0.1.9 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "backtrace-sys"
version = "0.1.24"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "cc 1.0.25 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.43 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "base64"
version = "0.9.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "byteorder 1.2.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "safemem 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "bitflags"
version = "1.0.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
# 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]]
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
]
[[package]]
name = "adler"
version = "0.2.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ee2a4ec343196209d6594e19543ae87a39f96d5534d7174822a3ad825dd6ed7e"
 "libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
 "gimli 0.22.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "gimli",
checksum = "1b6a2d3371669ab3ca9797670853d61402b03d0b4b9ebf33d677dfa720203072"
name = "MacTypes-sys"
version = "2.1.0"
name = "addr2line"
version = "0.13.0"
[[package]]
name = "aho-corasick"
version = "0.6.9"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
# This file is automatically @generated by Cargo.
# It is not intended for manual editing.
# 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.51 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "MacTypes-sys"
version = "2.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "libc 0.2.47 (registry+https://github.com/rust-lang/crates.io-index)",
]

File deletion: .ignore
BF:BFD[1.0] → [10.12258:12267]
BF:BFD[10.12267] → [10.12268:12268]
B:BD[10.12268] → [10.12269:12296]
```
/target
/.hg
*.rs.bk
*.swp
```
File addition: src (drwxr-xr-x)
[1.0]
File addition: xmpp (drwxr-xr-x)
[0.6]

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

[0.14]

use futures_util::future::Either;
use std::collections::{HashMap, VecDeque};
use std::time::{Duration, Instant};
use tokio_xmpp::{AsyncClient, Event, Packet};
use log::{error, info, warn};
use super::stanzas;
use super::element_processor;
use crate::config;
#[derive(Debug)]
pub enum XmppCommand {
    /// Send message to someone by jid
    Chat {
        xmpp_to: xmpp_parsers::Jid,
        message: String,
    },
    /// Send message to MUC
    Chatroom { muc_id: String, message: String },
    /// Send ping request to the server to test connection
    Ping,
    /// Set presence status
    Presence {
        show: xmpp_parsers::presence::Show,
        message: String,
    },
    /// Send presence status to MUC
    ChatroomPresence {
        muc_id: String,
        show: xmpp_parsers::presence::Show,
        message: String,
    },
    /// Check iq requests if some have expired timeouts
    TimeoutCleanup,
}
/// trait of processing iq
/// each function consumes handlers and
/// returns false if connection should be reset
trait IqHandler {
    /// process result
    fn result(
        self: Box<Self>,
        conn: &mut XmppConnection,
        opt_element: Option<xmpp_parsers::Element>,
    ) -> bool;
    /// process error
    fn error(
        self: Box<Self>,
        conn: &mut XmppConnection,
        error: xmpp_parsers::stanza_error::StanzaError,
    ) -> bool;
    /// process tmeout
    fn timeout(self: Box<Self>, conn: &mut XmppConnection) -> bool;
}
struct AddRosterIqHandler {
    jid: xmpp_parsers::BareJid,
}
impl IqHandler for AddRosterIqHandler {
    fn result(
        self: Box<Self>,
        conn: &mut XmppConnection,
        opt_element: Option<xmpp_parsers::Element>,
    ) -> bool {
        match opt_element {
            Some(element) => {
                warn!(
                    "Wrong payload when adding {} to roster: {}",
                    self.jid,
                    String::from(&element)
                );
            }
            None => {
                if conn.state.data.roster.contains_key(&self.jid) {
                    info!("Jid {} updated to roster", self.jid);
                } else {
                    info!("Jid {} added in roster", self.jid);
                    conn.state.data.roster.insert(
                        self.jid.clone(),
                        (
                            xmpp_parsers::roster::Subscription::None,
                            xmpp_parsers::roster::Ask::None,
                        ),
                    );
                }
            }
        }
        true
    }
    fn error(
        self: Box<Self>,
        _conn: &mut XmppConnection,
        _error: xmpp_parsers::stanza_error::StanzaError,
    ) -> bool {
        true
    }
    fn timeout(self: Box<Self>, _conn: &mut XmppConnection) -> bool {
        true // ignore
    }
}
struct PingIqHandler {}
impl IqHandler for PingIqHandler {
    fn result(
        self: Box<Self>,
        _conn: &mut XmppConnection,
        _opt_element: Option<xmpp_parsers::Element>,
    ) -> bool {
        info!("ping successed");
        true
    }
    fn error(
        self: Box<Self>,
        _conn: &mut XmppConnection,
        _error: xmpp_parsers::stanza_error::StanzaError,
    ) -> bool {
        false
    }
    fn timeout(self: Box<Self>, _conn: &mut XmppConnection) -> bool {
        false
    }
}
struct InitRosterIqHandler {}
impl IqHandler for InitRosterIqHandler {
    fn result(
        self: Box<Self>,
        conn: &mut XmppConnection,
        opt_element: Option<xmpp_parsers::Element>,
    ) -> bool {
        if let Some(result) = opt_element {
            use std::convert::TryInto;
            match result.try_into() as Result<xmpp_parsers::roster::Roster, _> {
                Ok(roster) => {
                    conn.state.data.roster_init = true;
                    conn.state.data.roster.clear();
                    info!("Got first roster:");
                    for i in roster.items {
                        info!(" >>> {:?}", i);
                        conn.state
                            .data
                            .roster
                            .insert(i.jid, (i.subscription, i.ask));
                    }
                    true
                }
                Err(e) => {
                    error!("Cann't parse roster: {}", e);
                    false
                }
            }
        } else {
            error!("No roster responded");
            false
        }
    }
    fn error(
        self: Box<Self>,
        _conn: &mut XmppConnection,
        _error: xmpp_parsers::stanza_error::StanzaError,
    ) -> bool {
        false
    }
    fn timeout(self: Box<Self>, _conn: &mut XmppConnection) -> bool {
        false
    }
}
/// data for awaiting iq answer
struct IqWait {
    /// time of sending iq
    sent: Instant,
    /// timeout
    timeout: Duration,
    /// handler for iq processing
    handler: Box<dyn IqHandler>,
}
impl IqWait {
    pub fn new<T: IqHandler + 'static>(timeout_secs: u64, handler: T) -> IqWait {
        IqWait {
            sent: Instant::now(),
            timeout: Duration::from_secs(timeout_secs),
            handler: Box::new(handler),
        }
    }
}
#[derive(Default)]
struct XmppData {
    /// known roster data
    roster: HashMap<
        xmpp_parsers::BareJid,
        (
            xmpp_parsers::roster::Subscription,
            xmpp_parsers::roster::Ask,
        ),
    >,
    /// if roster was initialized
    /// ToDo: remove it as it is used only for initialization
    roster_init: bool,
    /// if self-presence accepted
    /// ToDo: remove it as it is used only for initialization
    self_presence: bool,
    /// ids counter
    counter: usize,
    /// 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>,
    /// map from iq's id to handler of this type of iqs
    pending_ids: HashMap<String, IqWait>,
}
struct XmppState {
    client: AsyncClient,
    data: XmppData,
}
pub struct XmppConnection {
    account: std::rc::Rc<config::Account>,
    state: XmppState,
}
trait IqRequestHandler {
    fn process(
        self: Box<Self>,
        conn: &mut XmppConnection,
        id: String,
        from: Option<xmpp_parsers::Jid>,
    ) -> xmpp_parsers::iq::Iq;
}
struct IqRequestUnknown {
    element: xmpp_parsers::Element,
    type_: &'static str,
}
impl IqRequestHandler for IqRequestUnknown {
    fn process(
        self: Box<Self>,
        conn: &mut XmppConnection,
        id: String,
        from: Option<xmpp_parsers::Jid>,
    ) -> xmpp_parsers::iq::Iq {
        warn!(
            "Unsupported IQ {} request from {:?}: {}",
            self.type_,
            from,
            String::from(&self.element)
        );
        stanzas::make_iq_unsupported_error(id, conn.account.jid.clone(), from)
    }
}
struct IqSetRoster {}
impl IqRequestHandler for IqSetRoster {
    fn process(
        self: Box<Self>,
        conn: &mut XmppConnection,
        id: String,
        from: Option<xmpp_parsers::Jid>,
    ) -> xmpp_parsers::iq::Iq {
        info!("Got roster push {} from {:?}", id, from);
        stanzas::make_roster_push_answer(id, conn.account.jid.clone(), from)
    }
}
struct IqGetPing {}
impl IqRequestHandler for IqGetPing {
    fn process(
        self: Box<Self>,
        conn: &mut XmppConnection,
        id: String,
        from: Option<xmpp_parsers::Jid>,
    ) -> xmpp_parsers::iq::Iq {
        info!("Got ping {} from {:?}", id, from);
        stanzas::make_pong(id, conn.account.jid.clone(), from)
    }
}
struct IqGetVersion {}
impl IqRequestHandler for IqGetVersion {
    fn process(
        self: Box<Self>,
        conn: &mut XmppConnection,
        id: String,
        from: Option<xmpp_parsers::Jid>,
    ) -> xmpp_parsers::iq::Iq {
        info!("Got version query {} from {:?}", id, from);
        stanzas::make_version(id, conn.account.jid.clone(), from)
    }
}
struct IqGetDiscoInfo {}
impl IqRequestHandler for IqGetDiscoInfo {
    fn process(
        self: Box<Self>,
        conn: &mut XmppConnection,
        id: String,
        from: Option<xmpp_parsers::Jid>,
    ) -> xmpp_parsers::iq::Iq {
        info!("Got disco query {} from {:?}", id, from);
        stanzas::make_disco_info_result(id, conn.account.jid.clone(), from)
    }
}
struct IqGetDiscoItems {}
impl IqRequestHandler for IqGetDiscoItems {
    fn process(
        self: Box<Self>,
        conn: &mut XmppConnection,
        id: String,
        from: Option<xmpp_parsers::Jid>,
    ) -> xmpp_parsers::iq::Iq {
        info!("Got disco items query {} from {:?}", id, from);
        stanzas::make_disco_items_result(id, conn.account.jid.clone(), from)
    }
}
struct IqGetDiscoCommands {}
impl IqRequestHandler for IqGetDiscoCommands {
    fn process(
        self: Box<Self>,
        conn: &mut XmppConnection,
        id: String,
        from: Option<xmpp_parsers::Jid>,
    ) -> xmpp_parsers::iq::Iq {
        info!("Got disco commands query {} from {:?}", id, from);
        stanzas::make_disco_items_commands(id, conn.account.jid.clone(), from)
    }
}
lazy_static::lazy_static! {
    static ref INCOMING: element_processor::Processor<XmppConnection, bool, xmpp_parsers::Element> = {
        let mut incoming = element_processor::Processor::new(&|_, e| {
            warn!("Unknown stanza {}", String::from(&e));
            true
        });
        incoming.register(&XmppConnection::incoming_iq_processing);
        incoming.register(&XmppConnection::incoming_presence_processing);
        incoming.register(&XmppConnection::incoming_message_processing);
        incoming
    };
    static ref INCOMING_IQ_SET: element_processor::Processor<XmppConnection, Box<dyn IqRequestHandler>, xmpp_parsers::Element> = {
        let mut iq_set =
            element_processor::Processor::new(&|_conn: &mut XmppConnection, element| {
                Box::new(IqRequestUnknown {
                    element,
                    type_: "set",
                }) as Box<dyn IqRequestHandler>
            });
        iq_set.register(&XmppConnection::incoming_iq_processing_set_roster);
        iq_set
    };
    static ref INCOMING_IQ_GET: element_processor::Processor<XmppConnection, Box<dyn IqRequestHandler>, xmpp_parsers::Element> = {
        let mut iq_get =
            element_processor::Processor::new(&|_conn: &mut XmppConnection, element| {
                Box::new(IqRequestUnknown {
                    element,
                    type_: "get",
                }) as Box<dyn IqRequestHandler>
            });
        iq_get.register(&XmppConnection::incoming_iq_processing_get_ping);
        iq_get.register(&XmppConnection::incoming_iq_processing_get_disco_info);
        iq_get.register(&XmppConnection::incoming_iq_processing_get_disco_items);
        iq_get.register(&XmppConnection::incoming_iq_processing_get_version);
        iq_get
    };
}
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 async fn connect<F>(self, stop_future: F) -> Result<XmppConnection, failure::Error>
    where
        F: std::future::Future<Output = ()> + Clone + 'static,
    {
        info!("xmpp check connection...");
        let MaybeXmppConnection { account, state } = self;
        if let Some(state) = state {
            Ok(XmppConnection { account, state })
        } else {
            loop {
                let pin_stop_future = stop_future.clone();
                tokio::pin!(pin_stop_future);
                let connect = futures_util::future::select(
                    pin_stop_future,
                    Box::pin(async {
                        info!("xmpp initialization...");
                        let mut client = AsyncClient::new_with_jid(
                            account.jid.clone(),
                            account.password.clone(),
                        );
                        client.set_reconnect(false);
                        let stop_future = stop_future.clone();
                        let (connected, stopped) = XmppConnection {
                            state: XmppState {
                                client,
                                data: std::default::Default::default(),
                            },
                            account: account.clone(),
                        }
                        .processing(XmppConnection::online, Box::pin(stop_future), true)
                        .await;
                        let (connected, stopped) = match (connected, stopped) {
                            (Ok(connection), Either::Left(stop_future)) => {
                                connection.initial_roster(stop_future).await
                            }
                            (connected, stopped) => (connected, stopped),
                        };
                        let (connected, stopped) = match (connected, stopped) {
                            (Ok(connection), Either::Left(stop_future)) => {
                                connection.self_presence(stop_future).await
                            }
                            (connected, stopped) => (connected, stopped),
                        };
                        match (connected, stopped) {
                            (Ok(connection), Either::Left(stop_future)) => {
                                connection.enter_mucs(stop_future).await
                            }
                            (connected, stopped) => (connected, stopped),
                        }
                    }),
                )
                .await;
                match connect {
                    Either::Left((_, _)) => {
                        break Err(failure::format_err!("Stop XMPP connection"))
                    }
                    Either::Right(((_, Either::Right(_)), _)) => {
                        break Err(failure::format_err!("Stop XMPP connection(2)"))
                    }
                    Either::Right(((result, Either::Left(_)), _)) => match result {
                        Ok(connection) => break Ok(connection),
                        Err(account) => {}
                    },
                }
            }
        }
    }
}
impl XmppConnection {
    /// base XMPP processing
    /// Returns false on error to disconnect
    fn xmpp_processing(&mut self, event: &Event) -> bool {
        match event {
            Event::Stanza(stanza) => INCOMING.process(self, stanza.clone()),
            Event::Online { .. } => true,
            Event::Disconnected(error) => {
                error!("Unexpected event {:?}", error);
                false
            }
        }
    }
    /// Process roster push
    /// see RFC 6212 2.1.6. Roster Push
    fn incoming_iq_processing_set_roster(
        &mut self,
        roster: xmpp_parsers::roster::Roster,
    ) -> Box<dyn IqRequestHandler> {
        for i in roster.items {
            if let Some(ref mut rdata) = self.state.data.roster.get_mut(&i.jid) {
                info!("Update {} in roster", i.jid);
                rdata.0 = i.subscription;
                rdata.1 = i.ask;
            } else {
                info!("Add {} to roster", i.jid);
                self.state
                    .data
                    .roster
                    .insert(i.jid.clone(), (i.subscription, i.ask));
            }
        }
        Box::new(IqSetRoster {})
    }
    /// Enforce to answer to IQ "set"
    fn incoming_iq_processing_set(
        &mut self,
        id: String,
        from: Option<xmpp_parsers::Jid>,
        element: minidom::Element,
    ) -> xmpp_parsers::iq::Iq {
        INCOMING_IQ_SET
            .process(self, element)
            .process(self, id, from)
    }
    /// Process ping request
    /// see XEP-0199: XMPP Ping
    fn incoming_iq_processing_get_ping(
        &mut self,
        _ping: xmpp_parsers::ping::Ping,
    ) -> Box<dyn IqRequestHandler> {
        Box::new(IqGetPing {})
    }
    /// Process disco query
    /// see XEP-0030: Service Discovery
    fn incoming_iq_processing_get_disco_info(
        &mut self,
        disco: xmpp_parsers::disco::DiscoInfoQuery,
    ) -> Box<dyn IqRequestHandler> {
        if let Some(ref node) = disco.node {
            warn!("Unsupported node {}", node);
            Box::new(IqRequestUnknown {
                element: disco.into(),
                type_: "get",
            })
        } else {
            Box::new(IqGetDiscoInfo {})
        }
    }
    /// Process disco items query
    /// see XEP-0030: Service Discovery
    fn incoming_iq_processing_get_disco_items(
        &mut self,
        disco: xmpp_parsers::disco::DiscoItemsQuery,
    ) -> Box<dyn IqRequestHandler> {
        match &disco.node {
            Some(node) if node == "http://jabber.org/protocol/commands" => {
                Box::new(IqGetDiscoCommands {})
            }
            Some(node) => {
                warn!("Unsupported node {}", node);
                Box::new(IqRequestUnknown {
                    element: disco.into(),
                    type_: "get",
                })
            }
            None => Box::new(IqGetDiscoItems {}),
        }
    }
    /// Process version query
    /// see XEP-0092: Software Version
    fn incoming_iq_processing_get_version(
        &mut self,
        _version: xmpp_parsers::version::VersionQuery,
    ) -> Box<dyn IqRequestHandler> {
        Box::new(IqGetVersion {})
    }
    /// Enforce to answer to IQ "get"
    fn incoming_iq_processing_get(
        &mut self,
        id: String,
        from: Option<xmpp_parsers::Jid>,
        element: minidom::Element,
    ) -> xmpp_parsers::iq::Iq {
        INCOMING_IQ_GET
            .process(self, element)
            .process(self, id, from)
    }
    fn incoming_iq_processing(&mut self, iq: xmpp_parsers::iq::Iq) -> bool {
        match iq.payload {
            xmpp_parsers::iq::IqType::Set(element) => {
                let iq_answer = self.incoming_iq_processing_set(iq.id, iq.from, element);
                self.state.data.send_queue.push_back(iq_answer.into());
            }
            xmpp_parsers::iq::IqType::Error(e) => {
                if let Some((_, data)) = self.state.data.pending_ids.remove_entry(&iq.id) {
                    return data.handler.error(self, e);
                }
                error!("iq error: {:?}", e);
                return false;
            }
            xmpp_parsers::iq::IqType::Get(element) => {
                let iq_answer = self.incoming_iq_processing_get(iq.id, iq.from, element);
                self.state.data.send_queue.push_back(iq_answer.into());
            }
            xmpp_parsers::iq::IqType::Result(opt_element) => {
                if let Some((_, data)) = self.state.data.pending_ids.remove_entry(&iq.id) {
                    let now = Instant::now();
                    if data.sent + data.timeout > now {
                        info!(
                            "Timeout for {} was {:?} expected {:?}",
                            iq.id,
                            now - data.sent,
                            data.timeout
                        );
                        return data.handler.result(self, opt_element);
                    } else {
                        warn!(
                            "Timeout for {} was {:?} expected {:?}",
                            iq.id,
                            now - data.sent,
                            data.timeout
                        );
                        return data.handler.timeout(self);
                    }
                }
                warn!(
                    "Unwanted iq result id {} from {:?}: {:?}",
                    iq.id,
                    iq.from,
                    opt_element.map(|e| String::from(&e))
                );
            }
        }
        true
    }
    fn incoming_presence_processing(&mut self, presence: xmpp_parsers::presence::Presence) -> bool {
        if presence.from.as_ref() == Some(&self.account.jid) {
            info!("Self-presence accepted");
            self.state.data.self_presence = true;
        } else {
            warn!("Incoming presence stanza: {:?}", presence);
        }
        true
    }
    fn incoming_message_processing(&mut self, message: xmpp_parsers::message::Message) -> bool {
        for payload in message.payloads.iter() {
            use std::convert::TryInto;
            if let Some(_delay) =
                payload.clone().try_into().ok() as Option<xmpp_parsers::delay::Delay>
            {
                return true; // ignore delayed messages
            }
        }
        warn!("Incoming message stanza: {:?}", message);
        true
    }
    /// first data: return Ok(conn) if still connected, Err(account) if disconnected
    /// second data: true if stopped
    pub async fn processing<S, F, O>(
        mut self,
        mut stop_condition: S,
        stop_future: F,
        stop_fatal: bool,
    ) -> (Result<Self, std::rc::Rc<config::Account>>, Either<F, O>)
    where
        S: FnMut(&mut Self, Event) -> Result<bool, ()> + 'static,
        F: std::future::Future<Output = O> + Unpin,
    {
        let account = self.account.clone();
        let mut stop_future = stop_future;
        loop {
            if let Some(send_element) = self.state.data.send_queue.pop_front() {
                info!("Sending {}", String::from(&send_element));
                let stop = {
                    let send_future = self.state.client.send_stanza(send_element);
                    tokio::pin!(send_future);
                    match futures_util::future::select(stop_future, send_future).await {
                        Either::Left((stop, send_future)) => {
                            if stop_fatal {
                                warn!("Sending interrupted!");
                            } else {
                                match send_future.await {
                                    Ok(_) => {
                                        info!("Sent!");
                                    }
                                    Err(e) => {
                                        error!("Send stanza error: {}", e);
                                        break (Err(self.account), Either::Right(stop));
                                    }
                                }
                            }
                            stop
                        }
                        Either::Right((Ok(_), f)) => {
                            info!("Sent!");
                            stop_future = f;
                            continue;
                        }
                        Either::Right((Err(e), f)) => {
                            error!("Send stanza error: {}", e);
                            break (Err(self.account), Either::Left(f));
                        }
                    }
                };
                break (Ok(self), Either::Right(stop));
            } else {
                use futures_util::StreamExt;
                let recv_future = self.state.client.next();
                tokio::pin!(recv_future);
                match futures_util::future::select(stop_future, recv_future).await {
                    Either::Left((stop, s)) => break (Ok(self), Either::Right(stop)),
                    Either::Right((None, f)) => {
                        break (Err(self.account), Either::Left(f));
                    }
                    Either::Right((Some(event), f)) => {
                        stop_future = f;
                        if (self.xmpp_processing(&event)) {
                            match stop_condition(&mut self, event) {
                                Ok(true) => break (Ok(self), Either::Left(stop_future)),
                                Ok(false) => {}
                                Err(_) => break (Err(self.account), Either::Left(stop_future)),
                            }
                        } else {
                            break (Err(self.account), Either::Left(stop_future));
                        }
                    }
                }
            }
        }
    }
    /// 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: {}", String::from(&s));
                Ok(false)
            }
            Event::Disconnected(e) => {
                error!("Disconnected while waiting online: {:?}", e);
                Err(())
            }
        }
    }
    async fn initial_roster<F>(
        mut self,
        stop_future: F,
    ) -> (Result<Self, std::rc::Rc<config::Account>>, Either<F, ()>)
    where
        F: std::future::Future<Output = ()> + Unpin,
    {
        self.state.data.counter += 1;
        let id_init_roster = format!("id_init_roster{}", self.state.data.counter);
        let get_roster = stanzas::make_get_roster(&id_init_roster);
        info!("Quering roster... {}", String::from(&get_roster));
        self.state.data.pending_ids.insert(
            id_init_roster.clone(),
            IqWait::new(60, InitRosterIqHandler {}),
        );
        let stop_future = {
            let send_future = self.state.client.send_stanza(get_roster);
            tokio::pin!(send_future);
            match futures_util::future::select(stop_future, send_future).await {
                Either::Left(((), _)) => None,
                Either::Right((Ok(_), stop_future)) => Some(stop_future),
                Either::Right((Err(e), f)) => {
                    error!("Send initial roster stanza error: {}", e);
                    return (Err(self.account), Either::Left(f));
                }
            }
        };
        if let Some(stop_future) = stop_future {
            self.processing(
                move |conn, _| Ok(conn.state.data.roster_init),
                stop_future,
                true,
            )
            .await
        } else {
            (Ok(self), Either::Right(()))
        }
    }
    async fn self_presence<F>(
        mut self,
        stop_future: F,
    ) -> (Result<Self, std::rc::Rc<config::Account>>, Either<F, ()>)
    where
        F: std::future::Future<Output = ()> + Unpin,
    {
        self.state.data.counter += 1;
        let id_presence = format!("id_init_presence{}", self.state.data.counter);
        let presence = stanzas::make_presence(id_presence, None, "Online!".to_string());
        info!("Sending presence... {}", String::from(&presence));
        let stop_future = {
            let send_future = self.state.client.send_stanza(presence);
            tokio::pin!(send_future);
            match futures_util::future::select(stop_future, send_future).await {
                Either::Left(((), send_future)) => None,
                Either::Right((Ok(_), stop_future)) => Some(stop_future),
                Either::Right((Err(e), f)) => {
                    error!("Send self-presence stanza error: {}", e);
                    return (Err(self.account), Either::Left(f));
                }
            }
        };
        if let Some(stop_future) = stop_future {
            self.processing(
                move |conn, _| Ok(conn.state.data.self_presence),
                stop_future,
                true,
            )
            .await
        } else {
            (Ok(self), Either::Right(()))
        }
    }
    pub fn process_command(mut self, cmd: XmppCommand) -> MaybeXmppConnection {
        match cmd {
            XmppCommand::Presence { show, message } => {
                self.state.data.counter += 1;
                let id_presence = format!("id_presence{}", self.state.data.counter);
                self.state.data.send_queue.push_back(stanzas::make_presence(
                    id_presence,
                    Some(show),
                    message,
                ));
            }
            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
                        .bound_jid()
                        .map_or_else(|| self.account.jid.clone(), |j| j.clone()),
                );
                self.state.data.send_queue.push_back(ping);
                self.state
                    .data
                    .pending_ids
                    .insert(id_ping, IqWait::new(30, PingIqHandler {}));
            }
            XmppCommand::TimeoutCleanup => {
                let now = Instant::now();
                let timeouted: Vec<String> = self
                    .state
                    .data
                    .pending_ids
                    .iter()
                    .filter_map(|(id, data)| {
                        if now >= data.sent + data.timeout {
                            warn!(
                                "Timeout for {} was {:?} expected {:?}",
                                id,
                                now - data.sent,
                                data.timeout
                            );
                            Some(id.to_string())
                        } else {
                            None
                        }
                    })
                    .collect();
                let mut correct = true;
                timeouted.into_iter().for_each(|id| {
                    if let Some(data) = self.state.data.pending_ids.remove(&id) {
                        correct &= data.handler.timeout(&mut self);
                    }
                })
            }
            _ => todo!(),
        }
        self.into()
    }
    async fn enter_mucs<F>(
        mut self,
        mut stop_future: F,
    ) -> (Result<Self, std::rc::Rc<config::Account>>, Either<F, ()>)
    where
        F: std::future::Future<Output = ()> + Unpin,
    {
        for chatroom in &self.account.chatrooms {
            self.state.data.counter += 1;
            let id_muc_presence = format!("id_muc_presence{}", self.state.data.counter);
            let muc_presence = stanzas::make_muc_presence(
                &id_muc_presence,
                self.account.jid.clone(),
                chatroom.1.clone(),
                None,
                None,
            );
            info!("Sending muc presence... {}", String::from(&muc_presence));
            let opt_stop_future = {
                let send_future = self.state.client.send_stanza(muc_presence);
                tokio::pin!(send_future);
                match futures_util::future::select(stop_future, send_future).await {
                    Either::Left(((), _)) => None,
                    Either::Right((Ok(_), stop_future)) => Some(stop_future),
                    Either::Right((Err(e), f)) => {
                        error!("Send self-presence stanza error: {}", e);
                        return (Err(self.account), Either::Left(f));
                    }
                }
            };
            if let Some(f) = opt_stop_future {
                stop_future = f;
            } else {
                return (Ok(self), Either::Right(()));
            }
        }
        (Ok(self), Either::Left(stop_future))
    }
}

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

[0.14]

use minidom::Element;
use xmpp_parsers::disco::{DiscoInfoResult, DiscoItemsResult, Feature, Identity};
use xmpp_parsers::iq::Iq;
use xmpp_parsers::message::{Body, Message, MessageType};
use xmpp_parsers::ping::Ping;
use xmpp_parsers::presence::{Presence, Show as PresenceShow, Type as PresenceType};
use xmpp_parsers::roster::{Item, Roster};
use xmpp_parsers::stanza_error::{DefinedCondition, ErrorType, StanzaError};
use xmpp_parsers::version::VersionResult;
use xmpp_parsers::{BareJid, Jid};
pub fn make_presence(id: String, show: Option<PresenceShow>, text: String) -> Element {
    let mut presence = Presence::new(PresenceType::None);
    presence.id = Some(id);
    presence.show = show;
    presence.statuses.insert(String::from("en"), text);
    presence.into()
}
pub fn make_get_roster(id: &str) -> Element {
    Iq::from_get(
        id,
        Roster {
            items: vec![],
            ver: None,
        },
    )
    .into()
}
pub fn make_add_roster(id: &str, jid: xmpp_parsers::BareJid) -> Element {
    Iq::from_set(
        id,
        Roster {
            items: vec![Item {
                jid,
                name: None,
                subscription: xmpp_parsers::roster::Subscription::None,
                ask: xmpp_parsers::roster::Ask::None,
                groups: vec![],
            }],
            ver: None,
        },
    )
    .into()
}
pub fn make_roster_push_answer(
    id: String,
    from: xmpp_parsers::Jid,
    to: Option<xmpp_parsers::Jid>,
) -> Iq {
    let mut answer = Iq::from_result(id, None as Option<Roster>);
    answer.from = Some(from);
    answer.to = to;
    answer
}
pub fn make_ask_subscribe(id: String, jid: xmpp_parsers::Jid) -> Element {
    let mut presence = Presence::new(PresenceType::Subscribe);
    presence.id = Some(id);
    presence.to = Some(jid);
    presence.into()
}
pub fn make_allow_subscribe(id: String, jid: xmpp_parsers::Jid) -> Element {
    let mut presence = Presence::new(PresenceType::Subscribed);
    presence.id = Some(id);
    presence.to = Some(jid);
    presence.into()
}
pub fn make_chat_message(jid: xmpp_parsers::Jid, text: String) -> Element {
    let mut message = Message::new(Some(jid));
    message.bodies.insert(String::new(), Body(text));
    message.type_ = MessageType::Chat;
    message.into()
}
pub fn make_muc_presence(
    id: &str,
    from: xmpp_parsers::Jid,
    to: xmpp_parsers::Jid,
    show: Option<PresenceShow>,
    text: Option<String>,
) -> Element {
    let mut presence = Presence::new(PresenceType::None);
    presence.from = Some(from);
    presence.to = Some(to);
    presence.id = Some(id.to_string());
    presence.show = show;
    if let Some(text) = text {
        presence.statuses.insert(String::from("en"), text);
    }
    presence.add_payload(xmpp_parsers::muc::Muc::new());
    presence.into()
}
pub fn make_muc_message(to: xmpp_parsers::Jid, text: String) -> Element {
    let mut message = Message::new(Some(Jid::Bare(to.into())));
    message.bodies.insert(String::new(), Body(text));
    message.type_ = MessageType::Groupchat;
    message.into()
}
pub fn make_muc_presence_leave(from: xmpp_parsers::Jid, to: xmpp_parsers::Jid) -> Element {
    let mut presence = Presence::new(PresenceType::Unavailable);
    presence.from = Some(from);
    presence.to = Some(to);
    presence.into()
}
pub fn make_ping(id: &str, from: xmpp_parsers::Jid) -> Element {
    let ping = Iq::from_get(id, Ping)
        .with_to(Jid::Bare(BareJid::domain(from.clone().domain())))
        .with_from(from);
    ping.into()
}
pub fn make_pong(id: String, from: xmpp_parsers::Jid, to: Option<xmpp_parsers::Jid>) -> Iq {
    let mut pong = Iq::from_result(id, None as Option<Roster>);
    pong.from = Some(from);
    pong.to = to;
    pong
}
pub fn make_version(id: String, from: xmpp_parsers::Jid, to: Option<xmpp_parsers::Jid>) -> Iq {
    let mut version = Iq::from_result(
        id,
        Some(VersionResult {
            name: "SendXmppDRust".to_string(),
            version: "0.1.0".to_string(),
            os: None,
        }),
    );
    version.from = Some(from);
    version.to = to;
    version
}
pub fn make_iq_unsupported_error(
    id: String,
    from: xmpp_parsers::Jid,
    to: Option<xmpp_parsers::Jid>,
) -> Iq {
    let mut error = Iq::from_error(
        id,
        StanzaError {
            type_: ErrorType::Cancel,
            by: Some(from.clone()),
            defined_condition: DefinedCondition::ServiceUnavailable,
            texts: std::collections::BTreeMap::new(),
            other: None,
        },
    );
    error.from = Some(from);
    error.to = to;
    error
}
pub fn make_disco_info_result(
    id: String,
    from: xmpp_parsers::Jid,
    to: Option<xmpp_parsers::Jid>,
) -> Iq {
    let mut result = Iq::from_result(
        id,
        Some(DiscoInfoResult {
            node: None,
            identities: vec![Identity {
                category: "client".to_string(),
                type_: "bot".to_string(),
                name: None,
                lang: None,
            }],
            features: vec![
                Feature {
                    var: "http://jabber.org/protocol/disco#info".to_string(),
                },
                Feature {
                    var: "urn:xmpp:ping".to_string(),
                },
                Feature {
                    var: "http://jabber.org/protocol/commands".to_string(),
                },
            ],
            extensions: vec![],
        }),
    );
    result.from = Some(from);
    result.to = to;
    result
}
pub fn make_disco_items_result(
    id: String,
    from: xmpp_parsers::Jid,
    to: Option<xmpp_parsers::Jid>,
) -> Iq {
    let mut result = Iq::from_result(
        id,
        Some(DiscoItemsResult {
            node: None,
            items: vec![],
        }),
    );
    result.from = Some(from);
    result.to = to;
    result
}
pub fn make_disco_items_commands(
    id: String,
    from: xmpp_parsers::Jid,
    to: Option<xmpp_parsers::Jid>,
) -> Iq {
    let mut result = Iq::from_result(
        id,
        Some(DiscoItemsResult {
            node: Some("http://jabber.org/protocol/commands".to_string()),
            items: vec![],
        }),
    );
    result.from = Some(from);
    result.to = to;
    result
}

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

[0.14]

use futures_util::future::Either;
use log::{error, info, warn};
use crate::config;
mod element_processor;
mod stanzas;
mod xmpp_connection;
use xmpp_connection::MaybeXmppConnection;
pub use xmpp_connection::XmppCommand;
struct XmppProcessState<F, S> {
    cmd_recv: S,
    signal: F,
    conn: MaybeXmppConnection,
}
impl<F, S> XmppProcessState<F, S> {
    fn new(cmd_recv: S, signal: F, conn: MaybeXmppConnection) -> XmppProcessState<F, S> {
        XmppProcessState {
            cmd_recv,
            signal,
            conn,
        }
    }
}
pub async fn xmpp_process<F, S>(
    signal: F,
    mut cmd_recv: S,
    account: config::Account,
) -> Result<(), failure::Error>
where
    F: std::future::Future<Output = ()> + Clone + 'static,
    S: tokio::stream::Stream<Item = XmppCommand> + Unpin,
{
    use futures_util::StreamExt;
    let mut maybe_conn: MaybeXmppConnection = account.into();
    let mut recv_future = cmd_recv.next();
    loop {
        match maybe_conn.connect(signal.clone()).await {
            Ok(conn) => match conn.processing(|_, _| Ok(false), recv_future, false).await {
                (Ok(conn), Either::Left(f)) => {
                    maybe_conn = conn.into();
                    recv_future = f;
                }
                (Ok(conn), Either::Right(None)) => break Ok(()),
                (Ok(conn), Either::Right(Some(cmd))) => {
                    info!("Get command: {:?}", cmd);
                    maybe_conn = conn.process_command(cmd);
                    recv_future = cmd_recv.next();
                }
                (Err(acc), Either::Left(f)) => {
                    maybe_conn = acc.into();
                    recv_future = f;
                }
                (Err(acc), Either::Right(None)) => break Ok(()),
                (Err(acc), Either::Right(Some(cmd))) => {
                    warn!("Get command for broken connection: {:?}", cmd);
                    maybe_conn = acc.into();
                    recv_future = cmd_recv.next();
                }
            },
            Err(e) => break Err(e),
        }
    }
}

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

[0.14]

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

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

[0.6]

use std::future::Future;
use std::pin::Pin;
use tokio::stream::Stream;
use tokio::sync::mpsc::Receiver;
use pin_project::pin_project;
#[pin_project(project = StoppableReceiverProj)]
pub struct StoppableReceiver<T, F: Future<Output = ()>> {
    #[pin]
    receiver: Receiver<T>,
    #[pin]
    stop_future: F,
    finished: bool,
}
impl<T, F: Future<Output = ()>> Stream for StoppableReceiver<T, F> {
    type Item = T;
    fn poll_next(
        self: Pin<&mut Self>,
        cx: &mut std::task::Context,
    ) -> std::task::Poll<Option<Self::Item>> {
        let StoppableReceiverProj {
            mut receiver,
            stop_future,
            finished,
        } = self.project();
        if *finished {
            return std::task::Poll::Ready(None);
        }
        if let std::task::Poll::Ready(_) = stop_future.poll(cx) {
            *finished = true;
            receiver.close();
            return std::task::Poll::Ready(None);
        }
        receiver.poll_recv(cx)
    }
}
pub fn stop_receiver<T, F: Future<Output = ()>>(
    receiver: Receiver<T>,
    stop_future: F,
) -> StoppableReceiver<T, F> {
    StoppableReceiver {
        receiver,
        stop_future,
        finished: false,
    }
}

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

[0.6]

#![deny(deprecated)]
#![deny(missing_docs)]
#![deny(bare_trait_objects)]
//! XMPP client service
use hyper::{Body, Request, Response, Server};
use log::{error, info, warn};
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
async fn body_to_string(req: Request<Body>) -> Result<String, failure::Error> {
    let whole_body = hyper::body::to_bytes(req.into_body()).await?;
    std::str::from_utf8(&whole_body)
        .map(std::string::ToString::to_string)
        .map_err(std::convert::Into::into)
}
struct ServiceCmd {
    cmd_send: tokio::sync::mpsc::Sender<XmppCommand>,
}
impl hyper::service::Service<Request<Body>> for ServiceCmd {
    type Response = Response<Body>;
    type Error = failure::Error;
    type Future = std::pin::Pin<
        Box<dyn std::future::Future<Output = Result<Self::Response, Self::Error>> + Send>,
    >;
    fn poll_ready(
        &mut self,
        _: &mut std::task::Context,
    ) -> std::task::Poll<Result<(), Self::Error>> {
        std::task::Poll::Ready(Ok(()))
    }
    fn call(&mut self, req: Request<Body>) -> 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(failure::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));
        let xmpp_pres_opt = req.headers().get("X-XMPP-Presence");
        let xmpp_pres_res: Result<xmpp_parsers::presence::Show, failure::Error> = xmpp_pres_opt
            .map_or_else(
                || Err(failure::format_err!("No X-XMPP-Presence header")),
                |show| {
                    std::str::from_utf8(show.as_bytes())
                        .map_err(std::convert::Into::into)
                        .and_then(|s| {
                            std::str::FromStr::from_str(s)
                                .map_err(|e| failure::format_err!("Incorrect presence {}", e))
                        })
                },
            );
        match (xmpp_muc_opt, xmpp_to_res, xmpp_pres_res) {
            (None, Err(err), Err(err2)) => {
                warn!("Unknown destination: {}", err);
                warn!("Unknown destination2: {}", err2);
                Box::pin(async move {
                    Response::builder()
                        .status(hyper::StatusCode::BAD_REQUEST)
                        .body(Body::from(format!(
                            "Unknown destination: {}\nUnknown destination2: {}",
                            err, err2,
                        )))
                        .map_err(std::convert::Into::into)
                })
            }
            (None, _, Ok(show)) => {
                info!("Got presence request. Reading body...");
                let mut cmd_send = self.cmd_send.clone();
                Box::pin(async move {
                    match body_to_string(req).await {
                        Ok(message) => {
                            match cmd_send.send(XmppCommand::Presence { show, message }).await {
                                Ok(_) => Response::builder()
                                    .body(Body::from(format!("Accepted")))
                                    .map_err(std::convert::Into::into),
                                Err(e) => {
                                    error!("Cann't send presence command: {}", e);
                                    Response::builder()
                                        .status(hyper::StatusCode::BAD_REQUEST)
                                        .body(Body::from(format!("Cann't get presence text")))
                                        .map_err(std::convert::Into::into)
                                }
                            }
                        }
                        Err(e) => Response::builder()
                            .status(hyper::StatusCode::BAD_REQUEST)
                            .body(Body::from(format!("Cann't get presence text")))
                            .map_err(std::convert::Into::into),
                    }
                })
            }
            (None, Ok(xmpp_to), _) => Box::pin(async {
                Response::builder()
                    .status(hyper::StatusCode::BAD_REQUEST)
                    .body(Body::from(format!("SOON")))
                    .map_err(std::convert::Into::into)
            }),
            (Some(Ok(muc_id)), _, Ok(show)) => Box::pin(async {
                Response::builder()
                    .status(hyper::StatusCode::BAD_REQUEST)
                    .body(Body::from(format!("SOON")))
                    .map_err(std::convert::Into::into)
            }),
            (Some(Ok(muc_id)), _, _) => Box::pin(async {
                Response::builder()
                    .status(hyper::StatusCode::BAD_REQUEST)
                    .body(Body::from(format!("SOON")))
                    .map_err(std::convert::Into::into)
            }),
            (Some(Err(err)), _, _) => Box::pin(async {
                Response::builder()
                    .status(hyper::StatusCode::BAD_REQUEST)
                    .body(Body::from(format!("SOON")))
                    .map_err(std::convert::Into::into)
            }),
        }
    }
}
struct MakeServiceCmd {
    cmd_send: tokio::sync::mpsc::Sender<XmppCommand>,
}
impl<T> hyper::service::Service<T> for MakeServiceCmd {
    type Response = ServiceCmd;
    type Error = failure::Error;
    type Future = std::pin::Pin<
        Box<dyn std::future::Future<Output = Result<Self::Response, Self::Error>> + Send>,
    >;
    fn poll_ready(
        &mut self,
        _: &mut std::task::Context,
    ) -> std::task::Poll<Result<(), Self::Error>> {
        std::task::Poll::Ready(Ok(()))
    }
    fn call(&mut self, _: T) -> Self::Future {
        let cmd_send = self.cmd_send.clone();
        let fut = async move { Ok(ServiceCmd { cmd_send }) };
        Box::pin(fut)
    }
}
/// Entry point of daemon
#[tokio::main]
pub async fn main() -> Result<(), failure::Error> {
    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 futures_util::future::FutureExt;
    let ctrl_c = async {
        tokio::signal::ctrl_c().await;
    }
    .shared();
    let (mut cmd_send, cmd_recv) = tokio::sync::mpsc::channel(10);
    let http_server = Server::bind(&config.http)
        .serve(MakeServiceCmd {
            cmd_send: cmd_send.clone(),
        })
        .with_graceful_shutdown(ctrl_c.clone());
    if let Some(ping) = config.account.ping {
        let mut ping = tokio::time::interval(std::time::Duration::from_secs(ping));
        let mut ctrl_c = ctrl_c.clone();
        tokio::spawn(async move {
            loop {
                let tick = ping.tick();
                tokio::pin!(tick);
                match futures_util::future::select(ctrl_c, tick).await {
                    futures_util::future::Either::Left((_, _)) => break,
                    futures_util::future::Either::Right((_, ctrl_c__)) => {
                        ctrl_c = ctrl_c__;
                        info!("Tick");
                        cmd_send.clone().send(XmppCommand::Ping).await;
                        cmd_send.send(XmppCommand::TimeoutCleanup).await;
                    }
                }
            }
        });
    }
    let xmpp_join = std::thread::Builder::new()
        .name("XMPP Thread".into())
        .spawn(move || -> Result<(), failure::Error> {
            let recv = stop_receiver(cmd_recv, ctrl_c.clone());
            // Launch single-threaded runtime
            let mut ctrt = tokio::runtime::Builder::new()
                .basic_scheduler()
                .enable_time()
                .enable_io()
                .build()?;
            let result = ctrt.block_on(xmpp_process(ctrl_c.clone(), recv, config.account));
            info!("Stopping xmpp thread");
            result
        })
        .expect("XMPP Thread");
    info!("Server started");
    http_server.await;
    info!("Server stopped");
    xmpp_join.join().unwrap();
    Ok(())
}

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

[0.6]

use std::collections::HashMap;
use std::fs::File;
use std::io;
use std::path::Path;
use serde_derive::Deserialize;
#[derive(Debug, Deserialize)]
pub struct Account {
    #[serde(deserialize_with = "deserialize_jid")]
    pub jid: xmpp_parsers::Jid,
    pub password: String,
    #[serde(default, deserialize_with = "deserialize_jid_map")]
    pub chatrooms: HashMap<String, xmpp_parsers::Jid>,
    pub ping: Option<u64>,
}
#[derive(Debug, Deserialize)]
pub struct Config {
    pub account: Account,
    pub http: std::net::SocketAddr,
}
impl Config {
    pub fn read<P: AsRef<Path>>(path: P) -> io::Result<Self> {
        use std::io::Read;
        let mut f = File::open(path)?;
        let mut buffer = String::new();
        f.read_to_string(&mut buffer)?;
        Ok(toml::from_str(&buffer).unwrap())
    }
}
fn deserialize_jid<'de, D>(deserializer: D) -> Result<xmpp_parsers::Jid, D::Error>
where
    D: serde::Deserializer<'de>,
{
    use serde::Deserialize;
    let s = String::deserialize(deserializer)?;
    std::str::FromStr::from_str(&s).map_err(serde::de::Error::custom)
}
fn deserialize_jid_map<'de, D>(
    deserializer: D,
) -> Result<HashMap<String, xmpp_parsers::Jid>, D::Error>
where
    D: serde::Deserializer<'de>,
{
    use serde::Deserialize;
    let s = HashMap::<String, String>::deserialize(deserializer)?;
    let size = s.len();
    s.into_iter()
        .map(|(k, v)| (k, std::str::FromStr::from_str(&v)))
        .take_while(|(_k, r)| r.is_ok())
        .fold(Ok(HashMap::with_capacity(size)), |res, (k, r)| match res {
            Ok(mut res) => match r {
                Ok(v) => {
                    res.insert(k, v);
                    Ok(res)
                }
                Err(e) => Err(e),
            },
            Err(e) => Err(e),
        })
        .map_err(serde::de::Error::custom)
}

File addition: rustfmt.toml (-rw-r--r--)

[1.0]

max_width = 100
reorder_imports = true
reorder_modules = true
use_field_init_shorthand = true
use_try_shorthand = true

File addition: bitbucket-pipelines.yml (-rw-r--r--)

[1.0]

# This is a sample build configuration for Rust.
# Check our guides at https://confluence.atlassian.com/x/5Q4SMw for more examples.
# Only use spaces to indent your .yml configuration.
# -----
# You can specify a custom docker image from Docker Hub as your build environment.
image: rust:latest
pipelines:
  default:
    - step:
        caches:
          - crates
        script:
#         - apt-get update
#         - apt-get install --no-install-recommends -y libsdl2-dev
          - rustc --verbose --version
          - cargo update -v
          - cargo build -v
          - cargo test -v
          - rustup component add clippy-preview
          - cargo clippy --all -v
    - step:
        name: Nightly
        image: rustlang/rust:nightly
        caches:
          - crates
        script:
#         - apt-get update
#         - apt-get install --no-install-recommends -y libsdl2-dev
          - rustup component add rustfmt-preview --toolchain nightly
          - rustc --verbose --version
          - cargo update -v
          - cargo build -v
          - cargo test -v
          - rustup component add clippy-preview --toolchain nightly
          - cargo clippy --all -v
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
          - cargo fmt -- --version
          - cargo fmt --all -- --check
================================
          - cargo fix --edition
<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
definitions:
  caches:
    crates: /usr/local/cargo/

File addition: README.md (-rw-r--r--)

[1.0]

# XMPP client daemon
## XMPP
### XMPP Core
Ensures granted subscription before delivering messages
### XEPs
#### XEP-0030: Service Discovery
Answers to `http://jabber.org/protocol/disco#info` query.
Answers to `http://jabber.org/protocol/disco#items` query.
#### XEP-0045: Multi-User Chat
Enters to all MUC in `account.chatrooms` at start.
#### XEP-0050: Ad-Hoc Commands
Answers empty commands list. (Awaiting for implementation in xmpp_parser).
#### XEP-0092: Software Version
Answers version.
#### XEP-0199: XMPP Ping
Sends ping each `account.ping` seconds to XMPP server.
Answers to incoming pings.
#### XEP-0203: Delayed Delivery
Ignores delayed messages.
## HTTP API
### 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"
```
### Setting status
```
curl http://localhost:8083/ -H "X-XMPP-Presence: chat" -d "Test"
```
### Setting status to MUC
```
curl http://localhost:8083/ -H "X-XMPP-Muc: smac" -H "X-XMPP-Presence: chat" -d "Test"
```

File addition: LICENSE-MIT (-rw-r--r--)

[1.0]

Permission is hereby granted, free of charge, to any
person obtaining a copy of this software and associated
documentation files (the "Software"), to deal in the
Software without restriction, including without
limitation the rights to use, copy, modify, merge,
publish, distribute, sublicense, and/or sell copies of
the Software, and to permit persons to whom the Software
is furnished to do so, subject to the following
conditions:
The above copyright notice and this permission notice
shall be included in all copies or substantial portions
of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
DEALINGS IN THE SOFTWARE.

File addition: LICENSE-APACHE (-rw-r--r--)

[1.0]

                              Apache License
                        Version 2.0, January 2004
                     http://www.apache.org/licenses/
TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
1. Definitions.
   "License" shall mean the terms and conditions for use, reproduction,
   and distribution as defined by Sections 1 through 9 of this document.
   "Licensor" shall mean the copyright owner or entity authorized by
   the copyright owner that is granting the License.
   "Legal Entity" shall mean the union of the acting entity and all
   other entities that control, are controlled by, or are under common
   control with that entity. For the purposes of this definition,
   "control" means (i) the power, direct or indirect, to cause the
   direction or management of such entity, whether by contract or
   otherwise, or (ii) ownership of fifty percent (50%) or more of the
   outstanding shares, or (iii) beneficial ownership of such entity.
   "You" (or "Your") shall mean an individual or Legal Entity
   exercising permissions granted by this License.
   "Source" form shall mean the preferred form for making modifications,
   including but not limited to software source code, documentation
   source, and configuration files.
   "Object" form shall mean any form resulting from mechanical
   transformation or translation of a Source form, including but
   not limited to compiled object code, generated documentation,
   and conversions to other media types.
   "Work" shall mean the work of authorship, whether in Source or
   Object form, made available under the License, as indicated by a
   copyright notice that is included in or attached to the work
   (an example is provided in the Appendix below).
   "Derivative Works" shall mean any work, whether in Source or Object
   form, that is based on (or derived from) the Work and for which the
   editorial revisions, annotations, elaborations, or other modifications
   represent, as a whole, an original work of authorship. For the purposes
   of this License, Derivative Works shall not include works that remain
   separable from, or merely link (or bind by name) to the interfaces of,
   the Work and Derivative Works thereof.
   "Contribution" shall mean any work of authorship, including
   the original version of the Work and any modifications or additions
   to that Work or Derivative Works thereof, that is intentionally
   submitted to Licensor for inclusion in the Work by the copyright owner
   or by an individual or Legal Entity authorized to submit on behalf of
   the copyright owner. For the purposes of this definition, "submitted"
   means any form of electronic, verbal, or written communication sent
   to the Licensor or its representatives, including but not limited to
   communication on electronic mailing lists, source code control systems,
   and issue tracking systems that are managed by, or on behalf of, the
   Licensor for the purpose of discussing and improving the Work, but
   excluding communication that is conspicuously marked or otherwise
   designated in writing by the copyright owner as "Not a Contribution."
   "Contributor" shall mean Licensor and any individual or Legal Entity
   on behalf of whom a Contribution has been received by Licensor and
   subsequently incorporated within the Work.
2. Grant of Copyright License. Subject to the terms and conditions of
   this License, each Contributor hereby grants to You a perpetual,
   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
   copyright license to reproduce, prepare Derivative Works of,
   publicly display, publicly perform, sublicense, and distribute the
   Work and such Derivative Works in Source or Object form.
3. Grant of Patent License. Subject to the terms and conditions of
   this License, each Contributor hereby grants to You a perpetual,
   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
   (except as stated in this section) patent license to make, have made,
   use, offer to sell, sell, import, and otherwise transfer the Work,
   where such license applies only to those patent claims licensable
   by such Contributor that are necessarily infringed by their
   Contribution(s) alone or by combination of their Contribution(s)
   with the Work to which such Contribution(s) was submitted. If You
   institute patent litigation against any entity (including a
   cross-claim or counterclaim in a lawsuit) alleging that the Work
   or a Contribution incorporated within the Work constitutes direct
   or contributory patent infringement, then any patent licenses
   granted to You under this License for that Work shall terminate
   as of the date such litigation is filed.
4. Redistribution. You may reproduce and distribute copies of the
   Work or Derivative Works thereof in any medium, with or without
   modifications, and in Source or Object form, provided that You
   meet the following conditions:
   (a) You must give any other recipients of the Work or
       Derivative Works a copy of this License; and
   (b) You must cause any modified files to carry prominent notices
       stating that You changed the files; and
   (c) You must retain, in the Source form of any Derivative Works
       that You distribute, all copyright, patent, trademark, and
       attribution notices from the Source form of the Work,
       excluding those notices that do not pertain to any part of
       the Derivative Works; and
   (d) If the Work includes a "NOTICE" text file as part of its
       distribution, then any Derivative Works that You distribute must
       include a readable copy of the attribution notices contained
       within such NOTICE file, excluding those notices that do not
       pertain to any part of the Derivative Works, in at least one
       of the following places: within a NOTICE text file distributed
       as part of the Derivative Works; within the Source form or
       documentation, if provided along with the Derivative Works; or,
       within a display generated by the Derivative Works, if and
       wherever such third-party notices normally appear. The contents
       of the NOTICE file are for informational purposes only and
       do not modify the License. You may add Your own attribution
       notices within Derivative Works that You distribute, alongside
       or as an addendum to the NOTICE text from the Work, provided
       that such additional attribution notices cannot be construed
       as modifying the License.
   You may add Your own copyright statement to Your modifications and
   may provide additional or different license terms and conditions
   for use, reproduction, or distribution of Your modifications, or
   for any such Derivative Works as a whole, provided Your use,
   reproduction, and distribution of the Work otherwise complies with
   the conditions stated in this License.
5. Submission of Contributions. Unless You explicitly state otherwise,
   any Contribution intentionally submitted for inclusion in the Work
   by You to the Licensor shall be under the terms and conditions of
   this License, without any additional terms or conditions.
   Notwithstanding the above, nothing herein shall supersede or modify
   the terms of any separate license agreement you may have executed
   with Licensor regarding such Contributions.
6. Trademarks. This License does not grant permission to use the trade
   names, trademarks, service marks, or product names of the Licensor,
   except as required for reasonable and customary use in describing the
   origin of the Work and reproducing the content of the NOTICE file.
7. Disclaimer of Warranty. Unless required by applicable law or
   agreed to in writing, Licensor provides the Work (and each
   Contributor provides its Contributions) on an "AS IS" BASIS,
   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
   implied, including, without limitation, any warranties or conditions
   of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
   PARTICULAR PURPOSE. You are solely responsible for determining the
   appropriateness of using or redistributing the Work and assume any
   risks associated with Your exercise of permissions under this License.
8. Limitation of Liability. In no event and under no legal theory,
   whether in tort (including negligence), contract, or otherwise,
   unless required by applicable law (such as deliberate and grossly
   negligent acts) or agreed to in writing, shall any Contributor be
   liable to You for damages, including any direct, indirect, special,
   incidental, or consequential damages of any character arising as a
   result of this License or out of the use or inability to use the
   Work (including but not limited to damages for loss of goodwill,
   work stoppage, computer failure or malfunction, or any and all
   other commercial damages or losses), even if such Contributor
   has been advised of the possibility of such damages.
9. Accepting Warranty or Additional Liability. While redistributing
   the Work or Derivative Works thereof, You may choose to offer,
   and charge a fee for, acceptance of support, warranty, indemnity,
   or other liability obligations and/or rights consistent with this
   License. However, in accepting such obligations, You may act only
   on Your own behalf and on Your sole responsibility, not on behalf
   of any other Contributor, and only if You agree to indemnify,
   defend, and hold each Contributor harmless for any liability
   incurred by, or claims asserted against, such Contributor by reason
   of your accepting any such warranty or additional liability.
END OF TERMS AND CONDITIONS
APPENDIX: How to apply the Apache License to your work.
   To apply the Apache License to your work, attach the following
   boilerplate notice, with the fields enclosed by brackets "[]"
   replaced with your own identifying information. (Don't include
   the brackets!)  The text should be enclosed in the appropriate
   comment syntax for the file format. We also recommend that a
   file or class name and description of purpose be included on the
   same "printed page" as the copyright notice for easier
   identification within third-party archives.
Copyright [yyyy] [name of copyright owner]
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
	http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.

File addition: Cargo.toml (-rw-r--r--)

[1.0]

[package]
name = "sendxmppd-rust"
version = "0.1.0"
authors = ["O01eg <o01eg@yandex.ru>"]
license = "MIT/Apache-2.0"
repository = "https://bitbucket.org/O01eg/sendxmppd-rust"
edition = "2018"
[dependencies]
futures-util = "0.3.5"
tokio-xmpp = { git = "https://gitlab.com/xmpp-rs/xmpp-rs", branch = "main" }
failure = "0.1.8"
hyper = "0.13"
toml = "0.5"
serde = "1.0"
serde_derive = "1.0"
clap = "2.33"
log = "0.4"
env_logger = "0.7"
xmpp-parsers = "0.17"
minidom = "=0.12.0" # xmpp-parsers
lazy_static = "1.4.0" # ToDo: remove after const fn will be powerfull enough
pin-project = "0.4"
[dependencies.tokio]
version = "0.2"
features = ["signal", "sync", "rt-threaded"]
[patch.crates-io]
xmpp-parsers = { git = "https://gitlab.com/xmpp-rs/xmpp-rs", branch = "main" }
minidom = { git = "https://gitlab.com/xmpp-rs/xmpp-rs", branch = "main" }

File addition: Cargo.lock (-rw-r--r--)

[1.0]

# This file is automatically @generated by Cargo.
# It is not intended for manual editing.
[[package]]
name = "addr2line"
version = "0.13.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "1b6a2d3371669ab3ca9797670853d61402b03d0b4b9ebf33d677dfa720203072"
dependencies = [
 "gimli",
]
[[package]]
name = "adler"
version = "0.2.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ee2a4ec343196209d6594e19543ae87a39f96d5534d7174822a3ad825dd6ed7e"
[[package]]
name = "aho-corasick"
version = "0.7.13"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "043164d8ba5c4c3035fec9bbee8647c0261d788f3474306f93bb65901cae0e86"
dependencies = [
 "memchr",
]
[[package]]
name = "ansi_term"
version = "0.11.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ee49baf6cb617b853aa8d93bf420db2383fab46d314482ca2803b40d5fde979b"
dependencies = [
 "winapi 0.3.9",
]
[[package]]
name = "arc-swap"
version = "0.4.7"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "4d25d88fd6b8041580a654f9d0c581a047baee2b3efee13275f2fc392fc75034"
[[package]]
name = "async-trait"
version = "0.1.41"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "b246867b8b3b6ae56035f1eb1ed557c1d8eae97f0d53696138a50fa0e3a3b8c0"
dependencies = [
 "proc-macro2",
 "quote",
 "syn",
]
[[package]]
name = "atty"
version = "0.2.14"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d9b39be18770d11421cdb1b9947a45dd3f37e93092cbf377614828a319d5fee8"
dependencies = [
 "hermit-abi",
 "libc",
 "winapi 0.3.9",
]
[[package]]
name = "autocfg"
version = "1.0.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "cdb031dd78e28731d87d56cc8ffef4a8f36ca26c38fe2de700543e627f8a464a"
[[package]]
name = "backtrace"
version = "0.3.52"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f813291114c186a042350e787af10c26534601062603d888be110f59f85ef8fa"
dependencies = [
 "addr2line",
 "cfg-if",
 "libc",
 "miniz_oxide",
 "object",
 "rustc-demangle",
]
[[package]]
name = "base64"
version = "0.10.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "0b25d992356d2eb0ed82172f5248873db5560c4721f564b13cb5193bda5e668e"
dependencies = [
 "byteorder",
]
[[package]]
name = "base64"
version = "0.12.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "3441f0f7b02788e948e47f457ca01f1d7e6d92c693bc132c22b087d3141c03ff"
[[package]]
name = "bitflags"
version = "1.2.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "cf1de2fe8c75bc145a2f577add951f8134889b4795d47466a54a5c846d691693"
[[package]]
name = "blake2"
version = "0.9.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "84ce5b6108f8e154604bd4eb76a2f726066c3464d5a552a4229262a18c9bb471"
dependencies = [
 "byte-tools",
 "byteorder",
 "crypto-mac 0.8.0",
 "digest 0.9.0",
 "opaque-debug 0.2.3",
]
[[package]]
name = "block-buffer"
version = "0.7.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "c0940dc441f31689269e10ac70eb1002a3a1d3ad1390e030043662eb7fe4688b"
dependencies = [
 "block-padding 0.1.5",
 "byte-tools",
 "byteorder",
 "generic-array 0.12.3",
]
[[package]]
name = "block-buffer"
version = "0.9.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "4152116fd6e9dadb291ae18fc1ec3575ed6d84c29642d97890f4b4a3417297e4"
dependencies = [
 "block-padding 0.2.1",
 "generic-array 0.14.4",
]
[[package]]
name = "block-padding"
version = "0.1.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "fa79dedbb091f449f1f39e53edf88d5dbe95f895dae6135a8d7b881fb5af73f5"
dependencies = [
 "byte-tools",
]
[[package]]
name = "block-padding"
version = "0.2.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "8d696c370c750c948ada61c69a0ee2cbbb9c50b1019ddb86d9317157a99c2cae"
[[package]]
name = "byte-tools"
version = "0.3.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "e3b5ca7a04898ad4bcd41c90c5285445ff5b791899bb1b0abdd2a2aa791211d7"
[[package]]
name = "byteorder"
version = "1.3.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "08c48aae112d48ed9f069b33538ea9e3e90aa263cfa3d1c24309612b1f7472de"
[[package]]
name = "bytes"
version = "0.5.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "0e4cec68f03f32e44924783795810fa50a7035d8c8ebe78580ad7e6c703fba38"
[[package]]
name = "cc"
version = "1.0.61"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ed67cbde08356238e75fc4656be4749481eeffb09e19f320a25237d5221c985d"
[[package]]
name = "cfg-if"
version = "0.1.10"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "4785bdd1c96b2a846b2bd7cc02e86b6b3dbf14e7e53446c4f54c92a361040822"
[[package]]
name = "chrono"
version = "0.4.19"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "670ad68c9088c2a963aaa298cb369688cf3f9465ce5e2d4ca10e6e0098a1ce73"
dependencies = [
 "libc",
 "num-integer",
 "num-traits",
 "time",
 "winapi 0.3.9",
]
[[package]]
name = "clap"
version = "2.33.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "37e58ac78573c40708d45522f0d80fa2f01cc4f9b4e2bf749807255454312002"
dependencies = [
 "ansi_term",
 "atty",
 "bitflags",
 "strsim",
 "textwrap",
 "unicode-width",
 "vec_map",
]
[[package]]
name = "cloudabi"
version = "0.0.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ddfc5b9aa5d4507acaf872de71051dfd0e309860e88966e1051e462a077aac4f"
dependencies = [
 "bitflags",
]
[[package]]
name = "core-foundation"
version = "0.7.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "57d24c7a13c43e870e37c1556b74555437870a04514f7685f5b354e090567171"
dependencies = [
 "core-foundation-sys",
 "libc",
]
[[package]]
name = "core-foundation-sys"
version = "0.7.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "b3a71ab494c0b5b860bdc8407ae08978052417070c2ced38573a9157ad75b8ac"
[[package]]
name = "cpuid-bool"
version = "0.1.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "8aebca1129a03dc6dc2b127edd729435bbc4a37e1d5f4d7513165089ceb02634"
[[package]]
name = "crypto-mac"
version = "0.7.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "4434400df11d95d556bac068ddfedd482915eb18fe8bea89bc80b6e4b1c179e5"
dependencies = [
 "generic-array 0.12.3",
 "subtle 1.0.0",
]
[[package]]
name = "crypto-mac"
version = "0.8.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "b584a330336237c1eecd3e94266efb216c56ed91225d634cb2991c5f3fd1aeab"
dependencies = [
 "generic-array 0.14.4",
 "subtle 2.3.0",
]
[[package]]
name = "digest"
version = "0.8.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f3d0c8c8752312f9713efd397ff63acb9f85585afbf179282e720e7704954dd5"
dependencies = [
 "generic-array 0.12.3",
]
[[package]]
name = "digest"
version = "0.9.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d3dd60d1080a57a05ab032377049e0591415d2b31afd7028356dbf3cc6dcb066"
dependencies = [
 "generic-array 0.14.4",
]
[[package]]
name = "enum-as-inner"
version = "0.3.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "7c5f0096a91d210159eceb2ff5e1c4da18388a170e1e3ce948aac9c8fdbbf595"
dependencies = [
 "heck",
 "proc-macro2",
 "quote",
 "syn",
]
[[package]]
name = "env_logger"
version = "0.7.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "44533bbbb3bb3c1fa17d9f2e4e38bbbaf8396ba82193c4cb1b6445d711445d36"
dependencies = [
 "atty",
 "humantime",
 "log",
 "regex",
 "termcolor",
]
[[package]]
name = "failure"
version = "0.1.8"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d32e9bd16cc02eae7db7ef620b392808b89f6a5e16bb3497d159c6b92a0f4f86"
dependencies = [
 "backtrace",
 "failure_derive",
]
[[package]]
name = "failure_derive"
version = "0.1.8"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "aa4da3c766cd7a0db8242e326e9e4e081edd567072893ed320008189715366a4"
dependencies = [
 "proc-macro2",
 "quote",
 "syn",
 "synstructure",
]
[[package]]
name = "fake-simd"
version = "0.1.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "e88a8acf291dafb59c2d96e8f59828f3838bb1a70398823ade51a84de6a6deed"
[[package]]
name = "fnv"
version = "1.0.7"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "3f9eec918d3f24069decb9af1554cad7c880e2da24a9afd88aca000531ab82c1"
[[package]]
name = "foreign-types"
version = "0.3.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f6f339eb8adc052cd2ca78910fda869aefa38d22d5cb648e6485e4d3fc06f3b1"
dependencies = [
 "foreign-types-shared",
]
[[package]]
name = "foreign-types-shared"
version = "0.1.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "00b0228411908ca8685dba7fc2cdd70ec9990a6e753e89b6ac91a84c40fbaf4b"
[[package]]
name = "fuchsia-cprng"
version = "0.1.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "a06f77d526c1a601b7c4cdd98f54b5eaabffc14d5f2f0296febdc7f357c6d3ba"
[[package]]
name = "fuchsia-zircon"
version = "0.3.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "2e9763c69ebaae630ba35f74888db465e49e259ba1bc0eda7d06f4a067615d82"
dependencies = [
 "bitflags",
 "fuchsia-zircon-sys",
]
[[package]]
name = "fuchsia-zircon-sys"
version = "0.3.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "3dcaa9ae7725d12cdb85b3ad99a434db70b468c09ded17e012d86b5c1010f7a7"
[[package]]
name = "futf"
version = "0.1.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "7c9c1ce3fa9336301af935ab852c437817d14cd33690446569392e65170aac3b"
dependencies = [
 "mac",
 "new_debug_unreachable",
]
[[package]]
name = "futures"
version = "0.3.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "5d8e3078b7b2a8a671cb7a3d17b4760e4181ea243227776ba83fd043b4ca034e"
dependencies = [
 "futures-channel",
 "futures-core",
 "futures-executor",
 "futures-io",
 "futures-sink",
 "futures-task",
 "futures-util",
]
[[package]]
name = "futures-channel"
version = "0.3.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "a7a4d35f7401e948629c9c3d6638fb9bf94e0b2121e96c3b428cc4e631f3eb74"
dependencies = [
 "futures-core",
 "futures-sink",
]
[[package]]
name = "futures-core"
version = "0.3.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d674eaa0056896d5ada519900dbf97ead2e46a7b6621e8160d79e2f2e1e2784b"
[[package]]
name = "futures-executor"
version = "0.3.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "cc709ca1da6f66143b8c9bec8e6260181869893714e9b5a490b169b0414144ab"
dependencies = [
 "futures-core",
 "futures-task",
 "futures-util",
]
[[package]]
name = "futures-io"
version = "0.3.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "5fc94b64bb39543b4e432f1790b6bf18e3ee3b74653c5449f63310e9a74b123c"
[[package]]
name = "futures-macro"
version = "0.3.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f57ed14da4603b2554682e9f2ff3c65d7567b53188db96cb71538217fc64581b"
dependencies = [
 "proc-macro-hack",
 "proc-macro2",
 "quote",
 "syn",
]
[[package]]
name = "futures-sink"
version = "0.3.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "0d8764258ed64ebc5d9ed185cf86a95db5cac810269c5d20ececb32e0088abbd"
[[package]]
name = "futures-task"
version = "0.3.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "4dd26820a9f3637f1302da8bceba3ff33adbe53464b54ca24d4e2d4f1db30f94"
dependencies = [
 "once_cell",
]
[[package]]
name = "futures-util"
version = "0.3.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "8a894a0acddba51a2d49a6f4263b1e64b8c579ece8af50fa86503d52cd1eea34"
dependencies = [
 "futures-channel",
 "futures-core",
 "futures-io",
 "futures-macro",
 "futures-sink",
 "futures-task",
 "memchr",
 "pin-project",
 "pin-utils",
 "proc-macro-hack",
 "proc-macro-nested",
 "slab",
]
[[package]]
name = "generic-array"
version = "0.12.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "c68f0274ae0e023facc3c97b2e00f076be70e254bc851d972503b328db79b2ec"
dependencies = [
 "typenum",
]
[[package]]
name = "generic-array"
version = "0.14.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "501466ecc8a30d1d3b7fc9229b122b2ce8ed6e9d9223f1138d4babb253e51817"
dependencies = [
 "typenum",
 "version_check",
]
[[package]]
name = "getrandom"
version = "0.1.15"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "fc587bc0ec293155d5bfa6b9891ec18a1e330c234f896ea47fbada4cadbe47e6"
dependencies = [
 "cfg-if",
 "libc",
 "wasi 0.9.0+wasi-snapshot-preview1",
]
[[package]]
name = "gimli"
version = "0.22.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "aaf91faf136cb47367fa430cd46e37a788775e7fa104f8b4bcb3861dc389b724"
[[package]]
name = "h2"
version = "0.2.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "993f9e0baeed60001cf565546b0d3dbe6a6ad23f2bd31644a133c641eccf6d53"
dependencies = [
 "bytes",
 "fnv",
 "futures-core",
 "futures-sink",
 "futures-util",
 "http",
 "indexmap",
 "slab",
 "tokio",
 "tokio-util",
 "tracing",
]
[[package]]
name = "hashbrown"
version = "0.9.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d7afe4a420e3fe79967a00898cc1f4db7c8a49a9333a29f8a4bd76a253d5cd04"
[[package]]
name = "heck"
version = "0.3.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "20564e78d53d2bb135c343b3f47714a56af2061f1c928fdb541dc7b9fdd94205"
dependencies = [
 "unicode-segmentation",
]
[[package]]
name = "hermit-abi"
version = "0.1.17"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "5aca5565f760fb5b220e499d72710ed156fdb74e631659e99377d9ebfbd13ae8"
dependencies = [
 "libc",
]
[[package]]
name = "hmac"
version = "0.7.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "5dcb5e64cda4c23119ab41ba960d1e170a774c8e4b9d9e6a9bc18aabf5e59695"
dependencies = [
 "crypto-mac 0.7.0",
 "digest 0.8.1",
]
[[package]]
name = "hostname"
version = "0.3.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "3c731c3e10504cc8ed35cfe2f1db4c9274c3d35fa486e3b31df46f068ef3e867"
dependencies = [
 "libc",
 "match_cfg",
 "winapi 0.3.9",
]
[[package]]
name = "http"
version = "0.2.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "28d569972648b2c512421b5f2a405ad6ac9666547189d0c5477a3f200f3e02f9"
dependencies = [
 "bytes",
 "fnv",
 "itoa",
]
[[package]]
name = "http-body"
version = "0.3.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "13d5ff830006f7646652e057693569bfe0d51760c0085a071769d142a205111b"
dependencies = [
 "bytes",
 "http",
]
[[package]]
name = "httparse"
version = "1.3.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "cd179ae861f0c2e53da70d892f5f3029f9594be0c41dc5269cd371691b1dc2f9"
[[package]]
name = "httpdate"
version = "0.3.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "494b4d60369511e7dea41cf646832512a94e542f68bb9c49e54518e0f468eb47"
[[package]]
name = "humantime"
version = "1.3.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "df004cfca50ef23c36850aaaa59ad52cc70d0e90243c3c7737a4dd32dc7a3c4f"
dependencies = [
 "quick-error",
]
[[package]]
name = "hyper"
version = "0.13.8"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "2f3afcfae8af5ad0576a31e768415edb627824129e8e5a29b8bfccb2f234e835"
dependencies = [
 "bytes",
 "futures-channel",
 "futures-core",
 "futures-util",
 "h2",
 "http",
 "http-body",
 "httparse",
 "httpdate",
 "itoa",
 "pin-project",
 "socket2",
 "tokio",
 "tower-service",
 "tracing",
 "want",
]
[[package]]
name = "idna"
version = "0.2.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "02e2673c30ee86b5b96a9cb52ad15718aa1f966f5ab9ad54a8b95d5ca33120a9"
dependencies = [
 "matches",
 "unicode-bidi",
 "unicode-normalization",
]
[[package]]
name = "indexmap"
version = "1.6.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "55e2e4c765aa53a0424761bf9f41aa7a6ac1efa87238f59560640e27fca028f2"
dependencies = [
 "autocfg",
 "hashbrown",
]
[[package]]
name = "iovec"
version = "0.1.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "b2b3ea6ff95e175473f8ffe6a7eb7c00d054240321b84c57051175fe3c1e075e"
dependencies = [
 "libc",
]
[[package]]
name = "ipconfig"
version = "0.2.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f7e2f18aece9709094573a9f24f483c4f65caa4298e2f7ae1b71cc65d853fad7"
dependencies = [
 "socket2",
 "widestring",
 "winapi 0.3.9",
 "winreg",
]
[[package]]
name = "itoa"
version = "0.4.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "dc6f3ad7b9d11a0c00842ff8de1b60ee58661048eb8049ed33c73594f359d7e6"
[[package]]
name = "jid"
version = "0.9.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "3d9f987c3ff1c2c7d477c9e0a3dc25cc58ea97692b19a53018089109445b4ab3"
dependencies = [
 "minidom",
]
[[package]]
name = "keccak"
version = "0.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "67c21572b4949434e4fc1e1978b99c5f77064153c59d998bf13ecd96fb5ecba7"
[[package]]
name = "kernel32-sys"
version = "0.2.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "7507624b29483431c0ba2d82aece8ca6cdba9382bff4ddd0f7490560c056098d"
dependencies = [
 "winapi 0.2.8",
 "winapi-build",
]
[[package]]
name = "lazy_static"
version = "1.4.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "e2abad23fbc42b3700f2f279844dc832adb2b2eb069b2df918f455c4e18cc646"
[[package]]
name = "libc"
version = "0.2.79"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "2448f6066e80e3bfc792e9c98bf705b4b0fc6e8ef5b43e5889aff0eaa9c58743"
[[package]]
name = "linked-hash-map"
version = "0.5.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "8dd5a6d5999d9907cda8ed67bbd137d3af8085216c2ac62de5be860bd41f304a"
[[package]]
name = "log"
version = "0.4.11"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "4fabed175da42fed1fa0746b0ea71f412aa9d35e76e95e59b192c64b9dc2bf8b"
dependencies = [
 "cfg-if",
]
[[package]]
name = "lru-cache"
version = "0.1.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "31e24f1ad8321ca0e8a1e0ac13f23cb668e6f5466c2c57319f6a5cf1cc8e3b1c"
dependencies = [
 "linked-hash-map",
]
[[package]]
name = "mac"
version = "0.1.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "c41e0c4fef86961ac6d6f8a82609f55f31b05e4fce149ac5710e439df7619ba4"
[[package]]
name = "markup5ever"
version = "0.10.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "aae38d669396ca9b707bfc3db254bc382ddb94f57cc5c235f34623a669a01dab"
dependencies = [
 "log",
 "phf",
 "phf_codegen",
 "serde",
 "serde_derive",
 "serde_json",
 "string_cache",
 "string_cache_codegen",
 "tendril",
]
[[package]]
name = "match_cfg"
version = "0.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ffbee8634e0d45d258acb448e7eaab3fce7a0a467395d4d9f228e3c1f01fb2e4"
[[package]]
name = "matches"
version = "0.1.8"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "7ffc5c5338469d4d3ea17d269fa8ea3512ad247247c30bd2df69e68309ed0a08"
[[package]]
name = "memchr"
version = "2.3.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "3728d817d99e5ac407411fa471ff9800a778d88a24685968b36824eaf4bee400"
[[package]]
name = "minidom"
version = "0.12.0"
source = "git+https://gitlab.com/xmpp-rs/xmpp-rs?branch=main#e1f2e2653a9c14409a04bc4fcd7b10ce842871ea"
dependencies = [
 "quick-xml",
]
[[package]]
name = "miniz_oxide"
version = "0.4.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "0f2d26ec3309788e423cfbf68ad1800f061638098d76a83681af979dc4eda19d"
dependencies = [
 "adler",
 "autocfg",
]
[[package]]
name = "mio"
version = "0.6.22"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "fce347092656428bc8eaf6201042cb551b8d67855af7374542a92a0fbfcac430"
dependencies = [
 "cfg-if",
 "fuchsia-zircon",
 "fuchsia-zircon-sys",
 "iovec",
 "kernel32-sys",
 "libc",
 "log",
 "miow",
 "net2",
 "slab",
 "winapi 0.2.8",
]
[[package]]
name = "mio-uds"
version = "0.6.8"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "afcb699eb26d4332647cc848492bbc15eafb26f08d0304550d5aa1f612e066f0"
dependencies = [
 "iovec",
 "libc",
 "mio",
]
[[package]]
name = "miow"
version = "0.2.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "8c1f2f3b1cf331de6896aabf6e9d55dca90356cc9960cca7eaaf408a355ae919"
dependencies = [
 "kernel32-sys",
 "net2",
 "winapi 0.2.8",
 "ws2_32-sys",
]
[[package]]
name = "native-tls"
version = "0.2.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "2b0d88c06fe90d5ee94048ba40409ef1d9315d86f6f38c2efdaad4fb50c58b2d"
dependencies = [
 "lazy_static",
 "libc",
 "log",
 "openssl",
 "openssl-probe",
 "openssl-sys",
 "schannel",
 "security-framework",
 "security-framework-sys",
 "tempfile",
]
[[package]]
name = "net2"
version = "0.2.35"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "3ebc3ec692ed7c9a255596c67808dee269f64655d8baf7b4f0638e51ba1d6853"
dependencies = [
 "cfg-if",
 "libc",
 "winapi 0.3.9",
]
[[package]]
name = "new_debug_unreachable"
version = "1.0.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "e4a24736216ec316047a1fc4252e27dabb04218aa4a3f37c6e7ddbf1f9782b54"
[[package]]
name = "num-integer"
version = "0.1.43"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "8d59457e662d541ba17869cf51cf177c0b5f0cbf476c66bdc90bf1edac4f875b"
dependencies = [
 "autocfg",
 "num-traits",
]
[[package]]
name = "num-traits"
version = "0.2.12"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ac267bcc07f48ee5f8935ab0d24f316fb722d7a1292e2913f0cc196b29ffd611"
dependencies = [
 "autocfg",
]
[[package]]
name = "num_cpus"
version = "1.13.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "05499f3756671c15885fee9034446956fff3f243d6077b91e5767df161f766b3"
dependencies = [
 "hermit-abi",
 "libc",
]
[[package]]
name = "object"
version = "0.20.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "1ab52be62400ca80aa00285d25253d7f7c437b7375c4de678f5405d3afe82ca5"
[[package]]
name = "once_cell"
version = "1.4.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "260e51e7efe62b592207e9e13a68e43692a7a279171d6ba57abd208bf23645ad"
[[package]]
name = "opaque-debug"
version = "0.2.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "2839e79665f131bdb5782e51f2c6c9599c133c6098982a54c794358bf432529c"
[[package]]
name = "opaque-debug"
version = "0.3.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "624a8340c38c1b80fd549087862da4ba43e08858af025b236e509b6649fc13d5"
[[package]]
name = "openssl"
version = "0.10.30"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "8d575eff3665419f9b83678ff2815858ad9d11567e082f5ac1814baba4e2bcb4"
dependencies = [
 "bitflags",
 "cfg-if",
 "foreign-types",
 "lazy_static",
 "libc",
 "openssl-sys",
]
[[package]]
name = "openssl-probe"
version = "0.1.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "77af24da69f9d9341038eba93a073b1fdaaa1b788221b00a69bce9e762cb32de"
[[package]]
name = "openssl-sys"
version = "0.9.58"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "a842db4709b604f0fe5d1170ae3565899be2ad3d9cbc72dedc789ac0511f78de"
dependencies = [
 "autocfg",
 "cc",
 "libc",
 "pkg-config",
 "vcpkg",
]
[[package]]
name = "pbkdf2"
version = "0.3.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "006c038a43a45995a9670da19e67600114740e8511d4333bf97a56e66a7542d9"
dependencies = [
 "byteorder",
 "crypto-mac 0.7.0",
]
[[package]]
name = "percent-encoding"
version = "2.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d4fd5641d01c8f18a23da7b6fe29298ff4b55afcccdf78973b24cf3175fee32e"
[[package]]
name = "phf"
version = "0.8.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "3dfb61232e34fcb633f43d12c58f83c1df82962dcdfa565a4e866ffc17dafe12"
dependencies = [
 "phf_shared",
]
[[package]]
name = "phf_codegen"
version = "0.8.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "cbffee61585b0411840d3ece935cce9cb6321f01c45477d30066498cd5e1a815"
dependencies = [
 "phf_generator",
 "phf_shared",
]
[[package]]
name = "phf_generator"
version = "0.8.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "17367f0cc86f2d25802b2c26ee58a7b23faeccf78a396094c13dced0d0182526"
dependencies = [
 "phf_shared",
 "rand",
]
[[package]]
name = "phf_shared"
version = "0.8.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "c00cf8b9eafe68dde5e9eaa2cef8ee84a9336a47d566ec55ca16589633b65af7"
dependencies = [
 "siphasher",
]
[[package]]
name = "pin-project"
version = "0.4.26"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "13fbdfd6bdee3dc9be46452f86af4a4072975899cf8592466668620bebfbcc17"
dependencies = [
 "pin-project-internal",
]
[[package]]
name = "pin-project-internal"
version = "0.4.26"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "c82fb1329f632c3552cf352d14427d57a511b1cf41db93b3a7d77906a82dcc8e"
dependencies = [
 "proc-macro2",
 "quote",
 "syn",
]
[[package]]
name = "pin-project-lite"
version = "0.1.10"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "e555d9e657502182ac97b539fb3dae8b79cda19e3e4f8ffb5e8de4f18df93c95"
[[package]]
name = "pin-utils"
version = "0.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "8b870d8c151b6f2fb93e84a13146138f05d02ed11c7e7c54f8826aaaf7c9f184"
[[package]]
name = "pkg-config"
version = "0.3.18"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d36492546b6af1463394d46f0c834346f31548646f6ba10849802c9c9a27ac33"
[[package]]
name = "ppv-lite86"
version = "0.2.9"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "c36fa947111f5c62a733b652544dd0016a43ce89619538a8ef92724a6f501a20"
[[package]]
name = "precomputed-hash"
version = "0.1.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "925383efa346730478fb4838dbe9137d2a47675ad789c546d150a6e1dd4ab31c"
[[package]]
name = "proc-macro-hack"
version = "0.5.18"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "99c605b9a0adc77b7211c6b1f722dcb613d68d66859a44f3d485a6da332b0598"
[[package]]
name = "proc-macro-nested"
version = "0.1.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "eba180dafb9038b050a4c280019bbedf9f2467b61e5d892dcad585bb57aadc5a"
[[package]]
name = "proc-macro2"
version = "1.0.24"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "1e0704ee1a7e00d7bb417d0770ea303c1bccbabf0ef1667dae92b5967f5f8a71"
dependencies = [
 "unicode-xid",
]
[[package]]
name = "quick-error"
version = "1.2.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "a1d01941d82fa2ab50be1e79e6714289dd7cde78eba4c074bc5a4374f650dfe0"
[[package]]
name = "quick-xml"
version = "0.18.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "3cc440ee4802a86e357165021e3e255a9143724da31db1e2ea540214c96a0f82"
dependencies = [
 "memchr",
]
[[package]]
name = "quote"
version = "1.0.7"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "aa563d17ecb180e500da1cfd2b028310ac758de548efdd203e18f283af693f37"
dependencies = [
 "proc-macro2",
]
[[package]]
name = "rand"
version = "0.7.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "6a6b1679d49b24bbfe0c803429aa1874472f50d9b363131f0e89fc356b544d03"
dependencies = [
 "getrandom",
 "libc",
 "rand_chacha",
 "rand_core 0.5.1",
 "rand_hc",
 "rand_pcg",
]
[[package]]
name = "rand_chacha"
version = "0.2.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f4c8ed856279c9737206bf725bf36935d8666ead7aa69b52be55af369d193402"
dependencies = [
 "ppv-lite86",
 "rand_core 0.5.1",
]
[[package]]
name = "rand_core"
version = "0.3.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "7a6fdeb83b075e8266dcc8762c22776f6877a63111121f5f8c7411e5be7eed4b"
dependencies = [
 "rand_core 0.4.2",
]
[[package]]
name = "rand_core"
version = "0.4.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "9c33a3c44ca05fa6f1807d8e6743f3824e8509beca625669633be0acbdf509dc"
[[package]]
name = "rand_core"
version = "0.5.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "90bde5296fc891b0cef12a6d03ddccc162ce7b2aff54160af9338f8d40df6d19"
dependencies = [
 "getrandom",
]
[[package]]
name = "rand_hc"
version = "0.2.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ca3129af7b92a17112d59ad498c6f81eaf463253766b90396d39ea7a39d6613c"
dependencies = [
 "rand_core 0.5.1",
]
[[package]]
name = "rand_os"
version = "0.1.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "7b75f676a1e053fc562eafbb47838d67c84801e38fc1ba459e8f180deabd5071"
dependencies = [
 "cloudabi",
 "fuchsia-cprng",
 "libc",
 "rand_core 0.4.2",
 "rdrand",
 "winapi 0.3.9",
]
[[package]]
name = "rand_pcg"
version = "0.2.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "16abd0c1b639e9eb4d7c50c0b8100b0d0f849be2349829c740fe8e6eb4816429"
dependencies = [
 "rand_core 0.5.1",
]
[[package]]
name = "rdrand"
version = "0.4.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "678054eb77286b51581ba43620cc911abf02758c91f93f479767aed0f90458b2"
dependencies = [
 "rand_core 0.3.1",
]
[[package]]
name = "redox_syscall"
version = "0.1.57"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "41cc0f7e4d5d4544e8861606a285bb08d3e70712ccc7d2b84d7c0ccfaf4b05ce"
[[package]]
name = "regex"
version = "1.3.9"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "9c3780fcf44b193bc4d09f36d2a3c87b251da4a046c87795a0d35f4f927ad8e6"
dependencies = [
 "aho-corasick",
 "memchr",
 "regex-syntax",
 "thread_local",
]
[[package]]
name = "regex-syntax"
version = "0.6.18"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "26412eb97c6b088a6997e05f69403a802a92d520de2f8e63c2b65f9e0f47c4e8"
[[package]]
name = "remove_dir_all"
version = "0.5.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "3acd125665422973a33ac9d3dd2df85edad0f4ae9b00dafb1a05e43a9f5ef8e7"
dependencies = [
 "winapi 0.3.9",
]
[[package]]
name = "resolv-conf"
version = "0.6.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "11834e137f3b14e309437a8276714eed3a80d1ef894869e510f2c0c0b98b9f4a"
dependencies = [
 "hostname",
 "quick-error",
]
[[package]]
name = "rustc-demangle"
version = "0.1.17"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "b2610b7f643d18c87dff3b489950269617e6601a51f1f05aa5daefee36f64f0b"
[[package]]
name = "ryu"
version = "1.0.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "71d301d4193d031abdd79ff7e3dd721168a9572ef3fe51a1517aba235bd8f86e"
[[package]]
name = "sasl"
version = "0.4.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "e457758c85b736bbad56dc099406cd2a9c19554cf81880dba7a51d092929e600"
dependencies = [
 "base64 0.10.1",
 "hmac",
 "pbkdf2",
 "rand_os",
 "sha-1 0.8.2",
 "sha2 0.8.2",
]
[[package]]
name = "schannel"
version = "0.1.19"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "8f05ba609c234e60bee0d547fe94a4c7e9da733d1c962cf6e59efa4cd9c8bc75"
dependencies = [
 "lazy_static",
 "winapi 0.3.9",
]
[[package]]
name = "security-framework"
version = "0.4.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "64808902d7d99f78eaddd2b4e2509713babc3dc3c85ad6f4c447680f3c01e535"
dependencies = [
 "bitflags",
 "core-foundation",
 "core-foundation-sys",
 "libc",
 "security-framework-sys",
]
[[package]]
name = "security-framework-sys"
version = "0.4.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "17bf11d99252f512695eb468de5516e5cf75455521e69dfe343f3b74e4748405"
dependencies = [
 "core-foundation-sys",
 "libc",
]
[[package]]
name = "sendxmppd-rust"
version = "0.1.0"
dependencies = [
 "clap",
 "env_logger",
 "failure",
 "futures-util",
 "hyper",
 "lazy_static",
 "log",
 "minidom",
 "pin-project",
 "serde",
 "serde_derive",
 "tokio",
 "tokio-xmpp",
 "toml",
 "xmpp-parsers",
]
[[package]]
name = "serde"
version = "1.0.116"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "96fe57af81d28386a513cbc6858332abc6117cfdb5999647c6444b8f43a370a5"
[[package]]
name = "serde_derive"
version = "1.0.116"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f630a6370fd8e457873b4bd2ffdae75408bc291ba72be773772a4c2a065d9ae8"
dependencies = [
 "proc-macro2",
 "quote",
 "syn",
]
[[package]]
name = "serde_json"
version = "1.0.58"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "a230ea9107ca2220eea9d46de97eddcb04cd00e92d13dda78e478dd33fa82bd4"
dependencies = [
 "itoa",
 "ryu",
 "serde",
]
[[package]]
name = "sha-1"
version = "0.8.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f7d94d0bede923b3cea61f3f1ff57ff8cdfd77b400fb8f9998949e0cf04163df"
dependencies = [
 "block-buffer 0.7.3",
 "digest 0.8.1",
 "fake-simd",
 "opaque-debug 0.2.3",
]
[[package]]
name = "sha-1"
version = "0.9.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "170a36ea86c864a3f16dd2687712dd6646f7019f301e57537c7f4dc9f5916770"
dependencies = [
 "block-buffer 0.9.0",
 "cfg-if",
 "cpuid-bool",
 "digest 0.9.0",
 "opaque-debug 0.3.0",
]
[[package]]
name = "sha2"
version = "0.8.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "a256f46ea78a0c0d9ff00077504903ac881a1dafdc20da66545699e7776b3e69"
dependencies = [
 "block-buffer 0.7.3",
 "digest 0.8.1",
 "fake-simd",
 "opaque-debug 0.2.3",
]
[[package]]
name = "sha2"
version = "0.9.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "2933378ddfeda7ea26f48c555bdad8bb446bf8a3d17832dc83e380d444cfb8c1"
dependencies = [
 "block-buffer 0.9.0",
 "cfg-if",
 "cpuid-bool",
 "digest 0.9.0",
 "opaque-debug 0.3.0",
]
[[package]]
name = "sha3"
version = "0.9.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f81199417d4e5de3f04b1e871023acea7389672c4135918f05aa9cbf2f2fa809"
dependencies = [
 "block-buffer 0.9.0",
 "digest 0.9.0",
 "keccak",
 "opaque-debug 0.3.0",
]
[[package]]
name = "signal-hook-registry"
version = "1.2.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "a3e12110bc539e657a646068aaf5eb5b63af9d0c1f7b29c97113fad80e15f035"
dependencies = [
 "arc-swap",
 "libc",
]
[[package]]
name = "siphasher"
version = "0.3.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "fa8f3741c7372e75519bd9346068370c9cdaabcc1f9599cbcf2a2719352286b7"
[[package]]
name = "slab"
version = "0.4.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "c111b5bd5695e56cffe5129854aa230b39c93a305372fdbb2668ca2394eea9f8"
[[package]]
name = "smallvec"
version = "1.4.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "fbee7696b84bbf3d89a1c2eccff0850e3047ed46bfcd2e92c29a2d074d57e252"
[[package]]
name = "socket2"
version = "0.3.15"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "b1fa70dc5c8104ec096f4fe7ede7a221d35ae13dcd19ba1ad9a81d2cab9a1c44"
dependencies = [
 "cfg-if",
 "libc",
 "redox_syscall",
 "winapi 0.3.9",
]
[[package]]
name = "string_cache"
version = "0.8.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "2940c75beb4e3bf3a494cef919a747a2cb81e52571e212bfbd185074add7208a"
dependencies = [
 "lazy_static",
 "new_debug_unreachable",
 "phf_shared",
 "precomputed-hash",
 "serde",
]
[[package]]
name = "string_cache_codegen"
version = "0.5.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f24c8e5e19d22a726626f1a5e16fe15b132dcf21d10177fa5a45ce7962996b97"
dependencies = [
 "phf_generator",
 "phf_shared",
 "proc-macro2",
 "quote",
]
[[package]]
name = "strsim"
version = "0.8.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "8ea5119cdb4c55b55d432abb513a0429384878c15dde60cc77b1c99de1a95a6a"
[[package]]
name = "subtle"
version = "1.0.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "2d67a5a62ba6e01cb2192ff309324cb4875d0c451d55fe2319433abe7a05a8ee"
[[package]]
name = "subtle"
version = "2.3.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "343f3f510c2915908f155e94f17220b19ccfacf2a64a2a5d8004f2c3e311e7fd"
[[package]]
name = "syn"
version = "1.0.43"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "1e2e59c50ed8f6b050b071aa7b6865293957a9af6b58b94f97c1c9434ad440ea"
dependencies = [
 "proc-macro2",
 "quote",
 "unicode-xid",
]
[[package]]
name = "synstructure"
version = "0.12.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "b834f2d66f734cb897113e34aaff2f1ab4719ca946f9a7358dba8f8064148701"
dependencies = [
 "proc-macro2",
 "quote",
 "syn",
 "unicode-xid",
]
[[package]]
name = "tempfile"
version = "3.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "7a6e24d9338a0a5be79593e2fa15a648add6138caa803e2d5bc782c371732ca9"
dependencies = [
 "cfg-if",
 "libc",
 "rand",
 "redox_syscall",
 "remove_dir_all",
 "winapi 0.3.9",
]
[[package]]
name = "tendril"
version = "0.4.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "707feda9f2582d5d680d733e38755547a3e8fb471e7ba11452ecfd9ce93a5d3b"
dependencies = [
 "futf",
 "mac",
 "utf-8",
]
[[package]]
name = "termcolor"
version = "1.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "bb6bfa289a4d7c5766392812c0a1f4c1ba45afa1ad47803c11e1f407d846d75f"
dependencies = [
 "winapi-util",
]
[[package]]
name = "textwrap"
version = "0.11.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d326610f408c7a4eb6f51c37c330e496b08506c9457c9d34287ecc38809fb060"
dependencies = [
 "unicode-width",
]
[[package]]
name = "thiserror"
version = "1.0.21"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "318234ffa22e0920fe9a40d7b8369b5f649d490980cf7aadcf1eb91594869b42"
dependencies = [
 "thiserror-impl",
]
[[package]]
name = "thiserror-impl"
version = "1.0.21"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "cae2447b6282786c3493999f40a9be2a6ad20cb8bd268b0a0dbf5a065535c0ab"
dependencies = [
 "proc-macro2",
 "quote",
 "syn",
]
[[package]]
name = "thread_local"
version = "1.0.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d40c6d1b69745a6ec6fb1ca717914848da4b44ae29d9b3080cbee91d72a69b14"
dependencies = [
 "lazy_static",
]
[[package]]
name = "time"
version = "0.1.44"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "6db9e6914ab8b1ae1c260a4ae7a49b6c5611b40328a735b21862567685e73255"
dependencies = [
 "libc",
 "wasi 0.10.0+wasi-snapshot-preview1",
 "winapi 0.3.9",
]
[[package]]
name = "tinyvec"
version = "0.3.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "238ce071d267c5710f9d31451efec16c5ee22de34df17cc05e56cbc92e967117"
[[package]]
name = "tokio"
version = "0.2.22"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "5d34ca54d84bf2b5b4d7d31e901a8464f7b60ac145a284fba25ceb801f2ddccd"
dependencies = [
 "bytes",
 "fnv",
 "futures-core",
 "iovec",
 "lazy_static",
 "libc",
 "memchr",
 "mio",
 "mio-uds",
 "num_cpus",
 "pin-project-lite",
 "signal-hook-registry",
 "slab",
 "tokio-macros",
 "winapi 0.3.9",
]
[[package]]
name = "tokio-macros"
version = "0.2.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f0c3acc6aa564495a0f2e1d59fab677cd7f81a19994cfc7f3ad0e64301560389"
dependencies = [
 "proc-macro2",
 "quote",
 "syn",
]
[[package]]
name = "tokio-tls"
version = "0.3.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "9a70f4fcd7b3b24fb194f837560168208f669ca8cb70d0c4b862944452396343"
dependencies = [
 "native-tls",
 "tokio",
]
[[package]]
name = "tokio-util"
version = "0.3.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "be8242891f2b6cbef26a2d7e8605133c2c554cd35b3e4948ea892d6d68436499"
dependencies = [
 "bytes",
 "futures-core",
 "futures-sink",
 "log",
 "pin-project-lite",
 "tokio",
]
[[package]]
name = "tokio-xmpp"
version = "2.0.0"
source = "git+https://gitlab.com/xmpp-rs/xmpp-rs?branch=main#e1f2e2653a9c14409a04bc4fcd7b10ce842871ea"
dependencies = [
 "bytes",
 "futures",
 "idna",
 "log",
 "native-tls",
 "sasl",
 "tokio",
 "tokio-tls",
 "tokio-util",
 "trust-dns-proto",
 "trust-dns-resolver",
 "xml5ever",
 "xmpp-parsers",
]
[[package]]
name = "toml"
version = "0.5.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ffc92d160b1eef40665be3a05630d003936a3bc7da7421277846c2613e92c71a"
dependencies = [
 "serde",
]
[[package]]
name = "tower-service"
version = "0.3.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "e987b6bf443f4b5b3b6f38704195592cca41c5bb7aedd3c3693c7081f8289860"
[[package]]
name = "tracing"
version = "0.1.21"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "b0987850db3733619253fe60e17cb59b82d37c7e6c0236bb81e4d6b87c879f27"
dependencies = [
 "cfg-if",
 "log",
 "pin-project-lite",
 "tracing-core",
]
[[package]]
name = "tracing-core"
version = "0.1.17"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f50de3927f93d202783f4513cda820ab47ef17f624b03c096e86ef00c67e6b5f"
dependencies = [
 "lazy_static",
]
[[package]]
name = "trust-dns-proto"
version = "0.19.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "cdd7061ba6f4d4d9721afedffbfd403f20f39a4301fee1b70d6fcd09cca69f28"
dependencies = [
 "async-trait",
 "backtrace",
 "enum-as-inner",
 "futures",
 "idna",
 "lazy_static",
 "log",
 "rand",
 "smallvec",
 "thiserror",
 "tokio",
 "url",
]
[[package]]
name = "trust-dns-resolver"
version = "0.19.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "0f23cdfdc3d8300b3c50c9e84302d3bd6d860fb9529af84ace6cf9665f181b77"
dependencies = [
 "backtrace",
 "cfg-if",
 "futures",
 "ipconfig",
 "lazy_static",
 "log",
 "lru-cache",
 "resolv-conf",
 "smallvec",
 "thiserror",
 "tokio",
 "trust-dns-proto",
]
[[package]]
name = "try-lock"
version = "0.2.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "59547bce71d9c38b83d9c0e92b6066c4253371f15005def0c30d9657f50c7642"
[[package]]
name = "typenum"
version = "1.12.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "373c8a200f9e67a0c95e62a4f52fbf80c23b4381c05a17845531982fa99e6b33"
[[package]]
name = "unicode-bidi"
version = "0.3.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "49f2bd0c6468a8230e1db229cff8029217cf623c767ea5d60bfbd42729ea54d5"
dependencies = [
 "matches",
]
[[package]]
name = "unicode-normalization"
version = "0.1.13"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "6fb19cf769fa8c6a80a162df694621ebeb4dafb606470b2b2fce0be40a98a977"
dependencies = [
 "tinyvec",
]
[[package]]
name = "unicode-segmentation"
version = "1.6.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "e83e153d1053cbb5a118eeff7fd5be06ed99153f00dbcd8ae310c5fb2b22edc0"
[[package]]
name = "unicode-width"
version = "0.1.8"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "9337591893a19b88d8d87f2cec1e73fad5cdfd10e5a6f349f498ad6ea2ffb1e3"
[[package]]
name = "unicode-xid"
version = "0.2.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f7fe0bb3479651439c9112f72b6c505038574c9fbb575ed1bf3b797fa39dd564"
[[package]]
name = "url"
version = "2.1.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "829d4a8476c35c9bf0bbce5a3b23f4106f79728039b726d292bb93bc106787cb"
dependencies = [
 "idna",
 "matches",
 "percent-encoding",
]
[[package]]
name = "utf-8"
version = "0.7.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "05e42f7c18b8f902290b009cde6d651262f956c98bc51bca4cd1d511c9cd85c7"
[[package]]
name = "vcpkg"
version = "0.2.10"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "6454029bf181f092ad1b853286f23e2c507d8e8194d01d92da4a55c274a5508c"
[[package]]
name = "vec_map"
version = "0.8.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f1bddf1187be692e79c5ffeab891132dfb0f236ed36a43c7ed39f1165ee20191"
[[package]]
name = "version_check"
version = "0.9.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "b5a972e5669d67ba988ce3dc826706fb0a8b01471c088cb0b6110b805cc36aed"
[[package]]
name = "want"
version = "0.3.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "1ce8a968cb1cd110d136ff8b819a556d6fb6d919363c61534f6860c7eb172ba0"
dependencies = [
 "log",
 "try-lock",
]
[[package]]
name = "wasi"
version = "0.9.0+wasi-snapshot-preview1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "cccddf32554fecc6acb585f82a32a72e28b48f8c4c1883ddfeeeaa96f7d8e519"
[[package]]
name = "wasi"
version = "0.10.0+wasi-snapshot-preview1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "1a143597ca7c7793eff794def352d41792a93c481eb1042423ff7ff72ba2c31f"
[[package]]
name = "widestring"
version = "0.4.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "c168940144dd21fd8046987c16a46a33d5fc84eec29ef9dcddc2ac9e31526b7c"
[[package]]
name = "winapi"
version = "0.2.8"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "167dc9d6949a9b857f3451275e911c3f44255842c1f7a76f33c55103a909087a"
[[package]]
name = "winapi"
version = "0.3.9"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "5c839a674fcd7a98952e593242ea400abe93992746761e38641405d28b00f419"
dependencies = [
 "winapi-i686-pc-windows-gnu",
 "winapi-x86_64-pc-windows-gnu",
]
[[package]]
name = "winapi-build"
version = "0.1.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "2d315eee3b34aca4797b2da6b13ed88266e6d612562a0c46390af8299fc699bc"
[[package]]
name = "winapi-i686-pc-windows-gnu"
version = "0.4.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6"
[[package]]
name = "winapi-util"
version = "0.1.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "70ec6ce85bb158151cae5e5c87f95a8e97d2c0c4b001223f33a334e3ce5de178"
dependencies = [
 "winapi 0.3.9",
]
[[package]]
name = "winapi-x86_64-pc-windows-gnu"
version = "0.4.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
[[package]]
name = "winreg"
version = "0.6.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "b2986deb581c4fe11b621998a5e53361efe6b48a151178d0cd9eeffa4dc6acc9"
dependencies = [
 "winapi 0.3.9",
]
[[package]]
name = "ws2_32-sys"
version = "0.2.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d59cefebd0c892fa2dd6de581e937301d8552cb44489cdff035c6187cb63fa5e"
dependencies = [
 "winapi 0.2.8",
 "winapi-build",
]
[[package]]
name = "xml5ever"
version = "0.16.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "0b1b52e6e8614d4a58b8e70cf51ec0cc21b256ad8206708bcff8139b5bbd6a59"
dependencies = [
 "log",
 "mac",
 "markup5ever",
 "time",
]
[[package]]
name = "xmpp-parsers"
version = "0.17.0"
source = "git+https://gitlab.com/xmpp-rs/xmpp-rs?branch=main#e1f2e2653a9c14409a04bc4fcd7b10ce842871ea"
dependencies = [
 "base64 0.12.3",
 "blake2",
 "chrono",
 "digest 0.9.0",
 "jid",
 "minidom",
 "sha-1 0.9.1",
 "sha2 0.9.1",
 "sha3",
]

Fix README

Dependencies

In channels

Change contents

File deletion: bitbucket-pipelines.yml

File deletion: rustfmt.toml

File deletion: src

File deletion: main.rs

File deletion: stoppable_receiver.rs

File deletion: config.rs

File deletion: xmpp

File deletion: stanzas.rs

File deletion: element_processor.rs

File deletion: xmpp_connection.rs

File deletion: mod.rs

File deletion: xmpp.rs, xmpp.rs, xmpp.rs, xmpp.rs

File deletion: README.md

File deletion: LICENSE-MIT

File deletion: LICENSE-APACHE

File deletion: Cargo.toml

File deletion: Cargo.lock

File deletion: .ignore

File addition: src (drwxr-xr-x)

File addition: xmpp (drwxr-xr-x)

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

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

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

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

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

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

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

File addition: rustfmt.toml (-rw-r--r--)

File addition: bitbucket-pipelines.yml (-rw-r--r--)

File addition: README.md (-rw-r--r--)

File addition: LICENSE-MIT (-rw-r--r--)

File addition: LICENSE-APACHE (-rw-r--r--)

File addition: Cargo.toml (-rw-r--r--)

File addition: Cargo.lock (-rw-r--r--)