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PHNlY3Rpb24gaWQ9ImNvbmNsdXNpb24iPgogIDxoMj5Db25jbHVzaW9uPC9oMj4KICA8cD4KICAgIFdpdGhpbiB0aGUgaGlnaC1zdGFrZXMgc2V0dGluZyBvZiBmb29kIHByb2R1Y3Rpb24sIGluIHdoaWNoIHByb2R1Y3Qgc2FmZXR5IGFuZCBwcm9jZXNzIGVmZmljaWVuY3kgYXJlIHRvcCBwcmlvcml0aWVzLCBlZmZlY3RpdmUgU0RTIGNvbXBsaWFuY2UgY29uc3RpdHV0ZXMgYW4gYWJzb2x1dGUgY29ybmVyc3RvbmUgb2Ygd29ya3BsYWNlIHNhZmV0eSBhbmQgcmVndWxhdG9yeSBjb21wbGlhbmNlLgogIDwvcD4KCiAgPHA+CiAgICBCeSBjb25zb2xpZGF0aW5nIFNEUyBpbmZvcm1hdGlvbiwgc3RyZWFtbGluaW5nIHVwZGF0ZXMgYW5kIHRyYWluaW5nLCBhbmQgcHJvbW90aW5nIGEgY3VsdHVyZSBvZiBvbmdvaW5nIGltcHJvdmVtZW50LCBmb29kIG1hbnVmYWN0dXJlcnMgY2FuIHJlZHVjZSBjaGVtaWNhbCBoYXphcmRzLCBzaGllbGQgZW1wbG95ZWVzLCBhbmQgc2hpZWxkIGJyYW5kIHJlcHV0YXRpb24uIFdpdGggY2hlbWljYWwgZm9ybXVsYXRpb25zIGNoYW5naW5nIGFuZCByZWd1bGF0aW9ucyBiZWNvbWluZyBzdHJpY3RlciwgcHJvYWN0aXZlIG1hbmFnZW1lbnQgb2YgU0RTIHByb3ZpZGVzIGJvdGggcmlzayByZWR1Y3Rpb24gYW5kIGNvbXBldGl0aXZlIGVkZ2XigJRhc3N1cmluZyBzYWZlLCBjb21wbGlhbnQsIGFuZCByb2J1c3QgZm9vZCBwcm9kdWN0aW9uLgogIDwvcD4KPC9zZWN0aW9uPg==
