LyoKICogQ29weXJpZ2h0IKkgMjAwOSBJbnRlbCBDb3Jwb3JhdGlvbgogKgogKiBQZXJtaXNzaW9uIGlzIGhlcmVieSBncmFudGVkLCBmcmVlIG9mIGNoYXJnZSwgdG8gYW55IHBlcnNvbiBvYnRhaW5pbmcgYQogKiBjb3B5IG9mIHRoaXMgc29mdHdhcmUgYW5kIGFzc29jaWF0ZWQgZG9jdW1lbnRhdGlvbiBmaWxlcyAodGhlCiAqICJTb2Z0d2FyZSIpLCB0byBkZWFsIGluIHRoZSBTb2Z0d2FyZSB3aXRob3V0IHJlc3RyaWN0aW9uLCBpbmNsdWRpbmcKICogd2l0aG91dCBsaW1pdGF0aW9uIHRoZSByaWdodHMgdG8gdXNlLCBjb3B5LCBtb2RpZnksIG1lcmdlLCBwdWJsaXNoLAogKiBkaXN0cmlidXRlLCBzdWIgbGljZW5zZSwgYW5kL29yIHNlbGwgY29waWVzIG9mIHRoZSBTb2Z0d2FyZSwgYW5kIHRvCiAqIHBlcm1pdCBwZXJzb25zIHRvIHdob20gdGhlIFNvZnR3YXJlIGlzIGZ1cm5pc2hlZCB0byBkbyBzbywgc3ViamVjdCB0bwogKiB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnM6CiAqCiAqIFRoZSBhYm92ZSBjb3B5cmlnaHQgbm90aWNlIGFuZCB0aGlzIHBlcm1pc3Npb24gbm90aWNlIChpbmNsdWRpbmcgdGhlCiAqIG5leHQgcGFyYWdyYXBoKSBzaGFsbCBiZSBpbmNsdWRlZCBpbiBhbGwgY29waWVzIG9yIHN1YnN0YW50aWFsIHBvcnRpb25zCiAqIG9mIHRoZSBTb2Z0d2FyZS4KICoKICogVEhFIFNPRlRXQVJFIElTIFBST1ZJREVEICJBUyBJUyIsIFdJVEhPVVQgV0FSUkFOVFkgT0YgQU5ZIEtJTkQsIEVYUFJFU1MKICogT1IgSU1QTElFRCwgSU5DTFVESU5HIEJVVCBOT1QgTElNSVRFRCBUTyBUSEUgV0FSUkFOVElFUyBPRgogKiBNRVJDSEFOVEFCSUxJVFksIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFIEFORCBOT04tSU5GUklOR0VNRU5ULgogKiBJTiBOTyBFVkVOVCBTSEFMTCBQUkVDSVNJT04gSU5TSUdIVCBBTkQvT1IgSVRTIFNVUFBMSUVSUyBCRSBMSUFCTEUgRk9SCiAqIEFOWSBDTEFJTSwgREFNQUdFUyBPUiBPVEhFUiBMSUFCSUxJVFksIFdIRVRIRVIgSU4gQU4gQUNUSU9OIE9GIENPTlRSQUNULAogKiBUT1JUIE9SIE9USEVSV0lTRSwgQVJJU0lORyBGUk9NLCBPVVQgT0YgT1IgSU4gQ09OTkVDVElPTiBXSVRIIFRIRQogKiBTT0ZUV0FSRSBPUiBUSEUgVVNFIE9SIE9USEVSIERFQUxJTkdTIElOIFRIRSBTT0ZUV0FSRS4KICoKICogQXV0aG9yczoKICogICAgWGlhbmcgSGFpaGFvIDxoYWloYW8ueGlhbmdAaW50ZWwuY29tPgogKiAgICBab3UgTmFuIGhhaSA8bmFuaGFpLnpvdUBpbnRlbC5jb20+CiAqCiAqLwoKI2lmbmRlZiBfSTk2NV9EUlZfVklERU9fSF8KI2RlZmluZSBfSTk2NV9EUlZfVklERU9fSF8KCiNpbmNsdWRlICJ2YS5oIgojaW5jbHVkZSAib2JqZWN0X2hlYXAuaCIKCiNpbmNsdWRlICJpbnRlbF9kcml2ZXIuaCIKCiNpbmNsdWRlICJpOTY1X21lZGlhLmgiCiNpbmNsdWRlICJpOTY1X3JlbmRlci5oIgoKI2RlZmluZSBJOTY1X01BWF9QUk9GSUxFUyAgICAgICAgICAgICAgICAgICAgICAgMTEKI2RlZmluZSBJOTY1X01BWF9FTlRSWVBPSU5UUyAgICAgICAgICAgICAgICAgICAgNQojZGVmaW5lIEk5NjVfTUFYX0NPTkZJR19BVFRSSUJVVEVTICAgICAgICAgICAgICAxMAojZGVmaW5lIEk5NjVfTUFYX0lNQUdFX0ZPUk1BVFMgICAgICAgICAgICAgICAgICAxMAojZGVmaW5lIEk5NjVfTUFYX1NVQlBJQ19GT1JNQVRTICAgICAgICAgICAgICAgICAyCiNkZWZpbmUgSTk2NV9NQVhfRElTUExBWV9BVFRSSUJVVEVTICAgICAgICAgICAgIDQKI2RlZmluZSBJOTY1X1NUUl9WRU5ET1IgICAgICAgICAgICAgICAgICAgICAgICAgImk5NjUgRHJpdmVyIDAuMSIKCnN0cnVjdCBidWZmZXJfc3RvcmUKewogICAgdW5zaWduZWQgY2hhciAqYnVmZmVyOwogICAgZHJpX2JvICpibzsKICAgIGludCByZWZfY291bnQ7Cn07CiAgICAKc3RydWN0IG9iamVjdF9jb25maWcgCnsKICAgIHN0cnVjdCBvYmplY3RfYmFzZSBiYXNlOwogICAgVkFQcm9maWxlIHByb2ZpbGU7CiAgICBWQUVudHJ5cG9pbnQgZW50cnlwb2ludDsKICAgIFZBQ29uZmlnQXR0cmliIGF0dHJpYl9saXN0W0k5NjVfTUFYX0NPTkZJR19BVFRSSUJVVEVTXTsKICAgIGludCBudW1fYXR0cmliczsKfTsKCnN0cnVjdCBkZWNvZGVfc3RhdGUKewogICAgc3RydWN0IGJ1ZmZlcl9zdG9yZSAqcGljX3BhcmFtOwogICAgc3RydWN0IGJ1ZmZlcl9zdG9yZSAqc2xpY2VfcGFyYW07CiAgICBzdHJ1Y3QgYnVmZmVyX3N0b3JlICppcV9tYXRyaXg7CiAgICBzdHJ1Y3QgYnVmZmVyX3N0b3JlICpiaXRfcGxhbmU7CiAgICBzdHJ1Y3QgYnVmZmVyX3N0b3JlICpzbGljZV9kYXRhOwogICAgVkFTdXJmYWNlSUQgY3VycmVudF9yZW5kZXJfdGFyZ2V0OwogICAgaW50IG51bV9zbGljZXM7Cn07CgpzdHJ1Y3Qgb2JqZWN0X2NvbnRleHQgCnsKICAgIHN0cnVjdCBvYmplY3RfYmFzZSBiYXNlOwogICAgVkFDb250ZXh0SUQgY29udGV4dF9pZDsKICAgIFZBQ29uZmlnSUQgY29uZmlnX2lkOwogICAgVkFTdXJmYWNlSUQgKnJlbmRlcl90YXJnZXRzOwogICAgaW50IG51bV9yZW5kZXJfdGFyZ2V0czsKICAgIGludCBwaWN0dXJlX3dpZHRoOwogICAgaW50IHBpY3R1cmVfaGVpZ2h0OwogICAgaW50IGZsYWdzOwogICAgc3RydWN0IGRlY29kZV9zdGF0ZSBkZWNvZGVfc3RhdGU7Cn07CgpzdHJ1Y3Qgb2JqZWN0X3N1cmZhY2UgCnsKICAgIHN0cnVjdCBvYmplY3RfYmFzZSBiYXNlOwogICAgVkFTdXJmYWNlU3RhdHVzIHN0YXR1czsKICAgIFZBU3VicGljdHVyZUlEIHN1YnBpYzsKICAgIGludCB3aWR0aDsKICAgIGludCBoZWlnaHQ7CiAgICBpbnQgc2l6ZTsKICAgIGRyaV9ibyAqYm87Cn07CgpzdHJ1Y3Qgb2JqZWN0X2J1ZmZlciAKewogICAgc3RydWN0IG9iamVjdF9iYXNlIGJhc2U7CiAgICBzdHJ1Y3QgYnVmZmVyX3N0b3JlICpidWZmZXJfc3RvcmU7CiAgICBpbnQgbWF4X251bV9lbGVtZW50czsKICAgIGludCBudW1fZWxlbWVudHM7CiAgICBpbnQgc2l6ZV9lbGVtZW50OwogICAgVkFCdWZmZXJUeXBlIHR5cGU7Cn07CgpzdHJ1Y3Qgb2JqZWN0X2ltYWdlIAp7CiAgICBzdHJ1Y3Qgb2JqZWN0X2Jhc2UgYmFzZTsKICAgIFZBSW1hZ2UgaW1hZ2U7CiAgICBkcmlfYm8gKmJvOwogICAgdW5zaWduZWQgaW50ICpwYWxldHRlOwp9OwoKc3RydWN0IG9iamVjdF9zdWJwaWMgCnsKICAgIHN0cnVjdCBvYmplY3RfYmFzZSBiYXNlOwogICAgVkFJbWFnZUlEIGltYWdlOwogICAgVkFSZWN0YW5nbGUgc3JjX3JlY3Q7CiAgICBWQVJlY3RhbmdsZSBkc3RfcmVjdDsKICAgIHVuc2lnbmVkIGludCBmb3JtYXQ7CiAgICBpbnQgd2lkdGg7CiAgICBpbnQgaGVpZ2h0OwogICAgZHJpX2JvICpibzsKfTsKCgoKc3RydWN0IGk5NjVfZHJpdmVyX2RhdGEgCnsKICAgIHN0cnVjdCBpbnRlbF9kcml2ZXJfZGF0YSBpbnRlbDsKICAgIHN0cnVjdCBvYmplY3RfaGVhcCBjb25maWdfaGVhcDsKICAgIHN0cnVjdCBvYmplY3RfaGVhcCBjb250ZXh0X2hlYXA7CiAgICBzdHJ1Y3Qgb2JqZWN0X2hlYXAgc3VyZmFjZV9oZWFwOwogICAgc3RydWN0IG9iamVjdF9oZWFwIGJ1ZmZlcl9oZWFwOwogICAgc3RydWN0IG9iamVjdF9oZWFwIGltYWdlX2hlYXA7CiAgICBzdHJ1Y3Qgb2JqZWN0X2hlYXAgc3VicGljX2hlYXA7CiAgICBzdHJ1Y3QgaTk2NV9tZWRpYV9zdGF0ZSBtZWRpYV9zdGF0ZTsKICAgIHN0cnVjdCBpOTY1X3JlbmRlcl9zdGF0ZSByZW5kZXJfc3RhdGU7Cn07CgojZGVmaW5lIE5FV19DT05GSUdfSUQoKSBvYmplY3RfaGVhcF9hbGxvY2F0ZSgmaTk2NS0+Y29uZmlnX2hlYXApOwojZGVmaW5lIE5FV19DT05URVhUX0lEKCkgb2JqZWN0X2hlYXBfYWxsb2NhdGUoJmk5NjUtPmNvbnRleHRfaGVhcCk7CiNkZWZpbmUgTkVXX1NVUkZBQ0VfSUQoKSBvYmplY3RfaGVhcF9hbGxvY2F0ZSgmaTk2NS0+c3VyZmFjZV9oZWFwKTsKI2RlZmluZSBORVdfQlVGRkVSX0lEKCkgb2JqZWN0X2hlYXBfYWxsb2NhdGUoJmk5NjUtPmJ1ZmZlcl9oZWFwKTsKI2RlZmluZSBORVdfSU1BR0VfSUQoKSBvYmplY3RfaGVhcF9hbGxvY2F0ZSgmaTk2NS0+aW1hZ2VfaGVhcCk7CiNkZWZpbmUgTkVXX1NVQlBJQ19JRCgpIG9iamVjdF9oZWFwX2FsbG9jYXRlKCZpOTY1LT5zdWJwaWNfaGVhcCk7CgojZGVmaW5lIENPTkZJRyhpZCkgKChzdHJ1Y3Qgb2JqZWN0X2NvbmZpZyAqKW9iamVjdF9oZWFwX2xvb2t1cCgmaTk2NS0+Y29uZmlnX2hlYXAsIGlkKSkKI2RlZmluZSBDT05URVhUKGlkKSAoKHN0cnVjdCBvYmplY3RfY29udGV4dCAqKW9iamVjdF9oZWFwX2xvb2t1cCgmaTk2NS0+Y29udGV4dF9oZWFwLCBpZCkpCiNkZWZpbmUgU1VSRkFDRShpZCkgKChzdHJ1Y3Qgb2JqZWN0X3N1cmZhY2UgKilvYmplY3RfaGVhcF9sb29rdXAoJmk5NjUtPnN1cmZhY2VfaGVhcCwgaWQpKQojZGVmaW5lIEJVRkZFUihpZCkgKChzdHJ1Y3Qgb2JqZWN0X2J1ZmZlciAqKW9iamVjdF9oZWFwX2xvb2t1cCgmaTk2NS0+YnVmZmVyX2hlYXAsIGlkKSkKI2RlZmluZSBJTUFHRShpZCkgKChzdHJ1Y3Qgb2JqZWN0X2ltYWdlICopb2JqZWN0X2hlYXBfbG9va3VwKCZpOTY1LT5pbWFnZV9oZWFwLCBpZCkpCiNkZWZpbmUgU1VCUElDKGlkKSAoKHN0cnVjdCBvYmplY3Rfc3VicGljICopb2JqZWN0X2hlYXBfbG9va3VwKCZpOTY1LT5zdWJwaWNfaGVhcCwgaWQpKQoKI2RlZmluZSBGT1VSQ0NfSUE0NCAweDM0MzQ0MTQ5CiNkZWZpbmUgRk9VUkNDX0FJNDQgMHgzNDM0NDk0MQoKI2RlZmluZSBTVFJJREUodykgICAgICAgICAgICAgICAoKCh3KSArIDB4ZikgJiB+MHhmKQojZGVmaW5lIFNJWkVfWVVWNDIwKHcsIGgpICAgICAgIChoICogKFNUUklERSh3KSArIFNUUklERSh3ID4+IDEpKSkKCnN0YXRpYyBJTkxJTkUgc3RydWN0IGk5NjVfZHJpdmVyX2RhdGEgKgppOTY1X2RyaXZlcl9kYXRhKFZBRHJpdmVyQ29udGV4dFAgY3R4KQp7CiAgICByZXR1cm4gKHN0cnVjdCBpOTY1X2RyaXZlcl9kYXRhICopKGN0eC0+cERyaXZlckRhdGEpOwp9CgojZW5kaWYgLyogX0k5NjVfRFJWX1ZJREVPX0hfICovCg==