チャンピオンのアリゴテワイン-Winestealssd.com

コート・シャロネーズのブズロンにあるドメーヌA＆Pドヴィレーヌ

ハイライト
雑誌：2019年9月号
テイスティングホーム

あなたがブドウの木の下の土地を所有している場合ブルゴーニュの伝説的なコートドール、多くのコミッションを期待しないでください。グランクリュのブドウ園の価格は10年で2倍になり、ボトル1滴ごとに2回売ることができるでしょう。

{ 'コンテンツ'： 'PHA + QWxsIHlvdSBuZWVkIGRvIGlzIGV4YWN0bHkgd2hhdCB5b3VyIHByZWRlY2Vzc29ycyBkaWQsIGdpdmUgb3IgdGFrZSBhIGZldyB3aW5lcnkgaW1wcm92ZW1lbnRzIGFuZCBwZXJoYXBzIGEgbW9yZSBjYXJlZnVsIGF0dGl0dWRlIHRvIGNoZW1pY2FscyBvbiB0aGUgdmluZXMuPC9wPgo8cD48ZGl2IGNsYXNzPSJhZC1jb250YWluZXIgYWQtY29udGFpbmVyLS1tb2JpbGUiPjxkaXYgaWQ9InBvc3QtaW5saW5lLTEiIGNsYXNzPSJpcGMtYWR2ZXJ0Ij48L2Rpdj48L2Rpdj48L3A + Cjxocj4KPGgyIHN0eWxlPSJ0ZXh0LWFsaWduOiBjZW50ZXI7Ij5TY3JvbGwgZG93biBmb3IgTmluYSBDYXBsYW7igJlzIHBpY2sgb2YgdGhlIHdvcmxk4oCZcyBiZXN0IEFsaWdvdMOpPC9oMj4KPGhyPgo8cD5PZiBjb3Vyc2UsIHlvdeKAmXJlIHdvcnJpZWQgYWJvdXQgY2xpbWF0ZSBjaGFuZ2UgYW5kIHlvdSBmcmV0IGFib3V0IGZyb3N0IGFuZCBoYWlsLiBCdXQgYXMgYSB3aW5lbWFrZXIgaW4gb25lIG9mIHRoZSB3b3JsZOKAmXMgYmVzdC1sb3ZlZCB3aW5lIHJlZ2lvbnMsIHlvdSBwcm9iYWJseSBlbmNvdW50ZXIgcGl0eSBvbmx5IHNsaWdodGx5IG1vcmUgZnJlcXVlbnRseSB0aGFuIHlvdSBzZWUgPGEgaHJlZj0iaHR0cHM6Ly93d3cuZGVjYW50ZXIuY29tL3dpbmUvZ3JhcGUtdmFyaWV0aWVzL2NhYmVybmV0LXNhdXZpZ25vbi8iIHRhcmdldD0iX2JsYW5rIiByZWw9Im5vb3BlbmVyIj5DYWJlcm5ldCBTYXV2aWdub248 L2E + IHZpbmVzLjwvcD4KPHA + QnV0IHRoYXTigJlzIGFsbCByaWdodDogQnVyZ3VuZHnigJlzIGJlc3QgeW91bmcgd2luZW1ha2VycyBhcmVu4oCZdCBsb29raW5nIGZvciBwaXR5LCBleGNlcHQgcGVyaGFwcyBmcm9tIHRoZSBoZWF2ZW5zIGluIHRoZSBtYXR0ZXIgb2YgbGF0ZSBzcHJpbmcgZnJvc3RzLiBXaGF0IHRoZXkgd2FudCBpcyBzb21ldGhpbmcgZXZlbiBsZXNzIGluIGV2aWRlbmNlOiBhIGNoYW5jZSB0byByZW1ha2UgdGhlIHdvcmxkLiBJdOKAmXMgYWxsIHZlcnkgd2VsbCBkb2luZyB0aGluZ3MganVzdCBhcyB5b3VyIGZhdGhlcnMgZGlkIChhbmQsIHVzdWFsbHksIGl0IHdhcyBmYXRoZXJzIOKAkyBvciBhdCBsZWFzdCB0aGUgbWVuIHRvb2sgdGhlIGNyZWRpdCkuPC9wPgo8cD5CdXQgaXQgaXMgbm90IGhvdyB0aGUgbmV4dCBnZW5lcmF0aW9uIGxpa2VzIHRvIG9wZXJhdGUuIFdoaWNoIG1heSBiZSBvbmUgcmVhc29uIGZvciBhbiBvYnNlc3Npb24gdGhlaXIgZm9yZWZhdGhlcnMgY2VydGFpbmx5IGRpZG7igJl0IHNoYXJlOiB3aXRoIEFsaWdvdMOpLCBhIGdyYXBlIGFzIHVuZGVycmF0ZWQgYW5kIG1pc3VuZGVyc3Rvb2QgYXMgYW55IHRlZW5hZ2VyLjwvcD4KPHA + PGRpdiBjbGFzcz0iYWQtY29udGFpbmVyIGFkLWNvbnRhaW5lci0tbW9iaWxlIj48ZGl2IGlkPSJwb3N0LWlubGluZS0yIiBjbGFzcz0iaXBjLWFkdmVydCI + PC9kaXY + PC9kaXY + PC9wPgo8cD7igJhBbGlnb3TDqSBpcyBoaWdoIGluIHlpZWxk LOKAmSB3cm90ZSBvbmUgY29tbWVudGF0b3IgaW4gMTg0MSAoYXMgcXVvdGVkIGJ5IFBpZXJyZSBSw6l6ZWF1IGluIGhpcyBEaWN0aW9ubmFpcmUgZGVzIG5vbXMgZGUgY8OpcGFnZXMgZGUgRnJhbmNlKS4g4oCYVGhlIG5ldyB3aW5lIGhhcyBhIHBhcnRpY3VsYXIsIHJhdGhlciBkaXNhZ3JlZWFibGUgZmxhdm91ciwgd2hpY2ggZGlzYXBwZWFycyBhZnRlciBhIGZldyB3ZWVrcy7igJkgQ2hhcm1pbmcuPC9wPgo8cD5BbGlnb3TDqSBpcyBzdGlsbCB2aWV3ZWQgYXMgYSBib3JpbmcsIGFjaWRpYyB3aGl0ZSBncmFwZSwgZ29vZCBvbmx5IGZvciBzd2VldGVuaW5nIHdpdGggY2Fzc2lzIHRvIG1ha2Uga2lyIG9yIHBlcnN1YWRpbmcgdG8gYnViYmxlIGFzIENyw6ltYW50IGRlIEJvdXJnb2duZS4gQW5kIHRoZXJl4oCZcyBwbGVudHkgb2YgbWVkaW9jcmUgQWxpZ290w6kgYXJvdW5kLCBidXQgdGhhdOKAmXMgdHJ1ZSBvZiA8YSBocmVmPSJodHRwczovL3d3dy5kZWNhbnRlci5jb20vd2luZS9ncmFwZS12YXJpZXRpZXMvY2hhcmRvbm5heS8iIHRhcmdldD0iX2JsYW5rIiByZWw9Im5vb3BlbmVyIj5DaGFyZG9ubmF5PC9hPiB0b28uIEFyZSBBbGlnb3TDqeKAmXMgcHJvYmxlbXMgYSBmYWlyIGp1ZGdlbWVudCBvbiB0aGUgdmFyaWV0eSwgb3IgaXMgaXQgYSBtYXR0ZXIgb2Ygd2luZW1ha2luZywgdGVycm9pciBhbmQgdHJhZGl0aW9uPzwvcD4KPGgyPkV4cGVuc2l2ZSBpbmR1bGdlbmNlPC9oMj4KPHA + SSB2aXNpdGVkIHRoZSBD w7R0ZSBk4oCZT3IgdG8gZW5xdWlyZSBhbmQgZm91bmQgYSBidW5jaCBvZiBmcmllbmRseSBmYW5hdGljcy4gQWxsIG9mIHRoZW0gbWFrZSB0aGVpciBsaXZpbmcgZnJvbSBDaGFyZG9ubmF5IGFuZCA8YSBocmVmPSJodHRwczovL3d3dy5kZWNhbnRlci5jb20vd2luZS9ncmFwZS12YXJpZXRpZXMvcGlub3Qtbm9pci8iIHRhcmdldD0iX2JsYW5rIiByZWw9Im5vb3BlbmVyIj5QaW5vdCBOb2lyPC9hPiwgYmVjYXVzZSBidXllcnMg4oCYd2FudCBzb21ldGhpbmcgdGhleSBhbHJlYWR5IHVuZGVyc3RhbmTigJksIHNheXMgTGF1cmVudCBGb3VybmllciBvZiBEb21haW5lIEplYW4gRm91cm5pZXIuIFRoZSBvYnNlc3Npb24gd2l0aCBBbGlnb3TDqSBpcyBhbiBleHBlbnNpdmUgaW5kdWxnZW5jZSwgc2luY2UgaXQgaW52b2x2ZXMgcGxhbnRpbmcgdGhlIGJldHRlciB0ZXJyb2lycyB3aXRoIGEgdmFyaWV0eSB0aGF0IHNlbGxzIGZvciBmYXIgbGVzcyB0aGFuIENoYXJkb25uYXkuIEJ1dCB0aGV5IGFyZSB1bnJlcGVudGFudC4g4oCYQWxpZ290w6kgaXMgYWxtb3N0IG1vcmUgZXhwcmVzc2l2ZSBvZiB0ZXJyb2lyIHRoYW4gQ2hhcmRvbm5heSBpcyzigJkgc2F5cyBTeWx2YWluIFBhdGFpbGxlIG9mIERvbWFpbmUgU3lsdmFpbiBQYXRhaWxsZSwgd2hvc2UgTWFyc2FubmF5IHJlZHMgaGF2ZSB3b24gaGltIHByYWlzZSB0aGF0IHdvdWxkIGRpc3RyYWN0IGEgbGVzc2VyIG1hbiBmcm9tIEFsaWdvdMOpLiBUaGUgdHdvIHdoaXRlIHZh cmlldGllcyBhcmUgY2xvc2UgcmVsYXRpb25zIOKAkyBib3RoIG9mZnNwcmluZyBvZiBQaW5vdCBOb2lyIGFuZCBHb3VhaXMgQmxhbmMsIGJvdGggcHJvYmFibHkgbmF0aXZlIHRvIHRoaXMgcmVnaW9uLiBPbmUgaXMgcmV2ZXJlZCAob24gdGhlIEPDtHRlIGTigJlPciBhdCBsZWFzdCksIHRoZSBvdGhlciBkZXNwaXNlZC4gV2hhdCBoYXBwZW5lZD88L3A + CjxkaXYgY2xhc3M9ImFkLWNvbnRhaW5lciBhZC1jb250YWluZXItLW1vYmlsZSI + PGRpdiBpZD0icG9zdC1pbmxpbmUtMyIgY2xhc3M9ImlwYy1hZHZlcnQiPjwvZGl2PjwvZGl2Pgo8cD5QaHlsbG94ZXJhIGlzIHBhcnQgb2YgdGhlIGFuc3dlci4gVGhlcmUgd2VyZSBBbGlnb3TDqSB2aW5lcyBibGVuZGVkIGluIHdpdGggdGhlIENoYXJkb25uYXkgYmVmb3JlIHRoZSBsb3VzZSBhcnJpdmVkIGluIHRoZSAxOXRoIGNlbnR1cnksIGFuZCBhZnRlcndhcmRzIG1hbnkgd2VyZSBub3QgcmVwbGFjZWQsIGFzIENoYXJkb25uYXkgd2FzIGRlZW1lZCBtb3JlIHZhbHVhYmxlLiBCdXQgQWxpZ290w6kgaGFkIGJlZW4gbWlzdHJ1c3RlZCBiZWZvcmUgdGhhdCwgYXMgdGhhdCBncnVtcHkgMTg0MHMgcXVvdGUgaW5kaWNhdGVzLCBwb3NzaWJseSBhcyBpdCByZXF1aXJlcyBtb3JlIHdvcmsgaW4gdGhlIHZpbmV5YXJkIHRvIHNob3cgaXRzIGZ1bGwgcG90ZW50aWFsLjwvcD4KPHA + Tm90IGV2ZXJ5b25lIGFncmVlZDogdGhlcmUgd2FzIHN0aWxsIEFsaWdvdMOpIG9uIHByZW1pZXIg Y3J1IGhpbGxzaWRlcyBhZnRlciBXb3JsZCBXYXIgSUk7IHNvbWUgd2FzIHB1bGxlZCBvdXQgb2YgdGhlIGdyYW5kIGNydSBDb3J0b24tQ2hhcmxlbWFnbmUgdmluZXlhcmRzIGluIHRoZSAxOTcwcy4gRG9tYWluZSBQb25zb3QgbWFrZXMgTGUgQ2xvcyBkZXMgTW9udHMgTHVpc2FudHMsIHRoZSBvbmx5IHByZW1pZXIgY3J1IEFsaWdvdMOpLCB0aGFua3MgdG8gYSBibG9vZHkgbWluZGVkbmVzcyB0aGF0IHJlZnVzZWQgdG8gYWNjZXB0IDIwdGgtY2VudHVyeSBydWxlcyBkZXZhbHVpbmcgdGhlIGdyYXBlLiBTdXJlbHksIGlmIG9uZSBncmVhdCB0ZXJyb2lyIGNhbiBtYWtlIHRvcC1jYWxpYnJlIEFsaWdvdMOpLCB0aGVuIG90aGVycyBjYW4gdG9vLjwvcD4KPGRpdiBjbGFzcz0iYWQtY29udGFpbmVyIGFkLWNvbnRhaW5lci0tbW9iaWxlIj48ZGl2IGlkPSJwb3N0LWlubGluZS00IiBjbGFzcz0iaXBjLWFkdmVydCI + PC9kaXY + PC9kaXY + CjxoMj5GYW4gY2x1YjwvaDI + CjxwPkZvdXJuaWVyIHRoaW5rcyBzby4g4oCYSSBoYWQgc29tZSBvbGQgdmluZXMgYW5kIEkgd2FudGVkIHRvIG1ha2UgYSBzZXJpb3VzLCBnYXN0cm9ub21pYyBBbGlnb3TDqSwgYnV0IG5vYm9keSB3YXMgaW50ZXJlc3RlZCzigJkgaGUgc2F5cy4gQXQgYSBQYXJpc2lhbiByZXN0YXVyYW50LCBhIGZldyBBbGlnb3TDqSBmYW5jaWVycyBmb3VuZCBhIGRvemVuIEFsaWdvdMOpcyBvbiB0aGUgbGlzdDog4oCYV2UgY291bGRu4oCZdCBiZWxpZXZlIGl0LOKA mSByZWNhbGxzIFBhdGFpbGxlLiBTbyBoZSBvcmRlcmVkIHRoZW0gYWxsLiBJdCBtYXkgaGF2ZSB0YWtlbiB0aGUgcHJvcHJpZXRvciwgUGhpbGlwcGUgRGVsYWNvdXJjZWxsZSwgYSBmZXcgbW9tZW50cyB0byByZWFsaXNlIHRoYXQgaGlzIGN1c3RvbWVycyAod2hvIGhhZCBub3QgcmVxdWVzdGVkIGEgc3BpdHRvb24pIHdlcmUgY29ubm9pc3NldXJzIHJhdGhlciB0aGFuIGRydW5rYXJkcywgYnV0IHRoZW4gdGhlaXIgc2hhcmVkIHBhc3Npb24gYmVjYW1lIHRoZSByb290IG9mIGEgZGVlcCBmcmllbmRzaGlwLjwvcD4KPHA + Tm93LCBEZWxhY291cmNlbGxlIGhhcyBidWlsdCBCb2lzcm91Z2UsIGEgYmVhdXRpZnVsIHJlc3RhdXJhbnQgYW5kIGZpdmUtYmVkcm9vbSBndWVzdGhvdXNlIGluIHRoZSB3b29kcyBuZWFyIEZsYWdleS1FY2jDqXplYXV4LCBhbmQgc2VydmVzIGFzIHByZXNpZGVudCBvZiBhbiBpbmZvcm1hbCBvcmdhbmlzYXRpb24ga25vd24g4oCTIHdpdGggYSB3aW5rIHRvIGJvdGggYXV0ZXVycyBhbmQgcmVwdGlsZXMg4oCTIGFzIExlcyBBbGlnb3RldXJzLjwvcD4KPGRpdiBjbGFzcz0iYWQtY29udGFpbmVyIGFkLWNvbnRhaW5lci0tbW9iaWxlIj48ZGl2IGlkPSJwb3N0LWlubGluZS01IiBjbGFzcz0iaXBjLWFkdmVydCI + PC9kaXY + PC9kaXY + CjxwPkF0IGZpcnN0LCB0aGV5IHdlcmUganVzdCBhIGhhbmRmdWwgb2YgeW91bmdlciBmcmVlLXRoaW5rZXJzLCBpbmNsdWRpbmcgUGF0YWlsbGUgYW5kIEZvdXJu aWVyLCB3aG8gd2VyZSBjaGlsZGhvb2QgZnJpZW5kczsgTmljb2xhcyBNb3JpbiwgYSBuw6lnb2NpYW50IGluIE51aXRzLVN0LUdlb3JnZXM7IFBhYmxvIENoZXZyb3QgaW4gTWFyYW5nZXM7IGFuZCBBbm5lIE1vcmV5IGluIE1ldXJzYXVsdC4gUGllcnJlIGRlIEJlbm9pc3QsIG5lcGhldyBvZiBEb21haW5lIGRlIGxhIFJvbWFuw6llLUNvbnRp4oCZcyBBdWJlcnQgZGUgVmlsbGFpbmUgYW5kIG92ZXJzZWVyIG9mIGhpcyBwcm9wZXJ0eSBhdCBCb3V6ZXJvbiwgaGFzIGJlY29tZSB2ZXJ5IGludm9sdmVkIHRvby4g4oCYQWxpZ290w6kgbmVlZHMgYSBjaGFtcGlvbizigJkgaGUgc2F5cy48L3A + CjxwPldlbGwsIG5vdyBpdCBoYXMgNTEgb2YgdGhlbSwgd2l0aCBhIHN1Y2Nlc3NmdWwgc2Fsb24gaW4gMjAxOCB1bmRlciB0aGVpciBjb2xsZWN0aXZlIGJlbHQuIFRoZXJlIGlzIGJpZyBkZW1hbmQgdG8gam9pbiB0aGUgQWxpZ290ZXVycywgRm91cm5pZXIgc2F5czog4oCYQnV0IHdlIGRvbuKAmXQgd2FudCB0byBnZXQgdG9vIGJpZy4gV2Ugd2FudCB0byBtYWtlIGdyZWF0IHdpbmUgYW5kIGFjaGlldmUgcmVjb2duaXRpb24gZm9yIGl0IHdpdGhvdXQgdGFraW5nIG91cnNlbHZlcyB0b28gc2VyaW91c2x5LuKAmSBUaGV5IGRvbuKAmXQgaW5zaXN0IG9uIG9yZ2FuaWMgcHJhY3RpY2U7IHRoZXkgZG9u4oCZdCBpbnNpc3Qgb24gbXVjaC4g4oCYV2Ugd2FudCB0byByZXNwZWN0IGV2ZXJ5b25l4oCZcyBjaG9pY2VzLiBCdXQgd2Ug ZG8gd2FudCBwZW9wbGUgd2hvIHdpbGwgb3BlbiBhIGZldyBib3R0bGVzIOKAkyB5b3UgY2Fu4oCZdCBqdXN0IHNheSB5b3UgaGF2ZSBub3RoaW5nIHRvIHNlbGw7IHRoYXTigJlzIG5vdCBvdXIgcGhpbG9zb3BoeS7igJk8L3A + CjxoMz5TZXJpb3VzbHkgZ29vZDwvaDM + CjxwPllvdSBjYW4gc2F5IHRoYXQgYWdhaW4uIER1cmluZyBteSBkYXkgd2l0aCB0aGUgQWxpZ290ZXVycyBJIHRoaW5rIEkgdGFzdGVkIGNsb3NlIHRvIDEwMCBBbGlnb3TDqXMsIHNvbWUgc2VyaW91c2x5IGdvb2QuIE1hbnkgaGFkIGEgZGVsaWNhdGUsIGxlbW9ueSBtaW5lcmFsaXR5IGFuZCBhIGxpY2sgb2Ygc2FsdC4gU29tZSB3ZXJlIGNyZWFtaWVyLCB0aGFua3MgdG8gdGltZSBpbiBvYWs7IG1vc3QgcmVnaXN0ZXJlZCB0aGUgYWNpZGl0eSBmb3Igd2hpY2ggQWxpZ290w6kgaXMgYmVzdCBrbm93biDigJMgYSBxdWFsaXR5IHRoYXQgc2hvdWxkIG1ha2UgYWdlaW5nIHBlcmZlY3RseSBwb3NzaWJsZS4gQW5kLCBpbiBmYWN0LCB0aGUgb2xkZXN0IHdpbmUgSSB0cmllZCwgYSBEb21haW5lIENoZXZyb3QgMTk4NiwgaGFkIGxvdmVseSBmbGF2b3VycyBvZiBob25leSBhbmQgcXVpbmNlIHBhc3RlLCBkZXNwaXRlIGJlaW5nIHBhc3QgaXRzIGJlc3QuPC9wPgo8cD7igJhQZW9wbGUgZG9u4oCZdCByZWFsbHkgdGFsayBhYm91dCBBbGlnb3TDqSzigJkgc2F5cyBEYW1pZW4gQ29saW4gb2YgRG9tYWluZSBNYXJjIENvbGluLCB3aG8gaXNu4oCZdCBhbiBB bGlnb3RldXIgYnV0IGhhcyBhIHNpbWlsYXIgb3V0bG9vazsg4oCYVGhleSBmb3JnZXQgaXTigJlzIGEgbm9ibGUgQnVyZ3VuZGlhbiB2YXJpZXR5LuKAmSBIZSBncm93cyBoaXMgQWxpZ290w6kgb24gY2xheSBzb2lscyBpbiBTdC1BdWJpbiBhbmQgUHVsaWdueS1Nb250cmFjaGV0IGFuZCBsZWF2ZXMgaXQgaW4gb2xkIG9hayBmb3IgMTMgbW9udGhzICh0aGUgQ2hhcmRvbm5heSBnZXRzIDE4IG1vbnRocykuIEl0IGFnZXMgd2VsbCwgaGUgdGVsbHMgbWUsIGFuZCBoZSBsaWtlcyB0aGUgZmFjdCB0aGF0IGhlIGNhbiBzZWxsIGl0IGZhciBjaGVhcGVyIHRoYW4gaGlzIENoYXJkb25uYXkg4oCTIOKAmG90aGVyd2lzZSBteSBjb3VudHJ5bWVuIHdpbGwgbmV2ZXIgZ2V0IHRvIHRhc3RlIG15IHdpbmVz4oCZLjwvcD4KPHA + QWxpZ290w6kgcmlwZW5zIGxhdGVyIHRoYW4gQ2hhcmRvbm5heSDigJMgYW4gYWR2YW50YWdlLCBnaXZlbiBjbGltYXRlIGNoYW5nZSDigJMgYW5kIGJ1ZHMgZWFybHksIHdoaWNoIG1ha2VzIGl0IG1vcmUgcmVzaXN0YW50IHRvIGNvbGQuIEl04oCZcyBsZXNzIHN1c2NlcHRpYmxlIHRoYW4gQ2hhcmRvbm5heSB0byBzZXZlcmFsIGRpc2Vhc2VzLCBpbmNsdWRpbmcgcG93ZGVyeSBtaWxkZXcgYW5kIGdyZXkgcm90LiBOb25ldGhlbGVzcywgd2hlbiB0aGUgQUMgc3lzdGVtIHdhcyBjcmVhdGVkIGluIDE5MzcsIEFsaWdvdMOpIHdhcyBvbmx5IGF3YXJkZWQgdGhlIGxvd2x5IGNsYXNzaWZpY2F0aW9uIEJv dXJnb2duZSBBbGlnb3TDqS48YnIgLz4KSW4gMTk3OSBCb3V6ZXJvbiBnYWluZWQgaXRzIG93biB2aWxsYWdlIGFwcGVsbGF0aW9uLCBhbmQgaXMgdmVyeSBwcm91ZCBvZiBpdHMgQWxpZ290w6kgRG9yw6ksIHdoaWNoIGlzIG5vdyBwcm9wYWdhdGVkIHRocm91Z2ggbWFzc2FsIHNlbGVjdGlvbiBhbmQgaXMgYmVsaWV2ZWQgdG8gYmUgYSByaWNoZXIsIGhpZ2hlciBxdWFsaXR5IGNsb25lIHRoYW4gdGhlIG1vcmUgY29tbW9uIEFsaWdvdMOpIFZlcnQuIFRoZW4gaW4gMTk5NywgQm91emVyb24gd2FzIHJlY29nbmlzZWQgYXMgYW4gQUMsIGxhcmdlbHkgYmVjYXVzZSBoZXJlIHRoZSBBbGlnb3TDqSBpcyBwbGFudGVkIG9uIHRoZSBiZXR0ZXIsIGhpZ2hlciBzbG9wZXMuPC9wPgo8aDI + V2luZSBhbmQgbGF1Z2h0ZXI8L2gyPgo8cD5UaGV54oCZcmUgbG92ZWx5LCB0aG9zZSBzbG9wZXMsIHRoZWlyIGRhcmsgc29pbCBsaXR0ZXJlZCB3aXRoIGNydW1ibGVkIGNodW5rcyBvZiBsaW1lc3RvbmUgYW5kIHRpbnkgcHVycGxlIHdpbGRmbG93ZXJzLiBCZW5vw650IFBhZ290IHRha2VzIHVzIHRvIGhpcyB0aW55IERvbWFpbmUgR291ZmZpZXIgd2luZXJ5OyBkZSBCZW5vaXN0IHNob3dzIG9mZiB0aGUgY29uc2VydmF0b2lyZSB3aGVyZSBoZSBpcyBwcmVzZXJ2aW5nIHRoZSB2YXJpZXR54oCZcyBnZW5ldGljIGRpdmVyc2l0eS4gUGF0YWlsbGUgcG9pbnRzIHRvIDdoYSB0aGF0IEJvdWNoYXJkIHJlY2VudGx5IHNvbGQsIHRvIDEzIHBy b2R1Y2VycyDigJMgYWx0aG91Z2ggZm9yIG5vdyBoZTxiciAvPgpoaW1zZWxmIGlzIG5vdCBvbmUgb2YgdGhlbS4gSGlzIGZvdXIgcGFyY2VscyBvZiBBbGlnb3TDqSBhcmUgZWxzZXdoZXJlOyB0aGUgbGFyZ2VzdCBpcyAwLjNoYS4gSGUgdmluaWZpZXMgYW5kIGJvdHRsZXMgZWFjaCBpbmRpdmlkdWFsbHksIGRlc3BpdGUgdGhlIGZhY3QgdGhhdCB0aGlzIGlzIGVjb25vbWljIGluc2FuaXR5LjwvcD4KPHA + 4oCYV2UgZG9u4oCZdCBncm93IEFsaWdvdMOpIHRvIGdldCByaWNoLOKAmSBhZ3JlZXMgRm91cm5pZXIsIGFuZCBldmVuIGRlIEJlbm9pc3QsIHdpdGggdGhlIHdvcmxkLWZhbW91cyBuYW1lIG9mIGRlIFZpbGxhaW5lIG9uIGhpcyBib3R0bGVzIGFuZCB2aW5lcyB1cCB0byAxMTUgeWVhcnMgb2xkLCBzZWxscyBoaXMgQWxpZ290w6kgZm9yIGFib3V0IOKCrDE1IGFuZCBzb21ldGltZXMgZ2V0cyBhc2tlZCB3aHkgaXQgY29zdHMgc28gbXVjaC48L3A + CjxwPkJhY2sgYXQgQm9pc3JvdWdlLCBEZWxhY291cmNlbGxlIGJyaW5ncyBvdXQgZ291Z8OocmVzIChCdXJndW5kaWFuIGNoZWVzZSBwdWZmcykgYW5kIHdoaXRlIGFzcGFyYWd1cywgYm90aCBleGNlbGxlbnQgd2l0aCB0aGUgYm90dGxlcyBvZiBBbGlnb3TDqSB0aGF0IGxpdHRlciB0aGUgdGFibGUuIFRoZSBBbGlnb3RldXJzIGRyaW5rLCBlYXQgYW5kIGxhdWdoIOKAkyB0aGUgZm9ybWVyIHByZXNpZGVudCBKYWNxdWVzIENoaXJhYyB3b3VsZCBoYXZlIG1hZGUg YSBmaW5lIHdpbmVtYWtlciwgc29tZW9uZSBjcmFja3MsIOKAmGJlY2F1c2UgaW4gMTIgeWVhcnMgaGUgZGlkIGFsbW9zdCBub3RoaW5nIeKAmSkuIEdldHRpbmcgcmljaCBmZWVscyBsaWtlIGEgcG9vciBhbHRlcm5hdGl2ZS48L3A + CjxwPk90aGVycyBhcmUgaW50ZXJlc3RlZCBpbiBBbGlnb3TDqSwgdG9vOiBpdOKAmXMgRnJhbmNl4oCZcyAxMHRoIG1vc3Qgd2lkZWx5IHBsYW50ZWQgd2hpdGUgZ3JhcGUsIHZlcnkgcG9wdWxhciBpbiBFYXN0ZXJuIEV1cm9wZSwgYW5kIENow6J0ZWF1IGRlcyBDaGFybWVzIGV2ZW4gbWFrZXMgb25lIGluIE9udGFyaW8uIEhpY2tpbmJvdGhhbSBhbmQgR2FyYWdpc3RlLCB0d28gd2luZXJpZXMgaW4gQXVzdHJhbGlh4oCZcyBNb3JuaW5ndG9uIFBlbmluc3VsYSwgYm90aCB0dXJuIG91dCBpbXByZXNzaXZlIHZlcnNpb25zLjwvcD4KPGRpdiBjbGFzcz0iaW5qZWN0aW9uIj48L2Rpdj4KPHA + QmFjayBpbiBGcmFuY2UsIGEgc2Vjb25kIGdhdGhlcmluZyBhd2FpdHMgaW4gUGFyaXMgb24gMiBEZWNlbWJlci4gVGhlcmUgd2lsbCBiZSBtdWNoIHdpbmUgYW5kIG1vcmUgbGF1Z2h0ZXIuIERvb3JzIHdpbGwgYmUgY2xvc2VkIHRvIHRoZSBjbG9zZWQtbWluZGVkOyBldmVyeW9uZSBlbHNlIGlzIHdlbGNvbWUuPC9wPgo8cD48ZW0 + TmluYSBDYXBsYW4gaXMgYW4gYXdhcmRlZCBqb3VybmFsaXN0LCB3cml0ZXIgYW5kIGVkaXRvci4gU2hlIHdyaXRlcyBhIGNvbHVtbiBmb3IgdGhlIE5ldyBTdGF0 ZXNtYW4sIGFuZCB3YXMgdGhlIExvdWlzIFJvZWRlcmVyIEludGVybmF0aW9uYWwgRm9vZCAmYW1wOyBXaW5lIFdyaXRlciBvZiB0aGUgWWVhciAyMDE2PC9lbT48L3A + Cjxocj4KPGgyPlNlZSBOaW5hIENhcGxhbuKAmXMgcGljayBvZiB0aGUgd29ybGTigJlzIGJlc3QgQWxpZ290w6k8L2gyPgo8cD4K '}