ZGlmZiAtLWdpdCBhL2NvcmUvZnBkZmRvYy9jcGRmX2dlbmVyYXRlYXAuY3BwIGIvY29yZS9mcGRmZG9jL2NwZGZfZ2VuZXJhdGVhcC5jcHAKaW5kZXggMDMwNzdlMi4uYTVlZjcyYyAxMDA2NDQKLS0tIGEvY29yZS9mcGRmZG9jL2NwZGZfZ2VuZXJhdGVhcC5jcHAKKysrIGIvY29yZS9mcGRmZG9jL2NwZGZfZ2VuZXJhdGVhcC5jcHAKQEAgLTkyLDE4ICs5MiwyNCBAQAogICByZXR1cm4gUERGX0VuY29kZVN0cmluZyh3b3JkcykgKyAiIFRqXG4iOwogfQogCitCeXRlU3RyaW5nIFN0cmluZ0Zyb21Gb250TmFtZUFuZFNpemUoY29uc3QgQnl0ZVN0cmluZyYgZm9udF9uYW1lLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGZsb2F0IGZvbnRfc2l6ZSkgeworICBmeGNydDo6b3N0cmluZ3N0cmVhbSBmb250X3N0cmVhbTsKKyAgaWYgKGZvbnRfbmFtZS5HZXRMZW5ndGgoKSA+IDAgJiYgZm9udF9zaXplID4gMCkgeworICAgIGZvbnRfc3RyZWFtIDw8ICIvIiA8PCBmb250X25hbWUgPDwgIiAiOworICAgIFdyaXRlRmxvYXQoZm9udF9zdHJlYW0sIGZvbnRfc2l6ZSkgPDwgIiBUZlxuIjsKKyAgfQorICByZXR1cm4gQnl0ZVN0cmluZyhmb250X3N0cmVhbSk7Cit9CisKIEJ5dGVTdHJpbmcgR2V0Rm9udFNldFN0cmluZyhJUFZUX0ZvbnRNYXAqIGZvbnRfbWFwLAogICAgICAgICAgICAgICAgICAgICAgICAgICAgIGludDMyX3QgZm9udF9pbmRleCwKICAgICAgICAgICAgICAgICAgICAgICAgICAgICBmbG9hdCBmb250X3NpemUpIHsKLSAgZnhjcnQ6Om9zdHJpbmdzdHJlYW0gZm9udF9zdHJlYW07Ci0gIGlmIChmb250X21hcCkgewotICAgIEJ5dGVTdHJpbmcgZm9udF9hbGlhcyA9IGZvbnRfbWFwLT5HZXRQREZGb250QWxpYXMoZm9udF9pbmRleCk7Ci0gICAgaWYgKGZvbnRfYWxpYXMuR2V0TGVuZ3RoKCkgPiAwICYmIGZvbnRfc2l6ZSA+IDApIHsKLSAgICAgIGZvbnRfc3RyZWFtIDw8ICIvIiA8PCBmb250X2FsaWFzIDw8ICIgIjsKLSAgICAgIFdyaXRlRmxvYXQoZm9udF9zdHJlYW0sIGZvbnRfc2l6ZSkgPDwgIiBUZlxuIjsKLSAgICB9CisgIGlmICghZm9udF9tYXApIHsKKyAgICByZXR1cm4gQnl0ZVN0cmluZygpOwogICB9Ci0gIHJldHVybiBCeXRlU3RyaW5nKGZvbnRfc3RyZWFtKTsKKyAgcmV0dXJuIFN0cmluZ0Zyb21Gb250TmFtZUFuZFNpemUoZm9udF9tYXAtPkdldFBERkZvbnRBbGlhcyhmb250X2luZGV4KSwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgZm9udF9zaXplKTsKIH0KIAogdm9pZCBTZXRWdEZvbnRTaXplKGZsb2F0IGZvbnRfc2l6ZSwgQ1BWVF9WYXJpYWJsZVRleHQmIHZ0KSB7CkBAIC0xNjAxLDMgKzE2MDcsNDQgQEAKICAgICAgIHJldHVybiBmYWxzZTsKICAgfQogfQorCisvLyBzdGF0aWMKK2Jvb2wgQ1BERl9HZW5lcmF0ZUFQOjpHZW5lcmF0ZURlZmF1bHRBcHBlYXJhbmNlV2l0aENvbG9yKAorICAgIENQREZfRG9jdW1lbnQqIGRvYywKKyAgICBDUERGX0RpY3Rpb25hcnkqIGFubm90X2RpY3QsCisgICAgY29uc3QgQ0ZYX0NvbG9yJiBjb2xvcikgeworICBSZXRhaW5QdHI8Q1BERl9EaWN0aW9uYXJ5PiByb290X2RpY3QgPSBkb2MtPkdldE11dGFibGVSb290KCk7CisgIGlmICghcm9vdF9kaWN0KSB7CisgICAgcmV0dXJuIGZhbHNlOworICB9CisKKyAgUmV0YWluUHRyPENQREZfRGljdGlvbmFyeT4gYWNyb2Zvcm1fZGljdCA9CisgICAgICByb290X2RpY3QtPkdldE11dGFibGVEaWN0Rm9yKCJBY3JvRm9ybSIpOworICBpZiAoIWFjcm9mb3JtX2RpY3QpIHsKKyAgICBhY3JvZm9ybV9kaWN0ID0gQ1BERl9JbnRlcmFjdGl2ZUZvcm06OkluaXRBY3JvRm9ybURpY3QoZG9jKTsKKyAgICBDSEVDSyhhY3JvZm9ybV9kaWN0KTsKKyAgfQorCisgIENQREZfRGVmYXVsdEFwcGVhcmFuY2UgZGVmYXVsdF9hcHBlYXJhbmNlKGFubm90X2RpY3QsIGFjcm9mb3JtX2RpY3QpOworICBhdXRvIG1heWJlX2ZvbnRfbmFtZV9hbmRfc2l6ZSA9IGRlZmF1bHRfYXBwZWFyYW5jZS5HZXRGb250KCk7CisgIGlmICghbWF5YmVfZm9udF9uYW1lX2FuZF9zaXplLmhhc192YWx1ZSgpKSB7CisgICAgcmV0dXJuIGZhbHNlOworICB9CisKKyAgQnl0ZVN0cmluZyBuZXdfZGVmYXVsdF9hcHBlYXJhbmNlX2ZvbnRfbmFtZV9hbmRfc2l6ZSA9CisgICAgICBTdHJpbmdGcm9tRm9udE5hbWVBbmRTaXplKG1heWJlX2ZvbnRfbmFtZV9hbmRfc2l6ZS52YWx1ZSgpLm5hbWUsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIG1heWJlX2ZvbnRfbmFtZV9hbmRfc2l6ZS52YWx1ZSgpLnNpemUpOworICBpZiAobmV3X2RlZmF1bHRfYXBwZWFyYW5jZV9mb250X25hbWVfYW5kX3NpemUuSXNFbXB0eSgpKSB7CisgICAgcmV0dXJuIGZhbHNlOworICB9CisKKyAgQnl0ZVN0cmluZyBuZXdfZGVmYXVsdF9hcHBlYXJhbmNlX2NvbG9yID0KKyAgICAgIEdlbmVyYXRlQ29sb3JBUChjb2xvciwgUGFpbnRPcGVyYXRpb246OmtGaWxsKTsKKyAgQ0hFQ0soIW5ld19kZWZhdWx0X2FwcGVhcmFuY2VfY29sb3IuSXNFbXB0eSgpKTsKKyAgYW5ub3RfZGljdC0+U2V0TmV3Rm9yPENQREZfU3RyaW5nPigKKyAgICAgICJEQSIsCisgICAgICBuZXdfZGVmYXVsdF9hcHBlYXJhbmNlX2ZvbnRfbmFtZV9hbmRfc2l6ZSArIG5ld19kZWZhdWx0X2FwcGVhcmFuY2VfY29sb3IpOworCisgIC8vIFRPRE8odGhlc3RpZyk6IENhbGwgR2VuZXJhdGVBbm5vdEFQKCk7CisgIHJldHVybiB0cnVlOworfQpkaWZmIC0tZ2l0IGEvY29yZS9mcGRmZG9jL2NwZGZfZ2VuZXJhdGVhcC5oIGIvY29yZS9mcGRmZG9jL2NwZGZfZ2VuZXJhdGVhcC5oCmluZGV4IDUyMGNlNGYuLjYwYjE1OGIgMTAwNjQ0Ci0tLSBhL2NvcmUvZnBkZmRvYy9jcGRmX2dlbmVyYXRlYXAuaAorKysgYi9jb3JlL2ZwZGZkb2MvY3BkZl9nZW5lcmF0ZWFwLmgKQEAgLTExLDYgKzExLDcgQEAKIAogY2xhc3MgQ1BERl9EaWN0aW9uYXJ5OwogY2xhc3MgQ1BERl9Eb2N1bWVudDsKK3N0cnVjdCBDRlhfQ29sb3I7CiAKIGNsYXNzIENQREZfR2VuZXJhdGVBUCB7CiAgcHVibGljOgpAQCAtMjYsNiArMjcsMTAgQEAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIENQREZfRGljdGlvbmFyeSogcEFubm90RGljdCwKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIENQREZfQW5ub3Q6OlN1YnR5cGUgc3VidHlwZSk7CiAKKyAgc3RhdGljIGJvb2wgR2VuZXJhdGVEZWZhdWx0QXBwZWFyYW5jZVdpdGhDb2xvcihDUERGX0RvY3VtZW50KiBkb2MsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgQ1BERl9EaWN0aW9uYXJ5KiBhbm5vdF9kaWN0LAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGNvbnN0IENGWF9Db2xvciYgY29sb3IpOworCiAgIENQREZfR2VuZXJhdGVBUCgpID0gZGVsZXRlOwogICBDUERGX0dlbmVyYXRlQVAoY29uc3QgQ1BERl9HZW5lcmF0ZUFQJikgPSBkZWxldGU7CiAgIENQREZfR2VuZXJhdGVBUCYgb3BlcmF0b3I9KGNvbnN0IENQREZfR2VuZXJhdGVBUCYpID0gZGVsZXRlOwpkaWZmIC0tZ2l0IGEvY29yZS9mcGRmZG9jL2NwZGZfaW50ZXJhY3RpdmVmb3JtLmggYi9jb3JlL2ZwZGZkb2MvY3BkZl9pbnRlcmFjdGl2ZWZvcm0uaAppbmRleCBlYTNhMDdhLi4zM2MwOTE3IDEwMDY0NAotLS0gYS9jb3JlL2ZwZGZkb2MvY3BkZl9pbnRlcmFjdGl2ZWZvcm0uaAorKysgYi9jb3JlL2ZwZGZkb2MvY3BkZl9pbnRlcmFjdGl2ZWZvcm0uaApAQCAtMTA1LDYgKzEwNSw4IEBACiAgIGNvbnN0IHN0ZDo6dmVjdG9yPFVub3duZWRQdHI8Q1BERl9Gb3JtQ29udHJvbD4+JiBHZXRDb250cm9sc0ZvckZpZWxkKAogICAgICAgY29uc3QgQ1BERl9Gb3JtRmllbGQqIGZpZWxkKTsKIAorICBDUERGX0RvY3VtZW50KiBkb2N1bWVudCgpIHsgcmV0dXJuIGRvY3VtZW50XzsgfQorCiAgcHJpdmF0ZToKICAgdm9pZCBMb2FkRmllbGQoUmV0YWluUHRyPENQREZfRGljdGlvbmFyeT4gZmllbGRfZGljdCwgaW50IG5MZXZlbCk7CiAgIHZvaWQgQWRkVGVybWluYWxGaWVsZChSZXRhaW5QdHI8Q1BERl9EaWN0aW9uYXJ5PiBmaWVsZF9kaWN0KTsKZGlmZiAtLWdpdCBhL2ZwZGZzZGsvZnBkZl9hbm5vdC5jcHAgYi9mcGRmc2RrL2ZwZGZfYW5ub3QuY3BwCmluZGV4IGQyNTk5MDguLjJlYWQ1ODEgMTAwNjQ0Ci0tLSBhL2ZwZGZzZGsvZnBkZl9hbm5vdC5jcHAKKysrIGIvZnBkZnNkay9mcGRmX2Fubm90LmNwcApAQCAtMTQ4NCw2ICsxNDg0LDQ2IEBACiB9CiAKIEZQREZfRVhQT1JUIEZQREZfQk9PTCBGUERGX0NBTExDT05WCitGUERGQW5ub3RfU2V0Rm9udENvbG9yKEZQREZfRk9STUhBTkRMRSBoYW5kbGUsCisgICAgICAgICAgICAgICAgICAgICAgIEZQREZfQU5OT1RBVElPTiBhbm5vdCwKKyAgICAgICAgICAgICAgICAgICAgICAgdW5zaWduZWQgaW50IFIsCisgICAgICAgICAgICAgICAgICAgICAgIHVuc2lnbmVkIGludCBHLAorICAgICAgICAgICAgICAgICAgICAgICB1bnNpZ25lZCBpbnQgQikgeworICBSZXRhaW5QdHI8Q1BERl9EaWN0aW9uYXJ5PiBhbm5vdF9kaWN0ID0KKyAgICAgIEdldE11dGFibGVBbm5vdERpY3RGcm9tRlBERkFubm90YXRpb24oYW5ub3QpOworICBpZiAoIWFubm90X2RpY3QgfHwgUiA+IDI1NSB8fCBHID4gMjU1IHx8IEIgPiAyNTUpIHsKKyAgICByZXR1cm4gZmFsc2U7CisgIH0KKworICBjb25zdCBDUERGX0Fubm90OjpTdWJ0eXBlIHN1YnR5cGUgPSBDUERGX0Fubm90OjpTdHJpbmdUb0Fubm90U3VidHlwZSgKKyAgICAgIGFubm90X2RpY3QtPkdldE5hbWVGb3IocGRmaXVtOjphbm5vdGF0aW9uOjprU3VidHlwZSkpOworICBpZiAoc3VidHlwZSAhPSBDUERGX0Fubm90OjpTdWJ0eXBlOjpGUkVFVEVYVCkgeworICAgIC8vIFRPRE8odGhlc3RpZyk6IENvbnNpZGVyIGFkZGluZyB3aWRnZXQgc3VwcG9ydCB0byBtaXJyb3IKKyAgICAvLyBGUERGQW5ub3RfR2V0Rm9udENvbG9yKCkuCisgICAgcmV0dXJuIGZhbHNlOworICB9CisKKyAgQ1BERlNES19JbnRlcmFjdGl2ZUZvcm0qIGZvcm0gPSBGb3JtSGFuZGxlVG9JbnRlcmFjdGl2ZUZvcm0oaGFuZGxlKTsKKyAgaWYgKCFmb3JtKSB7CisgICAgcmV0dXJuIGZhbHNlOworICB9CisKKyAgYm9vbCBnZW5lcmF0ZWQgPSBDUERGX0dlbmVyYXRlQVA6OkdlbmVyYXRlRGVmYXVsdEFwcGVhcmFuY2VXaXRoQ29sb3IoCisgICAgICBmb3JtLT5HZXRJbnRlcmFjdGl2ZUZvcm0oKS0+ZG9jdW1lbnQoKSwgYW5ub3RfZGljdCwgQ0ZYX0NvbG9yKFIsIEcsIEIpKTsKKyAgaWYgKCFnZW5lcmF0ZWQpIHsKKyAgICByZXR1cm4gZmFsc2U7CisgIH0KKworICAvLyBSZW1vdmUgdGhlIGFwcGVhcmFuY2Ugc3RyZWFtLiBPdGhlcndpc2UgUERGIHZpZXdlcnMgd2lsbCByZW5kZXIgdGhhdCBhbmQKKyAgLy8gbm90IHVzZSB0aGUgbmV3IGNvbG9yLgorICAvLworICAvLyBUT0RPKHRoZXN0aWcpIFdoZW4gR2VuZXJhdGVEZWZhdWx0QXBwZWFyYW5jZVdpdGhDb2xvcigpIHByb3Blcmx5IHVwZGF0ZXMKKyAgLy8gdGhlIGFubm90YXRpb24ncyBhcHBlYXJhbmNlIHN0cmVhbSwgcmVtb3ZlIHRoaXMuCisgIGFubm90X2RpY3QtPlJlbW92ZUZvcihwZGZpdW06OmFubm90YXRpb246OmtBUCk7CisgIHJldHVybiB0cnVlOworfQorCitGUERGX0VYUE9SVCBGUERGX0JPT0wgRlBERl9DQUxMQ09OVgogRlBERkFubm90X0dldEZvbnRDb2xvcihGUERGX0ZPUk1IQU5ETEUgaEhhbmRsZSwKICAgICAgICAgICAgICAgICAgICAgICAgRlBERl9BTk5PVEFUSU9OIGFubm90LAogICAgICAgICAgICAgICAgICAgICAgICB1bnNpZ25lZCBpbnQqIFIsCmRpZmYgLS1naXQgYS9mcGRmc2RrL2ZwZGZfYW5ub3RfZW1iZWRkZXJ0ZXN0LmNwcCBiL2ZwZGZzZGsvZnBkZl9hbm5vdF9lbWJlZGRlcnRlc3QuY3BwCmluZGV4IGQ2NjYxMjIuLjA0MTdmNzQgMTAwNjQ0Ci0tLSBhL2ZwZGZzZGsvZnBkZl9hbm5vdF9lbWJlZGRlcnRlc3QuY3BwCisrKyBiL2ZwZGZzZGsvZnBkZl9hbm5vdF9lbWJlZGRlcnRlc3QuY3BwCkBAIC0yNzQ1LDYgKzI3NDUsOTggQEAKICAgfQogfQogCitURVNUX0YoRlBERkFubm90RW1iZWRkZXJUZXN0LCBTZXRGb250Q29sb3IpIHsKKyAgc3RhdGljIGNvbnN0ZXhwciBpbnQga0RpbWVuc2lvbiA9IDIwMDsKKyAgY29uc3QgY2hhciogb3JpZ2luYWxfY2hlY2tzdW0gPSBbXSgpIHsKKyAgICBpZiAoQ0ZYX0RlZmF1bHRSZW5kZXJEZXZpY2U6OlVzZVNraWFSZW5kZXJlcigpKSB7CisjaWYgQlVJTERGTEFHKElTX1dJTikKKyAgICAgIHJldHVybiAiN2U1YjI4YzA5NWM3OTRmYWQzMmFiNmQ0MmEyZjg3MmYiOworI2VsaWYgQlVJTERGTEFHKElTX0FQUExFKQorICAgICAgcmV0dXJuICIxMzM0OWJmMzBiODAyNTBlMWIyZmExZjQxMGNmZGYwMiI7CisjZWxzZQorICAgICAgcmV0dXJuICJjYjUwNGRkNjQ2NWM3ODA4ODdlYzA1MWRmMTk5MTJiYiI7CisjZW5kaWYKKyAgICB9CisjaWYgQlVJTERGTEFHKElTX0FQUExFKQorICAgIHJldHVybiAiZDAwYjVlNjY5ZTkyMmYyZTFlOWI0NDJjOGI4OTYwNTYiOworI2Vsc2UKKyAgICByZXR1cm4gIjdmMmU3NzdkODhhOGM0ZDkxNGNmNGJkMzhlOWZkZjBkIjsKKyNlbmRpZgorICB9KCk7CisgIGNvbnN0IGNoYXIqIG1vZGlmaWVkX2NoZWNrc3VtID0gW10oKSB7CisgICAgaWYgKENGWF9EZWZhdWx0UmVuZGVyRGV2aWNlOjpVc2VTa2lhUmVuZGVyZXIoKSkgeworI2lmIEJVSUxERkxBRyhJU19XSU4pCisgICAgICByZXR1cm4gIjA1NmVlZjFmZmNiZjUyMmU2NDE0MmVlOTljNTBkNmVjIjsKKyNlbGlmIEJVSUxERkxBRyhJU19BUFBMRSkKKyAgICAgIHJldHVybiAiYzczNjc5M2M0YzlmODljOWMxOTJkNDAwZDg0ZjY5NzkiOworI2Vsc2UKKyAgICAgIHJldHVybiAiMTQwN2UzOWZkNWVlMmQ5OTljNjJlNjQyODIxYTMzYWIiOworI2VuZGlmCisgICAgfQorI2lmIEJVSUxERkxBRyhJU19BUFBMRSkKKyAgICByZXR1cm4gIjE5NzdiMzgyMDQ2MGMzYTAxZjEwNDdkMzBhMGRhMjVmIjsKKyNlbHNlCisgICAgcmV0dXJuICI1YjMzOTA1MWY1NmQ0OGRkNzMxNGM4NGUxMDZhN2M4MiI7CisjZW5kaWYKKyAgfSgpOworCisgIEFTU0VSVF9UUlVFKE9wZW5Eb2N1bWVudCgiZnJlZXRleHRfYW5ub3RhdGlvbl93aXRob3V0X2RhLnBkZiIpKTsKKyAgU2NvcGVkUGFnZSBwYWdlID0gTG9hZFNjb3BlZFBhZ2UoMCk7CisgIEFTU0VSVF9UUlVFKHBhZ2UpOworCisgIHsKKyAgICBTY29wZWRGUERGQml0bWFwIGJpdG1hcCA9IFJlbmRlckxvYWRlZFBhZ2VXaXRoRmxhZ3MocGFnZS5nZXQoKSwgRlBERl9BTk5PVCk7CisgICAgQ29tcGFyZUJpdG1hcChiaXRtYXAuZ2V0KCksIGtEaW1lbnNpb24sIGtEaW1lbnNpb24sIG9yaWdpbmFsX2NoZWNrc3VtKTsKKworICAgIC8vIE9idGFpbiB0aGUgb25seSBhbm5vdGF0aW9uIGFuZCBzZXQgaXRzIHRleHQgY29sb3IuCisgICAgU2NvcGVkRlBERkFubm90YXRpb24gYW5ub3QoRlBERlBhZ2VfR2V0QW5ub3QocGFnZS5nZXQoKSwgMCkpOworICAgIEFTU0VSVF9UUlVFKGFubm90KTsKKworICAgIC8vIFRPRE8odGhlc3RpZyk6IENoZWNrIEZQREZBbm5vdF9HZXRGb250Q29sb3IoKSByZXN1bHRzIGJlZm9yZSBhbmQgYWZ0ZXIsCisgICAgLy8gd2hlbiB0aGUgQVBJIHN1cHBvcnRzIGZyZWV0ZXh0IGFubm90YXRpb25zLgorICAgIEFTU0VSVF9UUlVFKAorICAgICAgICBGUERGQW5ub3RfU2V0Rm9udENvbG9yKGZvcm1faGFuZGxlKCksIGFubm90LmdldCgpLCA2MCwgMTIwLCAxODApKTsKKyAgICBiaXRtYXAgPSBSZW5kZXJMb2FkZWRQYWdlV2l0aEZsYWdzKHBhZ2UuZ2V0KCksIEZQREZfQU5OT1QpOworICAgIENvbXBhcmVCaXRtYXAoYml0bWFwLmdldCgpLCBrRGltZW5zaW9uLCBrRGltZW5zaW9uLCBtb2RpZmllZF9jaGVja3N1bSk7CisgIH0KKworICBFWFBFQ1RfVFJVRShGUERGX1NhdmVBc0NvcHkoZG9jdW1lbnQoKSwgdGhpcywgMCkpOworCisgIEFTU0VSVF9UUlVFKE9wZW5TYXZlZERvY3VtZW50KCkpOworICBGUERGX1BBR0Ugc2F2ZWRfcGFnZSA9IExvYWRTYXZlZFBhZ2UoMCk7CisgIEFTU0VSVF9UUlVFKHNhdmVkX3BhZ2UpOworICBWZXJpZnlTYXZlZFJlbmRlcmluZyhzYXZlZF9wYWdlLCBrRGltZW5zaW9uLCBrRGltZW5zaW9uLCBtb2RpZmllZF9jaGVja3N1bSk7CisKKyAgQ2xvc2VTYXZlZFBhZ2Uoc2F2ZWRfcGFnZSk7CisgIENsb3NlU2F2ZWREb2N1bWVudCgpOworfQorCitURVNUX0YoRlBERkFubm90RW1iZWRkZXJUZXN0LCBTZXRGb250Q29sb3JOZWdhdGl2ZSkgeworICBBU1NFUlRfVFJVRShPcGVuRG9jdW1lbnQoInRleHRfZm9ybV9jb2xvci5wZGYiKSk7CisgIFNjb3BlZFBhZ2UgcGFnZSA9IExvYWRTY29wZWRQYWdlKDApOworICBBU1NFUlRfVFJVRShwYWdlKTsKKworICB7CisgICAgLy8gT2J0YWluIHRoZSBmaXJzdCBhbm5vdGF0aW9uLCBhIHRleHQgZmllbGQgd2l0aCBvcmFuZ2UgY29sb3IuCisgICAgU2NvcGVkRlBERkFubm90YXRpb24gYW5ub3QoRlBERlBhZ2VfR2V0QW5ub3QocGFnZS5nZXQoKSwgMCkpOworICAgIEFTU0VSVF9UUlVFKGFubm90KTsKKworICAgIC8vIE5lZ2F0aXZlIHRlc3Rpbmcgd2l0aCBpbnZhbGlkIHBhcmFtZXRlcnMuCisgICAgQVNTRVJUX0ZBTFNFKEZQREZBbm5vdF9TZXRGb250Q29sb3IobnVsbHB0ciwgbnVsbHB0ciwgMjU2LCAyNTYsIDI1NikpOworICAgIEFTU0VSVF9GQUxTRShGUERGQW5ub3RfU2V0Rm9udENvbG9yKGZvcm1faGFuZGxlKCksIG51bGxwdHIsIDAsIDAsIDApKTsKKyAgICBBU1NFUlRfRkFMU0UoRlBERkFubm90X1NldEZvbnRDb2xvcihudWxscHRyLCBhbm5vdC5nZXQoKSwgMCwgMCwgMCkpOworICAgIEFTU0VSVF9GQUxTRShGUERGQW5ub3RfU2V0Rm9udENvbG9yKG51bGxwdHIsIG51bGxwdHIsIDI1NiwgMCwgMCkpOworICAgIEFTU0VSVF9GQUxTRShGUERGQW5ub3RfU2V0Rm9udENvbG9yKG51bGxwdHIsIG51bGxwdHIsIDAsIDI1NiwgMCkpOworICAgIEFTU0VSVF9GQUxTRShGUERGQW5ub3RfU2V0Rm9udENvbG9yKG51bGxwdHIsIG51bGxwdHIsIDAsIDAsIDI1NikpOworCisgICAgLy8gVGhlIHRleHQgZmllbGQgd2lkZ2V0IGluIHRoZSBQREYgaXMgbm90IHN1cHBvcnRlZCB5ZXQuCisgICAgLy8gVE9ETyh0aGVzdGlnKTogTW92ZSBvdXQgb2YgdGhpcyB0ZXN0IGNhc2UgYW5kIG1ha2Ugc3VyZSB0aGlzIHN1Y2NlZWRzCisgICAgLy8gYWZ0ZXIgYWRkaW5nIHN1cHBvcnQuCisgICAgQVNTRVJUX0ZBTFNFKAorICAgICAgICBGUERGQW5ub3RfU2V0Rm9udENvbG9yKGZvcm1faGFuZGxlKCksIGFubm90LmdldCgpLCA2MCwgMTIwLCAxODApKTsKKyAgfQorfQorCiBURVNUX0YoRlBERkFubm90RW1iZWRkZXJUZXN0LCBHZXRGb250Q29sb3IpIHsKICAgLy8gT3BlbiBhIGZpbGUgd2l0aCB0ZXh0ZmllbGQgYW5ub3RhdGlvbnMgYW5kIGxvYWQgaXRzIGZpcnN0IHBhZ2UuCiAgIEFTU0VSVF9UUlVFKE9wZW5Eb2N1bWVudCgidGV4dF9mb3JtX2NvbG9yLnBkZiIpKTsKZGlmZiAtLWdpdCBhL2ZwZGZzZGsvZnBkZl92aWV3X2NfYXBpX3Rlc3QuYyBiL2ZwZGZzZGsvZnBkZl92aWV3X2NfYXBpX3Rlc3QuYwppbmRleCA2MDQ4YTk0Li5kMmVjOTJlIDEwMDY0NAotLS0gYS9mcGRmc2RrL2ZwZGZfdmlld19jX2FwaV90ZXN0LmMKKysrIGIvZnBkZnNkay9mcGRmX3ZpZXdfY19hcGlfdGVzdC5jCkBAIC05NCw2ICs5NCw3IEBACiAgICAgQ0hLKEZQREZBbm5vdF9TZXRDb2xvcik7CiAgICAgQ0hLKEZQREZBbm5vdF9TZXRGbGFncyk7CiAgICAgQ0hLKEZQREZBbm5vdF9TZXRGb2N1c2FibGVTdWJ0eXBlcyk7CisgICAgQ0hLKEZQREZBbm5vdF9TZXRGb250Q29sb3IpOwogICAgIENISyhGUERGQW5ub3RfU2V0Rm9ybUZpZWxkRmxhZ3MpOwogICAgIENISyhGUERGQW5ub3RfU2V0UmVjdCk7CiAgICAgQ0hLKEZQREZBbm5vdF9TZXRTdHJpbmdWYWx1ZSk7CmRpZmYgLS1naXQgYS9wdWJsaWMvZnBkZl9hbm5vdC5oIGIvcHVibGljL2ZwZGZfYW5ub3QuaAppbmRleCA1MjVhOWY5Li4wYWE5ZjY4IDEwMDY0NAotLS0gYS9wdWJsaWMvZnBkZl9hbm5vdC5oCisrKyBiL3B1YmxpYy9mcGRmX2Fubm90LmgKQEAgLTg2MCw2ICs4NjAsMjcgQEAKICAgICAgICAgICAgICAgICAgICAgICBmbG9hdCogdmFsdWUpOwogCiAvLyBFeHBlcmltZW50YWwgQVBJLgorLy8gU2V0IHRoZSB0ZXh0IGNvbG9yIG9mIGFuIGFubm90YXRpb24uCisvLworLy8gICBoYW5kbGUgICAtIGhhbmRsZSB0byB0aGUgZm9ybSBmaWxsIG1vZHVsZSwgcmV0dXJuZWQgYnkKKy8vICAgICAgICAgICAgICBGUERGRE9DX0luaXRGb3JtRmlsbEVudmlyb25tZW50LgorLy8gICBhbm5vdCAgICAtIGhhbmRsZSB0byBhbiBhbm5vdGF0aW9uLgorLy8gICBSICAgICAgICAtIHRoZSByZWQgY29tcG9uZW50IGZvciB0aGUgdGV4dCBjb2xvci4KKy8vICAgRyAgICAgICAgLSB0aGUgZ3JlZW4gY29tcG9uZW50IGZvciB0aGUgdGV4dCBjb2xvci4KKy8vICAgQiAgICAgICAgLSB0aGUgYmx1ZSBjb21wb25lbnQgZm9yIHRoZSB0ZXh0IGNvbG9yLgorLy8KKy8vIFJldHVybnMgdHJ1ZSBpZiBzdWNjZXNzZnVsLgorLy8KKy8vIEN1cnJlbnRseSBzdXBwb3J0ZWQgc3VidHlwZXM6IGZyZWV0ZXh0LgorLy8gVGhlIHJhbmdlIGZvciB0aGUgY29sb3IgY29tcG9uZW50cyBpcyAwIHRvIDI1NS4KK0ZQREZfRVhQT1JUIEZQREZfQk9PTCBGUERGX0NBTExDT05WCitGUERGQW5ub3RfU2V0Rm9udENvbG9yKEZQREZfRk9STUhBTkRMRSBoYW5kbGUsCisgICAgICAgICAgICAgICAgICAgICAgIEZQREZfQU5OT1RBVElPTiBhbm5vdCwKKyAgICAgICAgICAgICAgICAgICAgICAgdW5zaWduZWQgaW50IFIsCisgICAgICAgICAgICAgICAgICAgICAgIHVuc2lnbmVkIGludCBHLAorICAgICAgICAgICAgICAgICAgICAgICB1bnNpZ25lZCBpbnQgQik7CisKKy8vIEV4cGVyaW1lbnRhbCBBUEkuCiAvLyBHZXQgdGhlIFJHQiB2YWx1ZSBvZiB0aGUgZm9udCBjb2xvciBmb3IgYW4gfGFubm90fCB3aXRoIHZhcmlhYmxlIHRleHQuCiAvLwogLy8gICBoSGFuZGxlICAtIGhhbmRsZSB0byB0aGUgZm9ybSBmaWxsIG1vZHVsZSwgcmV0dXJuZWQgYnkKZGlmZiAtLWdpdCBhL3Rlc3RpbmcvcmVzb3VyY2VzL2ZyZWV0ZXh0X2Fubm90YXRpb25fd2l0aG91dF9kYS5wZGYgYi90ZXN0aW5nL3Jlc291cmNlcy9mcmVldGV4dF9hbm5vdGF0aW9uX3dpdGhvdXRfZGEucGRmCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLmU2OGYzNDQKLS0tIC9kZXYvbnVsbAorKysgYi90ZXN0aW5nL3Jlc291cmNlcy9mcmVldGV4dF9hbm5vdGF0aW9uX3dpdGhvdXRfZGEucGRmCkBAIC0wLDAgKzEsMjkgQEAKKyVQREYtMS43DQorJaGzxdcNCisxIDAgb2JqDQorPDwvUGFnZXMgMiAwIFIgL1R5cGUvQ2F0YWxvZz4+DQorZW5kb2JqDQorMiAwIG9iag0KKzw8L0NvdW50IDEvS2lkc1sgNCAwIFIgXS9UeXBlL1BhZ2VzPj4NCitlbmRvYmoNCiszIDAgb2JqDQorPDwvQ3JlYXRpb25EYXRlKEQ6MjAyNDExMjIxMTAxMjApL0NyZWF0b3IoUERGaXVtKT4+DQorZW5kb2JqDQorNCAwIG9iag0KKzw8L0Fubm90c1s8PC9DWyAxIDAgMF0vQ0EgMS9Db250ZW50cyhIZWxsbyEpL1JlY3RbIDEwMCA1MCAxNTAgNzVdL1N1YnR5cGUvRnJlZVRleHQvVHlwZS9Bbm5vdD4+XS9NZWRpYUJveFsgMCAwIDIwMCAyMDBdL1BhcmVudCAyIDAgUiAvUmVzb3VyY2VzPDw+Pi9Sb3RhdGUgMC9UeXBlL1BhZ2U+Pg0KK2VuZG9iag0KK3hyZWYNCiswIDUNCiswMDAwMDAwMDAwIDY1NTM1IGYNCiswMDAwMDAwMDE3IDAwMDAwIG4NCiswMDAwMDAwMDY2IDAwMDAwIG4NCiswMDAwMDAwMTIyIDAwMDAwIG4NCiswMDAwMDAwMTkyIDAwMDAwIG4NCit0cmFpbGVyDQorPDwNCisvUm9vdCAxIDAgUg0KKy9JbmZvIDMgMCBSDQorL1NpemUgNS9JRFs8MDUwOTNCQTg3QUNCNzM0QUUwMkZEMkE5NzlBNTU1Nzc+PDA1MDkzQkE4N0FDQjczNEFFMDJGRDJBOTc5QTU1NTc3Pl0+Pg0KK3N0YXJ0eHJlZg0KKzM3OQ0KKyUlRU9GDQo=