LyogQm9vc3QgaW50ZXJ2YWwvZGV0YWlsL2ludGVydmFsX3Byb3RvdHlwZS5ocHAgZmlsZQogKgogKiBDb3B5cmlnaHQgMjAwMiBIZXJ26SBCcvZubmltYW5uLCBHdWlsbGF1bWUgTWVscXVpb25kLCBTeWx2YWluIFBpb24KICoKICogRGlzdHJpYnV0ZWQgdW5kZXIgdGhlIEJvb3N0IFNvZnR3YXJlIExpY2Vuc2UsIFZlcnNpb24gMS4wLgogKiAoU2VlIGFjY29tcGFueWluZyBmaWxlIExJQ0VOU0VfMV8wLnR4dCBvcgogKiBjb3B5IGF0IGh0dHA6Ly93d3cuYm9vc3Qub3JnL0xJQ0VOU0VfMV8wLnR4dCkKICovCgojaWZuZGVmIEJPT1NUX05VTUVSSUNfSU5URVJWQUxfREVUQUlMX0lOVEVSVkFMX1BST1RPVFlQRV9IUFAKI2RlZmluZSBCT09TVF9OVU1FUklDX0lOVEVSVkFMX0RFVEFJTF9JTlRFUlZBTF9QUk9UT1RZUEVfSFBQCgpuYW1lc3BhY2UgYm9vc3QgewpuYW1lc3BhY2UgbnVtZXJpYyB7CgpuYW1lc3BhY2UgaW50ZXJ2YWxfbGliIHsKCnRlbXBsYXRlPGNsYXNzIFQ+IHN0cnVjdCByb3VuZGVkX21hdGg7CnRlbXBsYXRlPGNsYXNzIFQ+IHN0cnVjdCBjaGVja2luZ19zdHJpY3Q7CmNsYXNzIGNvbXBhcmlzb25fZXJyb3I7CnRlbXBsYXRlPGNsYXNzIFJvdW5kaW5nLCBjbGFzcyBDaGVja2luZz4gc3RydWN0IHBvbGljaWVzOwoKLyoKICogZGVmYXVsdCBwb2xpY2llcyBjbGFzcwogKi8KCnRlbXBsYXRlPGNsYXNzIFQ+CnN0cnVjdCBkZWZhdWx0X3BvbGljaWVzCnsKICB0eXBlZGVmIHBvbGljaWVzPHJvdW5kZWRfbWF0aDxUPiwgY2hlY2tpbmdfc3RyaWN0PFQ+ID4gdHlwZTsKfTsKICAgIAp9IC8vIG5hbWVzcGFjZSBpbnRlcnZhbF9saWIKCnRlbXBsYXRlPGNsYXNzIFQsIGNsYXNzIFBvbGljaWVzID0gdHlwZW5hbWUgaW50ZXJ2YWxfbGliOjpkZWZhdWx0X3BvbGljaWVzPFQ+Ojp0eXBlID4KY2xhc3MgaW50ZXJ2YWw7ICAKCn0gLy8gbmFtZXNwYWNlIG51bWVyaWMKfSAvLyBuYW1lc3BhY2UgYm9vc3QKCiNlbmRpZiAvLyBCT09TVF9OVU1FUklDX0lOVEVSVkFMX0RFVEFJTF9JTlRFUlZBTF9QUk9UT1RZUEVfSFBQCg==