ZGlmZiAtLWdpdCBhL0RvY3VtZW50YXRpb24va2VybmVsLXBhcmFtZXRlcnMudHh0IGIvRG9jdW1lbnRhdGlvbi9rZXJuZWwtcGFyYW1ldGVycy50eHQKaW5kZXggNzJkM2JmMC4uN2JjZGViZiAxMDA2NDQKLS0tIGEvRG9jdW1lbnRhdGlvbi9rZXJuZWwtcGFyYW1ldGVycy50eHQKKysrIGIvRG9jdW1lbnRhdGlvbi9rZXJuZWwtcGFyYW1ldGVycy50eHQKQEAgLTEwODMsNiArMTA4MywxMCBAQAogCQkJQ29uZmlndXJlIHRoZSBSb3V0ZXJCb2FyZCA1MzIgc2VyaWVzIG9uLWNoaXAKIAkJCUV0aGVybmV0IGFkYXB0ZXIgTUFDIGFkZHJlc3MuCiAKKwlrbWVtbGVhaz0JW0tOTF0gQm9vdC10aW1lIGttZW1sZWFrIGVuYWJsZS9kaXNhYmxlCisJCQlWYWxpZCBhcmd1bWVudHM6IG9uLCBvZmYKKwkJCURlZmF1bHQ6IG9uCisKIAlrc3RhY2s9TglbWDg2XSBQcmludCBOIHdvcmRzIGZyb20gdGhlIGtlcm5lbCBzdGFjawogCQkJaW4gb29wcyBkdW1wcy4KIApkaWZmIC0tZ2l0IGEvRG9jdW1lbnRhdGlvbi9rbWVtbGVhay50eHQgYi9Eb2N1bWVudGF0aW9uL2ttZW1sZWFrLnR4dApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi4wMTEyZGEzCi0tLSAvZGV2L251bGwKKysrIGIvRG9jdW1lbnRhdGlvbi9rbWVtbGVhay50eHQKQEAgLTAsMCArMSwxNDIgQEAKK0tlcm5lbCBNZW1vcnkgTGVhayBEZXRlY3RvcgorPT09PT09PT09PT09PT09PT09PT09PT09PT09CisKK0ludHJvZHVjdGlvbgorLS0tLS0tLS0tLS0tCisKK0ttZW1sZWFrIHByb3ZpZGVzIGEgd2F5IG9mIGRldGVjdGluZyBwb3NzaWJsZSBrZXJuZWwgbWVtb3J5IGxlYWtzIGluIGEKK3dheSBzaW1pbGFyIHRvIGEgdHJhY2luZyBnYXJiYWdlIGNvbGxlY3RvcgorKGh0dHA6Ly9lbi53aWtpcGVkaWEub3JnL3dpa2kvR2FyYmFnZV9jb2xsZWN0aW9uXyUyOGNvbXB1dGVyX3NjaWVuY2UlMjkjVHJhY2luZ19nYXJiYWdlX2NvbGxlY3RvcnMpLAord2l0aCB0aGUgZGlmZmVyZW5jZSB0aGF0IHRoZSBvcnBoYW4gb2JqZWN0cyBhcmUgbm90IGZyZWVkIGJ1dCBvbmx5CityZXBvcnRlZCB2aWEgL3N5cy9rZXJuZWwvZGVidWcva21lbWxlYWsuIEEgc2ltaWxhciBtZXRob2QgaXMgdXNlZCBieSB0aGUKK1ZhbGdyaW5kIHRvb2wgKG1lbWNoZWNrIC0tbGVhay1jaGVjaykgdG8gZGV0ZWN0IHRoZSBtZW1vcnkgbGVha3MgaW4KK3VzZXItc3BhY2UgYXBwbGljYXRpb25zLgorCitVc2FnZQorLS0tLS0KKworQ09ORklHX0RFQlVHX0tNRU1MRUFLIGluICJLZXJuZWwgaGFja2luZyIgaGFzIHRvIGJlIGVuYWJsZWQuIEEga2VybmVsCit0aHJlYWQgc2NhbnMgdGhlIG1lbW9yeSBldmVyeSAxMCBtaW51dGVzIChieSBkZWZhdWx0KSBhbmQgcHJpbnRzIGFueSBuZXcKK3VucmVmZXJlbmNlZCBvYmplY3RzIGZvdW5kLiBUbyB0cmlnZ2VyIGFuIGludGVybWVkaWF0ZSBzY2FuIGFuZCBkaXNwbGF5CithbGwgdGhlIHBvc3NpYmxlIG1lbW9yeSBsZWFrczoKKworICAjIG1vdW50IC10IGRlYnVnZnMgbm9kZXYgL3N5cy9rZXJuZWwvZGVidWcvCisgICMgY2F0IC9zeXMva2VybmVsL2RlYnVnL2ttZW1sZWFrCisKK05vdGUgdGhhdCB0aGUgb3JwaGFuIG9iamVjdHMgYXJlIGxpc3RlZCBpbiB0aGUgb3JkZXIgdGhleSB3ZXJlIGFsbG9jYXRlZAorYW5kIG9uZSBvYmplY3QgYXQgdGhlIGJlZ2lubmluZyBvZiB0aGUgbGlzdCBtYXkgY2F1c2Ugb3RoZXIgc3Vic2VxdWVudAorb2JqZWN0cyB0byBiZSByZXBvcnRlZCBhcyBvcnBoYW4uCisKK01lbW9yeSBzY2FubmluZyBwYXJhbWV0ZXJzIGNhbiBiZSBtb2RpZmllZCBhdCBydW4tdGltZSBieSB3cml0aW5nIHRvIHRoZQorL3N5cy9rZXJuZWwvZGVidWcva21lbWxlYWsgZmlsZS4gVGhlIGZvbGxvd2luZyBwYXJhbWV0ZXJzIGFyZSBzdXBwb3J0ZWQ6CisKKyAgb2ZmCQktIGRpc2FibGUga21lbWxlYWsgKGlycmV2ZXJzaWJsZSkKKyAgc3RhY2s9b24JLSBlbmFibGUgdGhlIHRhc2sgc3RhY2tzIHNjYW5uaW5nCisgIHN0YWNrPW9mZgktIGRpc2FibGUgdGhlIHRhc2tzIHN0YWNrcyBzY2FubmluZworICBzY2FuPW9uCS0gc3RhcnQgdGhlIGF1dG9tYXRpYyBtZW1vcnkgc2Nhbm5pbmcgdGhyZWFkCisgIHNjYW49b2ZmCS0gc3RvcCB0aGUgYXV0b21hdGljIG1lbW9yeSBzY2FubmluZyB0aHJlYWQKKyAgc2Nhbj08c2Vjcz4JLSBzZXQgdGhlIGF1dG9tYXRpYyBtZW1vcnkgc2Nhbm5pbmcgcGVyaW9kIGluIHNlY29uZHMgKDAKKwkJICB0byBkaXNhYmxlIGl0KQorCitLbWVtbGVhayBjYW4gYWxzbyBiZSBkaXNhYmxlZCBhdCBib290LXRpbWUgYnkgcGFzc2luZyAia21lbWxlYWs9b2ZmIiBvbgordGhlIGtlcm5lbCBjb21tYW5kIGxpbmUuCisKK0Jhc2ljIEFsZ29yaXRobQorLS0tLS0tLS0tLS0tLS0tCisKK1RoZSBtZW1vcnkgYWxsb2NhdGlvbnMgdmlhIGttYWxsb2MsIHZtYWxsb2MsIGttZW1fY2FjaGVfYWxsb2MgYW5kCitmcmllbmRzIGFyZSB0cmFjZWQgYW5kIHRoZSBwb2ludGVycywgdG9nZXRoZXIgd2l0aCBhZGRpdGlvbmFsCitpbmZvcm1hdGlvbiBsaWtlIHNpemUgYW5kIHN0YWNrIHRyYWNlLCBhcmUgc3RvcmVkIGluIGEgcHJpbyBzZWFyY2ggdHJlZS4KK1RoZSBjb3JyZXNwb25kaW5nIGZyZWVpbmcgZnVuY3Rpb24gY2FsbHMgYXJlIHRyYWNrZWQgYW5kIHRoZSBwb2ludGVycworcmVtb3ZlZCBmcm9tIHRoZSBrbWVtbGVhayBkYXRhIHN0cnVjdHVyZXMuCisKK0FuIGFsbG9jYXRlZCBibG9jayBvZiBtZW1vcnkgaXMgY29uc2lkZXJlZCBvcnBoYW4gaWYgbm8gcG9pbnRlciB0byBpdHMKK3N0YXJ0IGFkZHJlc3Mgb3IgdG8gYW55IGxvY2F0aW9uIGluc2lkZSB0aGUgYmxvY2sgY2FuIGJlIGZvdW5kIGJ5CitzY2FubmluZyB0aGUgbWVtb3J5IChpbmNsdWRpbmcgc2F2ZWQgcmVnaXN0ZXJzKS4gVGhpcyBtZWFucyB0aGF0IHRoZXJlCittaWdodCBiZSBubyB3YXkgZm9yIHRoZSBrZXJuZWwgdG8gcGFzcyB0aGUgYWRkcmVzcyBvZiB0aGUgYWxsb2NhdGVkCitibG9jayB0byBhIGZyZWVpbmcgZnVuY3Rpb24gYW5kIHRoZXJlZm9yZSB0aGUgYmxvY2sgaXMgY29uc2lkZXJlZCBhCittZW1vcnkgbGVhay4KKworVGhlIHNjYW5uaW5nIGFsZ29yaXRobSBzdGVwczoKKworICAxLiBtYXJrIGFsbCBvYmplY3RzIGFzIHdoaXRlIChyZW1haW5pbmcgd2hpdGUgb2JqZWN0cyB3aWxsIGxhdGVyIGJlCisgICAgIGNvbnNpZGVyZWQgb3JwaGFuKQorICAyLiBzY2FuIHRoZSBtZW1vcnkgc3RhcnRpbmcgd2l0aCB0aGUgZGF0YSBzZWN0aW9uIGFuZCBzdGFja3MsIGNoZWNraW5nCisgICAgIHRoZSB2YWx1ZXMgYWdhaW5zdCB0aGUgYWRkcmVzc2VzIHN0b3JlZCBpbiB0aGUgcHJpbyBzZWFyY2ggdHJlZS4gSWYKKyAgICAgYSBwb2ludGVyIHRvIGEgd2hpdGUgb2JqZWN0IGlzIGZvdW5kLCB0aGUgb2JqZWN0IGlzIGFkZGVkIHRvIHRoZQorICAgICBncmF5IGxpc3QKKyAgMy4gc2NhbiB0aGUgZ3JheSBvYmplY3RzIGZvciBtYXRjaGluZyBhZGRyZXNzZXMgKHNvbWUgd2hpdGUgb2JqZWN0cworICAgICBjYW4gYmVjb21lIGdyYXkgYW5kIGFkZGVkIGF0IHRoZSBlbmQgb2YgdGhlIGdyYXkgbGlzdCkgdW50aWwgdGhlCisgICAgIGdyYXkgc2V0IGlzIGZpbmlzaGVkCisgIDQuIHRoZSByZW1haW5pbmcgd2hpdGUgb2JqZWN0cyBhcmUgY29uc2lkZXJlZCBvcnBoYW4gYW5kIHJlcG9ydGVkIHZpYQorICAgICAvc3lzL2tlcm5lbC9kZWJ1Zy9rbWVtbGVhaworCitTb21lIGFsbG9jYXRlZCBtZW1vcnkgYmxvY2tzIGhhdmUgcG9pbnRlcnMgc3RvcmVkIGluIHRoZSBrZXJuZWwncworaW50ZXJuYWwgZGF0YSBzdHJ1Y3R1cmVzIGFuZCB0aGV5IGNhbm5vdCBiZSBkZXRlY3RlZCBhcyBvcnBoYW5zLiBUbworYXZvaWQgdGhpcywga21lbWxlYWsgY2FuIGFsc28gc3RvcmUgdGhlIG51bWJlciBvZiB2YWx1ZXMgcG9pbnRpbmcgdG8gYW4KK2FkZHJlc3MgaW5zaWRlIHRoZSBibG9jayBhZGRyZXNzIHJhbmdlIHRoYXQgbmVlZCB0byBiZSBmb3VuZCBzbyB0aGF0IHRoZQorYmxvY2sgaXMgbm90IGNvbnNpZGVyZWQgYSBsZWFrLiBPbmUgZXhhbXBsZSBpcyBfX3ZtYWxsb2MoKS4KKworS21lbWxlYWsgQVBJCistLS0tLS0tLS0tLS0KKworU2VlIHRoZSBpbmNsdWRlL2xpbnV4L2ttZW1sZWFrLmggaGVhZGVyIGZvciB0aGUgZnVuY3Rpb25zIHByb3RvdHlwZS4KKwora21lbWxlYWtfaW5pdAkJIC0gaW5pdGlhbGl6ZSBrbWVtbGVhawora21lbWxlYWtfYWxsb2MJCSAtIG5vdGlmeSBvZiBhIG1lbW9yeSBibG9jayBhbGxvY2F0aW9uCitrbWVtbGVha19mcmVlCQkgLSBub3RpZnkgb2YgYSBtZW1vcnkgYmxvY2sgZnJlZWluZwora21lbWxlYWtfbm90X2xlYWsJIC0gbWFyayBhbiBvYmplY3QgYXMgbm90IGEgbGVhawora21lbWxlYWtfaWdub3JlCQkgLSBkbyBub3Qgc2NhbiBvciByZXBvcnQgYW4gb2JqZWN0IGFzIGxlYWsKK2ttZW1sZWFrX3NjYW5fYXJlYQkgLSBhZGQgc2NhbiBhcmVhcyBpbnNpZGUgYSBtZW1vcnkgYmxvY2sKK2ttZW1sZWFrX25vX3NjYW4JIC0gZG8gbm90IHNjYW4gYSBtZW1vcnkgYmxvY2sKK2ttZW1sZWFrX2VyYXNlCQkgLSBlcmFzZSBhbiBvbGQgdmFsdWUgaW4gYSBwb2ludGVyIHZhcmlhYmxlCitrbWVtbGVha19hbGxvY19yZWN1cnNpdmUgLSBhcyBrbWVtbGVha19hbGxvYyBidXQgY2hlY2tzIHRoZSByZWN1cnNpdmVuZXNzCitrbWVtbGVha19mcmVlX3JlY3Vyc2l2ZQkgLSBhcyBrbWVtbGVha19mcmVlIGJ1dCBjaGVja3MgdGhlIHJlY3Vyc2l2ZW5lc3MKKworRGVhbGluZyB3aXRoIGZhbHNlIHBvc2l0aXZlcy9uZWdhdGl2ZXMKKy0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCisKK1RoZSBmYWxzZSBuZWdhdGl2ZXMgYXJlIHJlYWwgbWVtb3J5IGxlYWtzIChvcnBoYW4gb2JqZWN0cykgYnV0IG5vdAorcmVwb3J0ZWQgYnkga21lbWxlYWsgYmVjYXVzZSB2YWx1ZXMgZm91bmQgZHVyaW5nIHRoZSBtZW1vcnkgc2Nhbm5pbmcKK3BvaW50IHRvIHN1Y2ggb2JqZWN0cy4gVG8gcmVkdWNlIHRoZSBudW1iZXIgb2YgZmFsc2UgbmVnYXRpdmVzLCBrbWVtbGVhaworcHJvdmlkZXMgdGhlIGttZW1sZWFrX2lnbm9yZSwga21lbWxlYWtfc2Nhbl9hcmVhLCBrbWVtbGVha19ub19zY2FuIGFuZAora21lbWxlYWtfZXJhc2UgZnVuY3Rpb25zIChzZWUgYWJvdmUpLiBUaGUgdGFzayBzdGFja3MgYWxzbyBpbmNyZWFzZSB0aGUKK2Ftb3VudCBvZiBmYWxzZSBuZWdhdGl2ZXMgYW5kIHRoZWlyIHNjYW5uaW5nIGlzIG5vdCBlbmFibGVkIGJ5IGRlZmF1bHQuCisKK1RoZSBmYWxzZSBwb3NpdGl2ZXMgYXJlIG9iamVjdHMgd3JvbmdseSByZXBvcnRlZCBhcyBiZWluZyBtZW1vcnkgbGVha3MKKyhvcnBoYW4pLiBGb3Igb2JqZWN0cyBrbm93biBub3QgdG8gYmUgbGVha3MsIGttZW1sZWFrIHByb3ZpZGVzIHRoZQora21lbWxlYWtfbm90X2xlYWsgZnVuY3Rpb24uIFRoZSBrbWVtbGVha19pZ25vcmUgY291bGQgYWxzbyBiZSB1c2VkIGlmCit0aGUgbWVtb3J5IGJsb2NrIGlzIGtub3duIG5vdCB0byBjb250YWluIG90aGVyIHBvaW50ZXJzIGFuZCBpdCB3aWxsIG5vCitsb25nZXIgYmUgc2Nhbm5lZC4KKworU29tZSBvZiB0aGUgcmVwb3J0ZWQgbGVha3MgYXJlIG9ubHkgdHJhbnNpZW50LCBlc3BlY2lhbGx5IG9uIFNNUAorc3lzdGVtcywgYmVjYXVzZSBvZiBwb2ludGVycyB0ZW1wb3JhcmlseSBzdG9yZWQgaW4gQ1BVIHJlZ2lzdGVycyBvcgorc3RhY2tzLiBLbWVtbGVhayBkZWZpbmVzIE1TRUNTX01JTl9BR0UgKGRlZmF1bHRpbmcgdG8gMTAwMCkgcmVwcmVzZW50aW5nCit0aGUgbWluaW11bSBhZ2Ugb2YgYW4gb2JqZWN0IHRvIGJlIHJlcG9ydGVkIGFzIGEgbWVtb3J5IGxlYWsuCisKK0xpbWl0YXRpb25zIGFuZCBEcmF3YmFja3MKKy0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KKworVGhlIG1haW4gZHJhd2JhY2sgaXMgdGhlIHJlZHVjZWQgcGVyZm9ybWFuY2Ugb2YgbWVtb3J5IGFsbG9jYXRpb24gYW5kCitmcmVlaW5nLiBUbyBhdm9pZCBvdGhlciBwZW5hbHRpZXMsIHRoZSBtZW1vcnkgc2Nhbm5pbmcgaXMgb25seSBwZXJmb3JtZWQKK3doZW4gdGhlIC9zeXMva2VybmVsL2RlYnVnL2ttZW1sZWFrIGZpbGUgaXMgcmVhZC4gQW55d2F5LCB0aGlzIHRvb2wgaXMKK2ludGVuZGVkIGZvciBkZWJ1Z2dpbmcgcHVycG9zZXMgd2hlcmUgdGhlIHBlcmZvcm1hbmNlIG1pZ2h0IG5vdCBiZSB0aGUKK21vc3QgaW1wb3J0YW50IHJlcXVpcmVtZW50LgorCitUbyBrZWVwIHRoZSBhbGdvcml0aG0gc2ltcGxlLCBrbWVtbGVhayBzY2FucyBmb3IgdmFsdWVzIHBvaW50aW5nIHRvIGFueQorYWRkcmVzcyBpbnNpZGUgYSBibG9jaydzIGFkZHJlc3MgcmFuZ2UuIFRoaXMgbWF5IGxlYWQgdG8gYW4gaW5jcmVhc2VkCitudW1iZXIgb2YgZmFsc2UgbmVnYXRpdmVzLiBIb3dldmVyLCBpdCBpcyBsaWtlbHkgdGhhdCBhIHJlYWwgbWVtb3J5IGxlYWsKK3dpbGwgZXZlbnR1YWxseSBiZWNvbWUgdmlzaWJsZS4KKworQW5vdGhlciBzb3VyY2Ugb2YgZmFsc2UgbmVnYXRpdmVzIGlzIHRoZSBkYXRhIHN0b3JlZCBpbiBub24tcG9pbnRlcgordmFsdWVzLiBJbiBhIGZ1dHVyZSB2ZXJzaW9uLCBrbWVtbGVhayBjb3VsZCBvbmx5IHNjYW4gdGhlIHBvaW50ZXIKK21lbWJlcnMgaW4gdGhlIGFsbG9jYXRlZCBzdHJ1Y3R1cmVzLiBUaGlzIGZlYXR1cmUgd291bGQgc29sdmUgbWFueSBvZgordGhlIGZhbHNlIG5lZ2F0aXZlIGNhc2VzIGRlc2NyaWJlZCBhYm92ZS4KKworVGhlIHRvb2wgY2FuIHJlcG9ydCBmYWxzZSBwb3NpdGl2ZXMuIFRoZXNlIGFyZSBjYXNlcyB3aGVyZSBhbiBhbGxvY2F0ZWQKK2Jsb2NrIGRvZXNuJ3QgbmVlZCB0byBiZSBmcmVlZCAoc29tZSBjYXNlcyBpbiB0aGUgaW5pdF9jYWxsIGZ1bmN0aW9ucyksCit0aGUgcG9pbnRlciBpcyBjYWxjdWxhdGVkIGJ5IG90aGVyIG1ldGhvZHMgdGhhbiB0aGUgdXN1YWwgY29udGFpbmVyX29mCittYWNybyBvciB0aGUgcG9pbnRlciBpcyBzdG9yZWQgaW4gYSBsb2NhdGlvbiBub3Qgc2Nhbm5lZCBieSBrbWVtbGVhay4KKworUGFnZSBhbGxvY2F0aW9ucyBhbmQgaW9yZW1hcCBhcmUgbm90IHRyYWNrZWQuIE9ubHkgdGhlIEFSTSBhbmQgeDg2CithcmNoaXRlY3R1cmVzIGFyZSBjdXJyZW50bHkgc3VwcG9ydGVkLgpkaWZmIC0tZ2l0IGEvTUFJTlRBSU5FUlMgYi9NQUlOVEFJTkVSUwppbmRleCBlNjk3YjY3Li5jOTQ0ZDYxIDEwMDY0NAotLS0gYS9NQUlOVEFJTkVSUworKysgYi9NQUlOVEFJTkVSUwpAQCAtMzM3Miw2ICszMzcyLDEyIEBACiBGOglpbmNsdWRlL3RyYWNlL2ttZW10cmFjZS5oCiBGOglrZXJuZWwvdHJhY2Uva21lbXRyYWNlLmMKIAorS01FTUxFQUsKK1A6CUNhdGFsaW4gTWFyaW5hcworTToJY2F0YWxpbi5tYXJpbmFzQGFybS5jb20KK0w6CWxpbnV4LWtlcm5lbEB2Z2VyLmtlcm5lbC5vcmcKK1M6CU1haW50YWluZWQKKwogS1BST0JFUwogUDoJQW5hbnRoIE4gTWF2aW5ha2F5YW5haGFsbGkKIE06CWFuYW50aEBpbi5pYm0uY29tCkBAIC00NDA1LDYgKzQ0MTEsMTYgQEAKIEY6CWluY2x1ZGUvbGludXgvZGVsYXlhY2N0LmgKIEY6CWtlcm5lbC9kZWxheWFjY3QuYwogCitQRVJGT1JNQU5DRSBDT1VOVEVSIFNVQlNZU1RFTQorUDoJUGV0ZXIgWmlqbHN0cmEKK006CWEucC56aWpsc3RyYUBjaGVsbG8ubmwKK1A6CVBhdWwgTWFja2VycmFzCitNOglwYXVsdXNAc2FtYmEub3JnCitQOglJbmdvIE1vbG5hcgorTToJbWluZ29AZWx0ZS5odQorTDoJbGludXgta2VybmVsQHZnZXIua2VybmVsLm9yZworUzoJU3VwcG9ydGVkCisKIFBFUlNPTkFMSVRZIEhBTkRMSU5HCiBQOglDaHJpc3RvcGggSGVsbHdpZwogTToJaGNoQGluZnJhZGVhZC5vcmcKZGlmZiAtLWdpdCBhL2FyY2gvcG93ZXJwYy9pbmNsdWRlL2FzbS9od19pcnEuaCBiL2FyY2gvcG93ZXJwYy9pbmNsdWRlL2FzbS9od19pcnEuaAppbmRleCBiN2UwMzRiLi4yMGE0NGQwIDEwMDY0NAotLS0gYS9hcmNoL3Bvd2VycGMvaW5jbHVkZS9hc20vaHdfaXJxLmgKKysrIGIvYXJjaC9wb3dlcnBjL2luY2x1ZGUvYXNtL2h3X2lycS5oCkBAIC0xMzEsNSArMTMxLDQ0IEBACiAgKi8KIHN0cnVjdCBpcnFfY2hpcDsKIAorI2lmZGVmIENPTkZJR19QRVJGX0NPVU5URVJTCitzdGF0aWMgaW5saW5lIHVuc2lnbmVkIGxvbmcgdGVzdF9wZXJmX2NvdW50ZXJfcGVuZGluZyh2b2lkKQoreworCXVuc2lnbmVkIGxvbmcgeDsKKworCWFzbSB2b2xhdGlsZSgibGJ6ICUwLCUxKDEzKSIKKwkJOiAiPXIiICh4KQorCQk6ICJpIiAob2Zmc2V0b2Yoc3RydWN0IHBhY2Ffc3RydWN0LCBwZXJmX2NvdW50ZXJfcGVuZGluZykpKTsKKwlyZXR1cm4geDsKK30KKworc3RhdGljIGlubGluZSB2b2lkIHNldF9wZXJmX2NvdW50ZXJfcGVuZGluZyh2b2lkKQoreworCWFzbSB2b2xhdGlsZSgic3RiICUwLCUxKDEzKSIgOiA6CisJCSJyIiAoMSksCisJCSJpIiAob2Zmc2V0b2Yoc3RydWN0IHBhY2Ffc3RydWN0LCBwZXJmX2NvdW50ZXJfcGVuZGluZykpKTsKK30KKworc3RhdGljIGlubGluZSB2b2lkIGNsZWFyX3BlcmZfY291bnRlcl9wZW5kaW5nKHZvaWQpCit7CisJYXNtIHZvbGF0aWxlKCJzdGIgJTAsJTEoMTMpIiA6IDoKKwkJInIiICgwKSwKKwkJImkiIChvZmZzZXRvZihzdHJ1Y3QgcGFjYV9zdHJ1Y3QsIHBlcmZfY291bnRlcl9wZW5kaW5nKSkpOworfQorCitleHRlcm4gdm9pZCBwZXJmX2NvdW50ZXJfZG9fcGVuZGluZyh2b2lkKTsKKworI2Vsc2UKKworc3RhdGljIGlubGluZSB1bnNpZ25lZCBsb25nIHRlc3RfcGVyZl9jb3VudGVyX3BlbmRpbmcodm9pZCkKK3sKKwlyZXR1cm4gMDsKK30KKworc3RhdGljIGlubGluZSB2b2lkIHNldF9wZXJmX2NvdW50ZXJfcGVuZGluZyh2b2lkKSB7fQorc3RhdGljIGlubGluZSB2b2lkIGNsZWFyX3BlcmZfY291bnRlcl9wZW5kaW5nKHZvaWQpIHt9CitzdGF0aWMgaW5saW5lIHZvaWQgcGVyZl9jb3VudGVyX2RvX3BlbmRpbmcodm9pZCkge30KKyNlbmRpZiAvKiBDT05GSUdfUEVSRl9DT1VOVEVSUyAqLworCiAjZW5kaWYJLyogX19LRVJORUxfXyAqLwogI2VuZGlmCS8qIF9BU01fUE9XRVJQQ19IV19JUlFfSCAqLwpkaWZmIC0tZ2l0IGEvYXJjaC9wb3dlcnBjL2luY2x1ZGUvYXNtL3BhY2EuaCBiL2FyY2gvcG93ZXJwYy9pbmNsdWRlL2FzbS9wYWNhLmgKaW5kZXggMDgyYjNhZS4uNmVmMDU1NyAxMDA2NDQKLS0tIGEvYXJjaC9wb3dlcnBjL2luY2x1ZGUvYXNtL3BhY2EuaAorKysgYi9hcmNoL3Bvd2VycGMvaW5jbHVkZS9hc20vcGFjYS5oCkBAIC05OSw2ICs5OSw3IEBACiAJdTggc29mdF9lbmFibGVkOwkJLyogaXJxIHNvZnQtZW5hYmxlIGZsYWcgKi8KIAl1OCBoYXJkX2VuYWJsZWQ7CQkvKiBzZXQgaWYgaXJxcyBhcmUgZW5hYmxlZCBpbiBNU1IgKi8KIAl1OCBpb19zeW5jOwkJCS8qIHdyaXRlbCgpIG5lZWRzIHNwaW5fdW5sb2NrIHN5bmMgKi8KKwl1OCBwZXJmX2NvdW50ZXJfcGVuZGluZzsJLyogUE0gaW50ZXJydXB0IHdoaWxlIHNvZnQtZGlzYWJsZWQgKi8KIAogCS8qIFN0dWZmIGZvciBhY2N1cmF0ZSB0aW1lIGFjY291bnRpbmcgKi8KIAl1NjQgdXNlcl90aW1lOwkJCS8qIGFjY3VtdWxhdGVkIHVzZXJtb2RlIFRCIHRpY2tzICovCmRpZmYgLS1naXQgYS9hcmNoL3Bvd2VycGMvaW5jbHVkZS9hc20vcGVyZl9jb3VudGVyLmggYi9hcmNoL3Bvd2VycGMvaW5jbHVkZS9hc20vcGVyZl9jb3VudGVyLmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uY2M3Yzg4NwotLS0gL2Rldi9udWxsCisrKyBiL2FyY2gvcG93ZXJwYy9pbmNsdWRlL2FzbS9wZXJmX2NvdW50ZXIuaApAQCAtMCwwICsxLDk4IEBACisvKgorICogUGVyZm9ybWFuY2UgY291bnRlciBzdXBwb3J0IC0gUG93ZXJQQy1zcGVjaWZpYyBkZWZpbml0aW9ucy4KKyAqCisgKiBDb3B5cmlnaHQgMjAwOC0yMDA5IFBhdWwgTWFja2VycmFzLCBJQk0gQ29ycG9yYXRpb24uCisgKgorICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vcgorICogbW9kaWZ5IGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UKKyAqIGFzIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uOyBlaXRoZXIgdmVyc2lvbgorICogMiBvZiB0aGUgTGljZW5zZSwgb3IgKGF0IHlvdXIgb3B0aW9uKSBhbnkgbGF0ZXIgdmVyc2lvbi4KKyAqLworI2luY2x1ZGUgPGxpbnV4L3R5cGVzLmg+CisKKyNkZWZpbmUgTUFYX0hXQ09VTlRFUlMJCTgKKyNkZWZpbmUgTUFYX0VWRU5UX0FMVEVSTkFUSVZFUwk4CisjZGVmaW5lIE1BWF9MSU1JVEVEX0hXQ09VTlRFUlMJMgorCisvKgorICogVGhpcyBzdHJ1Y3QgcHJvdmlkZXMgdGhlIGNvbnN0YW50cyBhbmQgZnVuY3Rpb25zIG5lZWRlZCB0bworICogZGVzY3JpYmUgdGhlIFBNVSBvbiBhIHBhcnRpY3VsYXIgUE9XRVItZmFtaWx5IENQVS4KKyAqLworc3RydWN0IHBvd2VyX3BtdSB7CisJaW50CW5fY291bnRlcjsKKwlpbnQJbWF4X2FsdGVybmF0aXZlczsKKwl1NjQJYWRkX2ZpZWxkczsKKwl1NjQJdGVzdF9hZGRlcjsKKwlpbnQJKCpjb21wdXRlX21tY3IpKHU2NCBldmVudHNbXSwgaW50IG5fZXYsCisJCQkJdW5zaWduZWQgaW50IGh3Y1tdLCB1NjQgbW1jcltdKTsKKwlpbnQJKCpnZXRfY29uc3RyYWludCkodTY0IGV2ZW50LCB1NjQgKm1za3AsIHU2NCAqdmFscCk7CisJaW50CSgqZ2V0X2FsdGVybmF0aXZlcykodTY0IGV2ZW50LCB1bnNpZ25lZCBpbnQgZmxhZ3MsCisJCQkJICAgIHU2NCBhbHRbXSk7CisJdm9pZAkoKmRpc2FibGVfcG1jKSh1bnNpZ25lZCBpbnQgcG1jLCB1NjQgbW1jcltdKTsKKwlpbnQJKCpsaW1pdGVkX3BtY19ldmVudCkodTY0IGV2ZW50KTsKKwl1MzIJZmxhZ3M7CisJaW50CW5fZ2VuZXJpYzsKKwlpbnQJKmdlbmVyaWNfZXZlbnRzOworCWludAkoKmNhY2hlX2V2ZW50cylbUEVSRl9DT1VOVF9IV19DQUNIRV9NQVhdCisJCQkgICAgICAgW1BFUkZfQ09VTlRfSFdfQ0FDSEVfT1BfTUFYXQorCQkJICAgICAgIFtQRVJGX0NPVU5UX0hXX0NBQ0hFX1JFU1VMVF9NQVhdOworfTsKKworZXh0ZXJuIHN0cnVjdCBwb3dlcl9wbXUgKnBwbXU7CisKKy8qCisgKiBWYWx1ZXMgZm9yIHBvd2VyX3BtdS5mbGFncworICovCisjZGVmaW5lIFBQTVVfTElNSVRFRF9QTUM1XzYJMQkvKiBQTUM1LzYgaGF2ZSBsaW1pdGVkIGZ1bmN0aW9uICovCisjZGVmaW5lIFBQTVVfQUxUX1NJUFIJCTIJLyogdXNlcyBhbHRlcm5hdGUgcG9zbiBmb3IgU0lQUi9IViAqLworCisvKgorICogVmFsdWVzIGZvciBmbGFncyB0byBnZXRfYWx0ZXJuYXRpdmVzKCkKKyAqLworI2RlZmluZSBQUE1VX0xJTUlURURfUE1DX09LCTEJLyogY2FuIHB1dCB0aGlzIG9uIGEgbGltaXRlZCBQTUMgKi8KKyNkZWZpbmUgUFBNVV9MSU1JVEVEX1BNQ19SRVFECTIJLyogaGF2ZSB0byBwdXQgdGhpcyBvbiBhIGxpbWl0ZWQgUE1DICovCisjZGVmaW5lIFBQTVVfT05MWV9DT1VOVF9SVU4JNAkvKiBvbmx5IGNvdW50aW5nIGluIHJ1biBzdGF0ZSAqLworCitzdHJ1Y3QgcHRfcmVnczsKK2V4dGVybiB1bnNpZ25lZCBsb25nIHBlcmZfbWlzY19mbGFncyhzdHJ1Y3QgcHRfcmVncyAqcmVncyk7CisjZGVmaW5lIHBlcmZfbWlzY19mbGFncyhyZWdzKQlwZXJmX21pc2NfZmxhZ3MocmVncykKKworZXh0ZXJuIHVuc2lnbmVkIGxvbmcgcGVyZl9pbnN0cnVjdGlvbl9wb2ludGVyKHN0cnVjdCBwdF9yZWdzICpyZWdzKTsKKworLyoKKyAqIFRoZSBwb3dlcl9wbXUuZ2V0X2NvbnN0cmFpbnQgZnVuY3Rpb24gcmV0dXJucyBhIDY0LWJpdCB2YWx1ZSBhbmQKKyAqIGEgNjQtYml0IG1hc2sgdGhhdCBleHByZXNzIHRoZSBjb25zdHJhaW50cyBiZXR3ZWVuIHRoaXMgZXZlbnQgYW5kCisgKiBvdGhlciBldmVudHMuCisgKgorICogVGhlIHZhbHVlIGFuZCBtYXNrIGFyZSBkaXZpZGVkIHVwIGludG8gKG5vbi1vdmVybGFwcGluZykgYml0ZmllbGRzCisgKiBvZiB0aHJlZSBkaWZmZXJlbnQgdHlwZXM6CisgKgorICogU2VsZWN0IGZpZWxkOiB0aGlzIGV4cHJlc3NlcyB0aGUgY29uc3RyYWludCB0aGF0IHNvbWUgc2V0IG9mIGJpdHMKKyAqIGluIE1NQ1IqIG5lZWRzIHRvIGJlIHNldCB0byBhIHNwZWNpZmljIHZhbHVlIGZvciB0aGlzIGV2ZW50LiAgRm9yIGEKKyAqIHNlbGVjdCBmaWVsZCwgdGhlIG1hc2sgY29udGFpbnMgMXMgaW4gZXZlcnkgYml0IG9mIHRoZSBmaWVsZCwgYW5kCisgKiB0aGUgdmFsdWUgY29udGFpbnMgYSB1bmlxdWUgdmFsdWUgZm9yIGVhY2ggcG9zc2libGUgc2V0dGluZyBvZiB0aGUKKyAqIE1NQ1IqIGJpdHMuICBUaGUgY29uc3RyYWludCBjaGVja2luZyBjb2RlIHdpbGwgZW5zdXJlIHRoYXQgdHdvIGV2ZW50cworICogdGhhdCBzZXQgdGhlIHNhbWUgZmllbGQgaW4gdGhlaXIgbWFza3MgaGF2ZSB0aGUgc2FtZSB2YWx1ZSBpbiB0aGVpcgorICogdmFsdWUgZHdvcmRzLgorICoKKyAqIEFkZCBmaWVsZDogdGhpcyBleHByZXNzZXMgdGhlIGNvbnN0cmFpbnQgdGhhdCB0aGVyZSBjYW4gYmUgYXQgbW9zdAorICogTiBldmVudHMgaW4gYSBwYXJ0aWN1bGFyIGNsYXNzLiAgQSBmaWVsZCBvZiBrIGJpdHMgY2FuIGJlIHVzZWQgZm9yCisgKiBOIDw9IDJeKGstMSkgLSAxLiAgVGhlIG1hc2sgaGFzIHRoZSBtb3N0IHNpZ25pZmljYW50IGJpdCBvZiB0aGUgZmllbGQKKyAqIHNldCAoYW5kIHRoZSBvdGhlciBiaXRzIDApLCBhbmQgdGhlIHZhbHVlIGhhcyBvbmx5IHRoZSBsZWFzdCBzaWduaWZpY2FudAorICogYml0IG9mIHRoZSBmaWVsZCBzZXQuICBJbiBhZGRpdGlvbiwgdGhlICdhZGRfZmllbGRzJyBhbmQgJ3Rlc3RfYWRkZXInCisgKiBpbiB0aGUgc3RydWN0IHBvd2VyX3BtdSBmb3IgdGhpcyBwcm9jZXNzb3IgY29tZSBpbnRvIHBsYXkuICBUaGUKKyAqIGFkZF9maWVsZHMgdmFsdWUgY29udGFpbnMgMSBpbiB0aGUgTFNCIG9mIHRoZSBmaWVsZCwgYW5kIHRoZQorICogdGVzdF9hZGRlciBjb250YWlucyAyXihrLTEpIC0gMSAtIE4gaW4gdGhlIGZpZWxkLgorICoKKyAqIE5BTkQgZmllbGQ6IHRoaXMgZXhwcmVzc2VzIHRoZSBjb25zdHJhaW50IHRoYXQgeW91IG1heSBub3QgaGF2ZSBldmVudHMKKyAqIGluIGFsbCBvZiBhIHNldCBvZiBjbGFzc2VzLiAgKEZvciBleGFtcGxlLCBvbiBQUEM5NzAsIHlvdSBjYW4ndCBzZWxlY3QKKyAqIGV2ZW50cyBmcm9tIHRoZSBGUFUsIElTVSBhbmQgSURVIHNpbXVsdGFuZW91c2x5LCBhbHRob3VnaCBhbnkgdHdvIGFyZQorICogcG9zc2libGUuKSAgRm9yIE4gY2xhc3NlcywgdGhlIGZpZWxkIGlzIE4rMSBiaXRzIHdpZGUsIGFuZCBlYWNoIGNsYXNzCisgKiBpcyBhc3NpZ25lZCBvbmUgYml0IGZyb20gdGhlIGxlYXN0LXNpZ25pZmljYW50IE4gYml0cy4gIFRoZSBtYXNrIGhhcworICogb25seSB0aGUgbW9zdC1zaWduaWZpY2FudCBiaXQgc2V0LCBhbmQgdGhlIHZhbHVlIGhhcyBvbmx5IHRoZSBiaXQKKyAqIGZvciB0aGUgZXZlbnQncyBjbGFzcyBzZXQuICBUaGUgdGVzdF9hZGRlciBoYXMgdGhlIGxlYXN0IHNpZ25pZmljYW50CisgKiBiaXQgc2V0IGluIHRoZSBmaWVsZC4KKyAqCisgKiBJZiBhbiBldmVudCBpcyBub3Qgc3ViamVjdCB0byB0aGUgY29uc3RyYWludCBleHByZXNzZWQgYnkgYSBwYXJ0aWN1bGFyCisgKiBmaWVsZCwgdGhlbiBpdCB3aWxsIGhhdmUgMCBpbiBib3RoIHRoZSBtYXNrIGFuZCB2YWx1ZSBmb3IgdGhhdCBmaWVsZC4KKyAqLwpkaWZmIC0tZ2l0IGEvYXJjaC9wb3dlcnBjL2luY2x1ZGUvYXNtL3JlZy5oIGIvYXJjaC9wb3dlcnBjL2luY2x1ZGUvYXNtL3JlZy5oCmluZGV4IGU4MDE4ZDUuLmZiMzU5YjAgMTAwNjQ0Ci0tLSBhL2FyY2gvcG93ZXJwYy9pbmNsdWRlL2FzbS9yZWcuaAorKysgYi9hcmNoL3Bvd2VycGMvaW5jbHVkZS9hc20vcmVnLmgKQEAgLTQ5MiwxMSArNDkyLDEzIEBACiAjZGVmaW5lICAgTU1DUjBfRkNIVgkweDAwMDAwMDAxVUwgLyogZnJlZXplIGNvbmRpdGlvbnMgaW4gaHlwZXJ2aXNvciBtb2RlICovCiAjZGVmaW5lIFNQUk5fTU1DUjEJNzk4CiAjZGVmaW5lIFNQUk5fTU1DUkEJMHgzMTIKKyNkZWZpbmUgICBNTUNSQV9TRFNZTkMJMHg4MDAwMDAwMFVMIC8qIFNEQVIgc3luY2VkIHdpdGggU0lBUiAqLwogI2RlZmluZSAgIE1NQ1JBX1NJSFYJMHgxMDAwMDAwMFVMIC8qIHN0YXRlIG9mIE1TUiBIViB3aGVuIFNJQVIgc2V0ICovCiAjZGVmaW5lICAgTU1DUkFfU0lQUgkweDA4MDAwMDAwVUwgLyogc3RhdGUgb2YgTVNSIFBSIHdoZW4gU0lBUiBzZXQgKi8KICNkZWZpbmUgICBNTUNSQV9TTE9UCTB4MDcwMDAwMDBVTCAvKiBTTE9UIGJpdHMgKDM3LTM5KSAqLwogI2RlZmluZSAgIE1NQ1JBX1NMT1RfU0hJRlQJMjQKICNkZWZpbmUgICBNTUNSQV9TQU1QTEVfRU5BQkxFIDB4MDAwMDAwMDFVTCAvKiBlbmFibGUgc2FtcGxpbmcgKi8KKyNkZWZpbmUgICBQT1dFUjZfTU1DUkFfU0RTWU5DIDB4MDAwMDA4MDAwMDAwMDAwMFVMTAkvKiBTREFSL1NJQVIgc3luY2VkICovCiAjZGVmaW5lICAgUE9XRVI2X01NQ1JBX1NJSFYgICAweDAwMDAwNDAwMDAwMDAwMDBVTEwKICNkZWZpbmUgICBQT1dFUjZfTU1DUkFfU0lQUiAgIDB4MDAwMDAyMDAwMDAwMDAwMFVMTAogI2RlZmluZSAgIFBPV0VSNl9NTUNSQV9USFJNCTB4MDAwMDAwMjBVTApkaWZmIC0tZ2l0IGEvYXJjaC9wb3dlcnBjL2luY2x1ZGUvYXNtL3N5c3RibC5oIGIvYXJjaC9wb3dlcnBjL2luY2x1ZGUvYXNtL3N5c3RibC5oCmluZGV4IGQ5OGEzMGQuLmEwYjkyZGUgMTAwNjQ0Ci0tLSBhL2FyY2gvcG93ZXJwYy9pbmNsdWRlL2FzbS9zeXN0YmwuaAorKysgYi9hcmNoL3Bvd2VycGMvaW5jbHVkZS9hc20vc3lzdGJsLmgKQEAgLTMyMiw2ICszMjIsNiBAQAogU1lTQ0FMTF9TUFUoZHVwMykKIFNZU0NBTExfU1BVKHBpcGUyKQogU1lTQ0FMTChpbm90aWZ5X2luaXQxKQotU1lTQ0FMTChuaV9zeXNjYWxsKQorU1lTQ0FMTF9TUFUocGVyZl9jb3VudGVyX29wZW4pCiBDT01QQVRfU1lTX1NQVShwcmVhZHYpCiBDT01QQVRfU1lTX1NQVShwd3JpdGV2KQpkaWZmIC0tZ2l0IGEvYXJjaC9wb3dlcnBjL2luY2x1ZGUvYXNtL3VuaXN0ZC5oIGIvYXJjaC9wb3dlcnBjL2luY2x1ZGUvYXNtL3VuaXN0ZC5oCmluZGV4IDNmMDZmOGUuLjRiYWRhYzIgMTAwNjQ0Ci0tLSBhL2FyY2gvcG93ZXJwYy9pbmNsdWRlL2FzbS91bmlzdGQuaAorKysgYi9hcmNoL3Bvd2VycGMvaW5jbHVkZS9hc20vdW5pc3RkLmgKQEAgLTM0MSw2ICszNDEsNyBAQAogI2RlZmluZSBfX05SX2R1cDMJCTMxNgogI2RlZmluZSBfX05SX3BpcGUyCQkzMTcKICNkZWZpbmUgX19OUl9pbm90aWZ5X2luaXQxCTMxOAorI2RlZmluZSBfX05SX3BlcmZfY291bnRlcl9vcGVuCTMxOQogI2RlZmluZSBfX05SX3ByZWFkdgkJMzIwCiAjZGVmaW5lIF9fTlJfcHdyaXRldgkJMzIxCiAKZGlmZiAtLWdpdCBhL2FyY2gvcG93ZXJwYy9rZXJuZWwvTWFrZWZpbGUgYi9hcmNoL3Bvd2VycGMva2VybmVsL01ha2VmaWxlCmluZGV4IDcxOTAxZmIuLmEyYzY4MzQgMTAwNjQ0Ci0tLSBhL2FyY2gvcG93ZXJwYy9rZXJuZWwvTWFrZWZpbGUKKysrIGIvYXJjaC9wb3dlcnBjL2tlcm5lbC9NYWtlZmlsZQpAQCAtOTQsNiArOTQsOSBAQAogCiBvYmotJChDT05GSUdfRFlOQU1JQ19GVFJBQ0UpCSs9IGZ0cmFjZS5vCiBvYmotJChDT05GSUdfRlVOQ1RJT05fR1JBUEhfVFJBQ0VSKQkrPSBmdHJhY2Uubworb2JqLSQoQ09ORklHX1BFUkZfQ09VTlRFUlMpCSs9IHBlcmZfY291bnRlci5vIHBvd2VyNC1wbXUubyBwcGM5NzAtcG11Lm8gXAorCQkJCSAgIHBvd2VyNS1wbXUubyBwb3dlcjUrLXBtdS5vIHBvd2VyNi1wbXUubyBcCisJCQkJICAgcG93ZXI3LXBtdS5vCiAKIG9iai0kKENPTkZJR184WFhfTUlOSU1BTF9GUEVNVSkgKz0gc29mdGVtdTh4eC5vCiAKZGlmZiAtLWdpdCBhL2FyY2gvcG93ZXJwYy9rZXJuZWwvYXNtLW9mZnNldHMuYyBiL2FyY2gvcG93ZXJwYy9rZXJuZWwvYXNtLW9mZnNldHMuYwppbmRleCAxZTQwYmMwLi5lOTgxZDFjIDEwMDY0NAotLS0gYS9hcmNoL3Bvd2VycGMva2VybmVsL2FzbS1vZmZzZXRzLmMKKysrIGIvYXJjaC9wb3dlcnBjL2tlcm5lbC9hc20tb2Zmc2V0cy5jCkBAIC0xMzEsNiArMTMxLDcgQEAKIAlERUZJTkUoUEFDQUtNU1IsIG9mZnNldG9mKHN0cnVjdCBwYWNhX3N0cnVjdCwga2VybmVsX21zcikpOwogCURFRklORShQQUNBU09GVElSUUVOLCBvZmZzZXRvZihzdHJ1Y3QgcGFjYV9zdHJ1Y3QsIHNvZnRfZW5hYmxlZCkpOwogCURFRklORShQQUNBSEFSRElSUUVOLCBvZmZzZXRvZihzdHJ1Y3QgcGFjYV9zdHJ1Y3QsIGhhcmRfZW5hYmxlZCkpOworCURFRklORShQQUNBUEVSRlBFTkQsIG9mZnNldG9mKHN0cnVjdCBwYWNhX3N0cnVjdCwgcGVyZl9jb3VudGVyX3BlbmRpbmcpKTsKIAlERUZJTkUoUEFDQVNMQkNBQ0hFLCBvZmZzZXRvZihzdHJ1Y3QgcGFjYV9zdHJ1Y3QsIHNsYl9jYWNoZSkpOwogCURFRklORShQQUNBU0xCQ0FDSEVQVFIsIG9mZnNldG9mKHN0cnVjdCBwYWNhX3N0cnVjdCwgc2xiX2NhY2hlX3B0cikpOwogCURFRklORShQQUNBQ09OVEVYVElELCBvZmZzZXRvZihzdHJ1Y3QgcGFjYV9zdHJ1Y3QsIGNvbnRleHQuaWQpKTsKZGlmZiAtLWdpdCBhL2FyY2gvcG93ZXJwYy9rZXJuZWwvZW50cnlfNjQuUyBiL2FyY2gvcG93ZXJwYy9rZXJuZWwvZW50cnlfNjQuUwppbmRleCBhYmZjMzIzLi40M2UwNzM0IDEwMDY0NAotLS0gYS9hcmNoL3Bvd2VycGMva2VybmVsL2VudHJ5XzY0LlMKKysrIGIvYXJjaC9wb3dlcnBjL2tlcm5lbC9lbnRyeV82NC5TCkBAIC01MjYsNiArNTI2LDE1IEBACiAyOgogCVRSQUNFX0FORF9SRVNUT1JFX0lSUShyNSk7CiAKKyNpZmRlZiBDT05GSUdfUEVSRl9DT1VOVEVSUworCS8qIGNoZWNrIHBhY2EtPnBlcmZfY291bnRlcl9wZW5kaW5nIGlmIHdlJ3JlIGVuYWJsaW5nIGludHMgKi8KKwlsYnoJcjMsUEFDQVBFUkZQRU5EKHIxMykKKwlhbmQuCXIzLHIzLHI1CisJYmVxCTI3ZgorCWJsCS5wZXJmX2NvdW50ZXJfZG9fcGVuZGluZworMjc6CisjZW5kaWYgLyogQ09ORklHX1BFUkZfQ09VTlRFUlMgKi8KKwogCS8qIGV4dHJhY3QgRUUgYml0IGFuZCB1c2UgaXQgdG8gcmVzdG9yZSBwYWNhLT5oYXJkX2VuYWJsZWQgKi8KIAlsZAlyMyxfTVNSKHIxKQogCXJsZGljbAlyNCxyMyw0OSw2MwkJLyogcjAgPSAocjMgPj4gMTUpICYgMSAqLwpkaWZmIC0tZ2l0IGEvYXJjaC9wb3dlcnBjL2tlcm5lbC9pcnEuYyBiL2FyY2gvcG93ZXJwYy9rZXJuZWwvaXJxLmMKaW5kZXggOGMxYTQ5Ni4uZmVmZjc5MiAxMDA2NDQKLS0tIGEvYXJjaC9wb3dlcnBjL2tlcm5lbC9pcnEuYworKysgYi9hcmNoL3Bvd2VycGMva2VybmVsL2lycS5jCkBAIC0xMzUsNiArMTM1LDExIEBACiAJCQlpc2VyaWVzX2hhbmRsZV9pbnRlcnJ1cHRzKCk7CiAJfQogCisJaWYgKHRlc3RfcGVyZl9jb3VudGVyX3BlbmRpbmcoKSkgeworCQljbGVhcl9wZXJmX2NvdW50ZXJfcGVuZGluZygpOworCQlwZXJmX2NvdW50ZXJfZG9fcGVuZGluZygpOworCX0KKwogCS8qCiAJICogaWYgKGdldF9wYWNhKCktPmhhcmRfZW5hYmxlZCkgcmV0dXJuOwogCSAqIEJ1dCBhZ2FpbiB3ZSBuZWVkIHRvIHRha2UgY2FyZSB0aGF0IGdjYyBnZXRzIGhhcmRfZW5hYmxlZCBkaXJlY3RseQpkaWZmIC0tZ2l0IGEvYXJjaC9wb3dlcnBjL2tlcm5lbC9wZXJmX2NvdW50ZXIuYyBiL2FyY2gvcG93ZXJwYy9rZXJuZWwvcGVyZl9jb3VudGVyLmMKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uYmIyMDIzOAotLS0gL2Rldi9udWxsCisrKyBiL2FyY2gvcG93ZXJwYy9rZXJuZWwvcGVyZl9jb3VudGVyLmMKQEAgLTAsMCArMSwxMjYzIEBACisvKgorICogUGVyZm9ybWFuY2UgY291bnRlciBzdXBwb3J0IC0gcG93ZXJwYyBhcmNoaXRlY3R1cmUgY29kZQorICoKKyAqIENvcHlyaWdodCAyMDA4LTIwMDkgUGF1bCBNYWNrZXJyYXMsIElCTSBDb3Jwb3JhdGlvbi4KKyAqCisgKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yCisgKiBtb2RpZnkgaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZQorICogYXMgcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb247IGVpdGhlciB2ZXJzaW9uCisgKiAyIG9mIHRoZSBMaWNlbnNlLCBvciAoYXQgeW91ciBvcHRpb24pIGFueSBsYXRlciB2ZXJzaW9uLgorICovCisjaW5jbHVkZSA8bGludXgva2VybmVsLmg+CisjaW5jbHVkZSA8bGludXgvc2NoZWQuaD4KKyNpbmNsdWRlIDxsaW51eC9wZXJmX2NvdW50ZXIuaD4KKyNpbmNsdWRlIDxsaW51eC9wZXJjcHUuaD4KKyNpbmNsdWRlIDxsaW51eC9oYXJkaXJxLmg+CisjaW5jbHVkZSA8YXNtL3JlZy5oPgorI2luY2x1ZGUgPGFzbS9wbWMuaD4KKyNpbmNsdWRlIDxhc20vbWFjaGRlcC5oPgorI2luY2x1ZGUgPGFzbS9maXJtd2FyZS5oPgorI2luY2x1ZGUgPGFzbS9wdHJhY2UuaD4KKworc3RydWN0IGNwdV9od19jb3VudGVycyB7CisJaW50IG5fY291bnRlcnM7CisJaW50IG5fcGVyY3B1OworCWludCBkaXNhYmxlZDsKKwlpbnQgbl9hZGRlZDsKKwlpbnQgbl9saW1pdGVkOworCXU4ICBwbWNzX2VuYWJsZWQ7CisJc3RydWN0IHBlcmZfY291bnRlciAqY291bnRlcltNQVhfSFdDT1VOVEVSU107CisJdTY0IGV2ZW50c1tNQVhfSFdDT1VOVEVSU107CisJdW5zaWduZWQgaW50IGZsYWdzW01BWF9IV0NPVU5URVJTXTsKKwl1NjQgbW1jclszXTsKKwlzdHJ1Y3QgcGVyZl9jb3VudGVyICpsaW1pdGVkX2NvdW50ZXJbTUFYX0xJTUlURURfSFdDT1VOVEVSU107CisJdTggIGxpbWl0ZWRfaHdpZHhbTUFYX0xJTUlURURfSFdDT1VOVEVSU107Cit9OworREVGSU5FX1BFUl9DUFUoc3RydWN0IGNwdV9od19jb3VudGVycywgY3B1X2h3X2NvdW50ZXJzKTsKKworc3RydWN0IHBvd2VyX3BtdSAqcHBtdTsKKworLyoKKyAqIE5vcm1hbGx5LCB0byBpZ25vcmUga2VybmVsIGV2ZW50cyB3ZSBzZXQgdGhlIEZDUyAoZnJlZXplIGNvdW50ZXJzCisgKiBpbiBzdXBlcnZpc29yIG1vZGUpIGJpdCBpbiBNTUNSMCwgYnV0IGlmIHRoZSBrZXJuZWwgcnVucyB3aXRoIHRoZQorICogaHlwZXJ2aXNvciBiaXQgc2V0IGluIHRoZSBNU1IsIG9yIGlmIHdlIGFyZSBydW5uaW5nIG9uIGEgcHJvY2Vzc29yCisgKiB3aGVyZSB0aGUgaHlwZXJ2aXNvciBiaXQgaXMgZm9yY2VkIHRvIDEgKGFzIG9uIEFwcGxlIEc1IHByb2Nlc3NvcnMpLAorICogdGhlbiB3ZSBuZWVkIHRvIHVzZSB0aGUgRkNIViBiaXQgdG8gaWdub3JlIGtlcm5lbCBldmVudHMuCisgKi8KK3N0YXRpYyB1bnNpZ25lZCBpbnQgZnJlZXplX2NvdW50ZXJzX2tlcm5lbCA9IE1NQ1IwX0ZDUzsKKworc3RhdGljIHZvaWQgcGVyZl9jb3VudGVyX2ludGVycnVwdChzdHJ1Y3QgcHRfcmVncyAqcmVncyk7CisKK3ZvaWQgcGVyZl9jb3VudGVyX3ByaW50X2RlYnVnKHZvaWQpCit7Cit9CisKKy8qCisgKiBSZWFkIG9uZSBwZXJmb3JtYW5jZSBtb25pdG9yIGNvdW50ZXIgKFBNQykuCisgKi8KK3N0YXRpYyB1bnNpZ25lZCBsb25nIHJlYWRfcG1jKGludCBpZHgpCit7CisJdW5zaWduZWQgbG9uZyB2YWw7CisKKwlzd2l0Y2ggKGlkeCkgeworCWNhc2UgMToKKwkJdmFsID0gbWZzcHIoU1BSTl9QTUMxKTsKKwkJYnJlYWs7CisJY2FzZSAyOgorCQl2YWwgPSBtZnNwcihTUFJOX1BNQzIpOworCQlicmVhazsKKwljYXNlIDM6CisJCXZhbCA9IG1mc3ByKFNQUk5fUE1DMyk7CisJCWJyZWFrOworCWNhc2UgNDoKKwkJdmFsID0gbWZzcHIoU1BSTl9QTUM0KTsKKwkJYnJlYWs7CisJY2FzZSA1OgorCQl2YWwgPSBtZnNwcihTUFJOX1BNQzUpOworCQlicmVhazsKKwljYXNlIDY6CisJCXZhbCA9IG1mc3ByKFNQUk5fUE1DNik7CisJCWJyZWFrOworCWNhc2UgNzoKKwkJdmFsID0gbWZzcHIoU1BSTl9QTUM3KTsKKwkJYnJlYWs7CisJY2FzZSA4OgorCQl2YWwgPSBtZnNwcihTUFJOX1BNQzgpOworCQlicmVhazsKKwlkZWZhdWx0OgorCQlwcmludGsoS0VSTl9FUlIgIm9vcHMgdHJ5aW5nIHRvIHJlYWQgUE1DJWRcbiIsIGlkeCk7CisJCXZhbCA9IDA7CisJfQorCXJldHVybiB2YWw7Cit9CisKKy8qCisgKiBXcml0ZSBvbmUgUE1DLgorICovCitzdGF0aWMgdm9pZCB3cml0ZV9wbWMoaW50IGlkeCwgdW5zaWduZWQgbG9uZyB2YWwpCit7CisJc3dpdGNoIChpZHgpIHsKKwljYXNlIDE6CisJCW10c3ByKFNQUk5fUE1DMSwgdmFsKTsKKwkJYnJlYWs7CisJY2FzZSAyOgorCQltdHNwcihTUFJOX1BNQzIsIHZhbCk7CisJCWJyZWFrOworCWNhc2UgMzoKKwkJbXRzcHIoU1BSTl9QTUMzLCB2YWwpOworCQlicmVhazsKKwljYXNlIDQ6CisJCW10c3ByKFNQUk5fUE1DNCwgdmFsKTsKKwkJYnJlYWs7CisJY2FzZSA1OgorCQltdHNwcihTUFJOX1BNQzUsIHZhbCk7CisJCWJyZWFrOworCWNhc2UgNjoKKwkJbXRzcHIoU1BSTl9QTUM2LCB2YWwpOworCQlicmVhazsKKwljYXNlIDc6CisJCW10c3ByKFNQUk5fUE1DNywgdmFsKTsKKwkJYnJlYWs7CisJY2FzZSA4OgorCQltdHNwcihTUFJOX1BNQzgsIHZhbCk7CisJCWJyZWFrOworCWRlZmF1bHQ6CisJCXByaW50ayhLRVJOX0VSUiAib29wcyB0cnlpbmcgdG8gd3JpdGUgUE1DJWRcbiIsIGlkeCk7CisJfQorfQorCisvKgorICogQ2hlY2sgaWYgYSBzZXQgb2YgZXZlbnRzIGNhbiBhbGwgZ28gb24gdGhlIFBNVSBhdCBvbmNlLgorICogSWYgdGhleSBjYW4ndCwgdGhpcyB3aWxsIGxvb2sgYXQgYWx0ZXJuYXRpdmUgY29kZXMgZm9yIHRoZSBldmVudHMKKyAqIGFuZCBzZWUgaWYgYW55IGNvbWJpbmF0aW9uIG9mIGFsdGVybmF0aXZlIGNvZGVzIGlzIGZlYXNpYmxlLgorICogVGhlIGZlYXNpYmxlIHNldCBpcyByZXR1cm5lZCBpbiBldmVudFtdLgorICovCitzdGF0aWMgaW50IHBvd2VyX2NoZWNrX2NvbnN0cmFpbnRzKHU2NCBldmVudFtdLCB1bnNpZ25lZCBpbnQgY2ZsYWdzW10sCisJCQkJICAgaW50IG5fZXYpCit7CisJdTY0IG1hc2ssIHZhbHVlLCBudjsKKwl1NjQgYWx0ZXJuYXRpdmVzW01BWF9IV0NPVU5URVJTXVtNQVhfRVZFTlRfQUxURVJOQVRJVkVTXTsKKwl1NjQgYW1hc2tzW01BWF9IV0NPVU5URVJTXVtNQVhfRVZFTlRfQUxURVJOQVRJVkVTXTsKKwl1NjQgYXZhbHVlc1tNQVhfSFdDT1VOVEVSU11bTUFYX0VWRU5UX0FMVEVSTkFUSVZFU107CisJdTY0IHNtYXNrc1tNQVhfSFdDT1VOVEVSU10sIHN2YWx1ZXNbTUFYX0hXQ09VTlRFUlNdOworCWludCBuX2FsdFtNQVhfSFdDT1VOVEVSU10sIGNob2ljZVtNQVhfSFdDT1VOVEVSU107CisJaW50IGksIGo7CisJdTY0IGFkZGYgPSBwcG11LT5hZGRfZmllbGRzOworCXU2NCB0YWRkID0gcHBtdS0+dGVzdF9hZGRlcjsKKworCWlmIChuX2V2ID4gcHBtdS0+bl9jb3VudGVyKQorCQlyZXR1cm4gLTE7CisKKwkvKiBGaXJzdCBzZWUgaWYgdGhlIGV2ZW50cyB3aWxsIGdvIG9uIGFzLWlzICovCisJZm9yIChpID0gMDsgaSA8IG5fZXY7ICsraSkgeworCQlpZiAoKGNmbGFnc1tpXSAmIFBQTVVfTElNSVRFRF9QTUNfUkVRRCkKKwkJICAgICYmICFwcG11LT5saW1pdGVkX3BtY19ldmVudChldmVudFtpXSkpIHsKKwkJCXBwbXUtPmdldF9hbHRlcm5hdGl2ZXMoZXZlbnRbaV0sIGNmbGFnc1tpXSwKKwkJCQkJICAgICAgIGFsdGVybmF0aXZlc1tpXSk7CisJCQlldmVudFtpXSA9IGFsdGVybmF0aXZlc1tpXVswXTsKKwkJfQorCQlpZiAocHBtdS0+Z2V0X2NvbnN0cmFpbnQoZXZlbnRbaV0sICZhbWFza3NbaV1bMF0sCisJCQkJCSAmYXZhbHVlc1tpXVswXSkpCisJCQlyZXR1cm4gLTE7CisJfQorCXZhbHVlID0gbWFzayA9IDA7CisJZm9yIChpID0gMDsgaSA8IG5fZXY7ICsraSkgeworCQludiA9ICh2YWx1ZSB8IGF2YWx1ZXNbaV1bMF0pICsgKHZhbHVlICYgYXZhbHVlc1tpXVswXSAmIGFkZGYpOworCQlpZiAoKCgobnYgKyB0YWRkKSBeIHZhbHVlKSAmIG1hc2spICE9IDAgfHwKKwkJICAgICgoKG52ICsgdGFkZCkgXiBhdmFsdWVzW2ldWzBdKSAmIGFtYXNrc1tpXVswXSkgIT0gMCkKKwkJCWJyZWFrOworCQl2YWx1ZSA9IG52OworCQltYXNrIHw9IGFtYXNrc1tpXVswXTsKKwl9CisJaWYgKGkgPT0gbl9ldikKKwkJcmV0dXJuIDA7CS8qIGFsbCBPSyAqLworCisJLyogZG9lc24ndCB3b3JrLCBnYXRoZXIgYWx0ZXJuYXRpdmVzLi4uICovCisJaWYgKCFwcG11LT5nZXRfYWx0ZXJuYXRpdmVzKQorCQlyZXR1cm4gLTE7CisJZm9yIChpID0gMDsgaSA8IG5fZXY7ICsraSkgeworCQljaG9pY2VbaV0gPSAwOworCQluX2FsdFtpXSA9IHBwbXUtPmdldF9hbHRlcm5hdGl2ZXMoZXZlbnRbaV0sIGNmbGFnc1tpXSwKKwkJCQkJCSAgYWx0ZXJuYXRpdmVzW2ldKTsKKwkJZm9yIChqID0gMTsgaiA8IG5fYWx0W2ldOyArK2opCisJCQlwcG11LT5nZXRfY29uc3RyYWludChhbHRlcm5hdGl2ZXNbaV1bal0sCisJCQkJCSAgICAgJmFtYXNrc1tpXVtqXSwgJmF2YWx1ZXNbaV1bal0pOworCX0KKworCS8qIGVudW1lcmF0ZSBhbGwgcG9zc2liaWxpdGllcyBhbmQgc2VlIGlmIGFueSB3aWxsIHdvcmsgKi8KKwlpID0gMDsKKwlqID0gLTE7CisJdmFsdWUgPSBtYXNrID0gbnYgPSAwOworCXdoaWxlIChpIDwgbl9ldikgeworCQlpZiAoaiA+PSAwKSB7CisJCQkvKiB3ZSdyZSBiYWNrdHJhY2tpbmcsIHJlc3RvcmUgY29udGV4dCAqLworCQkJdmFsdWUgPSBzdmFsdWVzW2ldOworCQkJbWFzayA9IHNtYXNrc1tpXTsKKwkJCWogPSBjaG9pY2VbaV07CisJCX0KKwkJLyoKKwkJICogU2VlIGlmIGFueSBhbHRlcm5hdGl2ZSBrIGZvciBldmVudCBpLAorCQkgKiB3aGVyZSBrID4gaiwgd2lsbCBzYXRpc2Z5IHRoZSBjb25zdHJhaW50cy4KKwkJICovCisJCXdoaWxlICgrK2ogPCBuX2FsdFtpXSkgeworCQkJbnYgPSAodmFsdWUgfCBhdmFsdWVzW2ldW2pdKSArCisJCQkJKHZhbHVlICYgYXZhbHVlc1tpXVtqXSAmIGFkZGYpOworCQkJaWYgKCgoKG52ICsgdGFkZCkgXiB2YWx1ZSkgJiBtYXNrKSA9PSAwICYmCisJCQkgICAgKCgobnYgKyB0YWRkKSBeIGF2YWx1ZXNbaV1bal0pCisJCQkgICAgICYgYW1hc2tzW2ldW2pdKSA9PSAwKQorCQkJCWJyZWFrOworCQl9CisJCWlmIChqID49IG5fYWx0W2ldKSB7CisJCQkvKgorCQkJICogTm8gZmVhc2libGUgYWx0ZXJuYXRpdmUsIGJhY2t0cmFjaworCQkJICogdG8gZXZlbnQgaS0xIGFuZCBjb250aW51ZSBlbnVtZXJhdGluZyBpdHMKKwkJCSAqIGFsdGVybmF0aXZlcyBmcm9tIHdoZXJlIHdlIGdvdCB1cCB0by4KKwkJCSAqLworCQkJaWYgKC0taSA8IDApCisJCQkJcmV0dXJuIC0xOworCQl9IGVsc2UgeworCQkJLyoKKwkJCSAqIEZvdW5kIGEgZmVhc2libGUgYWx0ZXJuYXRpdmUgZm9yIGV2ZW50IGksCisJCQkgKiByZW1lbWJlciB3aGVyZSB3ZSBnb3QgdXAgdG8gd2l0aCB0aGlzIGV2ZW50LAorCQkJICogZ28gb24gdG8gdGhlIG5leHQgZXZlbnQsIGFuZCBzdGFydCB3aXRoCisJCQkgKiB0aGUgZmlyc3QgYWx0ZXJuYXRpdmUgZm9yIGl0LgorCQkJICovCisJCQljaG9pY2VbaV0gPSBqOworCQkJc3ZhbHVlc1tpXSA9IHZhbHVlOworCQkJc21hc2tzW2ldID0gbWFzazsKKwkJCXZhbHVlID0gbnY7CisJCQltYXNrIHw9IGFtYXNrc1tpXVtqXTsKKwkJCSsraTsKKwkJCWogPSAtMTsKKwkJfQorCX0KKworCS8qIE9LLCB3ZSBoYXZlIGEgZmVhc2libGUgY29tYmluYXRpb24sIHRlbGwgdGhlIGNhbGxlciB0aGUgc29sdXRpb24gKi8KKwlmb3IgKGkgPSAwOyBpIDwgbl9ldjsgKytpKQorCQlldmVudFtpXSA9IGFsdGVybmF0aXZlc1tpXVtjaG9pY2VbaV1dOworCXJldHVybiAwOworfQorCisvKgorICogQ2hlY2sgaWYgbmV3bHktYWRkZWQgY291bnRlcnMgaGF2ZSBjb25zaXN0ZW50IHNldHRpbmdzIGZvcgorICogZXhjbHVkZV97dXNlcixrZXJuZWwsaHZ9IHdpdGggZWFjaCBvdGhlciBhbmQgYW55IHByZXZpb3VzbHkKKyAqIGFkZGVkIGNvdW50ZXJzLgorICovCitzdGF0aWMgaW50IGNoZWNrX2V4Y2x1ZGVzKHN0cnVjdCBwZXJmX2NvdW50ZXIgKipjdHJzLCB1bnNpZ25lZCBpbnQgY2ZsYWdzW10sCisJCQkgIGludCBuX3ByZXYsIGludCBuX25ldykKK3sKKwlpbnQgZXUgPSAwLCBlayA9IDAsIGVoID0gMDsKKwlpbnQgaSwgbiwgZmlyc3Q7CisJc3RydWN0IHBlcmZfY291bnRlciAqY291bnRlcjsKKworCW4gPSBuX3ByZXYgKyBuX25ldzsKKwlpZiAobiA8PSAxKQorCQlyZXR1cm4gMDsKKworCWZpcnN0ID0gMTsKKwlmb3IgKGkgPSAwOyBpIDwgbjsgKytpKSB7CisJCWlmIChjZmxhZ3NbaV0gJiBQUE1VX0xJTUlURURfUE1DX09LKSB7CisJCQljZmxhZ3NbaV0gJj0gflBQTVVfTElNSVRFRF9QTUNfUkVRRDsKKwkJCWNvbnRpbnVlOworCQl9CisJCWNvdW50ZXIgPSBjdHJzW2ldOworCQlpZiAoZmlyc3QpIHsKKwkJCWV1ID0gY291bnRlci0+YXR0ci5leGNsdWRlX3VzZXI7CisJCQllayA9IGNvdW50ZXItPmF0dHIuZXhjbHVkZV9rZXJuZWw7CisJCQllaCA9IGNvdW50ZXItPmF0dHIuZXhjbHVkZV9odjsKKwkJCWZpcnN0ID0gMDsKKwkJfSBlbHNlIGlmIChjb3VudGVyLT5hdHRyLmV4Y2x1ZGVfdXNlciAhPSBldSB8fAorCQkJICAgY291bnRlci0+YXR0ci5leGNsdWRlX2tlcm5lbCAhPSBlayB8fAorCQkJICAgY291bnRlci0+YXR0ci5leGNsdWRlX2h2ICE9IGVoKSB7CisJCQlyZXR1cm4gLUVBR0FJTjsKKwkJfQorCX0KKworCWlmIChldSB8fCBlayB8fCBlaCkKKwkJZm9yIChpID0gMDsgaSA8IG47ICsraSkKKwkJCWlmIChjZmxhZ3NbaV0gJiBQUE1VX0xJTUlURURfUE1DX09LKQorCQkJCWNmbGFnc1tpXSB8PSBQUE1VX0xJTUlURURfUE1DX1JFUUQ7CisKKwlyZXR1cm4gMDsKK30KKworc3RhdGljIHZvaWQgcG93ZXJfcG11X3JlYWQoc3RydWN0IHBlcmZfY291bnRlciAqY291bnRlcikKK3sKKwlsb25nIHZhbCwgZGVsdGEsIHByZXY7CisKKwlpZiAoIWNvdW50ZXItPmh3LmlkeCkKKwkJcmV0dXJuOworCS8qCisJICogUGVyZm9ybWFuY2UgbW9uaXRvciBpbnRlcnJ1cHRzIGNvbWUgZXZlbiB3aGVuIGludGVycnVwdHMKKwkgKiBhcmUgc29mdC1kaXNhYmxlZCwgYXMgbG9uZyBhcyBpbnRlcnJ1cHRzIGFyZSBoYXJkLWVuYWJsZWQuCisJICogVGhlcmVmb3JlIHdlIHRyZWF0IHRoZW0gbGlrZSBOTUlzLgorCSAqLworCWRvIHsKKwkJcHJldiA9IGF0b21pYzY0X3JlYWQoJmNvdW50ZXItPmh3LnByZXZfY291bnQpOworCQliYXJyaWVyKCk7CisJCXZhbCA9IHJlYWRfcG1jKGNvdW50ZXItPmh3LmlkeCk7CisJfSB3aGlsZSAoYXRvbWljNjRfY21weGNoZygmY291bnRlci0+aHcucHJldl9jb3VudCwgcHJldiwgdmFsKSAhPSBwcmV2KTsKKworCS8qIFRoZSBjb3VudGVycyBhcmUgb25seSAzMiBiaXRzIHdpZGUgKi8KKwlkZWx0YSA9ICh2YWwgLSBwcmV2KSAmIDB4ZmZmZmZmZmZ1bDsKKwlhdG9taWM2NF9hZGQoZGVsdGEsICZjb3VudGVyLT5jb3VudCk7CisJYXRvbWljNjRfc3ViKGRlbHRhLCAmY291bnRlci0+aHcucGVyaW9kX2xlZnQpOworfQorCisvKgorICogT24gc29tZSBtYWNoaW5lcywgUE1DNSBhbmQgUE1DNiBjYW4ndCBiZSB3cml0dGVuLCBkb24ndCByZXNwZWN0CisgKiB0aGUgZnJlZXplIGNvbmRpdGlvbnMsIGFuZCBkb24ndCBnZW5lcmF0ZSBpbnRlcnJ1cHRzLiAgVGhpcyB0ZWxscworICogdXMgaWYgYGNvdW50ZXInIGlzIHVzaW5nIHN1Y2ggYSBQTUMuCisgKi8KK3N0YXRpYyBpbnQgaXNfbGltaXRlZF9wbWMoaW50IHBtY251bSkKK3sKKwlyZXR1cm4gKHBwbXUtPmZsYWdzICYgUFBNVV9MSU1JVEVEX1BNQzVfNikKKwkJJiYgKHBtY251bSA9PSA1IHx8IHBtY251bSA9PSA2KTsKK30KKworc3RhdGljIHZvaWQgZnJlZXplX2xpbWl0ZWRfY291bnRlcnMoc3RydWN0IGNwdV9od19jb3VudGVycyAqY3B1aHcsCisJCQkJICAgIHVuc2lnbmVkIGxvbmcgcG1jNSwgdW5zaWduZWQgbG9uZyBwbWM2KQoreworCXN0cnVjdCBwZXJmX2NvdW50ZXIgKmNvdW50ZXI7CisJdTY0IHZhbCwgcHJldiwgZGVsdGE7CisJaW50IGk7CisKKwlmb3IgKGkgPSAwOyBpIDwgY3B1aHctPm5fbGltaXRlZDsgKytpKSB7CisJCWNvdW50ZXIgPSBjcHVody0+bGltaXRlZF9jb3VudGVyW2ldOworCQlpZiAoIWNvdW50ZXItPmh3LmlkeCkKKwkJCWNvbnRpbnVlOworCQl2YWwgPSAoY291bnRlci0+aHcuaWR4ID09IDUpID8gcG1jNSA6IHBtYzY7CisJCXByZXYgPSBhdG9taWM2NF9yZWFkKCZjb3VudGVyLT5ody5wcmV2X2NvdW50KTsKKwkJY291bnRlci0+aHcuaWR4ID0gMDsKKwkJZGVsdGEgPSAodmFsIC0gcHJldikgJiAweGZmZmZmZmZmdWw7CisJCWF0b21pYzY0X2FkZChkZWx0YSwgJmNvdW50ZXItPmNvdW50KTsKKwl9Cit9CisKK3N0YXRpYyB2b2lkIHRoYXdfbGltaXRlZF9jb3VudGVycyhzdHJ1Y3QgY3B1X2h3X2NvdW50ZXJzICpjcHVodywKKwkJCQkgIHVuc2lnbmVkIGxvbmcgcG1jNSwgdW5zaWduZWQgbG9uZyBwbWM2KQoreworCXN0cnVjdCBwZXJmX2NvdW50ZXIgKmNvdW50ZXI7CisJdTY0IHZhbDsKKwlpbnQgaTsKKworCWZvciAoaSA9IDA7IGkgPCBjcHVody0+bl9saW1pdGVkOyArK2kpIHsKKwkJY291bnRlciA9IGNwdWh3LT5saW1pdGVkX2NvdW50ZXJbaV07CisJCWNvdW50ZXItPmh3LmlkeCA9IGNwdWh3LT5saW1pdGVkX2h3aWR4W2ldOworCQl2YWwgPSAoY291bnRlci0+aHcuaWR4ID09IDUpID8gcG1jNSA6IHBtYzY7CisJCWF0b21pYzY0X3NldCgmY291bnRlci0+aHcucHJldl9jb3VudCwgdmFsKTsKKwkJcGVyZl9jb3VudGVyX3VwZGF0ZV91c2VycGFnZShjb3VudGVyKTsKKwl9Cit9CisKKy8qCisgKiBTaW5jZSBsaW1pdGVkIGNvdW50ZXJzIGRvbid0IHJlc3BlY3QgdGhlIGZyZWV6ZSBjb25kaXRpb25zLCB3ZQorICogaGF2ZSB0byByZWFkIHRoZW0gaW1tZWRpYXRlbHkgYWZ0ZXIgZnJlZXppbmcgb3IgdW5mcmVlemluZyB0aGUKKyAqIG90aGVyIGNvdW50ZXJzLiAgV2UgdHJ5IHRvIGtlZXAgdGhlIHZhbHVlcyBmcm9tIHRoZSBsaW1pdGVkCisgKiBjb3VudGVycyBhcyBjb25zaXN0ZW50IGFzIHBvc3NpYmxlIGJ5IGtlZXBpbmcgdGhlIGRlbGF5IChpbgorICogY3ljbGVzIGFuZCBpbnN0cnVjdGlvbnMpIGJldHdlZW4gZnJlZXppbmcvdW5mcmVlemluZyBhbmQgcmVhZGluZworICogdGhlIGxpbWl0ZWQgY291bnRlcnMgYXMgc21hbGwgYW5kIGNvbnNpc3RlbnQgYXMgcG9zc2libGUuCisgKiBUaGVyZWZvcmUsIGlmIGFueSBsaW1pdGVkIGNvdW50ZXJzIGFyZSBpbiB1c2UsIHdlIHJlYWQgdGhlbQorICogYm90aCwgYW5kIGFsd2F5cyBpbiB0aGUgc2FtZSBvcmRlciwgdG8gbWluaW1pemUgdmFyaWFiaWxpdHksCisgKiBhbmQgZG8gaXQgaW5zaWRlIHRoZSBzYW1lIGFzbSB0aGF0IHdyaXRlcyBNTUNSMC4KKyAqLworc3RhdGljIHZvaWQgd3JpdGVfbW1jcjAoc3RydWN0IGNwdV9od19jb3VudGVycyAqY3B1aHcsIHVuc2lnbmVkIGxvbmcgbW1jcjApCit7CisJdW5zaWduZWQgbG9uZyBwbWM1LCBwbWM2OworCisJaWYgKCFjcHVody0+bl9saW1pdGVkKSB7CisJCW10c3ByKFNQUk5fTU1DUjAsIG1tY3IwKTsKKwkJcmV0dXJuOworCX0KKworCS8qCisJICogV3JpdGUgTU1DUjAsIHRoZW4gcmVhZCBQTUM1IGFuZCBQTUM2IGltbWVkaWF0ZWx5LgorCSAqIFRvIGVuc3VyZSB3ZSBkb24ndCBnZXQgYSBwZXJmb3JtYW5jZSBtb25pdG9yIGludGVycnVwdAorCSAqIGJldHdlZW4gd3JpdGluZyBNTUNSMCBhbmQgZnJlZXppbmcvdGhhd2luZyB0aGUgbGltaXRlZAorCSAqIGNvdW50ZXJzLCB3ZSBmaXJzdCB3cml0ZSBNTUNSMCB3aXRoIHRoZSBjb3VudGVyIG92ZXJmbG93CisJICogaW50ZXJydXB0IGVuYWJsZSBiaXRzIHR1cm5lZCBvZmYuCisJICovCisJYXNtIHZvbGF0aWxlKCJtdHNwciAlMywlMjsgbWZzcHIgJTAsJTQ7IG1mc3ByICUxLCU1IgorCQkgICAgIDogIj0mciIgKHBtYzUpLCAiPSZyIiAocG1jNikKKwkJICAgICA6ICJyIiAobW1jcjAgJiB+KE1NQ1IwX1BNQzFDRSB8IE1NQ1IwX1BNQ2pDRSkpLAorCQkgICAgICAgImkiIChTUFJOX01NQ1IwKSwKKwkJICAgICAgICJpIiAoU1BSTl9QTUM1KSwgImkiIChTUFJOX1BNQzYpKTsKKworCWlmIChtbWNyMCAmIE1NQ1IwX0ZDKQorCQlmcmVlemVfbGltaXRlZF9jb3VudGVycyhjcHVodywgcG1jNSwgcG1jNik7CisJZWxzZQorCQl0aGF3X2xpbWl0ZWRfY291bnRlcnMoY3B1aHcsIHBtYzUsIHBtYzYpOworCisJLyoKKwkgKiBXcml0ZSB0aGUgZnVsbCBNTUNSMCBpbmNsdWRpbmcgdGhlIGNvdW50ZXIgb3ZlcmZsb3cgaW50ZXJydXB0CisJICogZW5hYmxlIGJpdHMsIGlmIG5lY2Vzc2FyeS4KKwkgKi8KKwlpZiAobW1jcjAgJiAoTU1DUjBfUE1DMUNFIHwgTU1DUjBfUE1DakNFKSkKKwkJbXRzcHIoU1BSTl9NTUNSMCwgbW1jcjApOworfQorCisvKgorICogRGlzYWJsZSBhbGwgY291bnRlcnMgdG8gcHJldmVudCBQTVUgaW50ZXJydXB0cyBhbmQgdG8gYWxsb3cKKyAqIGNvdW50ZXJzIHRvIGJlIGFkZGVkIG9yIHJlbW92ZWQuCisgKi8KK3ZvaWQgaHdfcGVyZl9kaXNhYmxlKHZvaWQpCit7CisJc3RydWN0IGNwdV9od19jb3VudGVycyAqY3B1aHc7CisJdW5zaWduZWQgbG9uZyByZXQ7CisJdW5zaWduZWQgbG9uZyBmbGFnczsKKworCWxvY2FsX2lycV9zYXZlKGZsYWdzKTsKKwljcHVodyA9ICZfX2dldF9jcHVfdmFyKGNwdV9od19jb3VudGVycyk7CisKKwlyZXQgPSBjcHVody0+ZGlzYWJsZWQ7CisJaWYgKCFyZXQpIHsKKwkJY3B1aHctPmRpc2FibGVkID0gMTsKKwkJY3B1aHctPm5fYWRkZWQgPSAwOworCisJCS8qCisJCSAqIENoZWNrIGlmIHdlIGV2ZXIgZW5hYmxlZCB0aGUgUE1VIG9uIHRoaXMgY3B1LgorCQkgKi8KKwkJaWYgKCFjcHVody0+cG1jc19lbmFibGVkKSB7CisJCQlpZiAocHBjX21kLmVuYWJsZV9wbWNzKQorCQkJCXBwY19tZC5lbmFibGVfcG1jcygpOworCQkJY3B1aHctPnBtY3NfZW5hYmxlZCA9IDE7CisJCX0KKworCQkvKgorCQkgKiBEaXNhYmxlIGluc3RydWN0aW9uIHNhbXBsaW5nIGlmIGl0IHdhcyBlbmFibGVkCisJCSAqLworCQlpZiAoY3B1aHctPm1tY3JbMl0gJiBNTUNSQV9TQU1QTEVfRU5BQkxFKSB7CisJCQltdHNwcihTUFJOX01NQ1JBLAorCQkJICAgICAgY3B1aHctPm1tY3JbMl0gJiB+TU1DUkFfU0FNUExFX0VOQUJMRSk7CisJCQltYigpOworCQl9CisKKwkJLyoKKwkJICogU2V0IHRoZSAnZnJlZXplIGNvdW50ZXJzJyBiaXQuCisJCSAqIFRoZSBiYXJyaWVyIGlzIHRvIG1ha2Ugc3VyZSB0aGUgbXRzcHIgaGFzIGJlZW4KKwkJICogZXhlY3V0ZWQgYW5kIHRoZSBQTVUgaGFzIGZyb3plbiB0aGUgY291bnRlcnMKKwkJICogYmVmb3JlIHdlIHJldHVybi4KKwkJICovCisJCXdyaXRlX21tY3IwKGNwdWh3LCBtZnNwcihTUFJOX01NQ1IwKSB8IE1NQ1IwX0ZDKTsKKwkJbWIoKTsKKwl9CisJbG9jYWxfaXJxX3Jlc3RvcmUoZmxhZ3MpOworfQorCisvKgorICogUmUtZW5hYmxlIGFsbCBjb3VudGVycyBpZiBkaXNhYmxlID09IDAuCisgKiBJZiB3ZSB3ZXJlIHByZXZpb3VzbHkgZGlzYWJsZWQgYW5kIGNvdW50ZXJzIHdlcmUgYWRkZWQsIHRoZW4KKyAqIHB1dCB0aGUgbmV3IGNvbmZpZyBvbiB0aGUgUE1VLgorICovCit2b2lkIGh3X3BlcmZfZW5hYmxlKHZvaWQpCit7CisJc3RydWN0IHBlcmZfY291bnRlciAqY291bnRlcjsKKwlzdHJ1Y3QgY3B1X2h3X2NvdW50ZXJzICpjcHVodzsKKwl1bnNpZ25lZCBsb25nIGZsYWdzOworCWxvbmcgaTsKKwl1bnNpZ25lZCBsb25nIHZhbDsKKwlzNjQgbGVmdDsKKwl1bnNpZ25lZCBpbnQgaHdjX2luZGV4W01BWF9IV0NPVU5URVJTXTsKKwlpbnQgbl9saW07CisJaW50IGlkeDsKKworCWxvY2FsX2lycV9zYXZlKGZsYWdzKTsKKwljcHVodyA9ICZfX2dldF9jcHVfdmFyKGNwdV9od19jb3VudGVycyk7CisJaWYgKCFjcHVody0+ZGlzYWJsZWQpIHsKKwkJbG9jYWxfaXJxX3Jlc3RvcmUoZmxhZ3MpOworCQlyZXR1cm47CisJfQorCWNwdWh3LT5kaXNhYmxlZCA9IDA7CisKKwkvKgorCSAqIElmIHdlIGRpZG4ndCBjaGFuZ2UgYW55dGhpbmcsIG9yIG9ubHkgcmVtb3ZlZCBjb3VudGVycywKKwkgKiBubyBuZWVkIHRvIHJlY2FsY3VsYXRlIE1NQ1IqIHNldHRpbmdzIGFuZCByZXNldCB0aGUgUE1Dcy4KKwkgKiBKdXN0IHJlZW5hYmxlIHRoZSBQTVUgd2l0aCB0aGUgY3VycmVudCBNTUNSKiBzZXR0aW5ncworCSAqIChwb3NzaWJseSB1cGRhdGVkIGZvciByZW1vdmFsIG9mIGNvdW50ZXJzKS4KKwkgKi8KKwlpZiAoIWNwdWh3LT5uX2FkZGVkKSB7CisJCW10c3ByKFNQUk5fTU1DUkEsIGNwdWh3LT5tbWNyWzJdICYgfk1NQ1JBX1NBTVBMRV9FTkFCTEUpOworCQltdHNwcihTUFJOX01NQ1IxLCBjcHVody0+bW1jclsxXSk7CisJCWlmIChjcHVody0+bl9jb3VudGVycyA9PSAwKQorCQkJZ2V0X2xwcGFjYSgpLT5wbWNyZWdzX2luX3VzZSA9IDA7CisJCWdvdG8gb3V0X2VuYWJsZTsKKwl9CisKKwkvKgorCSAqIENvbXB1dGUgTU1DUiogdmFsdWVzIGZvciB0aGUgbmV3IHNldCBvZiBjb3VudGVycworCSAqLworCWlmIChwcG11LT5jb21wdXRlX21tY3IoY3B1aHctPmV2ZW50cywgY3B1aHctPm5fY291bnRlcnMsIGh3Y19pbmRleCwKKwkJCSAgICAgICBjcHVody0+bW1jcikpIHsKKwkJLyogc2hvdWxkbid0IGV2ZXIgZ2V0IGhlcmUgKi8KKwkJcHJpbnRrKEtFUk5fRVJSICJvb3BzIGNvbXB1dGVfbW1jciBmYWlsZWRcbiIpOworCQlnb3RvIG91dDsKKwl9CisKKwkvKgorCSAqIEFkZCBpbiBNTUNSMCBmcmVlemUgYml0cyBjb3JyZXNwb25kaW5nIHRvIHRoZQorCSAqIGF0dHIuZXhjbHVkZV8qIGJpdHMgZm9yIHRoZSBmaXJzdCBjb3VudGVyLgorCSAqIFdlIGhhdmUgYWxyZWFkeSBjaGVja2VkIHRoYXQgYWxsIGNvdW50ZXJzIGhhdmUgdGhlCisJICogc2FtZSB2YWx1ZXMgZm9yIHRoZXNlIGJpdHMgYXMgdGhlIGZpcnN0IGNvdW50ZXIuCisJICovCisJY291bnRlciA9IGNwdWh3LT5jb3VudGVyWzBdOworCWlmIChjb3VudGVyLT5hdHRyLmV4Y2x1ZGVfdXNlcikKKwkJY3B1aHctPm1tY3JbMF0gfD0gTU1DUjBfRkNQOworCWlmIChjb3VudGVyLT5hdHRyLmV4Y2x1ZGVfa2VybmVsKQorCQljcHVody0+bW1jclswXSB8PSBmcmVlemVfY291bnRlcnNfa2VybmVsOworCWlmIChjb3VudGVyLT5hdHRyLmV4Y2x1ZGVfaHYpCisJCWNwdWh3LT5tbWNyWzBdIHw9IE1NQ1IwX0ZDSFY7CisKKwkvKgorCSAqIFdyaXRlIHRoZSBuZXcgY29uZmlndXJhdGlvbiB0byBNTUNSKiB3aXRoIHRoZSBmcmVlemUKKwkgKiBiaXQgc2V0IGFuZCBzZXQgdGhlIGhhcmR3YXJlIGNvdW50ZXJzIHRvIHRoZWlyIGluaXRpYWwgdmFsdWVzLgorCSAqIFRoZW4gdW5mcmVlemUgdGhlIGNvdW50ZXJzLgorCSAqLworCWdldF9scHBhY2EoKS0+cG1jcmVnc19pbl91c2UgPSAxOworCW10c3ByKFNQUk5fTU1DUkEsIGNwdWh3LT5tbWNyWzJdICYgfk1NQ1JBX1NBTVBMRV9FTkFCTEUpOworCW10c3ByKFNQUk5fTU1DUjEsIGNwdWh3LT5tbWNyWzFdKTsKKwltdHNwcihTUFJOX01NQ1IwLCAoY3B1aHctPm1tY3JbMF0gJiB+KE1NQ1IwX1BNQzFDRSB8IE1NQ1IwX1BNQ2pDRSkpCisJCQkJfCBNTUNSMF9GQyk7CisKKwkvKgorCSAqIFJlYWQgb2ZmIGFueSBwcmUtZXhpc3RpbmcgY291bnRlcnMgdGhhdCBuZWVkIHRvIG1vdmUKKwkgKiB0byBhbm90aGVyIFBNQy4KKwkgKi8KKwlmb3IgKGkgPSAwOyBpIDwgY3B1aHctPm5fY291bnRlcnM7ICsraSkgeworCQljb3VudGVyID0gY3B1aHctPmNvdW50ZXJbaV07CisJCWlmIChjb3VudGVyLT5ody5pZHggJiYgY291bnRlci0+aHcuaWR4ICE9IGh3Y19pbmRleFtpXSArIDEpIHsKKwkJCXBvd2VyX3BtdV9yZWFkKGNvdW50ZXIpOworCQkJd3JpdGVfcG1jKGNvdW50ZXItPmh3LmlkeCwgMCk7CisJCQljb3VudGVyLT5ody5pZHggPSAwOworCQl9CisJfQorCisJLyoKKwkgKiBJbml0aWFsaXplIHRoZSBQTUNzIGZvciBhbGwgdGhlIG5ldyBhbmQgbW92ZWQgY291bnRlcnMuCisJICovCisJY3B1aHctPm5fbGltaXRlZCA9IG5fbGltID0gMDsKKwlmb3IgKGkgPSAwOyBpIDwgY3B1aHctPm5fY291bnRlcnM7ICsraSkgeworCQljb3VudGVyID0gY3B1aHctPmNvdW50ZXJbaV07CisJCWlmIChjb3VudGVyLT5ody5pZHgpCisJCQljb250aW51ZTsKKwkJaWR4ID0gaHdjX2luZGV4W2ldICsgMTsKKwkJaWYgKGlzX2xpbWl0ZWRfcG1jKGlkeCkpIHsKKwkJCWNwdWh3LT5saW1pdGVkX2NvdW50ZXJbbl9saW1dID0gY291bnRlcjsKKwkJCWNwdWh3LT5saW1pdGVkX2h3aWR4W25fbGltXSA9IGlkeDsKKwkJCSsrbl9saW07CisJCQljb250aW51ZTsKKwkJfQorCQl2YWwgPSAwOworCQlpZiAoY291bnRlci0+aHcuc2FtcGxlX3BlcmlvZCkgeworCQkJbGVmdCA9IGF0b21pYzY0X3JlYWQoJmNvdW50ZXItPmh3LnBlcmlvZF9sZWZ0KTsKKwkJCWlmIChsZWZ0IDwgMHg4MDAwMDAwMEwpCisJCQkJdmFsID0gMHg4MDAwMDAwMEwgLSBsZWZ0OworCQl9CisJCWF0b21pYzY0X3NldCgmY291bnRlci0+aHcucHJldl9jb3VudCwgdmFsKTsKKwkJY291bnRlci0+aHcuaWR4ID0gaWR4OworCQl3cml0ZV9wbWMoaWR4LCB2YWwpOworCQlwZXJmX2NvdW50ZXJfdXBkYXRlX3VzZXJwYWdlKGNvdW50ZXIpOworCX0KKwljcHVody0+bl9saW1pdGVkID0gbl9saW07CisJY3B1aHctPm1tY3JbMF0gfD0gTU1DUjBfUE1YRSB8IE1NQ1IwX0ZDRUNFOworCisgb3V0X2VuYWJsZToKKwltYigpOworCXdyaXRlX21tY3IwKGNwdWh3LCBjcHVody0+bW1jclswXSk7CisKKwkvKgorCSAqIEVuYWJsZSBpbnN0cnVjdGlvbiBzYW1wbGluZyBpZiBuZWNlc3NhcnkKKwkgKi8KKwlpZiAoY3B1aHctPm1tY3JbMl0gJiBNTUNSQV9TQU1QTEVfRU5BQkxFKSB7CisJCW1iKCk7CisJCW10c3ByKFNQUk5fTU1DUkEsIGNwdWh3LT5tbWNyWzJdKTsKKwl9CisKKyBvdXQ6CisJbG9jYWxfaXJxX3Jlc3RvcmUoZmxhZ3MpOworfQorCitzdGF0aWMgaW50IGNvbGxlY3RfZXZlbnRzKHN0cnVjdCBwZXJmX2NvdW50ZXIgKmdyb3VwLCBpbnQgbWF4X2NvdW50LAorCQkJICBzdHJ1Y3QgcGVyZl9jb3VudGVyICpjdHJzW10sIHU2NCAqZXZlbnRzLAorCQkJICB1bnNpZ25lZCBpbnQgKmZsYWdzKQoreworCWludCBuID0gMDsKKwlzdHJ1Y3QgcGVyZl9jb3VudGVyICpjb3VudGVyOworCisJaWYgKCFpc19zb2Z0d2FyZV9jb3VudGVyKGdyb3VwKSkgeworCQlpZiAobiA+PSBtYXhfY291bnQpCisJCQlyZXR1cm4gLTE7CisJCWN0cnNbbl0gPSBncm91cDsKKwkJZmxhZ3Nbbl0gPSBncm91cC0+aHcuY291bnRlcl9iYXNlOworCQlldmVudHNbbisrXSA9IGdyb3VwLT5ody5jb25maWc7CisJfQorCWxpc3RfZm9yX2VhY2hfZW50cnkoY291bnRlciwgJmdyb3VwLT5zaWJsaW5nX2xpc3QsIGxpc3RfZW50cnkpIHsKKwkJaWYgKCFpc19zb2Z0d2FyZV9jb3VudGVyKGNvdW50ZXIpICYmCisJCSAgICBjb3VudGVyLT5zdGF0ZSAhPSBQRVJGX0NPVU5URVJfU1RBVEVfT0ZGKSB7CisJCQlpZiAobiA+PSBtYXhfY291bnQpCisJCQkJcmV0dXJuIC0xOworCQkJY3Ryc1tuXSA9IGNvdW50ZXI7CisJCQlmbGFnc1tuXSA9IGNvdW50ZXItPmh3LmNvdW50ZXJfYmFzZTsKKwkJCWV2ZW50c1tuKytdID0gY291bnRlci0+aHcuY29uZmlnOworCQl9CisJfQorCXJldHVybiBuOworfQorCitzdGF0aWMgdm9pZCBjb3VudGVyX3NjaGVkX2luKHN0cnVjdCBwZXJmX2NvdW50ZXIgKmNvdW50ZXIsIGludCBjcHUpCit7CisJY291bnRlci0+c3RhdGUgPSBQRVJGX0NPVU5URVJfU1RBVEVfQUNUSVZFOworCWNvdW50ZXItPm9uY3B1ID0gY3B1OworCWNvdW50ZXItPnRzdGFtcF9ydW5uaW5nICs9IGNvdW50ZXItPmN0eC0+dGltZSAtIGNvdW50ZXItPnRzdGFtcF9zdG9wcGVkOworCWlmIChpc19zb2Z0d2FyZV9jb3VudGVyKGNvdW50ZXIpKQorCQljb3VudGVyLT5wbXUtPmVuYWJsZShjb3VudGVyKTsKK30KKworLyoKKyAqIENhbGxlZCB0byBlbmFibGUgYSB3aG9sZSBncm91cCBvZiBjb3VudGVycy4KKyAqIFJldHVybnMgMSBpZiB0aGUgZ3JvdXAgd2FzIGVuYWJsZWQsIG9yIC1FQUdBSU4gaWYgaXQgY291bGQgbm90IGJlLgorICogQXNzdW1lcyB0aGUgY2FsbGVyIGhhcyBkaXNhYmxlZCBpbnRlcnJ1cHRzIGFuZCBoYXMKKyAqIGZyb3plbiB0aGUgUE1VIHdpdGggaHdfcGVyZl9zYXZlX2Rpc2FibGUuCisgKi8KK2ludCBod19wZXJmX2dyb3VwX3NjaGVkX2luKHN0cnVjdCBwZXJmX2NvdW50ZXIgKmdyb3VwX2xlYWRlciwKKwkgICAgICAgc3RydWN0IHBlcmZfY3B1X2NvbnRleHQgKmNwdWN0eCwKKwkgICAgICAgc3RydWN0IHBlcmZfY291bnRlcl9jb250ZXh0ICpjdHgsIGludCBjcHUpCit7CisJc3RydWN0IGNwdV9od19jb3VudGVycyAqY3B1aHc7CisJbG9uZyBpLCBuLCBuMDsKKwlzdHJ1Y3QgcGVyZl9jb3VudGVyICpzdWI7CisKKwljcHVodyA9ICZfX2dldF9jcHVfdmFyKGNwdV9od19jb3VudGVycyk7CisJbjAgPSBjcHVody0+bl9jb3VudGVyczsKKwluID0gY29sbGVjdF9ldmVudHMoZ3JvdXBfbGVhZGVyLCBwcG11LT5uX2NvdW50ZXIgLSBuMCwKKwkJCSAgICZjcHVody0+Y291bnRlcltuMF0sICZjcHVody0+ZXZlbnRzW24wXSwKKwkJCSAgICZjcHVody0+ZmxhZ3NbbjBdKTsKKwlpZiAobiA8IDApCisJCXJldHVybiAtRUFHQUlOOworCWlmIChjaGVja19leGNsdWRlcyhjcHVody0+Y291bnRlciwgY3B1aHctPmZsYWdzLCBuMCwgbikpCisJCXJldHVybiAtRUFHQUlOOworCWkgPSBwb3dlcl9jaGVja19jb25zdHJhaW50cyhjcHVody0+ZXZlbnRzLCBjcHVody0+ZmxhZ3MsIG4gKyBuMCk7CisJaWYgKGkgPCAwKQorCQlyZXR1cm4gLUVBR0FJTjsKKwljcHVody0+bl9jb3VudGVycyA9IG4wICsgbjsKKwljcHVody0+bl9hZGRlZCArPSBuOworCisJLyoKKwkgKiBPSywgdGhpcyBncm91cCBjYW4gZ28gb247IHVwZGF0ZSBjb3VudGVyIHN0YXRlcyBldGMuLAorCSAqIGFuZCBlbmFibGUgYW55IHNvZnR3YXJlIGNvdW50ZXJzCisJICovCisJZm9yIChpID0gbjA7IGkgPCBuMCArIG47ICsraSkKKwkJY3B1aHctPmNvdW50ZXJbaV0tPmh3LmNvbmZpZyA9IGNwdWh3LT5ldmVudHNbaV07CisJY3B1Y3R4LT5hY3RpdmVfb25jcHUgKz0gbjsKKwluID0gMTsKKwljb3VudGVyX3NjaGVkX2luKGdyb3VwX2xlYWRlciwgY3B1KTsKKwlsaXN0X2Zvcl9lYWNoX2VudHJ5KHN1YiwgJmdyb3VwX2xlYWRlci0+c2libGluZ19saXN0LCBsaXN0X2VudHJ5KSB7CisJCWlmIChzdWItPnN0YXRlICE9IFBFUkZfQ09VTlRFUl9TVEFURV9PRkYpIHsKKwkJCWNvdW50ZXJfc2NoZWRfaW4oc3ViLCBjcHUpOworCQkJKytuOworCQl9CisJfQorCWN0eC0+bnJfYWN0aXZlICs9IG47CisKKwlyZXR1cm4gMTsKK30KKworLyoKKyAqIEFkZCBhIGNvdW50ZXIgdG8gdGhlIFBNVS4KKyAqIElmIGFsbCBjb3VudGVycyBhcmUgbm90IGFscmVhZHkgZnJvemVuLCB0aGVuIHdlIGRpc2FibGUgYW5kCisgKiByZS1lbmFibGUgdGhlIFBNVSBpbiBvcmRlciB0byBnZXQgaHdfcGVyZl9lbmFibGUgdG8gZG8gdGhlCisgKiBhY3R1YWwgd29yayBvZiByZWNvbmZpZ3VyaW5nIHRoZSBQTVUuCisgKi8KK3N0YXRpYyBpbnQgcG93ZXJfcG11X2VuYWJsZShzdHJ1Y3QgcGVyZl9jb3VudGVyICpjb3VudGVyKQoreworCXN0cnVjdCBjcHVfaHdfY291bnRlcnMgKmNwdWh3OworCXVuc2lnbmVkIGxvbmcgZmxhZ3M7CisJaW50IG4wOworCWludCByZXQgPSAtRUFHQUlOOworCisJbG9jYWxfaXJxX3NhdmUoZmxhZ3MpOworCXBlcmZfZGlzYWJsZSgpOworCisJLyoKKwkgKiBBZGQgdGhlIGNvdW50ZXIgdG8gdGhlIGxpc3QgKGlmIHRoZXJlIGlzIHJvb20pCisJICogYW5kIGNoZWNrIHdoZXRoZXIgdGhlIHRvdGFsIHNldCBpcyBzdGlsbCBmZWFzaWJsZS4KKwkgKi8KKwljcHVodyA9ICZfX2dldF9jcHVfdmFyKGNwdV9od19jb3VudGVycyk7CisJbjAgPSBjcHVody0+bl9jb3VudGVyczsKKwlpZiAobjAgPj0gcHBtdS0+bl9jb3VudGVyKQorCQlnb3RvIG91dDsKKwljcHVody0+Y291bnRlcltuMF0gPSBjb3VudGVyOworCWNwdWh3LT5ldmVudHNbbjBdID0gY291bnRlci0+aHcuY29uZmlnOworCWNwdWh3LT5mbGFnc1tuMF0gPSBjb3VudGVyLT5ody5jb3VudGVyX2Jhc2U7CisJaWYgKGNoZWNrX2V4Y2x1ZGVzKGNwdWh3LT5jb3VudGVyLCBjcHVody0+ZmxhZ3MsIG4wLCAxKSkKKwkJZ290byBvdXQ7CisJaWYgKHBvd2VyX2NoZWNrX2NvbnN0cmFpbnRzKGNwdWh3LT5ldmVudHMsIGNwdWh3LT5mbGFncywgbjAgKyAxKSkKKwkJZ290byBvdXQ7CisKKwljb3VudGVyLT5ody5jb25maWcgPSBjcHVody0+ZXZlbnRzW24wXTsKKwkrK2NwdWh3LT5uX2NvdW50ZXJzOworCSsrY3B1aHctPm5fYWRkZWQ7CisKKwlyZXQgPSAwOworIG91dDoKKwlwZXJmX2VuYWJsZSgpOworCWxvY2FsX2lycV9yZXN0b3JlKGZsYWdzKTsKKwlyZXR1cm4gcmV0OworfQorCisvKgorICogUmVtb3ZlIGEgY291bnRlciBmcm9tIHRoZSBQTVUuCisgKi8KK3N0YXRpYyB2b2lkIHBvd2VyX3BtdV9kaXNhYmxlKHN0cnVjdCBwZXJmX2NvdW50ZXIgKmNvdW50ZXIpCit7CisJc3RydWN0IGNwdV9od19jb3VudGVycyAqY3B1aHc7CisJbG9uZyBpOworCXVuc2lnbmVkIGxvbmcgZmxhZ3M7CisKKwlsb2NhbF9pcnFfc2F2ZShmbGFncyk7CisJcGVyZl9kaXNhYmxlKCk7CisKKwlwb3dlcl9wbXVfcmVhZChjb3VudGVyKTsKKworCWNwdWh3ID0gJl9fZ2V0X2NwdV92YXIoY3B1X2h3X2NvdW50ZXJzKTsKKwlmb3IgKGkgPSAwOyBpIDwgY3B1aHctPm5fY291bnRlcnM7ICsraSkgeworCQlpZiAoY291bnRlciA9PSBjcHVody0+Y291bnRlcltpXSkgeworCQkJd2hpbGUgKCsraSA8IGNwdWh3LT5uX2NvdW50ZXJzKQorCQkJCWNwdWh3LT5jb3VudGVyW2ktMV0gPSBjcHVody0+Y291bnRlcltpXTsKKwkJCS0tY3B1aHctPm5fY291bnRlcnM7CisJCQlwcG11LT5kaXNhYmxlX3BtYyhjb3VudGVyLT5ody5pZHggLSAxLCBjcHVody0+bW1jcik7CisJCQlpZiAoY291bnRlci0+aHcuaWR4KSB7CisJCQkJd3JpdGVfcG1jKGNvdW50ZXItPmh3LmlkeCwgMCk7CisJCQkJY291bnRlci0+aHcuaWR4ID0gMDsKKwkJCX0KKwkJCXBlcmZfY291bnRlcl91cGRhdGVfdXNlcnBhZ2UoY291bnRlcik7CisJCQlicmVhazsKKwkJfQorCX0KKwlmb3IgKGkgPSAwOyBpIDwgY3B1aHctPm5fbGltaXRlZDsgKytpKQorCQlpZiAoY291bnRlciA9PSBjcHVody0+bGltaXRlZF9jb3VudGVyW2ldKQorCQkJYnJlYWs7CisJaWYgKGkgPCBjcHVody0+bl9saW1pdGVkKSB7CisJCXdoaWxlICgrK2kgPCBjcHVody0+bl9saW1pdGVkKSB7CisJCQljcHVody0+bGltaXRlZF9jb3VudGVyW2ktMV0gPSBjcHVody0+bGltaXRlZF9jb3VudGVyW2ldOworCQkJY3B1aHctPmxpbWl0ZWRfaHdpZHhbaS0xXSA9IGNwdWh3LT5saW1pdGVkX2h3aWR4W2ldOworCQl9CisJCS0tY3B1aHctPm5fbGltaXRlZDsKKwl9CisJaWYgKGNwdWh3LT5uX2NvdW50ZXJzID09IDApIHsKKwkJLyogZGlzYWJsZSBleGNlcHRpb25zIGlmIG5vIGNvdW50ZXJzIGFyZSBydW5uaW5nICovCisJCWNwdWh3LT5tbWNyWzBdICY9IH4oTU1DUjBfUE1YRSB8IE1NQ1IwX0ZDRUNFKTsKKwl9CisKKwlwZXJmX2VuYWJsZSgpOworCWxvY2FsX2lycV9yZXN0b3JlKGZsYWdzKTsKK30KKworLyoKKyAqIFJlLWVuYWJsZSBpbnRlcnJ1cHRzIG9uIGEgY291bnRlciBhZnRlciB0aGV5IHdlcmUgdGhyb3R0bGVkCisgKiBiZWNhdXNlIHRoZXkgd2VyZSBjb21pbmcgdG9vIGZhc3QuCisgKi8KK3N0YXRpYyB2b2lkIHBvd2VyX3BtdV91bnRocm90dGxlKHN0cnVjdCBwZXJmX2NvdW50ZXIgKmNvdW50ZXIpCit7CisJczY0IHZhbCwgbGVmdDsKKwl1bnNpZ25lZCBsb25nIGZsYWdzOworCisJaWYgKCFjb3VudGVyLT5ody5pZHggfHwgIWNvdW50ZXItPmh3LnNhbXBsZV9wZXJpb2QpCisJCXJldHVybjsKKwlsb2NhbF9pcnFfc2F2ZShmbGFncyk7CisJcGVyZl9kaXNhYmxlKCk7CisJcG93ZXJfcG11X3JlYWQoY291bnRlcik7CisJbGVmdCA9IGNvdW50ZXItPmh3LnNhbXBsZV9wZXJpb2Q7CisJY291bnRlci0+aHcubGFzdF9wZXJpb2QgPSBsZWZ0OworCXZhbCA9IDA7CisJaWYgKGxlZnQgPCAweDgwMDAwMDAwTCkKKwkJdmFsID0gMHg4MDAwMDAwMEwgLSBsZWZ0OworCXdyaXRlX3BtYyhjb3VudGVyLT5ody5pZHgsIHZhbCk7CisJYXRvbWljNjRfc2V0KCZjb3VudGVyLT5ody5wcmV2X2NvdW50LCB2YWwpOworCWF0b21pYzY0X3NldCgmY291bnRlci0+aHcucGVyaW9kX2xlZnQsIGxlZnQpOworCXBlcmZfY291bnRlcl91cGRhdGVfdXNlcnBhZ2UoY291bnRlcik7CisJcGVyZl9lbmFibGUoKTsKKwlsb2NhbF9pcnFfcmVzdG9yZShmbGFncyk7Cit9CisKK3N0cnVjdCBwbXUgcG93ZXJfcG11ID0geworCS5lbmFibGUJCT0gcG93ZXJfcG11X2VuYWJsZSwKKwkuZGlzYWJsZQk9IHBvd2VyX3BtdV9kaXNhYmxlLAorCS5yZWFkCQk9IHBvd2VyX3BtdV9yZWFkLAorCS51bnRocm90dGxlCT0gcG93ZXJfcG11X3VudGhyb3R0bGUsCit9OworCisvKgorICogUmV0dXJuIDEgaWYgd2UgbWlnaHQgYmUgYWJsZSB0byBwdXQgY291bnRlciBvbiBhIGxpbWl0ZWQgUE1DLAorICogb3IgMCBpZiBub3QuCisgKiBBIGNvdW50ZXIgY2FuIG9ubHkgZ28gb24gYSBsaW1pdGVkIFBNQyBpZiBpdCBjb3VudHMgc29tZXRoaW5nCisgKiB0aGF0IGEgbGltaXRlZCBQTUMgY2FuIGNvdW50LCBkb2Vzbid0IHJlcXVpcmUgaW50ZXJydXB0cywgYW5kCisgKiBkb2Vzbid0IGV4Y2x1ZGUgYW55IHByb2Nlc3NvciBtb2RlLgorICovCitzdGF0aWMgaW50IGNhbl9nb19vbl9saW1pdGVkX3BtYyhzdHJ1Y3QgcGVyZl9jb3VudGVyICpjb3VudGVyLCB1NjQgZXYsCisJCQkJIHVuc2lnbmVkIGludCBmbGFncykKK3sKKwlpbnQgbjsKKwl1NjQgYWx0W01BWF9FVkVOVF9BTFRFUk5BVElWRVNdOworCisJaWYgKGNvdW50ZXItPmF0dHIuZXhjbHVkZV91c2VyCisJICAgIHx8IGNvdW50ZXItPmF0dHIuZXhjbHVkZV9rZXJuZWwKKwkgICAgfHwgY291bnRlci0+YXR0ci5leGNsdWRlX2h2CisJICAgIHx8IGNvdW50ZXItPmF0dHIuc2FtcGxlX3BlcmlvZCkKKwkJcmV0dXJuIDA7CisKKwlpZiAocHBtdS0+bGltaXRlZF9wbWNfZXZlbnQoZXYpKQorCQlyZXR1cm4gMTsKKworCS8qCisJICogVGhlIHJlcXVlc3RlZCBldmVudCBpc24ndCBvbiBhIGxpbWl0ZWQgUE1DIGFscmVhZHk7CisJICogc2VlIGlmIGFueSBhbHRlcm5hdGl2ZSBjb2RlIGdvZXMgb24gYSBsaW1pdGVkIFBNQy4KKwkgKi8KKwlpZiAoIXBwbXUtPmdldF9hbHRlcm5hdGl2ZXMpCisJCXJldHVybiAwOworCisJZmxhZ3MgfD0gUFBNVV9MSU1JVEVEX1BNQ19PSyB8IFBQTVVfTElNSVRFRF9QTUNfUkVRRDsKKwluID0gcHBtdS0+Z2V0X2FsdGVybmF0aXZlcyhldiwgZmxhZ3MsIGFsdCk7CisKKwlyZXR1cm4gbiA+IDA7Cit9CisKKy8qCisgKiBGaW5kIGFuIGFsdGVybmF0aXZlIGV2ZW50IHRoYXQgZ29lcyBvbiBhIG5vcm1hbCBQTUMsIGlmIHBvc3NpYmxlLAorICogYW5kIHJldHVybiB0aGUgZXZlbnQgY29kZSwgb3IgMCBpZiB0aGVyZSBpcyBubyBzdWNoIGFsdGVybmF0aXZlLgorICogKE5vdGU6IGV2ZW50IGNvZGUgMCBpcyAiZG9uJ3QgY291bnQiIG9uIGFsbCBtYWNoaW5lcy4pCisgKi8KK3N0YXRpYyB1NjQgbm9ybWFsX3BtY19hbHRlcm5hdGl2ZSh1NjQgZXYsIHVuc2lnbmVkIGxvbmcgZmxhZ3MpCit7CisJdTY0IGFsdFtNQVhfRVZFTlRfQUxURVJOQVRJVkVTXTsKKwlpbnQgbjsKKworCWZsYWdzICY9IH4oUFBNVV9MSU1JVEVEX1BNQ19PSyB8IFBQTVVfTElNSVRFRF9QTUNfUkVRRCk7CisJbiA9IHBwbXUtPmdldF9hbHRlcm5hdGl2ZXMoZXYsIGZsYWdzLCBhbHQpOworCWlmICghbikKKwkJcmV0dXJuIDA7CisJcmV0dXJuIGFsdFswXTsKK30KKworLyogTnVtYmVyIG9mIHBlcmZfY291bnRlcnMgY291bnRpbmcgaGFyZHdhcmUgZXZlbnRzICovCitzdGF0aWMgYXRvbWljX3QgbnVtX2NvdW50ZXJzOworLyogVXNlZCB0byBhdm9pZCByYWNlcyBpbiBjYWxsaW5nIHJlc2VydmUvcmVsZWFzZV9wbWNfaGFyZHdhcmUgKi8KK3N0YXRpYyBERUZJTkVfTVVURVgocG1jX3Jlc2VydmVfbXV0ZXgpOworCisvKgorICogUmVsZWFzZSB0aGUgUE1VIGlmIHRoaXMgaXMgdGhlIGxhc3QgcGVyZl9jb3VudGVyLgorICovCitzdGF0aWMgdm9pZCBod19wZXJmX2NvdW50ZXJfZGVzdHJveShzdHJ1Y3QgcGVyZl9jb3VudGVyICpjb3VudGVyKQoreworCWlmICghYXRvbWljX2FkZF91bmxlc3MoJm51bV9jb3VudGVycywgLTEsIDEpKSB7CisJCW11dGV4X2xvY2soJnBtY19yZXNlcnZlX211dGV4KTsKKwkJaWYgKGF0b21pY19kZWNfcmV0dXJuKCZudW1fY291bnRlcnMpID09IDApCisJCQlyZWxlYXNlX3BtY19oYXJkd2FyZSgpOworCQltdXRleF91bmxvY2soJnBtY19yZXNlcnZlX211dGV4KTsKKwl9Cit9CisKKy8qCisgKiBUcmFuc2xhdGUgYSBnZW5lcmljIGNhY2hlIGV2ZW50IGNvbmZpZyB0byBhIHJhdyBldmVudCBjb2RlLgorICovCitzdGF0aWMgaW50IGh3X3BlcmZfY2FjaGVfZXZlbnQodTY0IGNvbmZpZywgdTY0ICpldmVudHApCit7CisJdW5zaWduZWQgbG9uZyB0eXBlLCBvcCwgcmVzdWx0OworCWludCBldjsKKworCWlmICghcHBtdS0+Y2FjaGVfZXZlbnRzKQorCQlyZXR1cm4gLUVJTlZBTDsKKworCS8qIHVucGFjayBjb25maWcgKi8KKwl0eXBlID0gY29uZmlnICYgMHhmZjsKKwlvcCA9IChjb25maWcgPj4gOCkgJiAweGZmOworCXJlc3VsdCA9IChjb25maWcgPj4gMTYpICYgMHhmZjsKKworCWlmICh0eXBlID49IFBFUkZfQ09VTlRfSFdfQ0FDSEVfTUFYIHx8CisJICAgIG9wID49IFBFUkZfQ09VTlRfSFdfQ0FDSEVfT1BfTUFYIHx8CisJICAgIHJlc3VsdCA+PSBQRVJGX0NPVU5UX0hXX0NBQ0hFX1JFU1VMVF9NQVgpCisJCXJldHVybiAtRUlOVkFMOworCisJZXYgPSAoKnBwbXUtPmNhY2hlX2V2ZW50cylbdHlwZV1bb3BdW3Jlc3VsdF07CisJaWYgKGV2ID09IDApCisJCXJldHVybiAtRU9QTk9UU1VQUDsKKwlpZiAoZXYgPT0gLTEpCisJCXJldHVybiAtRUlOVkFMOworCSpldmVudHAgPSBldjsKKwlyZXR1cm4gMDsKK30KKworY29uc3Qgc3RydWN0IHBtdSAqaHdfcGVyZl9jb3VudGVyX2luaXQoc3RydWN0IHBlcmZfY291bnRlciAqY291bnRlcikKK3sKKwl1NjQgZXY7CisJdW5zaWduZWQgbG9uZyBmbGFnczsKKwlzdHJ1Y3QgcGVyZl9jb3VudGVyICpjdHJzW01BWF9IV0NPVU5URVJTXTsKKwl1NjQgZXZlbnRzW01BWF9IV0NPVU5URVJTXTsKKwl1bnNpZ25lZCBpbnQgY2ZsYWdzW01BWF9IV0NPVU5URVJTXTsKKwlpbnQgbjsKKwlpbnQgZXJyOworCisJaWYgKCFwcG11KQorCQlyZXR1cm4gRVJSX1BUUigtRU5YSU8pOworCXN3aXRjaCAoY291bnRlci0+YXR0ci50eXBlKSB7CisJY2FzZSBQRVJGX1RZUEVfSEFSRFdBUkU6CisJCWV2ID0gY291bnRlci0+YXR0ci5jb25maWc7CisJCWlmIChldiA+PSBwcG11LT5uX2dlbmVyaWMgfHwgcHBtdS0+Z2VuZXJpY19ldmVudHNbZXZdID09IDApCisJCQlyZXR1cm4gRVJSX1BUUigtRU9QTk9UU1VQUCk7CisJCWV2ID0gcHBtdS0+Z2VuZXJpY19ldmVudHNbZXZdOworCQlicmVhazsKKwljYXNlIFBFUkZfVFlQRV9IV19DQUNIRToKKwkJZXJyID0gaHdfcGVyZl9jYWNoZV9ldmVudChjb3VudGVyLT5hdHRyLmNvbmZpZywgJmV2KTsKKwkJaWYgKGVycikKKwkJCXJldHVybiBFUlJfUFRSKGVycik7CisJCWJyZWFrOworCWNhc2UgUEVSRl9UWVBFX1JBVzoKKwkJZXYgPSBjb3VudGVyLT5hdHRyLmNvbmZpZzsKKwkJYnJlYWs7CisJfQorCWNvdW50ZXItPmh3LmNvbmZpZ19iYXNlID0gZXY7CisJY291bnRlci0+aHcuaWR4ID0gMDsKKworCS8qCisJICogSWYgd2UgYXJlIG5vdCBydW5uaW5nIG9uIGEgaHlwZXJ2aXNvciwgZm9yY2UgdGhlCisJICogZXhjbHVkZV9odiBiaXQgdG8gMCBzbyB0aGF0IHdlIGRvbid0IGNhcmUgd2hhdAorCSAqIHRoZSB1c2VyIHNldCBpdCB0by4KKwkgKi8KKwlpZiAoIWZpcm13YXJlX2hhc19mZWF0dXJlKEZXX0ZFQVRVUkVfTFBBUikpCisJCWNvdW50ZXItPmF0dHIuZXhjbHVkZV9odiA9IDA7CisKKwkvKgorCSAqIElmIHRoaXMgaXMgYSBwZXItdGFzayBjb3VudGVyLCB0aGVuIHdlIGNhbiB1c2UKKwkgKiBQTV9SVU5fKiBldmVudHMgaW50ZXJjaGFuZ2VhYmx5IHdpdGggdGhlaXIgbm9uIFJVTl8qCisJICogZXF1aXZhbGVudHMsIGUuZy4gUE1fUlVOX0NZQyBpbnN0ZWFkIG9mIFBNX0NZQy4KKwkgKiBYWFggd2Ugc2hvdWxkIGNoZWNrIGlmIHRoZSB0YXNrIGlzIGFuIGlkbGUgdGFzay4KKwkgKi8KKwlmbGFncyA9IDA7CisJaWYgKGNvdW50ZXItPmN0eC0+dGFzaykKKwkJZmxhZ3MgfD0gUFBNVV9PTkxZX0NPVU5UX1JVTjsKKworCS8qCisJICogSWYgdGhpcyBtYWNoaW5lIGhhcyBsaW1pdGVkIGNvdW50ZXJzLCBjaGVjayB3aGV0aGVyIHRoaXMKKwkgKiBldmVudCBjb3VsZCBnbyBvbiBhIGxpbWl0ZWQgY291bnRlci4KKwkgKi8KKwlpZiAocHBtdS0+ZmxhZ3MgJiBQUE1VX0xJTUlURURfUE1DNV82KSB7CisJCWlmIChjYW5fZ29fb25fbGltaXRlZF9wbWMoY291bnRlciwgZXYsIGZsYWdzKSkgeworCQkJZmxhZ3MgfD0gUFBNVV9MSU1JVEVEX1BNQ19PSzsKKwkJfSBlbHNlIGlmIChwcG11LT5saW1pdGVkX3BtY19ldmVudChldikpIHsKKwkJCS8qCisJCQkgKiBUaGUgcmVxdWVzdGVkIGV2ZW50IGlzIG9uIGEgbGltaXRlZCBQTUMsCisJCQkgKiBidXQgd2UgY2FuJ3QgdXNlIGEgbGltaXRlZCBQTUM7IHNlZSBpZiBhbnkKKwkJCSAqIGFsdGVybmF0aXZlIGdvZXMgb24gYSBub3JtYWwgUE1DLgorCQkJICovCisJCQlldiA9IG5vcm1hbF9wbWNfYWx0ZXJuYXRpdmUoZXYsIGZsYWdzKTsKKwkJCWlmICghZXYpCisJCQkJcmV0dXJuIEVSUl9QVFIoLUVJTlZBTCk7CisJCX0KKwl9CisKKwkvKgorCSAqIElmIHRoaXMgaXMgaW4gYSBncm91cCwgY2hlY2sgaWYgaXQgY2FuIGdvIG9uIHdpdGggYWxsIHRoZQorCSAqIG90aGVyIGhhcmR3YXJlIGNvdW50ZXJzIGluIHRoZSBncm91cC4gIFdlIGFzc3VtZSB0aGUgY291bnRlcgorCSAqIGhhc24ndCBiZWVuIGxpbmtlZCBpbnRvIGl0cyBsZWFkZXIncyBzaWJsaW5nIGxpc3QgYXQgdGhpcyBwb2ludC4KKwkgKi8KKwluID0gMDsKKwlpZiAoY291bnRlci0+Z3JvdXBfbGVhZGVyICE9IGNvdW50ZXIpIHsKKwkJbiA9IGNvbGxlY3RfZXZlbnRzKGNvdW50ZXItPmdyb3VwX2xlYWRlciwgcHBtdS0+bl9jb3VudGVyIC0gMSwKKwkJCQkgICBjdHJzLCBldmVudHMsIGNmbGFncyk7CisJCWlmIChuIDwgMCkKKwkJCXJldHVybiBFUlJfUFRSKC1FSU5WQUwpOworCX0KKwlldmVudHNbbl0gPSBldjsKKwljdHJzW25dID0gY291bnRlcjsKKwljZmxhZ3Nbbl0gPSBmbGFnczsKKwlpZiAoY2hlY2tfZXhjbHVkZXMoY3RycywgY2ZsYWdzLCBuLCAxKSkKKwkJcmV0dXJuIEVSUl9QVFIoLUVJTlZBTCk7CisJaWYgKHBvd2VyX2NoZWNrX2NvbnN0cmFpbnRzKGV2ZW50cywgY2ZsYWdzLCBuICsgMSkpCisJCXJldHVybiBFUlJfUFRSKC1FSU5WQUwpOworCisJY291bnRlci0+aHcuY29uZmlnID0gZXZlbnRzW25dOworCWNvdW50ZXItPmh3LmNvdW50ZXJfYmFzZSA9IGNmbGFnc1tuXTsKKwljb3VudGVyLT5ody5sYXN0X3BlcmlvZCA9IGNvdW50ZXItPmh3LnNhbXBsZV9wZXJpb2Q7CisJYXRvbWljNjRfc2V0KCZjb3VudGVyLT5ody5wZXJpb2RfbGVmdCwgY291bnRlci0+aHcubGFzdF9wZXJpb2QpOworCisJLyoKKwkgKiBTZWUgaWYgd2UgbmVlZCB0byByZXNlcnZlIHRoZSBQTVUuCisJICogSWYgbm8gY291bnRlcnMgYXJlIGN1cnJlbnRseSBpbiB1c2UsIHRoZW4gd2UgaGF2ZSB0byB0YWtlIGEKKwkgKiBtdXRleCB0byBlbnN1cmUgdGhhdCB3ZSBkb24ndCByYWNlIHdpdGggYW5vdGhlciB0YXNrIGRvaW5nCisJICogcmVzZXJ2ZV9wbWNfaGFyZHdhcmUgb3IgcmVsZWFzZV9wbWNfaGFyZHdhcmUuCisJICovCisJZXJyID0gMDsKKwlpZiAoIWF0b21pY19pbmNfbm90X3plcm8oJm51bV9jb3VudGVycykpIHsKKwkJbXV0ZXhfbG9jaygmcG1jX3Jlc2VydmVfbXV0ZXgpOworCQlpZiAoYXRvbWljX3JlYWQoJm51bV9jb3VudGVycykgPT0gMCAmJgorCQkgICAgcmVzZXJ2ZV9wbWNfaGFyZHdhcmUocGVyZl9jb3VudGVyX2ludGVycnVwdCkpCisJCQllcnIgPSAtRUJVU1k7CisJCWVsc2UKKwkJCWF0b21pY19pbmMoJm51bV9jb3VudGVycyk7CisJCW11dGV4X3VubG9jaygmcG1jX3Jlc2VydmVfbXV0ZXgpOworCX0KKwljb3VudGVyLT5kZXN0cm95ID0gaHdfcGVyZl9jb3VudGVyX2Rlc3Ryb3k7CisKKwlpZiAoZXJyKQorCQlyZXR1cm4gRVJSX1BUUihlcnIpOworCXJldHVybiAmcG93ZXJfcG11OworfQorCisvKgorICogQSBjb3VudGVyIGhhcyBvdmVyZmxvd2VkOyB1cGRhdGUgaXRzIGNvdW50IGFuZCByZWNvcmQKKyAqIHRoaW5ncyBpZiByZXF1ZXN0ZWQuICBOb3RlIHRoYXQgaW50ZXJydXB0cyBhcmUgaGFyZC1kaXNhYmxlZAorICogaGVyZSBzbyB0aGVyZSBpcyBubyBwb3NzaWJpbGl0eSBvZiBiZWluZyBpbnRlcnJ1cHRlZC4KKyAqLworc3RhdGljIHZvaWQgcmVjb3JkX2FuZF9yZXN0YXJ0KHN0cnVjdCBwZXJmX2NvdW50ZXIgKmNvdW50ZXIsIGxvbmcgdmFsLAorCQkJICAgICAgIHN0cnVjdCBwdF9yZWdzICpyZWdzLCBpbnQgbm1pKQoreworCXU2NCBwZXJpb2QgPSBjb3VudGVyLT5ody5zYW1wbGVfcGVyaW9kOworCXM2NCBwcmV2LCBkZWx0YSwgbGVmdDsKKwlpbnQgcmVjb3JkID0gMDsKKwl1NjQgYWRkciwgbW1jcmEsIHNkc3luYzsKKworCS8qIHdlIGRvbid0IGhhdmUgdG8gd29ycnkgYWJvdXQgaW50ZXJydXB0cyBoZXJlICovCisJcHJldiA9IGF0b21pYzY0X3JlYWQoJmNvdW50ZXItPmh3LnByZXZfY291bnQpOworCWRlbHRhID0gKHZhbCAtIHByZXYpICYgMHhmZmZmZmZmZnVsOworCWF0b21pYzY0X2FkZChkZWx0YSwgJmNvdW50ZXItPmNvdW50KTsKKworCS8qCisJICogU2VlIGlmIHRoZSB0b3RhbCBwZXJpb2QgZm9yIHRoaXMgY291bnRlciBoYXMgZXhwaXJlZCwKKwkgKiBhbmQgdXBkYXRlIGZvciB0aGUgbmV4dCBwZXJpb2QuCisJICovCisJdmFsID0gMDsKKwlsZWZ0ID0gYXRvbWljNjRfcmVhZCgmY291bnRlci0+aHcucGVyaW9kX2xlZnQpIC0gZGVsdGE7CisJaWYgKHBlcmlvZCkgeworCQlpZiAobGVmdCA8PSAwKSB7CisJCQlsZWZ0ICs9IHBlcmlvZDsKKwkJCWlmIChsZWZ0IDw9IDApCisJCQkJbGVmdCA9IHBlcmlvZDsKKwkJCXJlY29yZCA9IDE7CisJCX0KKwkJaWYgKGxlZnQgPCAweDgwMDAwMDAwTCkKKwkJCXZhbCA9IDB4ODAwMDAwMDBMIC0gbGVmdDsKKwl9CisKKwkvKgorCSAqIEZpbmFsbHkgcmVjb3JkIGRhdGEgaWYgcmVxdWVzdGVkLgorCSAqLworCWlmIChyZWNvcmQpIHsKKwkJc3RydWN0IHBlcmZfc2FtcGxlX2RhdGEgZGF0YSA9IHsKKwkJCS5yZWdzCT0gcmVncywKKwkJCS5hZGRyCT0gMCwKKwkJCS5wZXJpb2QJPSBjb3VudGVyLT5ody5sYXN0X3BlcmlvZCwKKwkJfTsKKworCQlpZiAoY291bnRlci0+YXR0ci5zYW1wbGVfdHlwZSAmIFBFUkZfU0FNUExFX0FERFIpIHsKKwkJCS8qCisJCQkgKiBUaGUgdXNlciB3YW50cyBhIGRhdGEgYWRkcmVzcyByZWNvcmRlZC4KKwkJCSAqIElmIHdlJ3JlIG5vdCBkb2luZyBpbnN0cnVjdGlvbiBzYW1wbGluZywKKwkJCSAqIGdpdmUgdGhlbSB0aGUgU0RBUiAoc2FtcGxlZCBkYXRhIGFkZHJlc3MpLgorCQkJICogSWYgd2UgYXJlIGRvaW5nIGluc3RydWN0aW9uIHNhbXBsaW5nLCB0aGVuIG9ubHkKKwkJCSAqIGdpdmUgdGhlbSB0aGUgU0RBUiBpZiBpdCBjb3JyZXNwb25kcyB0byB0aGUKKwkJCSAqIGluc3RydWN0aW9uIHBvaW50ZWQgdG8gYnkgU0lBUjsgdGhpcyBpcyBpbmRpY2F0ZWQKKwkJCSAqIGJ5IHRoZSBbUE9XRVI2X11NTUNSQV9TRFNZTkMgYml0IGluIE1NQ1JBLgorCQkJICovCisJCQltbWNyYSA9IHJlZ3MtPmRzaXNyOworCQkJc2RzeW5jID0gKHBwbXUtPmZsYWdzICYgUFBNVV9BTFRfU0lQUikgPworCQkJCVBPV0VSNl9NTUNSQV9TRFNZTkMgOiBNTUNSQV9TRFNZTkM7CisJCQlpZiAoIShtbWNyYSAmIE1NQ1JBX1NBTVBMRV9FTkFCTEUpIHx8IChtbWNyYSAmIHNkc3luYykpCisJCQkJZGF0YS5hZGRyID0gbWZzcHIoU1BSTl9TREFSKTsKKwkJfQorCQlpZiAocGVyZl9jb3VudGVyX292ZXJmbG93KGNvdW50ZXIsIG5taSwgJmRhdGEpKSB7CisJCQkvKgorCQkJICogSW50ZXJydXB0cyBhcmUgY29taW5nIHRvbyBmYXN0IC0gdGhyb3R0bGUgdGhlbQorCQkJICogYnkgc2V0dGluZyB0aGUgY291bnRlciB0byAwLCBzbyBpdCB3aWxsIGJlCisJCQkgKiBhdCBsZWFzdCAyXjMwIGN5Y2xlcyB1bnRpbCB0aGUgbmV4dCBpbnRlcnJ1cHQKKwkJCSAqIChhc3N1bWluZyBlYWNoIGNvdW50ZXIgY291bnRzIGF0IG1vc3QgMiBjb3VudHMKKwkJCSAqIHBlciBjeWNsZSkuCisJCQkgKi8KKwkJCXZhbCA9IDA7CisJCQlsZWZ0ID0gfjBVTEwgPj4gMTsKKwkJfQorCX0KKworCXdyaXRlX3BtYyhjb3VudGVyLT5ody5pZHgsIHZhbCk7CisJYXRvbWljNjRfc2V0KCZjb3VudGVyLT5ody5wcmV2X2NvdW50LCB2YWwpOworCWF0b21pYzY0X3NldCgmY291bnRlci0+aHcucGVyaW9kX2xlZnQsIGxlZnQpOworCXBlcmZfY291bnRlcl91cGRhdGVfdXNlcnBhZ2UoY291bnRlcik7Cit9CisKKy8qCisgKiBDYWxsZWQgZnJvbSBnZW5lcmljIGNvZGUgdG8gZ2V0IHRoZSBtaXNjIGZsYWdzIChpLmUuIHByb2Nlc3NvciBtb2RlKQorICogZm9yIGFuIGV2ZW50LgorICovCit1bnNpZ25lZCBsb25nIHBlcmZfbWlzY19mbGFncyhzdHJ1Y3QgcHRfcmVncyAqcmVncykKK3sKKwl1bnNpZ25lZCBsb25nIG1tY3JhOworCisJaWYgKFRSQVAocmVncykgIT0gMHhmMDApIHsKKwkJLyogbm90IGEgUE1VIGludGVycnVwdCAqLworCQlyZXR1cm4gdXNlcl9tb2RlKHJlZ3MpID8gUEVSRl9FVkVOVF9NSVNDX1VTRVIgOgorCQkJUEVSRl9FVkVOVF9NSVNDX0tFUk5FTDsKKwl9CisKKwltbWNyYSA9IHJlZ3MtPmRzaXNyOworCWlmIChwcG11LT5mbGFncyAmIFBQTVVfQUxUX1NJUFIpIHsKKwkJaWYgKG1tY3JhICYgUE9XRVI2X01NQ1JBX1NJSFYpCisJCQlyZXR1cm4gUEVSRl9FVkVOVF9NSVNDX0hZUEVSVklTT1I7CisJCXJldHVybiAobW1jcmEgJiBQT1dFUjZfTU1DUkFfU0lQUikgPyBQRVJGX0VWRU5UX01JU0NfVVNFUiA6CisJCQlQRVJGX0VWRU5UX01JU0NfS0VSTkVMOworCX0KKwlpZiAobW1jcmEgJiBNTUNSQV9TSUhWKQorCQlyZXR1cm4gUEVSRl9FVkVOVF9NSVNDX0hZUEVSVklTT1I7CisJcmV0dXJuIChtbWNyYSAmIE1NQ1JBX1NJUFIpID8gUEVSRl9FVkVOVF9NSVNDX1VTRVIgOgorCQkJUEVSRl9FVkVOVF9NSVNDX0tFUk5FTDsKK30KKworLyoKKyAqIENhbGxlZCBmcm9tIGdlbmVyaWMgY29kZSB0byBnZXQgdGhlIGluc3RydWN0aW9uIHBvaW50ZXIKKyAqIGZvciBhbiBldmVudC4KKyAqLwordW5zaWduZWQgbG9uZyBwZXJmX2luc3RydWN0aW9uX3BvaW50ZXIoc3RydWN0IHB0X3JlZ3MgKnJlZ3MpCit7CisJdW5zaWduZWQgbG9uZyBtbWNyYTsKKwl1bnNpZ25lZCBsb25nIGlwOworCXVuc2lnbmVkIGxvbmcgc2xvdDsKKworCWlmIChUUkFQKHJlZ3MpICE9IDB4ZjAwKQorCQlyZXR1cm4gcmVncy0+bmlwOwkvKiBub3QgYSBQTVUgaW50ZXJydXB0ICovCisKKwlpcCA9IG1mc3ByKFNQUk5fU0lBUik7CisJbW1jcmEgPSByZWdzLT5kc2lzcjsKKwlpZiAoKG1tY3JhICYgTU1DUkFfU0FNUExFX0VOQUJMRSkgJiYgIShwcG11LT5mbGFncyAmIFBQTVVfQUxUX1NJUFIpKSB7CisJCXNsb3QgPSAobW1jcmEgJiBNTUNSQV9TTE9UKSA+PiBNTUNSQV9TTE9UX1NISUZUOworCQlpZiAoc2xvdCA+IDEpCisJCQlpcCArPSA0ICogKHNsb3QgLSAxKTsKKwl9CisJcmV0dXJuIGlwOworfQorCisvKgorICogUGVyZm9ybWFuY2UgbW9uaXRvciBpbnRlcnJ1cHQgc3R1ZmYKKyAqLworc3RhdGljIHZvaWQgcGVyZl9jb3VudGVyX2ludGVycnVwdChzdHJ1Y3QgcHRfcmVncyAqcmVncykKK3sKKwlpbnQgaTsKKwlzdHJ1Y3QgY3B1X2h3X2NvdW50ZXJzICpjcHVodyA9ICZfX2dldF9jcHVfdmFyKGNwdV9od19jb3VudGVycyk7CisJc3RydWN0IHBlcmZfY291bnRlciAqY291bnRlcjsKKwlsb25nIHZhbDsKKwlpbnQgZm91bmQgPSAwOworCWludCBubWk7CisKKwlpZiAoY3B1aHctPm5fbGltaXRlZCkKKwkJZnJlZXplX2xpbWl0ZWRfY291bnRlcnMoY3B1aHcsIG1mc3ByKFNQUk5fUE1DNSksCisJCQkJCW1mc3ByKFNQUk5fUE1DNikpOworCisJLyoKKwkgKiBPdmVybG9hZCByZWdzLT5kc2lzciB0byBzdG9yZSBNTUNSQSBzbyB3ZSBvbmx5IG5lZWQgdG8gcmVhZCBpdCBvbmNlLgorCSAqLworCXJlZ3MtPmRzaXNyID0gbWZzcHIoU1BSTl9NTUNSQSk7CisKKwkvKgorCSAqIElmIGludGVycnVwdHMgd2VyZSBzb2Z0LWRpc2FibGVkIHdoZW4gdGhpcyBQTVUgaW50ZXJydXB0CisJICogb2NjdXJyZWQsIHRyZWF0IGl0IGFzIGFuIE5NSS4KKwkgKi8KKwlubWkgPSAhcmVncy0+c29mdGU7CisJaWYgKG5taSkKKwkJbm1pX2VudGVyKCk7CisJZWxzZQorCQlpcnFfZW50ZXIoKTsKKworCWZvciAoaSA9IDA7IGkgPCBjcHVody0+bl9jb3VudGVyczsgKytpKSB7CisJCWNvdW50ZXIgPSBjcHVody0+Y291bnRlcltpXTsKKwkJaWYgKCFjb3VudGVyLT5ody5pZHggfHwgaXNfbGltaXRlZF9wbWMoY291bnRlci0+aHcuaWR4KSkKKwkJCWNvbnRpbnVlOworCQl2YWwgPSByZWFkX3BtYyhjb3VudGVyLT5ody5pZHgpOworCQlpZiAoKGludCl2YWwgPCAwKSB7CisJCQkvKiBjb3VudGVyIGhhcyBvdmVyZmxvd2VkICovCisJCQlmb3VuZCA9IDE7CisJCQlyZWNvcmRfYW5kX3Jlc3RhcnQoY291bnRlciwgdmFsLCByZWdzLCBubWkpOworCQl9CisJfQorCisJLyoKKwkgKiBJbiBjYXNlIHdlIGRpZG4ndCBmaW5kIGFuZCByZXNldCB0aGUgY291bnRlciB0aGF0IGNhdXNlZAorCSAqIHRoZSBpbnRlcnJ1cHQsIHNjYW4gYWxsIGNvdW50ZXJzIGFuZCByZXNldCBhbnkgdGhhdCBhcmUKKwkgKiBuZWdhdGl2ZSwgdG8gYXZvaWQgZ2V0dGluZyBjb250aW51YWwgaW50ZXJydXB0cy4KKwkgKiBBbnkgdGhhdCB3ZSBwcm9jZXNzZWQgaW4gdGhlIHByZXZpb3VzIGxvb3Agd2lsbCBub3QgYmUgbmVnYXRpdmUuCisJICovCisJaWYgKCFmb3VuZCkgeworCQlmb3IgKGkgPSAwOyBpIDwgcHBtdS0+bl9jb3VudGVyOyArK2kpIHsKKwkJCWlmIChpc19saW1pdGVkX3BtYyhpICsgMSkpCisJCQkJY29udGludWU7CisJCQl2YWwgPSByZWFkX3BtYyhpICsgMSk7CisJCQlpZiAoKGludCl2YWwgPCAwKQorCQkJCXdyaXRlX3BtYyhpICsgMSwgMCk7CisJCX0KKwl9CisKKwkvKgorCSAqIFJlc2V0IE1NQ1IwIHRvIGl0cyBub3JtYWwgdmFsdWUuICBUaGlzIHdpbGwgc2V0IFBNWEUgYW5kCisJICogY2xlYXIgRkMgKGZyZWV6ZSBjb3VudGVycykgYW5kIFBNQU8gKHBlcmYgbW9uIGFsZXJ0IG9jY3VycmVkKQorCSAqIGFuZCB0aHVzIGFsbG93IGludGVycnVwdHMgdG8gb2NjdXIgYWdhaW4uCisJICogWFhYIG1pZ2h0IHdhbnQgdG8gdXNlIE1TUi5QTSB0byBrZWVwIHRoZSBjb3VudGVycyBmcm96ZW4gdW50aWwKKwkgKiB3ZSBnZXQgYmFjayBvdXQgb2YgdGhpcyBpbnRlcnJ1cHQuCisJICovCisJd3JpdGVfbW1jcjAoY3B1aHcsIGNwdWh3LT5tbWNyWzBdKTsKKworCWlmIChubWkpCisJCW5taV9leGl0KCk7CisJZWxzZQorCQlpcnFfZXhpdCgpOworfQorCit2b2lkIGh3X3BlcmZfY291bnRlcl9zZXR1cChpbnQgY3B1KQoreworCXN0cnVjdCBjcHVfaHdfY291bnRlcnMgKmNwdWh3ID0gJnBlcl9jcHUoY3B1X2h3X2NvdW50ZXJzLCBjcHUpOworCisJbWVtc2V0KGNwdWh3LCAwLCBzaXplb2YoKmNwdWh3KSk7CisJY3B1aHctPm1tY3JbMF0gPSBNTUNSMF9GQzsKK30KKworZXh0ZXJuIHN0cnVjdCBwb3dlcl9wbXUgcG93ZXI0X3BtdTsKK2V4dGVybiBzdHJ1Y3QgcG93ZXJfcG11IHBwYzk3MF9wbXU7CitleHRlcm4gc3RydWN0IHBvd2VyX3BtdSBwb3dlcjVfcG11OworZXh0ZXJuIHN0cnVjdCBwb3dlcl9wbXUgcG93ZXI1cF9wbXU7CitleHRlcm4gc3RydWN0IHBvd2VyX3BtdSBwb3dlcjZfcG11OworZXh0ZXJuIHN0cnVjdCBwb3dlcl9wbXUgcG93ZXI3X3BtdTsKKworc3RhdGljIGludCBpbml0X3BlcmZfY291bnRlcnModm9pZCkKK3sKKwl1bnNpZ25lZCBsb25nIHB2cjsKKworCS8qIFhYWCBzaG91bGQgZ2V0IHRoaXMgZnJvbSBjcHV0YWJsZSAqLworCXB2ciA9IG1mc3ByKFNQUk5fUFZSKTsKKwlzd2l0Y2ggKFBWUl9WRVIocHZyKSkgeworCWNhc2UgUFZfUE9XRVI0OgorCWNhc2UgUFZfUE9XRVI0cDoKKwkJcHBtdSA9ICZwb3dlcjRfcG11OworCQlicmVhazsKKwljYXNlIFBWXzk3MDoKKwljYXNlIFBWXzk3MEZYOgorCWNhc2UgUFZfOTcwTVA6CisJCXBwbXUgPSAmcHBjOTcwX3BtdTsKKwkJYnJlYWs7CisJY2FzZSBQVl9QT1dFUjU6CisJCXBwbXUgPSAmcG93ZXI1X3BtdTsKKwkJYnJlYWs7CisJY2FzZSBQVl9QT1dFUjVwOgorCQlwcG11ID0gJnBvd2VyNXBfcG11OworCQlicmVhazsKKwljYXNlIDB4M2U6CisJCXBwbXUgPSAmcG93ZXI2X3BtdTsKKwkJYnJlYWs7CisJY2FzZSAweDNmOgorCQlwcG11ID0gJnBvd2VyN19wbXU7CisJCWJyZWFrOworCX0KKworCS8qCisJICogVXNlIEZDSFYgdG8gaWdub3JlIGtlcm5lbCBldmVudHMgaWYgTVNSLkhWIGlzIHNldC4KKwkgKi8KKwlpZiAobWZtc3IoKSAmIE1TUl9IVikKKwkJZnJlZXplX2NvdW50ZXJzX2tlcm5lbCA9IE1NQ1IwX0ZDSFY7CisKKwlyZXR1cm4gMDsKK30KKworYXJjaF9pbml0Y2FsbChpbml0X3BlcmZfY291bnRlcnMpOwpkaWZmIC0tZ2l0IGEvYXJjaC9wb3dlcnBjL2tlcm5lbC9wb3dlcjQtcG11LmMgYi9hcmNoL3Bvd2VycGMva2VybmVsL3Bvd2VyNC1wbXUuYwpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi4wN2JkMzA4Ci0tLSAvZGV2L251bGwKKysrIGIvYXJjaC9wb3dlcnBjL2tlcm5lbC9wb3dlcjQtcG11LmMKQEAgLTAsMCArMSw1OTggQEAKKy8qCisgKiBQZXJmb3JtYW5jZSBjb3VudGVyIHN1cHBvcnQgZm9yIFBPV0VSNCAoR1ApIGFuZCBQT1dFUjQrIChHUSkgcHJvY2Vzc29ycy4KKyAqCisgKiBDb3B5cmlnaHQgMjAwOSBQYXVsIE1hY2tlcnJhcywgSUJNIENvcnBvcmF0aW9uLgorICoKKyAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IKKyAqIG1vZGlmeSBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlCisgKiBhcyBwdWJsaXNoZWQgYnkgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbjsgZWl0aGVyIHZlcnNpb24KKyAqIDIgb2YgdGhlIExpY2Vuc2UsIG9yIChhdCB5b3VyIG9wdGlvbikgYW55IGxhdGVyIHZlcnNpb24uCisgKi8KKyNpbmNsdWRlIDxsaW51eC9rZXJuZWwuaD4KKyNpbmNsdWRlIDxsaW51eC9wZXJmX2NvdW50ZXIuaD4KKyNpbmNsdWRlIDxhc20vcmVnLmg+CisKKy8qCisgKiBCaXRzIGluIGV2ZW50IGNvZGUgZm9yIFBPV0VSNAorICovCisjZGVmaW5lIFBNX1BNQ19TSAkxMgkvKiBQTUMgbnVtYmVyICgxLWJhc2VkKSBmb3IgZGlyZWN0IGV2ZW50cyAqLworI2RlZmluZSBQTV9QTUNfTVNLCTB4ZgorI2RlZmluZSBQTV9VTklUX1NICTgJLyogVFRNTVVYIG51bWJlciBhbmQgc2V0dGluZyAtIHVuaXQgc2VsZWN0ICovCisjZGVmaW5lIFBNX1VOSVRfTVNLCTB4ZgorI2RlZmluZSBQTV9MT1dFUl9TSAk2CisjZGVmaW5lIFBNX0xPV0VSX01TSwkxCisjZGVmaW5lIFBNX0xPV0VSX01TS1MJMHg0MAorI2RlZmluZSBQTV9CWVRFX1NICTQJLyogQnl0ZSBudW1iZXIgb2YgZXZlbnQgYnVzIHRvIHVzZSAqLworI2RlZmluZSBQTV9CWVRFX01TSwkzCisjZGVmaW5lIFBNX1BNQ1NFTF9NU0sJNworCisvKgorICogVW5pdCBjb2RlIHZhbHVlcworICovCisjZGVmaW5lIFBNX0ZQVQkJMQorI2RlZmluZSBQTV9JU1UxCQkyCisjZGVmaW5lIFBNX0lGVQkJMworI2RlZmluZSBQTV9JRFUwCQk0CisjZGVmaW5lIFBNX0lTVTFfQUxUCTYKKyNkZWZpbmUgUE1fSVNVMgkJNworI2RlZmluZSBQTV9JRlVfQUxUCTgKKyNkZWZpbmUgUE1fTFNVMAkJOQorI2RlZmluZSBQTV9MU1UxCQkweGMKKyNkZWZpbmUgUE1fR1BTCQkweGYKKworLyoKKyAqIEJpdHMgaW4gTU1DUjAgZm9yIFBPV0VSNAorICovCisjZGVmaW5lIE1NQ1IwX1BNQzFTRUxfU0gJOAorI2RlZmluZSBNTUNSMF9QTUMyU0VMX1NICTEKKyNkZWZpbmUgTU1DUl9QTUNTRUxfTVNLCQkweDFmCisKKy8qCisgKiBCaXRzIGluIE1NQ1IxIGZvciBQT1dFUjQKKyAqLworI2RlZmluZSBNTUNSMV9UVE0wU0VMX1NICTYyCisjZGVmaW5lIE1NQ1IxX1RUQzBTRUxfU0gJNjEKKyNkZWZpbmUgTU1DUjFfVFRNMVNFTF9TSAk1OQorI2RlZmluZSBNTUNSMV9UVEMxU0VMX1NICTU4CisjZGVmaW5lIE1NQ1IxX1RUTTJTRUxfU0gJNTYKKyNkZWZpbmUgTU1DUjFfVFRDMlNFTF9TSAk1NQorI2RlZmluZSBNTUNSMV9UVE0zU0VMX1NICTUzCisjZGVmaW5lIE1NQ1IxX1RUQzNTRUxfU0gJNTIKKyNkZWZpbmUgTU1DUjFfVFRNU0VMX01TSwkzCisjZGVmaW5lIE1NQ1IxX1REX0NQX0RCRzBTRUxfU0gJNTAKKyNkZWZpbmUgTU1DUjFfVERfQ1BfREJHMVNFTF9TSAk0OAorI2RlZmluZSBNTUNSMV9URF9DUF9EQkcyU0VMX1NICTQ2CisjZGVmaW5lIE1NQ1IxX1REX0NQX0RCRzNTRUxfU0gJNDQKKyNkZWZpbmUgTU1DUjFfREVCVUcwU0VMX1NICTQzCisjZGVmaW5lIE1NQ1IxX0RFQlVHMVNFTF9TSAk0MgorI2RlZmluZSBNTUNSMV9ERUJVRzJTRUxfU0gJNDEKKyNkZWZpbmUgTU1DUjFfREVCVUczU0VMX1NICTQwCisjZGVmaW5lIE1NQ1IxX1BNQzFfQURERVJfU0VMX1NICTM5CisjZGVmaW5lIE1NQ1IxX1BNQzJfQURERVJfU0VMX1NICTM4CisjZGVmaW5lIE1NQ1IxX1BNQzZfQURERVJfU0VMX1NICTM3CisjZGVmaW5lIE1NQ1IxX1BNQzVfQURERVJfU0VMX1NICTM2CisjZGVmaW5lIE1NQ1IxX1BNQzhfQURERVJfU0VMX1NICTM1CisjZGVmaW5lIE1NQ1IxX1BNQzdfQURERVJfU0VMX1NICTM0CisjZGVmaW5lIE1NQ1IxX1BNQzNfQURERVJfU0VMX1NICTMzCisjZGVmaW5lIE1NQ1IxX1BNQzRfQURERVJfU0VMX1NICTMyCisjZGVmaW5lIE1NQ1IxX1BNQzNTRUxfU0gJMjcKKyNkZWZpbmUgTU1DUjFfUE1DNFNFTF9TSAkyMgorI2RlZmluZSBNTUNSMV9QTUM1U0VMX1NICTE3CisjZGVmaW5lIE1NQ1IxX1BNQzZTRUxfU0gJMTIKKyNkZWZpbmUgTU1DUjFfUE1DN1NFTF9TSAk3CisjZGVmaW5lIE1NQ1IxX1BNQzhTRUxfU0gJMgkvKiBub3RlIGJpdCAwIGlzIGluIE1NQ1JBIGZvciBHUCAqLworCitzdGF0aWMgc2hvcnQgbW1jcjFfYWRkZXJfYml0c1s4XSA9IHsKKwlNTUNSMV9QTUMxX0FEREVSX1NFTF9TSCwKKwlNTUNSMV9QTUMyX0FEREVSX1NFTF9TSCwKKwlNTUNSMV9QTUMzX0FEREVSX1NFTF9TSCwKKwlNTUNSMV9QTUM0X0FEREVSX1NFTF9TSCwKKwlNTUNSMV9QTUM1X0FEREVSX1NFTF9TSCwKKwlNTUNSMV9QTUM2X0FEREVSX1NFTF9TSCwKKwlNTUNSMV9QTUM3X0FEREVSX1NFTF9TSCwKKwlNTUNSMV9QTUM4X0FEREVSX1NFTF9TSAorfTsKKworLyoKKyAqIEJpdHMgaW4gTU1DUkEKKyAqLworI2RlZmluZSBNTUNSQV9QTUM4U0VMMF9TSAkxNwkvKiBQTUM4U0VMIGJpdCAwIGZvciBHUCAqLworCisvKgorICogTGF5b3V0IG9mIGNvbnN0cmFpbnQgYml0czoKKyAqIDY2NjY1NTU1NTU1NTU1NDQ0NDQ0NDQ0NDMzMzMzMzMzMzMyMjIyMjIyMjIyMTExMTExMTExMTAwMDAwMDAwMDAKKyAqIDMyMTA5ODc2NTQzMjEwOTg3NjU0MzIxMDk4NzY1NDMyMTA5ODc2NTQzMjEwOTg3NjU0MzIxMDk4NzY1NDMyMTAKKyAqICAgICAgICB8WyAgPlsgID5bICAgPnx8fFsgID5bICA+PCAgPjwgID48ICA+PCAgPjw+PD48Pjw+PD48Pjw+PD4KKyAqICAgICAgICB8IFVDMSBVQzIgVUMzIHx8fCBQUzEgUFMyIEIwICBCMSAgQjIgIEIzIFAxUDJQM1A0UDVQNlA3UDgKKyAqIAkgIFxTTVBMCSAgICAgICAgfHxcVFRDM1NFTAorICogCQkgICAgICAgIHxcVFRDX0lGVV9TRUwKKyAqIAkJICAgICAgICBcVFRNMlNFTDAKKyAqCisgKiBTTVBMIC0gU0FNUExFX0VOQUJMRSBjb25zdHJhaW50CisgKiAgICAgNTY6IFNBTVBMRV9FTkFCTEUgdmFsdWUgMHgwMTAwXzAwMDBfMDAwMF8wMDAwCisgKgorICogVUMxIC0gdW5pdCBjb25zdHJhaW50IDE6IGNhbid0IGhhdmUgYWxsIHRocmVlIG9mIEZQVS9JU1UxL0lEVTB8SVNVMgorICogICAgIDU1OiBVQzEgZXJyb3IgMHgwMDgwXzAwMDBfMDAwMF8wMDAwCisgKiAgICAgNTQ6IEZQVSBldmVudHMgbmVlZGVkIDB4MDA0MF8wMDAwXzAwMDBfMDAwMAorICogICAgIDUzOiBJU1UxIGV2ZW50cyBuZWVkZWQgMHgwMDIwXzAwMDBfMDAwMF8wMDAwCisgKiAgICAgNTI6IElEVTB8SVNVMiBldmVudHMgbmVlZGVkIDB4MDAxMF8wMDAwXzAwMDBfMDAwMAorICoKKyAqIFVDMiAtIHVuaXQgY29uc3RyYWludCAyOiBjYW4ndCBoYXZlIGFsbCB0aHJlZSBvZiBGUFUvSUZVL0xTVTAKKyAqICAgICA1MTogVUMyIGVycm9yIDB4MDAwOF8wMDAwXzAwMDBfMDAwMAorICogICAgIDUwOiBGUFUgZXZlbnRzIG5lZWRlZCAweDAwMDRfMDAwMF8wMDAwXzAwMDAKKyAqICAgICA0OTogSUZVIGV2ZW50cyBuZWVkZWQgMHgwMDAyXzAwMDBfMDAwMF8wMDAwCisgKiAgICAgNDg6IExTVTAgZXZlbnRzIG5lZWRlZCAweDAwMDFfMDAwMF8wMDAwXzAwMDAKKyAqCisgKiBVQzMgLSB1bml0IGNvbnN0cmFpbnQgMzogY2FuJ3QgaGF2ZSBhbGwgZm91ciBvZiBMU1UwL0lGVS9JRFUwfElTVTIvSVNVMQorICogICAgIDQ3OiBVQzMgZXJyb3IgMHg4MDAwXzAwMDBfMDAwMAorICogICAgIDQ2OiBMU1UwIGV2ZW50cyBuZWVkZWQgMHg0MDAwXzAwMDBfMDAwMAorICogICAgIDQ1OiBJRlUgZXZlbnRzIG5lZWRlZCAweDIwMDBfMDAwMF8wMDAwCisgKiAgICAgNDQ6IElEVTB8SVNVMiBldmVudHMgbmVlZGVkIDB4MTAwMF8wMDAwXzAwMDAKKyAqICAgICA0MzogSVNVMSBldmVudHMgbmVlZGVkIDB4MDgwMF8wMDAwXzAwMDAKKyAqCisgKiBUVE0yU0VMMAorICogICAgIDQyOiAwID0gSURVMCBldmVudHMgbmVlZGVkCisgKiAgICAgCSAgIDEgPSBJU1UyIGV2ZW50cyBuZWVkZWQgMHgwNDAwXzAwMDBfMDAwMAorICoKKyAqIFRUQ19JRlVfU0VMCisgKiAgICAgNDE6IDAgPSBJRlUuVSBldmVudHMgbmVlZGVkCisgKiAgICAgCSAgIDEgPSBJRlUuTCBldmVudHMgbmVlZGVkIDB4MDIwMF8wMDAwXzAwMDAKKyAqCisgKiBUVEMzU0VMCisgKiAgICAgNDA6IDAgPSBMU1UxLlUgZXZlbnRzIG5lZWRlZAorICogICAgIAkgICAxID0gTFNVMS5MIGV2ZW50cyBuZWVkZWQgMHgwMTAwXzAwMDBfMDAwMAorICoKKyAqIFBTMQorICogICAgIDM5OiBQUzEgZXJyb3IgMHgwMDgwXzAwMDBfMDAwMAorICogICAgIDM2LTM4OiBjb3VudCBvZiBldmVudHMgbmVlZGluZyBQTUMxLzIvNS82IDB4MDA3MF8wMDAwXzAwMDAKKyAqCisgKiBQUzIKKyAqICAgICAzNTogUFMyIGVycm9yIDB4MDAwOF8wMDAwXzAwMDAKKyAqICAgICAzMi0zNDogY291bnQgb2YgZXZlbnRzIG5lZWRpbmcgUE1DMy80LzcvOCAweDAwMDdfMDAwMF8wMDAwCisgKgorICogQjAKKyAqICAgICAyOC0zMTogQnl0ZSAwIGV2ZW50IHNvdXJjZSAweGYwMDBfMDAwMAorICogICAgIAkgICAxID0gRlBVCisgKiAJICAgMiA9IElTVTEKKyAqIAkgICAzID0gSUZVCisgKiAJICAgNCA9IElEVTAKKyAqIAkgICA3ID0gSVNVMgorICogCSAgIDkgPSBMU1UwCisgKiAJICAgYyA9IExTVTEKKyAqIAkgICBmID0gR1BTCisgKgorICogQjEsIEIyLCBCMworICogICAgIDI0LTI3LCAyMC0yMywgMTYtMTk6IEJ5dGUgMSwgMiwgMyBldmVudCBzb3VyY2VzCisgKgorICogUDgKKyAqICAgICAxNTogUDggZXJyb3IgMHg4MDAwCisgKiAgICAgMTQtMTU6IENvdW50IG9mIGV2ZW50cyBuZWVkaW5nIFBNQzgKKyAqCisgKiBQMS4uUDcKKyAqICAgICAwLTEzOiBDb3VudCBvZiBldmVudHMgbmVlZGluZyBQTUMxLi5QTUM3CisgKgorICogTm90ZTogdGhpcyBkb2Vzbid0IGFsbG93IGV2ZW50cyB1c2luZyBJRlUuVSB0byBiZSBjb21iaW5lZCB3aXRoIGV2ZW50cworICogdXNpbmcgSUZVLkwsIHRob3VnaCB0aGF0IGlzIGZlYXNpYmxlICh1c2luZyBUVE0wIGFuZCBUVE0yKS4gIEhvd2V2ZXIKKyAqIHRoZXJlIGFyZSBubyBsaXN0ZWQgZXZlbnRzIGZvciBJRlUuTCAodGhleSBhcmUgZGVidWcgZXZlbnRzIG5vdAorICogdmVyaWZpZWQgZm9yIHBlcmZvcm1hbmNlIG1vbml0b3JpbmcpIHNvIHRoaXMgc2hvdWxkbid0IGNhdXNlIGEKKyAqIHByb2JsZW0uCisgKi8KKworc3RhdGljIHN0cnVjdCB1bml0aW5mbyB7CisJdTY0CXZhbHVlLCBtYXNrOworCWludAl1bml0OworCWludAlsb3dlcmJpdDsKK30gcDRfdW5pdGluZm9bMTZdID0geworCVtQTV9GUFVdICA9IHsgMHg0NDAwMDAwMDAwMDAwMHVsbCwgMHg4ODAwMDAwMDAwMDAwMHVsbCwgUE1fRlBVLCAwIH0sCisJW1BNX0lTVTFdID0geyAweDIwMDgwMDAwMDAwMDAwdWxsLCAweDg4MDAwMDAwMDAwMDAwdWxsLCBQTV9JU1UxLCAwIH0sCisJW1BNX0lTVTFfQUxUXSA9CisJCSAgICB7IDB4MjAwODAwMDAwMDAwMDB1bGwsIDB4ODgwMDAwMDAwMDAwMDB1bGwsIFBNX0lTVTEsIDAgfSwKKwlbUE1fSUZVXSAgPSB7IDB4MDIyMDAwMDAwMDAwMDB1bGwsIDB4MDg4MjAwMDAwMDAwMDB1bGwsIFBNX0lGVSwgNDEgfSwKKwlbUE1fSUZVX0FMVF0gPQorCQkgICAgeyAweDAyMjAwMDAwMDAwMDAwdWxsLCAweDA4ODIwMDAwMDAwMDAwdWxsLCBQTV9JRlUsIDQxIH0sCisJW1BNX0lEVTBdID0geyAweDEwMTAwMDAwMDAwMDAwdWxsLCAweDgwODQwMDAwMDAwMDAwdWxsLCBQTV9JRFUwLCAxIH0sCisJW1BNX0lTVTJdID0geyAweDEwMTQwMDAwMDAwMDAwdWxsLCAweDgwODQwMDAwMDAwMDAwdWxsLCBQTV9JU1UyLCAwIH0sCisJW1BNX0xTVTBdID0geyAweDAxNDAwMDAwMDAwMDAwdWxsLCAweDA4ODAwMDAwMDAwMDAwdWxsLCBQTV9MU1UwLCAwIH0sCisJW1BNX0xTVTFdID0geyAweDAwMDAwMDAwMDAwMDAwdWxsLCAweDAwMDEwMDAwMDAwMDAwdWxsLCBQTV9MU1UxLCA0MCB9LAorCVtQTV9HUFNdICA9IHsgMHgwMDAwMDAwMDAwMDAwMHVsbCwgMHgwMDAwMDAwMDAwMDAwMHVsbCwgUE1fR1BTLCAwIH0KK307CisKK3N0YXRpYyB1bnNpZ25lZCBjaGFyIGRpcmVjdF9tYXJrZWRfZXZlbnRbOF0gPSB7CisJKDE8PDIpIHwgKDE8PDMpLAkvKiBQTUMxOiBQTV9NUktfR1JQX0RJU1AsIFBNX01SS19TVF9DTVBMICovCisJKDE8PDMpIHwgKDE8PDUpLAkvKiBQTUMyOiBQTV9USFJFU0hfVElNRU8sIFBNX01SS19CUlVfRklOICovCisJKDE8PDMpLAkJCS8qIFBNQzM6IFBNX01SS19TVF9DTVBMX0lOVCAqLworCSgxPDw0KSB8ICgxPDw1KSwJLyogUE1DNDogUE1fTVJLX0dSUF9DTVBMLCBQTV9NUktfQ1JVX0ZJTiAqLworCSgxPDw0KSB8ICgxPDw1KSwJLyogUE1DNTogUE1fTVJLX0dSUF9USU1FTyAqLworCSgxPDwzKSB8ICgxPDw0KSB8ICgxPDw1KSwKKwkJLyogUE1DNjogUE1fTVJLX1NUX0dQUywgUE1fTVJLX0ZYVV9GSU4sIFBNX01SS19HUlBfSVNTVUVEICovCisJKDE8PDQpIHwgKDE8PDUpLAkvKiBQTUM3OiBQTV9NUktfRlBVX0ZJTiwgUE1fTVJLX0lOU1RfRklOICovCisJKDE8PDQpLAkJCS8qIFBNQzg6IFBNX01SS19MU1VfRklOICovCit9OworCisvKgorICogUmV0dXJucyAxIGlmIGV2ZW50IGNvdW50cyB0aGluZ3MgcmVsYXRpbmcgdG8gbWFya2VkIGluc3RydWN0aW9ucworICogYW5kIHRodXMgbmVlZHMgdGhlIE1NQ1JBX1NBTVBMRV9FTkFCTEUgYml0IHNldCwgb3IgMCBpZiBub3QuCisgKi8KK3N0YXRpYyBpbnQgcDRfbWFya2VkX2luc3RyX2V2ZW50KHU2NCBldmVudCkKK3sKKwlpbnQgcG1jLCBwc2VsLCB1bml0LCBieXRlLCBiaXQ7CisJdW5zaWduZWQgaW50IG1hc2s7CisKKwlwbWMgPSAoZXZlbnQgPj4gUE1fUE1DX1NIKSAmIFBNX1BNQ19NU0s7CisJcHNlbCA9IGV2ZW50ICYgUE1fUE1DU0VMX01TSzsKKwlpZiAocG1jKSB7CisJCWlmIChkaXJlY3RfbWFya2VkX2V2ZW50W3BtYyAtIDFdICYgKDEgPDwgcHNlbCkpCisJCQlyZXR1cm4gMTsKKwkJaWYgKHBzZWwgPT0gMCkJCS8qIGFkZCBldmVudHMgKi8KKwkJCWJpdCA9IChwbWMgPD0gNCk/IHBtYyAtIDE6IDggLSBwbWM7CisJCWVsc2UgaWYgKHBzZWwgPT0gNikJLyogZGVjb2RlIGV2ZW50cyAqLworCQkJYml0ID0gNDsKKwkJZWxzZQorCQkJcmV0dXJuIDA7CisJfSBlbHNlCisJCWJpdCA9IHBzZWw7CisKKwlieXRlID0gKGV2ZW50ID4+IFBNX0JZVEVfU0gpICYgUE1fQllURV9NU0s7CisJdW5pdCA9IChldmVudCA+PiBQTV9VTklUX1NIKSAmIFBNX1VOSVRfTVNLOworCW1hc2sgPSAwOworCXN3aXRjaCAodW5pdCkgeworCWNhc2UgUE1fTFNVMToKKwkJaWYgKGV2ZW50ICYgUE1fTE9XRVJfTVNLUykKKwkJCW1hc2sgPSAxIDw8IDI4OwkJLyogYnl0ZSA3IGJpdCA0ICovCisJCWVsc2UKKwkJCW1hc2sgPSA2IDw8IDI0OwkJLyogYnl0ZSAzIGJpdHMgMSBhbmQgMiAqLworCQlicmVhazsKKwljYXNlIFBNX0xTVTA6CisJCS8qIGJ5dGUgMywgYml0IDM7IGJ5dGUgMiBiaXRzIDAsMiwzLDQsNTsgYnl0ZSAxICovCisJCW1hc2sgPSAweDA4M2RmZjAwOworCX0KKwlyZXR1cm4gKG1hc2sgPj4gKGJ5dGUgKiA4ICsgYml0KSkgJiAxOworfQorCitzdGF0aWMgaW50IHA0X2dldF9jb25zdHJhaW50KHU2NCBldmVudCwgdTY0ICptYXNrcCwgdTY0ICp2YWxwKQoreworCWludCBwbWMsIGJ5dGUsIHVuaXQsIGxvd2VyLCBzaDsKKwl1NjQgbWFzayA9IDAsIHZhbHVlID0gMDsKKwlpbnQgZ3JwID0gLTE7CisKKwlwbWMgPSAoZXZlbnQgPj4gUE1fUE1DX1NIKSAmIFBNX1BNQ19NU0s7CisJaWYgKHBtYykgeworCQlpZiAocG1jID4gOCkKKwkJCXJldHVybiAtMTsKKwkJc2ggPSAocG1jIC0gMSkgKiAyOworCQltYXNrIHw9IDIgPDwgc2g7CisJCXZhbHVlIHw9IDEgPDwgc2g7CisJCWdycCA9ICgocG1jIC0gMSkgPj4gMSkgJiAxOworCX0KKwl1bml0ID0gKGV2ZW50ID4+IFBNX1VOSVRfU0gpICYgUE1fVU5JVF9NU0s7CisJYnl0ZSA9IChldmVudCA+PiBQTV9CWVRFX1NIKSAmIFBNX0JZVEVfTVNLOworCWlmICh1bml0KSB7CisJCWxvd2VyID0gKGV2ZW50ID4+IFBNX0xPV0VSX1NIKSAmIFBNX0xPV0VSX01TSzsKKworCQkvKgorCQkgKiBCdXMgZXZlbnRzIG9uIGJ5dGVzIDAgYW5kIDIgY2FuIGJlIGNvdW50ZWQKKwkJICogb24gUE1DMS8yLzUvNjsgYnl0ZXMgMSBhbmQgMyBvbiBQTUMzLzQvNy84LgorCQkgKi8KKwkJaWYgKCFwbWMpCisJCQlncnAgPSBieXRlICYgMTsKKworCQlpZiAoIXA0X3VuaXRpbmZvW3VuaXRdLnVuaXQpCisJCQlyZXR1cm4gLTE7CisJCW1hc2sgIHw9IHA0X3VuaXRpbmZvW3VuaXRdLm1hc2s7CisJCXZhbHVlIHw9IHA0X3VuaXRpbmZvW3VuaXRdLnZhbHVlOworCQlzaCA9IHA0X3VuaXRpbmZvW3VuaXRdLmxvd2VyYml0OworCQlpZiAoc2ggPiAxKQorCQkJdmFsdWUgfD0gKHU2NClsb3dlciA8PCBzaDsKKwkJZWxzZSBpZiAobG93ZXIgIT0gc2gpCisJCQlyZXR1cm4gLTE7CisJCXVuaXQgPSBwNF91bml0aW5mb1t1bml0XS51bml0OworCisJCS8qIFNldCBieXRlIGxhbmUgc2VsZWN0IGZpZWxkICovCisJCW1hc2sgIHw9IDB4ZlVMTCA8PCAoMjggLSA0ICogYnl0ZSk7CisJCXZhbHVlIHw9ICh1NjQpdW5pdCA8PCAoMjggLSA0ICogYnl0ZSk7CisJfQorCWlmIChncnAgPT0gMCkgeworCQkvKiBpbmNyZW1lbnQgUE1DMS8yLzUvNiBmaWVsZCAqLworCQltYXNrICB8PSAweDgwMDAwMDAwMDB1bGw7CisJCXZhbHVlIHw9IDB4MTAwMDAwMDAwMHVsbDsKKwl9IGVsc2UgeworCQkvKiBpbmNyZW1lbnQgUE1DMy80LzcvOCBmaWVsZCAqLworCQltYXNrICB8PSAweDgwMDAwMDAwMHVsbDsKKwkJdmFsdWUgfD0gMHgxMDAwMDAwMDB1bGw7CisJfQorCisJLyogTWFya2VkIGluc3RydWN0aW9uIGV2ZW50cyBuZWVkIHNhbXBsZV9lbmFibGUgc2V0ICovCisJaWYgKHA0X21hcmtlZF9pbnN0cl9ldmVudChldmVudCkpIHsKKwkJbWFzayAgfD0gMXVsbCA8PCA1NjsKKwkJdmFsdWUgfD0gMXVsbCA8PCA1NjsKKwl9CisKKwkvKiBQTUNTRUw9NiBkZWNvZGUgZXZlbnRzIG9uIGJ5dGUgMiBuZWVkIHNhbXBsZV9lbmFibGUgY2xlYXIgKi8KKwlpZiAocG1jICYmIChldmVudCAmIFBNX1BNQ1NFTF9NU0spID09IDYgJiYgYnl0ZSA9PSAyKQorCQltYXNrICB8PSAxdWxsIDw8IDU2OworCisJKm1hc2twID0gbWFzazsKKwkqdmFscCA9IHZhbHVlOworCXJldHVybiAwOworfQorCitzdGF0aWMgdW5zaWduZWQgaW50IHBwY19pbnN0X2NtcGxbXSA9IHsKKwkweDEwMDEsIDB4NDAwMSwgMHg2MDAxLCAweDcwMDEsIDB4ODAwMQorfTsKKworc3RhdGljIGludCBwNF9nZXRfYWx0ZXJuYXRpdmVzKHU2NCBldmVudCwgdW5zaWduZWQgaW50IGZsYWdzLCB1NjQgYWx0W10pCit7CisJaW50IGksIGosIG5hOworCisJYWx0WzBdID0gZXZlbnQ7CisJbmEgPSAxOworCisJLyogMiBwb3NzaWJpbGl0aWVzIGZvciBQTV9HUlBfRElTUF9SRUpFQ1QgKi8KKwlpZiAoZXZlbnQgPT0gMHg4MDAzIHx8IGV2ZW50ID09IDB4MDIyNCkgeworCQlhbHRbMV0gPSBldmVudCBeICgweDgwMDMgXiAweDAyMjQpOworCQlyZXR1cm4gMjsKKwl9CisKKwkvKiAyIHBvc3NpYmlsaXRpZXMgZm9yIFBNX1NUX01JU1NfTDEgKi8KKwlpZiAoZXZlbnQgPT0gMHgwYzEzIHx8IGV2ZW50ID09IDB4MGMyMykgeworCQlhbHRbMV0gPSBldmVudCBeICgweDBjMTMgXiAweDBjMjMpOworCQlyZXR1cm4gMjsKKwl9CisKKwkvKiBzZXZlcmFsIHBvc3NpYmlsaXRpZXMgZm9yIFBNX0lOU1RfQ01QTCAqLworCWZvciAoaSA9IDA7IGkgPCBBUlJBWV9TSVpFKHBwY19pbnN0X2NtcGwpOyArK2kpIHsKKwkJaWYgKGV2ZW50ID09IHBwY19pbnN0X2NtcGxbaV0pIHsKKwkJCWZvciAoaiA9IDA7IGogPCBBUlJBWV9TSVpFKHBwY19pbnN0X2NtcGwpOyArK2opCisJCQkJaWYgKGogIT0gaSkKKwkJCQkJYWx0W25hKytdID0gcHBjX2luc3RfY21wbFtqXTsKKwkJCWJyZWFrOworCQl9CisJfQorCisJcmV0dXJuIG5hOworfQorCitzdGF0aWMgaW50IHA0X2NvbXB1dGVfbW1jcih1NjQgZXZlbnRbXSwgaW50IG5fZXYsCisJCQkgICB1bnNpZ25lZCBpbnQgaHdjW10sIHU2NCBtbWNyW10pCit7CisJdTY0IG1tY3IwID0gMCwgbW1jcjEgPSAwLCBtbWNyYSA9IDA7CisJdW5zaWduZWQgaW50IHBtYywgdW5pdCwgYnl0ZSwgcHNlbCwgbG93ZXI7CisJdW5zaWduZWQgaW50IHR0bSwgZ3JwOworCXVuc2lnbmVkIGludCBwbWNfaW51c2UgPSAwOworCXVuc2lnbmVkIGludCBwbWNfZ3JwX3VzZVsyXTsKKwl1bnNpZ25lZCBjaGFyIGJ1c2J5dGVbNF07CisJdW5zaWduZWQgY2hhciB1bml0dXNlWzE2XTsKKwl1bnNpZ25lZCBpbnQgdW5pdGxvd2VyID0gMDsKKwlpbnQgaTsKKworCWlmIChuX2V2ID4gOCkKKwkJcmV0dXJuIC0xOworCisJLyogRmlyc3QgcGFzcyB0byBjb3VudCByZXNvdXJjZSB1c2UgKi8KKwlwbWNfZ3JwX3VzZVswXSA9IHBtY19ncnBfdXNlWzFdID0gMDsKKwltZW1zZXQoYnVzYnl0ZSwgMCwgc2l6ZW9mKGJ1c2J5dGUpKTsKKwltZW1zZXQodW5pdHVzZSwgMCwgc2l6ZW9mKHVuaXR1c2UpKTsKKwlmb3IgKGkgPSAwOyBpIDwgbl9ldjsgKytpKSB7CisJCXBtYyA9IChldmVudFtpXSA+PiBQTV9QTUNfU0gpICYgUE1fUE1DX01TSzsKKwkJaWYgKHBtYykgeworCQkJaWYgKHBtY19pbnVzZSAmICgxIDw8IChwbWMgLSAxKSkpCisJCQkJcmV0dXJuIC0xOworCQkJcG1jX2ludXNlIHw9IDEgPDwgKHBtYyAtIDEpOworCQkJLyogY291bnQgMS8yLzUvNiB2cyAzLzQvNy84IHVzZSAqLworCQkJKytwbWNfZ3JwX3VzZVsoKHBtYyAtIDEpID4+IDEpICYgMV07CisJCX0KKwkJdW5pdCA9IChldmVudFtpXSA+PiBQTV9VTklUX1NIKSAmIFBNX1VOSVRfTVNLOworCQlieXRlID0gKGV2ZW50W2ldID4+IFBNX0JZVEVfU0gpICYgUE1fQllURV9NU0s7CisJCWxvd2VyID0gKGV2ZW50W2ldID4+IFBNX0xPV0VSX1NIKSAmIFBNX0xPV0VSX01TSzsKKwkJaWYgKHVuaXQpIHsKKwkJCWlmICghcG1jKQorCQkJCSsrcG1jX2dycF91c2VbYnl0ZSAmIDFdOworCQkJaWYgKHVuaXQgPT0gNiB8fCB1bml0ID09IDgpCisJCQkJLyogbWFwIGFsdCBJU1UxL0lGVSBjb2RlczogNi0+MiwgOC0+MyAqLworCQkJCXVuaXQgPSAodW5pdCA+PiAxKSAtIDE7CisJCQlpZiAoYnVzYnl0ZVtieXRlXSAmJiBidXNieXRlW2J5dGVdICE9IHVuaXQpCisJCQkJcmV0dXJuIC0xOworCQkJYnVzYnl0ZVtieXRlXSA9IHVuaXQ7CisJCQlsb3dlciA8PD0gdW5pdDsKKwkJCWlmICh1bml0dXNlW3VuaXRdICYmIGxvd2VyICE9ICh1bml0bG93ZXIgJiBsb3dlcikpCisJCQkJcmV0dXJuIC0xOworCQkJdW5pdHVzZVt1bml0XSA9IDE7CisJCQl1bml0bG93ZXIgfD0gbG93ZXI7CisJCX0KKwl9CisJaWYgKHBtY19ncnBfdXNlWzBdID4gNCB8fCBwbWNfZ3JwX3VzZVsxXSA+IDQpCisJCXJldHVybiAtMTsKKworCS8qCisJICogQXNzaWduIHJlc291cmNlcyBhbmQgc2V0IG11bHRpcGxleGVyIHNlbGVjdHMuCisJICoKKwkgKiBVbml0cyAxLDIsMyBhcmUgb24gVFRNMCwgNCw2LDcgb24gVFRNMSwgOCwxMCBvbiBUVE0yLgorCSAqIEVhY2ggVFRNeCBjYW4gb25seSBzZWxlY3Qgb25lIHVuaXQsIGJ1dCBzaW5jZQorCSAqIHVuaXRzIDIgYW5kIDYgYXJlIGJvdGggSVNVMSwgYW5kIDMgYW5kIDggYXJlIGJvdGggSUZVLAorCSAqIHdlIGhhdmUgc29tZSBjaG9pY2VzLgorCSAqLworCWlmICh1bml0dXNlWzJdICYgKHVuaXR1c2VbMV0gfCAodW5pdHVzZVszXSAmIHVuaXR1c2VbOV0pKSkgeworCQl1bml0dXNlWzZdID0gMTsJCS8qIE1vdmUgMiB0byA2ICovCisJCXVuaXR1c2VbMl0gPSAwOworCX0KKwlpZiAodW5pdHVzZVszXSAmICh1bml0dXNlWzFdIHwgdW5pdHVzZVsyXSkpIHsKKwkJdW5pdHVzZVs4XSA9IDE7CQkvKiBNb3ZlIDMgdG8gOCAqLworCQl1bml0dXNlWzNdID0gMDsKKwkJdW5pdGxvd2VyID0gKHVuaXRsb3dlciAmIH44KSB8ICgodW5pdGxvd2VyICYgOCkgPDwgNSk7CisJfQorCS8qIENoZWNrIG9ubHkgb25lIHVuaXQgcGVyIFRUTXggKi8KKwlpZiAodW5pdHVzZVsxXSArIHVuaXR1c2VbMl0gKyB1bml0dXNlWzNdID4gMSB8fAorCSAgICB1bml0dXNlWzRdICsgdW5pdHVzZVs2XSArIHVuaXR1c2VbN10gPiAxIHx8CisJICAgIHVuaXR1c2VbOF0gKyB1bml0dXNlWzldID4gMSB8fAorCSAgICAodW5pdHVzZVs1XSB8IHVuaXR1c2VbMTBdIHwgdW5pdHVzZVsxMV0gfAorCSAgICAgdW5pdHVzZVsxM10gfCB1bml0dXNlWzE0XSkpCisJCXJldHVybiAtMTsKKworCS8qIFNldCBUVE14U0VMIGZpZWxkcy4gIE5vdGUsIHVuaXRzIDEtMyA9PiBUVE0wU0VMIGNvZGVzIDAtMiAqLworCW1tY3IxIHw9ICh1NjQpKHVuaXR1c2VbM10gKiAyICsgdW5pdHVzZVsyXSkgPDwgTU1DUjFfVFRNMFNFTF9TSDsKKwltbWNyMSB8PSAodTY0KSh1bml0dXNlWzddICogMyArIHVuaXR1c2VbNl0gKiAyKSA8PCBNTUNSMV9UVE0xU0VMX1NIOworCW1tY3IxIHw9ICh1NjQpdW5pdHVzZVs5XSA8PCBNTUNSMV9UVE0yU0VMX1NIOworCisJLyogU2V0IFRUQ3hTRUwgZmllbGRzLiAqLworCWlmICh1bml0bG93ZXIgJiAweGUpCisJCW1tY3IxIHw9IDF1bGwgPDwgTU1DUjFfVFRDMFNFTF9TSDsKKwlpZiAodW5pdGxvd2VyICYgMHhmMCkKKwkJbW1jcjEgfD0gMXVsbCA8PCBNTUNSMV9UVEMxU0VMX1NIOworCWlmICh1bml0bG93ZXIgJiAweGYwMCkKKwkJbW1jcjEgfD0gMXVsbCA8PCBNTUNSMV9UVEMyU0VMX1NIOworCWlmICh1bml0bG93ZXIgJiAweDcwMDApCisJCW1tY3IxIHw9IDF1bGwgPDwgTU1DUjFfVFRDM1NFTF9TSDsKKworCS8qIFNldCBieXRlIGxhbmUgc2VsZWN0IGZpZWxkcy4gKi8KKwlmb3IgKGJ5dGUgPSAwOyBieXRlIDwgNDsgKytieXRlKSB7CisJCXVuaXQgPSBidXNieXRlW2J5dGVdOworCQlpZiAoIXVuaXQpCisJCQljb250aW51ZTsKKwkJaWYgKHVuaXQgPT0gMHhmKSB7CisJCQkvKiBzcGVjaWFsIGNhc2UgZm9yIEdQUyAqLworCQkJbW1jcjEgfD0gMXVsbCA8PCAoTU1DUjFfREVCVUcwU0VMX1NIIC0gYnl0ZSk7CisJCX0gZWxzZSB7CisJCQlpZiAoIXVuaXR1c2VbdW5pdF0pCisJCQkJdHRtID0gdW5pdCAtIDE7CQkvKiAyLT4xLCAzLT4yICovCisJCQllbHNlCisJCQkJdHRtID0gdW5pdCA+PiAyOworCQkJbW1jcjEgfD0gKHU2NCl0dG0gPDwgKE1NQ1IxX1REX0NQX0RCRzBTRUxfU0ggLSAyKmJ5dGUpOworCQl9CisJfQorCisJLyogU2Vjb25kIHBhc3M6IGFzc2lnbiBQTUNzLCBzZXQgUE1DeFNFTCBhbmQgUE1DeF9BRERFUl9TRUwgZmllbGRzICovCisJZm9yIChpID0gMDsgaSA8IG5fZXY7ICsraSkgeworCQlwbWMgPSAoZXZlbnRbaV0gPj4gUE1fUE1DX1NIKSAmIFBNX1BNQ19NU0s7CisJCXVuaXQgPSAoZXZlbnRbaV0gPj4gUE1fVU5JVF9TSCkgJiBQTV9VTklUX01TSzsKKwkJYnl0ZSA9IChldmVudFtpXSA+PiBQTV9CWVRFX1NIKSAmIFBNX0JZVEVfTVNLOworCQlwc2VsID0gZXZlbnRbaV0gJiBQTV9QTUNTRUxfTVNLOworCQlpZiAoIXBtYykgeworCQkJLyogQnVzIGV2ZW50IG9yIDAweHh4IGRpcmVjdCBldmVudCAob2ZmIG9yIGN5Y2xlcykgKi8KKwkJCWlmICh1bml0KQorCQkJCXBzZWwgfD0gMHgxMCB8ICgoYnl0ZSAmIDIpIDw8IDIpOworCQkJZm9yIChwbWMgPSAwOyBwbWMgPCA4OyArK3BtYykgeworCQkJCWlmIChwbWNfaW51c2UgJiAoMSA8PCBwbWMpKQorCQkJCQljb250aW51ZTsKKwkJCQlncnAgPSAocG1jID4+IDEpICYgMTsKKwkJCQlpZiAodW5pdCkgeworCQkJCQlpZiAoZ3JwID09IChieXRlICYgMSkpCisJCQkJCQlicmVhazsKKwkJCQl9IGVsc2UgaWYgKHBtY19ncnBfdXNlW2dycF0gPCA0KSB7CisJCQkJCSsrcG1jX2dycF91c2VbZ3JwXTsKKwkJCQkJYnJlYWs7CisJCQkJfQorCQkJfQorCQkJcG1jX2ludXNlIHw9IDEgPDwgcG1jOworCQl9IGVsc2UgeworCQkJLyogRGlyZWN0IGV2ZW50ICovCisJCQktLXBtYzsKKwkJCWlmIChwc2VsID09IDAgJiYgKGJ5dGUgJiAyKSkKKwkJCQkvKiBhZGQgZXZlbnRzIG9uIGhpZ2hlci1udW1iZXJlZCBidXMgKi8KKwkJCQltbWNyMSB8PSAxdWxsIDw8IG1tY3IxX2FkZGVyX2JpdHNbcG1jXTsKKwkJCWVsc2UgaWYgKHBzZWwgPT0gNiAmJiBieXRlID09IDMpCisJCQkJLyogc2VlbSB0byBuZWVkIHRvIHNldCBzYW1wbGVfZW5hYmxlIGhlcmUgKi8KKwkJCQltbWNyYSB8PSBNTUNSQV9TQU1QTEVfRU5BQkxFOworCQkJcHNlbCB8PSA4OworCQl9CisJCWlmIChwbWMgPD0gMSkKKwkJCW1tY3IwIHw9IHBzZWwgPDwgKE1NQ1IwX1BNQzFTRUxfU0ggLSA3ICogcG1jKTsKKwkJZWxzZQorCQkJbW1jcjEgfD0gcHNlbCA8PCAoTU1DUjFfUE1DM1NFTF9TSCAtIDUgKiAocG1jIC0gMikpOworCQlpZiAocG1jID09IDcpCS8qIFBNQzggKi8KKwkJCW1tY3JhIHw9IChwc2VsICYgMSkgPDwgTU1DUkFfUE1DOFNFTDBfU0g7CisJCWh3Y1tpXSA9IHBtYzsKKwkJaWYgKHA0X21hcmtlZF9pbnN0cl9ldmVudChldmVudFtpXSkpCisJCQltbWNyYSB8PSBNTUNSQV9TQU1QTEVfRU5BQkxFOworCX0KKworCWlmIChwbWNfaW51c2UgJiAxKQorCQltbWNyMCB8PSBNTUNSMF9QTUMxQ0U7CisJaWYgKHBtY19pbnVzZSAmIDB4ZmUpCisJCW1tY3IwIHw9IE1NQ1IwX1BNQ2pDRTsKKworCW1tY3JhIHw9IDB4MjAwMDsJLyogbWFyayBvbmx5IG9uZSBJT1AgcGVyIFBQQyBpbnN0cnVjdGlvbiAqLworCisJLyogUmV0dXJuIE1NQ1J4IHZhbHVlcyAqLworCW1tY3JbMF0gPSBtbWNyMDsKKwltbWNyWzFdID0gbW1jcjE7CisJbW1jclsyXSA9IG1tY3JhOworCXJldHVybiAwOworfQorCitzdGF0aWMgdm9pZCBwNF9kaXNhYmxlX3BtYyh1bnNpZ25lZCBpbnQgcG1jLCB1NjQgbW1jcltdKQoreworCS8qCisJICogU2V0dGluZyB0aGUgUE1DeFNFTCBmaWVsZCB0byAwIGRpc2FibGVzIFBNQyB4LgorCSAqIChOb3RlIHRoYXQgcG1jIGlzIDAtYmFzZWQgaGVyZSwgbm90IDEtYmFzZWQuKQorCSAqLworCWlmIChwbWMgPD0gMSkgeworCQltbWNyWzBdICY9IH4oMHgxZlVMIDw8IChNTUNSMF9QTUMxU0VMX1NIIC0gNyAqIHBtYykpOworCX0gZWxzZSB7CisJCW1tY3JbMV0gJj0gfigweDFmVUwgPDwgKE1NQ1IxX1BNQzNTRUxfU0ggLSA1ICogKHBtYyAtIDIpKSk7CisJCWlmIChwbWMgPT0gNykKKwkJCW1tY3JbMl0gJj0gfigxVUwgPDwgTU1DUkFfUE1DOFNFTDBfU0gpOworCX0KK30KKworc3RhdGljIGludCBwNF9nZW5lcmljX2V2ZW50c1tdID0geworCVtQRVJGX0NPVU5UX0hXX0NQVV9DWUNMRVNdCQk9IDcsCisJW1BFUkZfQ09VTlRfSFdfSU5TVFJVQ1RJT05TXQkJPSAweDEwMDEsCisJW1BFUkZfQ09VTlRfSFdfQ0FDSEVfUkVGRVJFTkNFU10JPSAweDhjMTAsIC8qIFBNX0xEX1JFRl9MMSAqLworCVtQRVJGX0NPVU5UX0hXX0NBQ0hFX01JU1NFU10JCT0gMHgzYzEwLCAvKiBQTV9MRF9NSVNTX0wxICovCisJW1BFUkZfQ09VTlRfSFdfQlJBTkNIX0lOU1RSVUNUSU9OU10JPSAweDMzMCwgIC8qIFBNX0JSX0lTU1VFRCAqLworCVtQRVJGX0NPVU5UX0hXX0JSQU5DSF9NSVNTRVNdCQk9IDB4MzMxLCAgLyogUE1fQlJfTVBSRURfQ1IgKi8KK307CisKKyNkZWZpbmUgQyh4KQlQRVJGX0NPVU5UX0hXX0NBQ0hFXyMjeAorCisvKgorICogVGFibGUgb2YgZ2VuZXJhbGl6ZWQgY2FjaGUtcmVsYXRlZCBldmVudHMuCisgKiAwIG1lYW5zIG5vdCBzdXBwb3J0ZWQsIC0xIG1lYW5zIG5vbnNlbnNpY2FsLCBvdGhlciB2YWx1ZXMKKyAqIGFyZSBldmVudCBjb2Rlcy4KKyAqLworc3RhdGljIGludCBwb3dlcjRfY2FjaGVfZXZlbnRzW0MoTUFYKV1bQyhPUF9NQVgpXVtDKFJFU1VMVF9NQVgpXSA9IHsKKwlbQyhMMUQpXSA9IHsJCS8qIAlSRVNVTFRfQUNDRVNTCVJFU1VMVF9NSVNTICovCisJCVtDKE9QX1JFQUQpXSA9IHsJMHg4YzEwLAkJMHgzYzEwCX0sCisJCVtDKE9QX1dSSVRFKV0gPSB7CTB4N2MxMCwJCTB4YzEzCX0sCisJCVtDKE9QX1BSRUZFVENIKV0gPSB7CTB4YzM1LAkJMAl9LAorCX0sCisJW0MoTDFJKV0gPSB7CQkvKiAJUkVTVUxUX0FDQ0VTUwlSRVNVTFRfTUlTUyAqLworCQlbQyhPUF9SRUFEKV0gPSB7CTAsCQkwCX0sCisJCVtDKE9QX1dSSVRFKV0gPSB7CS0xLAkJLTEJfSwKKwkJW0MoT1BfUFJFRkVUQ0gpXSA9IHsJMCwJCTAJfSwKKwl9LAorCVtDKExMKV0gPSB7CQkvKiAJUkVTVUxUX0FDQ0VTUwlSRVNVTFRfTUlTUyAqLworCQlbQyhPUF9SRUFEKV0gPSB7CTAsCQkwCX0sCisJCVtDKE9QX1dSSVRFKV0gPSB7CTAsCQkwCX0sCisJCVtDKE9QX1BSRUZFVENIKV0gPSB7CTB4YzM0LAkJMAl9LAorCX0sCisJW0MoRFRMQildID0gewkJLyogCVJFU1VMVF9BQ0NFU1MJUkVTVUxUX01JU1MgKi8KKwkJW0MoT1BfUkVBRCldID0gewkwLAkJMHg5MDQJfSwKKwkJW0MoT1BfV1JJVEUpXSA9IHsJLTEsCQktMQl9LAorCQlbQyhPUF9QUkVGRVRDSCldID0gewktMSwJCS0xCX0sCisJfSwKKwlbQyhJVExCKV0gPSB7CQkvKiAJUkVTVUxUX0FDQ0VTUwlSRVNVTFRfTUlTUyAqLworCQlbQyhPUF9SRUFEKV0gPSB7CTAsCQkweDkwMAl9LAorCQlbQyhPUF9XUklURSldID0gewktMSwJCS0xCX0sCisJCVtDKE9QX1BSRUZFVENIKV0gPSB7CS0xLAkJLTEJfSwKKwl9LAorCVtDKEJQVSldID0gewkJLyogCVJFU1VMVF9BQ0NFU1MJUkVTVUxUX01JU1MgKi8KKwkJW0MoT1BfUkVBRCldID0gewkweDMzMCwJCTB4MzMxCX0sCisJCVtDKE9QX1dSSVRFKV0gPSB7CS0xLAkJLTEJfSwKKwkJW0MoT1BfUFJFRkVUQ0gpXSA9IHsJLTEsCQktMQl9LAorCX0sCit9OworCitzdHJ1Y3QgcG93ZXJfcG11IHBvd2VyNF9wbXUgPSB7CisJLm5fY291bnRlciA9IDgsCisJLm1heF9hbHRlcm5hdGl2ZXMgPSA1LAorCS5hZGRfZmllbGRzID0gMHgwMDAwMDAxMTAwMDA1NTU1dWxsLAorCS50ZXN0X2FkZGVyID0gMHgwMDExMDgzMzAwMDAwMDAwdWxsLAorCS5jb21wdXRlX21tY3IgPSBwNF9jb21wdXRlX21tY3IsCisJLmdldF9jb25zdHJhaW50ID0gcDRfZ2V0X2NvbnN0cmFpbnQsCisJLmdldF9hbHRlcm5hdGl2ZXMgPSBwNF9nZXRfYWx0ZXJuYXRpdmVzLAorCS5kaXNhYmxlX3BtYyA9IHA0X2Rpc2FibGVfcG1jLAorCS5uX2dlbmVyaWMgPSBBUlJBWV9TSVpFKHA0X2dlbmVyaWNfZXZlbnRzKSwKKwkuZ2VuZXJpY19ldmVudHMgPSBwNF9nZW5lcmljX2V2ZW50cywKKwkuY2FjaGVfZXZlbnRzID0gJnBvd2VyNF9jYWNoZV9ldmVudHMsCit9OwpkaWZmIC0tZ2l0IGEvYXJjaC9wb3dlcnBjL2tlcm5lbC9wb3dlcjUrLXBtdS5jIGIvYXJjaC9wb3dlcnBjL2tlcm5lbC9wb3dlcjUrLXBtdS5jCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjQxZTVkMmQKLS0tIC9kZXYvbnVsbAorKysgYi9hcmNoL3Bvd2VycGMva2VybmVsL3Bvd2VyNSstcG11LmMKQEAgLTAsMCArMSw2NzEgQEAKKy8qCisgKiBQZXJmb3JtYW5jZSBjb3VudGVyIHN1cHBvcnQgZm9yIFBPV0VSNSsvKysgKG5vdCBQT1dFUjUpIHByb2Nlc3NvcnMuCisgKgorICogQ29weXJpZ2h0IDIwMDkgUGF1bCBNYWNrZXJyYXMsIElCTSBDb3Jwb3JhdGlvbi4KKyAqCisgKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yCisgKiBtb2RpZnkgaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZQorICogYXMgcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb247IGVpdGhlciB2ZXJzaW9uCisgKiAyIG9mIHRoZSBMaWNlbnNlLCBvciAoYXQgeW91ciBvcHRpb24pIGFueSBsYXRlciB2ZXJzaW9uLgorICovCisjaW5jbHVkZSA8bGludXgva2VybmVsLmg+CisjaW5jbHVkZSA8bGludXgvcGVyZl9jb3VudGVyLmg+CisjaW5jbHVkZSA8YXNtL3JlZy5oPgorCisvKgorICogQml0cyBpbiBldmVudCBjb2RlIGZvciBQT1dFUjUrIChQT1dFUjUgR1MpIGFuZCBQT1dFUjUrKyAoUE9XRVI1IEdTIEREMykKKyAqLworI2RlZmluZSBQTV9QTUNfU0gJMjAJLyogUE1DIG51bWJlciAoMS1iYXNlZCkgZm9yIGRpcmVjdCBldmVudHMgKi8KKyNkZWZpbmUgUE1fUE1DX01TSwkweGYKKyNkZWZpbmUgUE1fUE1DX01TS1MJKFBNX1BNQ19NU0sgPDwgUE1fUE1DX1NIKQorI2RlZmluZSBQTV9VTklUX1NICTE2CS8qIFRUTU1VWCBudW1iZXIgYW5kIHNldHRpbmcgLSB1bml0IHNlbGVjdCAqLworI2RlZmluZSBQTV9VTklUX01TSwkweGYKKyNkZWZpbmUgUE1fQllURV9TSAkxMgkvKiBCeXRlIG51bWJlciBvZiBldmVudCBidXMgdG8gdXNlICovCisjZGVmaW5lIFBNX0JZVEVfTVNLCTcKKyNkZWZpbmUgUE1fR1JTX1NICTgJLyogU3RvcmFnZSBzdWJzeXN0ZW0gbXV4IHNlbGVjdCAqLworI2RlZmluZSBQTV9HUlNfTVNLCTcKKyNkZWZpbmUgUE1fQlVTRVZFTlRfTVNLCTB4ODAJLyogU2V0IGlmIGV2ZW50IHVzZXMgZXZlbnQgYnVzICovCisjZGVmaW5lIFBNX1BNQ1NFTF9NU0sJMHg3ZgorCisvKiBWYWx1ZXMgaW4gUE1fVU5JVCBmaWVsZCAqLworI2RlZmluZSBQTV9GUFUJCTAKKyNkZWZpbmUgUE1fSVNVMAkJMQorI2RlZmluZSBQTV9JRlUJCTIKKyNkZWZpbmUgUE1fSVNVMQkJMworI2RlZmluZSBQTV9JRFUJCTQKKyNkZWZpbmUgUE1fSVNVMF9BTFQJNgorI2RlZmluZSBQTV9HUlMJCTcKKyNkZWZpbmUgUE1fTFNVMAkJOAorI2RlZmluZSBQTV9MU1UxCQkweGMKKyNkZWZpbmUgUE1fTEFTVFVOSVQJMHhjCisKKy8qCisgKiBCaXRzIGluIE1NQ1IxIGZvciBQT1dFUjUrCisgKi8KKyNkZWZpbmUgTU1DUjFfVFRNMFNFTF9TSAk2MgorI2RlZmluZSBNTUNSMV9UVE0xU0VMX1NICTYwCisjZGVmaW5lIE1NQ1IxX1RUTTJTRUxfU0gJNTgKKyNkZWZpbmUgTU1DUjFfVFRNM1NFTF9TSAk1NgorI2RlZmluZSBNTUNSMV9UVE1TRUxfTVNLCTMKKyNkZWZpbmUgTU1DUjFfVERfQ1BfREJHMFNFTF9TSAk1NAorI2RlZmluZSBNTUNSMV9URF9DUF9EQkcxU0VMX1NICTUyCisjZGVmaW5lIE1NQ1IxX1REX0NQX0RCRzJTRUxfU0gJNTAKKyNkZWZpbmUgTU1DUjFfVERfQ1BfREJHM1NFTF9TSAk0OAorI2RlZmluZSBNTUNSMV9HUlNfTDJTRUxfU0gJNDYKKyNkZWZpbmUgTU1DUjFfR1JTX0wyU0VMX01TSwkzCisjZGVmaW5lIE1NQ1IxX0dSU19MM1NFTF9TSAk0NAorI2RlZmluZSBNTUNSMV9HUlNfTDNTRUxfTVNLCTMKKyNkZWZpbmUgTU1DUjFfR1JTX01DU0VMX1NICTQxCisjZGVmaW5lIE1NQ1IxX0dSU19NQ1NFTF9NU0sJNworI2RlZmluZSBNTUNSMV9HUlNfRkFCU0VMX1NICTM5CisjZGVmaW5lIE1NQ1IxX0dSU19GQUJTRUxfTVNLCTMKKyNkZWZpbmUgTU1DUjFfUE1DMV9BRERFUl9TRUxfU0gJMzUKKyNkZWZpbmUgTU1DUjFfUE1DMl9BRERFUl9TRUxfU0gJMzQKKyNkZWZpbmUgTU1DUjFfUE1DM19BRERFUl9TRUxfU0gJMzMKKyNkZWZpbmUgTU1DUjFfUE1DNF9BRERFUl9TRUxfU0gJMzIKKyNkZWZpbmUgTU1DUjFfUE1DMVNFTF9TSAkyNQorI2RlZmluZSBNTUNSMV9QTUMyU0VMX1NICTE3CisjZGVmaW5lIE1NQ1IxX1BNQzNTRUxfU0gJOQorI2RlZmluZSBNTUNSMV9QTUM0U0VMX1NICTEKKyNkZWZpbmUgTU1DUjFfUE1DU0VMX1NIKG4pCShNTUNSMV9QTUMxU0VMX1NIIC0gKG4pICogOCkKKyNkZWZpbmUgTU1DUjFfUE1DU0VMX01TSwkweDdmCisKKy8qCisgKiBCaXRzIGluIE1NQ1JBCisgKi8KKworLyoKKyAqIExheW91dCBvZiBjb25zdHJhaW50IGJpdHM6CisgKiA2NjY2NTU1NTU1NTU1NTQ0NDQ0NDQ0NDQzMzMzMzMzMzMzMjIyMjIyMjIyMjExMTExMTExMTEwMDAwMDAwMDAwCisgKiAzMjEwOTg3NjU0MzIxMDk4NzY1NDMyMTA5ODc2NTQzMjEwOTg3NjU0MzIxMDk4NzY1NDMyMTA5ODc2NTQzMjEwCisgKiAgICAgICAgICAgICBbICA+PD48PjwgPjw+IDw+PD5bICA+ICA8ICA+PCAgPjwgID48ICA+PD48Pjw+PD48Pjw+CisgKiAgICAgICAgICAgICBOQyAgRzBHMUcyIEczIFQwVDEgVUMgICAgQjAgIEIxICBCMiAgQjMgUDZQNVA0UDNQMlAxCisgKgorICogTkMgLSBudW1iZXIgb2YgY291bnRlcnMKKyAqICAgICA1MTogTkMgZXJyb3IgMHgwMDA4XzAwMDBfMDAwMF8wMDAwCisgKiAgICAgNDgtNTA6IG51bWJlciBvZiBldmVudHMgbmVlZGluZyBQTUMxLTQgMHgwMDA3XzAwMDBfMDAwMF8wMDAwCisgKgorICogRzAuLkczIC0gR1JTIG11eCBjb25zdHJhaW50cworICogICAgIDQ2LTQ3OiBHUlNfTDJTRUwgdmFsdWUKKyAqICAgICA0NC00NTogR1JTX0wzU0VMIHZhbHVlCisgKiAgICAgNDEtNDQ6IEdSU19NQ1NFTCB2YWx1ZQorICogICAgIDM5LTQwOiBHUlNfRkFCU0VMIHZhbHVlCisgKglOb3RlIHRoYXQgdGhlc2UgbWF0Y2ggdXAgd2l0aCB0aGVpciBiaXQgcG9zaXRpb25zIGluIE1NQ1IxCisgKgorICogVDAgLSBUVE0wIGNvbnN0cmFpbnQKKyAqICAgICAzNi0zNzogVFRNMFNFTCB2YWx1ZSAoMD1GUFUsIDI9SUZVLCAzPUlTVTEpIDB4MzBfMDAwMF8wMDAwCisgKgorICogVDEgLSBUVE0xIGNvbnN0cmFpbnQKKyAqICAgICAzNC0zNTogVFRNMVNFTCB2YWx1ZSAoMD1JRFUsIDM9R1JTKSAweDBjXzAwMDBfMDAwMAorICoKKyAqIFVDIC0gdW5pdCBjb25zdHJhaW50OiBjYW4ndCBoYXZlIGFsbCB0aHJlZSBvZiBGUFV8SUZVfElTVTEsIElTVTAsIElEVXxHUlMKKyAqICAgICAzMzogVUMzIGVycm9yIDB4MDJfMDAwMF8wMDAwCisgKiAgICAgMzI6IEZQVXxJRlV8SVNVMSBldmVudHMgbmVlZGVkIDB4MDFfMDAwMF8wMDAwCisgKiAgICAgMzE6IElTVTAgZXZlbnRzIG5lZWRlZCAweDAxXzgwMDBfMDAwMAorICogICAgIDMwOiBJRFV8R1JTIGV2ZW50cyBuZWVkZWQgMHgwMF80MDAwXzAwMDAKKyAqCisgKiBCMAorICogICAgIDI0LTI3OiBCeXRlIDAgZXZlbnQgc291cmNlIDB4MGYwMF8wMDAwCisgKgkgICAgICBFbmNvZGluZyBhcyBmb3IgdGhlIGV2ZW50IGNvZGUKKyAqCisgKiBCMSwgQjIsIEIzCisgKiAgICAgMjAtMjMsIDE2LTE5LCAxMi0xNTogQnl0ZSAxLCAyLCAzIGV2ZW50IHNvdXJjZXMKKyAqCisgKiBQNgorICogICAgIDExOiBQNiBlcnJvciAweDgwMAorICogICAgIDEwLTExOiBDb3VudCBvZiBldmVudHMgbmVlZGluZyBQTUM2CisgKgorICogUDEuLlA1CisgKiAgICAgMC05OiBDb3VudCBvZiBldmVudHMgbmVlZGluZyBQTUMxLi5QTUM1CisgKi8KKworc3RhdGljIGNvbnN0IGludCBncnNlbF9zaGlmdFs4XSA9IHsKKwlNTUNSMV9HUlNfTDJTRUxfU0gsIE1NQ1IxX0dSU19MMlNFTF9TSCwgTU1DUjFfR1JTX0wyU0VMX1NILAorCU1NQ1IxX0dSU19MM1NFTF9TSCwgTU1DUjFfR1JTX0wzU0VMX1NILCBNTUNSMV9HUlNfTDNTRUxfU0gsCisJTU1DUjFfR1JTX01DU0VMX1NILCBNTUNSMV9HUlNfRkFCU0VMX1NICit9OworCisvKiBNYXNrcyBhbmQgdmFsdWVzIGZvciB1c2luZyBldmVudHMgZnJvbSB0aGUgdmFyaW91cyB1bml0cyAqLworc3RhdGljIHU2NCB1bml0X2NvbnNbUE1fTEFTVFVOSVQrMV1bMl0gPSB7CisJW1BNX0ZQVV0gPSAgIHsgMHgzMjAwMDAwMDAwdWxsLCAweDAxMDAwMDAwMDB1bGwgfSwKKwlbUE1fSVNVMF0gPSAgeyAweDAyMDAwMDAwMDB1bGwsIDB4MDA4MDAwMDAwMHVsbCB9LAorCVtQTV9JU1UxXSA9ICB7IDB4MzIwMDAwMDAwMHVsbCwgMHgzMTAwMDAwMDAwdWxsIH0sCisJW1BNX0lGVV0gPSAgIHsgMHgzMjAwMDAwMDAwdWxsLCAweDIxMDAwMDAwMDB1bGwgfSwKKwlbUE1fSURVXSA9ICAgeyAweDBlMDAwMDAwMDB1bGwsIDB4MDA0MDAwMDAwMHVsbCB9LAorCVtQTV9HUlNdID0gICB7IDB4MGUwMDAwMDAwMHVsbCwgMHgwYzQwMDAwMDAwdWxsIH0sCit9OworCitzdGF0aWMgaW50IHBvd2VyNXBfZ2V0X2NvbnN0cmFpbnQodTY0IGV2ZW50LCB1NjQgKm1hc2twLCB1NjQgKnZhbHApCit7CisJaW50IHBtYywgYnl0ZSwgdW5pdCwgc2g7CisJaW50IGJpdCwgZm1hc2s7CisJdTY0IG1hc2sgPSAwLCB2YWx1ZSA9IDA7CisKKwlwbWMgPSAoZXZlbnQgPj4gUE1fUE1DX1NIKSAmIFBNX1BNQ19NU0s7CisJaWYgKHBtYykgeworCQlpZiAocG1jID4gNikKKwkJCXJldHVybiAtMTsKKwkJc2ggPSAocG1jIC0gMSkgKiAyOworCQltYXNrIHw9IDIgPDwgc2g7CisJCXZhbHVlIHw9IDEgPDwgc2g7CisJCWlmIChwbWMgPj0gNSAmJiAhKGV2ZW50ID09IDB4NTAwMDA5IHx8IGV2ZW50ID09IDB4NjAwMDA1KSkKKwkJCXJldHVybiAtMTsKKwl9CisJaWYgKGV2ZW50ICYgUE1fQlVTRVZFTlRfTVNLKSB7CisJCXVuaXQgPSAoZXZlbnQgPj4gUE1fVU5JVF9TSCkgJiBQTV9VTklUX01TSzsKKwkJaWYgKHVuaXQgPiBQTV9MQVNUVU5JVCkKKwkJCXJldHVybiAtMTsKKwkJaWYgKHVuaXQgPT0gUE1fSVNVMF9BTFQpCisJCQl1bml0ID0gUE1fSVNVMDsKKwkJbWFzayB8PSB1bml0X2NvbnNbdW5pdF1bMF07CisJCXZhbHVlIHw9IHVuaXRfY29uc1t1bml0XVsxXTsKKwkJYnl0ZSA9IChldmVudCA+PiBQTV9CWVRFX1NIKSAmIFBNX0JZVEVfTVNLOworCQlpZiAoYnl0ZSA+PSA0KSB7CisJCQlpZiAodW5pdCAhPSBQTV9MU1UxKQorCQkJCXJldHVybiAtMTsKKwkJCS8qIE1hcCBMU1UxIGxvdyB3b3JkIChieXRlcyA0LTcpIHRvIHVuaXQgTFNVMSsxICovCisJCQkrK3VuaXQ7CisJCQlieXRlICY9IDM7CisJCX0KKwkJaWYgKHVuaXQgPT0gUE1fR1JTKSB7CisJCQliaXQgPSBldmVudCAmIDc7CisJCQlmbWFzayA9IChiaXQgPT0gNik/IDc6IDM7CisJCQlzaCA9IGdyc2VsX3NoaWZ0W2JpdF07CisJCQltYXNrIHw9ICh1NjQpZm1hc2sgPDwgc2g7CisJCQl2YWx1ZSB8PSAodTY0KSgoZXZlbnQgPj4gUE1fR1JTX1NIKSAmIGZtYXNrKSA8PCBzaDsKKwkJfQorCQkvKiBTZXQgYnl0ZSBsYW5lIHNlbGVjdCBmaWVsZCAqLworCQltYXNrICB8PSAweGZVTEwgPDwgKDI0IC0gNCAqIGJ5dGUpOworCQl2YWx1ZSB8PSAodTY0KXVuaXQgPDwgKDI0IC0gNCAqIGJ5dGUpOworCX0KKwlpZiAocG1jIDwgNSkgeworCQkvKiBuZWVkIGEgY291bnRlciBmcm9tIFBNQzEtNCBzZXQgKi8KKwkJbWFzayAgfD0gMHg4MDAwMDAwMDAwMDAwdWxsOworCQl2YWx1ZSB8PSAweDEwMDAwMDAwMDAwMDB1bGw7CisJfQorCSptYXNrcCA9IG1hc2s7CisJKnZhbHAgPSB2YWx1ZTsKKwlyZXR1cm4gMDsKK30KKworc3RhdGljIGludCBwb3dlcjVwX2xpbWl0ZWRfcG1jX2V2ZW50KHU2NCBldmVudCkKK3sKKwlpbnQgcG1jID0gKGV2ZW50ID4+IFBNX1BNQ19TSCkgJiBQTV9QTUNfTVNLOworCisJcmV0dXJuIHBtYyA9PSA1IHx8IHBtYyA9PSA2OworfQorCisjZGVmaW5lIE1BWF9BTFQJMwkvKiBhdCBtb3N0IDMgYWx0ZXJuYXRpdmVzIGZvciBhbnkgZXZlbnQgKi8KKworc3RhdGljIGNvbnN0IHVuc2lnbmVkIGludCBldmVudF9hbHRlcm5hdGl2ZXNbXVtNQVhfQUxUXSA9IHsKKwl7IDB4MTAwYzAsICAweDQwMDAxZiB9LAkJCS8qIFBNX0dDVF9GVUxMX0NZQyAqLworCXsgMHgxMjBlNCwgIDB4NDAwMDAyIH0sCQkJLyogUE1fR1JQX0RJU1BfUkVKRUNUICovCisJeyAweDIzMGUyLCAgMHgzMjMwODcgfSwJCQkvKiBQTV9CUl9QUkVEX0NSICovCisJeyAweDIzMGUzLCAgMHgyMjMwODcsIDB4MzIzMGEwIH0sCS8qIFBNX0JSX1BSRURfVEEgKi8KKwl7IDB4NDEwYzcsICAweDQ0MTA4NCB9LAkJCS8qIFBNX1RIUkRfTDJNSVNTX0JPVEhfQ1lDICovCisJeyAweDgwMGM0LCAgMHhjMjBlMCB9LAkJCS8qIFBNX0RUTEJfTUlTUyAqLworCXsgMHhjNTBjNiwgIDB4YzYwZTAgfSwJCQkvKiBQTV9NUktfRFRMQl9NSVNTICovCisJeyAweDEwMDAwNSwgMHg2MDAwMDUgfSwJCQkvKiBQTV9SVU5fQ1lDICovCisJeyAweDEwMDAwOSwgMHgyMDAwMDkgfSwJCQkvKiBQTV9JTlNUX0NNUEwgKi8KKwl7IDB4MjAwMDE1LCAweDMwMDAxNSB9LAkJCS8qIFBNX0xTVV9MTVFfU1JRX0VNUFRZX0NZQyAqLworCXsgMHgzMDAwMDksIDB4NDAwMDA5IH0sCQkJLyogUE1fSU5TVF9ESVNQICovCit9OworCisvKgorICogU2NhbiB0aGUgYWx0ZXJuYXRpdmVzIHRhYmxlIGZvciBhIG1hdGNoIGFuZCByZXR1cm4gdGhlCisgKiBpbmRleCBpbnRvIHRoZSBhbHRlcm5hdGl2ZXMgdGFibGUgaWYgZm91bmQsIGVsc2UgLTEuCisgKi8KK3N0YXRpYyBpbnQgZmluZF9hbHRlcm5hdGl2ZSh1bnNpZ25lZCBpbnQgZXZlbnQpCit7CisJaW50IGksIGo7CisKKwlmb3IgKGkgPSAwOyBpIDwgQVJSQVlfU0laRShldmVudF9hbHRlcm5hdGl2ZXMpOyArK2kpIHsKKwkJaWYgKGV2ZW50IDwgZXZlbnRfYWx0ZXJuYXRpdmVzW2ldWzBdKQorCQkJYnJlYWs7CisJCWZvciAoaiA9IDA7IGogPCBNQVhfQUxUICYmIGV2ZW50X2FsdGVybmF0aXZlc1tpXVtqXTsgKytqKQorCQkJaWYgKGV2ZW50ID09IGV2ZW50X2FsdGVybmF0aXZlc1tpXVtqXSkKKwkJCQlyZXR1cm4gaTsKKwl9CisJcmV0dXJuIC0xOworfQorCitzdGF0aWMgY29uc3QgdW5zaWduZWQgY2hhciBieXRlZGVjb2RlX2FsdGVybmF0aXZlc1s0XVs0XSA9IHsKKwkvKiBQTUMgMSAqLwl7IDB4MjEsIDB4MjMsIDB4MjUsIDB4MjcgfSwKKwkvKiBQTUMgMiAqLwl7IDB4MDcsIDB4MTcsIDB4MGUsIDB4MWUgfSwKKwkvKiBQTUMgMyAqLwl7IDB4MjAsIDB4MjIsIDB4MjQsIDB4MjYgfSwKKwkvKiBQTUMgNCAqLwl7IDB4MDcsIDB4MTcsIDB4MGUsIDB4MWUgfQorfTsKKworLyoKKyAqIFNvbWUgZGlyZWN0IGV2ZW50cyBmb3IgZGVjb2RlcyBvZiBldmVudCBidXMgYnl0ZSAzIGhhdmUgYWx0ZXJuYXRpdmUKKyAqIFBNQ1NFTCB2YWx1ZXMgb24gb3RoZXIgY291bnRlcnMuICBUaGlzIHJldHVybnMgdGhlIGFsdGVybmF0aXZlCisgKiBldmVudCBjb2RlIGZvciB0aG9zZSB0aGF0IGRvLCBvciAtMSBvdGhlcndpc2UuICBUaGlzIGFsc28gaGFuZGxlcworICogYWx0ZXJuYXRpdmUgUENNU0VMIHZhbHVlcyBmb3IgYWRkIGV2ZW50cy4KKyAqLworc3RhdGljIHM2NCBmaW5kX2FsdGVybmF0aXZlX2JkZWNvZGUodTY0IGV2ZW50KQoreworCWludCBwbWMsIGFsdHBtYywgcHAsIGo7CisKKwlwbWMgPSAoZXZlbnQgPj4gUE1fUE1DX1NIKSAmIFBNX1BNQ19NU0s7CisJaWYgKHBtYyA9PSAwIHx8IHBtYyA+IDQpCisJCXJldHVybiAtMTsKKwlhbHRwbWMgPSA1IC0gcG1jOwkvKiAxIDwtPiA0LCAyIDwtPiAzICovCisJcHAgPSBldmVudCAmIFBNX1BNQ1NFTF9NU0s7CisJZm9yIChqID0gMDsgaiA8IDQ7ICsraikgeworCQlpZiAoYnl0ZWRlY29kZV9hbHRlcm5hdGl2ZXNbcG1jIC0gMV1bal0gPT0gcHApIHsKKwkJCXJldHVybiAoZXZlbnQgJiB+KFBNX1BNQ19NU0tTIHwgUE1fUE1DU0VMX01TSykpIHwKKwkJCQkoYWx0cG1jIDw8IFBNX1BNQ19TSCkgfAorCQkJCWJ5dGVkZWNvZGVfYWx0ZXJuYXRpdmVzW2FsdHBtYyAtIDFdW2pdOworCQl9CisJfQorCisJLyogbmV3IGRlY29kZSBhbHRlcm5hdGl2ZXMgZm9yIHBvd2VyNSsgKi8KKwlpZiAocG1jID09IDEgJiYgKHBwID09IDB4MGQgfHwgcHAgPT0gMHgwZSkpCisJCXJldHVybiBldmVudCArICgyIDw8IFBNX1BNQ19TSCkgKyAoMHgyZSAtIDB4MGQpOworCWlmIChwbWMgPT0gMyAmJiAocHAgPT0gMHgyZSB8fCBwcCA9PSAweDJmKSkKKwkJcmV0dXJuIGV2ZW50IC0gKDIgPDwgUE1fUE1DX1NIKSAtICgweDJlIC0gMHgwZCk7CisKKwkvKiBhbHRlcm5hdGl2ZSBhZGQgZXZlbnQgZW5jb2RpbmdzICovCisJaWYgKHBwID09IDB4MTAgfHwgcHAgPT0gMHgyOCkKKwkJcmV0dXJuICgoZXZlbnQgXiAoMHgxMCBeIDB4MjgpKSAmIH5QTV9QTUNfTVNLUykgfAorCQkJKGFsdHBtYyA8PCBQTV9QTUNfU0gpOworCisJcmV0dXJuIC0xOworfQorCitzdGF0aWMgaW50IHBvd2VyNXBfZ2V0X2FsdGVybmF0aXZlcyh1NjQgZXZlbnQsIHVuc2lnbmVkIGludCBmbGFncywgdTY0IGFsdFtdKQoreworCWludCBpLCBqLCBuYWx0ID0gMTsKKwlpbnQgbmxpbTsKKwlzNjQgYWU7CisKKwlhbHRbMF0gPSBldmVudDsKKwluYWx0ID0gMTsKKwlubGltID0gcG93ZXI1cF9saW1pdGVkX3BtY19ldmVudChldmVudCk7CisJaSA9IGZpbmRfYWx0ZXJuYXRpdmUoZXZlbnQpOworCWlmIChpID49IDApIHsKKwkJZm9yIChqID0gMDsgaiA8IE1BWF9BTFQ7ICsraikgeworCQkJYWUgPSBldmVudF9hbHRlcm5hdGl2ZXNbaV1bal07CisJCQlpZiAoYWUgJiYgYWUgIT0gZXZlbnQpCisJCQkJYWx0W25hbHQrK10gPSBhZTsKKwkJCW5saW0gKz0gcG93ZXI1cF9saW1pdGVkX3BtY19ldmVudChhZSk7CisJCX0KKwl9IGVsc2UgeworCQlhZSA9IGZpbmRfYWx0ZXJuYXRpdmVfYmRlY29kZShldmVudCk7CisJCWlmIChhZSA+IDApCisJCQlhbHRbbmFsdCsrXSA9IGFlOworCX0KKworCWlmIChmbGFncyAmIFBQTVVfT05MWV9DT1VOVF9SVU4pIHsKKwkJLyoKKwkJICogV2UncmUgb25seSBjb3VudGluZyBpbiBSVU4gc3RhdGUsCisJCSAqIHNvIFBNX0NZQyBpcyBlcXVpdmFsZW50IHRvIFBNX1JVTl9DWUMKKwkJICogYW5kIFBNX0lOU1RfQ01QTCA9PT0gUE1fUlVOX0lOU1RfQ01QTC4KKwkJICogVGhpcyBkb2Vzbid0IGluY2x1ZGUgYWx0ZXJuYXRpdmVzIHRoYXQgZG9uJ3QgcHJvdmlkZQorCQkgKiBhbnkgZXh0cmEgZmxleGliaWxpdHkgaW4gYXNzaWduaW5nIFBNQ3MgKGUuZy4KKwkJICogMHgxMDAwMDUgZm9yIFBNX1JVTl9DWUMgdnMuIDB4ZiBmb3IgUE1fQ1lDKS4KKwkJICogTm90ZSB0aGF0IGV2ZW4gd2l0aCB0aGVzZSBhZGRpdGlvbmFsIGFsdGVybmF0aXZlcworCQkgKiB3ZSBuZXZlciBlbmQgdXAgd2l0aCBtb3JlIHRoYW4gMyBhbHRlcm5hdGl2ZXMgZm9yIGFueSBldmVudC4KKwkJICovCisJCWogPSBuYWx0OworCQlmb3IgKGkgPSAwOyBpIDwgbmFsdDsgKytpKSB7CisJCQlzd2l0Y2ggKGFsdFtpXSkgeworCQkJY2FzZSAweGY6CS8qIFBNX0NZQyAqLworCQkJCWFsdFtqKytdID0gMHg2MDAwMDU7CS8qIFBNX1JVTl9DWUMgKi8KKwkJCQkrK25saW07CisJCQkJYnJlYWs7CisJCQljYXNlIDB4NjAwMDA1OgkvKiBQTV9SVU5fQ1lDICovCisJCQkJYWx0W2orK10gPSAweGY7CisJCQkJYnJlYWs7CisJCQljYXNlIDB4MTAwMDA5OgkvKiBQTV9JTlNUX0NNUEwgKi8KKwkJCQlhbHRbaisrXSA9IDB4NTAwMDA5OwkvKiBQTV9SVU5fSU5TVF9DTVBMICovCisJCQkJKytubGltOworCQkJCWJyZWFrOworCQkJY2FzZSAweDUwMDAwOToJLyogUE1fUlVOX0lOU1RfQ01QTCAqLworCQkJCWFsdFtqKytdID0gMHgxMDAwMDk7CS8qIFBNX0lOU1RfQ01QTCAqLworCQkJCWFsdFtqKytdID0gMHgyMDAwMDk7CisJCQkJYnJlYWs7CisJCQl9CisJCX0KKwkJbmFsdCA9IGo7CisJfQorCisJaWYgKCEoZmxhZ3MgJiBQUE1VX0xJTUlURURfUE1DX09LKSAmJiBubGltKSB7CisJCS8qIHJlbW92ZSB0aGUgbGltaXRlZCBQTUMgZXZlbnRzICovCisJCWogPSAwOworCQlmb3IgKGkgPSAwOyBpIDwgbmFsdDsgKytpKSB7CisJCQlpZiAoIXBvd2VyNXBfbGltaXRlZF9wbWNfZXZlbnQoYWx0W2ldKSkgeworCQkJCWFsdFtqXSA9IGFsdFtpXTsKKwkJCQkrK2o7CisJCQl9CisJCX0KKwkJbmFsdCA9IGo7CisJfSBlbHNlIGlmICgoZmxhZ3MgJiBQUE1VX0xJTUlURURfUE1DX1JFUUQpICYmIG5saW0gPCBuYWx0KSB7CisJCS8qIHJlbW92ZSBhbGwgYnV0IHRoZSBsaW1pdGVkIFBNQyBldmVudHMgKi8KKwkJaiA9IDA7CisJCWZvciAoaSA9IDA7IGkgPCBuYWx0OyArK2kpIHsKKwkJCWlmIChwb3dlcjVwX2xpbWl0ZWRfcG1jX2V2ZW50KGFsdFtpXSkpIHsKKwkJCQlhbHRbal0gPSBhbHRbaV07CisJCQkJKytqOworCQkJfQorCQl9CisJCW5hbHQgPSBqOworCX0KKworCXJldHVybiBuYWx0OworfQorCisvKgorICogTWFwIG9mIHdoaWNoIGRpcmVjdCBldmVudHMgb24gd2hpY2ggUE1DcyBhcmUgbWFya2VkIGluc3RydWN0aW9uIGV2ZW50cy4KKyAqIEluZGV4ZWQgYnkgUE1DU0VMIHZhbHVlLCBiaXQgaSAoTEUpIHNldCBpZiBQTUMgaSBpcyBhIG1hcmtlZCBldmVudC4KKyAqIEJpdCAwIGlzIHNldCBpZiBpdCBpcyBtYXJrZWQgZm9yIGFsbCBQTUNzLgorICogVGhlIDB4ODAgYml0IGluZGljYXRlcyBhIGJ5dGUgZGVjb2RlIFBNQ1NFTCB2YWx1ZS4KKyAqLworc3RhdGljIHVuc2lnbmVkIGNoYXIgZGlyZWN0X2V2ZW50X2lzX21hcmtlZFsweDI4XSA9IHsKKwkwLAkvKiAwMCAqLworCTB4MWYsCS8qIDAxIFBNX0lPUFNfQ01QTCAqLworCTB4MiwJLyogMDIgUE1fTVJLX0dSUF9ESVNQICovCisJMHhlLAkvKiAwMyBQTV9NUktfU1RfQ01QTCwgUE1fTVJLX1NUX0dQUywgUE1fTVJLX1NUX0NNUExfSU5UICovCisJMCwJLyogMDQgKi8KKwkweDFjLAkvKiAwNSBQTV9NUktfQlJVX0ZJTiwgUE1fTVJLX0lOU1RfRklOLCBQTV9NUktfQ1JVX0ZJTiAqLworCTB4ODAsCS8qIDA2ICovCisJMHg4MCwJLyogMDcgKi8KKwkwLCAwLCAwLC8qIDA4IC0gMGEgKi8KKwkweDE4LAkvKiAwYiBQTV9USFJFU0hfVElNRU8sIFBNX01SS19HUlBfVElNRU8gKi8KKwkwLAkvKiAwYyAqLworCTB4ODAsCS8qIDBkICovCisJMHg4MCwJLyogMGUgKi8KKwkwLAkvKiAwZiAqLworCTAsCS8qIDEwICovCisJMHgxNCwJLyogMTEgUE1fTVJLX0dSUF9CUl9SRURJUiwgUE1fTVJLX0dSUF9JQ19NSVNTICovCisJMCwJLyogMTIgKi8KKwkweDEwLAkvKiAxMyBQTV9NUktfR1JQX0NNUEwgKi8KKwkweDFmLAkvKiAxNCBQTV9HUlBfTVJLLCBQTV9NUktfe0ZYVSxGUFUsTFNVfV9GSU4gKi8KKwkweDIsCS8qIDE1IFBNX01SS19HUlBfSVNTVUVEICovCisJMHg4MCwJLyogMTYgKi8KKwkweDgwLAkvKiAxNyAqLworCTAsIDAsIDAsIDAsIDAsCisJMHg4MCwJLyogMWQgKi8KKwkweDgwLAkvKiAxZSAqLworCTAsCS8qIDFmICovCisJMHg4MCwJLyogMjAgKi8KKwkweDgwLAkvKiAyMSAqLworCTB4ODAsCS8qIDIyICovCisJMHg4MCwJLyogMjMgKi8KKwkweDgwLAkvKiAyNCAqLworCTB4ODAsCS8qIDI1ICovCisJMHg4MCwJLyogMjYgKi8KKwkweDgwLAkvKiAyNyAqLworfTsKKworLyoKKyAqIFJldHVybnMgMSBpZiBldmVudCBjb3VudHMgdGhpbmdzIHJlbGF0aW5nIHRvIG1hcmtlZCBpbnN0cnVjdGlvbnMKKyAqIGFuZCB0aHVzIG5lZWRzIHRoZSBNTUNSQV9TQU1QTEVfRU5BQkxFIGJpdCBzZXQsIG9yIDAgaWYgbm90LgorICovCitzdGF0aWMgaW50IHBvd2VyNXBfbWFya2VkX2luc3RyX2V2ZW50KHU2NCBldmVudCkKK3sKKwlpbnQgcG1jLCBwc2VsOworCWludCBiaXQsIGJ5dGUsIHVuaXQ7CisJdTMyIG1hc2s7CisKKwlwbWMgPSAoZXZlbnQgPj4gUE1fUE1DX1NIKSAmIFBNX1BNQ19NU0s7CisJcHNlbCA9IGV2ZW50ICYgUE1fUE1DU0VMX01TSzsKKwlpZiAocG1jID49IDUpCisJCXJldHVybiAwOworCisJYml0ID0gLTE7CisJaWYgKHBzZWwgPCBzaXplb2YoZGlyZWN0X2V2ZW50X2lzX21hcmtlZCkpIHsKKwkJaWYgKGRpcmVjdF9ldmVudF9pc19tYXJrZWRbcHNlbF0gJiAoMSA8PCBwbWMpKQorCQkJcmV0dXJuIDE7CisJCWlmIChkaXJlY3RfZXZlbnRfaXNfbWFya2VkW3BzZWxdICYgMHg4MCkKKwkJCWJpdCA9IDQ7CisJCWVsc2UgaWYgKHBzZWwgPT0gMHgwOCkKKwkJCWJpdCA9IHBtYyAtIDE7CisJCWVsc2UgaWYgKHBzZWwgPT0gMHgxMCkKKwkJCWJpdCA9IDQgLSBwbWM7CisJCWVsc2UgaWYgKHBzZWwgPT0gMHgxYiAmJiAocG1jID09IDEgfHwgcG1jID09IDMpKQorCQkJYml0ID0gNDsKKwl9IGVsc2UgaWYgKChwc2VsICYgMHg0OCkgPT0gMHg0MCkgeworCQliaXQgPSBwc2VsICYgNzsKKwl9IGVsc2UgaWYgKHBzZWwgPT0gMHgyOCkgeworCQliaXQgPSBwbWMgLSAxOworCX0gZWxzZSBpZiAocG1jID09IDMgJiYgKHBzZWwgPT0gMHgyZSB8fCBwc2VsID09IDB4MmYpKSB7CisJCWJpdCA9IDQ7CisJfQorCisJaWYgKCEoZXZlbnQgJiBQTV9CVVNFVkVOVF9NU0spIHx8IGJpdCA9PSAtMSkKKwkJcmV0dXJuIDA7CisKKwlieXRlID0gKGV2ZW50ID4+IFBNX0JZVEVfU0gpICYgUE1fQllURV9NU0s7CisJdW5pdCA9IChldmVudCA+PiBQTV9VTklUX1NIKSAmIFBNX1VOSVRfTVNLOworCWlmICh1bml0ID09IFBNX0xTVTApIHsKKwkJLyogYnl0ZSAxIGJpdHMgMC03LCBieXRlIDIgYml0cyAwLDItNCw2ICovCisJCW1hc2sgPSAweDVkZmYwMDsKKwl9IGVsc2UgaWYgKHVuaXQgPT0gUE1fTFNVMSAmJiBieXRlID49IDQpIHsKKwkJYnl0ZSAtPSA0OworCQkvKiBieXRlIDUgYml0cyA2LTcsIGJ5dGUgNiBiaXRzIDAsNCwgYnl0ZSA3IGJpdHMgMC00LDYgKi8KKwkJbWFzayA9IDB4NWYxMWMwMDA7CisJfSBlbHNlCisJCXJldHVybiAwOworCisJcmV0dXJuIChtYXNrID4+IChieXRlICogOCArIGJpdCkpICYgMTsKK30KKworc3RhdGljIGludCBwb3dlcjVwX2NvbXB1dGVfbW1jcih1NjQgZXZlbnRbXSwgaW50IG5fZXYsCisJCQkJdW5zaWduZWQgaW50IGh3Y1tdLCB1NjQgbW1jcltdKQoreworCXU2NCBtbWNyMSA9IDA7CisJdTY0IG1tY3JhID0gMDsKKwl1bnNpZ25lZCBpbnQgcG1jLCB1bml0LCBieXRlLCBwc2VsOworCXVuc2lnbmVkIGludCB0dG07CisJaW50IGksIGlzYnVzLCBiaXQsIGdyc2VsOworCXVuc2lnbmVkIGludCBwbWNfaW51c2UgPSAwOworCXVuc2lnbmVkIGNoYXIgYnVzYnl0ZVs0XTsKKwl1bnNpZ25lZCBjaGFyIHVuaXR1c2VbMTZdOworCWludCB0dG11c2U7CisKKwlpZiAobl9ldiA+IDYpCisJCXJldHVybiAtMTsKKworCS8qIEZpcnN0IHBhc3MgdG8gY291bnQgcmVzb3VyY2UgdXNlICovCisJbWVtc2V0KGJ1c2J5dGUsIDAsIHNpemVvZihidXNieXRlKSk7CisJbWVtc2V0KHVuaXR1c2UsIDAsIHNpemVvZih1bml0dXNlKSk7CisJZm9yIChpID0gMDsgaSA8IG5fZXY7ICsraSkgeworCQlwbWMgPSAoZXZlbnRbaV0gPj4gUE1fUE1DX1NIKSAmIFBNX1BNQ19NU0s7CisJCWlmIChwbWMpIHsKKwkJCWlmIChwbWMgPiA2KQorCQkJCXJldHVybiAtMTsKKwkJCWlmIChwbWNfaW51c2UgJiAoMSA8PCAocG1jIC0gMSkpKQorCQkJCXJldHVybiAtMTsKKwkJCXBtY19pbnVzZSB8PSAxIDw8IChwbWMgLSAxKTsKKwkJfQorCQlpZiAoZXZlbnRbaV0gJiBQTV9CVVNFVkVOVF9NU0spIHsKKwkJCXVuaXQgPSAoZXZlbnRbaV0gPj4gUE1fVU5JVF9TSCkgJiBQTV9VTklUX01TSzsKKwkJCWJ5dGUgPSAoZXZlbnRbaV0gPj4gUE1fQllURV9TSCkgJiBQTV9CWVRFX01TSzsKKwkJCWlmICh1bml0ID4gUE1fTEFTVFVOSVQpCisJCQkJcmV0dXJuIC0xOworCQkJaWYgKHVuaXQgPT0gUE1fSVNVMF9BTFQpCisJCQkJdW5pdCA9IFBNX0lTVTA7CisJCQlpZiAoYnl0ZSA+PSA0KSB7CisJCQkJaWYgKHVuaXQgIT0gUE1fTFNVMSkKKwkJCQkJcmV0dXJuIC0xOworCQkJCSsrdW5pdDsKKwkJCQlieXRlICY9IDM7CisJCQl9CisJCQlpZiAoYnVzYnl0ZVtieXRlXSAmJiBidXNieXRlW2J5dGVdICE9IHVuaXQpCisJCQkJcmV0dXJuIC0xOworCQkJYnVzYnl0ZVtieXRlXSA9IHVuaXQ7CisJCQl1bml0dXNlW3VuaXRdID0gMTsKKwkJfQorCX0KKworCS8qCisJICogQXNzaWduIHJlc291cmNlcyBhbmQgc2V0IG11bHRpcGxleGVyIHNlbGVjdHMuCisJICoKKwkgKiBQTV9JU1UwIGNhbiBnbyBlaXRoZXIgb24gVFRNMCBvciBUVE0xLCBidXQgdGhhdCdzIHRoZSBvbmx5CisJICogY2hvaWNlIHdlIGhhdmUgdG8gZGVhbCB3aXRoLgorCSAqLworCWlmICh1bml0dXNlW1BNX0lTVTBdICYKKwkgICAgKHVuaXR1c2VbUE1fRlBVXSB8IHVuaXR1c2VbUE1fSUZVXSB8IHVuaXR1c2VbUE1fSVNVMV0pKSB7CisJCXVuaXR1c2VbUE1fSVNVMF9BTFRdID0gMTsJLyogbW92ZSBJU1UgdG8gVFRNMSAqLworCQl1bml0dXNlW1BNX0lTVTBdID0gMDsKKwl9CisJLyogU2V0IFRUTVswMV1TRUwgZmllbGRzLiAqLworCXR0bXVzZSA9IDA7CisJZm9yIChpID0gUE1fRlBVOyBpIDw9IFBNX0lTVTE7ICsraSkgeworCQlpZiAoIXVuaXR1c2VbaV0pCisJCQljb250aW51ZTsKKwkJaWYgKHR0bXVzZSsrKQorCQkJcmV0dXJuIC0xOworCQltbWNyMSB8PSAodTY0KWkgPDwgTU1DUjFfVFRNMFNFTF9TSDsKKwl9CisJdHRtdXNlID0gMDsKKwlmb3IgKDsgaSA8PSBQTV9HUlM7ICsraSkgeworCQlpZiAoIXVuaXR1c2VbaV0pCisJCQljb250aW51ZTsKKwkJaWYgKHR0bXVzZSsrKQorCQkJcmV0dXJuIC0xOworCQltbWNyMSB8PSAodTY0KShpICYgMykgPDwgTU1DUjFfVFRNMVNFTF9TSDsKKwl9CisJaWYgKHR0bXVzZSA+IDEpCisJCXJldHVybiAtMTsKKworCS8qIFNldCBieXRlIGxhbmUgc2VsZWN0IGZpZWxkcywgVFRNWzIzXVNFTCBhbmQgR1JTXypTRUwuICovCisJZm9yIChieXRlID0gMDsgYnl0ZSA8IDQ7ICsrYnl0ZSkgeworCQl1bml0ID0gYnVzYnl0ZVtieXRlXTsKKwkJaWYgKCF1bml0KQorCQkJY29udGludWU7CisJCWlmICh1bml0ID09IFBNX0lTVTAgJiYgdW5pdHVzZVtQTV9JU1UwX0FMVF0pIHsKKwkJCS8qIGdldCBJU1UwIHRocm91Z2ggVFRNMSByYXRoZXIgdGhhbiBUVE0wICovCisJCQl1bml0ID0gUE1fSVNVMF9BTFQ7CisJCX0gZWxzZSBpZiAodW5pdCA9PSBQTV9MU1UxICsgMSkgeworCQkJLyogc2VsZWN0IGxvd2VyIHdvcmQgb2YgTFNVMSBmb3IgdGhpcyBieXRlICovCisJCQltbWNyMSB8PSAxdWxsIDw8IChNTUNSMV9UVE0zU0VMX1NIICsgMyAtIGJ5dGUpOworCQl9CisJCXR0bSA9IHVuaXQgPj4gMjsKKwkJbW1jcjEgfD0gKHU2NCl0dG0gPDwgKE1NQ1IxX1REX0NQX0RCRzBTRUxfU0ggLSAyICogYnl0ZSk7CisJfQorCisJLyogU2Vjb25kIHBhc3M6IGFzc2lnbiBQTUNzLCBzZXQgUE1DeFNFTCBhbmQgUE1DeF9BRERFUl9TRUwgZmllbGRzICovCisJZm9yIChpID0gMDsgaSA8IG5fZXY7ICsraSkgeworCQlwbWMgPSAoZXZlbnRbaV0gPj4gUE1fUE1DX1NIKSAmIFBNX1BNQ19NU0s7CisJCXVuaXQgPSAoZXZlbnRbaV0gPj4gUE1fVU5JVF9TSCkgJiBQTV9VTklUX01TSzsKKwkJYnl0ZSA9IChldmVudFtpXSA+PiBQTV9CWVRFX1NIKSAmIFBNX0JZVEVfTVNLOworCQlwc2VsID0gZXZlbnRbaV0gJiBQTV9QTUNTRUxfTVNLOworCQlpc2J1cyA9IGV2ZW50W2ldICYgUE1fQlVTRVZFTlRfTVNLOworCQlpZiAoIXBtYykgeworCQkJLyogQnVzIGV2ZW50IG9yIGFueS1QTUMgZGlyZWN0IGV2ZW50ICovCisJCQlmb3IgKHBtYyA9IDA7IHBtYyA8IDQ7ICsrcG1jKSB7CisJCQkJaWYgKCEocG1jX2ludXNlICYgKDEgPDwgcG1jKSkpCisJCQkJCWJyZWFrOworCQkJfQorCQkJaWYgKHBtYyA+PSA0KQorCQkJCXJldHVybiAtMTsKKwkJCXBtY19pbnVzZSB8PSAxIDw8IHBtYzsKKwkJfSBlbHNlIGlmIChwbWMgPD0gNCkgeworCQkJLyogRGlyZWN0IGV2ZW50ICovCisJCQktLXBtYzsKKwkJCWlmIChpc2J1cyAmJiAoYnl0ZSAmIDIpICYmCisJCQkgICAgKHBzZWwgPT0gOCB8fCBwc2VsID09IDB4MTAgfHwgcHNlbCA9PSAweDI4KSkKKwkJCQkvKiBhZGQgZXZlbnRzIG9uIGhpZ2hlci1udW1iZXJlZCBidXMgKi8KKwkJCQltbWNyMSB8PSAxdWxsIDw8IChNTUNSMV9QTUMxX0FEREVSX1NFTF9TSCAtIHBtYyk7CisJCX0gZWxzZSB7CisJCQkvKiBJbnN0cnVjdGlvbnMgb3IgcnVuIGN5Y2xlcyBvbiBQTUM1LzYgKi8KKwkJCS0tcG1jOworCQl9CisJCWlmIChpc2J1cyAmJiB1bml0ID09IFBNX0dSUykgeworCQkJYml0ID0gcHNlbCAmIDc7CisJCQlncnNlbCA9IChldmVudFtpXSA+PiBQTV9HUlNfU0gpICYgUE1fR1JTX01TSzsKKwkJCW1tY3IxIHw9ICh1NjQpZ3JzZWwgPDwgZ3JzZWxfc2hpZnRbYml0XTsKKwkJfQorCQlpZiAocG93ZXI1cF9tYXJrZWRfaW5zdHJfZXZlbnQoZXZlbnRbaV0pKQorCQkJbW1jcmEgfD0gTU1DUkFfU0FNUExFX0VOQUJMRTsKKwkJaWYgKChwc2VsICYgMHg1OCkgPT0gMHg0MCAmJiAoYnl0ZSAmIDEpICE9ICgocG1jID4+IDEpICYgMSkpCisJCQkvKiBzZWxlY3QgYWx0ZXJuYXRlIGJ5dGUgbGFuZSAqLworCQkJcHNlbCB8PSAweDEwOworCQlpZiAocG1jIDw9IDMpCisJCQltbWNyMSB8PSBwc2VsIDw8IE1NQ1IxX1BNQ1NFTF9TSChwbWMpOworCQlod2NbaV0gPSBwbWM7CisJfQorCisJLyogUmV0dXJuIE1NQ1J4IHZhbHVlcyAqLworCW1tY3JbMF0gPSAwOworCWlmIChwbWNfaW51c2UgJiAxKQorCQltbWNyWzBdID0gTU1DUjBfUE1DMUNFOworCWlmIChwbWNfaW51c2UgJiAweDNlKQorCQltbWNyWzBdIHw9IE1NQ1IwX1BNQ2pDRTsKKwltbWNyWzFdID0gbW1jcjE7CisJbW1jclsyXSA9IG1tY3JhOworCXJldHVybiAwOworfQorCitzdGF0aWMgdm9pZCBwb3dlcjVwX2Rpc2FibGVfcG1jKHVuc2lnbmVkIGludCBwbWMsIHU2NCBtbWNyW10pCit7CisJaWYgKHBtYyA8PSAzKQorCQltbWNyWzFdICY9IH4oMHg3ZlVMIDw8IE1NQ1IxX1BNQ1NFTF9TSChwbWMpKTsKK30KKworc3RhdGljIGludCBwb3dlcjVwX2dlbmVyaWNfZXZlbnRzW10gPSB7CisJW1BFUkZfQ09VTlRfSFdfQ1BVX0NZQ0xFU10JCT0gMHhmLAorCVtQRVJGX0NPVU5UX0hXX0lOU1RSVUNUSU9OU10JCT0gMHgxMDAwMDksCisJW1BFUkZfQ09VTlRfSFdfQ0FDSEVfUkVGRVJFTkNFU10JPSAweDFjMTBhOCwgLyogTERfUkVGX0wxICovCisJW1BFUkZfQ09VTlRfSFdfQ0FDSEVfTUlTU0VTXQkJPSAweDNjMTA4OCwgLyogTERfTUlTU19MMSAqLworCVtQRVJGX0NPVU5UX0hXX0JSQU5DSF9JTlNUUlVDVElPTlNdCT0gMHgyMzBlNCwgIC8qIEJSX0lTU1VFRCAqLworCVtQRVJGX0NPVU5UX0hXX0JSQU5DSF9NSVNTRVNdCQk9IDB4MjMwZTUsICAvKiBCUl9NUFJFRF9DUiAqLworfTsKKworI2RlZmluZSBDKHgpCVBFUkZfQ09VTlRfSFdfQ0FDSEVfIyN4CisKKy8qCisgKiBUYWJsZSBvZiBnZW5lcmFsaXplZCBjYWNoZS1yZWxhdGVkIGV2ZW50cy4KKyAqIDAgbWVhbnMgbm90IHN1cHBvcnRlZCwgLTEgbWVhbnMgbm9uc2Vuc2ljYWwsIG90aGVyIHZhbHVlcworICogYXJlIGV2ZW50IGNvZGVzLgorICovCitzdGF0aWMgaW50IHBvd2VyNXBfY2FjaGVfZXZlbnRzW0MoTUFYKV1bQyhPUF9NQVgpXVtDKFJFU1VMVF9NQVgpXSA9IHsKKwlbQyhMMUQpXSA9IHsJCS8qIAlSRVNVTFRfQUNDRVNTCVJFU1VMVF9NSVNTICovCisJCVtDKE9QX1JFQUQpXSA9IHsJMHgxYzEwYTgsCTB4M2MxMDg4CX0sCisJCVtDKE9QX1dSSVRFKV0gPSB7CTB4MmMxMGE4LAkweGMxMGMzCQl9LAorCQlbQyhPUF9QUkVGRVRDSCldID0gewkweGM3MGU3LAktMQkJfSwKKwl9LAorCVtDKEwxSSldID0gewkJLyogCVJFU1VMVF9BQ0NFU1MJUkVTVUxUX01JU1MgKi8KKwkJW0MoT1BfUkVBRCldID0gewkwLAkJMAkJfSwKKwkJW0MoT1BfV1JJVEUpXSA9IHsJLTEsCQktMQkJfSwKKwkJW0MoT1BfUFJFRkVUQ0gpXSA9IHsJMCwJCTAJCX0sCisJfSwKKwlbQyhMTCldID0gewkJLyogCVJFU1VMVF9BQ0NFU1MJUkVTVUxUX01JU1MgKi8KKwkJW0MoT1BfUkVBRCldID0gewkwLAkJMAkJfSwKKwkJW0MoT1BfV1JJVEUpXSA9IHsJMCwJCTAJCX0sCisJCVtDKE9QX1BSRUZFVENIKV0gPSB7CTB4YzUwYzMsCTAJCX0sCisJfSwKKwlbQyhEVExCKV0gPSB7CQkvKiAJUkVTVUxUX0FDQ0VTUwlSRVNVTFRfTUlTUyAqLworCQlbQyhPUF9SRUFEKV0gPSB7CTB4YzIwZTQsCTB4ODAwYzQJCX0sCisJCVtDKE9QX1dSSVRFKV0gPSB7CS0xLAkJLTEJCX0sCisJCVtDKE9QX1BSRUZFVENIKV0gPSB7CS0xLAkJLTEJCX0sCisJfSwKKwlbQyhJVExCKV0gPSB7CQkvKiAJUkVTVUxUX0FDQ0VTUwlSRVNVTFRfTUlTUyAqLworCQlbQyhPUF9SRUFEKV0gPSB7CTAsCQkweDgwMGMwCQl9LAorCQlbQyhPUF9XUklURSldID0gewktMSwJCS0xCQl9LAorCQlbQyhPUF9QUkVGRVRDSCldID0gewktMSwJCS0xCQl9LAorCX0sCisJW0MoQlBVKV0gPSB7CQkvKiAJUkVTVUxUX0FDQ0VTUwlSRVNVTFRfTUlTUyAqLworCQlbQyhPUF9SRUFEKV0gPSB7CTB4MjMwZTQsCTB4MjMwZTUJCX0sCisJCVtDKE9QX1dSSVRFKV0gPSB7CS0xLAkJLTEJCX0sCisJCVtDKE9QX1BSRUZFVENIKV0gPSB7CS0xLAkJLTEJCX0sCisJfSwKK307CisKK3N0cnVjdCBwb3dlcl9wbXUgcG93ZXI1cF9wbXUgPSB7CisJLm5fY291bnRlciA9IDYsCisJLm1heF9hbHRlcm5hdGl2ZXMgPSBNQVhfQUxULAorCS5hZGRfZmllbGRzID0gMHg3MDAwMDAwMDAwMDU1dWxsLAorCS50ZXN0X2FkZGVyID0gMHgzMDAwMDQwMDAwMDAwdWxsLAorCS5jb21wdXRlX21tY3IgPSBwb3dlcjVwX2NvbXB1dGVfbW1jciwKKwkuZ2V0X2NvbnN0cmFpbnQgPSBwb3dlcjVwX2dldF9jb25zdHJhaW50LAorCS5nZXRfYWx0ZXJuYXRpdmVzID0gcG93ZXI1cF9nZXRfYWx0ZXJuYXRpdmVzLAorCS5kaXNhYmxlX3BtYyA9IHBvd2VyNXBfZGlzYWJsZV9wbWMsCisJLmxpbWl0ZWRfcG1jX2V2ZW50ID0gcG93ZXI1cF9saW1pdGVkX3BtY19ldmVudCwKKwkuZmxhZ3MgPSBQUE1VX0xJTUlURURfUE1DNV82LAorCS5uX2dlbmVyaWMgPSBBUlJBWV9TSVpFKHBvd2VyNXBfZ2VuZXJpY19ldmVudHMpLAorCS5nZW5lcmljX2V2ZW50cyA9IHBvd2VyNXBfZ2VuZXJpY19ldmVudHMsCisJLmNhY2hlX2V2ZW50cyA9ICZwb3dlcjVwX2NhY2hlX2V2ZW50cywKK307CmRpZmYgLS1naXQgYS9hcmNoL3Bvd2VycGMva2VybmVsL3Bvd2VyNS1wbXUuYyBiL2FyY2gvcG93ZXJwYy9rZXJuZWwvcG93ZXI1LXBtdS5jCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjA1NjAwYjYKLS0tIC9kZXYvbnVsbAorKysgYi9hcmNoL3Bvd2VycGMva2VybmVsL3Bvd2VyNS1wbXUuYwpAQCAtMCwwICsxLDYxMSBAQAorLyoKKyAqIFBlcmZvcm1hbmNlIGNvdW50ZXIgc3VwcG9ydCBmb3IgUE9XRVI1IChub3QgUE9XRVI1KyspIHByb2Nlc3NvcnMuCisgKgorICogQ29weXJpZ2h0IDIwMDkgUGF1bCBNYWNrZXJyYXMsIElCTSBDb3Jwb3JhdGlvbi4KKyAqCisgKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yCisgKiBtb2RpZnkgaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZQorICogYXMgcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb247IGVpdGhlciB2ZXJzaW9uCisgKiAyIG9mIHRoZSBMaWNlbnNlLCBvciAoYXQgeW91ciBvcHRpb24pIGFueSBsYXRlciB2ZXJzaW9uLgorICovCisjaW5jbHVkZSA8bGludXgva2VybmVsLmg+CisjaW5jbHVkZSA8bGludXgvcGVyZl9jb3VudGVyLmg+CisjaW5jbHVkZSA8YXNtL3JlZy5oPgorCisvKgorICogQml0cyBpbiBldmVudCBjb2RlIGZvciBQT1dFUjUgKG5vdCBQT1dFUjUrKykKKyAqLworI2RlZmluZSBQTV9QTUNfU0gJMjAJLyogUE1DIG51bWJlciAoMS1iYXNlZCkgZm9yIGRpcmVjdCBldmVudHMgKi8KKyNkZWZpbmUgUE1fUE1DX01TSwkweGYKKyNkZWZpbmUgUE1fUE1DX01TS1MJKFBNX1BNQ19NU0sgPDwgUE1fUE1DX1NIKQorI2RlZmluZSBQTV9VTklUX1NICTE2CS8qIFRUTU1VWCBudW1iZXIgYW5kIHNldHRpbmcgLSB1bml0IHNlbGVjdCAqLworI2RlZmluZSBQTV9VTklUX01TSwkweGYKKyNkZWZpbmUgUE1fQllURV9TSAkxMgkvKiBCeXRlIG51bWJlciBvZiBldmVudCBidXMgdG8gdXNlICovCisjZGVmaW5lIFBNX0JZVEVfTVNLCTcKKyNkZWZpbmUgUE1fR1JTX1NICTgJLyogU3RvcmFnZSBzdWJzeXN0ZW0gbXV4IHNlbGVjdCAqLworI2RlZmluZSBQTV9HUlNfTVNLCTcKKyNkZWZpbmUgUE1fQlVTRVZFTlRfTVNLCTB4ODAJLyogU2V0IGlmIGV2ZW50IHVzZXMgZXZlbnQgYnVzICovCisjZGVmaW5lIFBNX1BNQ1NFTF9NU0sJMHg3ZgorCisvKiBWYWx1ZXMgaW4gUE1fVU5JVCBmaWVsZCAqLworI2RlZmluZSBQTV9GUFUJCTAKKyNkZWZpbmUgUE1fSVNVMAkJMQorI2RlZmluZSBQTV9JRlUJCTIKKyNkZWZpbmUgUE1fSVNVMQkJMworI2RlZmluZSBQTV9JRFUJCTQKKyNkZWZpbmUgUE1fSVNVMF9BTFQJNgorI2RlZmluZSBQTV9HUlMJCTcKKyNkZWZpbmUgUE1fTFNVMAkJOAorI2RlZmluZSBQTV9MU1UxCQkweGMKKyNkZWZpbmUgUE1fTEFTVFVOSVQJMHhjCisKKy8qCisgKiBCaXRzIGluIE1NQ1IxIGZvciBQT1dFUjUKKyAqLworI2RlZmluZSBNTUNSMV9UVE0wU0VMX1NICTYyCisjZGVmaW5lIE1NQ1IxX1RUTTFTRUxfU0gJNjAKKyNkZWZpbmUgTU1DUjFfVFRNMlNFTF9TSAk1OAorI2RlZmluZSBNTUNSMV9UVE0zU0VMX1NICTU2CisjZGVmaW5lIE1NQ1IxX1RUTVNFTF9NU0sJMworI2RlZmluZSBNTUNSMV9URF9DUF9EQkcwU0VMX1NICTU0CisjZGVmaW5lIE1NQ1IxX1REX0NQX0RCRzFTRUxfU0gJNTIKKyNkZWZpbmUgTU1DUjFfVERfQ1BfREJHMlNFTF9TSAk1MAorI2RlZmluZSBNTUNSMV9URF9DUF9EQkczU0VMX1NICTQ4CisjZGVmaW5lIE1NQ1IxX0dSU19MMlNFTF9TSAk0NgorI2RlZmluZSBNTUNSMV9HUlNfTDJTRUxfTVNLCTMKKyNkZWZpbmUgTU1DUjFfR1JTX0wzU0VMX1NICTQ0CisjZGVmaW5lIE1NQ1IxX0dSU19MM1NFTF9NU0sJMworI2RlZmluZSBNTUNSMV9HUlNfTUNTRUxfU0gJNDEKKyNkZWZpbmUgTU1DUjFfR1JTX01DU0VMX01TSwk3CisjZGVmaW5lIE1NQ1IxX0dSU19GQUJTRUxfU0gJMzkKKyNkZWZpbmUgTU1DUjFfR1JTX0ZBQlNFTF9NU0sJMworI2RlZmluZSBNTUNSMV9QTUMxX0FEREVSX1NFTF9TSAkzNQorI2RlZmluZSBNTUNSMV9QTUMyX0FEREVSX1NFTF9TSAkzNAorI2RlZmluZSBNTUNSMV9QTUMzX0FEREVSX1NFTF9TSAkzMworI2RlZmluZSBNTUNSMV9QTUM0X0FEREVSX1NFTF9TSAkzMgorI2RlZmluZSBNTUNSMV9QTUMxU0VMX1NICTI1CisjZGVmaW5lIE1NQ1IxX1BNQzJTRUxfU0gJMTcKKyNkZWZpbmUgTU1DUjFfUE1DM1NFTF9TSAk5CisjZGVmaW5lIE1NQ1IxX1BNQzRTRUxfU0gJMQorI2RlZmluZSBNTUNSMV9QTUNTRUxfU0gobikJKE1NQ1IxX1BNQzFTRUxfU0ggLSAobikgKiA4KQorI2RlZmluZSBNTUNSMV9QTUNTRUxfTVNLCTB4N2YKKworLyoKKyAqIEJpdHMgaW4gTU1DUkEKKyAqLworCisvKgorICogTGF5b3V0IG9mIGNvbnN0cmFpbnQgYml0czoKKyAqIDY2NjY1NTU1NTU1NTU1NDQ0NDQ0NDQ0NDMzMzMzMzMzMzMyMjIyMjIyMjIyMTExMTExMTExMTAwMDAwMDAwMDAKKyAqIDMyMTA5ODc2NTQzMjEwOTg3NjU0MzIxMDk4NzY1NDMyMTA5ODc2NTQzMjEwOTg3NjU0MzIxMDk4NzY1NDMyMTAKKyAqICAgICAgICAgPD48PlsgID48Pjw+PCA+PD4gWyAgPlsgPlsgPjwgID48ICA+PCAgPjwgID48Pjw+PD48Pjw+PD4KKyAqICAgICAgICAgVDBUMSBOQyBHMEcxRzIgRzMgIFVDIFBTMVBTMiBCMCAgQjEgIEIyICBCMyBQNlA1UDRQM1AyUDEKKyAqCisgKiBUMCAtIFRUTTAgY29uc3RyYWludAorICogICAgIDU0LTU1OiBUVE0wU0VMIHZhbHVlICgwPUZQVSwgMj1JRlUsIDM9SVNVMSkgMHhjMF8wMDAwXzAwMDBfMDAwMAorICoKKyAqIFQxIC0gVFRNMSBjb25zdHJhaW50CisgKiAgICAgNTItNTM6IFRUTTFTRUwgdmFsdWUgKDA9SURVLCAzPUdSUykgMHgzMF8wMDAwXzAwMDBfMDAwMAorICoKKyAqIE5DIC0gbnVtYmVyIG9mIGNvdW50ZXJzCisgKiAgICAgNTE6IE5DIGVycm9yIDB4MDAwOF8wMDAwXzAwMDBfMDAwMAorICogICAgIDQ4LTUwOiBudW1iZXIgb2YgZXZlbnRzIG5lZWRpbmcgUE1DMS00IDB4MDAwN18wMDAwXzAwMDBfMDAwMAorICoKKyAqIEcwLi5HMyAtIEdSUyBtdXggY29uc3RyYWludHMKKyAqICAgICA0Ni00NzogR1JTX0wyU0VMIHZhbHVlCisgKiAgICAgNDQtNDU6IEdSU19MM1NFTCB2YWx1ZQorICogICAgIDQxLTQ0OiBHUlNfTUNTRUwgdmFsdWUKKyAqICAgICAzOS00MDogR1JTX0ZBQlNFTCB2YWx1ZQorICoJTm90ZSB0aGF0IHRoZXNlIG1hdGNoIHVwIHdpdGggdGhlaXIgYml0IHBvc2l0aW9ucyBpbiBNTUNSMQorICoKKyAqIFVDIC0gdW5pdCBjb25zdHJhaW50OiBjYW4ndCBoYXZlIGFsbCB0aHJlZSBvZiBGUFV8SUZVfElTVTEsIElTVTAsIElEVXxHUlMKKyAqICAgICAzNzogVUMzIGVycm9yIDB4MjBfMDAwMF8wMDAwCisgKiAgICAgMzY6IEZQVXxJRlV8SVNVMSBldmVudHMgbmVlZGVkIDB4MTBfMDAwMF8wMDAwCisgKiAgICAgMzU6IElTVTAgZXZlbnRzIG5lZWRlZCAweDA4XzAwMDBfMDAwMAorICogICAgIDM0OiBJRFV8R1JTIGV2ZW50cyBuZWVkZWQgMHgwNF8wMDAwXzAwMDAKKyAqCisgKiBQUzEKKyAqICAgICAzMzogUFMxIGVycm9yIDB4Ml8wMDAwXzAwMDAKKyAqICAgICAzMS0zMjogY291bnQgb2YgZXZlbnRzIG5lZWRpbmcgUE1DMS8yIDB4MV84MDAwXzAwMDAKKyAqCisgKiBQUzIKKyAqICAgICAzMDogUFMyIGVycm9yIDB4NDAwMF8wMDAwCisgKiAgICAgMjgtMjk6IGNvdW50IG9mIGV2ZW50cyBuZWVkaW5nIFBNQzMvNCAweDMwMDBfMDAwMAorICoKKyAqIEIwCisgKiAgICAgMjQtMjc6IEJ5dGUgMCBldmVudCBzb3VyY2UgMHgwZjAwXzAwMDAKKyAqCSAgICAgIEVuY29kaW5nIGFzIGZvciB0aGUgZXZlbnQgY29kZQorICoKKyAqIEIxLCBCMiwgQjMKKyAqICAgICAyMC0yMywgMTYtMTksIDEyLTE1OiBCeXRlIDEsIDIsIDMgZXZlbnQgc291cmNlcworICoKKyAqIFAxLi5QNgorICogICAgIDAtMTE6IENvdW50IG9mIGV2ZW50cyBuZWVkaW5nIFBNQzEuLlBNQzYKKyAqLworCitzdGF0aWMgY29uc3QgaW50IGdyc2VsX3NoaWZ0WzhdID0geworCU1NQ1IxX0dSU19MMlNFTF9TSCwgTU1DUjFfR1JTX0wyU0VMX1NILCBNTUNSMV9HUlNfTDJTRUxfU0gsCisJTU1DUjFfR1JTX0wzU0VMX1NILCBNTUNSMV9HUlNfTDNTRUxfU0gsIE1NQ1IxX0dSU19MM1NFTF9TSCwKKwlNTUNSMV9HUlNfTUNTRUxfU0gsIE1NQ1IxX0dSU19GQUJTRUxfU0gKK307CisKKy8qIE1hc2tzIGFuZCB2YWx1ZXMgZm9yIHVzaW5nIGV2ZW50cyBmcm9tIHRoZSB2YXJpb3VzIHVuaXRzICovCitzdGF0aWMgdTY0IHVuaXRfY29uc1tQTV9MQVNUVU5JVCsxXVsyXSA9IHsKKwlbUE1fRlBVXSA9ICAgeyAweGMwMDAyMDAwMDAwMDAwdWxsLCAweDAwMDAxMDAwMDAwMDAwdWxsIH0sCisJW1BNX0lTVTBdID0gIHsgMHgwMDAwMjAwMDAwMDAwMHVsbCwgMHgwMDAwMDgwMDAwMDAwMHVsbCB9LAorCVtQTV9JU1UxXSA9ICB7IDB4YzAwMDIwMDAwMDAwMDB1bGwsIDB4YzAwMDEwMDAwMDAwMDB1bGwgfSwKKwlbUE1fSUZVXSA9ICAgeyAweGMwMDAyMDAwMDAwMDAwdWxsLCAweDgwMDAxMDAwMDAwMDAwdWxsIH0sCisJW1BNX0lEVV0gPSAgIHsgMHgzMDAwMjAwMDAwMDAwMHVsbCwgMHgwMDAwMDQwMDAwMDAwMHVsbCB9LAorCVtQTV9HUlNdID0gICB7IDB4MzAwMDIwMDAwMDAwMDB1bGwsIDB4MzAwMDA0MDAwMDAwMDB1bGwgfSwKK307CisKK3N0YXRpYyBpbnQgcG93ZXI1X2dldF9jb25zdHJhaW50KHU2NCBldmVudCwgdTY0ICptYXNrcCwgdTY0ICp2YWxwKQoreworCWludCBwbWMsIGJ5dGUsIHVuaXQsIHNoOworCWludCBiaXQsIGZtYXNrOworCXU2NCBtYXNrID0gMCwgdmFsdWUgPSAwOworCWludCBncnAgPSAtMTsKKworCXBtYyA9IChldmVudCA+PiBQTV9QTUNfU0gpICYgUE1fUE1DX01TSzsKKwlpZiAocG1jKSB7CisJCWlmIChwbWMgPiA2KQorCQkJcmV0dXJuIC0xOworCQlzaCA9IChwbWMgLSAxKSAqIDI7CisJCW1hc2sgfD0gMiA8PCBzaDsKKwkJdmFsdWUgfD0gMSA8PCBzaDsKKwkJaWYgKHBtYyA8PSA0KQorCQkJZ3JwID0gKHBtYyAtIDEpID4+IDE7CisJCWVsc2UgaWYgKGV2ZW50ICE9IDB4NTAwMDA5ICYmIGV2ZW50ICE9IDB4NjAwMDA1KQorCQkJcmV0dXJuIC0xOworCX0KKwlpZiAoZXZlbnQgJiBQTV9CVVNFVkVOVF9NU0spIHsKKwkJdW5pdCA9IChldmVudCA+PiBQTV9VTklUX1NIKSAmIFBNX1VOSVRfTVNLOworCQlpZiAodW5pdCA+IFBNX0xBU1RVTklUKQorCQkJcmV0dXJuIC0xOworCQlpZiAodW5pdCA9PSBQTV9JU1UwX0FMVCkKKwkJCXVuaXQgPSBQTV9JU1UwOworCQltYXNrIHw9IHVuaXRfY29uc1t1bml0XVswXTsKKwkJdmFsdWUgfD0gdW5pdF9jb25zW3VuaXRdWzFdOworCQlieXRlID0gKGV2ZW50ID4+IFBNX0JZVEVfU0gpICYgUE1fQllURV9NU0s7CisJCWlmIChieXRlID49IDQpIHsKKwkJCWlmICh1bml0ICE9IFBNX0xTVTEpCisJCQkJcmV0dXJuIC0xOworCQkJLyogTWFwIExTVTEgbG93IHdvcmQgKGJ5dGVzIDQtNykgdG8gdW5pdCBMU1UxKzEgKi8KKwkJCSsrdW5pdDsKKwkJCWJ5dGUgJj0gMzsKKwkJfQorCQlpZiAodW5pdCA9PSBQTV9HUlMpIHsKKwkJCWJpdCA9IGV2ZW50ICYgNzsKKwkJCWZtYXNrID0gKGJpdCA9PSA2KT8gNzogMzsKKwkJCXNoID0gZ3JzZWxfc2hpZnRbYml0XTsKKwkJCW1hc2sgfD0gKHU2NClmbWFzayA8PCBzaDsKKwkJCXZhbHVlIHw9ICh1NjQpKChldmVudCA+PiBQTV9HUlNfU0gpICYgZm1hc2spIDw8IHNoOworCQl9CisJCS8qCisJCSAqIEJ1cyBldmVudHMgb24gYnl0ZXMgMCBhbmQgMiBjYW4gYmUgY291bnRlZAorCQkgKiBvbiBQTUMxLzI7IGJ5dGVzIDEgYW5kIDMgb24gUE1DMy80LgorCQkgKi8KKwkJaWYgKCFwbWMpCisJCQlncnAgPSBieXRlICYgMTsKKwkJLyogU2V0IGJ5dGUgbGFuZSBzZWxlY3QgZmllbGQgKi8KKwkJbWFzayAgfD0gMHhmVUxMIDw8ICgyNCAtIDQgKiBieXRlKTsKKwkJdmFsdWUgfD0gKHU2NCl1bml0IDw8ICgyNCAtIDQgKiBieXRlKTsKKwl9CisJaWYgKGdycCA9PSAwKSB7CisJCS8qIGluY3JlbWVudCBQTUMxLzIgZmllbGQgKi8KKwkJbWFzayAgfD0gMHgyMDAwMDAwMDB1bGw7CisJCXZhbHVlIHw9IDB4MDgwMDAwMDAwdWxsOworCX0gZWxzZSBpZiAoZ3JwID09IDEpIHsKKwkJLyogaW5jcmVtZW50IFBNQzMvNCBmaWVsZCAqLworCQltYXNrICB8PSAweDQwMDAwMDAwdWxsOworCQl2YWx1ZSB8PSAweDEwMDAwMDAwdWxsOworCX0KKwlpZiAocG1jIDwgNSkgeworCQkvKiBuZWVkIGEgY291bnRlciBmcm9tIFBNQzEtNCBzZXQgKi8KKwkJbWFzayAgfD0gMHg4MDAwMDAwMDAwMDAwdWxsOworCQl2YWx1ZSB8PSAweDEwMDAwMDAwMDAwMDB1bGw7CisJfQorCSptYXNrcCA9IG1hc2s7CisJKnZhbHAgPSB2YWx1ZTsKKwlyZXR1cm4gMDsKK30KKworI2RlZmluZSBNQVhfQUxUCTMJLyogYXQgbW9zdCAzIGFsdGVybmF0aXZlcyBmb3IgYW55IGV2ZW50ICovCisKK3N0YXRpYyBjb25zdCB1bnNpZ25lZCBpbnQgZXZlbnRfYWx0ZXJuYXRpdmVzW11bTUFYX0FMVF0gPSB7CisJeyAweDEyMGU0LCAgMHg0MDAwMDIgfSwJCQkvKiBQTV9HUlBfRElTUF9SRUpFQ1QgKi8KKwl7IDB4NDEwYzcsICAweDQ0MTA4NCB9LAkJCS8qIFBNX1RIUkRfTDJNSVNTX0JPVEhfQ1lDICovCisJeyAweDEwMDAwNSwgMHg2MDAwMDUgfSwJCQkvKiBQTV9SVU5fQ1lDICovCisJeyAweDEwMDAwOSwgMHgyMDAwMDksIDB4NTAwMDA5IH0sCS8qIFBNX0lOU1RfQ01QTCAqLworCXsgMHgzMDAwMDksIDB4NDAwMDA5IH0sCQkJLyogUE1fSU5TVF9ESVNQICovCit9OworCisvKgorICogU2NhbiB0aGUgYWx0ZXJuYXRpdmVzIHRhYmxlIGZvciBhIG1hdGNoIGFuZCByZXR1cm4gdGhlCisgKiBpbmRleCBpbnRvIHRoZSBhbHRlcm5hdGl2ZXMgdGFibGUgaWYgZm91bmQsIGVsc2UgLTEuCisgKi8KK3N0YXRpYyBpbnQgZmluZF9hbHRlcm5hdGl2ZSh1NjQgZXZlbnQpCit7CisJaW50IGksIGo7CisKKwlmb3IgKGkgPSAwOyBpIDwgQVJSQVlfU0laRShldmVudF9hbHRlcm5hdGl2ZXMpOyArK2kpIHsKKwkJaWYgKGV2ZW50IDwgZXZlbnRfYWx0ZXJuYXRpdmVzW2ldWzBdKQorCQkJYnJlYWs7CisJCWZvciAoaiA9IDA7IGogPCBNQVhfQUxUICYmIGV2ZW50X2FsdGVybmF0aXZlc1tpXVtqXTsgKytqKQorCQkJaWYgKGV2ZW50ID09IGV2ZW50X2FsdGVybmF0aXZlc1tpXVtqXSkKKwkJCQlyZXR1cm4gaTsKKwl9CisJcmV0dXJuIC0xOworfQorCitzdGF0aWMgY29uc3QgdW5zaWduZWQgY2hhciBieXRlZGVjb2RlX2FsdGVybmF0aXZlc1s0XVs0XSA9IHsKKwkvKiBQTUMgMSAqLwl7IDB4MjEsIDB4MjMsIDB4MjUsIDB4MjcgfSwKKwkvKiBQTUMgMiAqLwl7IDB4MDcsIDB4MTcsIDB4MGUsIDB4MWUgfSwKKwkvKiBQTUMgMyAqLwl7IDB4MjAsIDB4MjIsIDB4MjQsIDB4MjYgfSwKKwkvKiBQTUMgNCAqLwl7IDB4MDcsIDB4MTcsIDB4MGUsIDB4MWUgfQorfTsKKworLyoKKyAqIFNvbWUgZGlyZWN0IGV2ZW50cyBmb3IgZGVjb2RlcyBvZiBldmVudCBidXMgYnl0ZSAzIGhhdmUgYWx0ZXJuYXRpdmUKKyAqIFBNQ1NFTCB2YWx1ZXMgb24gb3RoZXIgY291bnRlcnMuICBUaGlzIHJldHVybnMgdGhlIGFsdGVybmF0aXZlCisgKiBldmVudCBjb2RlIGZvciB0aG9zZSB0aGF0IGRvLCBvciAtMSBvdGhlcndpc2UuCisgKi8KK3N0YXRpYyBzNjQgZmluZF9hbHRlcm5hdGl2ZV9iZGVjb2RlKHU2NCBldmVudCkKK3sKKwlpbnQgcG1jLCBhbHRwbWMsIHBwLCBqOworCisJcG1jID0gKGV2ZW50ID4+IFBNX1BNQ19TSCkgJiBQTV9QTUNfTVNLOworCWlmIChwbWMgPT0gMCB8fCBwbWMgPiA0KQorCQlyZXR1cm4gLTE7CisJYWx0cG1jID0gNSAtIHBtYzsJLyogMSA8LT4gNCwgMiA8LT4gMyAqLworCXBwID0gZXZlbnQgJiBQTV9QTUNTRUxfTVNLOworCWZvciAoaiA9IDA7IGogPCA0OyArK2opIHsKKwkJaWYgKGJ5dGVkZWNvZGVfYWx0ZXJuYXRpdmVzW3BtYyAtIDFdW2pdID09IHBwKSB7CisJCQlyZXR1cm4gKGV2ZW50ICYgfihQTV9QTUNfTVNLUyB8IFBNX1BNQ1NFTF9NU0spKSB8CisJCQkJKGFsdHBtYyA8PCBQTV9QTUNfU0gpIHwKKwkJCQlieXRlZGVjb2RlX2FsdGVybmF0aXZlc1thbHRwbWMgLSAxXVtqXTsKKwkJfQorCX0KKwlyZXR1cm4gLTE7Cit9CisKK3N0YXRpYyBpbnQgcG93ZXI1X2dldF9hbHRlcm5hdGl2ZXModTY0IGV2ZW50LCB1bnNpZ25lZCBpbnQgZmxhZ3MsIHU2NCBhbHRbXSkKK3sKKwlpbnQgaSwgaiwgbmFsdCA9IDE7CisJczY0IGFlOworCisJYWx0WzBdID0gZXZlbnQ7CisJbmFsdCA9IDE7CisJaSA9IGZpbmRfYWx0ZXJuYXRpdmUoZXZlbnQpOworCWlmIChpID49IDApIHsKKwkJZm9yIChqID0gMDsgaiA8IE1BWF9BTFQ7ICsraikgeworCQkJYWUgPSBldmVudF9hbHRlcm5hdGl2ZXNbaV1bal07CisJCQlpZiAoYWUgJiYgYWUgIT0gZXZlbnQpCisJCQkJYWx0W25hbHQrK10gPSBhZTsKKwkJfQorCX0gZWxzZSB7CisJCWFlID0gZmluZF9hbHRlcm5hdGl2ZV9iZGVjb2RlKGV2ZW50KTsKKwkJaWYgKGFlID4gMCkKKwkJCWFsdFtuYWx0KytdID0gYWU7CisJfQorCXJldHVybiBuYWx0OworfQorCisvKgorICogTWFwIG9mIHdoaWNoIGRpcmVjdCBldmVudHMgb24gd2hpY2ggUE1DcyBhcmUgbWFya2VkIGluc3RydWN0aW9uIGV2ZW50cy4KKyAqIEluZGV4ZWQgYnkgUE1DU0VMIHZhbHVlLCBiaXQgaSAoTEUpIHNldCBpZiBQTUMgaSBpcyBhIG1hcmtlZCBldmVudC4KKyAqIEJpdCAwIGlzIHNldCBpZiBpdCBpcyBtYXJrZWQgZm9yIGFsbCBQTUNzLgorICogVGhlIDB4ODAgYml0IGluZGljYXRlcyBhIGJ5dGUgZGVjb2RlIFBNQ1NFTCB2YWx1ZS4KKyAqLworc3RhdGljIHVuc2lnbmVkIGNoYXIgZGlyZWN0X2V2ZW50X2lzX21hcmtlZFsweDI4XSA9IHsKKwkwLAkvKiAwMCAqLworCTB4MWYsCS8qIDAxIFBNX0lPUFNfQ01QTCAqLworCTB4MiwJLyogMDIgUE1fTVJLX0dSUF9ESVNQICovCisJMHhlLAkvKiAwMyBQTV9NUktfU1RfQ01QTCwgUE1fTVJLX1NUX0dQUywgUE1fTVJLX1NUX0NNUExfSU5UICovCisJMCwJLyogMDQgKi8KKwkweDFjLAkvKiAwNSBQTV9NUktfQlJVX0ZJTiwgUE1fTVJLX0lOU1RfRklOLCBQTV9NUktfQ1JVX0ZJTiAqLworCTB4ODAsCS8qIDA2ICovCisJMHg4MCwJLyogMDcgKi8KKwkwLCAwLCAwLC8qIDA4IC0gMGEgKi8KKwkweDE4LAkvKiAwYiBQTV9USFJFU0hfVElNRU8sIFBNX01SS19HUlBfVElNRU8gKi8KKwkwLAkvKiAwYyAqLworCTB4ODAsCS8qIDBkICovCisJMHg4MCwJLyogMGUgKi8KKwkwLAkvKiAwZiAqLworCTAsCS8qIDEwICovCisJMHgxNCwJLyogMTEgUE1fTVJLX0dSUF9CUl9SRURJUiwgUE1fTVJLX0dSUF9JQ19NSVNTICovCisJMCwJLyogMTIgKi8KKwkweDEwLAkvKiAxMyBQTV9NUktfR1JQX0NNUEwgKi8KKwkweDFmLAkvKiAxNCBQTV9HUlBfTVJLLCBQTV9NUktfe0ZYVSxGUFUsTFNVfV9GSU4gKi8KKwkweDIsCS8qIDE1IFBNX01SS19HUlBfSVNTVUVEICovCisJMHg4MCwJLyogMTYgKi8KKwkweDgwLAkvKiAxNyAqLworCTAsIDAsIDAsIDAsIDAsCisJMHg4MCwJLyogMWQgKi8KKwkweDgwLAkvKiAxZSAqLworCTAsCS8qIDFmICovCisJMHg4MCwJLyogMjAgKi8KKwkweDgwLAkvKiAyMSAqLworCTB4ODAsCS8qIDIyICovCisJMHg4MCwJLyogMjMgKi8KKwkweDgwLAkvKiAyNCAqLworCTB4ODAsCS8qIDI1ICovCisJMHg4MCwJLyogMjYgKi8KKwkweDgwLAkvKiAyNyAqLworfTsKKworLyoKKyAqIFJldHVybnMgMSBpZiBldmVudCBjb3VudHMgdGhpbmdzIHJlbGF0aW5nIHRvIG1hcmtlZCBpbnN0cnVjdGlvbnMKKyAqIGFuZCB0aHVzIG5lZWRzIHRoZSBNTUNSQV9TQU1QTEVfRU5BQkxFIGJpdCBzZXQsIG9yIDAgaWYgbm90LgorICovCitzdGF0aWMgaW50IHBvd2VyNV9tYXJrZWRfaW5zdHJfZXZlbnQodTY0IGV2ZW50KQoreworCWludCBwbWMsIHBzZWw7CisJaW50IGJpdCwgYnl0ZSwgdW5pdDsKKwl1MzIgbWFzazsKKworCXBtYyA9IChldmVudCA+PiBQTV9QTUNfU0gpICYgUE1fUE1DX01TSzsKKwlwc2VsID0gZXZlbnQgJiBQTV9QTUNTRUxfTVNLOworCWlmIChwbWMgPj0gNSkKKwkJcmV0dXJuIDA7CisKKwliaXQgPSAtMTsKKwlpZiAocHNlbCA8IHNpemVvZihkaXJlY3RfZXZlbnRfaXNfbWFya2VkKSkgeworCQlpZiAoZGlyZWN0X2V2ZW50X2lzX21hcmtlZFtwc2VsXSAmICgxIDw8IHBtYykpCisJCQlyZXR1cm4gMTsKKwkJaWYgKGRpcmVjdF9ldmVudF9pc19tYXJrZWRbcHNlbF0gJiAweDgwKQorCQkJYml0ID0gNDsKKwkJZWxzZSBpZiAocHNlbCA9PSAweDA4KQorCQkJYml0ID0gcG1jIC0gMTsKKwkJZWxzZSBpZiAocHNlbCA9PSAweDEwKQorCQkJYml0ID0gNCAtIHBtYzsKKwkJZWxzZSBpZiAocHNlbCA9PSAweDFiICYmIChwbWMgPT0gMSB8fCBwbWMgPT0gMykpCisJCQliaXQgPSA0OworCX0gZWxzZSBpZiAoKHBzZWwgJiAweDU4KSA9PSAweDQwKQorCQliaXQgPSBwc2VsICYgNzsKKworCWlmICghKGV2ZW50ICYgUE1fQlVTRVZFTlRfTVNLKSkKKwkJcmV0dXJuIDA7CisKKwlieXRlID0gKGV2ZW50ID4+IFBNX0JZVEVfU0gpICYgUE1fQllURV9NU0s7CisJdW5pdCA9IChldmVudCA+PiBQTV9VTklUX1NIKSAmIFBNX1VOSVRfTVNLOworCWlmICh1bml0ID09IFBNX0xTVTApIHsKKwkJLyogYnl0ZSAxIGJpdHMgMC03LCBieXRlIDIgYml0cyAwLDItNCw2ICovCisJCW1hc2sgPSAweDVkZmYwMDsKKwl9IGVsc2UgaWYgKHVuaXQgPT0gUE1fTFNVMSAmJiBieXRlID49IDQpIHsKKwkJYnl0ZSAtPSA0OworCQkvKiBieXRlIDQgYml0cyAxLDMsNSw3LCBieXRlIDUgYml0cyA2LTcsIGJ5dGUgNyBiaXRzIDAtNCw2ICovCisJCW1hc2sgPSAweDVmMDBjMGFhOworCX0gZWxzZQorCQlyZXR1cm4gMDsKKworCXJldHVybiAobWFzayA+PiAoYnl0ZSAqIDggKyBiaXQpKSAmIDE7Cit9CisKK3N0YXRpYyBpbnQgcG93ZXI1X2NvbXB1dGVfbW1jcih1NjQgZXZlbnRbXSwgaW50IG5fZXYsCisJCQkgICAgICAgdW5zaWduZWQgaW50IGh3Y1tdLCB1NjQgbW1jcltdKQoreworCXU2NCBtbWNyMSA9IDA7CisJdTY0IG1tY3JhID0gMDsKKwl1bnNpZ25lZCBpbnQgcG1jLCB1bml0LCBieXRlLCBwc2VsOworCXVuc2lnbmVkIGludCB0dG0sIGdycDsKKwlpbnQgaSwgaXNidXMsIGJpdCwgZ3JzZWw7CisJdW5zaWduZWQgaW50IHBtY19pbnVzZSA9IDA7CisJdW5zaWduZWQgaW50IHBtY19ncnBfdXNlWzJdOworCXVuc2lnbmVkIGNoYXIgYnVzYnl0ZVs0XTsKKwl1bnNpZ25lZCBjaGFyIHVuaXR1c2VbMTZdOworCWludCB0dG11c2U7CisKKwlpZiAobl9ldiA+IDYpCisJCXJldHVybiAtMTsKKworCS8qIEZpcnN0IHBhc3MgdG8gY291bnQgcmVzb3VyY2UgdXNlICovCisJcG1jX2dycF91c2VbMF0gPSBwbWNfZ3JwX3VzZVsxXSA9IDA7CisJbWVtc2V0KGJ1c2J5dGUsIDAsIHNpemVvZihidXNieXRlKSk7CisJbWVtc2V0KHVuaXR1c2UsIDAsIHNpemVvZih1bml0dXNlKSk7CisJZm9yIChpID0gMDsgaSA8IG5fZXY7ICsraSkgeworCQlwbWMgPSAoZXZlbnRbaV0gPj4gUE1fUE1DX1NIKSAmIFBNX1BNQ19NU0s7CisJCWlmIChwbWMpIHsKKwkJCWlmIChwbWMgPiA2KQorCQkJCXJldHVybiAtMTsKKwkJCWlmIChwbWNfaW51c2UgJiAoMSA8PCAocG1jIC0gMSkpKQorCQkJCXJldHVybiAtMTsKKwkJCXBtY19pbnVzZSB8PSAxIDw8IChwbWMgLSAxKTsKKwkJCS8qIGNvdW50IDEvMiB2cyAzLzQgdXNlICovCisJCQlpZiAocG1jIDw9IDQpCisJCQkJKytwbWNfZ3JwX3VzZVsocG1jIC0gMSkgPj4gMV07CisJCX0KKwkJaWYgKGV2ZW50W2ldICYgUE1fQlVTRVZFTlRfTVNLKSB7CisJCQl1bml0ID0gKGV2ZW50W2ldID4+IFBNX1VOSVRfU0gpICYgUE1fVU5JVF9NU0s7CisJCQlieXRlID0gKGV2ZW50W2ldID4+IFBNX0JZVEVfU0gpICYgUE1fQllURV9NU0s7CisJCQlpZiAodW5pdCA+IFBNX0xBU1RVTklUKQorCQkJCXJldHVybiAtMTsKKwkJCWlmICh1bml0ID09IFBNX0lTVTBfQUxUKQorCQkJCXVuaXQgPSBQTV9JU1UwOworCQkJaWYgKGJ5dGUgPj0gNCkgeworCQkJCWlmICh1bml0ICE9IFBNX0xTVTEpCisJCQkJCXJldHVybiAtMTsKKwkJCQkrK3VuaXQ7CisJCQkJYnl0ZSAmPSAzOworCQkJfQorCQkJaWYgKCFwbWMpCisJCQkJKytwbWNfZ3JwX3VzZVtieXRlICYgMV07CisJCQlpZiAoYnVzYnl0ZVtieXRlXSAmJiBidXNieXRlW2J5dGVdICE9IHVuaXQpCisJCQkJcmV0dXJuIC0xOworCQkJYnVzYnl0ZVtieXRlXSA9IHVuaXQ7CisJCQl1bml0dXNlW3VuaXRdID0gMTsKKwkJfQorCX0KKwlpZiAocG1jX2dycF91c2VbMF0gPiAyIHx8IHBtY19ncnBfdXNlWzFdID4gMikKKwkJcmV0dXJuIC0xOworCisJLyoKKwkgKiBBc3NpZ24gcmVzb3VyY2VzIGFuZCBzZXQgbXVsdGlwbGV4ZXIgc2VsZWN0cy4KKwkgKgorCSAqIFBNX0lTVTAgY2FuIGdvIGVpdGhlciBvbiBUVE0wIG9yIFRUTTEsIGJ1dCB0aGF0J3MgdGhlIG9ubHkKKwkgKiBjaG9pY2Ugd2UgaGF2ZSB0byBkZWFsIHdpdGguCisJICovCisJaWYgKHVuaXR1c2VbUE1fSVNVMF0gJgorCSAgICAodW5pdHVzZVtQTV9GUFVdIHwgdW5pdHVzZVtQTV9JRlVdIHwgdW5pdHVzZVtQTV9JU1UxXSkpIHsKKwkJdW5pdHVzZVtQTV9JU1UwX0FMVF0gPSAxOwkvKiBtb3ZlIElTVSB0byBUVE0xICovCisJCXVuaXR1c2VbUE1fSVNVMF0gPSAwOworCX0KKwkvKiBTZXQgVFRNWzAxXVNFTCBmaWVsZHMuICovCisJdHRtdXNlID0gMDsKKwlmb3IgKGkgPSBQTV9GUFU7IGkgPD0gUE1fSVNVMTsgKytpKSB7CisJCWlmICghdW5pdHVzZVtpXSkKKwkJCWNvbnRpbnVlOworCQlpZiAodHRtdXNlKyspCisJCQlyZXR1cm4gLTE7CisJCW1tY3IxIHw9ICh1NjQpaSA8PCBNTUNSMV9UVE0wU0VMX1NIOworCX0KKwl0dG11c2UgPSAwOworCWZvciAoOyBpIDw9IFBNX0dSUzsgKytpKSB7CisJCWlmICghdW5pdHVzZVtpXSkKKwkJCWNvbnRpbnVlOworCQlpZiAodHRtdXNlKyspCisJCQlyZXR1cm4gLTE7CisJCW1tY3IxIHw9ICh1NjQpKGkgJiAzKSA8PCBNTUNSMV9UVE0xU0VMX1NIOworCX0KKwlpZiAodHRtdXNlID4gMSkKKwkJcmV0dXJuIC0xOworCisJLyogU2V0IGJ5dGUgbGFuZSBzZWxlY3QgZmllbGRzLCBUVE1bMjNdU0VMIGFuZCBHUlNfKlNFTC4gKi8KKwlmb3IgKGJ5dGUgPSAwOyBieXRlIDwgNDsgKytieXRlKSB7CisJCXVuaXQgPSBidXNieXRlW2J5dGVdOworCQlpZiAoIXVuaXQpCisJCQljb250aW51ZTsKKwkJaWYgKHVuaXQgPT0gUE1fSVNVMCAmJiB1bml0dXNlW1BNX0lTVTBfQUxUXSkgeworCQkJLyogZ2V0IElTVTAgdGhyb3VnaCBUVE0xIHJhdGhlciB0aGFuIFRUTTAgKi8KKwkJCXVuaXQgPSBQTV9JU1UwX0FMVDsKKwkJfSBlbHNlIGlmICh1bml0ID09IFBNX0xTVTEgKyAxKSB7CisJCQkvKiBzZWxlY3QgbG93ZXIgd29yZCBvZiBMU1UxIGZvciB0aGlzIGJ5dGUgKi8KKwkJCW1tY3IxIHw9IDF1bGwgPDwgKE1NQ1IxX1RUTTNTRUxfU0ggKyAzIC0gYnl0ZSk7CisJCX0KKwkJdHRtID0gdW5pdCA+PiAyOworCQltbWNyMSB8PSAodTY0KXR0bSA8PCAoTU1DUjFfVERfQ1BfREJHMFNFTF9TSCAtIDIgKiBieXRlKTsKKwl9CisKKwkvKiBTZWNvbmQgcGFzczogYXNzaWduIFBNQ3MsIHNldCBQTUN4U0VMIGFuZCBQTUN4X0FEREVSX1NFTCBmaWVsZHMgKi8KKwlmb3IgKGkgPSAwOyBpIDwgbl9ldjsgKytpKSB7CisJCXBtYyA9IChldmVudFtpXSA+PiBQTV9QTUNfU0gpICYgUE1fUE1DX01TSzsKKwkJdW5pdCA9IChldmVudFtpXSA+PiBQTV9VTklUX1NIKSAmIFBNX1VOSVRfTVNLOworCQlieXRlID0gKGV2ZW50W2ldID4+IFBNX0JZVEVfU0gpICYgUE1fQllURV9NU0s7CisJCXBzZWwgPSBldmVudFtpXSAmIFBNX1BNQ1NFTF9NU0s7CisJCWlzYnVzID0gZXZlbnRbaV0gJiBQTV9CVVNFVkVOVF9NU0s7CisJCWlmICghcG1jKSB7CisJCQkvKiBCdXMgZXZlbnQgb3IgYW55LVBNQyBkaXJlY3QgZXZlbnQgKi8KKwkJCWZvciAocG1jID0gMDsgcG1jIDwgNDsgKytwbWMpIHsKKwkJCQlpZiAocG1jX2ludXNlICYgKDEgPDwgcG1jKSkKKwkJCQkJY29udGludWU7CisJCQkJZ3JwID0gKHBtYyA+PiAxKSAmIDE7CisJCQkJaWYgKGlzYnVzKSB7CisJCQkJCWlmIChncnAgPT0gKGJ5dGUgJiAxKSkKKwkJCQkJCWJyZWFrOworCQkJCX0gZWxzZSBpZiAocG1jX2dycF91c2VbZ3JwXSA8IDIpIHsKKwkJCQkJKytwbWNfZ3JwX3VzZVtncnBdOworCQkJCQlicmVhazsKKwkJCQl9CisJCQl9CisJCQlwbWNfaW51c2UgfD0gMSA8PCBwbWM7CisJCX0gZWxzZSBpZiAocG1jIDw9IDQpIHsKKwkJCS8qIERpcmVjdCBldmVudCAqLworCQkJLS1wbWM7CisJCQlpZiAoKHBzZWwgPT0gOCB8fCBwc2VsID09IDB4MTApICYmIGlzYnVzICYmIChieXRlICYgMikpCisJCQkJLyogYWRkIGV2ZW50cyBvbiBoaWdoZXItbnVtYmVyZWQgYnVzICovCisJCQkJbW1jcjEgfD0gMXVsbCA8PCAoTU1DUjFfUE1DMV9BRERFUl9TRUxfU0ggLSBwbWMpOworCQl9IGVsc2UgeworCQkJLyogSW5zdHJ1Y3Rpb25zIG9yIHJ1biBjeWNsZXMgb24gUE1DNS82ICovCisJCQktLXBtYzsKKwkJfQorCQlpZiAoaXNidXMgJiYgdW5pdCA9PSBQTV9HUlMpIHsKKwkJCWJpdCA9IHBzZWwgJiA3OworCQkJZ3JzZWwgPSAoZXZlbnRbaV0gPj4gUE1fR1JTX1NIKSAmIFBNX0dSU19NU0s7CisJCQltbWNyMSB8PSAodTY0KWdyc2VsIDw8IGdyc2VsX3NoaWZ0W2JpdF07CisJCX0KKwkJaWYgKHBvd2VyNV9tYXJrZWRfaW5zdHJfZXZlbnQoZXZlbnRbaV0pKQorCQkJbW1jcmEgfD0gTU1DUkFfU0FNUExFX0VOQUJMRTsKKwkJaWYgKHBtYyA8PSAzKQorCQkJbW1jcjEgfD0gcHNlbCA8PCBNTUNSMV9QTUNTRUxfU0gocG1jKTsKKwkJaHdjW2ldID0gcG1jOworCX0KKworCS8qIFJldHVybiBNTUNSeCB2YWx1ZXMgKi8KKwltbWNyWzBdID0gMDsKKwlpZiAocG1jX2ludXNlICYgMSkKKwkJbW1jclswXSA9IE1NQ1IwX1BNQzFDRTsKKwlpZiAocG1jX2ludXNlICYgMHgzZSkKKwkJbW1jclswXSB8PSBNTUNSMF9QTUNqQ0U7CisJbW1jclsxXSA9IG1tY3IxOworCW1tY3JbMl0gPSBtbWNyYTsKKwlyZXR1cm4gMDsKK30KKworc3RhdGljIHZvaWQgcG93ZXI1X2Rpc2FibGVfcG1jKHVuc2lnbmVkIGludCBwbWMsIHU2NCBtbWNyW10pCit7CisJaWYgKHBtYyA8PSAzKQorCQltbWNyWzFdICY9IH4oMHg3ZlVMIDw8IE1NQ1IxX1BNQ1NFTF9TSChwbWMpKTsKK30KKworc3RhdGljIGludCBwb3dlcjVfZ2VuZXJpY19ldmVudHNbXSA9IHsKKwlbUEVSRl9DT1VOVF9IV19DUFVfQ1lDTEVTXQkJPSAweGYsCisJW1BFUkZfQ09VTlRfSFdfSU5TVFJVQ1RJT05TXQkJPSAweDEwMDAwOSwKKwlbUEVSRl9DT1VOVF9IV19DQUNIRV9SRUZFUkVOQ0VTXQk9IDB4NGMxMDkwLCAvKiBMRF9SRUZfTDEgKi8KKwlbUEVSRl9DT1VOVF9IV19DQUNIRV9NSVNTRVNdCQk9IDB4M2MxMDg4LCAvKiBMRF9NSVNTX0wxICovCisJW1BFUkZfQ09VTlRfSFdfQlJBTkNIX0lOU1RSVUNUSU9OU10JPSAweDIzMGU0LCAgLyogQlJfSVNTVUVEICovCisJW1BFUkZfQ09VTlRfSFdfQlJBTkNIX01JU1NFU10JCT0gMHgyMzBlNSwgIC8qIEJSX01QUkVEX0NSICovCit9OworCisjZGVmaW5lIEMoeCkJUEVSRl9DT1VOVF9IV19DQUNIRV8jI3gKKworLyoKKyAqIFRhYmxlIG9mIGdlbmVyYWxpemVkIGNhY2hlLXJlbGF0ZWQgZXZlbnRzLgorICogMCBtZWFucyBub3Qgc3VwcG9ydGVkLCAtMSBtZWFucyBub25zZW5zaWNhbCwgb3RoZXIgdmFsdWVzCisgKiBhcmUgZXZlbnQgY29kZXMuCisgKi8KK3N0YXRpYyBpbnQgcG93ZXI1X2NhY2hlX2V2ZW50c1tDKE1BWCldW0MoT1BfTUFYKV1bQyhSRVNVTFRfTUFYKV0gPSB7CisJW0MoTDFEKV0gPSB7CQkvKiAJUkVTVUxUX0FDQ0VTUwlSRVNVTFRfTUlTUyAqLworCQlbQyhPUF9SRUFEKV0gPSB7CTB4NGMxMDkwLAkweDNjMTA4OAl9LAorCQlbQyhPUF9XUklURSldID0gewkweDNjMTA5MCwJMHhjMTBjMwkJfSwKKwkJW0MoT1BfUFJFRkVUQ0gpXSA9IHsJMHhjNzBlNywJMAkJfSwKKwl9LAorCVtDKEwxSSldID0gewkJLyogCVJFU1VMVF9BQ0NFU1MJUkVTVUxUX01JU1MgKi8KKwkJW0MoT1BfUkVBRCldID0gewkwLAkJMAkJfSwKKwkJW0MoT1BfV1JJVEUpXSA9IHsJLTEsCQktMQkJfSwKKwkJW0MoT1BfUFJFRkVUQ0gpXSA9IHsJMCwJCTAJCX0sCisJfSwKKwlbQyhMTCldID0gewkJLyogCVJFU1VMVF9BQ0NFU1MJUkVTVUxUX01JU1MgKi8KKwkJW0MoT1BfUkVBRCldID0gewkwLAkJMHgzYzMwOWIJfSwKKwkJW0MoT1BfV1JJVEUpXSA9IHsJMCwJCTAJCX0sCisJCVtDKE9QX1BSRUZFVENIKV0gPSB7CTB4YzUwYzMsCTAJCX0sCisJfSwKKwlbQyhEVExCKV0gPSB7CQkvKiAJUkVTVUxUX0FDQ0VTUwlSRVNVTFRfTUlTUyAqLworCQlbQyhPUF9SRUFEKV0gPSB7CTB4MmM0MDkwLAkweDgwMGM0CQl9LAorCQlbQyhPUF9XUklURSldID0gewktMSwJCS0xCQl9LAorCQlbQyhPUF9QUkVGRVRDSCldID0gewktMSwJCS0xCQl9LAorCX0sCisJW0MoSVRMQildID0gewkJLyogCVJFU1VMVF9BQ0NFU1MJUkVTVUxUX01JU1MgKi8KKwkJW0MoT1BfUkVBRCldID0gewkwLAkJMHg4MDBjMAkJfSwKKwkJW0MoT1BfV1JJVEUpXSA9IHsJLTEsCQktMQkJfSwKKwkJW0MoT1BfUFJFRkVUQ0gpXSA9IHsJLTEsCQktMQkJfSwKKwl9LAorCVtDKEJQVSldID0gewkJLyogCVJFU1VMVF9BQ0NFU1MJUkVTVUxUX01JU1MgKi8KKwkJW0MoT1BfUkVBRCldID0gewkweDIzMGU0LAkweDIzMGU1CQl9LAorCQlbQyhPUF9XUklURSldID0gewktMSwJCS0xCQl9LAorCQlbQyhPUF9QUkVGRVRDSCldID0gewktMSwJCS0xCQl9LAorCX0sCit9OworCitzdHJ1Y3QgcG93ZXJfcG11IHBvd2VyNV9wbXUgPSB7CisJLm5fY291bnRlciA9IDYsCisJLm1heF9hbHRlcm5hdGl2ZXMgPSBNQVhfQUxULAorCS5hZGRfZmllbGRzID0gMHg3MDAwMDkwMDAwNTU1dWxsLAorCS50ZXN0X2FkZGVyID0gMHgzMDAwNDkwMDAwMDAwdWxsLAorCS5jb21wdXRlX21tY3IgPSBwb3dlcjVfY29tcHV0ZV9tbWNyLAorCS5nZXRfY29uc3RyYWludCA9IHBvd2VyNV9nZXRfY29uc3RyYWludCwKKwkuZ2V0X2FsdGVybmF0aXZlcyA9IHBvd2VyNV9nZXRfYWx0ZXJuYXRpdmVzLAorCS5kaXNhYmxlX3BtYyA9IHBvd2VyNV9kaXNhYmxlX3BtYywKKwkubl9nZW5lcmljID0gQVJSQVlfU0laRShwb3dlcjVfZ2VuZXJpY19ldmVudHMpLAorCS5nZW5lcmljX2V2ZW50cyA9IHBvd2VyNV9nZW5lcmljX2V2ZW50cywKKwkuY2FjaGVfZXZlbnRzID0gJnBvd2VyNV9jYWNoZV9ldmVudHMsCit9OwpkaWZmIC0tZ2l0IGEvYXJjaC9wb3dlcnBjL2tlcm5lbC9wb3dlcjYtcG11LmMgYi9hcmNoL3Bvd2VycGMva2VybmVsL3Bvd2VyNi1wbXUuYwpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi40NmY3NGJlCi0tLSAvZGV2L251bGwKKysrIGIvYXJjaC9wb3dlcnBjL2tlcm5lbC9wb3dlcjYtcG11LmMKQEAgLTAsMCArMSw1MzIgQEAKKy8qCisgKiBQZXJmb3JtYW5jZSBjb3VudGVyIHN1cHBvcnQgZm9yIFBPV0VSNiBwcm9jZXNzb3JzLgorICoKKyAqIENvcHlyaWdodCAyMDA4LTIwMDkgUGF1bCBNYWNrZXJyYXMsIElCTSBDb3Jwb3JhdGlvbi4KKyAqCisgKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yCisgKiBtb2RpZnkgaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZQorICogYXMgcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb247IGVpdGhlciB2ZXJzaW9uCisgKiAyIG9mIHRoZSBMaWNlbnNlLCBvciAoYXQgeW91ciBvcHRpb24pIGFueSBsYXRlciB2ZXJzaW9uLgorICovCisjaW5jbHVkZSA8bGludXgva2VybmVsLmg+CisjaW5jbHVkZSA8bGludXgvcGVyZl9jb3VudGVyLmg+CisjaW5jbHVkZSA8YXNtL3JlZy5oPgorCisvKgorICogQml0cyBpbiBldmVudCBjb2RlIGZvciBQT1dFUjYKKyAqLworI2RlZmluZSBQTV9QTUNfU0gJMjAJLyogUE1DIG51bWJlciAoMS1iYXNlZCkgZm9yIGRpcmVjdCBldmVudHMgKi8KKyNkZWZpbmUgUE1fUE1DX01TSwkweDcKKyNkZWZpbmUgUE1fUE1DX01TS1MJKFBNX1BNQ19NU0sgPDwgUE1fUE1DX1NIKQorI2RlZmluZSBQTV9VTklUX1NICTE2CS8qIFVuaXQgZXZlbnQgY29tZXMgKFRUTXhTRUwgZW5jb2RpbmcpICovCisjZGVmaW5lIFBNX1VOSVRfTVNLCTB4ZgorI2RlZmluZSBQTV9VTklUX01TS1MJKFBNX1VOSVRfTVNLIDw8IFBNX1VOSVRfU0gpCisjZGVmaW5lIFBNX0xMQVYJCTB4ODAwMAkvKiBMb2FkIGxvb2thaGVhZCBtYXRjaCB2YWx1ZSAqLworI2RlZmluZSBQTV9MTEEJCTB4NDAwMAkvKiBMb2FkIGxvb2thaGVhZCBtYXRjaCBlbmFibGUgKi8KKyNkZWZpbmUgUE1fQllURV9TSAkxMgkvKiBCeXRlIG9mIGV2ZW50IGJ1cyB0byB1c2UgKi8KKyNkZWZpbmUgUE1fQllURV9NU0sJMworI2RlZmluZSBQTV9TVUJVTklUX1NICTgJLyogU3VidW5pdCBldmVudCBjb21lcyBmcm9tIChORVNUX1NFTCBlbmMuKSAqLworI2RlZmluZSBQTV9TVUJVTklUX01TSwk3CisjZGVmaW5lIFBNX1NVQlVOSVRfTVNLUwkoUE1fU1VCVU5JVF9NU0sgPDwgUE1fU1VCVU5JVF9TSCkKKyNkZWZpbmUgUE1fUE1DU0VMX01TSwkweGZmCS8qIFBNQ3hTRUwgdmFsdWUgKi8KKyNkZWZpbmUgUE1fQlVTRVZFTlRfTVNLCTB4ZjM3MDAKKworLyoKKyAqIEJpdHMgaW4gTU1DUjEgZm9yIFBPV0VSNgorICovCisjZGVmaW5lIE1NQ1IxX1RUTTBTRUxfU0gJNjAKKyNkZWZpbmUgTU1DUjFfVFRNU0VMX1NIKG4pCShNTUNSMV9UVE0wU0VMX1NIIC0gKG4pICogNCkKKyNkZWZpbmUgTU1DUjFfVFRNU0VMX01TSwkweGYKKyNkZWZpbmUgTU1DUjFfVFRNU0VMKG0sIG4pCSgoKG0pID4+IE1NQ1IxX1RUTVNFTF9TSChuKSkgJiBNTUNSMV9UVE1TRUxfTVNLKQorI2RlZmluZSBNTUNSMV9ORVNUU0VMX1NICTQ1CisjZGVmaW5lIE1NQ1IxX05FU1RTRUxfTVNLCTB4NworI2RlZmluZSBNTUNSMV9ORVNUU0VMKG0pCSgoKG0pID4+IE1NQ1IxX05FU1RTRUxfU0gpICYgTU1DUjFfTkVTVFNFTF9NU0spCisjZGVmaW5lIE1NQ1IxX1BNQzFfTExBCQkoKHU2NCkxIDw8IDQ0KQorI2RlZmluZSBNTUNSMV9QTUMxX0xMQV9WQUxVRQkoKHU2NCkxIDw8IDM5KQorI2RlZmluZSBNTUNSMV9QTUMxX0FERFJfU0VMCSgodTY0KTEgPDwgMzUpCisjZGVmaW5lIE1NQ1IxX1BNQzFTRUxfU0gJMjQKKyNkZWZpbmUgTU1DUjFfUE1DU0VMX1NIKG4pCShNTUNSMV9QTUMxU0VMX1NIIC0gKG4pICogOCkKKyNkZWZpbmUgTU1DUjFfUE1DU0VMX01TSwkweGZmCisKKy8qCisgKiBNYXAgb2Ygd2hpY2ggZGlyZWN0IGV2ZW50cyBvbiB3aGljaCBQTUNzIGFyZSBtYXJrZWQgaW5zdHJ1Y3Rpb24gZXZlbnRzLgorICogSW5kZXhlZCBieSBQTUNTRUwgdmFsdWUgPj4gMS4KKyAqIEJvdHRvbSA0IGJpdHMgYXJlIGEgbWFwIG9mIHdoaWNoIFBNQ3MgYXJlIGludGVyZXN0aW5nLAorICogdG9wIDQgYml0cyBzYXkgd2hhdCBzb3J0IG9mIGV2ZW50OgorICogICAwID0gZGlyZWN0IG1hcmtlZCBldmVudCwKKyAqICAgMSA9IGJ5dGUgZGVjb2RlIGV2ZW50LAorICogICA0ID0gYWRkL2FuZCBldmVudCAoUE1DMSAtPiBiaXRzIDAgJiA0KSwKKyAqICAgNSA9IGFkZC9hbmQgZXZlbnQgKFBNQzEgLT4gYml0cyAxICYgNSksCisgKiAgIDYgPSBhZGQvYW5kIGV2ZW50IChQTUMxIC0+IGJpdHMgMiAmIDYpLAorICogICA3ID0gYWRkL2FuZCBldmVudCAoUE1DMSAtPiBiaXRzIDMgJiA3KS4KKyAqLworc3RhdGljIHVuc2lnbmVkIGNoYXIgZGlyZWN0X2V2ZW50X2lzX21hcmtlZFsweDYwID4+IDFdID0geworCTAsCS8qIDAwICovCisJMCwJLyogMDIgKi8KKwkwLAkvKiAwNCAqLworCTB4MDcsCS8qIDA2IFBNX01SS19TVF9DTVBMLCBQTV9NUktfU1RfR1BTLCBQTV9NUktfU1RfQ01QTF9JTlQgKi8KKwkweDA0LAkvKiAwOCBQTV9NUktfREZVX0ZJTiAqLworCTB4MDYsCS8qIDBhIFBNX01SS19JRlVfRklOLCBQTV9NUktfSU5TVF9GSU4gKi8KKwkwLAkvKiAwYyAqLworCTAsCS8qIDBlICovCisJMHgwMiwJLyogMTAgUE1fTVJLX0lOU1RfRElTUCAqLworCTB4MDgsCS8qIDEyIFBNX01SS19MU1VfREVSQVRfTUlTUyAqLworCTAsCS8qIDE0ICovCisJMCwJLyogMTYgKi8KKwkweDBjLAkvKiAxOCBQTV9USFJFU0hfVElNRU8sIFBNX01SS19JTlNUX0ZJTiAqLworCTB4MGYsCS8qIDFhIFBNX01SS19JTlNUX0RJU1AsIFBNX01SS197RlhVLEZQVSxMU1V9X0ZJTiAqLworCTB4MDEsCS8qIDFjIFBNX01SS19JTlNUX0lTU1VFRCAqLworCTAsCS8qIDFlICovCisJMCwJLyogMjAgKi8KKwkwLAkvKiAyMiAqLworCTAsCS8qIDI0ICovCisJMCwJLyogMjYgKi8KKwkweDE1LAkvKiAyOCBQTV9NUktfREFUQV9GUk9NX0wyTUlTUywgUE1fTVJLX0RBVEFfRlJPTV9MM01JU1MgKi8KKwkwLAkvKiAyYSAqLworCTAsCS8qIDJjICovCisJMCwJLyogMmUgKi8KKwkweDRmLAkvKiAzMCAqLworCTB4N2YsCS8qIDMyICovCisJMHg0ZiwJLyogMzQgKi8KKwkweDVmLAkvKiAzNiAqLworCTB4NmYsCS8qIDM4ICovCisJMHg0ZiwJLyogM2EgKi8KKwkwLAkvKiAzYyAqLworCTB4MDgsCS8qIDNlIFBNX01SS19JTlNUX1RJTUVPICovCisJMHgxZiwJLyogNDAgKi8KKwkweDFmLAkvKiA0MiAqLworCTB4MWYsCS8qIDQ0ICovCisJMHgxZiwJLyogNDYgKi8KKwkweDFmLAkvKiA0OCAqLworCTB4MWYsCS8qIDRhICovCisJMHgxZiwJLyogNGMgKi8KKwkweDFmLAkvKiA0ZSAqLworCTAsCS8qIDUwICovCisJMHgwNSwJLyogNTIgUE1fTVJLX0JSX1RBS0VOLCBQTV9NUktfQlJfTVBSRUQgKi8KKwkweDFjLAkvKiA1NCBQTV9NUktfUFRFR19GUk9NX0wzTUlTUywgUE1fTVJLX1BURUdfRlJPTV9MMk1JU1MgKi8KKwkweDAyLAkvKiA1NiBQTV9NUktfTERfTUlTU19MMSAqLworCTAsCS8qIDU4ICovCisJMCwJLyogNWEgKi8KKwkwLAkvKiA1YyAqLworCTAsCS8qIDVlICovCit9OworCisvKgorICogTWFza3Mgc2hvd2luZyBmb3IgZWFjaCB1bml0IHdoaWNoIGJpdHMgYXJlIG1hcmtlZCBldmVudHMuCisgKiBUaGVzZSBtYXNrcyBhcmUgaW4gTEUgb3JkZXIsIGkuZS4gMHgwMDAwMDAwMSBpcyBieXRlIDAsIGJpdCAwLgorICovCitzdGF0aWMgdTMyIG1hcmtlZF9idXNfZXZlbnRzWzE2XSA9IHsKKwkweDAxMDAwMDAwLAkvKiBkaXJlY3QgZXZlbnRzIHNldCAxOiBieXRlIDMgYml0IDAgKi8KKwkweDAwMDEwMDAwLAkvKiBkaXJlY3QgZXZlbnRzIHNldCAyOiBieXRlIDIgYml0IDAgKi8KKwkwLCAwLCAwLCAwLAkvKiBJRFUsIElGVSwgbmVzdDogbm90aGluZyAqLworCTB4MDAwMDAwODgsCS8qIFZNWCBzZXQgMTogYnl0ZSAwIGJpdHMgMywgNyAqLworCTB4MDAwMDAwYzAsCS8qIFZNWCBzZXQgMjogYnl0ZSAwIGJpdHMgNC03ICovCisJMHgwNDAxMDAwMCwJLyogTFNVIHNldCAxOiBieXRlIDIgYml0IDAsIGJ5dGUgMyBiaXQgMiAqLworCTB4ZmYwMTAwMDB1LAkvKiBMU1Ugc2V0IDI6IGJ5dGUgMiBiaXQgMCwgYWxsIG9mIGJ5dGUgMyAqLworCTAsCQkvKiBMU1Ugc2V0IDMgKi8KKwkweDAwMDAwMDEwLAkvKiBWTVggc2V0IDM6IGJ5dGUgMCBiaXQgNCAqLworCTAsCQkvKiBCRlAgc2V0IDEgKi8KKwkweDAwMDAwMDIyLAkvKiBCRlAgc2V0IDI6IGJ5dGUgMCBiaXRzIDEsIDUgKi8KKwkwLCAwCit9OworCQorLyoKKyAqIFJldHVybnMgMSBpZiBldmVudCBjb3VudHMgdGhpbmdzIHJlbGF0aW5nIHRvIG1hcmtlZCBpbnN0cnVjdGlvbnMKKyAqIGFuZCB0aHVzIG5lZWRzIHRoZSBNTUNSQV9TQU1QTEVfRU5BQkxFIGJpdCBzZXQsIG9yIDAgaWYgbm90LgorICovCitzdGF0aWMgaW50IHBvd2VyNl9tYXJrZWRfaW5zdHJfZXZlbnQodTY0IGV2ZW50KQoreworCWludCBwbWMsIHBzZWwsIHB0eXBlOworCWludCBiaXQsIGJ5dGUsIHVuaXQ7CisJdTMyIG1hc2s7CisKKwlwbWMgPSAoZXZlbnQgPj4gUE1fUE1DX1NIKSAmIFBNX1BNQ19NU0s7CisJcHNlbCA9IChldmVudCAmIFBNX1BNQ1NFTF9NU0spID4+IDE7CS8qIGRyb3AgZWRnZS9sZXZlbCBiaXQgKi8KKwlpZiAocG1jID49IDUpCisJCXJldHVybiAwOworCisJYml0ID0gLTE7CisJaWYgKHBzZWwgPCBzaXplb2YoZGlyZWN0X2V2ZW50X2lzX21hcmtlZCkpIHsKKwkJcHR5cGUgPSBkaXJlY3RfZXZlbnRfaXNfbWFya2VkW3BzZWxdOworCQlpZiAocG1jID09IDAgfHwgIShwdHlwZSAmICgxIDw8IChwbWMgLSAxKSkpKQorCQkJcmV0dXJuIDA7CisJCXB0eXBlID4+PSA0OworCQlpZiAocHR5cGUgPT0gMCkKKwkJCXJldHVybiAxOworCQlpZiAocHR5cGUgPT0gMSkKKwkJCWJpdCA9IDA7CisJCWVsc2UKKwkJCWJpdCA9IHB0eXBlIF4gKHBtYyAtIDEpOworCX0gZWxzZSBpZiAoKHBzZWwgJiAweDQ4KSA9PSAweDQwKQorCQliaXQgPSBwc2VsICYgNzsKKworCWlmICghKGV2ZW50ICYgUE1fQlVTRVZFTlRfTVNLKSB8fCBiaXQgPT0gLTEpCisJCXJldHVybiAwOworCisJYnl0ZSA9IChldmVudCA+PiBQTV9CWVRFX1NIKSAmIFBNX0JZVEVfTVNLOworCXVuaXQgPSAoZXZlbnQgPj4gUE1fVU5JVF9TSCkgJiBQTV9VTklUX01TSzsKKwltYXNrID0gbWFya2VkX2J1c19ldmVudHNbdW5pdF07CisJcmV0dXJuIChtYXNrID4+IChieXRlICogOCArIGJpdCkpICYgMTsKK30KKworLyoKKyAqIEFzc2lnbiBQTUMgbnVtYmVycyBhbmQgY29tcHV0ZSBNTUNSMSB2YWx1ZSBmb3IgYSBzZXQgb2YgZXZlbnRzCisgKi8KK3N0YXRpYyBpbnQgcDZfY29tcHV0ZV9tbWNyKHU2NCBldmVudFtdLCBpbnQgbl9ldiwKKwkJCSAgIHVuc2lnbmVkIGludCBod2NbXSwgdTY0IG1tY3JbXSkKK3sKKwl1NjQgbW1jcjEgPSAwOworCXU2NCBtbWNyYSA9IDA7CisJaW50IGk7CisJdW5zaWduZWQgaW50IHBtYywgZXYsIGIsIHUsIHMsIHBzZWw7CisJdW5zaWduZWQgaW50IHR0bXNldCA9IDA7CisJdW5zaWduZWQgaW50IHBtY19pbnVzZSA9IDA7CisKKwlpZiAobl9ldiA+IDYpCisJCXJldHVybiAtMTsKKwlmb3IgKGkgPSAwOyBpIDwgbl9ldjsgKytpKSB7CisJCXBtYyA9IChldmVudFtpXSA+PiBQTV9QTUNfU0gpICYgUE1fUE1DX01TSzsKKwkJaWYgKHBtYykgeworCQkJaWYgKHBtY19pbnVzZSAmICgxIDw8IChwbWMgLSAxKSkpCisJCQkJcmV0dXJuIC0xOwkvKiBjb2xsaXNpb24hICovCisJCQlwbWNfaW51c2UgfD0gMSA8PCAocG1jIC0gMSk7CisJCX0KKwl9CisJZm9yIChpID0gMDsgaSA8IG5fZXY7ICsraSkgeworCQlldiA9IGV2ZW50W2ldOworCQlwbWMgPSAoZXYgPj4gUE1fUE1DX1NIKSAmIFBNX1BNQ19NU0s7CisJCWlmIChwbWMpIHsKKwkJCS0tcG1jOworCQl9IGVsc2UgeworCQkJLyogY2FuIGdvIG9uIGFueSBQTUM7IGZpbmQgYSBmcmVlIG9uZSAqLworCQkJZm9yIChwbWMgPSAwOyBwbWMgPCA0OyArK3BtYykKKwkJCQlpZiAoIShwbWNfaW51c2UgJiAoMSA8PCBwbWMpKSkKKwkJCQkJYnJlYWs7CisJCQlpZiAocG1jID49IDQpCisJCQkJcmV0dXJuIC0xOworCQkJcG1jX2ludXNlIHw9IDEgPDwgcG1jOworCQl9CisJCWh3Y1tpXSA9IHBtYzsKKwkJcHNlbCA9IGV2ICYgUE1fUE1DU0VMX01TSzsKKwkJaWYgKGV2ICYgUE1fQlVTRVZFTlRfTVNLKSB7CisJCQkvKiB0aGlzIGV2ZW50IHVzZXMgdGhlIGV2ZW50IGJ1cyAqLworCQkJYiA9IChldiA+PiBQTV9CWVRFX1NIKSAmIFBNX0JZVEVfTVNLOworCQkJdSA9IChldiA+PiBQTV9VTklUX1NIKSAmIFBNX1VOSVRfTVNLOworCQkJLyogY2hlY2sgZm9yIGNvbmZsaWN0IG9uIHRoaXMgYnl0ZSBvZiBldmVudCBidXMgKi8KKwkJCWlmICgodHRtc2V0ICYgKDEgPDwgYikpICYmIE1NQ1IxX1RUTVNFTChtbWNyMSwgYikgIT0gdSkKKwkJCQlyZXR1cm4gLTE7CisJCQltbWNyMSB8PSAodTY0KXUgPDwgTU1DUjFfVFRNU0VMX1NIKGIpOworCQkJdHRtc2V0IHw9IDEgPDwgYjsKKwkJCWlmICh1ID09IDUpIHsKKwkJCQkvKiBOZXN0IGV2ZW50cyBoYXZlIGEgZnVydGhlciBtdXggKi8KKwkJCQlzID0gKGV2ID4+IFBNX1NVQlVOSVRfU0gpICYgUE1fU1VCVU5JVF9NU0s7CisJCQkJaWYgKCh0dG1zZXQgJiAweDEwKSAmJgorCQkJCSAgICBNTUNSMV9ORVNUU0VMKG1tY3IxKSAhPSBzKQorCQkJCQlyZXR1cm4gLTE7CisJCQkJdHRtc2V0IHw9IDB4MTA7CisJCQkJbW1jcjEgfD0gKHU2NClzIDw8IE1NQ1IxX05FU1RTRUxfU0g7CisJCQl9CisJCQlpZiAoMHgzMCA8PSBwc2VsICYmIHBzZWwgPD0gMHgzZCkgeworCQkJCS8qIHRoZXNlIG5lZWQgdGhlIFBNQ3hfQUREUl9TRUwgYml0cyAqLworCQkJCWlmIChiID49IDIpCisJCQkJCW1tY3IxIHw9IE1NQ1IxX1BNQzFfQUREUl9TRUwgPj4gcG1jOworCQkJfQorCQkJLyogYnVzIHNlbGVjdCB2YWx1ZXMgYXJlIGRpZmZlcmVudCBmb3IgUE1DMy80ICovCisJCQlpZiAocG1jID49IDIgJiYgKHBzZWwgJiAweDkwKSA9PSAweDgwKQorCQkJCXBzZWwgXj0gMHgyMDsKKwkJfQorCQlpZiAoZXYgJiBQTV9MTEEpIHsKKwkJCW1tY3IxIHw9IE1NQ1IxX1BNQzFfTExBID4+IHBtYzsKKwkJCWlmIChldiAmIFBNX0xMQVYpCisJCQkJbW1jcjEgfD0gTU1DUjFfUE1DMV9MTEFfVkFMVUUgPj4gcG1jOworCQl9CisJCWlmIChwb3dlcjZfbWFya2VkX2luc3RyX2V2ZW50KGV2ZW50W2ldKSkKKwkJCW1tY3JhIHw9IE1NQ1JBX1NBTVBMRV9FTkFCTEU7CisJCWlmIChwbWMgPCA0KQorCQkJbW1jcjEgfD0gKHU2NClwc2VsIDw8IE1NQ1IxX1BNQ1NFTF9TSChwbWMpOworCX0KKwltbWNyWzBdID0gMDsKKwlpZiAocG1jX2ludXNlICYgMSkKKwkJbW1jclswXSA9IE1NQ1IwX1BNQzFDRTsKKwlpZiAocG1jX2ludXNlICYgMHhlKQorCQltbWNyWzBdIHw9IE1NQ1IwX1BNQ2pDRTsKKwltbWNyWzFdID0gbW1jcjE7CisJbW1jclsyXSA9IG1tY3JhOworCXJldHVybiAwOworfQorCisvKgorICogTGF5b3V0IG9mIGNvbnN0cmFpbnQgYml0czoKKyAqCisgKgkwLTEJYWRkIGZpZWxkOiBudW1iZXIgb2YgdXNlcyBvZiBQTUMxIChtYXggMSkKKyAqCTItMywgNC01LCA2LTcsIDgtOSwgMTAtMTE6IGRpdHRvIGZvciBQTUMyLCAzLCA0LCA1LCA2CisgKgkxMi0xNQlhZGQgZmllbGQ6IG51bWJlciBvZiB1c2VzIG9mIFBNQzEtNCAobWF4IDQpCisgKgkxNi0xOQlzZWxlY3QgZmllbGQ6IHVuaXQgb24gYnl0ZSAwIG9mIGV2ZW50IGJ1cworICoJMjAtMjMsIDI0LTI3LCAyOC0zMSBkaXR0byBmb3IgYnl0ZXMgMSwgMiwgMworICoJMzItMzQJc2VsZWN0IGZpZWxkOiBuZXN0IChzdWJ1bml0KSBldmVudCBzZWxlY3RvcgorICovCitzdGF0aWMgaW50IHA2X2dldF9jb25zdHJhaW50KHU2NCBldmVudCwgdTY0ICptYXNrcCwgdTY0ICp2YWxwKQoreworCWludCBwbWMsIGJ5dGUsIHNoLCBzdWJ1bml0OworCXU2NCBtYXNrID0gMCwgdmFsdWUgPSAwOworCisJcG1jID0gKGV2ZW50ID4+IFBNX1BNQ19TSCkgJiBQTV9QTUNfTVNLOworCWlmIChwbWMpIHsKKwkJaWYgKHBtYyA+IDQgJiYgIShldmVudCA9PSAweDUwMDAwOSB8fCBldmVudCA9PSAweDYwMDAwNSkpCisJCQlyZXR1cm4gLTE7CisJCXNoID0gKHBtYyAtIDEpICogMjsKKwkJbWFzayB8PSAyIDw8IHNoOworCQl2YWx1ZSB8PSAxIDw8IHNoOworCX0KKwlpZiAoZXZlbnQgJiBQTV9CVVNFVkVOVF9NU0spIHsKKwkJYnl0ZSA9IChldmVudCA+PiBQTV9CWVRFX1NIKSAmIFBNX0JZVEVfTVNLOworCQlzaCA9IGJ5dGUgKiA0ICsgKDE2IC0gUE1fVU5JVF9TSCk7CisJCW1hc2sgfD0gUE1fVU5JVF9NU0tTIDw8IHNoOworCQl2YWx1ZSB8PSAodTY0KShldmVudCAmIFBNX1VOSVRfTVNLUykgPDwgc2g7CisJCWlmICgoZXZlbnQgJiBQTV9VTklUX01TS1MpID09ICg1IDw8IFBNX1VOSVRfU0gpKSB7CisJCQlzdWJ1bml0ID0gKGV2ZW50ID4+IFBNX1NVQlVOSVRfU0gpICYgUE1fU1VCVU5JVF9NU0s7CisJCQltYXNrICB8PSAodTY0KVBNX1NVQlVOSVRfTVNLIDw8IDMyOworCQkJdmFsdWUgfD0gKHU2NClzdWJ1bml0IDw8IDMyOworCQl9CisJfQorCWlmIChwbWMgPD0gNCkgeworCQltYXNrICB8PSAweDgwMDA7CS8qIGFkZCBmaWVsZCBmb3IgY291bnQgb2YgUE1DMS00IHVzZXMgKi8KKwkJdmFsdWUgfD0gMHgxMDAwOworCX0KKwkqbWFza3AgPSBtYXNrOworCSp2YWxwID0gdmFsdWU7CisJcmV0dXJuIDA7Cit9CisKK3N0YXRpYyBpbnQgcDZfbGltaXRlZF9wbWNfZXZlbnQodTY0IGV2ZW50KQoreworCWludCBwbWMgPSAoZXZlbnQgPj4gUE1fUE1DX1NIKSAmIFBNX1BNQ19NU0s7CisKKwlyZXR1cm4gcG1jID09IDUgfHwgcG1jID09IDY7Cit9CisKKyNkZWZpbmUgTUFYX0FMVAk0CS8qIGF0IG1vc3QgNCBhbHRlcm5hdGl2ZXMgZm9yIGFueSBldmVudCAqLworCitzdGF0aWMgY29uc3QgdW5zaWduZWQgaW50IGV2ZW50X2FsdGVybmF0aXZlc1tdW01BWF9BTFRdID0geworCXsgMHgwMTMwZTgsIDB4MjAwMGY2LCAweDMwMDBmYyB9LAkvKiBQTV9QVEVHX1JFTE9BRF9WQUxJRCAqLworCXsgMHgwODAwODAsIDB4MTAwMDBkLCAweDMwMDAwYywgMHg0MDAwZjAgfSwgLyogUE1fTERfTUlTU19MMSAqLworCXsgMHgwODAwODgsIDB4MjAwMDU0LCAweDMwMDBmMCB9LAkvKiBQTV9TVF9NSVNTX0wxICovCisJeyAweDEwMDAwYSwgMHgyMDAwZjQsIDB4NjAwMDA1IH0sCS8qIFBNX1JVTl9DWUMgKi8KKwl7IDB4MTAwMDBiLCAweDIwMDBmNSB9LAkJCS8qIFBNX1JVTl9DT1VOVCAqLworCXsgMHgxMDAwMGUsIDB4NDAwMDEwIH0sCQkJLyogUE1fUFVSUiAqLworCXsgMHgxMDAwMTAsIDB4NDAwMGY4IH0sCQkJLyogUE1fRkxVU0ggKi8KKwl7IDB4MTAwMDFhLCAweDIwMDAxMCB9LAkJCS8qIFBNX01SS19JTlNUX0RJU1AgKi8KKwl7IDB4MTAwMDI2LCAweDMwMDBmOCB9LAkJCS8qIFBNX1RCX0JJVF9UUkFOUyAqLworCXsgMHgxMDAwNTQsIDB4MjAwMGYwIH0sCQkJLyogUE1fU1RfRklOICovCisJeyAweDEwMDA1NiwgMHgyMDAwZmMgfSwJCQkvKiBQTV9MMV9JQ0FDSEVfTUlTUyAqLworCXsgMHgxMDAwZjAsIDB4NDAwMDBhIH0sCQkJLyogUE1fSU5TVF9JTUNfTUFUQ0hfQ01QTCAqLworCXsgMHgxMDAwZjgsIDB4MjAwMDA4IH0sCQkJLyogUE1fR0NUX0VNUFRZX0NZQyAqLworCXsgMHgxMDAwZmMsIDB4NDAwMDA2IH0sCQkJLyogUE1fTFNVX0RFUkFUX01JU1NfQ1lDICovCisJeyAweDIwMDAwZSwgMHg0MDAwMDcgfSwJCQkvKiBQTV9MU1VfREVSQVRfTUlTUyAqLworCXsgMHgyMDAwMTIsIDB4MzAwMDEyIH0sCQkJLyogUE1fSU5TVF9ESVNQICovCisJeyAweDIwMDBmMiwgMHgzMDAwZjIgfSwJCQkvKiBQTV9JTlNUX0RJU1AgKi8KKwl7IDB4MjAwMGY4LCAweDMwMDAxMCB9LAkJCS8qIFBNX0VYVF9JTlQgKi8KKwl7IDB4MjAwMGZlLCAweDMwMDA1NiB9LAkJCS8qIFBNX0RBVEFfRlJPTV9MMk1JU1MgKi8KKwl7IDB4MmQwMDMwLCAweDMwMDAxYSB9LAkJCS8qIFBNX01SS19GUFVfRklOICovCisJeyAweDMwMDAwYSwgMHg0MDAwMTggfSwJCQkvKiBQTV9NUktfSU5TVF9GSU4gKi8KKwl7IDB4MzAwMGY2LCAweDQwMDAwZSB9LAkJCS8qIFBNX0wxX0RDQUNIRV9SRUxPQURfVkFMSUQgKi8KKwl7IDB4MzAwMGZlLCAweDQwMDA1NiB9LAkJCS8qIFBNX0RBVEFfRlJPTV9MM01JU1MgKi8KK307CisKKy8qCisgKiBUaGlzIGNvdWxkIGJlIG1hZGUgbW9yZSBlZmZpY2llbnQgd2l0aCBhIGJpbmFyeSBzZWFyY2ggb24KKyAqIGEgcHJlc29ydGVkIGxpc3QsIGlmIG5lY2Vzc2FyeQorICovCitzdGF0aWMgaW50IGZpbmRfYWx0ZXJuYXRpdmVzX2xpc3QodTY0IGV2ZW50KQoreworCWludCBpLCBqOworCXVuc2lnbmVkIGludCBhbHQ7CisKKwlmb3IgKGkgPSAwOyBpIDwgQVJSQVlfU0laRShldmVudF9hbHRlcm5hdGl2ZXMpOyArK2kpIHsKKwkJaWYgKGV2ZW50IDwgZXZlbnRfYWx0ZXJuYXRpdmVzW2ldWzBdKQorCQkJcmV0dXJuIC0xOworCQlmb3IgKGogPSAwOyBqIDwgTUFYX0FMVDsgKytqKSB7CisJCQlhbHQgPSBldmVudF9hbHRlcm5hdGl2ZXNbaV1bal07CisJCQlpZiAoIWFsdCB8fCBldmVudCA8IGFsdCkKKwkJCQlicmVhazsKKwkJCWlmIChldmVudCA9PSBhbHQpCisJCQkJcmV0dXJuIGk7CisJCX0KKwl9CisJcmV0dXJuIC0xOworfQorCitzdGF0aWMgaW50IHA2X2dldF9hbHRlcm5hdGl2ZXModTY0IGV2ZW50LCB1bnNpZ25lZCBpbnQgZmxhZ3MsIHU2NCBhbHRbXSkKK3sKKwlpbnQgaSwgaiwgbmxpbTsKKwl1bnNpZ25lZCBpbnQgcHNlbCwgcG1jOworCXVuc2lnbmVkIGludCBuYWx0ID0gMTsKKwl1NjQgYWV2ZW50OworCisJYWx0WzBdID0gZXZlbnQ7CisJbmxpbSA9IHA2X2xpbWl0ZWRfcG1jX2V2ZW50KGV2ZW50KTsKKworCS8qIGNoZWNrIHRoZSBhbHRlcm5hdGl2ZXMgdGFibGUgKi8KKwlpID0gZmluZF9hbHRlcm5hdGl2ZXNfbGlzdChldmVudCk7CisJaWYgKGkgPj0gMCkgeworCQkvKiBjb3B5IG91dCBhbHRlcm5hdGl2ZXMgZnJvbSBsaXN0ICovCisJCWZvciAoaiA9IDA7IGogPCBNQVhfQUxUOyArK2opIHsKKwkJCWFldmVudCA9IGV2ZW50X2FsdGVybmF0aXZlc1tpXVtqXTsKKwkJCWlmICghYWV2ZW50KQorCQkJCWJyZWFrOworCQkJaWYgKGFldmVudCAhPSBldmVudCkKKwkJCQlhbHRbbmFsdCsrXSA9IGFldmVudDsKKwkJCW5saW0gKz0gcDZfbGltaXRlZF9wbWNfZXZlbnQoYWV2ZW50KTsKKwkJfQorCisJfSBlbHNlIHsKKwkJLyogQ2hlY2sgZm9yIGFsdGVybmF0aXZlIHdheXMgb2YgY29tcHV0aW5nIHN1bSBldmVudHMgKi8KKwkJLyogUE1DU0VMIDB4MzIgY291bnRlciBOID09IFBNQ1NFTCAweDM0IGNvdW50ZXIgNS1OICovCisJCXBzZWwgPSBldmVudCAmIChQTV9QTUNTRUxfTVNLICYgfjEpOwkvKiBpZ25vcmUgZWRnZSBiaXQgKi8KKwkJcG1jID0gKGV2ZW50ID4+IFBNX1BNQ19TSCkgJiBQTV9QTUNfTVNLOworCQlpZiAocG1jICYmIChwc2VsID09IDB4MzIgfHwgcHNlbCA9PSAweDM0KSkKKwkJCWFsdFtuYWx0KytdID0gKChldmVudCBeIDB4NikgJiB+UE1fUE1DX01TS1MpIHwKKwkJCQkoKDUgLSBwbWMpIDw8IFBNX1BNQ19TSCk7CisKKwkJLyogUE1DU0VMIDB4MzggY291bnRlciBOID09IFBNQ1NFTCAweDNhIGNvdW50ZXIgTisvLTIgKi8KKwkJaWYgKHBtYyAmJiAocHNlbCA9PSAweDM4IHx8IHBzZWwgPT0gMHgzYSkpCisJCQlhbHRbbmFsdCsrXSA9ICgoZXZlbnQgXiAweDIpICYgflBNX1BNQ19NU0tTKSB8CisJCQkJKChwbWMgPiAyPyBwbWMgLSAyOiBwbWMgKyAyKSA8PCBQTV9QTUNfU0gpOworCX0KKworCWlmIChmbGFncyAmIFBQTVVfT05MWV9DT1VOVF9SVU4pIHsKKwkJLyoKKwkJICogV2UncmUgb25seSBjb3VudGluZyBpbiBSVU4gc3RhdGUsCisJCSAqIHNvIFBNX0NZQyBpcyBlcXVpdmFsZW50IHRvIFBNX1JVTl9DWUMsCisJCSAqIFBNX0lOU1RfQ01QTCA9PT0gUE1fUlVOX0lOU1RfQ01QTCwgUE1fUFVSUiA9PT0gUE1fUlVOX1BVUlIuCisJCSAqIFRoaXMgZG9lc24ndCBpbmNsdWRlIGFsdGVybmF0aXZlcyB0aGF0IGRvbid0IHByb3ZpZGUKKwkJICogYW55IGV4dHJhIGZsZXhpYmlsaXR5IGluIGFzc2lnbmluZyBQTUNzIChlLmcuCisJCSAqIDB4MTAwMDBhIGZvciBQTV9SVU5fQ1lDIHZzLiAweDFlIGZvciBQTV9DWUMpLgorCQkgKiBOb3RlIHRoYXQgZXZlbiB3aXRoIHRoZXNlIGFkZGl0aW9uYWwgYWx0ZXJuYXRpdmVzCisJCSAqIHdlIG5ldmVyIGVuZCB1cCB3aXRoIG1vcmUgdGhhbiA0IGFsdGVybmF0aXZlcyBmb3IgYW55IGV2ZW50LgorCQkgKi8KKwkJaiA9IG5hbHQ7CisJCWZvciAoaSA9IDA7IGkgPCBuYWx0OyArK2kpIHsKKwkJCXN3aXRjaCAoYWx0W2ldKSB7CisJCQljYXNlIDB4MWU6CS8qIFBNX0NZQyAqLworCQkJCWFsdFtqKytdID0gMHg2MDAwMDU7CS8qIFBNX1JVTl9DWUMgKi8KKwkJCQkrK25saW07CisJCQkJYnJlYWs7CisJCQljYXNlIDB4MTAwMDBhOgkvKiBQTV9SVU5fQ1lDICovCisJCQkJYWx0W2orK10gPSAweDFlOwkvKiBQTV9DWUMgKi8KKwkJCQlicmVhazsKKwkJCWNhc2UgMjoJCS8qIFBNX0lOU1RfQ01QTCAqLworCQkJCWFsdFtqKytdID0gMHg1MDAwMDk7CS8qIFBNX1JVTl9JTlNUX0NNUEwgKi8KKwkJCQkrK25saW07CisJCQkJYnJlYWs7CisJCQljYXNlIDB4NTAwMDA5OgkvKiBQTV9SVU5fSU5TVF9DTVBMICovCisJCQkJYWx0W2orK10gPSAyOwkJLyogUE1fSU5TVF9DTVBMICovCisJCQkJYnJlYWs7CisJCQljYXNlIDB4MTAwMDBlOgkvKiBQTV9QVVJSICovCisJCQkJYWx0W2orK10gPSAweDQwMDBmNDsJLyogUE1fUlVOX1BVUlIgKi8KKwkJCQlicmVhazsKKwkJCWNhc2UgMHg0MDAwZjQ6CS8qIFBNX1JVTl9QVVJSICovCisJCQkJYWx0W2orK10gPSAweDEwMDAwZTsJLyogUE1fUFVSUiAqLworCQkJCWJyZWFrOworCQkJfQorCQl9CisJCW5hbHQgPSBqOworCX0KKworCWlmICghKGZsYWdzICYgUFBNVV9MSU1JVEVEX1BNQ19PSykgJiYgbmxpbSkgeworCQkvKiByZW1vdmUgdGhlIGxpbWl0ZWQgUE1DIGV2ZW50cyAqLworCQlqID0gMDsKKwkJZm9yIChpID0gMDsgaSA8IG5hbHQ7ICsraSkgeworCQkJaWYgKCFwNl9saW1pdGVkX3BtY19ldmVudChhbHRbaV0pKSB7CisJCQkJYWx0W2pdID0gYWx0W2ldOworCQkJCSsrajsKKwkJCX0KKwkJfQorCQluYWx0ID0gajsKKwl9IGVsc2UgaWYgKChmbGFncyAmIFBQTVVfTElNSVRFRF9QTUNfUkVRRCkgJiYgbmxpbSA8IG5hbHQpIHsKKwkJLyogcmVtb3ZlIGFsbCBidXQgdGhlIGxpbWl0ZWQgUE1DIGV2ZW50cyAqLworCQlqID0gMDsKKwkJZm9yIChpID0gMDsgaSA8IG5hbHQ7ICsraSkgeworCQkJaWYgKHA2X2xpbWl0ZWRfcG1jX2V2ZW50KGFsdFtpXSkpIHsKKwkJCQlhbHRbal0gPSBhbHRbaV07CisJCQkJKytqOworCQkJfQorCQl9CisJCW5hbHQgPSBqOworCX0KKworCXJldHVybiBuYWx0OworfQorCitzdGF0aWMgdm9pZCBwNl9kaXNhYmxlX3BtYyh1bnNpZ25lZCBpbnQgcG1jLCB1NjQgbW1jcltdKQoreworCS8qIFNldCBQTUN4U0VMIHRvIDAgdG8gZGlzYWJsZSBQTUN4ICovCisJaWYgKHBtYyA8PSAzKQorCQltbWNyWzFdICY9IH4oMHhmZlVMIDw8IE1NQ1IxX1BNQ1NFTF9TSChwbWMpKTsKK30KKworc3RhdGljIGludCBwb3dlcjZfZ2VuZXJpY19ldmVudHNbXSA9IHsKKwlbUEVSRl9DT1VOVF9IV19DUFVfQ1lDTEVTXQkJPSAweDFlLAorCVtQRVJGX0NPVU5UX0hXX0lOU1RSVUNUSU9OU10JCT0gMiwKKwlbUEVSRl9DT1VOVF9IV19DQUNIRV9SRUZFUkVOQ0VTXQk9IDB4MjgwMDMwLCAvKiBMRF9SRUZfTDEgKi8KKwlbUEVSRl9DT1VOVF9IV19DQUNIRV9NSVNTRVNdCQk9IDB4MzAwMDBjLCAvKiBMRF9NSVNTX0wxICovCisJW1BFUkZfQ09VTlRfSFdfQlJBTkNIX0lOU1RSVUNUSU9OU10JPSAweDQxMGEwLCAgLyogQlJfUFJFRCAqLworCVtQRVJGX0NPVU5UX0hXX0JSQU5DSF9NSVNTRVNdCQk9IDB4NDAwMDUyLCAvKiBCUl9NUFJFRCAqLworfTsKKworI2RlZmluZSBDKHgpCVBFUkZfQ09VTlRfSFdfQ0FDSEVfIyN4CisKKy8qCisgKiBUYWJsZSBvZiBnZW5lcmFsaXplZCBjYWNoZS1yZWxhdGVkIGV2ZW50cy4KKyAqIDAgbWVhbnMgbm90IHN1cHBvcnRlZCwgLTEgbWVhbnMgbm9uc2Vuc2ljYWwsIG90aGVyIHZhbHVlcworICogYXJlIGV2ZW50IGNvZGVzLgorICogVGhlICJEVExCIiBhbmQgIklUTEIiIGV2ZW50cyByZWxhdGUgdG8gdGhlIERFUkFUIGFuZCBJRVJBVC4KKyAqLworc3RhdGljIGludCBwb3dlcjZfY2FjaGVfZXZlbnRzW0MoTUFYKV1bQyhPUF9NQVgpXVtDKFJFU1VMVF9NQVgpXSA9IHsKKwlbQyhMMUQpXSA9IHsJCS8qIAlSRVNVTFRfQUNDRVNTCVJFU1VMVF9NSVNTICovCisJCVtDKE9QX1JFQUQpXSA9IHsJMHg4MDA4MiwJMHg4MDA4MAkJfSwKKwkJW0MoT1BfV1JJVEUpXSA9IHsJMHg4MDA4NiwJMHg4MDA4OAkJfSwKKwkJW0MoT1BfUFJFRkVUQ0gpXSA9IHsJMHg4MTBhNCwJMAkJfSwKKwl9LAorCVtDKEwxSSldID0gewkJLyogCVJFU1VMVF9BQ0NFU1MJUkVTVUxUX01JU1MgKi8KKwkJW0MoT1BfUkVBRCldID0gewkwLAkJMHgxMDAwNTYgCX0sCisJCVtDKE9QX1dSSVRFKV0gPSB7CS0xLAkJLTEJCX0sCisJCVtDKE9QX1BSRUZFVENIKV0gPSB7CTB4NDAwOGMsCTAJCX0sCisJfSwKKwlbQyhMTCldID0gewkJLyogCVJFU1VMVF9BQ0NFU1MJUkVTVUxUX01JU1MgKi8KKwkJW0MoT1BfUkVBRCldID0gewkweDE1MDczMCwJMHgyNTA1MzIJfSwKKwkJW0MoT1BfV1JJVEUpXSA9IHsJMHgyNTA0MzIsCTB4MTUwNDMyCX0sCisJCVtDKE9QX1BSRUZFVENIKV0gPSB7CTB4ODEwYTYsCTAJCX0sCisJfSwKKwlbQyhEVExCKV0gPSB7CQkvKiAJUkVTVUxUX0FDQ0VTUwlSRVNVTFRfTUlTUyAqLworCQlbQyhPUF9SRUFEKV0gPSB7CTAsCQkweDIwMDAwZQl9LAorCQlbQyhPUF9XUklURSldID0gewktMSwJCS0xCQl9LAorCQlbQyhPUF9QUkVGRVRDSCldID0gewktMSwJCS0xCQl9LAorCX0sCisJW0MoSVRMQildID0gewkJLyogCVJFU1VMVF9BQ0NFU1MJUkVTVUxUX01JU1MgKi8KKwkJW0MoT1BfUkVBRCldID0gewkwLAkJMHg0MjBjZQkJfSwKKwkJW0MoT1BfV1JJVEUpXSA9IHsJLTEsCQktMQkJfSwKKwkJW0MoT1BfUFJFRkVUQ0gpXSA9IHsJLTEsCQktMQkJfSwKKwl9LAorCVtDKEJQVSldID0gewkJLyogCVJFU1VMVF9BQ0NFU1MJUkVTVUxUX01JU1MgKi8KKwkJW0MoT1BfUkVBRCldID0gewkweDQzMGU2LAkweDQwMDA1Mgl9LAorCQlbQyhPUF9XUklURSldID0gewktMSwJCS0xCQl9LAorCQlbQyhPUF9QUkVGRVRDSCldID0gewktMSwJCS0xCQl9LAorCX0sCit9OworCitzdHJ1Y3QgcG93ZXJfcG11IHBvd2VyNl9wbXUgPSB7CisJLm5fY291bnRlciA9IDYsCisJLm1heF9hbHRlcm5hdGl2ZXMgPSBNQVhfQUxULAorCS5hZGRfZmllbGRzID0gMHgxNTU1LAorCS50ZXN0X2FkZGVyID0gMHgzMDAwLAorCS5jb21wdXRlX21tY3IgPSBwNl9jb21wdXRlX21tY3IsCisJLmdldF9jb25zdHJhaW50ID0gcDZfZ2V0X2NvbnN0cmFpbnQsCisJLmdldF9hbHRlcm5hdGl2ZXMgPSBwNl9nZXRfYWx0ZXJuYXRpdmVzLAorCS5kaXNhYmxlX3BtYyA9IHA2X2Rpc2FibGVfcG1jLAorCS5saW1pdGVkX3BtY19ldmVudCA9IHA2X2xpbWl0ZWRfcG1jX2V2ZW50LAorCS5mbGFncyA9IFBQTVVfTElNSVRFRF9QTUM1XzYgfCBQUE1VX0FMVF9TSVBSLAorCS5uX2dlbmVyaWMgPSBBUlJBWV9TSVpFKHBvd2VyNl9nZW5lcmljX2V2ZW50cyksCisJLmdlbmVyaWNfZXZlbnRzID0gcG93ZXI2X2dlbmVyaWNfZXZlbnRzLAorCS5jYWNoZV9ldmVudHMgPSAmcG93ZXI2X2NhY2hlX2V2ZW50cywKK307CmRpZmYgLS1naXQgYS9hcmNoL3Bvd2VycGMva2VybmVsL3Bvd2VyNy1wbXUuYyBiL2FyY2gvcG93ZXJwYy9rZXJuZWwvcG93ZXI3LXBtdS5jCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLmIzZjdkMTIKLS0tIC9kZXYvbnVsbAorKysgYi9hcmNoL3Bvd2VycGMva2VybmVsL3Bvd2VyNy1wbXUuYwpAQCAtMCwwICsxLDM1NyBAQAorLyoKKyAqIFBlcmZvcm1hbmNlIGNvdW50ZXIgc3VwcG9ydCBmb3IgUE9XRVI3IHByb2Nlc3NvcnMuCisgKgorICogQ29weXJpZ2h0IDIwMDkgUGF1bCBNYWNrZXJyYXMsIElCTSBDb3Jwb3JhdGlvbi4KKyAqCisgKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yCisgKiBtb2RpZnkgaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZQorICogYXMgcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb247IGVpdGhlciB2ZXJzaW9uCisgKiAyIG9mIHRoZSBMaWNlbnNlLCBvciAoYXQgeW91ciBvcHRpb24pIGFueSBsYXRlciB2ZXJzaW9uLgorICovCisjaW5jbHVkZSA8bGludXgva2VybmVsLmg+CisjaW5jbHVkZSA8bGludXgvcGVyZl9jb3VudGVyLmg+CisjaW5jbHVkZSA8YXNtL3JlZy5oPgorCisvKgorICogQml0cyBpbiBldmVudCBjb2RlIGZvciBQT1dFUjcKKyAqLworI2RlZmluZSBQTV9QTUNfU0gJMTYJLyogUE1DIG51bWJlciAoMS1iYXNlZCkgZm9yIGRpcmVjdCBldmVudHMgKi8KKyNkZWZpbmUgUE1fUE1DX01TSwkweGYKKyNkZWZpbmUgUE1fUE1DX01TS1MJKFBNX1BNQ19NU0sgPDwgUE1fUE1DX1NIKQorI2RlZmluZSBQTV9VTklUX1NICTEyCS8qIFRUTU1VWCBudW1iZXIgYW5kIHNldHRpbmcgLSB1bml0IHNlbGVjdCAqLworI2RlZmluZSBQTV9VTklUX01TSwkweGYKKyNkZWZpbmUgUE1fQ09NQklORV9TSAkxMQkvKiBDb21iaW5lZCBldmVudCBiaXQgKi8KKyNkZWZpbmUgUE1fQ09NQklORV9NU0sJMQorI2RlZmluZSBQTV9DT01CSU5FX01TS1MJMHg4MDAKKyNkZWZpbmUgUE1fTDJTRUxfU0gJOAkvKiBMMiBldmVudCBzZWxlY3QgKi8KKyNkZWZpbmUgUE1fTDJTRUxfTVNLCTcKKyNkZWZpbmUgUE1fUE1DU0VMX01TSwkweGZmCisKKy8qCisgKiBCaXRzIGluIE1NQ1IxIGZvciBQT1dFUjcKKyAqLworI2RlZmluZSBNTUNSMV9UVE0wU0VMX1NICTYwCisjZGVmaW5lIE1NQ1IxX1RUTTFTRUxfU0gJNTYKKyNkZWZpbmUgTU1DUjFfVFRNMlNFTF9TSAk1MgorI2RlZmluZSBNTUNSMV9UVE0zU0VMX1NICTQ4CisjZGVmaW5lIE1NQ1IxX1RUTVNFTF9NU0sJMHhmCisjZGVmaW5lIE1NQ1IxX0wyU0VMX1NICQk0NQorI2RlZmluZSBNTUNSMV9MMlNFTF9NU0sJCTcKKyNkZWZpbmUgTU1DUjFfUE1DMV9DT01CSU5FX1NICTM1CisjZGVmaW5lIE1NQ1IxX1BNQzJfQ09NQklORV9TSAkzNAorI2RlZmluZSBNTUNSMV9QTUMzX0NPTUJJTkVfU0gJMzMKKyNkZWZpbmUgTU1DUjFfUE1DNF9DT01CSU5FX1NICTMyCisjZGVmaW5lIE1NQ1IxX1BNQzFTRUxfU0gJMjQKKyNkZWZpbmUgTU1DUjFfUE1DMlNFTF9TSAkxNgorI2RlZmluZSBNTUNSMV9QTUMzU0VMX1NICTgKKyNkZWZpbmUgTU1DUjFfUE1DNFNFTF9TSAkwCisjZGVmaW5lIE1NQ1IxX1BNQ1NFTF9TSChuKQkoTU1DUjFfUE1DMVNFTF9TSCAtIChuKSAqIDgpCisjZGVmaW5lIE1NQ1IxX1BNQ1NFTF9NU0sJMHhmZgorCisvKgorICogQml0cyBpbiBNTUNSQQorICovCisKKy8qCisgKiBMYXlvdXQgb2YgY29uc3RyYWludCBiaXRzOgorICogNjY2NjU1NTU1NTU1NTU0NDQ0NDQ0NDQ0MzMzMzMzMzMzMzIyMjIyMjIyMjIxMTExMTExMTExMDAwMDAwMDAwMAorICogMzIxMDk4NzY1NDMyMTA5ODc2NTQzMjEwOTg3NjU0MzIxMDk4NzY1NDMyMTA5ODc2NTQzMjEwOTg3NjU0MzIxMAorICogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgWyAgPjw+PD48Pjw+PD48PgorICogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIE5DIFA2UDVQNFAzUDJQMQorICoKKyAqIE5DIC0gbnVtYmVyIG9mIGNvdW50ZXJzCisgKiAgICAgMTU6IE5DIGVycm9yIDB4ODAwMAorICogICAgIDEyLTE0OiBudW1iZXIgb2YgZXZlbnRzIG5lZWRpbmcgUE1DMS00IDB4NzAwMAorICoKKyAqIFA2CisgKiAgICAgMTE6IFA2IGVycm9yIDB4ODAwCisgKiAgICAgMTAtMTE6IENvdW50IG9mIGV2ZW50cyBuZWVkaW5nIFBNQzYKKyAqCisgKiBQMS4uUDUKKyAqICAgICAwLTk6IENvdW50IG9mIGV2ZW50cyBuZWVkaW5nIFBNQzEuLlBNQzUKKyAqLworCitzdGF0aWMgaW50IHBvd2VyN19nZXRfY29uc3RyYWludCh1NjQgZXZlbnQsIHU2NCAqbWFza3AsIHU2NCAqdmFscCkKK3sKKwlpbnQgcG1jLCBzaDsKKwl1NjQgbWFzayA9IDAsIHZhbHVlID0gMDsKKworCXBtYyA9IChldmVudCA+PiBQTV9QTUNfU0gpICYgUE1fUE1DX01TSzsKKwlpZiAocG1jKSB7CisJCWlmIChwbWMgPiA2KQorCQkJcmV0dXJuIC0xOworCQlzaCA9IChwbWMgLSAxKSAqIDI7CisJCW1hc2sgfD0gMiA8PCBzaDsKKwkJdmFsdWUgfD0gMSA8PCBzaDsKKwkJaWYgKHBtYyA+PSA1ICYmICEoZXZlbnQgPT0gMHg1MDBmYSB8fCBldmVudCA9PSAweDYwMGY0KSkKKwkJCXJldHVybiAtMTsKKwl9CisJaWYgKHBtYyA8IDUpIHsKKwkJLyogbmVlZCBhIGNvdW50ZXIgZnJvbSBQTUMxLTQgc2V0ICovCisJCW1hc2sgIHw9IDB4ODAwMDsKKwkJdmFsdWUgfD0gMHgxMDAwOworCX0KKwkqbWFza3AgPSBtYXNrOworCSp2YWxwID0gdmFsdWU7CisJcmV0dXJuIDA7Cit9CisKKyNkZWZpbmUgTUFYX0FMVAkyCS8qIGF0IG1vc3QgMiBhbHRlcm5hdGl2ZXMgZm9yIGFueSBldmVudCAqLworCitzdGF0aWMgY29uc3QgdW5zaWduZWQgaW50IGV2ZW50X2FsdGVybmF0aXZlc1tdW01BWF9BTFRdID0geworCXsgMHgyMDBmMiwgMHgzMDBmMiB9LAkJLyogUE1fSU5TVF9ESVNQICovCisJeyAweDIwMGY0LCAweDYwMGY0IH0sCQkvKiBQTV9SVU5fQ1lDICovCisJeyAweDQwMGZhLCAweDUwMGZhIH0sCQkvKiBQTV9SVU5fSU5TVF9DTVBMICovCit9OworCisvKgorICogU2NhbiB0aGUgYWx0ZXJuYXRpdmVzIHRhYmxlIGZvciBhIG1hdGNoIGFuZCByZXR1cm4gdGhlCisgKiBpbmRleCBpbnRvIHRoZSBhbHRlcm5hdGl2ZXMgdGFibGUgaWYgZm91bmQsIGVsc2UgLTEuCisgKi8KK3N0YXRpYyBpbnQgZmluZF9hbHRlcm5hdGl2ZSh1NjQgZXZlbnQpCit7CisJaW50IGksIGo7CisKKwlmb3IgKGkgPSAwOyBpIDwgQVJSQVlfU0laRShldmVudF9hbHRlcm5hdGl2ZXMpOyArK2kpIHsKKwkJaWYgKGV2ZW50IDwgZXZlbnRfYWx0ZXJuYXRpdmVzW2ldWzBdKQorCQkJYnJlYWs7CisJCWZvciAoaiA9IDA7IGogPCBNQVhfQUxUICYmIGV2ZW50X2FsdGVybmF0aXZlc1tpXVtqXTsgKytqKQorCQkJaWYgKGV2ZW50ID09IGV2ZW50X2FsdGVybmF0aXZlc1tpXVtqXSkKKwkJCQlyZXR1cm4gaTsKKwl9CisJcmV0dXJuIC0xOworfQorCitzdGF0aWMgczY0IGZpbmRfYWx0ZXJuYXRpdmVfZGVjb2RlKHU2NCBldmVudCkKK3sKKwlpbnQgcG1jLCBwc2VsOworCisJLyogdGhpcyBvbmx5IGhhbmRsZXMgdGhlIDR4IGRlY29kZSBldmVudHMgKi8KKwlwbWMgPSAoZXZlbnQgPj4gUE1fUE1DX1NIKSAmIFBNX1BNQ19NU0s7CisJcHNlbCA9IGV2ZW50ICYgUE1fUE1DU0VMX01TSzsKKwlpZiAoKHBtYyA9PSAyIHx8IHBtYyA9PSA0KSAmJiAocHNlbCAmIH43KSA9PSAweDQwKQorCQlyZXR1cm4gZXZlbnQgLSAoMSA8PCBQTV9QTUNfU0gpICsgODsKKwlpZiAoKHBtYyA9PSAxIHx8IHBtYyA9PSAzKSAmJiAocHNlbCAmIH43KSA9PSAweDQ4KQorCQlyZXR1cm4gZXZlbnQgKyAoMSA8PCBQTV9QTUNfU0gpIC0gODsKKwlyZXR1cm4gLTE7Cit9CisKK3N0YXRpYyBpbnQgcG93ZXI3X2dldF9hbHRlcm5hdGl2ZXModTY0IGV2ZW50LCB1bnNpZ25lZCBpbnQgZmxhZ3MsIHU2NCBhbHRbXSkKK3sKKwlpbnQgaSwgaiwgbmFsdCA9IDE7CisJczY0IGFlOworCisJYWx0WzBdID0gZXZlbnQ7CisJbmFsdCA9IDE7CisJaSA9IGZpbmRfYWx0ZXJuYXRpdmUoZXZlbnQpOworCWlmIChpID49IDApIHsKKwkJZm9yIChqID0gMDsgaiA8IE1BWF9BTFQ7ICsraikgeworCQkJYWUgPSBldmVudF9hbHRlcm5hdGl2ZXNbaV1bal07CisJCQlpZiAoYWUgJiYgYWUgIT0gZXZlbnQpCisJCQkJYWx0W25hbHQrK10gPSBhZTsKKwkJfQorCX0gZWxzZSB7CisJCWFlID0gZmluZF9hbHRlcm5hdGl2ZV9kZWNvZGUoZXZlbnQpOworCQlpZiAoYWUgPiAwKQorCQkJYWx0W25hbHQrK10gPSBhZTsKKwl9CisKKwlpZiAoZmxhZ3MgJiBQUE1VX09OTFlfQ09VTlRfUlVOKSB7CisJCS8qCisJCSAqIFdlJ3JlIG9ubHkgY291bnRpbmcgaW4gUlVOIHN0YXRlLAorCQkgKiBzbyBQTV9DWUMgaXMgZXF1aXZhbGVudCB0byBQTV9SVU5fQ1lDCisJCSAqIGFuZCBQTV9JTlNUX0NNUEwgPT09IFBNX1JVTl9JTlNUX0NNUEwuCisJCSAqIFRoaXMgZG9lc24ndCBpbmNsdWRlIGFsdGVybmF0aXZlcyB0aGF0IGRvbid0IHByb3ZpZGUKKwkJICogYW55IGV4dHJhIGZsZXhpYmlsaXR5IGluIGFzc2lnbmluZyBQTUNzLgorCQkgKi8KKwkJaiA9IG5hbHQ7CisJCWZvciAoaSA9IDA7IGkgPCBuYWx0OyArK2kpIHsKKwkJCXN3aXRjaCAoYWx0W2ldKSB7CisJCQljYXNlIDB4MWU6CS8qIFBNX0NZQyAqLworCQkJCWFsdFtqKytdID0gMHg2MDBmNDsJLyogUE1fUlVOX0NZQyAqLworCQkJCWJyZWFrOworCQkJY2FzZSAweDYwMGY0OgkvKiBQTV9SVU5fQ1lDICovCisJCQkJYWx0W2orK10gPSAweDFlOworCQkJCWJyZWFrOworCQkJY2FzZSAweDI6CS8qIFBNX1BQQ19DTVBMICovCisJCQkJYWx0W2orK10gPSAweDUwMGZhOwkvKiBQTV9SVU5fSU5TVF9DTVBMICovCisJCQkJYnJlYWs7CisJCQljYXNlIDB4NTAwZmE6CS8qIFBNX1JVTl9JTlNUX0NNUEwgKi8KKwkJCQlhbHRbaisrXSA9IDB4MjsJLyogUE1fUFBDX0NNUEwgKi8KKwkJCQlicmVhazsKKwkJCX0KKwkJfQorCQluYWx0ID0gajsKKwl9CisKKwlyZXR1cm4gbmFsdDsKK30KKworLyoKKyAqIFJldHVybnMgMSBpZiBldmVudCBjb3VudHMgdGhpbmdzIHJlbGF0aW5nIHRvIG1hcmtlZCBpbnN0cnVjdGlvbnMKKyAqIGFuZCB0aHVzIG5lZWRzIHRoZSBNTUNSQV9TQU1QTEVfRU5BQkxFIGJpdCBzZXQsIG9yIDAgaWYgbm90LgorICovCitzdGF0aWMgaW50IHBvd2VyN19tYXJrZWRfaW5zdHJfZXZlbnQodTY0IGV2ZW50KQoreworCWludCBwbWMsIHBzZWw7CisJaW50IHVuaXQ7CisKKwlwbWMgPSAoZXZlbnQgPj4gUE1fUE1DX1NIKSAmIFBNX1BNQ19NU0s7CisJdW5pdCA9IChldmVudCA+PiBQTV9VTklUX1NIKSAmIFBNX1VOSVRfTVNLOworCXBzZWwgPSBldmVudCAmIFBNX1BNQ1NFTF9NU0sgJiB+MTsJLyogdHJpbSBvZmYgZWRnZS9sZXZlbCBiaXQgKi8KKwlpZiAocG1jID49IDUpCisJCXJldHVybiAwOworCisJc3dpdGNoIChwc2VsID4+IDQpIHsKKwljYXNlIDI6CisJCXJldHVybiBwbWMgPT0gMiB8fCBwbWMgPT0gNDsKKwljYXNlIDM6CisJCWlmIChwc2VsID09IDB4M2MpCisJCQlyZXR1cm4gcG1jID09IDE7CisJCWlmIChwc2VsID09IDB4M2UpCisJCQlyZXR1cm4gcG1jICE9IDI7CisJCXJldHVybiAxOworCWNhc2UgNDoKKwljYXNlIDU6CisJCXJldHVybiB1bml0ID09IDB4ZDsKKwljYXNlIDY6CisJCWlmIChwc2VsID09IDB4NjQpCisJCQlyZXR1cm4gcG1jID49IDM7CisJY2FzZSA4OgorCQlyZXR1cm4gdW5pdCA9PSAweGQ7CisJfQorCXJldHVybiAwOworfQorCitzdGF0aWMgaW50IHBvd2VyN19jb21wdXRlX21tY3IodTY0IGV2ZW50W10sIGludCBuX2V2LAorCQkJICAgICAgIHVuc2lnbmVkIGludCBod2NbXSwgdTY0IG1tY3JbXSkKK3sKKwl1NjQgbW1jcjEgPSAwOworCXU2NCBtbWNyYSA9IDA7CisJdW5zaWduZWQgaW50IHBtYywgdW5pdCwgY29tYmluZSwgbDJzZWwsIHBzZWw7CisJdW5zaWduZWQgaW50IHBtY19pbnVzZSA9IDA7CisJaW50IGk7CisKKwkvKiBGaXJzdCBwYXNzIHRvIGNvdW50IHJlc291cmNlIHVzZSAqLworCWZvciAoaSA9IDA7IGkgPCBuX2V2OyArK2kpIHsKKwkJcG1jID0gKGV2ZW50W2ldID4+IFBNX1BNQ19TSCkgJiBQTV9QTUNfTVNLOworCQlpZiAocG1jKSB7CisJCQlpZiAocG1jID4gNikKKwkJCQlyZXR1cm4gLTE7CisJCQlpZiAocG1jX2ludXNlICYgKDEgPDwgKHBtYyAtIDEpKSkKKwkJCQlyZXR1cm4gLTE7CisJCQlwbWNfaW51c2UgfD0gMSA8PCAocG1jIC0gMSk7CisJCX0KKwl9CisKKwkvKiBTZWNvbmQgcGFzczogYXNzaWduIFBNQ3MsIHNldCBhbGwgTU1DUjEgZmllbGRzICovCisJZm9yIChpID0gMDsgaSA8IG5fZXY7ICsraSkgeworCQlwbWMgPSAoZXZlbnRbaV0gPj4gUE1fUE1DX1NIKSAmIFBNX1BNQ19NU0s7CisJCXVuaXQgPSAoZXZlbnRbaV0gPj4gUE1fVU5JVF9TSCkgJiBQTV9VTklUX01TSzsKKwkJY29tYmluZSA9IChldmVudFtpXSA+PiBQTV9DT01CSU5FX1NIKSAmIFBNX0NPTUJJTkVfTVNLOworCQlsMnNlbCA9IChldmVudFtpXSA+PiBQTV9MMlNFTF9TSCkgJiBQTV9MMlNFTF9NU0s7CisJCXBzZWwgPSBldmVudFtpXSAmIFBNX1BNQ1NFTF9NU0s7CisJCWlmICghcG1jKSB7CisJCQkvKiBCdXMgZXZlbnQgb3IgYW55LVBNQyBkaXJlY3QgZXZlbnQgKi8KKwkJCWZvciAocG1jID0gMDsgcG1jIDwgNDsgKytwbWMpIHsKKwkJCQlpZiAoIShwbWNfaW51c2UgJiAoMSA8PCBwbWMpKSkKKwkJCQkJYnJlYWs7CisJCQl9CisJCQlpZiAocG1jID49IDQpCisJCQkJcmV0dXJuIC0xOworCQkJcG1jX2ludXNlIHw9IDEgPDwgcG1jOworCQl9IGVsc2UgeworCQkJLyogRGlyZWN0IG9yIGRlY29kZWQgZXZlbnQgKi8KKwkJCS0tcG1jOworCQl9CisJCWlmIChwbWMgPD0gMykgeworCQkJbW1jcjEgfD0gKHU2NCkgdW5pdCA8PCAoTU1DUjFfVFRNMFNFTF9TSCAtIDQgKiBwbWMpOworCQkJbW1jcjEgfD0gKHU2NCkgY29tYmluZSA8PCAoTU1DUjFfUE1DMV9DT01CSU5FX1NIIC0gcG1jKTsKKwkJCW1tY3IxIHw9IHBzZWwgPDwgTU1DUjFfUE1DU0VMX1NIKHBtYyk7CisJCQlpZiAodW5pdCA9PSA2KQkvKiBMMiBldmVudHMgKi8KKwkJCQltbWNyMSB8PSAodTY0KSBsMnNlbCA8PCBNTUNSMV9MMlNFTF9TSDsKKwkJfQorCQlpZiAocG93ZXI3X21hcmtlZF9pbnN0cl9ldmVudChldmVudFtpXSkpCisJCQltbWNyYSB8PSBNTUNSQV9TQU1QTEVfRU5BQkxFOworCQlod2NbaV0gPSBwbWM7CisJfQorCisJLyogUmV0dXJuIE1NQ1J4IHZhbHVlcyAqLworCW1tY3JbMF0gPSAwOworCWlmIChwbWNfaW51c2UgJiAxKQorCQltbWNyWzBdID0gTU1DUjBfUE1DMUNFOworCWlmIChwbWNfaW51c2UgJiAweDNlKQorCQltbWNyWzBdIHw9IE1NQ1IwX1BNQ2pDRTsKKwltbWNyWzFdID0gbW1jcjE7CisJbW1jclsyXSA9IG1tY3JhOworCXJldHVybiAwOworfQorCitzdGF0aWMgdm9pZCBwb3dlcjdfZGlzYWJsZV9wbWModW5zaWduZWQgaW50IHBtYywgdTY0IG1tY3JbXSkKK3sKKwlpZiAocG1jIDw9IDMpCisJCW1tY3JbMV0gJj0gfigweGZmVUxMIDw8IE1NQ1IxX1BNQ1NFTF9TSChwbWMpKTsKK30KKworc3RhdGljIGludCBwb3dlcjdfZ2VuZXJpY19ldmVudHNbXSA9IHsKKwlbUEVSRl9DT1VOVF9DUFVfQ1lDTEVTXSA9IDB4MWUsCisJW1BFUkZfQ09VTlRfSU5TVFJVQ1RJT05TXSA9IDIsCisJW1BFUkZfQ09VTlRfQ0FDSEVfUkVGRVJFTkNFU10gPSAweGM4ODAsCQkvKiBMRF9SRUZfTDFfTFNVICovCisJW1BFUkZfQ09VTlRfQ0FDSEVfTUlTU0VTXSA9IDB4NDAwZjAsCQkvKiBMRF9NSVNTX0wxICovCisJW1BFUkZfQ09VTlRfQlJBTkNIX0lOU1RSVUNUSU9OU10gPSAweDEwMDY4LAkvKiBCUlVfRklOICovCisJW1BFUkZfQ09VTlRfQlJBTkNIX01JU1NFU10gPSAweDQwMGY2LAkJLyogQlJfTVBSRUQgKi8KK307CisKKyNkZWZpbmUgQyh4KQlQRVJGX0NPVU5UX0hXX0NBQ0hFXyMjeAorCisvKgorICogVGFibGUgb2YgZ2VuZXJhbGl6ZWQgY2FjaGUtcmVsYXRlZCBldmVudHMuCisgKiAwIG1lYW5zIG5vdCBzdXBwb3J0ZWQsIC0xIG1lYW5zIG5vbnNlbnNpY2FsLCBvdGhlciB2YWx1ZXMKKyAqIGFyZSBldmVudCBjb2Rlcy4KKyAqLworc3RhdGljIGludCBwb3dlcjdfY2FjaGVfZXZlbnRzW0MoTUFYKV1bQyhPUF9NQVgpXVtDKFJFU1VMVF9NQVgpXSA9IHsKKwlbQyhMMUQpXSA9IHsJCS8qIAlSRVNVTFRfQUNDRVNTCVJFU1VMVF9NSVNTICovCisJCVtDKE9QX1JFQUQpXSA9IHsJMHg0MDBmMCwJMHhjODgwCX0sCisJCVtDKE9QX1dSSVRFKV0gPSB7CTAsCQkweDMwMGYwCX0sCisJCVtDKE9QX1BSRUZFVENIKV0gPSB7CTB4ZDhiOCwJCTAJfSwKKwl9LAorCVtDKEwxSSldID0gewkJLyogCVJFU1VMVF9BQ0NFU1MJUkVTVUxUX01JU1MgKi8KKwkJW0MoT1BfUkVBRCldID0gewkwLAkJMHgyMDBmYwl9LAorCQlbQyhPUF9XUklURSldID0gewktMSwJCS0xCX0sCisJCVtDKE9QX1BSRUZFVENIKV0gPSB7CTB4NDA4YSwJCTAJfSwKKwl9LAorCVtDKExMKV0gPSB7CQkvKiAJUkVTVUxUX0FDQ0VTUwlSRVNVTFRfTUlTUyAqLworCQlbQyhPUF9SRUFEKV0gPSB7CTB4NjA4MCwJCTB4NjA4NAl9LAorCQlbQyhPUF9XUklURSldID0gewkweDYwODIsCQkweDYwODYJfSwKKwkJW0MoT1BfUFJFRkVUQ0gpXSA9IHsJMCwJCTAJfSwKKwl9LAorCVtDKERUTEIpXSA9IHsJCS8qIAlSRVNVTFRfQUNDRVNTCVJFU1VMVF9NSVNTICovCisJCVtDKE9QX1JFQUQpXSA9IHsJMCwJCTB4MzAwZmMJfSwKKwkJW0MoT1BfV1JJVEUpXSA9IHsJLTEsCQktMQl9LAorCQlbQyhPUF9QUkVGRVRDSCldID0gewktMSwJCS0xCX0sCisJfSwKKwlbQyhJVExCKV0gPSB7CQkvKiAJUkVTVUxUX0FDQ0VTUwlSRVNVTFRfTUlTUyAqLworCQlbQyhPUF9SRUFEKV0gPSB7CTAsCQkweDQwMGZjCX0sCisJCVtDKE9QX1dSSVRFKV0gPSB7CS0xLAkJLTEJfSwKKwkJW0MoT1BfUFJFRkVUQ0gpXSA9IHsJLTEsCQktMQl9LAorCX0sCisJW0MoQlBVKV0gPSB7CQkvKiAJUkVTVUxUX0FDQ0VTUwlSRVNVTFRfTUlTUyAqLworCQlbQyhPUF9SRUFEKV0gPSB7CTB4MTAwNjgsCTB4NDAwZjYJfSwKKwkJW0MoT1BfV1JJVEUpXSA9IHsJLTEsCQktMQl9LAorCQlbQyhPUF9QUkVGRVRDSCldID0gewktMSwJCS0xCX0sCisJfSwKK307CisKK3N0cnVjdCBwb3dlcl9wbXUgcG93ZXI3X3BtdSA9IHsKKwkubl9jb3VudGVyID0gNiwKKwkubWF4X2FsdGVybmF0aXZlcyA9IE1BWF9BTFQgKyAxLAorCS5hZGRfZmllbGRzID0gMHgxNTU1dWxsLAorCS50ZXN0X2FkZGVyID0gMHgzMDAwdWxsLAorCS5jb21wdXRlX21tY3IgPSBwb3dlcjdfY29tcHV0ZV9tbWNyLAorCS5nZXRfY29uc3RyYWludCA9IHBvd2VyN19nZXRfY29uc3RyYWludCwKKwkuZ2V0X2FsdGVybmF0aXZlcyA9IHBvd2VyN19nZXRfYWx0ZXJuYXRpdmVzLAorCS5kaXNhYmxlX3BtYyA9IHBvd2VyN19kaXNhYmxlX3BtYywKKwkubl9nZW5lcmljID0gQVJSQVlfU0laRShwb3dlcjdfZ2VuZXJpY19ldmVudHMpLAorCS5nZW5lcmljX2V2ZW50cyA9IHBvd2VyN19nZW5lcmljX2V2ZW50cywKKwkuY2FjaGVfZXZlbnRzID0gJnBvd2VyN19jYWNoZV9ldmVudHMsCit9OwpkaWZmIC0tZ2l0IGEvYXJjaC9wb3dlcnBjL2tlcm5lbC9wcGM5NzAtcG11LmMgYi9hcmNoL3Bvd2VycGMva2VybmVsL3BwYzk3MC1wbXUuYwpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi5iYTBhMzU3Ci0tLSAvZGV2L251bGwKKysrIGIvYXJjaC9wb3dlcnBjL2tlcm5lbC9wcGM5NzAtcG11LmMKQEAgLTAsMCArMSw0ODIgQEAKKy8qCisgKiBQZXJmb3JtYW5jZSBjb3VudGVyIHN1cHBvcnQgZm9yIFBQQzk3MC1mYW1pbHkgcHJvY2Vzc29ycy4KKyAqCisgKiBDb3B5cmlnaHQgMjAwOC0yMDA5IFBhdWwgTWFja2VycmFzLCBJQk0gQ29ycG9yYXRpb24uCisgKgorICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vcgorICogbW9kaWZ5IGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UKKyAqIGFzIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uOyBlaXRoZXIgdmVyc2lvbgorICogMiBvZiB0aGUgTGljZW5zZSwgb3IgKGF0IHlvdXIgb3B0aW9uKSBhbnkgbGF0ZXIgdmVyc2lvbi4KKyAqLworI2luY2x1ZGUgPGxpbnV4L3N0cmluZy5oPgorI2luY2x1ZGUgPGxpbnV4L3BlcmZfY291bnRlci5oPgorI2luY2x1ZGUgPGFzbS9yZWcuaD4KKworLyoKKyAqIEJpdHMgaW4gZXZlbnQgY29kZSBmb3IgUFBDOTcwCisgKi8KKyNkZWZpbmUgUE1fUE1DX1NICTEyCS8qIFBNQyBudW1iZXIgKDEtYmFzZWQpIGZvciBkaXJlY3QgZXZlbnRzICovCisjZGVmaW5lIFBNX1BNQ19NU0sJMHhmCisjZGVmaW5lIFBNX1VOSVRfU0gJOAkvKiBUVE1NVVggbnVtYmVyIGFuZCBzZXR0aW5nIC0gdW5pdCBzZWxlY3QgKi8KKyNkZWZpbmUgUE1fVU5JVF9NU0sJMHhmCisjZGVmaW5lIFBNX1NQQ1NFTF9TSAk2CisjZGVmaW5lIFBNX1NQQ1NFTF9NU0sJMworI2RlZmluZSBQTV9CWVRFX1NICTQJLyogQnl0ZSBudW1iZXIgb2YgZXZlbnQgYnVzIHRvIHVzZSAqLworI2RlZmluZSBQTV9CWVRFX01TSwkzCisjZGVmaW5lIFBNX1BNQ1NFTF9NU0sJMHhmCisKKy8qIFZhbHVlcyBpbiBQTV9VTklUIGZpZWxkICovCisjZGVmaW5lIFBNX05PTkUJCTAKKyNkZWZpbmUgUE1fRlBVCQkxCisjZGVmaW5lIFBNX1ZQVQkJMgorI2RlZmluZSBQTV9JU1UJCTMKKyNkZWZpbmUgUE1fSUZVCQk0CisjZGVmaW5lIFBNX0lEVQkJNQorI2RlZmluZSBQTV9TVFMJCTYKKyNkZWZpbmUgUE1fTFNVMAkJNworI2RlZmluZSBQTV9MU1UxVQk4CisjZGVmaW5lIFBNX0xTVTFMCTkKKyNkZWZpbmUgUE1fTEFTVFVOSVQJOQorCisvKgorICogQml0cyBpbiBNTUNSMCBmb3IgUFBDOTcwCisgKi8KKyNkZWZpbmUgTU1DUjBfUE1DMVNFTF9TSAk4CisjZGVmaW5lIE1NQ1IwX1BNQzJTRUxfU0gJMQorI2RlZmluZSBNTUNSX1BNQ1NFTF9NU0sJCTB4MWYKKworLyoKKyAqIEJpdHMgaW4gTU1DUjEgZm9yIFBQQzk3MAorICovCisjZGVmaW5lIE1NQ1IxX1RUTTBTRUxfU0gJNjIKKyNkZWZpbmUgTU1DUjFfVFRNMVNFTF9TSAk1OQorI2RlZmluZSBNTUNSMV9UVE0zU0VMX1NICTUzCisjZGVmaW5lIE1NQ1IxX1RUTVNFTF9NU0sJMworI2RlZmluZSBNTUNSMV9URF9DUF9EQkcwU0VMX1NICTUwCisjZGVmaW5lIE1NQ1IxX1REX0NQX0RCRzFTRUxfU0gJNDgKKyNkZWZpbmUgTU1DUjFfVERfQ1BfREJHMlNFTF9TSAk0NgorI2RlZmluZSBNTUNSMV9URF9DUF9EQkczU0VMX1NICTQ0CisjZGVmaW5lIE1NQ1IxX1BNQzFfQURERVJfU0VMX1NICTM5CisjZGVmaW5lIE1NQ1IxX1BNQzJfQURERVJfU0VMX1NICTM4CisjZGVmaW5lIE1NQ1IxX1BNQzZfQURERVJfU0VMX1NICTM3CisjZGVmaW5lIE1NQ1IxX1BNQzVfQURERVJfU0VMX1NICTM2CisjZGVmaW5lIE1NQ1IxX1BNQzhfQURERVJfU0VMX1NICTM1CisjZGVmaW5lIE1NQ1IxX1BNQzdfQURERVJfU0VMX1NICTM0CisjZGVmaW5lIE1NQ1IxX1BNQzNfQURERVJfU0VMX1NICTMzCisjZGVmaW5lIE1NQ1IxX1BNQzRfQURERVJfU0VMX1NICTMyCisjZGVmaW5lIE1NQ1IxX1BNQzNTRUxfU0gJMjcKKyNkZWZpbmUgTU1DUjFfUE1DNFNFTF9TSAkyMgorI2RlZmluZSBNTUNSMV9QTUM1U0VMX1NICTE3CisjZGVmaW5lIE1NQ1IxX1BNQzZTRUxfU0gJMTIKKyNkZWZpbmUgTU1DUjFfUE1DN1NFTF9TSAk3CisjZGVmaW5lIE1NQ1IxX1BNQzhTRUxfU0gJMgorCitzdGF0aWMgc2hvcnQgbW1jcjFfYWRkZXJfYml0c1s4XSA9IHsKKwlNTUNSMV9QTUMxX0FEREVSX1NFTF9TSCwKKwlNTUNSMV9QTUMyX0FEREVSX1NFTF9TSCwKKwlNTUNSMV9QTUMzX0FEREVSX1NFTF9TSCwKKwlNTUNSMV9QTUM0X0FEREVSX1NFTF9TSCwKKwlNTUNSMV9QTUM1X0FEREVSX1NFTF9TSCwKKwlNTUNSMV9QTUM2X0FEREVSX1NFTF9TSCwKKwlNTUNSMV9QTUM3X0FEREVSX1NFTF9TSCwKKwlNTUNSMV9QTUM4X0FEREVSX1NFTF9TSAorfTsKKworLyoKKyAqIEJpdHMgaW4gTU1DUkEKKyAqLworCisvKgorICogTGF5b3V0IG9mIGNvbnN0cmFpbnQgYml0czoKKyAqIDY2NjY1NTU1NTU1NTU1NDQ0NDQ0NDQ0NDMzMzMzMzMzMzMyMjIyMjIyMjIyMTExMTExMTExMTAwMDAwMDAwMDAKKyAqIDMyMTA5ODc2NTQzMjEwOTg3NjU0MzIxMDk4NzY1NDMyMTA5ODc2NTQzMjEwOTg3NjU0MzIxMDk4NzY1NDMyMTAKKyAqICAgICAgICAgICAgICAgPD48Pjw+WyAgPlsgID5bICA+PCAgPjwgID48ICA+PCAgPjw+PD48Pjw+PD48Pjw+PD4KKyAqICAgICAgICAgICAgICAgU1BUMFQxIFVDICBQUzEgUFMyIEIwICBCMSAgQjIgIEIzIFAxUDJQM1A0UDVQNlA3UDgKKyAqCisgKiBTUCAtIFNQQ1NFTCBjb25zdHJhaW50CisgKiAgICAgNDgtNDk6IFNQQ1NFTCB2YWx1ZSAweDNfMDAwMF8wMDAwXzAwMDAKKyAqCisgKiBUMCAtIFRUTTAgY29uc3RyYWludAorICogICAgIDQ2LTQ3OiBUVE0wU0VMIHZhbHVlICgwPUZQVSwgMj1JRlUsIDM9VlBVKSAweEMwMDBfMDAwMF8wMDAwCisgKgorICogVDEgLSBUVE0xIGNvbnN0cmFpbnQKKyAqICAgICA0NC00NTogVFRNMVNFTCB2YWx1ZSAoMD1JRFUsIDM9U1RTKSAweDMwMDBfMDAwMF8wMDAwCisgKgorICogVUMgLSB1bml0IGNvbnN0cmFpbnQ6IGNhbid0IGhhdmUgYWxsIHRocmVlIG9mIEZQVXxJRlV8VlBVLCBJU1UsIElEVXxTVFMKKyAqICAgICA0MzogVUMzIGVycm9yIDB4MDgwMF8wMDAwXzAwMDAKKyAqICAgICA0MjogRlBVfElGVXxWUFUgZXZlbnRzIG5lZWRlZCAweDA0MDBfMDAwMF8wMDAwCisgKiAgICAgNDE6IElTVSBldmVudHMgbmVlZGVkIDB4MDIwMF8wMDAwXzAwMDAKKyAqICAgICA0MDogSURVfFNUUyBldmVudHMgbmVlZGVkIDB4MDEwMF8wMDAwXzAwMDAKKyAqCisgKiBQUzEKKyAqICAgICAzOTogUFMxIGVycm9yIDB4MDA4MF8wMDAwXzAwMDAKKyAqICAgICAzNi0zODogY291bnQgb2YgZXZlbnRzIG5lZWRpbmcgUE1DMS8yLzUvNiAweDAwNzBfMDAwMF8wMDAwCisgKgorICogUFMyCisgKiAgICAgMzU6IFBTMiBlcnJvciAweDAwMDhfMDAwMF8wMDAwCisgKiAgICAgMzItMzQ6IGNvdW50IG9mIGV2ZW50cyBuZWVkaW5nIFBNQzMvNC83LzggMHgwMDA3XzAwMDBfMDAwMAorICoKKyAqIEIwCisgKiAgICAgMjgtMzE6IEJ5dGUgMCBldmVudCBzb3VyY2UgMHhmMDAwXzAwMDAKKyAqCSAgICAgIEVuY29kaW5nIGFzIGZvciB0aGUgZXZlbnQgY29kZQorICoKKyAqIEIxLCBCMiwgQjMKKyAqICAgICAyNC0yNywgMjAtMjMsIDE2LTE5OiBCeXRlIDEsIDIsIDMgZXZlbnQgc291cmNlcworICoKKyAqIFAxCisgKiAgICAgMTU6IFAxIGVycm9yIDB4ODAwMAorICogICAgIDE0LTE1OiBDb3VudCBvZiBldmVudHMgbmVlZGluZyBQTUMxCisgKgorICogUDIuLlA4CisgKiAgICAgMC0xMzogQ291bnQgb2YgZXZlbnRzIG5lZWRpbmcgUE1DMi4uUE1DOAorICovCisKK3N0YXRpYyB1bnNpZ25lZCBjaGFyIGRpcmVjdF9tYXJrZWRfZXZlbnRbOF0gPSB7CisJKDE8PDIpIHwgKDE8PDMpLAkvKiBQTUMxOiBQTV9NUktfR1JQX0RJU1AsIFBNX01SS19TVF9DTVBMICovCisJKDE8PDMpIHwgKDE8PDUpLAkvKiBQTUMyOiBQTV9USFJFU0hfVElNRU8sIFBNX01SS19CUlVfRklOICovCisJKDE8PDMpIHwgKDE8PDUpLAkvKiBQTUMzOiBQTV9NUktfU1RfQ01QTF9JTlQsIFBNX01SS19WTVhfRklOICovCisJKDE8PDQpIHwgKDE8PDUpLAkvKiBQTUM0OiBQTV9NUktfR1JQX0NNUEwsIFBNX01SS19DUlVfRklOICovCisJKDE8PDQpIHwgKDE8PDUpLAkvKiBQTUM1OiBQTV9HUlBfTVJLLCBQTV9NUktfR1JQX1RJTUVPICovCisJKDE8PDMpIHwgKDE8PDQpIHwgKDE8PDUpLAorCQkvKiBQTUM2OiBQTV9NUktfU1RfU1RTLCBQTV9NUktfRlhVX0ZJTiwgUE1fTVJLX0dSUF9JU1NVRUQgKi8KKwkoMTw8NCkgfCAoMTw8NSksCS8qIFBNQzc6IFBNX01SS19GUFVfRklOLCBQTV9NUktfSU5TVF9GSU4gKi8KKwkoMTw8NCkJCQkvKiBQTUM4OiBQTV9NUktfTFNVX0ZJTiAqLworfTsKKworLyoKKyAqIFJldHVybnMgMSBpZiBldmVudCBjb3VudHMgdGhpbmdzIHJlbGF0aW5nIHRvIG1hcmtlZCBpbnN0cnVjdGlvbnMKKyAqIGFuZCB0aHVzIG5lZWRzIHRoZSBNTUNSQV9TQU1QTEVfRU5BQkxFIGJpdCBzZXQsIG9yIDAgaWYgbm90LgorICovCitzdGF0aWMgaW50IHA5NzBfbWFya2VkX2luc3RyX2V2ZW50KHU2NCBldmVudCkKK3sKKwlpbnQgcG1jLCBwc2VsLCB1bml0LCBieXRlLCBiaXQ7CisJdW5zaWduZWQgaW50IG1hc2s7CisKKwlwbWMgPSAoZXZlbnQgPj4gUE1fUE1DX1NIKSAmIFBNX1BNQ19NU0s7CisJcHNlbCA9IGV2ZW50ICYgUE1fUE1DU0VMX01TSzsKKwlpZiAocG1jKSB7CisJCWlmIChkaXJlY3RfbWFya2VkX2V2ZW50W3BtYyAtIDFdICYgKDEgPDwgcHNlbCkpCisJCQlyZXR1cm4gMTsKKwkJaWYgKHBzZWwgPT0gMCkJCS8qIGFkZCBldmVudHMgKi8KKwkJCWJpdCA9IChwbWMgPD0gNCk/IHBtYyAtIDE6IDggLSBwbWM7CisJCWVsc2UgaWYgKHBzZWwgPT0gNyB8fCBwc2VsID09IDEzKQkvKiBkZWNvZGUgZXZlbnRzICovCisJCQliaXQgPSA0OworCQllbHNlCisJCQlyZXR1cm4gMDsKKwl9IGVsc2UKKwkJYml0ID0gcHNlbDsKKworCWJ5dGUgPSAoZXZlbnQgPj4gUE1fQllURV9TSCkgJiBQTV9CWVRFX01TSzsKKwl1bml0ID0gKGV2ZW50ID4+IFBNX1VOSVRfU0gpICYgUE1fVU5JVF9NU0s7CisJbWFzayA9IDA7CisJc3dpdGNoICh1bml0KSB7CisJY2FzZSBQTV9WUFU6CisJCW1hc2sgPSAweDRjOwkJLyogYnl0ZSAwIGJpdHMgMiwzLDYgKi8KKwljYXNlIFBNX0xTVTA6CisJCS8qIGJ5dGUgMiBiaXRzIDAsMiwzLDQsNjsgYWxsIG9mIGJ5dGUgMSAqLworCQltYXNrID0gMHgwODVkZmYwMDsKKwljYXNlIFBNX0xTVTFMOgorCQltYXNrID0gMHg1MCA8PCAyNDsJLyogYnl0ZSAzIGJpdHMgNCw2ICovCisJCWJyZWFrOworCX0KKwlyZXR1cm4gKG1hc2sgPj4gKGJ5dGUgKiA4ICsgYml0KSkgJiAxOworfQorCisvKiBNYXNrcyBhbmQgdmFsdWVzIGZvciB1c2luZyBldmVudHMgZnJvbSB0aGUgdmFyaW91cyB1bml0cyAqLworc3RhdGljIHU2NCB1bml0X2NvbnNbUE1fTEFTVFVOSVQrMV1bMl0gPSB7CisJW1BNX0ZQVV0gPSAgIHsgMHhjODAwMDAwMDAwMDB1bGwsIDB4MDQwMDAwMDAwMDAwdWxsIH0sCisJW1BNX1ZQVV0gPSAgIHsgMHhjODAwMDAwMDAwMDB1bGwsIDB4YzQwMDAwMDAwMDAwdWxsIH0sCisJW1BNX0lTVV0gPSAgIHsgMHgwODAwMDAwMDAwMDB1bGwsIDB4MDIwMDAwMDAwMDAwdWxsIH0sCisJW1BNX0lGVV0gPSAgIHsgMHhjODAwMDAwMDAwMDB1bGwsIDB4ODQwMDAwMDAwMDAwdWxsIH0sCisJW1BNX0lEVV0gPSAgIHsgMHgzODAwMDAwMDAwMDB1bGwsIDB4MDEwMDAwMDAwMDAwdWxsIH0sCisJW1BNX1NUU10gPSAgIHsgMHgzODAwMDAwMDAwMDB1bGwsIDB4MzEwMDAwMDAwMDAwdWxsIH0sCit9OworCitzdGF0aWMgaW50IHA5NzBfZ2V0X2NvbnN0cmFpbnQodTY0IGV2ZW50LCB1NjQgKm1hc2twLCB1NjQgKnZhbHApCit7CisJaW50IHBtYywgYnl0ZSwgdW5pdCwgc2gsIHNwY3NlbDsKKwl1NjQgbWFzayA9IDAsIHZhbHVlID0gMDsKKwlpbnQgZ3JwID0gLTE7CisKKwlwbWMgPSAoZXZlbnQgPj4gUE1fUE1DX1NIKSAmIFBNX1BNQ19NU0s7CisJaWYgKHBtYykgeworCQlpZiAocG1jID4gOCkKKwkJCXJldHVybiAtMTsKKwkJc2ggPSAocG1jIC0gMSkgKiAyOworCQltYXNrIHw9IDIgPDwgc2g7CisJCXZhbHVlIHw9IDEgPDwgc2g7CisJCWdycCA9ICgocG1jIC0gMSkgPj4gMSkgJiAxOworCX0KKwl1bml0ID0gKGV2ZW50ID4+IFBNX1VOSVRfU0gpICYgUE1fVU5JVF9NU0s7CisJaWYgKHVuaXQpIHsKKwkJaWYgKHVuaXQgPiBQTV9MQVNUVU5JVCkKKwkJCXJldHVybiAtMTsKKwkJbWFzayB8PSB1bml0X2NvbnNbdW5pdF1bMF07CisJCXZhbHVlIHw9IHVuaXRfY29uc1t1bml0XVsxXTsKKwkJYnl0ZSA9IChldmVudCA+PiBQTV9CWVRFX1NIKSAmIFBNX0JZVEVfTVNLOworCQkvKgorCQkgKiBCdXMgZXZlbnRzIG9uIGJ5dGVzIDAgYW5kIDIgY2FuIGJlIGNvdW50ZWQKKwkJICogb24gUE1DMS8yLzUvNjsgYnl0ZXMgMSBhbmQgMyBvbiBQTUMzLzQvNy84LgorCQkgKi8KKwkJaWYgKCFwbWMpCisJCQlncnAgPSBieXRlICYgMTsKKwkJLyogU2V0IGJ5dGUgbGFuZSBzZWxlY3QgZmllbGQgKi8KKwkJbWFzayAgfD0gMHhmVUxMIDw8ICgyOCAtIDQgKiBieXRlKTsKKwkJdmFsdWUgfD0gKHU2NCl1bml0IDw8ICgyOCAtIDQgKiBieXRlKTsKKwl9CisJaWYgKGdycCA9PSAwKSB7CisJCS8qIGluY3JlbWVudCBQTUMxLzIvNS82IGZpZWxkICovCisJCW1hc2sgIHw9IDB4ODAwMDAwMDAwMHVsbDsKKwkJdmFsdWUgfD0gMHgxMDAwMDAwMDAwdWxsOworCX0gZWxzZSBpZiAoZ3JwID09IDEpIHsKKwkJLyogaW5jcmVtZW50IFBNQzMvNC83LzggZmllbGQgKi8KKwkJbWFzayAgfD0gMHg4MDAwMDAwMDB1bGw7CisJCXZhbHVlIHw9IDB4MTAwMDAwMDAwdWxsOworCX0KKwlzcGNzZWwgPSAoZXZlbnQgPj4gUE1fU1BDU0VMX1NIKSAmIFBNX1NQQ1NFTF9NU0s7CisJaWYgKHNwY3NlbCkgeworCQltYXNrICB8PSAzdWxsIDw8IDQ4OworCQl2YWx1ZSB8PSAodTY0KXNwY3NlbCA8PCA0ODsKKwl9CisJKm1hc2twID0gbWFzazsKKwkqdmFscCA9IHZhbHVlOworCXJldHVybiAwOworfQorCitzdGF0aWMgaW50IHA5NzBfZ2V0X2FsdGVybmF0aXZlcyh1NjQgZXZlbnQsIHVuc2lnbmVkIGludCBmbGFncywgdTY0IGFsdFtdKQoreworCWFsdFswXSA9IGV2ZW50OworCisJLyogMiBhbHRlcm5hdGl2ZXMgZm9yIExTVSBlbXB0eSAqLworCWlmIChldmVudCA9PSAweDIwMDIgfHwgZXZlbnQgPT0gMHgzMDAyKSB7CisJCWFsdFsxXSA9IGV2ZW50IF4gMHgxMDAwOworCQlyZXR1cm4gMjsKKwl9CisJCQorCXJldHVybiAxOworfQorCitzdGF0aWMgaW50IHA5NzBfY29tcHV0ZV9tbWNyKHU2NCBldmVudFtdLCBpbnQgbl9ldiwKKwkJCSAgICAgdW5zaWduZWQgaW50IGh3Y1tdLCB1NjQgbW1jcltdKQoreworCXU2NCBtbWNyMCA9IDAsIG1tY3IxID0gMCwgbW1jcmEgPSAwOworCXVuc2lnbmVkIGludCBwbWMsIHVuaXQsIGJ5dGUsIHBzZWw7CisJdW5zaWduZWQgaW50IHR0bSwgZ3JwOworCXVuc2lnbmVkIGludCBwbWNfaW51c2UgPSAwOworCXVuc2lnbmVkIGludCBwbWNfZ3JwX3VzZVsyXTsKKwl1bnNpZ25lZCBjaGFyIGJ1c2J5dGVbNF07CisJdW5zaWduZWQgY2hhciB1bml0dXNlWzE2XTsKKwl1bnNpZ25lZCBjaGFyIHVuaXRtYXBbXSA9IHsgMCwgMDw8MywgMzw8MywgMTw8MywgMjw8MywgMHw0LCAzfDQgfTsKKwl1bnNpZ25lZCBjaGFyIHR0bXVzZVsyXTsKKwl1bnNpZ25lZCBjaGFyIHBtY3NlbFs4XTsKKwlpbnQgaTsKKwlpbnQgc3Bjc2VsOworCisJaWYgKG5fZXYgPiA4KQorCQlyZXR1cm4gLTE7CisKKwkvKiBGaXJzdCBwYXNzIHRvIGNvdW50IHJlc291cmNlIHVzZSAqLworCXBtY19ncnBfdXNlWzBdID0gcG1jX2dycF91c2VbMV0gPSAwOworCW1lbXNldChidXNieXRlLCAwLCBzaXplb2YoYnVzYnl0ZSkpOworCW1lbXNldCh1bml0dXNlLCAwLCBzaXplb2YodW5pdHVzZSkpOworCWZvciAoaSA9IDA7IGkgPCBuX2V2OyArK2kpIHsKKwkJcG1jID0gKGV2ZW50W2ldID4+IFBNX1BNQ19TSCkgJiBQTV9QTUNfTVNLOworCQlpZiAocG1jKSB7CisJCQlpZiAocG1jX2ludXNlICYgKDEgPDwgKHBtYyAtIDEpKSkKKwkJCQlyZXR1cm4gLTE7CisJCQlwbWNfaW51c2UgfD0gMSA8PCAocG1jIC0gMSk7CisJCQkvKiBjb3VudCAxLzIvNS82IHZzIDMvNC83LzggdXNlICovCisJCQkrK3BtY19ncnBfdXNlWygocG1jIC0gMSkgPj4gMSkgJiAxXTsKKwkJfQorCQl1bml0ID0gKGV2ZW50W2ldID4+IFBNX1VOSVRfU0gpICYgUE1fVU5JVF9NU0s7CisJCWJ5dGUgPSAoZXZlbnRbaV0gPj4gUE1fQllURV9TSCkgJiBQTV9CWVRFX01TSzsKKwkJaWYgKHVuaXQpIHsKKwkJCWlmICh1bml0ID4gUE1fTEFTVFVOSVQpCisJCQkJcmV0dXJuIC0xOworCQkJaWYgKCFwbWMpCisJCQkJKytwbWNfZ3JwX3VzZVtieXRlICYgMV07CisJCQlpZiAoYnVzYnl0ZVtieXRlXSAmJiBidXNieXRlW2J5dGVdICE9IHVuaXQpCisJCQkJcmV0dXJuIC0xOworCQkJYnVzYnl0ZVtieXRlXSA9IHVuaXQ7CisJCQl1bml0dXNlW3VuaXRdID0gMTsKKwkJfQorCX0KKwlpZiAocG1jX2dycF91c2VbMF0gPiA0IHx8IHBtY19ncnBfdXNlWzFdID4gNCkKKwkJcmV0dXJuIC0xOworCisJLyoKKwkgKiBBc3NpZ24gcmVzb3VyY2VzIGFuZCBzZXQgbXVsdGlwbGV4ZXIgc2VsZWN0cy4KKwkgKgorCSAqIFBNX0lTVSBjYW4gZ28gZWl0aGVyIG9uIFRUTTAgb3IgVFRNMSwgYnV0IHRoYXQncyB0aGUgb25seQorCSAqIGNob2ljZSB3ZSBoYXZlIHRvIGRlYWwgd2l0aC4KKwkgKi8KKwlpZiAodW5pdHVzZVtQTV9JU1VdICYKKwkgICAgKHVuaXR1c2VbUE1fRlBVXSB8IHVuaXR1c2VbUE1fSUZVXSB8IHVuaXR1c2VbUE1fVlBVXSkpCisJCXVuaXRtYXBbUE1fSVNVXSA9IDIgfCA0OwkvKiBtb3ZlIElTVSB0byBUVE0xICovCisJLyogU2V0IFRUTVswMV1TRUwgZmllbGRzLiAqLworCXR0bXVzZVswXSA9IHR0bXVzZVsxXSA9IDA7CisJZm9yIChpID0gUE1fRlBVOyBpIDw9IFBNX1NUUzsgKytpKSB7CisJCWlmICghdW5pdHVzZVtpXSkKKwkJCWNvbnRpbnVlOworCQl0dG0gPSB1bml0bWFwW2ldOworCQkrK3R0bXVzZVsodHRtID4+IDIpICYgMV07CisJCW1tY3IxIHw9ICh1NjQpKHR0bSAmIH40KSA8PCBNTUNSMV9UVE0xU0VMX1NIOworCX0KKwkvKiBDaGVjayBvbmx5IG9uZSB1bml0IHBlciBUVE14ICovCisJaWYgKHR0bXVzZVswXSA+IDEgfHwgdHRtdXNlWzFdID4gMSkKKwkJcmV0dXJuIC0xOworCisJLyogU2V0IGJ5dGUgbGFuZSBzZWxlY3QgZmllbGRzIGFuZCBUVE0zU0VMLiAqLworCWZvciAoYnl0ZSA9IDA7IGJ5dGUgPCA0OyArK2J5dGUpIHsKKwkJdW5pdCA9IGJ1c2J5dGVbYnl0ZV07CisJCWlmICghdW5pdCkKKwkJCWNvbnRpbnVlOworCQlpZiAodW5pdCA8PSBQTV9TVFMpCisJCQl0dG0gPSAodW5pdG1hcFt1bml0XSA+PiAyKSAmIDE7CisJCWVsc2UgaWYgKHVuaXQgPT0gUE1fTFNVMCkKKwkJCXR0bSA9IDI7CisJCWVsc2UgeworCQkJdHRtID0gMzsKKwkJCWlmICh1bml0ID09IFBNX0xTVTFMICYmIGJ5dGUgPj0gMikKKwkJCQltbWNyMSB8PSAxdWxsIDw8IChNTUNSMV9UVE0zU0VMX1NIICsgMyAtIGJ5dGUpOworCQl9CisJCW1tY3IxIHw9ICh1NjQpdHRtIDw8IChNTUNSMV9URF9DUF9EQkcwU0VMX1NIIC0gMiAqIGJ5dGUpOworCX0KKworCS8qIFNlY29uZCBwYXNzOiBhc3NpZ24gUE1Dcywgc2V0IFBNQ3hTRUwgYW5kIFBNQ3hfQURERVJfU0VMIGZpZWxkcyAqLworCW1lbXNldChwbWNzZWwsIDB4OCwgc2l6ZW9mKHBtY3NlbCkpOwkvKiA4IG1lYW5zIGRvbid0IGNvdW50ICovCisJZm9yIChpID0gMDsgaSA8IG5fZXY7ICsraSkgeworCQlwbWMgPSAoZXZlbnRbaV0gPj4gUE1fUE1DX1NIKSAmIFBNX1BNQ19NU0s7CisJCXVuaXQgPSAoZXZlbnRbaV0gPj4gUE1fVU5JVF9TSCkgJiBQTV9VTklUX01TSzsKKwkJYnl0ZSA9IChldmVudFtpXSA+PiBQTV9CWVRFX1NIKSAmIFBNX0JZVEVfTVNLOworCQlwc2VsID0gZXZlbnRbaV0gJiBQTV9QTUNTRUxfTVNLOworCQlpZiAoIXBtYykgeworCQkJLyogQnVzIGV2ZW50IG9yIGFueS1QTUMgZGlyZWN0IGV2ZW50ICovCisJCQlpZiAodW5pdCkKKwkJCQlwc2VsIHw9IDB4MTAgfCAoKGJ5dGUgJiAyKSA8PCAyKTsKKwkJCWVsc2UKKwkJCQlwc2VsIHw9IDg7CisJCQlmb3IgKHBtYyA9IDA7IHBtYyA8IDg7ICsrcG1jKSB7CisJCQkJaWYgKHBtY19pbnVzZSAmICgxIDw8IHBtYykpCisJCQkJCWNvbnRpbnVlOworCQkJCWdycCA9IChwbWMgPj4gMSkgJiAxOworCQkJCWlmICh1bml0KSB7CisJCQkJCWlmIChncnAgPT0gKGJ5dGUgJiAxKSkKKwkJCQkJCWJyZWFrOworCQkJCX0gZWxzZSBpZiAocG1jX2dycF91c2VbZ3JwXSA8IDQpIHsKKwkJCQkJKytwbWNfZ3JwX3VzZVtncnBdOworCQkJCQlicmVhazsKKwkJCQl9CisJCQl9CisJCQlwbWNfaW51c2UgfD0gMSA8PCBwbWM7CisJCX0gZWxzZSB7CisJCQkvKiBEaXJlY3QgZXZlbnQgKi8KKwkJCS0tcG1jOworCQkJaWYgKHBzZWwgPT0gMCAmJiAoYnl0ZSAmIDIpKQorCQkJCS8qIGFkZCBldmVudHMgb24gaGlnaGVyLW51bWJlcmVkIGJ1cyAqLworCQkJCW1tY3IxIHw9IDF1bGwgPDwgbW1jcjFfYWRkZXJfYml0c1twbWNdOworCQl9CisJCXBtY3NlbFtwbWNdID0gcHNlbDsKKwkJaHdjW2ldID0gcG1jOworCQlzcGNzZWwgPSAoZXZlbnRbaV0gPj4gUE1fU1BDU0VMX1NIKSAmIFBNX1NQQ1NFTF9NU0s7CisJCW1tY3IxIHw9IHNwY3NlbDsKKwkJaWYgKHA5NzBfbWFya2VkX2luc3RyX2V2ZW50KGV2ZW50W2ldKSkKKwkJCW1tY3JhIHw9IE1NQ1JBX1NBTVBMRV9FTkFCTEU7CisJfQorCWZvciAocG1jID0gMDsgcG1jIDwgMjsgKytwbWMpCisJCW1tY3IwIHw9IHBtY3NlbFtwbWNdIDw8IChNTUNSMF9QTUMxU0VMX1NIIC0gNyAqIHBtYyk7CisJZm9yICg7IHBtYyA8IDg7ICsrcG1jKQorCQltbWNyMSB8PSAodTY0KXBtY3NlbFtwbWNdIDw8IChNTUNSMV9QTUMzU0VMX1NIIC0gNSAqIChwbWMgLSAyKSk7CisJaWYgKHBtY19pbnVzZSAmIDEpCisJCW1tY3IwIHw9IE1NQ1IwX1BNQzFDRTsKKwlpZiAocG1jX2ludXNlICYgMHhmZSkKKwkJbW1jcjAgfD0gTU1DUjBfUE1DakNFOworCisJbW1jcmEgfD0gMHgyMDAwOwkvKiBtYXJrIG9ubHkgb25lIElPUCBwZXIgUFBDIGluc3RydWN0aW9uICovCisKKwkvKiBSZXR1cm4gTU1DUnggdmFsdWVzICovCisJbW1jclswXSA9IG1tY3IwOworCW1tY3JbMV0gPSBtbWNyMTsKKwltbWNyWzJdID0gbW1jcmE7CisJcmV0dXJuIDA7Cit9CisKK3N0YXRpYyB2b2lkIHA5NzBfZGlzYWJsZV9wbWModW5zaWduZWQgaW50IHBtYywgdTY0IG1tY3JbXSkKK3sKKwlpbnQgc2hpZnQsIGk7CisKKwlpZiAocG1jIDw9IDEpIHsKKwkJc2hpZnQgPSBNTUNSMF9QTUMxU0VMX1NIIC0gNyAqIHBtYzsKKwkJaSA9IDA7CisJfSBlbHNlIHsKKwkJc2hpZnQgPSBNTUNSMV9QTUMzU0VMX1NIIC0gNSAqIChwbWMgLSAyKTsKKwkJaSA9IDE7CisJfQorCS8qCisJICogU2V0dGluZyB0aGUgUE1DeFNFTCBmaWVsZCB0byAweDA4IGRpc2FibGVzIFBNQyB4LgorCSAqLworCW1tY3JbaV0gPSAobW1jcltpXSAmIH4oMHgxZlVMIDw8IHNoaWZ0KSkgfCAoMHgwOFVMIDw8IHNoaWZ0KTsKK30KKworc3RhdGljIGludCBwcGM5NzBfZ2VuZXJpY19ldmVudHNbXSA9IHsKKwlbUEVSRl9DT1VOVF9IV19DUFVfQ1lDTEVTXQkJPSA3LAorCVtQRVJGX0NPVU5UX0hXX0lOU1RSVUNUSU9OU10JCT0gMSwKKwlbUEVSRl9DT1VOVF9IV19DQUNIRV9SRUZFUkVOQ0VTXQk9IDB4ODgxMCwgLyogUE1fTERfUkVGX0wxICovCisJW1BFUkZfQ09VTlRfSFdfQ0FDSEVfTUlTU0VTXQkJPSAweDM4MTAsIC8qIFBNX0xEX01JU1NfTDEgKi8KKwlbUEVSRl9DT1VOVF9IV19CUkFOQ0hfSU5TVFJVQ1RJT05TXQk9IDB4NDMxLCAgLyogUE1fQlJfSVNTVUVEICovCisJW1BFUkZfQ09VTlRfSFdfQlJBTkNIX01JU1NFU10gCQk9IDB4MzI3LCAgLyogUE1fR1JQX0JSX01QUkVEICovCit9OworCisjZGVmaW5lIEMoeCkJUEVSRl9DT1VOVF9IV19DQUNIRV8jI3gKKworLyoKKyAqIFRhYmxlIG9mIGdlbmVyYWxpemVkIGNhY2hlLXJlbGF0ZWQgZXZlbnRzLgorICogMCBtZWFucyBub3Qgc3VwcG9ydGVkLCAtMSBtZWFucyBub25zZW5zaWNhbCwgb3RoZXIgdmFsdWVzCisgKiBhcmUgZXZlbnQgY29kZXMuCisgKi8KK3N0YXRpYyBpbnQgcHBjOTcwX2NhY2hlX2V2ZW50c1tDKE1BWCldW0MoT1BfTUFYKV1bQyhSRVNVTFRfTUFYKV0gPSB7CisJW0MoTDFEKV0gPSB7CQkvKiAJUkVTVUxUX0FDQ0VTUwlSRVNVTFRfTUlTUyAqLworCQlbQyhPUF9SRUFEKV0gPSB7CTB4ODgxMCwJCTB4MzgxMAl9LAorCQlbQyhPUF9XUklURSldID0gewkweDc4MTAsCQkweDgxMwl9LAorCQlbQyhPUF9QUkVGRVRDSCldID0gewkweDczMSwJCTAJfSwKKwl9LAorCVtDKEwxSSldID0gewkJLyogCVJFU1VMVF9BQ0NFU1MJUkVTVUxUX01JU1MgKi8KKwkJW0MoT1BfUkVBRCldID0gewkwLAkJMAl9LAorCQlbQyhPUF9XUklURSldID0gewktMSwJCS0xCX0sCisJCVtDKE9QX1BSRUZFVENIKV0gPSB7CTAsCQkwCX0sCisJfSwKKwlbQyhMTCldID0gewkJLyogCVJFU1VMVF9BQ0NFU1MJUkVTVUxUX01JU1MgKi8KKwkJW0MoT1BfUkVBRCldID0gewkwLAkJMAl9LAorCQlbQyhPUF9XUklURSldID0gewkwLAkJMAl9LAorCQlbQyhPUF9QUkVGRVRDSCldID0gewkweDczMywJCTAJfSwKKwl9LAorCVtDKERUTEIpXSA9IHsJCS8qIAlSRVNVTFRfQUNDRVNTCVJFU1VMVF9NSVNTICovCisJCVtDKE9QX1JFQUQpXSA9IHsJMCwJCTB4NzA0CX0sCisJCVtDKE9QX1dSSVRFKV0gPSB7CS0xLAkJLTEJfSwKKwkJW0MoT1BfUFJFRkVUQ0gpXSA9IHsJLTEsCQktMQl9LAorCX0sCisJW0MoSVRMQildID0gewkJLyogCVJFU1VMVF9BQ0NFU1MJUkVTVUxUX01JU1MgKi8KKwkJW0MoT1BfUkVBRCldID0gewkwLAkJMHg3MDAJfSwKKwkJW0MoT1BfV1JJVEUpXSA9IHsJLTEsCQktMQl9LAorCQlbQyhPUF9QUkVGRVRDSCldID0gewktMSwJCS0xCX0sCisJfSwKKwlbQyhCUFUpXSA9IHsJCS8qIAlSRVNVTFRfQUNDRVNTCVJFU1VMVF9NSVNTICovCisJCVtDKE9QX1JFQUQpXSA9IHsJMHg0MzEsCQkweDMyNwl9LAorCQlbQyhPUF9XUklURSldID0gewktMSwJCS0xCX0sCisJCVtDKE9QX1BSRUZFVENIKV0gPSB7CS0xLAkJLTEJfSwKKwl9LAorfTsKKworc3RydWN0IHBvd2VyX3BtdSBwcGM5NzBfcG11ID0geworCS5uX2NvdW50ZXIgPSA4LAorCS5tYXhfYWx0ZXJuYXRpdmVzID0gMiwKKwkuYWRkX2ZpZWxkcyA9IDB4MDAxMTAwMDA1NTU1dWxsLAorCS50ZXN0X2FkZGVyID0gMHgwMTMzMDAwMDAwMDB1bGwsCisJLmNvbXB1dGVfbW1jciA9IHA5NzBfY29tcHV0ZV9tbWNyLAorCS5nZXRfY29uc3RyYWludCA9IHA5NzBfZ2V0X2NvbnN0cmFpbnQsCisJLmdldF9hbHRlcm5hdGl2ZXMgPSBwOTcwX2dldF9hbHRlcm5hdGl2ZXMsCisJLmRpc2FibGVfcG1jID0gcDk3MF9kaXNhYmxlX3BtYywKKwkubl9nZW5lcmljID0gQVJSQVlfU0laRShwcGM5NzBfZ2VuZXJpY19ldmVudHMpLAorCS5nZW5lcmljX2V2ZW50cyA9IHBwYzk3MF9nZW5lcmljX2V2ZW50cywKKwkuY2FjaGVfZXZlbnRzID0gJnBwYzk3MF9jYWNoZV9ldmVudHMsCit9OwpkaWZmIC0tZ2l0IGEvYXJjaC9wb3dlcnBjL21tL2ZhdWx0LmMgYi9hcmNoL3Bvd2VycGMvbW0vZmF1bHQuYwppbmRleCA3Njk5Mzk0Li41YmVmZmM4IDEwMDY0NAotLS0gYS9hcmNoL3Bvd2VycGMvbW0vZmF1bHQuYworKysgYi9hcmNoL3Bvd2VycGMvbW0vZmF1bHQuYwpAQCAtMjksNiArMjksNyBAQAogI2luY2x1ZGUgPGxpbnV4L21vZHVsZS5oPgogI2luY2x1ZGUgPGxpbnV4L2twcm9iZXMuaD4KICNpbmNsdWRlIDxsaW51eC9rZGVidWcuaD4KKyNpbmNsdWRlIDxsaW51eC9wZXJmX2NvdW50ZXIuaD4KIAogI2luY2x1ZGUgPGFzbS9maXJtd2FyZS5oPgogI2luY2x1ZGUgPGFzbS9wYWdlLmg+CkBAIC0xNzAsNiArMTcxLDggQEAKIAkJZGllKCJXZWlyZCBwYWdlIGZhdWx0IiwgcmVncywgU0lHU0VHVik7CiAJfQogCisJcGVyZl9zd2NvdW50ZXJfZXZlbnQoUEVSRl9DT1VOVF9TV19QQUdFX0ZBVUxUUywgMSwgMCwgcmVncywgYWRkcmVzcyk7CisKIAkvKiBXaGVuIHJ1bm5pbmcgaW4gdGhlIGtlcm5lbCB3ZSBleHBlY3QgZmF1bHRzIHRvIG9jY3VyIG9ubHkgdG8KIAkgKiBhZGRyZXNzZXMgaW4gdXNlciBzcGFjZS4gIEFsbCBvdGhlciBmYXVsdHMgcmVwcmVzZW50IGVycm9ycyBpbiB0aGUKIAkgKiBrZXJuZWwgYW5kIHNob3VsZCBnZW5lcmF0ZSBhbiBPT1BTLiAgVW5mb3J0dW5hdGVseSwgaW4gdGhlIGNhc2Ugb2YgYW4KQEAgLTMwOSw2ICszMTIsOCBAQAogCX0KIAlpZiAocmV0ICYgVk1fRkFVTFRfTUFKT1IpIHsKIAkJY3VycmVudC0+bWFqX2ZsdCsrOworCQlwZXJmX3N3Y291bnRlcl9ldmVudChQRVJGX0NPVU5UX1NXX1BBR0VfRkFVTFRTX01BSiwgMSwgMCwKKwkJCQkgICAgIHJlZ3MsIGFkZHJlc3MpOwogI2lmZGVmIENPTkZJR19QUENfU01MUEFSCiAJCWlmIChmaXJtd2FyZV9oYXNfZmVhdHVyZShGV19GRUFUVVJFX0NNTykpIHsKIAkJCXByZWVtcHRfZGlzYWJsZSgpOwpAQCAtMzE2LDggKzMyMSwxMSBAQAogCQkJcHJlZW1wdF9lbmFibGUoKTsKIAkJfQogI2VuZGlmCi0JfSBlbHNlCisJfSBlbHNlIHsKIAkJY3VycmVudC0+bWluX2ZsdCsrOworCQlwZXJmX3N3Y291bnRlcl9ldmVudChQRVJGX0NPVU5UX1NXX1BBR0VfRkFVTFRTX01JTiwgMSwgMCwKKwkJCQkgICAgIHJlZ3MsIGFkZHJlc3MpOworCX0KIAl1cF9yZWFkKCZtbS0+bW1hcF9zZW0pOwogCXJldHVybiAwOwogCmRpZmYgLS1naXQgYS9hcmNoL3Bvd2VycGMvcGxhdGZvcm1zL0tjb25maWcuY3B1dHlwZSBiL2FyY2gvcG93ZXJwYy9wbGF0Zm9ybXMvS2NvbmZpZy5jcHV0eXBlCmluZGV4IDlkYTc5NWUuLjczMmVlOTMgMTAwNjQ0Ci0tLSBhL2FyY2gvcG93ZXJwYy9wbGF0Zm9ybXMvS2NvbmZpZy5jcHV0eXBlCisrKyBiL2FyY2gvcG93ZXJwYy9wbGF0Zm9ybXMvS2NvbmZpZy5jcHV0eXBlCkBAIC0xLDYgKzEsNyBAQAogY29uZmlnIFBQQzY0CiAJYm9vbCAiNjQtYml0IGtlcm5lbCIKIAlkZWZhdWx0IG4KKwlzZWxlY3QgSEFWRV9QRVJGX0NPVU5URVJTCiAJaGVscAogCSAgVGhpcyBvcHRpb24gc2VsZWN0cyB3aGV0aGVyIGEgMzItYml0IG9yIGEgNjQtYml0IGtlcm5lbAogCSAgd2lsbCBiZSBidWlsdC4KZGlmZiAtLWdpdCBhL2FyY2gveDg2L0tjb25maWcgYi9hcmNoL3g4Ni9LY29uZmlnCmluZGV4IGFhZmFlM2IuLjY4ZjU1NzggMTAwNjQ0Ci0tLSBhL2FyY2gveDg2L0tjb25maWcKKysrIGIvYXJjaC94ODYvS2NvbmZpZwpAQCAtNzM5LDYgKzczOSw3IEBACiBjb25maWcgWDg2X0xPQ0FMX0FQSUMKIAlkZWZfYm9vbCB5CiAJZGVwZW5kcyBvbiBYODZfNjQgfHwgU01QIHx8IFg4Nl8zMl9OT05fU1RBTkRBUkQgfHwgWDg2X1VQX0FQSUMKKwlzZWxlY3QgSEFWRV9QRVJGX0NPVU5URVJTIGlmICghTTM4NiAmJiAhTTQ4NikKIAogY29uZmlnIFg4Nl9JT19BUElDCiAJZGVmX2Jvb2wgeQpkaWZmIC0tZ2l0IGEvYXJjaC94ODYvaWEzMi9pYTMyZW50cnkuUyBiL2FyY2gveDg2L2lhMzIvaWEzMmVudHJ5LlMKaW5kZXggZGNlZjM4Ny4uZTU5MDI2MSAxMDA2NDQKLS0tIGEvYXJjaC94ODYvaWEzMi9pYTMyZW50cnkuUworKysgYi9hcmNoL3g4Ni9pYTMyL2lhMzJlbnRyeS5TCkBAIC04MjUsMTAgKzgyNSwxMSBAQAogCS5xdWFkIGNvbXBhdF9zeXNfc2lnbmFsZmQ0CiAJLnF1YWQgc3lzX2V2ZW50ZmQyCiAJLnF1YWQgc3lzX2Vwb2xsX2NyZWF0ZTEKLQkucXVhZCBzeXNfZHVwMwkJCS8qIDMzMCAqLworCS5xdWFkIHN5c19kdXAzCQkJCS8qIDMzMCAqLwogCS5xdWFkIHN5c19waXBlMgogCS5xdWFkIHN5c19pbm90aWZ5X2luaXQxCiAJLnF1YWQgY29tcGF0X3N5c19wcmVhZHYKIAkucXVhZCBjb21wYXRfc3lzX3B3cml0ZXYKIAkucXVhZCBjb21wYXRfc3lzX3J0X3Rnc2lncXVldWVpbmZvCS8qIDMzNSAqLworCS5xdWFkIHN5c19wZXJmX2NvdW50ZXJfb3BlbgogaWEzMl9zeXNjYWxsX2VuZDoKZGlmZiAtLWdpdCBhL2FyY2gveDg2L2luY2x1ZGUvYXNtL2F0b21pY18zMi5oIGIvYXJjaC94ODYvaW5jbHVkZS9hc20vYXRvbWljXzMyLmgKaW5kZXggODViNDZmYi4uYWZmOWYxZiAxMDA2NDQKLS0tIGEvYXJjaC94ODYvaW5jbHVkZS9hc20vYXRvbWljXzMyLmgKKysrIGIvYXJjaC94ODYvaW5jbHVkZS9hc20vYXRvbWljXzMyLmgKQEAgLTI0Nyw1ICsyNDcsMjQxIEBACiAjZGVmaW5lIHNtcF9tYl9fYmVmb3JlX2F0b21pY19pbmMoKQliYXJyaWVyKCkKICNkZWZpbmUgc21wX21iX19hZnRlcl9hdG9taWNfaW5jKCkJYmFycmllcigpCiAKKy8qIEFuIDY0Yml0IGF0b21pYyB0eXBlICovCisKK3R5cGVkZWYgc3RydWN0IHsKKwl1bnNpZ25lZCBsb25nIGxvbmcgY291bnRlcjsKK30gYXRvbWljNjRfdDsKKworI2RlZmluZSBBVE9NSUM2NF9JTklUKHZhbCkJeyAodmFsKSB9CisKKy8qKgorICogYXRvbWljNjRfcmVhZCAtIHJlYWQgYXRvbWljNjQgdmFyaWFibGUKKyAqIEB2OiBwb2ludGVyIG9mIHR5cGUgYXRvbWljNjRfdAorICoKKyAqIEF0b21pY2FsbHkgcmVhZHMgdGhlIHZhbHVlIG9mIEB2LgorICogRG9lc24ndCBpbXBseSBhIHJlYWQgbWVtb3J5IGJhcnJpZXIuCisgKi8KKyNkZWZpbmUgX19hdG9taWM2NF9yZWFkKHB0cikJCSgocHRyKS0+Y291bnRlcikKKworc3RhdGljIGlubGluZSB1bnNpZ25lZCBsb25nIGxvbmcKK2NtcHhjaGc4Yih1bnNpZ25lZCBsb25nIGxvbmcgKnB0ciwgdW5zaWduZWQgbG9uZyBsb25nIG9sZCwgdW5zaWduZWQgbG9uZyBsb25nIG5ldykKK3sKKwlhc20gdm9sYXRpbGUoCisKKwkJTE9DS19QUkVGSVggImNtcHhjaGc4YiAoJVtwdHJdKVxuIgorCisJCSAgICAgOgkJIj1BIiAob2xkKQorCisJCSAgICAgOiBbcHRyXQkiRCIgKHB0ciksCisJCQkJIkEiIChvbGQpLAorCQkJCSJiIiAobGxfbG93KG5ldykpLAorCQkJCSJjIiAobGxfaGlnaChuZXcpKQorCisJCSAgICAgOiAibWVtb3J5Iik7CisKKwlyZXR1cm4gb2xkOworfQorCitzdGF0aWMgaW5saW5lIHVuc2lnbmVkIGxvbmcgbG9uZworYXRvbWljNjRfY21weGNoZyhhdG9taWM2NF90ICpwdHIsIHVuc2lnbmVkIGxvbmcgbG9uZyBvbGRfdmFsLAorCQkgdW5zaWduZWQgbG9uZyBsb25nIG5ld192YWwpCit7CisJcmV0dXJuIGNtcHhjaGc4YigmcHRyLT5jb3VudGVyLCBvbGRfdmFsLCBuZXdfdmFsKTsKK30KKworLyoqCisgKiBhdG9taWM2NF94Y2hnIC0geGNoZyBhdG9taWM2NCB2YXJpYWJsZQorICogQHB0cjogICAgICBwb2ludGVyIHRvIHR5cGUgYXRvbWljNjRfdAorICogQG5ld192YWw6ICB2YWx1ZSB0byBhc3NpZ24KKyAqIEBvbGRfdmFsOiAgb2xkIHZhbHVlIHRoYXQgd2FzIHRoZXJlCisgKgorICogQXRvbWljYWxseSB4Y2hncyB0aGUgdmFsdWUgb2YgQHB0ciB0byBAbmV3X3ZhbCBhbmQgcmV0dXJucworICogdGhlIG9sZCB2YWx1ZS4KKyAqLworCitzdGF0aWMgaW5saW5lIHVuc2lnbmVkIGxvbmcgbG9uZworYXRvbWljNjRfeGNoZyhhdG9taWM2NF90ICpwdHIsIHVuc2lnbmVkIGxvbmcgbG9uZyBuZXdfdmFsKQoreworCXVuc2lnbmVkIGxvbmcgbG9uZyBvbGRfdmFsOworCisJZG8geworCQlvbGRfdmFsID0gYXRvbWljX3JlYWQocHRyKTsKKwl9IHdoaWxlIChhdG9taWM2NF9jbXB4Y2hnKHB0ciwgb2xkX3ZhbCwgbmV3X3ZhbCkgIT0gb2xkX3ZhbCk7CisKKwlyZXR1cm4gb2xkX3ZhbDsKK30KKworLyoqCisgKiBhdG9taWM2NF9zZXQgLSBzZXQgYXRvbWljNjQgdmFyaWFibGUKKyAqIEBwdHI6ICAgICAgcG9pbnRlciB0byB0eXBlIGF0b21pYzY0X3QKKyAqIEBuZXdfdmFsOiAgdmFsdWUgdG8gYXNzaWduCisgKgorICogQXRvbWljYWxseSBzZXRzIHRoZSB2YWx1ZSBvZiBAcHRyIHRvIEBuZXdfdmFsLgorICovCitzdGF0aWMgaW5saW5lIHZvaWQgYXRvbWljNjRfc2V0KGF0b21pYzY0X3QgKnB0ciwgdW5zaWduZWQgbG9uZyBsb25nIG5ld192YWwpCit7CisJYXRvbWljNjRfeGNoZyhwdHIsIG5ld192YWwpOworfQorCisvKioKKyAqIGF0b21pYzY0X3JlYWQgLSByZWFkIGF0b21pYzY0IHZhcmlhYmxlCisgKiBAcHRyOiAgICAgIHBvaW50ZXIgdG8gdHlwZSBhdG9taWM2NF90CisgKgorICogQXRvbWljYWxseSByZWFkcyB0aGUgdmFsdWUgb2YgQHB0ciBhbmQgcmV0dXJucyBpdC4KKyAqLworc3RhdGljIGlubGluZSB1bnNpZ25lZCBsb25nIGxvbmcgYXRvbWljNjRfcmVhZChhdG9taWM2NF90ICpwdHIpCit7CisJdW5zaWduZWQgbG9uZyBsb25nIGN1cnJfdmFsOworCisJZG8geworCQljdXJyX3ZhbCA9IF9fYXRvbWljNjRfcmVhZChwdHIpOworCX0gd2hpbGUgKGF0b21pYzY0X2NtcHhjaGcocHRyLCBjdXJyX3ZhbCwgY3Vycl92YWwpICE9IGN1cnJfdmFsKTsKKworCXJldHVybiBjdXJyX3ZhbDsKK30KKworLyoqCisgKiBhdG9taWM2NF9hZGRfcmV0dXJuIC0gYWRkIGFuZCByZXR1cm4KKyAqIEBkZWx0YTogaW50ZWdlciB2YWx1ZSB0byBhZGQKKyAqIEBwdHI6ICAgcG9pbnRlciB0byB0eXBlIGF0b21pYzY0X3QKKyAqCisgKiBBdG9taWNhbGx5IGFkZHMgQGRlbHRhIHRvIEBwdHIgYW5kIHJldHVybnMgQGRlbHRhICsgKkBwdHIKKyAqLworc3RhdGljIGlubGluZSB1bnNpZ25lZCBsb25nIGxvbmcKK2F0b21pYzY0X2FkZF9yZXR1cm4odW5zaWduZWQgbG9uZyBsb25nIGRlbHRhLCBhdG9taWM2NF90ICpwdHIpCit7CisJdW5zaWduZWQgbG9uZyBsb25nIG9sZF92YWwsIG5ld192YWw7CisKKwlkbyB7CisJCW9sZF92YWwgPSBhdG9taWNfcmVhZChwdHIpOworCQluZXdfdmFsID0gb2xkX3ZhbCArIGRlbHRhOworCisJfSB3aGlsZSAoYXRvbWljNjRfY21weGNoZyhwdHIsIG9sZF92YWwsIG5ld192YWwpICE9IG9sZF92YWwpOworCisJcmV0dXJuIG5ld192YWw7Cit9CisKK3N0YXRpYyBpbmxpbmUgbG9uZyBhdG9taWM2NF9zdWJfcmV0dXJuKHVuc2lnbmVkIGxvbmcgbG9uZyBkZWx0YSwgYXRvbWljNjRfdCAqcHRyKQoreworCXJldHVybiBhdG9taWM2NF9hZGRfcmV0dXJuKC1kZWx0YSwgcHRyKTsKK30KKworc3RhdGljIGlubGluZSBsb25nIGF0b21pYzY0X2luY19yZXR1cm4oYXRvbWljNjRfdCAqcHRyKQoreworCXJldHVybiBhdG9taWM2NF9hZGRfcmV0dXJuKDEsIHB0cik7Cit9CisKK3N0YXRpYyBpbmxpbmUgbG9uZyBhdG9taWM2NF9kZWNfcmV0dXJuKGF0b21pYzY0X3QgKnB0cikKK3sKKwlyZXR1cm4gYXRvbWljNjRfc3ViX3JldHVybigxLCBwdHIpOworfQorCisvKioKKyAqIGF0b21pYzY0X2FkZCAtIGFkZCBpbnRlZ2VyIHRvIGF0b21pYzY0IHZhcmlhYmxlCisgKiBAZGVsdGE6IGludGVnZXIgdmFsdWUgdG8gYWRkCisgKiBAcHRyOiAgIHBvaW50ZXIgdG8gdHlwZSBhdG9taWM2NF90CisgKgorICogQXRvbWljYWxseSBhZGRzIEBkZWx0YSB0byBAcHRyLgorICovCitzdGF0aWMgaW5saW5lIHZvaWQgYXRvbWljNjRfYWRkKHVuc2lnbmVkIGxvbmcgbG9uZyBkZWx0YSwgYXRvbWljNjRfdCAqcHRyKQoreworCWF0b21pYzY0X2FkZF9yZXR1cm4oZGVsdGEsIHB0cik7Cit9CisKKy8qKgorICogYXRvbWljNjRfc3ViIC0gc3VidHJhY3QgdGhlIGF0b21pYzY0IHZhcmlhYmxlCisgKiBAZGVsdGE6IGludGVnZXIgdmFsdWUgdG8gc3VidHJhY3QKKyAqIEBwdHI6ICAgcG9pbnRlciB0byB0eXBlIGF0b21pYzY0X3QKKyAqCisgKiBBdG9taWNhbGx5IHN1YnRyYWN0cyBAZGVsdGEgZnJvbSBAcHRyLgorICovCitzdGF0aWMgaW5saW5lIHZvaWQgYXRvbWljNjRfc3ViKHVuc2lnbmVkIGxvbmcgbG9uZyBkZWx0YSwgYXRvbWljNjRfdCAqcHRyKQoreworCWF0b21pYzY0X2FkZCgtZGVsdGEsIHB0cik7Cit9CisKKy8qKgorICogYXRvbWljNjRfc3ViX2FuZF90ZXN0IC0gc3VidHJhY3QgdmFsdWUgZnJvbSB2YXJpYWJsZSBhbmQgdGVzdCByZXN1bHQKKyAqIEBkZWx0YTogaW50ZWdlciB2YWx1ZSB0byBzdWJ0cmFjdAorICogQHB0cjogICBwb2ludGVyIHRvIHR5cGUgYXRvbWljNjRfdAorICoKKyAqIEF0b21pY2FsbHkgc3VidHJhY3RzIEBkZWx0YSBmcm9tIEBwdHIgYW5kIHJldHVybnMKKyAqIHRydWUgaWYgdGhlIHJlc3VsdCBpcyB6ZXJvLCBvciBmYWxzZSBmb3IgYWxsCisgKiBvdGhlciBjYXNlcy4KKyAqLworc3RhdGljIGlubGluZSBpbnQKK2F0b21pYzY0X3N1Yl9hbmRfdGVzdCh1bnNpZ25lZCBsb25nIGxvbmcgZGVsdGEsIGF0b21pYzY0X3QgKnB0cikKK3sKKwl1bnNpZ25lZCBsb25nIGxvbmcgb2xkX3ZhbCA9IGF0b21pYzY0X3N1Yl9yZXR1cm4oZGVsdGEsIHB0cik7CisKKwlyZXR1cm4gb2xkX3ZhbCA9PSAwOworfQorCisvKioKKyAqIGF0b21pYzY0X2luYyAtIGluY3JlbWVudCBhdG9taWM2NCB2YXJpYWJsZQorICogQHB0cjogcG9pbnRlciB0byB0eXBlIGF0b21pYzY0X3QKKyAqCisgKiBBdG9taWNhbGx5IGluY3JlbWVudHMgQHB0ciBieSAxLgorICovCitzdGF0aWMgaW5saW5lIHZvaWQgYXRvbWljNjRfaW5jKGF0b21pYzY0X3QgKnB0cikKK3sKKwlhdG9taWM2NF9hZGQoMSwgcHRyKTsKK30KKworLyoqCisgKiBhdG9taWM2NF9kZWMgLSBkZWNyZW1lbnQgYXRvbWljNjQgdmFyaWFibGUKKyAqIEBwdHI6IHBvaW50ZXIgdG8gdHlwZSBhdG9taWM2NF90CisgKgorICogQXRvbWljYWxseSBkZWNyZW1lbnRzIEBwdHIgYnkgMS4KKyAqLworc3RhdGljIGlubGluZSB2b2lkIGF0b21pYzY0X2RlYyhhdG9taWM2NF90ICpwdHIpCit7CisJYXRvbWljNjRfc3ViKDEsIHB0cik7Cit9CisKKy8qKgorICogYXRvbWljNjRfZGVjX2FuZF90ZXN0IC0gZGVjcmVtZW50IGFuZCB0ZXN0CisgKiBAcHRyOiBwb2ludGVyIHRvIHR5cGUgYXRvbWljNjRfdAorICoKKyAqIEF0b21pY2FsbHkgZGVjcmVtZW50cyBAcHRyIGJ5IDEgYW5kCisgKiByZXR1cm5zIHRydWUgaWYgdGhlIHJlc3VsdCBpcyAwLCBvciBmYWxzZSBmb3IgYWxsIG90aGVyCisgKiBjYXNlcy4KKyAqLworc3RhdGljIGlubGluZSBpbnQgYXRvbWljNjRfZGVjX2FuZF90ZXN0KGF0b21pYzY0X3QgKnB0cikKK3sKKwlyZXR1cm4gYXRvbWljNjRfc3ViX2FuZF90ZXN0KDEsIHB0cik7Cit9CisKKy8qKgorICogYXRvbWljNjRfaW5jX2FuZF90ZXN0IC0gaW5jcmVtZW50IGFuZCB0ZXN0CisgKiBAcHRyOiBwb2ludGVyIHRvIHR5cGUgYXRvbWljNjRfdAorICoKKyAqIEF0b21pY2FsbHkgaW5jcmVtZW50cyBAcHRyIGJ5IDEKKyAqIGFuZCByZXR1cm5zIHRydWUgaWYgdGhlIHJlc3VsdCBpcyB6ZXJvLCBvciBmYWxzZSBmb3IgYWxsCisgKiBvdGhlciBjYXNlcy4KKyAqLworc3RhdGljIGlubGluZSBpbnQgYXRvbWljNjRfaW5jX2FuZF90ZXN0KGF0b21pYzY0X3QgKnB0cikKK3sKKwlyZXR1cm4gYXRvbWljNjRfc3ViX2FuZF90ZXN0KC0xLCBwdHIpOworfQorCisvKioKKyAqIGF0b21pYzY0X2FkZF9uZWdhdGl2ZSAtIGFkZCBhbmQgdGVzdCBpZiBuZWdhdGl2ZQorICogQGRlbHRhOiBpbnRlZ2VyIHZhbHVlIHRvIGFkZAorICogQHB0cjogICBwb2ludGVyIHRvIHR5cGUgYXRvbWljNjRfdAorICoKKyAqIEF0b21pY2FsbHkgYWRkcyBAZGVsdGEgdG8gQHB0ciBhbmQgcmV0dXJucyB0cnVlCisgKiBpZiB0aGUgcmVzdWx0IGlzIG5lZ2F0aXZlLCBvciBmYWxzZSB3aGVuCisgKiByZXN1bHQgaXMgZ3JlYXRlciB0aGFuIG9yIGVxdWFsIHRvIHplcm8uCisgKi8KK3N0YXRpYyBpbmxpbmUgaW50CithdG9taWM2NF9hZGRfbmVnYXRpdmUodW5zaWduZWQgbG9uZyBsb25nIGRlbHRhLCBhdG9taWM2NF90ICpwdHIpCit7CisJbG9uZyBsb25nIG9sZF92YWwgPSBhdG9taWM2NF9hZGRfcmV0dXJuKGRlbHRhLCBwdHIpOworCisJcmV0dXJuIG9sZF92YWwgPCAwOworfQorCiAjaW5jbHVkZSA8YXNtLWdlbmVyaWMvYXRvbWljLmg+CiAjZW5kaWYgLyogX0FTTV9YODZfQVRPTUlDXzMyX0ggKi8KZGlmZiAtLWdpdCBhL2FyY2gveDg2L2luY2x1ZGUvYXNtL2VudHJ5X2FyY2guaCBiL2FyY2gveDg2L2luY2x1ZGUvYXNtL2VudHJ5X2FyY2guaAppbmRleCBjMmU2YmVkLi5kNzUwYTEwIDEwMDY0NAotLS0gYS9hcmNoL3g4Ni9pbmNsdWRlL2FzbS9lbnRyeV9hcmNoLmgKKysrIGIvYXJjaC94ODYvaW5jbHVkZS9hc20vZW50cnlfYXJjaC5oCkBAIC00OSw3ICs0OSw3IEBACiBCVUlMRF9JTlRFUlJVUFQoc3B1cmlvdXNfaW50ZXJydXB0LFNQVVJJT1VTX0FQSUNfVkVDVE9SKQogCiAjaWZkZWYgQ09ORklHX1BFUkZfQ09VTlRFUlMKLUJVSUxEX0lOVEVSUlVQVChwZXJmX2NvdW50ZXJfaW50ZXJydXB0LCBMT0NBTF9QRVJGX1ZFQ1RPUikKK0JVSUxEX0lOVEVSUlVQVChwZXJmX3BlbmRpbmdfaW50ZXJydXB0LCBMT0NBTF9QRU5ESU5HX1ZFQ1RPUikKICNlbmRpZgogCiAjaWZkZWYgQ09ORklHX1g4Nl9NQ0VfUDRUSEVSTUFMCmRpZmYgLS1naXQgYS9hcmNoL3g4Ni9pbmNsdWRlL2FzbS9oYXJkaXJxLmggYi9hcmNoL3g4Ni9pbmNsdWRlL2FzbS9oYXJkaXJxLmgKaW5kZXggMzc1NTVlNS4uOWViYzVjMiAxMDA2NDQKLS0tIGEvYXJjaC94ODYvaW5jbHVkZS9hc20vaGFyZGlycS5oCisrKyBiL2FyY2gveDg2L2luY2x1ZGUvYXNtL2hhcmRpcnEuaApAQCAtMTMsNiArMTMsOCBAQAogCXVuc2lnbmVkIGludCBpcnFfc3B1cmlvdXNfY291bnQ7CiAjZW5kaWYKIAl1bnNpZ25lZCBpbnQgZ2VuZXJpY19pcnFzOwkvKiBhcmNoIGRlcGVuZGVudCAqLworCXVuc2lnbmVkIGludCBhcGljX3BlcmZfaXJxczsKKwl1bnNpZ25lZCBpbnQgYXBpY19wZW5kaW5nX2lycXM7CiAjaWZkZWYgQ09ORklHX1NNUAogCXVuc2lnbmVkIGludCBpcnFfcmVzY2hlZF9jb3VudDsKIAl1bnNpZ25lZCBpbnQgaXJxX2NhbGxfY291bnQ7CmRpZmYgLS1naXQgYS9hcmNoL3g4Ni9pbmNsdWRlL2FzbS9od19pcnEuaCBiL2FyY2gveDg2L2luY2x1ZGUvYXNtL2h3X2lycS5oCmluZGV4IDNiZDE3NzcuLjZkZjQ1ZjYgMTAwNjQ0Ci0tLSBhL2FyY2gveDg2L2luY2x1ZGUvYXNtL2h3X2lycS5oCisrKyBiL2FyY2gveDg2L2luY2x1ZGUvYXNtL2h3X2lycS5oCkBAIC0yOSw2ICsyOSw4IEBACiBleHRlcm4gdm9pZCBhcGljX3RpbWVyX2ludGVycnVwdCh2b2lkKTsKIGV4dGVybiB2b2lkIGdlbmVyaWNfaW50ZXJydXB0KHZvaWQpOwogZXh0ZXJuIHZvaWQgZXJyb3JfaW50ZXJydXB0KHZvaWQpOworZXh0ZXJuIHZvaWQgcGVyZl9wZW5kaW5nX2ludGVycnVwdCh2b2lkKTsKKwogZXh0ZXJuIHZvaWQgc3B1cmlvdXNfaW50ZXJydXB0KHZvaWQpOwogZXh0ZXJuIHZvaWQgdGhlcm1hbF9pbnRlcnJ1cHQodm9pZCk7CiBleHRlcm4gdm9pZCByZXNjaGVkdWxlX2ludGVycnVwdCh2b2lkKTsKZGlmZiAtLWdpdCBhL2FyY2gveDg2L2luY2x1ZGUvYXNtL2ludGVsX2FyY2hfcGVyZm1vbi5oIGIvYXJjaC94ODYvaW5jbHVkZS9hc20vaW50ZWxfYXJjaF9wZXJmbW9uLmgKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IGZhMGZkMDYuLjAwMDAwMDAKLS0tIGEvYXJjaC94ODYvaW5jbHVkZS9hc20vaW50ZWxfYXJjaF9wZXJmbW9uLmgKKysrIC9kZXYvbnVsbApAQCAtMSwzMSArMCwwIEBACi0jaWZuZGVmIF9BU01fWDg2X0lOVEVMX0FSQ0hfUEVSRk1PTl9ICi0jZGVmaW5lIF9BU01fWDg2X0lOVEVMX0FSQ0hfUEVSRk1PTl9ICi0KLSNkZWZpbmUgTVNSX0FSQ0hfUEVSRk1PTl9QRVJGQ1RSMAkJMHhjMQotI2RlZmluZSBNU1JfQVJDSF9QRVJGTU9OX1BFUkZDVFIxCQkweGMyCi0KLSNkZWZpbmUgTVNSX0FSQ0hfUEVSRk1PTl9FVkVOVFNFTDAJCTB4MTg2Ci0jZGVmaW5lIE1TUl9BUkNIX1BFUkZNT05fRVZFTlRTRUwxCQkweDE4NwotCi0jZGVmaW5lIEFSQ0hfUEVSRk1PTl9FVkVOVFNFTDBfRU5BQkxFCSgxIDw8IDIyKQotI2RlZmluZSBBUkNIX1BFUkZNT05fRVZFTlRTRUxfSU5UCSgxIDw8IDIwKQotI2RlZmluZSBBUkNIX1BFUkZNT05fRVZFTlRTRUxfT1MJKDEgPDwgMTcpCi0jZGVmaW5lIEFSQ0hfUEVSRk1PTl9FVkVOVFNFTF9VU1IJKDEgPDwgMTYpCi0KLSNkZWZpbmUgQVJDSF9QRVJGTU9OX1VOSEFMVEVEX0NPUkVfQ1lDTEVTX1NFTAkoMHgzYykKLSNkZWZpbmUgQVJDSF9QRVJGTU9OX1VOSEFMVEVEX0NPUkVfQ1lDTEVTX1VNQVNLCSgweDAwIDw8IDgpCi0jZGVmaW5lIEFSQ0hfUEVSRk1PTl9VTkhBTFRFRF9DT1JFX0NZQ0xFU19JTkRFWCAoMCkKLSNkZWZpbmUgQVJDSF9QRVJGTU9OX1VOSEFMVEVEX0NPUkVfQ1lDTEVTX1BSRVNFTlQgXAotCSgxIDw8IChBUkNIX1BFUkZNT05fVU5IQUxURURfQ09SRV9DWUNMRVNfSU5ERVgpKQotCi11bmlvbiBjcHVpZDEwX2VheCB7Ci0Jc3RydWN0IHsKLQkJdW5zaWduZWQgaW50IHZlcnNpb25faWQ6ODsKLQkJdW5zaWduZWQgaW50IG51bV9jb3VudGVyczo4OwotCQl1bnNpZ25lZCBpbnQgYml0X3dpZHRoOjg7Ci0JCXVuc2lnbmVkIGludCBtYXNrX2xlbmd0aDo4OwotCX0gc3BsaXQ7Ci0JdW5zaWduZWQgaW50IGZ1bGw7Ci19OwotCi0jZW5kaWYgLyogX0FTTV9YODZfSU5URUxfQVJDSF9QRVJGTU9OX0ggKi8KZGlmZiAtLWdpdCBhL2FyY2gveDg2L2luY2x1ZGUvYXNtL2lycV92ZWN0b3JzLmggYi9hcmNoL3g4Ni9pbmNsdWRlL2FzbS9pcnFfdmVjdG9ycy5oCmluZGV4IDkxMGI1YTMuLmU5OTdiZTk4IDEwMDY0NAotLS0gYS9hcmNoL3g4Ni9pbmNsdWRlL2FzbS9pcnFfdmVjdG9ycy5oCisrKyBiL2FyY2gveDg2L2luY2x1ZGUvYXNtL2lycV92ZWN0b3JzLmgKQEAgLTEwOCwxNiArMTA4LDE2IEBACiAjZGVmaW5lIExPQ0FMX1RJTUVSX1ZFQ1RPUgkJMHhlZgogCiAvKgotICogUGVyZm9ybWFuY2UgbW9uaXRvcmluZyBpbnRlcnJ1cHQgdmVjdG9yOgotICovCi0jZGVmaW5lIExPQ0FMX1BFUkZfVkVDVE9SCQkweGVlCi0KLS8qCiAgKiBHZW5lcmljIHN5c3RlbSB2ZWN0b3IgZm9yIHBsYXRmb3JtIHNwZWNpZmljIHVzZQogICovCiAjZGVmaW5lIEdFTkVSSUNfSU5URVJSVVBUX1ZFQ1RPUgkweGVkCiAKIC8qCisgKiBQZXJmb3JtYW5jZSBtb25pdG9yaW5nIHBlbmRpbmcgd29yayB2ZWN0b3I6CisgKi8KKyNkZWZpbmUgTE9DQUxfUEVORElOR19WRUNUT1IJCTB4ZWMKKworLyoKICAqIEZpcnN0IEFQSUMgdmVjdG9yIGF2YWlsYWJsZSB0byBkcml2ZXJzOiAodmVjdG9ycyAweDMwLTB4ZWUpIHdlCiAgKiBzdGFydCBhdCAweDMxKDB4NDEpIHRvIHNwcmVhZCBvdXQgdmVjdG9ycyBldmVubHkgYmV0d2VlbiBwcmlvcml0eQogICogbGV2ZWxzLiAoMHg4MCBpcyB0aGUgc3lzY2FsbCB2ZWN0b3IpCmRpZmYgLS1naXQgYS9hcmNoL3g4Ni9pbmNsdWRlL2FzbS9wZXJmX2NvdW50ZXIuaCBiL2FyY2gveDg2L2luY2x1ZGUvYXNtL3BlcmZfY291bnRlci5oCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjg3NmVkOTcKLS0tIC9kZXYvbnVsbAorKysgYi9hcmNoL3g4Ni9pbmNsdWRlL2FzbS9wZXJmX2NvdW50ZXIuaApAQCAtMCwwICsxLDEwMCBAQAorI2lmbmRlZiBfQVNNX1g4Nl9QRVJGX0NPVU5URVJfSAorI2RlZmluZSBfQVNNX1g4Nl9QRVJGX0NPVU5URVJfSAorCisvKgorICogUGVyZm9ybWFuY2UgY291bnRlciBodyBkZXRhaWxzOgorICovCisKKyNkZWZpbmUgWDg2X1BNQ19NQVhfR0VORVJJQwkJCQkJOAorI2RlZmluZSBYODZfUE1DX01BWF9GSVhFRAkJCQkJMworCisjZGVmaW5lIFg4Nl9QTUNfSURYX0dFTkVSSUMJCQkJICAgICAgICAwCisjZGVmaW5lIFg4Nl9QTUNfSURYX0ZJWEVECQkJCSAgICAgICAzMgorI2RlZmluZSBYODZfUE1DX0lEWF9NQVgJCQkJCSAgICAgICA2NAorCisjZGVmaW5lIE1TUl9BUkNIX1BFUkZNT05fUEVSRkNUUjAJCQkgICAgICAweGMxCisjZGVmaW5lIE1TUl9BUkNIX1BFUkZNT05fUEVSRkNUUjEJCQkgICAgICAweGMyCisKKyNkZWZpbmUgTVNSX0FSQ0hfUEVSRk1PTl9FVkVOVFNFTDAJCQkgICAgIDB4MTg2CisjZGVmaW5lIE1TUl9BUkNIX1BFUkZNT05fRVZFTlRTRUwxCQkJICAgICAweDE4NworCisjZGVmaW5lIEFSQ0hfUEVSRk1PTl9FVkVOVFNFTDBfRU5BQkxFCQkJICAoMSA8PCAyMikKKyNkZWZpbmUgQVJDSF9QRVJGTU9OX0VWRU5UU0VMX0lOVAkJCSAgKDEgPDwgMjApCisjZGVmaW5lIEFSQ0hfUEVSRk1PTl9FVkVOVFNFTF9PUwkJCSAgKDEgPDwgMTcpCisjZGVmaW5lIEFSQ0hfUEVSRk1PTl9FVkVOVFNFTF9VU1IJCQkgICgxIDw8IDE2KQorCisvKgorICogSW5jbHVkZXMgZXZlbnRzZWwgYW5kIHVuaXQgbWFzayBhcyB3ZWxsOgorICovCisjZGVmaW5lIEFSQ0hfUEVSRk1PTl9FVkVOVF9NQVNLCQkJCSAgICAweGZmZmYKKworI2RlZmluZSBBUkNIX1BFUkZNT05fVU5IQUxURURfQ09SRV9DWUNMRVNfU0VMCQkgICAgICAweDNjCisjZGVmaW5lIEFSQ0hfUEVSRk1PTl9VTkhBTFRFRF9DT1JFX0NZQ0xFU19VTUFTSwkJKDB4MDAgPDwgOCkKKyNkZWZpbmUgQVJDSF9QRVJGTU9OX1VOSEFMVEVEX0NPUkVfQ1lDTEVTX0lOREVYIAkJIDAKKyNkZWZpbmUgQVJDSF9QRVJGTU9OX1VOSEFMVEVEX0NPUkVfQ1lDTEVTX1BSRVNFTlQgXAorCQkoMSA8PCAoQVJDSF9QRVJGTU9OX1VOSEFMVEVEX0NPUkVfQ1lDTEVTX0lOREVYKSkKKworI2RlZmluZSBBUkNIX1BFUkZNT05fQlJBTkNIX01JU1NFU19SRVRJUkVECQkJIDYKKworLyoKKyAqIEludGVsICJBcmNoaXRlY3R1cmFsIFBlcmZvcm1hbmNlIE1vbml0b3JpbmciIENQVUlECisgKiBkZXRlY3Rpb24vZW51bWVyYXRpb24gZGV0YWlsczoKKyAqLwordW5pb24gY3B1aWQxMF9lYXggeworCXN0cnVjdCB7CisJCXVuc2lnbmVkIGludCB2ZXJzaW9uX2lkOjg7CisJCXVuc2lnbmVkIGludCBudW1fY291bnRlcnM6ODsKKwkJdW5zaWduZWQgaW50IGJpdF93aWR0aDo4OworCQl1bnNpZ25lZCBpbnQgbWFza19sZW5ndGg6ODsKKwl9IHNwbGl0OworCXVuc2lnbmVkIGludCBmdWxsOworfTsKKwordW5pb24gY3B1aWQxMF9lZHggeworCXN0cnVjdCB7CisJCXVuc2lnbmVkIGludCBudW1fY291bnRlcnNfZml4ZWQ6NDsKKwkJdW5zaWduZWQgaW50IHJlc2VydmVkOjI4OworCX0gc3BsaXQ7CisJdW5zaWduZWQgaW50IGZ1bGw7Cit9OworCisKKy8qCisgKiBGaXhlZC1wdXJwb3NlIHBlcmZvcm1hbmNlIGNvdW50ZXJzOgorICovCisKKy8qCisgKiBBbGwgMyBmaXhlZC1tb2RlIFBNQ3MgYXJlIGNvbmZpZ3VyZWQgdmlhIHRoaXMgc2luZ2xlIE1TUjoKKyAqLworI2RlZmluZSBNU1JfQVJDSF9QRVJGTU9OX0ZJWEVEX0NUUl9DVFJMCQkJMHgzOGQKKworLyoKKyAqIFRoZSBjb3VudHMgYXJlIGF2YWlsYWJsZSBpbiB0aHJlZSBzZXBhcmF0ZSBNU1JzOgorICovCisKKy8qIEluc3RyX1JldGlyZWQuQW55OiAqLworI2RlZmluZSBNU1JfQVJDSF9QRVJGTU9OX0ZJWEVEX0NUUjAJCQkweDMwOQorI2RlZmluZSBYODZfUE1DX0lEWF9GSVhFRF9JTlNUUlVDVElPTlMJCQkoWDg2X1BNQ19JRFhfRklYRUQgKyAwKQorCisvKiBDUFVfQ0xLX1VuaGFsdGVkLkNvcmU6ICovCisjZGVmaW5lIE1TUl9BUkNIX1BFUkZNT05fRklYRURfQ1RSMQkJCTB4MzBhCisjZGVmaW5lIFg4Nl9QTUNfSURYX0ZJWEVEX0NQVV9DWUNMRVMJCQkoWDg2X1BNQ19JRFhfRklYRUQgKyAxKQorCisvKiBDUFVfQ0xLX1VuaGFsdGVkLlJlZjogKi8KKyNkZWZpbmUgTVNSX0FSQ0hfUEVSRk1PTl9GSVhFRF9DVFIyCQkJMHgzMGIKKyNkZWZpbmUgWDg2X1BNQ19JRFhfRklYRURfQlVTX0NZQ0xFUwkJCShYODZfUE1DX0lEWF9GSVhFRCArIDIpCisKK2V4dGVybiB2b2lkIHNldF9wZXJmX2NvdW50ZXJfcGVuZGluZyh2b2lkKTsKKworI2RlZmluZSBjbGVhcl9wZXJmX2NvdW50ZXJfcGVuZGluZygpCWRvIHsgfSB3aGlsZSAoMCkKKyNkZWZpbmUgdGVzdF9wZXJmX2NvdW50ZXJfcGVuZGluZygpCSgwKQorCisjaWZkZWYgQ09ORklHX1BFUkZfQ09VTlRFUlMKK2V4dGVybiB2b2lkIGluaXRfaHdfcGVyZl9jb3VudGVycyh2b2lkKTsKK2V4dGVybiB2b2lkIHBlcmZfY291bnRlcnNfbGFwaWNfaW5pdCh2b2lkKTsKKyNlbHNlCitzdGF0aWMgaW5saW5lIHZvaWQgaW5pdF9od19wZXJmX2NvdW50ZXJzKHZvaWQpCQl7IH0KK3N0YXRpYyBpbmxpbmUgdm9pZCBwZXJmX2NvdW50ZXJzX2xhcGljX2luaXQodm9pZCkJeyB9CisjZW5kaWYKKworI2VuZGlmIC8qIF9BU01fWDg2X1BFUkZfQ09VTlRFUl9IICovCmRpZmYgLS1naXQgYS9hcmNoL3g4Ni9pbmNsdWRlL2FzbS91bmlzdGRfMzIuaCBiL2FyY2gveDg2L2luY2x1ZGUvYXNtL3VuaXN0ZF8zMi5oCmluZGV4IDcwOGRhZTYxLi43MzJhMzA3MCAxMDA2NDQKLS0tIGEvYXJjaC94ODYvaW5jbHVkZS9hc20vdW5pc3RkXzMyLmgKKysrIGIvYXJjaC94ODYvaW5jbHVkZS9hc20vdW5pc3RkXzMyLmgKQEAgLTM0MSw2ICszNDEsNyBAQAogI2RlZmluZSBfX05SX3ByZWFkdgkJMzMzCiAjZGVmaW5lIF9fTlJfcHdyaXRldgkJMzM0CiAjZGVmaW5lIF9fTlJfcnRfdGdzaWdxdWV1ZWluZm8JMzM1CisjZGVmaW5lIF9fTlJfcGVyZl9jb3VudGVyX29wZW4JMzM2CiAKICNpZmRlZiBfX0tFUk5FTF9fCiAKZGlmZiAtLWdpdCBhL2FyY2gveDg2L2luY2x1ZGUvYXNtL3VuaXN0ZF82NC5oIGIvYXJjaC94ODYvaW5jbHVkZS9hc20vdW5pc3RkXzY0LmgKaW5kZXggNGUyYjA1NC4uOTAwZTE2MSAxMDA2NDQKLS0tIGEvYXJjaC94ODYvaW5jbHVkZS9hc20vdW5pc3RkXzY0LmgKKysrIGIvYXJjaC94ODYvaW5jbHVkZS9hc20vdW5pc3RkXzY0LmgKQEAgLTY1OSw3ICs2NTksOCBAQAogX19TWVNDQUxMKF9fTlJfcHdyaXRldiwgc3lzX3B3cml0ZXYpCiAjZGVmaW5lIF9fTlJfcnRfdGdzaWdxdWV1ZWluZm8JCQkyOTcKIF9fU1lTQ0FMTChfX05SX3J0X3Rnc2lncXVldWVpbmZvLCBzeXNfcnRfdGdzaWdxdWV1ZWluZm8pCi0KKyNkZWZpbmUgX19OUl9wZXJmX2NvdW50ZXJfb3BlbgkJCTI5OAorX19TWVNDQUxMKF9fTlJfcGVyZl9jb3VudGVyX29wZW4sIHN5c19wZXJmX2NvdW50ZXJfb3BlbikKIAogI2lmbmRlZiBfX05PX1NUVUJTCiAjZGVmaW5lIF9fQVJDSF9XQU5UX09MRF9SRUFERElSCmRpZmYgLS1naXQgYS9hcmNoL3g4Ni9rZXJuZWwvYXBpYy9hcGljLmMgYi9hcmNoL3g4Ni9rZXJuZWwvYXBpYy9hcGljLmMKaW5kZXggYTRjOWNmMC4uMDc2ZDM4OCAxMDA2NDQKLS0tIGEvYXJjaC94ODYva2VybmVsL2FwaWMvYXBpYy5jCisrKyBiL2FyY2gveDg2L2tlcm5lbC9hcGljL2FwaWMuYwpAQCAtMTQsNiArMTQsNyBAQAogICoJTWlrYWVsIFBldHRlcnNzb24JOglQTSBjb252ZXJ0ZWQgdG8gZHJpdmVyIG1vZGVsLgogICovCiAKKyNpbmNsdWRlIDxsaW51eC9wZXJmX2NvdW50ZXIuaD4KICNpbmNsdWRlIDxsaW51eC9rZXJuZWxfc3RhdC5oPgogI2luY2x1ZGUgPGxpbnV4L21jMTQ2ODE4cnRjLmg+CiAjaW5jbHVkZSA8bGludXgvYWNwaV9wbXRtci5oPgpAQCAtMzQsNiArMzUsNyBAQAogI2luY2x1ZGUgPGxpbnV4L3NtcC5oPgogI2luY2x1ZGUgPGxpbnV4L21tLmg+CiAKKyNpbmNsdWRlIDxhc20vcGVyZl9jb3VudGVyLmg+CiAjaW5jbHVkZSA8YXNtL3BnYWxsb2MuaD4KICNpbmNsdWRlIDxhc20vYXRvbWljLmg+CiAjaW5jbHVkZSA8YXNtL21wc3BlYy5oPgpAQCAtMTE4Nyw2ICsxMTg5LDcgQEAKIAkJYXBpY193cml0ZShBUElDX0VTUiwgMCk7CiAJfQogI2VuZGlmCisJcGVyZl9jb3VudGVyc19sYXBpY19pbml0KCk7CiAKIAlwcmVlbXB0X2Rpc2FibGUoKTsKIApkaWZmIC0tZ2l0IGEvYXJjaC94ODYva2VybmVsL2FwaWMvaW9fYXBpYy5jIGIvYXJjaC94ODYva2VybmVsL2FwaWMvaW9fYXBpYy5jCmluZGV4IDE5NDZmYWMuLjk0NjA1ZTcgMTAwNjQ0Ci0tLSBhL2FyY2gveDg2L2tlcm5lbC9hcGljL2lvX2FwaWMuYworKysgYi9hcmNoL3g4Ni9rZXJuZWwvYXBpYy9pb19hcGljLmMKQEAgLTE3NywxNiArMTc3LDE4IEBACiAJc3RydWN0IGlycV9jZmcgKmNmZzsKIAlzdHJ1Y3QgaXJxX2Rlc2MgKmRlc2M7CiAJaW50IGNvdW50OworCWludCBub2RlOwogCWludCBpOwogCiAJY2ZnID0gaXJxX2NmZ3g7CiAJY291bnQgPSBBUlJBWV9TSVpFKGlycV9jZmd4KTsKKwlub2RlPSBjcHVfdG9fbm9kZShib290X2NwdV9pZCk7CiAKIAlmb3IgKGkgPSAwOyBpIDwgY291bnQ7IGkrKykgewogCQlkZXNjID0gaXJxX3RvX2Rlc2MoaSk7CiAJCWRlc2MtPmNoaXBfZGF0YSA9ICZjZmdbaV07Ci0JCWFsbG9jX2Jvb3RtZW1fY3B1bWFza192YXIoJmNmZ1tpXS5kb21haW4pOwotCQlhbGxvY19ib290bWVtX2NwdW1hc2tfdmFyKCZjZmdbaV0ub2xkX2RvbWFpbik7CisJCWFsbG9jX2NwdW1hc2tfdmFyX25vZGUoJmNmZ1tpXS5kb21haW4sIEdGUF9OT1dBSVQsIG5vZGUpOworCQlhbGxvY19jcHVtYXNrX3Zhcl9ub2RlKCZjZmdbaV0ub2xkX2RvbWFpbiwgR0ZQX05PV0FJVCwgbm9kZSk7CiAJCWlmIChpIDwgTlJfSVJRU19MRUdBQ1kpCiAJCQljcHVtYXNrX3NldGFsbChjZmdbaV0uZG9tYWluKTsKIAl9CmRpZmYgLS1naXQgYS9hcmNoL3g4Ni9rZXJuZWwvY3B1L01ha2VmaWxlIGIvYXJjaC94ODYva2VybmVsL2NwdS9NYWtlZmlsZQppbmRleCA0ZTI0MmY5Li4zZWZjYjJiIDEwMDY0NAotLS0gYS9hcmNoL3g4Ni9rZXJuZWwvY3B1L01ha2VmaWxlCisrKyBiL2FyY2gveDg2L2tlcm5lbC9jcHUvTWFrZWZpbGUKQEAgLTEsNSArMSw1IEBACiAjCi0jIE1ha2VmaWxlIGZvciB4ODYtY29tcGF0aWJsZSBDUFUgZGV0YWlscyBhbmQgcXVpcmtzCisjIE1ha2VmaWxlIGZvciB4ODYtY29tcGF0aWJsZSBDUFUgZGV0YWlscywgZmVhdHVyZXMgYW5kIHF1aXJrcwogIwogCiAjIERvbid0IHRyYWNlIGVhcmx5IHN0YWdlcyBvZiBhIHNlY29uZGFyeSBDUFUgYm9vdApAQCAtMjMsMTEgKzIzLDEzIEBACiBvYmotJChDT05GSUdfQ1BVX1NVUF9UUkFOU01FVEFfMzIpCSs9IHRyYW5zbWV0YS5vCiBvYmotJChDT05GSUdfQ1BVX1NVUF9VTUNfMzIpCQkrPSB1bWMubwogCi1vYmotJChDT05GSUdfWDg2X01DRSkJKz0gbWNoZWNrLwotb2JqLSQoQ09ORklHX01UUlIpCSs9IG10cnIvCi1vYmotJChDT05GSUdfQ1BVX0ZSRVEpCSs9IGNwdWZyZXEvCitvYmotJChDT05GSUdfUEVSRl9DT1VOVEVSUykJCSs9IHBlcmZfY291bnRlci5vCiAKLW9iai0kKENPTkZJR19YODZfTE9DQUxfQVBJQykgKz0gcGVyZmN0ci13YXRjaGRvZy5vCitvYmotJChDT05GSUdfWDg2X01DRSkJCQkrPSBtY2hlY2svCitvYmotJChDT05GSUdfTVRSUikJCQkrPSBtdHJyLworb2JqLSQoQ09ORklHX0NQVV9GUkVRKQkJCSs9IGNwdWZyZXEvCisKK29iai0kKENPTkZJR19YODZfTE9DQUxfQVBJQykJCSs9IHBlcmZjdHItd2F0Y2hkb2cubwogCiBxdWlldF9jbWRfbWtjYXBmbGFncyA9IE1LQ0FQICAgJEAKICAgICAgIGNtZF9ta2NhcGZsYWdzID0gJChQRVJMKSAkKHNyY3RyZWUpLyQoc3JjKS9ta2NhcGZsYWdzLnBsICQ8ICRACmRpZmYgLS1naXQgYS9hcmNoL3g4Ni9rZXJuZWwvY3B1L2NvbW1vbi5jIGIvYXJjaC94ODYva2VybmVsL2NwdS9jb21tb24uYwppbmRleCBiMDUxN2FhLi4zZmZkY2ZhIDEwMDY0NAotLS0gYS9hcmNoL3g4Ni9rZXJuZWwvY3B1L2NvbW1vbi5jCisrKyBiL2FyY2gveDg2L2tlcm5lbC9jcHUvY29tbW9uLmMKQEAgLTEzLDYgKzEzLDcgQEAKICNpbmNsdWRlIDxsaW51eC9pby5oPgogCiAjaW5jbHVkZSA8YXNtL3N0YWNrcHJvdGVjdG9yLmg+CisjaW5jbHVkZSA8YXNtL3BlcmZfY291bnRlci5oPgogI2luY2x1ZGUgPGFzbS9tbXVfY29udGV4dC5oPgogI2luY2x1ZGUgPGFzbS9oeXBlcnZpc29yLmg+CiAjaW5jbHVkZSA8YXNtL3Byb2Nlc3Nvci5oPgpAQCAtODc0LDYgKzg3NSw3IEBACiAjZWxzZQogCXZnZXRjcHVfc2V0X21vZGUoKTsKICNlbmRpZgorCWluaXRfaHdfcGVyZl9jb3VudGVycygpOwogfQogCiB2b2lkIF9fY3B1aW5pdCBpZGVudGlmeV9zZWNvbmRhcnlfY3B1KHN0cnVjdCBjcHVpbmZvX3g4NiAqYykKZGlmZiAtLWdpdCBhL2FyY2gveDg2L2tlcm5lbC9jcHUvcGVyZl9jb3VudGVyLmMgYi9hcmNoL3g4Ni9rZXJuZWwvY3B1L3BlcmZfY291bnRlci5jCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjg5NWM4MmUKLS0tIC9kZXYvbnVsbAorKysgYi9hcmNoL3g4Ni9rZXJuZWwvY3B1L3BlcmZfY291bnRlci5jCkBAIC0wLDAgKzEsMTcwNCBAQAorLyoKKyAqIFBlcmZvcm1hbmNlIGNvdW50ZXIgeDg2IGFyY2hpdGVjdHVyZSBjb2RlCisgKgorICogIENvcHlyaWdodCAoQykgMjAwOCBUaG9tYXMgR2xlaXhuZXIgPHRnbHhAbGludXRyb25peC5kZT4KKyAqICBDb3B5cmlnaHQgKEMpIDIwMDgtMjAwOSBSZWQgSGF0LCBJbmMuLCBJbmdvIE1vbG5hcgorICogIENvcHlyaWdodCAoQykgMjAwOSBKYXN3aW5kZXIgU2luZ2ggUmFqcHV0CisgKiAgQ29weXJpZ2h0IChDKSAyMDA5IEFkdmFuY2VkIE1pY3JvIERldmljZXMsIEluYy4sIFJvYmVydCBSaWNodGVyCisgKiAgQ29weXJpZ2h0IChDKSAyMDA4LTIwMDkgUmVkIEhhdCwgSW5jLiwgUGV0ZXIgWmlqbHN0cmEgPHB6aWpsc3RyQHJlZGhhdC5jb20+CisgKgorICogIEZvciBsaWNlbmNpbmcgZGV0YWlscyBzZWUga2VybmVsLWJhc2UvQ09QWUlORworICovCisKKyNpbmNsdWRlIDxsaW51eC9wZXJmX2NvdW50ZXIuaD4KKyNpbmNsdWRlIDxsaW51eC9jYXBhYmlsaXR5Lmg+CisjaW5jbHVkZSA8bGludXgvbm90aWZpZXIuaD4KKyNpbmNsdWRlIDxsaW51eC9oYXJkaXJxLmg+CisjaW5jbHVkZSA8bGludXgva3Byb2Jlcy5oPgorI2luY2x1ZGUgPGxpbnV4L21vZHVsZS5oPgorI2luY2x1ZGUgPGxpbnV4L2tkZWJ1Zy5oPgorI2luY2x1ZGUgPGxpbnV4L3NjaGVkLmg+CisjaW5jbHVkZSA8bGludXgvdWFjY2Vzcy5oPgorCisjaW5jbHVkZSA8YXNtL2FwaWMuaD4KKyNpbmNsdWRlIDxhc20vc3RhY2t0cmFjZS5oPgorI2luY2x1ZGUgPGFzbS9ubWkuaD4KKworc3RhdGljIHU2NCBwZXJmX2NvdW50ZXJfbWFzayBfX3JlYWRfbW9zdGx5OworCitzdHJ1Y3QgY3B1X2h3X2NvdW50ZXJzIHsKKwlzdHJ1Y3QgcGVyZl9jb3VudGVyCSpjb3VudGVyc1tYODZfUE1DX0lEWF9NQVhdOworCXVuc2lnbmVkIGxvbmcJCXVzZWRfbWFza1tCSVRTX1RPX0xPTkdTKFg4Nl9QTUNfSURYX01BWCldOworCXVuc2lnbmVkIGxvbmcJCWFjdGl2ZV9tYXNrW0JJVFNfVE9fTE9OR1MoWDg2X1BNQ19JRFhfTUFYKV07CisJdW5zaWduZWQgbG9uZwkJaW50ZXJydXB0czsKKwlpbnQJCQllbmFibGVkOworfTsKKworLyoKKyAqIHN0cnVjdCB4ODZfcG11IC0gZ2VuZXJpYyB4ODYgcG11CisgKi8KK3N0cnVjdCB4ODZfcG11IHsKKwljb25zdCBjaGFyCSpuYW1lOworCWludAkJdmVyc2lvbjsKKwlpbnQJCSgqaGFuZGxlX2lycSkoc3RydWN0IHB0X3JlZ3MgKik7CisJdm9pZAkJKCpkaXNhYmxlX2FsbCkodm9pZCk7CisJdm9pZAkJKCplbmFibGVfYWxsKSh2b2lkKTsKKwl2b2lkCQkoKmVuYWJsZSkoc3RydWN0IGh3X3BlcmZfY291bnRlciAqLCBpbnQpOworCXZvaWQJCSgqZGlzYWJsZSkoc3RydWN0IGh3X3BlcmZfY291bnRlciAqLCBpbnQpOworCXVuc2lnbmVkCWV2ZW50c2VsOworCXVuc2lnbmVkCXBlcmZjdHI7CisJdTY0CQkoKmV2ZW50X21hcCkoaW50KTsKKwl1NjQJCSgqcmF3X2V2ZW50KSh1NjQpOworCWludAkJbWF4X2V2ZW50czsKKwlpbnQJCW51bV9jb3VudGVyczsKKwlpbnQJCW51bV9jb3VudGVyc19maXhlZDsKKwlpbnQJCWNvdW50ZXJfYml0czsKKwl1NjQJCWNvdW50ZXJfbWFzazsKKwl1NjQJCW1heF9wZXJpb2Q7CisJdTY0CQlpbnRlbF9jdHJsOworfTsKKworc3RhdGljIHN0cnVjdCB4ODZfcG11IHg4Nl9wbXUgX19yZWFkX21vc3RseTsKKworc3RhdGljIERFRklORV9QRVJfQ1BVKHN0cnVjdCBjcHVfaHdfY291bnRlcnMsIGNwdV9od19jb3VudGVycykgPSB7CisJLmVuYWJsZWQgPSAxLAorfTsKKworLyoKKyAqIEludGVsIFBlcmZNb24gdjMuIFVzZWQgb24gQ29yZTIgYW5kIGxhdGVyLgorICovCitzdGF0aWMgY29uc3QgdTY0IGludGVsX3BlcmZtb25fZXZlbnRfbWFwW10gPQoreworICBbUEVSRl9DT1VOVF9IV19DUFVfQ1lDTEVTXQkJPSAweDAwM2MsCisgIFtQRVJGX0NPVU5UX0hXX0lOU1RSVUNUSU9OU10JCT0gMHgwMGMwLAorICBbUEVSRl9DT1VOVF9IV19DQUNIRV9SRUZFUkVOQ0VTXQk9IDB4NGYyZSwKKyAgW1BFUkZfQ09VTlRfSFdfQ0FDSEVfTUlTU0VTXQkJPSAweDQxMmUsCisgIFtQRVJGX0NPVU5UX0hXX0JSQU5DSF9JTlNUUlVDVElPTlNdCT0gMHgwMGM0LAorICBbUEVSRl9DT1VOVF9IV19CUkFOQ0hfTUlTU0VTXQkJPSAweDAwYzUsCisgIFtQRVJGX0NPVU5UX0hXX0JVU19DWUNMRVNdCQk9IDB4MDEzYywKK307CisKK3N0YXRpYyB1NjQgaW50ZWxfcG11X2V2ZW50X21hcChpbnQgZXZlbnQpCit7CisJcmV0dXJuIGludGVsX3BlcmZtb25fZXZlbnRfbWFwW2V2ZW50XTsKK30KKworLyoKKyAqIEdlbmVyYWxpemVkIGh3IGNhY2hpbmcgcmVsYXRlZCBldmVudCB0YWJsZSwgZmlsbGVkCisgKiBpbiBvbiBhIHBlciBtb2RlbCBiYXNpcy4gQSB2YWx1ZSBvZiAwIG1lYW5zCisgKiAnbm90IHN1cHBvcnRlZCcsIC0xIG1lYW5zICdldmVudCBtYWtlcyBubyBzZW5zZSBvbgorICogdGhpcyBDUFUnLCBhbnkgb3RoZXIgdmFsdWUgbWVhbnMgdGhlIHJhdyBldmVudAorICogSUQuCisgKi8KKworI2RlZmluZSBDKHgpIFBFUkZfQ09VTlRfSFdfQ0FDSEVfIyN4CisKK3N0YXRpYyB1NjQgX19yZWFkX21vc3RseSBod19jYWNoZV9ldmVudF9pZHMKKwkJCQlbUEVSRl9DT1VOVF9IV19DQUNIRV9NQVhdCisJCQkJW1BFUkZfQ09VTlRfSFdfQ0FDSEVfT1BfTUFYXQorCQkJCVtQRVJGX0NPVU5UX0hXX0NBQ0hFX1JFU1VMVF9NQVhdOworCitzdGF0aWMgY29uc3QgdTY0IG5laGFsZW1faHdfY2FjaGVfZXZlbnRfaWRzCisJCQkJW1BFUkZfQ09VTlRfSFdfQ0FDSEVfTUFYXQorCQkJCVtQRVJGX0NPVU5UX0hXX0NBQ0hFX09QX01BWF0KKwkJCQlbUEVSRl9DT1VOVF9IV19DQUNIRV9SRVNVTFRfTUFYXSA9Cit7CisgWyBDKEwxRCkgXSA9IHsKKwlbIEMoT1BfUkVBRCkgXSA9IHsKKwkJWyBDKFJFU1VMVF9BQ0NFU1MpIF0gPSAweDBmNDAsIC8qIEwxRF9DQUNIRV9MRC5NRVNJICAgICAgICAgICAgKi8KKwkJWyBDKFJFU1VMVF9NSVNTKSAgIF0gPSAweDAxNDAsIC8qIEwxRF9DQUNIRV9MRC5JX1NUQVRFICAgICAgICAgKi8KKwl9LAorCVsgQyhPUF9XUklURSkgXSA9IHsKKwkJWyBDKFJFU1VMVF9BQ0NFU1MpIF0gPSAweDBmNDEsIC8qIEwxRF9DQUNIRV9TVC5NRVNJICAgICAgICAgICAgKi8KKwkJWyBDKFJFU1VMVF9NSVNTKSAgIF0gPSAweDAxNDEsIC8qIEwxRF9DQUNIRV9TVC5JX1NUQVRFICAgICAgICAgKi8KKwl9LAorCVsgQyhPUF9QUkVGRVRDSCkgXSA9IHsKKwkJWyBDKFJFU1VMVF9BQ0NFU1MpIF0gPSAweDAxNGUsIC8qIEwxRF9QUkVGRVRDSC5SRVFVRVNUUyAgICAgICAgKi8KKwkJWyBDKFJFU1VMVF9NSVNTKSAgIF0gPSAweDAyNGUsIC8qIEwxRF9QUkVGRVRDSC5NSVNTICAgICAgICAgICAgKi8KKwl9LAorIH0sCisgWyBDKEwxSSApIF0gPSB7CisJWyBDKE9QX1JFQUQpIF0gPSB7CisJCVsgQyhSRVNVTFRfQUNDRVNTKSBdID0gMHgwMzgwLCAvKiBMMUkuUkVBRFMgICAgICAgICAgICAgICAgICAgICovCisJCVsgQyhSRVNVTFRfTUlTUykgICBdID0gMHgwMjgwLCAvKiBMMUkuTUlTU0VTICAgICAgICAgICAgICAgICAgICovCisJfSwKKwlbIEMoT1BfV1JJVEUpIF0gPSB7CisJCVsgQyhSRVNVTFRfQUNDRVNTKSBdID0gLTEsCisJCVsgQyhSRVNVTFRfTUlTUykgICBdID0gLTEsCisJfSwKKwlbIEMoT1BfUFJFRkVUQ0gpIF0gPSB7CisJCVsgQyhSRVNVTFRfQUNDRVNTKSBdID0gMHgwLAorCQlbIEMoUkVTVUxUX01JU1MpICAgXSA9IDB4MCwKKwl9LAorIH0sCisgWyBDKExMICApIF0gPSB7CisJWyBDKE9QX1JFQUQpIF0gPSB7CisJCVsgQyhSRVNVTFRfQUNDRVNTKSBdID0gMHgwMzI0LCAvKiBMMl9SUVNUUy5MT0FEUyAgICAgICAgICAgICAgICovCisJCVsgQyhSRVNVTFRfTUlTUykgICBdID0gMHgwMjI0LCAvKiBMMl9SUVNUUy5MRF9NSVNTICAgICAgICAgICAgICovCisJfSwKKwlbIEMoT1BfV1JJVEUpIF0gPSB7CisJCVsgQyhSRVNVTFRfQUNDRVNTKSBdID0gMHgwYzI0LCAvKiBMMl9SUVNUUy5SRk9TICAgICAgICAgICAgICAgICovCisJCVsgQyhSRVNVTFRfTUlTUykgICBdID0gMHgwODI0LCAvKiBMMl9SUVNUUy5SRk9fTUlTUyAgICAgICAgICAgICovCisJfSwKKwlbIEMoT1BfUFJFRkVUQ0gpIF0gPSB7CisJCVsgQyhSRVNVTFRfQUNDRVNTKSBdID0gMHg0ZjJlLCAvKiBMTEMgUmVmZXJlbmNlICAgICAgICAgICAgICAgICovCisJCVsgQyhSRVNVTFRfTUlTUykgICBdID0gMHg0MTJlLCAvKiBMTEMgTWlzc2VzICAgICAgICAgICAgICAgICAgICovCisJfSwKKyB9LAorIFsgQyhEVExCKSBdID0geworCVsgQyhPUF9SRUFEKSBdID0geworCQlbIEMoUkVTVUxUX0FDQ0VTUykgXSA9IDB4MGY0MCwgLyogTDFEX0NBQ0hFX0xELk1FU0kgICAoYWxpYXMpICAqLworCQlbIEMoUkVTVUxUX01JU1MpICAgXSA9IDB4MDEwOCwgLyogRFRMQl9MT0FEX01JU1NFUy5BTlkgICAgICAgICAqLworCX0sCisJWyBDKE9QX1dSSVRFKSBdID0geworCQlbIEMoUkVTVUxUX0FDQ0VTUykgXSA9IDB4MGY0MSwgLyogTDFEX0NBQ0hFX1NULk1FU0kgICAoYWxpYXMpICAqLworCQlbIEMoUkVTVUxUX01JU1MpICAgXSA9IDB4MDEwYywgLyogTUVNX1NUT1JFX1JFVElSRUQuRFRMQl9NSVNTICAqLworCX0sCisJWyBDKE9QX1BSRUZFVENIKSBdID0geworCQlbIEMoUkVTVUxUX0FDQ0VTUykgXSA9IDB4MCwKKwkJWyBDKFJFU1VMVF9NSVNTKSAgIF0gPSAweDAsCisJfSwKKyB9LAorIFsgQyhJVExCKSBdID0geworCVsgQyhPUF9SRUFEKSBdID0geworCQlbIEMoUkVTVUxUX0FDQ0VTUykgXSA9IDB4MDFjMCwgLyogSU5TVF9SRVRJUkVELkFOWV9QICAgICAgICAgICAqLworCQlbIEMoUkVTVUxUX01JU1MpICAgXSA9IDB4MjBjOCwgLyogSVRMQl9NSVNTX1JFVElSRUQgICAgICAgICAgICAqLworCX0sCisJWyBDKE9QX1dSSVRFKSBdID0geworCQlbIEMoUkVTVUxUX0FDQ0VTUykgXSA9IC0xLAorCQlbIEMoUkVTVUxUX01JU1MpICAgXSA9IC0xLAorCX0sCisJWyBDKE9QX1BSRUZFVENIKSBdID0geworCQlbIEMoUkVTVUxUX0FDQ0VTUykgXSA9IC0xLAorCQlbIEMoUkVTVUxUX01JU1MpICAgXSA9IC0xLAorCX0sCisgfSwKKyBbIEMoQlBVICkgXSA9IHsKKwlbIEMoT1BfUkVBRCkgXSA9IHsKKwkJWyBDKFJFU1VMVF9BQ0NFU1MpIF0gPSAweDAwYzQsIC8qIEJSX0lOU1RfUkVUSVJFRC5BTExfQlJBTkNIRVMgKi8KKwkJWyBDKFJFU1VMVF9NSVNTKSAgIF0gPSAweDAzZTgsIC8qIEJQVV9DTEVBUlMuQU5ZICAgICAgICAgICAgICAgKi8KKwl9LAorCVsgQyhPUF9XUklURSkgXSA9IHsKKwkJWyBDKFJFU1VMVF9BQ0NFU1MpIF0gPSAtMSwKKwkJWyBDKFJFU1VMVF9NSVNTKSAgIF0gPSAtMSwKKwl9LAorCVsgQyhPUF9QUkVGRVRDSCkgXSA9IHsKKwkJWyBDKFJFU1VMVF9BQ0NFU1MpIF0gPSAtMSwKKwkJWyBDKFJFU1VMVF9NSVNTKSAgIF0gPSAtMSwKKwl9LAorIH0sCit9OworCitzdGF0aWMgY29uc3QgdTY0IGNvcmUyX2h3X2NhY2hlX2V2ZW50X2lkcworCQkJCVtQRVJGX0NPVU5UX0hXX0NBQ0hFX01BWF0KKwkJCQlbUEVSRl9DT1VOVF9IV19DQUNIRV9PUF9NQVhdCisJCQkJW1BFUkZfQ09VTlRfSFdfQ0FDSEVfUkVTVUxUX01BWF0gPQoreworIFsgQyhMMUQpIF0gPSB7CisJWyBDKE9QX1JFQUQpIF0gPSB7CisJCVsgQyhSRVNVTFRfQUNDRVNTKSBdID0gMHgwZjQwLCAvKiBMMURfQ0FDSEVfTEQuTUVTSSAgICAgICAgICAqLworCQlbIEMoUkVTVUxUX01JU1MpICAgXSA9IDB4MDE0MCwgLyogTDFEX0NBQ0hFX0xELklfU1RBVEUgICAgICAgKi8KKwl9LAorCVsgQyhPUF9XUklURSkgXSA9IHsKKwkJWyBDKFJFU1VMVF9BQ0NFU1MpIF0gPSAweDBmNDEsIC8qIEwxRF9DQUNIRV9TVC5NRVNJICAgICAgICAgICovCisJCVsgQyhSRVNVTFRfTUlTUykgICBdID0gMHgwMTQxLCAvKiBMMURfQ0FDSEVfU1QuSV9TVEFURSAgICAgICAqLworCX0sCisJWyBDKE9QX1BSRUZFVENIKSBdID0geworCQlbIEMoUkVTVUxUX0FDQ0VTUykgXSA9IDB4MTA0ZSwgLyogTDFEX1BSRUZFVENILlJFUVVFU1RTICAgICAgKi8KKwkJWyBDKFJFU1VMVF9NSVNTKSAgIF0gPSAwLAorCX0sCisgfSwKKyBbIEMoTDFJICkgXSA9IHsKKwlbIEMoT1BfUkVBRCkgXSA9IHsKKwkJWyBDKFJFU1VMVF9BQ0NFU1MpIF0gPSAweDAwODAsIC8qIEwxSS5SRUFEUyAgICAgICAgICAgICAgICAgICovCisJCVsgQyhSRVNVTFRfTUlTUykgICBdID0gMHgwMDgxLCAvKiBMMUkuTUlTU0VTICAgICAgICAgICAgICAgICAqLworCX0sCisJWyBDKE9QX1dSSVRFKSBdID0geworCQlbIEMoUkVTVUxUX0FDQ0VTUykgXSA9IC0xLAorCQlbIEMoUkVTVUxUX01JU1MpICAgXSA9IC0xLAorCX0sCisJWyBDKE9QX1BSRUZFVENIKSBdID0geworCQlbIEMoUkVTVUxUX0FDQ0VTUykgXSA9IDAsCisJCVsgQyhSRVNVTFRfTUlTUykgICBdID0gMCwKKwl9LAorIH0sCisgWyBDKExMICApIF0gPSB7CisJWyBDKE9QX1JFQUQpIF0gPSB7CisJCVsgQyhSRVNVTFRfQUNDRVNTKSBdID0gMHg0ZjI5LCAvKiBMMl9MRC5NRVNJICAgICAgICAgICAgICAgICAqLworCQlbIEMoUkVTVUxUX01JU1MpICAgXSA9IDB4NDEyOSwgLyogTDJfTEQuSVNUQVRFICAgICAgICAgICAgICAgKi8KKwl9LAorCVsgQyhPUF9XUklURSkgXSA9IHsKKwkJWyBDKFJFU1VMVF9BQ0NFU1MpIF0gPSAweDRmMkEsIC8qIEwyX1NULk1FU0kgICAgICAgICAgICAgICAgICovCisJCVsgQyhSRVNVTFRfTUlTUykgICBdID0gMHg0MTJBLCAvKiBMMl9TVC5JU1RBVEUgICAgICAgICAgICAgICAqLworCX0sCisJWyBDKE9QX1BSRUZFVENIKSBdID0geworCQlbIEMoUkVTVUxUX0FDQ0VTUykgXSA9IDAsCisJCVsgQyhSRVNVTFRfTUlTUykgICBdID0gMCwKKwl9LAorIH0sCisgWyBDKERUTEIpIF0gPSB7CisJWyBDKE9QX1JFQUQpIF0gPSB7CisJCVsgQyhSRVNVTFRfQUNDRVNTKSBdID0gMHgwZjQwLCAvKiBMMURfQ0FDSEVfTEQuTUVTSSAgKGFsaWFzKSAqLworCQlbIEMoUkVTVUxUX01JU1MpICAgXSA9IDB4MDIwOCwgLyogRFRMQl9NSVNTRVMuTUlTU19MRCAgICAgICAgKi8KKwl9LAorCVsgQyhPUF9XUklURSkgXSA9IHsKKwkJWyBDKFJFU1VMVF9BQ0NFU1MpIF0gPSAweDBmNDEsIC8qIEwxRF9DQUNIRV9TVC5NRVNJICAoYWxpYXMpICovCisJCVsgQyhSRVNVTFRfTUlTUykgICBdID0gMHgwODA4LCAvKiBEVExCX01JU1NFUy5NSVNTX1NUICAgICAgICAqLworCX0sCisJWyBDKE9QX1BSRUZFVENIKSBdID0geworCQlbIEMoUkVTVUxUX0FDQ0VTUykgXSA9IDAsCisJCVsgQyhSRVNVTFRfTUlTUykgICBdID0gMCwKKwl9LAorIH0sCisgWyBDKElUTEIpIF0gPSB7CisJWyBDKE9QX1JFQUQpIF0gPSB7CisJCVsgQyhSRVNVTFRfQUNDRVNTKSBdID0gMHgwMGMwLCAvKiBJTlNUX1JFVElSRUQuQU5ZX1AgICAgICAgICAqLworCQlbIEMoUkVTVUxUX01JU1MpICAgXSA9IDB4MTI4MiwgLyogSVRMQk1JU1NFUyAgICAgICAgICAgICAgICAgKi8KKwl9LAorCVsgQyhPUF9XUklURSkgXSA9IHsKKwkJWyBDKFJFU1VMVF9BQ0NFU1MpIF0gPSAtMSwKKwkJWyBDKFJFU1VMVF9NSVNTKSAgIF0gPSAtMSwKKwl9LAorCVsgQyhPUF9QUkVGRVRDSCkgXSA9IHsKKwkJWyBDKFJFU1VMVF9BQ0NFU1MpIF0gPSAtMSwKKwkJWyBDKFJFU1VMVF9NSVNTKSAgIF0gPSAtMSwKKwl9LAorIH0sCisgWyBDKEJQVSApIF0gPSB7CisJWyBDKE9QX1JFQUQpIF0gPSB7CisJCVsgQyhSRVNVTFRfQUNDRVNTKSBdID0gMHgwMGM0LCAvKiBCUl9JTlNUX1JFVElSRUQuQU5ZICAgICAgICAqLworCQlbIEMoUkVTVUxUX01JU1MpICAgXSA9IDB4MDBjNSwgLyogQlBfSU5TVF9SRVRJUkVELk1JU1BSRUQgICAgKi8KKwl9LAorCVsgQyhPUF9XUklURSkgXSA9IHsKKwkJWyBDKFJFU1VMVF9BQ0NFU1MpIF0gPSAtMSwKKwkJWyBDKFJFU1VMVF9NSVNTKSAgIF0gPSAtMSwKKwl9LAorCVsgQyhPUF9QUkVGRVRDSCkgXSA9IHsKKwkJWyBDKFJFU1VMVF9BQ0NFU1MpIF0gPSAtMSwKKwkJWyBDKFJFU1VMVF9NSVNTKSAgIF0gPSAtMSwKKwl9LAorIH0sCit9OworCitzdGF0aWMgY29uc3QgdTY0IGF0b21faHdfY2FjaGVfZXZlbnRfaWRzCisJCQkJW1BFUkZfQ09VTlRfSFdfQ0FDSEVfTUFYXQorCQkJCVtQRVJGX0NPVU5UX0hXX0NBQ0hFX09QX01BWF0KKwkJCQlbUEVSRl9DT1VOVF9IV19DQUNIRV9SRVNVTFRfTUFYXSA9Cit7CisgWyBDKEwxRCkgXSA9IHsKKwlbIEMoT1BfUkVBRCkgXSA9IHsKKwkJWyBDKFJFU1VMVF9BQ0NFU1MpIF0gPSAweDIxNDAsIC8qIEwxRF9DQUNIRS5MRCAgICAgICAgICAgICAgICovCisJCVsgQyhSRVNVTFRfTUlTUykgICBdID0gMCwKKwl9LAorCVsgQyhPUF9XUklURSkgXSA9IHsKKwkJWyBDKFJFU1VMVF9BQ0NFU1MpIF0gPSAweDIyNDAsIC8qIEwxRF9DQUNIRS5TVCAgICAgICAgICAgICAgICovCisJCVsgQyhSRVNVTFRfTUlTUykgICBdID0gMCwKKwl9LAorCVsgQyhPUF9QUkVGRVRDSCkgXSA9IHsKKwkJWyBDKFJFU1VMVF9BQ0NFU1MpIF0gPSAweDAsCisJCVsgQyhSRVNVTFRfTUlTUykgICBdID0gMCwKKwl9LAorIH0sCisgWyBDKEwxSSApIF0gPSB7CisJWyBDKE9QX1JFQUQpIF0gPSB7CisJCVsgQyhSRVNVTFRfQUNDRVNTKSBdID0gMHgwMzgwLCAvKiBMMUkuUkVBRFMgICAgICAgICAgICAgICAgICAqLworCQlbIEMoUkVTVUxUX01JU1MpICAgXSA9IDB4MDI4MCwgLyogTDFJLk1JU1NFUyAgICAgICAgICAgICAgICAgKi8KKwl9LAorCVsgQyhPUF9XUklURSkgXSA9IHsKKwkJWyBDKFJFU1VMVF9BQ0NFU1MpIF0gPSAtMSwKKwkJWyBDKFJFU1VMVF9NSVNTKSAgIF0gPSAtMSwKKwl9LAorCVsgQyhPUF9QUkVGRVRDSCkgXSA9IHsKKwkJWyBDKFJFU1VMVF9BQ0NFU1MpIF0gPSAwLAorCQlbIEMoUkVTVUxUX01JU1MpICAgXSA9IDAsCisJfSwKKyB9LAorIFsgQyhMTCAgKSBdID0geworCVsgQyhPUF9SRUFEKSBdID0geworCQlbIEMoUkVTVUxUX0FDQ0VTUykgXSA9IDB4NGYyOSwgLyogTDJfTEQuTUVTSSAgICAgICAgICAgICAgICAgKi8KKwkJWyBDKFJFU1VMVF9NSVNTKSAgIF0gPSAweDQxMjksIC8qIEwyX0xELklTVEFURSAgICAgICAgICAgICAgICovCisJfSwKKwlbIEMoT1BfV1JJVEUpIF0gPSB7CisJCVsgQyhSRVNVTFRfQUNDRVNTKSBdID0gMHg0ZjJBLCAvKiBMMl9TVC5NRVNJICAgICAgICAgICAgICAgICAqLworCQlbIEMoUkVTVUxUX01JU1MpICAgXSA9IDB4NDEyQSwgLyogTDJfU1QuSVNUQVRFICAgICAgICAgICAgICAgKi8KKwl9LAorCVsgQyhPUF9QUkVGRVRDSCkgXSA9IHsKKwkJWyBDKFJFU1VMVF9BQ0NFU1MpIF0gPSAwLAorCQlbIEMoUkVTVUxUX01JU1MpICAgXSA9IDAsCisJfSwKKyB9LAorIFsgQyhEVExCKSBdID0geworCVsgQyhPUF9SRUFEKSBdID0geworCQlbIEMoUkVTVUxUX0FDQ0VTUykgXSA9IDB4MjE0MCwgLyogTDFEX0NBQ0hFX0xELk1FU0kgIChhbGlhcykgKi8KKwkJWyBDKFJFU1VMVF9NSVNTKSAgIF0gPSAweDA1MDgsIC8qIERUTEJfTUlTU0VTLk1JU1NfTEQgICAgICAgICovCisJfSwKKwlbIEMoT1BfV1JJVEUpIF0gPSB7CisJCVsgQyhSRVNVTFRfQUNDRVNTKSBdID0gMHgyMjQwLCAvKiBMMURfQ0FDSEVfU1QuTUVTSSAgKGFsaWFzKSAqLworCQlbIEMoUkVTVUxUX01JU1MpICAgXSA9IDB4MDYwOCwgLyogRFRMQl9NSVNTRVMuTUlTU19TVCAgICAgICAgKi8KKwl9LAorCVsgQyhPUF9QUkVGRVRDSCkgXSA9IHsKKwkJWyBDKFJFU1VMVF9BQ0NFU1MpIF0gPSAwLAorCQlbIEMoUkVTVUxUX01JU1MpICAgXSA9IDAsCisJfSwKKyB9LAorIFsgQyhJVExCKSBdID0geworCVsgQyhPUF9SRUFEKSBdID0geworCQlbIEMoUkVTVUxUX0FDQ0VTUykgXSA9IDB4MDBjMCwgLyogSU5TVF9SRVRJUkVELkFOWV9QICAgICAgICAgKi8KKwkJWyBDKFJFU1VMVF9NSVNTKSAgIF0gPSAweDAyODIsIC8qIElUTEIuTUlTU0VTICAgICAgICAgICAgICAgICovCisJfSwKKwlbIEMoT1BfV1JJVEUpIF0gPSB7CisJCVsgQyhSRVNVTFRfQUNDRVNTKSBdID0gLTEsCisJCVsgQyhSRVNVTFRfTUlTUykgICBdID0gLTEsCisJfSwKKwlbIEMoT1BfUFJFRkVUQ0gpIF0gPSB7CisJCVsgQyhSRVNVTFRfQUNDRVNTKSBdID0gLTEsCisJCVsgQyhSRVNVTFRfTUlTUykgICBdID0gLTEsCisJfSwKKyB9LAorIFsgQyhCUFUgKSBdID0geworCVsgQyhPUF9SRUFEKSBdID0geworCQlbIEMoUkVTVUxUX0FDQ0VTUykgXSA9IDB4MDBjNCwgLyogQlJfSU5TVF9SRVRJUkVELkFOWSAgICAgICAgKi8KKwkJWyBDKFJFU1VMVF9NSVNTKSAgIF0gPSAweDAwYzUsIC8qIEJQX0lOU1RfUkVUSVJFRC5NSVNQUkVEICAgICovCisJfSwKKwlbIEMoT1BfV1JJVEUpIF0gPSB7CisJCVsgQyhSRVNVTFRfQUNDRVNTKSBdID0gLTEsCisJCVsgQyhSRVNVTFRfTUlTUykgICBdID0gLTEsCisJfSwKKwlbIEMoT1BfUFJFRkVUQ0gpIF0gPSB7CisJCVsgQyhSRVNVTFRfQUNDRVNTKSBdID0gLTEsCisJCVsgQyhSRVNVTFRfTUlTUykgICBdID0gLTEsCisJfSwKKyB9LAorfTsKKworc3RhdGljIHU2NCBpbnRlbF9wbXVfcmF3X2V2ZW50KHU2NCBldmVudCkKK3sKKyNkZWZpbmUgQ09SRV9FVk5UU0VMX0VWRU5UX01BU0sJCTB4MDAwMDAwRkZVTEwKKyNkZWZpbmUgQ09SRV9FVk5UU0VMX1VOSVRfTUFTSwkJMHgwMDAwRkYwMFVMTAorI2RlZmluZSBDT1JFX0VWTlRTRUxfRURHRV9NQVNLCQkweDAwMDQwMDAwVUxMCisjZGVmaW5lIENPUkVfRVZOVFNFTF9JTlZfTUFTSwkJMHgwMDgwMDAwMFVMTAorI2RlZmluZSBDT1JFX0VWTlRTRUxfQ09VTlRFUl9NQVNLCTB4RkYwMDAwMDBVTEwKKworI2RlZmluZSBDT1JFX0VWTlRTRUxfTUFTSwkJXAorCShDT1JFX0VWTlRTRUxfRVZFTlRfTUFTSyB8CVwKKwkgQ09SRV9FVk5UU0VMX1VOSVRfTUFTSyAgfAlcCisJIENPUkVfRVZOVFNFTF9FREdFX01BU0sgIHwJXAorCSBDT1JFX0VWTlRTRUxfSU5WX01BU0sgIHwJXAorCSBDT1JFX0VWTlRTRUxfQ09VTlRFUl9NQVNLKQorCisJcmV0dXJuIGV2ZW50ICYgQ09SRV9FVk5UU0VMX01BU0s7Cit9CisKK3N0YXRpYyBjb25zdCB1NjQgYW1kXzBmX2h3X2NhY2hlX2V2ZW50X2lkcworCQkJCVtQRVJGX0NPVU5UX0hXX0NBQ0hFX01BWF0KKwkJCQlbUEVSRl9DT1VOVF9IV19DQUNIRV9PUF9NQVhdCisJCQkJW1BFUkZfQ09VTlRfSFdfQ0FDSEVfUkVTVUxUX01BWF0gPQoreworIFsgQyhMMUQpIF0gPSB7CisJWyBDKE9QX1JFQUQpIF0gPSB7CisJCVsgQyhSRVNVTFRfQUNDRVNTKSBdID0gMCwKKwkJWyBDKFJFU1VMVF9NSVNTKSAgIF0gPSAwLAorCX0sCisJWyBDKE9QX1dSSVRFKSBdID0geworCQlbIEMoUkVTVUxUX0FDQ0VTUykgXSA9IDAsCisJCVsgQyhSRVNVTFRfTUlTUykgICBdID0gMCwKKwl9LAorCVsgQyhPUF9QUkVGRVRDSCkgXSA9IHsKKwkJWyBDKFJFU1VMVF9BQ0NFU1MpIF0gPSAwLAorCQlbIEMoUkVTVUxUX01JU1MpICAgXSA9IDAsCisJfSwKKyB9LAorIFsgQyhMMUkgKSBdID0geworCVsgQyhPUF9SRUFEKSBdID0geworCQlbIEMoUkVTVUxUX0FDQ0VTUykgXSA9IDB4MDA4MCwgLyogSW5zdHJ1Y3Rpb24gY2FjaGUgZmV0Y2hlcyAgKi8KKwkJWyBDKFJFU1VMVF9NSVNTKSAgIF0gPSAweDAwODEsIC8qIEluc3RydWN0aW9uIGNhY2hlIG1pc3NlcyAgICovCisJfSwKKwlbIEMoT1BfV1JJVEUpIF0gPSB7CisJCVsgQyhSRVNVTFRfQUNDRVNTKSBdID0gLTEsCisJCVsgQyhSRVNVTFRfTUlTUykgICBdID0gLTEsCisJfSwKKwlbIEMoT1BfUFJFRkVUQ0gpIF0gPSB7CisJCVsgQyhSRVNVTFRfQUNDRVNTKSBdID0gMCwKKwkJWyBDKFJFU1VMVF9NSVNTKSAgIF0gPSAwLAorCX0sCisgfSwKKyBbIEMoTEwgICkgXSA9IHsKKwlbIEMoT1BfUkVBRCkgXSA9IHsKKwkJWyBDKFJFU1VMVF9BQ0NFU1MpIF0gPSAwLAorCQlbIEMoUkVTVUxUX01JU1MpICAgXSA9IDAsCisJfSwKKwlbIEMoT1BfV1JJVEUpIF0gPSB7CisJCVsgQyhSRVNVTFRfQUNDRVNTKSBdID0gMCwKKwkJWyBDKFJFU1VMVF9NSVNTKSAgIF0gPSAwLAorCX0sCisJWyBDKE9QX1BSRUZFVENIKSBdID0geworCQlbIEMoUkVTVUxUX0FDQ0VTUykgXSA9IDAsCisJCVsgQyhSRVNVTFRfTUlTUykgICBdID0gMCwKKwl9LAorIH0sCisgWyBDKERUTEIpIF0gPSB7CisJWyBDKE9QX1JFQUQpIF0gPSB7CisJCVsgQyhSRVNVTFRfQUNDRVNTKSBdID0gMCwKKwkJWyBDKFJFU1VMVF9NSVNTKSAgIF0gPSAwLAorCX0sCisJWyBDKE9QX1dSSVRFKSBdID0geworCQlbIEMoUkVTVUxUX0FDQ0VTUykgXSA9IDAsCisJCVsgQyhSRVNVTFRfTUlTUykgICBdID0gMCwKKwl9LAorCVsgQyhPUF9QUkVGRVRDSCkgXSA9IHsKKwkJWyBDKFJFU1VMVF9BQ0NFU1MpIF0gPSAwLAorCQlbIEMoUkVTVUxUX01JU1MpICAgXSA9IDAsCisJfSwKKyB9LAorIFsgQyhJVExCKSBdID0geworCVsgQyhPUF9SRUFEKSBdID0geworCQlbIEMoUkVTVUxUX0FDQ0VTUykgXSA9IDB4MDA4MCwgLyogSW5zdHJ1Y3Rpb24gZmVjdGhlcyAgICAgICAgKi8KKwkJWyBDKFJFU1VMVF9NSVNTKSAgIF0gPSAweDAwODUsIC8qIEluc3RyLiBmZXRjaCBJVExCIG1pc3NlcyAgICovCisJfSwKKwlbIEMoT1BfV1JJVEUpIF0gPSB7CisJCVsgQyhSRVNVTFRfQUNDRVNTKSBdID0gLTEsCisJCVsgQyhSRVNVTFRfTUlTUykgICBdID0gLTEsCisJfSwKKwlbIEMoT1BfUFJFRkVUQ0gpIF0gPSB7CisJCVsgQyhSRVNVTFRfQUNDRVNTKSBdID0gLTEsCisJCVsgQyhSRVNVTFRfTUlTUykgICBdID0gLTEsCisJfSwKKyB9LAorIFsgQyhCUFUgKSBdID0geworCVsgQyhPUF9SRUFEKSBdID0geworCQlbIEMoUkVTVUxUX0FDQ0VTUykgXSA9IDB4MDBjMiwgLyogUmV0aXJlZCBCcmFuY2ggSW5zdHIuICAgICAgKi8KKwkJWyBDKFJFU1VMVF9NSVNTKSAgIF0gPSAweDAwYzMsIC8qIFJldGlyZWQgTWlzcHJlZGljdGVkIEJJICAgICovCisJfSwKKwlbIEMoT1BfV1JJVEUpIF0gPSB7CisJCVsgQyhSRVNVTFRfQUNDRVNTKSBdID0gLTEsCisJCVsgQyhSRVNVTFRfTUlTUykgICBdID0gLTEsCisJfSwKKwlbIEMoT1BfUFJFRkVUQ0gpIF0gPSB7CisJCVsgQyhSRVNVTFRfQUNDRVNTKSBdID0gLTEsCisJCVsgQyhSRVNVTFRfTUlTUykgICBdID0gLTEsCisJfSwKKyB9LAorfTsKKworLyoKKyAqIEFNRCBQZXJmb3JtYW5jZSBNb25pdG9yIEs3IGFuZCBsYXRlci4KKyAqLworc3RhdGljIGNvbnN0IHU2NCBhbWRfcGVyZm1vbl9ldmVudF9tYXBbXSA9Cit7CisgIFtQRVJGX0NPVU5UX0hXX0NQVV9DWUNMRVNdCQk9IDB4MDA3NiwKKyAgW1BFUkZfQ09VTlRfSFdfSU5TVFJVQ1RJT05TXQkJPSAweDAwYzAsCisgIFtQRVJGX0NPVU5UX0hXX0NBQ0hFX1JFRkVSRU5DRVNdCT0gMHgwMDgwLAorICBbUEVSRl9DT1VOVF9IV19DQUNIRV9NSVNTRVNdCQk9IDB4MDA4MSwKKyAgW1BFUkZfQ09VTlRfSFdfQlJBTkNIX0lOU1RSVUNUSU9OU10JPSAweDAwYzQsCisgIFtQRVJGX0NPVU5UX0hXX0JSQU5DSF9NSVNTRVNdCQk9IDB4MDBjNSwKK307CisKK3N0YXRpYyB1NjQgYW1kX3BtdV9ldmVudF9tYXAoaW50IGV2ZW50KQoreworCXJldHVybiBhbWRfcGVyZm1vbl9ldmVudF9tYXBbZXZlbnRdOworfQorCitzdGF0aWMgdTY0IGFtZF9wbXVfcmF3X2V2ZW50KHU2NCBldmVudCkKK3sKKyNkZWZpbmUgSzdfRVZOVFNFTF9FVkVOVF9NQVNLCTB4NzAwMDAwMEZGVUxMCisjZGVmaW5lIEs3X0VWTlRTRUxfVU5JVF9NQVNLCTB4MDAwMDBGRjAwVUxMCisjZGVmaW5lIEs3X0VWTlRTRUxfRURHRV9NQVNLCTB4MDAwMDQwMDAwVUxMCisjZGVmaW5lIEs3X0VWTlRTRUxfSU5WX01BU0sJMHgwMDA4MDAwMDBVTEwKKyNkZWZpbmUgSzdfRVZOVFNFTF9DT1VOVEVSX01BU0sJMHgwRkYwMDAwMDBVTEwKKworI2RlZmluZSBLN19FVk5UU0VMX01BU0sJCQlcCisJKEs3X0VWTlRTRUxfRVZFTlRfTUFTSyB8CVwKKwkgSzdfRVZOVFNFTF9VTklUX01BU0sgIHwJXAorCSBLN19FVk5UU0VMX0VER0VfTUFTSyAgfAlcCisJIEs3X0VWTlRTRUxfSU5WX01BU0sgICB8CVwKKwkgSzdfRVZOVFNFTF9DT1VOVEVSX01BU0spCisKKwlyZXR1cm4gZXZlbnQgJiBLN19FVk5UU0VMX01BU0s7Cit9CisKKy8qCisgKiBQcm9wYWdhdGUgY291bnRlciBlbGFwc2VkIHRpbWUgaW50byB0aGUgZ2VuZXJpYyBjb3VudGVyLgorICogQ2FuIG9ubHkgYmUgZXhlY3V0ZWQgb24gdGhlIENQVSB3aGVyZSB0aGUgY291bnRlciBpcyBhY3RpdmUuCisgKiBSZXR1cm5zIHRoZSBkZWx0YSBldmVudHMgcHJvY2Vzc2VkLgorICovCitzdGF0aWMgdTY0Cit4ODZfcGVyZl9jb3VudGVyX3VwZGF0ZShzdHJ1Y3QgcGVyZl9jb3VudGVyICpjb3VudGVyLAorCQkJc3RydWN0IGh3X3BlcmZfY291bnRlciAqaHdjLCBpbnQgaWR4KQoreworCWludCBzaGlmdCA9IDY0IC0geDg2X3BtdS5jb3VudGVyX2JpdHM7CisJdTY0IHByZXZfcmF3X2NvdW50LCBuZXdfcmF3X2NvdW50OworCXM2NCBkZWx0YTsKKworCS8qCisJICogQ2FyZWZ1bDogYW4gTk1JIG1pZ2h0IG1vZGlmeSB0aGUgcHJldmlvdXMgY291bnRlciB2YWx1ZS4KKwkgKgorCSAqIE91ciB0YWN0aWMgdG8gaGFuZGxlIHRoaXMgaXMgdG8gZmlyc3QgYXRvbWljYWxseSByZWFkIGFuZAorCSAqIGV4Y2hhbmdlIGEgbmV3IHJhdyBjb3VudCAtIHRoZW4gYWRkIHRoYXQgbmV3LXByZXYgZGVsdGEKKwkgKiBjb3VudCB0byB0aGUgZ2VuZXJpYyBjb3VudGVyIGF0b21pY2FsbHk6CisJICovCithZ2FpbjoKKwlwcmV2X3Jhd19jb3VudCA9IGF0b21pYzY0X3JlYWQoJmh3Yy0+cHJldl9jb3VudCk7CisJcmRtc3JsKGh3Yy0+Y291bnRlcl9iYXNlICsgaWR4LCBuZXdfcmF3X2NvdW50KTsKKworCWlmIChhdG9taWM2NF9jbXB4Y2hnKCZod2MtPnByZXZfY291bnQsIHByZXZfcmF3X2NvdW50LAorCQkJCQluZXdfcmF3X2NvdW50KSAhPSBwcmV2X3Jhd19jb3VudCkKKwkJZ290byBhZ2FpbjsKKworCS8qCisJICogTm93IHdlIGhhdmUgdGhlIG5ldyByYXcgdmFsdWUgYW5kIGhhdmUgdXBkYXRlZCB0aGUgcHJldgorCSAqIHRpbWVzdGFtcCBhbHJlYWR5LiBXZSBjYW4gbm93IGNhbGN1bGF0ZSB0aGUgZWxhcHNlZCBkZWx0YQorCSAqIChjb3VudGVyLSl0aW1lIGFuZCBhZGQgdGhhdCB0byB0aGUgZ2VuZXJpYyBjb3VudGVyLgorCSAqCisJICogQ2FyZWZ1bCwgbm90IGFsbCBodyBzaWduLWV4dGVuZHMgYWJvdmUgdGhlIHBoeXNpY2FsIHdpZHRoCisJICogb2YgdGhlIGNvdW50LgorCSAqLworCWRlbHRhID0gKG5ld19yYXdfY291bnQgPDwgc2hpZnQpIC0gKHByZXZfcmF3X2NvdW50IDw8IHNoaWZ0KTsKKwlkZWx0YSA+Pj0gc2hpZnQ7CisKKwlhdG9taWM2NF9hZGQoZGVsdGEsICZjb3VudGVyLT5jb3VudCk7CisJYXRvbWljNjRfc3ViKGRlbHRhLCAmaHdjLT5wZXJpb2RfbGVmdCk7CisKKwlyZXR1cm4gbmV3X3Jhd19jb3VudDsKK30KKworc3RhdGljIGF0b21pY190IGFjdGl2ZV9jb3VudGVyczsKK3N0YXRpYyBERUZJTkVfTVVURVgocG1jX3Jlc2VydmVfbXV0ZXgpOworCitzdGF0aWMgYm9vbCByZXNlcnZlX3BtY19oYXJkd2FyZSh2b2lkKQoreworCWludCBpOworCisJaWYgKG5taV93YXRjaGRvZyA9PSBOTUlfTE9DQUxfQVBJQykKKwkJZGlzYWJsZV9sYXBpY19ubWlfd2F0Y2hkb2coKTsKKworCWZvciAoaSA9IDA7IGkgPCB4ODZfcG11Lm51bV9jb3VudGVyczsgaSsrKSB7CisJCWlmICghcmVzZXJ2ZV9wZXJmY3RyX25taSh4ODZfcG11LnBlcmZjdHIgKyBpKSkKKwkJCWdvdG8gcGVyZmN0cl9mYWlsOworCX0KKworCWZvciAoaSA9IDA7IGkgPCB4ODZfcG11Lm51bV9jb3VudGVyczsgaSsrKSB7CisJCWlmICghcmVzZXJ2ZV9ldm50c2VsX25taSh4ODZfcG11LmV2ZW50c2VsICsgaSkpCisJCQlnb3RvIGV2ZW50c2VsX2ZhaWw7CisJfQorCisJcmV0dXJuIHRydWU7CisKK2V2ZW50c2VsX2ZhaWw6CisJZm9yIChpLS07IGkgPj0gMDsgaS0tKQorCQlyZWxlYXNlX2V2bnRzZWxfbm1pKHg4Nl9wbXUuZXZlbnRzZWwgKyBpKTsKKworCWkgPSB4ODZfcG11Lm51bV9jb3VudGVyczsKKworcGVyZmN0cl9mYWlsOgorCWZvciAoaS0tOyBpID49IDA7IGktLSkKKwkJcmVsZWFzZV9wZXJmY3RyX25taSh4ODZfcG11LnBlcmZjdHIgKyBpKTsKKworCWlmIChubWlfd2F0Y2hkb2cgPT0gTk1JX0xPQ0FMX0FQSUMpCisJCWVuYWJsZV9sYXBpY19ubWlfd2F0Y2hkb2coKTsKKworCXJldHVybiBmYWxzZTsKK30KKworc3RhdGljIHZvaWQgcmVsZWFzZV9wbWNfaGFyZHdhcmUodm9pZCkKK3sKKwlpbnQgaTsKKworCWZvciAoaSA9IDA7IGkgPCB4ODZfcG11Lm51bV9jb3VudGVyczsgaSsrKSB7CisJCXJlbGVhc2VfcGVyZmN0cl9ubWkoeDg2X3BtdS5wZXJmY3RyICsgaSk7CisJCXJlbGVhc2VfZXZudHNlbF9ubWkoeDg2X3BtdS5ldmVudHNlbCArIGkpOworCX0KKworCWlmIChubWlfd2F0Y2hkb2cgPT0gTk1JX0xPQ0FMX0FQSUMpCisJCWVuYWJsZV9sYXBpY19ubWlfd2F0Y2hkb2coKTsKK30KKworc3RhdGljIHZvaWQgaHdfcGVyZl9jb3VudGVyX2Rlc3Ryb3koc3RydWN0IHBlcmZfY291bnRlciAqY291bnRlcikKK3sKKwlpZiAoYXRvbWljX2RlY19hbmRfbXV0ZXhfbG9jaygmYWN0aXZlX2NvdW50ZXJzLCAmcG1jX3Jlc2VydmVfbXV0ZXgpKSB7CisJCXJlbGVhc2VfcG1jX2hhcmR3YXJlKCk7CisJCW11dGV4X3VubG9jaygmcG1jX3Jlc2VydmVfbXV0ZXgpOworCX0KK30KKworc3RhdGljIGlubGluZSBpbnQgeDg2X3BtdV9pbml0aWFsaXplZCh2b2lkKQoreworCXJldHVybiB4ODZfcG11LmhhbmRsZV9pcnEgIT0gTlVMTDsKK30KKworc3RhdGljIGlubGluZSBpbnQKK3NldF9leHRfaHdfYXR0cihzdHJ1Y3QgaHdfcGVyZl9jb3VudGVyICpod2MsIHN0cnVjdCBwZXJmX2NvdW50ZXJfYXR0ciAqYXR0cikKK3sKKwl1bnNpZ25lZCBpbnQgY2FjaGVfdHlwZSwgY2FjaGVfb3AsIGNhY2hlX3Jlc3VsdDsKKwl1NjQgY29uZmlnLCB2YWw7CisKKwljb25maWcgPSBhdHRyLT5jb25maWc7CisKKwljYWNoZV90eXBlID0gKGNvbmZpZyA+PiAgMCkgJiAweGZmOworCWlmIChjYWNoZV90eXBlID49IFBFUkZfQ09VTlRfSFdfQ0FDSEVfTUFYKQorCQlyZXR1cm4gLUVJTlZBTDsKKworCWNhY2hlX29wID0gKGNvbmZpZyA+PiAgOCkgJiAweGZmOworCWlmIChjYWNoZV9vcCA+PSBQRVJGX0NPVU5UX0hXX0NBQ0hFX09QX01BWCkKKwkJcmV0dXJuIC1FSU5WQUw7CisKKwljYWNoZV9yZXN1bHQgPSAoY29uZmlnID4+IDE2KSAmIDB4ZmY7CisJaWYgKGNhY2hlX3Jlc3VsdCA+PSBQRVJGX0NPVU5UX0hXX0NBQ0hFX1JFU1VMVF9NQVgpCisJCXJldHVybiAtRUlOVkFMOworCisJdmFsID0gaHdfY2FjaGVfZXZlbnRfaWRzW2NhY2hlX3R5cGVdW2NhY2hlX29wXVtjYWNoZV9yZXN1bHRdOworCisJaWYgKHZhbCA9PSAwKQorCQlyZXR1cm4gLUVOT0VOVDsKKworCWlmICh2YWwgPT0gLTEpCisJCXJldHVybiAtRUlOVkFMOworCisJaHdjLT5jb25maWcgfD0gdmFsOworCisJcmV0dXJuIDA7Cit9CisKKy8qCisgKiBTZXR1cCB0aGUgaGFyZHdhcmUgY29uZmlndXJhdGlvbiBmb3IgYSBnaXZlbiBhdHRyX3R5cGUKKyAqLworc3RhdGljIGludCBfX2h3X3BlcmZfY291bnRlcl9pbml0KHN0cnVjdCBwZXJmX2NvdW50ZXIgKmNvdW50ZXIpCit7CisJc3RydWN0IHBlcmZfY291bnRlcl9hdHRyICphdHRyID0gJmNvdW50ZXItPmF0dHI7CisJc3RydWN0IGh3X3BlcmZfY291bnRlciAqaHdjID0gJmNvdW50ZXItPmh3OworCWludCBlcnI7CisKKwlpZiAoIXg4Nl9wbXVfaW5pdGlhbGl6ZWQoKSkKKwkJcmV0dXJuIC1FTk9ERVY7CisKKwllcnIgPSAwOworCWlmICghYXRvbWljX2luY19ub3RfemVybygmYWN0aXZlX2NvdW50ZXJzKSkgeworCQltdXRleF9sb2NrKCZwbWNfcmVzZXJ2ZV9tdXRleCk7CisJCWlmIChhdG9taWNfcmVhZCgmYWN0aXZlX2NvdW50ZXJzKSA9PSAwICYmICFyZXNlcnZlX3BtY19oYXJkd2FyZSgpKQorCQkJZXJyID0gLUVCVVNZOworCQllbHNlCisJCQlhdG9taWNfaW5jKCZhY3RpdmVfY291bnRlcnMpOworCQltdXRleF91bmxvY2soJnBtY19yZXNlcnZlX211dGV4KTsKKwl9CisJaWYgKGVycikKKwkJcmV0dXJuIGVycjsKKworCS8qCisJICogR2VuZXJhdGUgUE1DIElSUXM6CisJICogKGtlZXAgJ2VuYWJsZWQnIGJpdCBjbGVhciBmb3Igbm93KQorCSAqLworCWh3Yy0+Y29uZmlnID0gQVJDSF9QRVJGTU9OX0VWRU5UU0VMX0lOVDsKKworCS8qCisJICogQ291bnQgdXNlciBhbmQgT1MgZXZlbnRzIHVubGVzcyByZXF1ZXN0ZWQgbm90IHRvLgorCSAqLworCWlmICghYXR0ci0+ZXhjbHVkZV91c2VyKQorCQlod2MtPmNvbmZpZyB8PSBBUkNIX1BFUkZNT05fRVZFTlRTRUxfVVNSOworCWlmICghYXR0ci0+ZXhjbHVkZV9rZXJuZWwpCisJCWh3Yy0+Y29uZmlnIHw9IEFSQ0hfUEVSRk1PTl9FVkVOVFNFTF9PUzsKKworCWlmICghaHdjLT5zYW1wbGVfcGVyaW9kKSB7CisJCWh3Yy0+c2FtcGxlX3BlcmlvZCA9IHg4Nl9wbXUubWF4X3BlcmlvZDsKKwkJaHdjLT5sYXN0X3BlcmlvZCA9IGh3Yy0+c2FtcGxlX3BlcmlvZDsKKwkJYXRvbWljNjRfc2V0KCZod2MtPnBlcmlvZF9sZWZ0LCBod2MtPnNhbXBsZV9wZXJpb2QpOworCX0KKworCWNvdW50ZXItPmRlc3Ryb3kgPSBod19wZXJmX2NvdW50ZXJfZGVzdHJveTsKKworCS8qCisJICogUmF3IGV2ZW50IHR5cGUgcHJvdmlkZSB0aGUgY29uZmlnIGluIHRoZSBldmVudCBzdHJ1Y3R1cmUKKwkgKi8KKwlpZiAoYXR0ci0+dHlwZSA9PSBQRVJGX1RZUEVfUkFXKSB7CisJCWh3Yy0+Y29uZmlnIHw9IHg4Nl9wbXUucmF3X2V2ZW50KGF0dHItPmNvbmZpZyk7CisJCXJldHVybiAwOworCX0KKworCWlmIChhdHRyLT50eXBlID09IFBFUkZfVFlQRV9IV19DQUNIRSkKKwkJcmV0dXJuIHNldF9leHRfaHdfYXR0cihod2MsIGF0dHIpOworCisJaWYgKGF0dHItPmNvbmZpZyA+PSB4ODZfcG11Lm1heF9ldmVudHMpCisJCXJldHVybiAtRUlOVkFMOworCS8qCisJICogVGhlIGdlbmVyaWMgbWFwOgorCSAqLworCWh3Yy0+Y29uZmlnIHw9IHg4Nl9wbXUuZXZlbnRfbWFwKGF0dHItPmNvbmZpZyk7CisKKwlyZXR1cm4gMDsKK30KKworc3RhdGljIHZvaWQgaW50ZWxfcG11X2Rpc2FibGVfYWxsKHZvaWQpCit7CisJd3Jtc3JsKE1TUl9DT1JFX1BFUkZfR0xPQkFMX0NUUkwsIDApOworfQorCitzdGF0aWMgdm9pZCBhbWRfcG11X2Rpc2FibGVfYWxsKHZvaWQpCit7CisJc3RydWN0IGNwdV9od19jb3VudGVycyAqY3B1YyA9ICZfX2dldF9jcHVfdmFyKGNwdV9od19jb3VudGVycyk7CisJaW50IGlkeDsKKworCWlmICghY3B1Yy0+ZW5hYmxlZCkKKwkJcmV0dXJuOworCisJY3B1Yy0+ZW5hYmxlZCA9IDA7CisJLyoKKwkgKiBlbnN1cmUgd2Ugd3JpdGUgdGhlIGRpc2FibGUgYmVmb3JlIHdlIHN0YXJ0IGRpc2FibGluZyB0aGUKKwkgKiBjb3VudGVycyBwcm9wZXIsIHNvIHRoYXQgYW1kX3BtdV9lbmFibGVfY291bnRlcigpIGRvZXMgdGhlCisJICogcmlnaHQgdGhpbmcuCisJICovCisJYmFycmllcigpOworCisJZm9yIChpZHggPSAwOyBpZHggPCB4ODZfcG11Lm51bV9jb3VudGVyczsgaWR4KyspIHsKKwkJdTY0IHZhbDsKKworCQlpZiAoIXRlc3RfYml0KGlkeCwgY3B1Yy0+YWN0aXZlX21hc2spKQorCQkJY29udGludWU7CisJCXJkbXNybChNU1JfSzdfRVZOVFNFTDAgKyBpZHgsIHZhbCk7CisJCWlmICghKHZhbCAmIEFSQ0hfUEVSRk1PTl9FVkVOVFNFTDBfRU5BQkxFKSkKKwkJCWNvbnRpbnVlOworCQl2YWwgJj0gfkFSQ0hfUEVSRk1PTl9FVkVOVFNFTDBfRU5BQkxFOworCQl3cm1zcmwoTVNSX0s3X0VWTlRTRUwwICsgaWR4LCB2YWwpOworCX0KK30KKwordm9pZCBod19wZXJmX2Rpc2FibGUodm9pZCkKK3sKKwlpZiAoIXg4Nl9wbXVfaW5pdGlhbGl6ZWQoKSkKKwkJcmV0dXJuOworCXJldHVybiB4ODZfcG11LmRpc2FibGVfYWxsKCk7Cit9CisKK3N0YXRpYyB2b2lkIGludGVsX3BtdV9lbmFibGVfYWxsKHZvaWQpCit7CisJd3Jtc3JsKE1TUl9DT1JFX1BFUkZfR0xPQkFMX0NUUkwsIHg4Nl9wbXUuaW50ZWxfY3RybCk7Cit9CisKK3N0YXRpYyB2b2lkIGFtZF9wbXVfZW5hYmxlX2FsbCh2b2lkKQoreworCXN0cnVjdCBjcHVfaHdfY291bnRlcnMgKmNwdWMgPSAmX19nZXRfY3B1X3ZhcihjcHVfaHdfY291bnRlcnMpOworCWludCBpZHg7CisKKwlpZiAoY3B1Yy0+ZW5hYmxlZCkKKwkJcmV0dXJuOworCisJY3B1Yy0+ZW5hYmxlZCA9IDE7CisJYmFycmllcigpOworCisJZm9yIChpZHggPSAwOyBpZHggPCB4ODZfcG11Lm51bV9jb3VudGVyczsgaWR4KyspIHsKKwkJdTY0IHZhbDsKKworCQlpZiAoIXRlc3RfYml0KGlkeCwgY3B1Yy0+YWN0aXZlX21hc2spKQorCQkJY29udGludWU7CisJCXJkbXNybChNU1JfSzdfRVZOVFNFTDAgKyBpZHgsIHZhbCk7CisJCWlmICh2YWwgJiBBUkNIX1BFUkZNT05fRVZFTlRTRUwwX0VOQUJMRSkKKwkJCWNvbnRpbnVlOworCQl2YWwgfD0gQVJDSF9QRVJGTU9OX0VWRU5UU0VMMF9FTkFCTEU7CisJCXdybXNybChNU1JfSzdfRVZOVFNFTDAgKyBpZHgsIHZhbCk7CisJfQorfQorCit2b2lkIGh3X3BlcmZfZW5hYmxlKHZvaWQpCit7CisJaWYgKCF4ODZfcG11X2luaXRpYWxpemVkKCkpCisJCXJldHVybjsKKwl4ODZfcG11LmVuYWJsZV9hbGwoKTsKK30KKworc3RhdGljIGlubGluZSB1NjQgaW50ZWxfcG11X2dldF9zdGF0dXModm9pZCkKK3sKKwl1NjQgc3RhdHVzOworCisJcmRtc3JsKE1TUl9DT1JFX1BFUkZfR0xPQkFMX1NUQVRVUywgc3RhdHVzKTsKKworCXJldHVybiBzdGF0dXM7Cit9CisKK3N0YXRpYyBpbmxpbmUgdm9pZCBpbnRlbF9wbXVfYWNrX3N0YXR1cyh1NjQgYWNrKQoreworCXdybXNybChNU1JfQ09SRV9QRVJGX0dMT0JBTF9PVkZfQ1RSTCwgYWNrKTsKK30KKworc3RhdGljIGlubGluZSB2b2lkIHg4Nl9wbXVfZW5hYmxlX2NvdW50ZXIoc3RydWN0IGh3X3BlcmZfY291bnRlciAqaHdjLCBpbnQgaWR4KQoreworCWludCBlcnI7CisJZXJyID0gY2hlY2tpbmdfd3Jtc3JsKGh3Yy0+Y29uZmlnX2Jhc2UgKyBpZHgsCisJCQkgICAgICBod2MtPmNvbmZpZyB8IEFSQ0hfUEVSRk1PTl9FVkVOVFNFTDBfRU5BQkxFKTsKK30KKworc3RhdGljIGlubGluZSB2b2lkIHg4Nl9wbXVfZGlzYWJsZV9jb3VudGVyKHN0cnVjdCBod19wZXJmX2NvdW50ZXIgKmh3YywgaW50IGlkeCkKK3sKKwlpbnQgZXJyOworCWVyciA9IGNoZWNraW5nX3dybXNybChod2MtPmNvbmZpZ19iYXNlICsgaWR4LAorCQkJICAgICAgaHdjLT5jb25maWcpOworfQorCitzdGF0aWMgaW5saW5lIHZvaWQKK2ludGVsX3BtdV9kaXNhYmxlX2ZpeGVkKHN0cnVjdCBod19wZXJmX2NvdW50ZXIgKmh3YywgaW50IF9faWR4KQoreworCWludCBpZHggPSBfX2lkeCAtIFg4Nl9QTUNfSURYX0ZJWEVEOworCXU2NCBjdHJsX3ZhbCwgbWFzazsKKwlpbnQgZXJyOworCisJbWFzayA9IDB4ZlVMTCA8PCAoaWR4ICogNCk7CisKKwlyZG1zcmwoaHdjLT5jb25maWdfYmFzZSwgY3RybF92YWwpOworCWN0cmxfdmFsICY9IH5tYXNrOworCWVyciA9IGNoZWNraW5nX3dybXNybChod2MtPmNvbmZpZ19iYXNlLCBjdHJsX3ZhbCk7Cit9CisKK3N0YXRpYyBpbmxpbmUgdm9pZAoraW50ZWxfcG11X2Rpc2FibGVfY291bnRlcihzdHJ1Y3QgaHdfcGVyZl9jb3VudGVyICpod2MsIGludCBpZHgpCit7CisJaWYgKHVubGlrZWx5KGh3Yy0+Y29uZmlnX2Jhc2UgPT0gTVNSX0FSQ0hfUEVSRk1PTl9GSVhFRF9DVFJfQ1RSTCkpIHsKKwkJaW50ZWxfcG11X2Rpc2FibGVfZml4ZWQoaHdjLCBpZHgpOworCQlyZXR1cm47CisJfQorCisJeDg2X3BtdV9kaXNhYmxlX2NvdW50ZXIoaHdjLCBpZHgpOworfQorCitzdGF0aWMgaW5saW5lIHZvaWQKK2FtZF9wbXVfZGlzYWJsZV9jb3VudGVyKHN0cnVjdCBod19wZXJmX2NvdW50ZXIgKmh3YywgaW50IGlkeCkKK3sKKwl4ODZfcG11X2Rpc2FibGVfY291bnRlcihod2MsIGlkeCk7Cit9CisKK3N0YXRpYyBERUZJTkVfUEVSX0NQVSh1NjQsIHByZXZfbGVmdFtYODZfUE1DX0lEWF9NQVhdKTsKKworLyoKKyAqIFNldCB0aGUgbmV4dCBJUlEgcGVyaW9kLCBiYXNlZCBvbiB0aGUgaHdjLT5wZXJpb2RfbGVmdCB2YWx1ZS4KKyAqIFRvIGJlIGNhbGxlZCB3aXRoIHRoZSBjb3VudGVyIGRpc2FibGVkIGluIGh3OgorICovCitzdGF0aWMgaW50Cit4ODZfcGVyZl9jb3VudGVyX3NldF9wZXJpb2Qoc3RydWN0IHBlcmZfY291bnRlciAqY291bnRlciwKKwkJCSAgICAgc3RydWN0IGh3X3BlcmZfY291bnRlciAqaHdjLCBpbnQgaWR4KQoreworCXM2NCBsZWZ0ID0gYXRvbWljNjRfcmVhZCgmaHdjLT5wZXJpb2RfbGVmdCk7CisJczY0IHBlcmlvZCA9IGh3Yy0+c2FtcGxlX3BlcmlvZDsKKwlpbnQgZXJyLCByZXQgPSAwOworCisJLyoKKwkgKiBJZiB3ZSBhcmUgd2F5IG91dHNpZGUgYSByZWFzb2FibGUgcmFuZ2UgdGhlbiBqdXN0IHNraXAgZm9yd2FyZDoKKwkgKi8KKwlpZiAodW5saWtlbHkobGVmdCA8PSAtcGVyaW9kKSkgeworCQlsZWZ0ID0gcGVyaW9kOworCQlhdG9taWM2NF9zZXQoJmh3Yy0+cGVyaW9kX2xlZnQsIGxlZnQpOworCQlod2MtPmxhc3RfcGVyaW9kID0gcGVyaW9kOworCQlyZXQgPSAxOworCX0KKworCWlmICh1bmxpa2VseShsZWZ0IDw9IDApKSB7CisJCWxlZnQgKz0gcGVyaW9kOworCQlhdG9taWM2NF9zZXQoJmh3Yy0+cGVyaW9kX2xlZnQsIGxlZnQpOworCQlod2MtPmxhc3RfcGVyaW9kID0gcGVyaW9kOworCQlyZXQgPSAxOworCX0KKwkvKgorCSAqIFF1aXJrOiBjZXJ0YWluIENQVXMgZG9udCBsaWtlIGl0IGlmIGp1c3QgMSBldmVudCBpcyBsZWZ0OgorCSAqLworCWlmICh1bmxpa2VseShsZWZ0IDwgMikpCisJCWxlZnQgPSAyOworCisJaWYgKGxlZnQgPiB4ODZfcG11Lm1heF9wZXJpb2QpCisJCWxlZnQgPSB4ODZfcG11Lm1heF9wZXJpb2Q7CisKKwlwZXJfY3B1KHByZXZfbGVmdFtpZHhdLCBzbXBfcHJvY2Vzc29yX2lkKCkpID0gbGVmdDsKKworCS8qCisJICogVGhlIGh3IGNvdW50ZXIgc3RhcnRzIGNvdW50aW5nIGZyb20gdGhpcyBjb3VudGVyIG9mZnNldCwKKwkgKiBtYXJrIGl0IHRvIGJlIGFibGUgdG8gZXh0cmEgZnV0dXJlIGRlbHRhczoKKwkgKi8KKwlhdG9taWM2NF9zZXQoJmh3Yy0+cHJldl9jb3VudCwgKHU2NCktbGVmdCk7CisKKwllcnIgPSBjaGVja2luZ193cm1zcmwoaHdjLT5jb3VudGVyX2Jhc2UgKyBpZHgsCisJCQkgICAgICh1NjQpKC1sZWZ0KSAmIHg4Nl9wbXUuY291bnRlcl9tYXNrKTsKKworCXJldHVybiByZXQ7Cit9CisKK3N0YXRpYyBpbmxpbmUgdm9pZAoraW50ZWxfcG11X2VuYWJsZV9maXhlZChzdHJ1Y3QgaHdfcGVyZl9jb3VudGVyICpod2MsIGludCBfX2lkeCkKK3sKKwlpbnQgaWR4ID0gX19pZHggLSBYODZfUE1DX0lEWF9GSVhFRDsKKwl1NjQgY3RybF92YWwsIGJpdHMsIG1hc2s7CisJaW50IGVycjsKKworCS8qCisJICogRW5hYmxlIElSUSBnZW5lcmF0aW9uICgweDgpLAorCSAqIGFuZCBlbmFibGUgcmluZy0zIGNvdW50aW5nICgweDIpIGFuZCByaW5nLTAgY291bnRpbmcgKDB4MSkKKwkgKiBpZiByZXF1ZXN0ZWQ6CisJICovCisJYml0cyA9IDB4OFVMTDsKKwlpZiAoaHdjLT5jb25maWcgJiBBUkNIX1BFUkZNT05fRVZFTlRTRUxfVVNSKQorCQliaXRzIHw9IDB4MjsKKwlpZiAoaHdjLT5jb25maWcgJiBBUkNIX1BFUkZNT05fRVZFTlRTRUxfT1MpCisJCWJpdHMgfD0gMHgxOworCWJpdHMgPDw9IChpZHggKiA0KTsKKwltYXNrID0gMHhmVUxMIDw8IChpZHggKiA0KTsKKworCXJkbXNybChod2MtPmNvbmZpZ19iYXNlLCBjdHJsX3ZhbCk7CisJY3RybF92YWwgJj0gfm1hc2s7CisJY3RybF92YWwgfD0gYml0czsKKwllcnIgPSBjaGVja2luZ193cm1zcmwoaHdjLT5jb25maWdfYmFzZSwgY3RybF92YWwpOworfQorCitzdGF0aWMgdm9pZCBpbnRlbF9wbXVfZW5hYmxlX2NvdW50ZXIoc3RydWN0IGh3X3BlcmZfY291bnRlciAqaHdjLCBpbnQgaWR4KQoreworCWlmICh1bmxpa2VseShod2MtPmNvbmZpZ19iYXNlID09IE1TUl9BUkNIX1BFUkZNT05fRklYRURfQ1RSX0NUUkwpKSB7CisJCWludGVsX3BtdV9lbmFibGVfZml4ZWQoaHdjLCBpZHgpOworCQlyZXR1cm47CisJfQorCisJeDg2X3BtdV9lbmFibGVfY291bnRlcihod2MsIGlkeCk7Cit9CisKK3N0YXRpYyB2b2lkIGFtZF9wbXVfZW5hYmxlX2NvdW50ZXIoc3RydWN0IGh3X3BlcmZfY291bnRlciAqaHdjLCBpbnQgaWR4KQoreworCXN0cnVjdCBjcHVfaHdfY291bnRlcnMgKmNwdWMgPSAmX19nZXRfY3B1X3ZhcihjcHVfaHdfY291bnRlcnMpOworCisJaWYgKGNwdWMtPmVuYWJsZWQpCisJCXg4Nl9wbXVfZW5hYmxlX2NvdW50ZXIoaHdjLCBpZHgpOworCWVsc2UKKwkJeDg2X3BtdV9kaXNhYmxlX2NvdW50ZXIoaHdjLCBpZHgpOworfQorCitzdGF0aWMgaW50CitmaXhlZF9tb2RlX2lkeChzdHJ1Y3QgcGVyZl9jb3VudGVyICpjb3VudGVyLCBzdHJ1Y3QgaHdfcGVyZl9jb3VudGVyICpod2MpCit7CisJdW5zaWduZWQgaW50IGV2ZW50OworCisJaWYgKCF4ODZfcG11Lm51bV9jb3VudGVyc19maXhlZCkKKwkJcmV0dXJuIC0xOworCisJZXZlbnQgPSBod2MtPmNvbmZpZyAmIEFSQ0hfUEVSRk1PTl9FVkVOVF9NQVNLOworCisJaWYgKHVubGlrZWx5KGV2ZW50ID09IHg4Nl9wbXUuZXZlbnRfbWFwKFBFUkZfQ09VTlRfSFdfSU5TVFJVQ1RJT05TKSkpCisJCXJldHVybiBYODZfUE1DX0lEWF9GSVhFRF9JTlNUUlVDVElPTlM7CisJaWYgKHVubGlrZWx5KGV2ZW50ID09IHg4Nl9wbXUuZXZlbnRfbWFwKFBFUkZfQ09VTlRfSFdfQ1BVX0NZQ0xFUykpKQorCQlyZXR1cm4gWDg2X1BNQ19JRFhfRklYRURfQ1BVX0NZQ0xFUzsKKwlpZiAodW5saWtlbHkoZXZlbnQgPT0geDg2X3BtdS5ldmVudF9tYXAoUEVSRl9DT1VOVF9IV19CVVNfQ1lDTEVTKSkpCisJCXJldHVybiBYODZfUE1DX0lEWF9GSVhFRF9CVVNfQ1lDTEVTOworCisJcmV0dXJuIC0xOworfQorCisvKgorICogRmluZCBhIFBNQyBzbG90IGZvciB0aGUgZnJlc2hseSBlbmFibGVkIC8gc2NoZWR1bGVkIGluIGNvdW50ZXI6CisgKi8KK3N0YXRpYyBpbnQgeDg2X3BtdV9lbmFibGUoc3RydWN0IHBlcmZfY291bnRlciAqY291bnRlcikKK3sKKwlzdHJ1Y3QgY3B1X2h3X2NvdW50ZXJzICpjcHVjID0gJl9fZ2V0X2NwdV92YXIoY3B1X2h3X2NvdW50ZXJzKTsKKwlzdHJ1Y3QgaHdfcGVyZl9jb3VudGVyICpod2MgPSAmY291bnRlci0+aHc7CisJaW50IGlkeDsKKworCWlkeCA9IGZpeGVkX21vZGVfaWR4KGNvdW50ZXIsIGh3Yyk7CisJaWYgKGlkeCA+PSAwKSB7CisJCS8qCisJCSAqIFRyeSB0byBnZXQgdGhlIGZpeGVkIGNvdW50ZXIsIGlmIHRoYXQgaXMgYWxyZWFkeSB0YWtlbgorCQkgKiB0aGVuIHRyeSB0byBnZXQgYSBnZW5lcmljIGNvdW50ZXI6CisJCSAqLworCQlpZiAodGVzdF9hbmRfc2V0X2JpdChpZHgsIGNwdWMtPnVzZWRfbWFzaykpCisJCQlnb3RvIHRyeV9nZW5lcmljOworCisJCWh3Yy0+Y29uZmlnX2Jhc2UgPSBNU1JfQVJDSF9QRVJGTU9OX0ZJWEVEX0NUUl9DVFJMOworCQkvKgorCQkgKiBXZSBzZXQgaXQgc28gdGhhdCBjb3VudGVyX2Jhc2UgKyBpZHggaW4gd3Jtc3IvcmRtc3IgbWFwcyB0bworCQkgKiBNU1JfQVJDSF9QRVJGTU9OX0ZJWEVEX0NUUjAgLi4uIENUUjI6CisJCSAqLworCQlod2MtPmNvdW50ZXJfYmFzZSA9CisJCQlNU1JfQVJDSF9QRVJGTU9OX0ZJWEVEX0NUUjAgLSBYODZfUE1DX0lEWF9GSVhFRDsKKwkJaHdjLT5pZHggPSBpZHg7CisJfSBlbHNlIHsKKwkJaWR4ID0gaHdjLT5pZHg7CisJCS8qIFRyeSB0byBnZXQgdGhlIHByZXZpb3VzIGdlbmVyaWMgY291bnRlciBhZ2FpbiAqLworCQlpZiAodGVzdF9hbmRfc2V0X2JpdChpZHgsIGNwdWMtPnVzZWRfbWFzaykpIHsKK3RyeV9nZW5lcmljOgorCQkJaWR4ID0gZmluZF9maXJzdF96ZXJvX2JpdChjcHVjLT51c2VkX21hc2ssCisJCQkJCQkgIHg4Nl9wbXUubnVtX2NvdW50ZXJzKTsKKwkJCWlmIChpZHggPT0geDg2X3BtdS5udW1fY291bnRlcnMpCisJCQkJcmV0dXJuIC1FQUdBSU47CisKKwkJCXNldF9iaXQoaWR4LCBjcHVjLT51c2VkX21hc2spOworCQkJaHdjLT5pZHggPSBpZHg7CisJCX0KKwkJaHdjLT5jb25maWdfYmFzZSAgPSB4ODZfcG11LmV2ZW50c2VsOworCQlod2MtPmNvdW50ZXJfYmFzZSA9IHg4Nl9wbXUucGVyZmN0cjsKKwl9CisKKwlwZXJmX2NvdW50ZXJzX2xhcGljX2luaXQoKTsKKworCXg4Nl9wbXUuZGlzYWJsZShod2MsIGlkeCk7CisKKwljcHVjLT5jb3VudGVyc1tpZHhdID0gY291bnRlcjsKKwlzZXRfYml0KGlkeCwgY3B1Yy0+YWN0aXZlX21hc2spOworCisJeDg2X3BlcmZfY291bnRlcl9zZXRfcGVyaW9kKGNvdW50ZXIsIGh3YywgaWR4KTsKKwl4ODZfcG11LmVuYWJsZShod2MsIGlkeCk7CisKKwlyZXR1cm4gMDsKK30KKworc3RhdGljIHZvaWQgeDg2X3BtdV91bnRocm90dGxlKHN0cnVjdCBwZXJmX2NvdW50ZXIgKmNvdW50ZXIpCit7CisJc3RydWN0IGNwdV9od19jb3VudGVycyAqY3B1YyA9ICZfX2dldF9jcHVfdmFyKGNwdV9od19jb3VudGVycyk7CisJc3RydWN0IGh3X3BlcmZfY291bnRlciAqaHdjID0gJmNvdW50ZXItPmh3OworCisJaWYgKFdBUk5fT05fT05DRShod2MtPmlkeCA+PSBYODZfUE1DX0lEWF9NQVggfHwKKwkJCQljcHVjLT5jb3VudGVyc1tod2MtPmlkeF0gIT0gY291bnRlcikpCisJCXJldHVybjsKKworCXg4Nl9wbXUuZW5hYmxlKGh3YywgaHdjLT5pZHgpOworfQorCit2b2lkIHBlcmZfY291bnRlcl9wcmludF9kZWJ1Zyh2b2lkKQoreworCXU2NCBjdHJsLCBzdGF0dXMsIG92ZXJmbG93LCBwbWNfY3RybCwgcG1jX2NvdW50LCBwcmV2X2xlZnQsIGZpeGVkOworCXN0cnVjdCBjcHVfaHdfY291bnRlcnMgKmNwdWM7CisJdW5zaWduZWQgbG9uZyBmbGFnczsKKwlpbnQgY3B1LCBpZHg7CisKKwlpZiAoIXg4Nl9wbXUubnVtX2NvdW50ZXJzKQorCQlyZXR1cm47CisKKwlsb2NhbF9pcnFfc2F2ZShmbGFncyk7CisKKwljcHUgPSBzbXBfcHJvY2Vzc29yX2lkKCk7CisJY3B1YyA9ICZwZXJfY3B1KGNwdV9od19jb3VudGVycywgY3B1KTsKKworCWlmICh4ODZfcG11LnZlcnNpb24gPj0gMikgeworCQlyZG1zcmwoTVNSX0NPUkVfUEVSRl9HTE9CQUxfQ1RSTCwgY3RybCk7CisJCXJkbXNybChNU1JfQ09SRV9QRVJGX0dMT0JBTF9TVEFUVVMsIHN0YXR1cyk7CisJCXJkbXNybChNU1JfQ09SRV9QRVJGX0dMT0JBTF9PVkZfQ1RSTCwgb3ZlcmZsb3cpOworCQlyZG1zcmwoTVNSX0FSQ0hfUEVSRk1PTl9GSVhFRF9DVFJfQ1RSTCwgZml4ZWQpOworCisJCXByX2luZm8oIlxuIik7CisJCXByX2luZm8oIkNQVSMlZDogY3RybDogICAgICAgJTAxNmxseFxuIiwgY3B1LCBjdHJsKTsKKwkJcHJfaW5mbygiQ1BVIyVkOiBzdGF0dXM6ICAgICAlMDE2bGx4XG4iLCBjcHUsIHN0YXR1cyk7CisJCXByX2luZm8oIkNQVSMlZDogb3ZlcmZsb3c6ICAgJTAxNmxseFxuIiwgY3B1LCBvdmVyZmxvdyk7CisJCXByX2luZm8oIkNQVSMlZDogZml4ZWQ6ICAgICAgJTAxNmxseFxuIiwgY3B1LCBmaXhlZCk7CisJfQorCXByX2luZm8oIkNQVSMlZDogdXNlZDogICAgICAgJTAxNmxseFxuIiwgY3B1LCAqKHU2NCAqKWNwdWMtPnVzZWRfbWFzayk7CisKKwlmb3IgKGlkeCA9IDA7IGlkeCA8IHg4Nl9wbXUubnVtX2NvdW50ZXJzOyBpZHgrKykgeworCQlyZG1zcmwoeDg2X3BtdS5ldmVudHNlbCArIGlkeCwgcG1jX2N0cmwpOworCQlyZG1zcmwoeDg2X3BtdS5wZXJmY3RyICArIGlkeCwgcG1jX2NvdW50KTsKKworCQlwcmV2X2xlZnQgPSBwZXJfY3B1KHByZXZfbGVmdFtpZHhdLCBjcHUpOworCisJCXByX2luZm8oIkNQVSMlZDogICBnZW4tUE1DJWQgY3RybDogICUwMTZsbHhcbiIsCisJCQljcHUsIGlkeCwgcG1jX2N0cmwpOworCQlwcl9pbmZvKCJDUFUjJWQ6ICAgZ2VuLVBNQyVkIGNvdW50OiAlMDE2bGx4XG4iLAorCQkJY3B1LCBpZHgsIHBtY19jb3VudCk7CisJCXByX2luZm8oIkNQVSMlZDogICBnZW4tUE1DJWQgbGVmdDogICUwMTZsbHhcbiIsCisJCQljcHUsIGlkeCwgcHJldl9sZWZ0KTsKKwl9CisJZm9yIChpZHggPSAwOyBpZHggPCB4ODZfcG11Lm51bV9jb3VudGVyc19maXhlZDsgaWR4KyspIHsKKwkJcmRtc3JsKE1TUl9BUkNIX1BFUkZNT05fRklYRURfQ1RSMCArIGlkeCwgcG1jX2NvdW50KTsKKworCQlwcl9pbmZvKCJDUFUjJWQ6IGZpeGVkLVBNQyVkIGNvdW50OiAlMDE2bGx4XG4iLAorCQkJY3B1LCBpZHgsIHBtY19jb3VudCk7CisJfQorCWxvY2FsX2lycV9yZXN0b3JlKGZsYWdzKTsKK30KKworc3RhdGljIHZvaWQgeDg2X3BtdV9kaXNhYmxlKHN0cnVjdCBwZXJmX2NvdW50ZXIgKmNvdW50ZXIpCit7CisJc3RydWN0IGNwdV9od19jb3VudGVycyAqY3B1YyA9ICZfX2dldF9jcHVfdmFyKGNwdV9od19jb3VudGVycyk7CisJc3RydWN0IGh3X3BlcmZfY291bnRlciAqaHdjID0gJmNvdW50ZXItPmh3OworCWludCBpZHggPSBod2MtPmlkeDsKKworCS8qCisJICogTXVzdCBiZSBkb25lIGJlZm9yZSB3ZSBkaXNhYmxlLCBvdGhlcndpc2UgdGhlIG5taSBoYW5kbGVyCisJICogY291bGQgcmVlbmFibGUgYWdhaW46CisJICovCisJY2xlYXJfYml0KGlkeCwgY3B1Yy0+YWN0aXZlX21hc2spOworCXg4Nl9wbXUuZGlzYWJsZShod2MsIGlkeCk7CisKKwkvKgorCSAqIE1ha2Ugc3VyZSB0aGUgY2xlYXJlZCBwb2ludGVyIGJlY29tZXMgdmlzaWJsZSBiZWZvcmUgd2UKKwkgKiAocG90ZW50aWFsbHkpIGZyZWUgdGhlIGNvdW50ZXI6CisJICovCisJYmFycmllcigpOworCisJLyoKKwkgKiBEcmFpbiB0aGUgcmVtYWluaW5nIGRlbHRhIGNvdW50IG91dCBvZiBhIGNvdW50ZXIKKwkgKiB0aGF0IHdlIGFyZSBkaXNhYmxpbmc6CisJICovCisJeDg2X3BlcmZfY291bnRlcl91cGRhdGUoY291bnRlciwgaHdjLCBpZHgpOworCWNwdWMtPmNvdW50ZXJzW2lkeF0gPSBOVUxMOworCWNsZWFyX2JpdChpZHgsIGNwdWMtPnVzZWRfbWFzayk7Cit9CisKKy8qCisgKiBTYXZlIGFuZCByZXN0YXJ0IGFuIGV4cGlyZWQgY291bnRlci4gQ2FsbGVkIGJ5IE5NSSBjb250ZXh0cywKKyAqIHNvIGl0IGhhcyB0byBiZSBjYXJlZnVsIGFib3V0IHByZWVtcHRpbmcgbm9ybWFsIGNvdW50ZXIgb3BzOgorICovCitzdGF0aWMgaW50IGludGVsX3BtdV9zYXZlX2FuZF9yZXN0YXJ0KHN0cnVjdCBwZXJmX2NvdW50ZXIgKmNvdW50ZXIpCit7CisJc3RydWN0IGh3X3BlcmZfY291bnRlciAqaHdjID0gJmNvdW50ZXItPmh3OworCWludCBpZHggPSBod2MtPmlkeDsKKwlpbnQgcmV0OworCisJeDg2X3BlcmZfY291bnRlcl91cGRhdGUoY291bnRlciwgaHdjLCBpZHgpOworCXJldCA9IHg4Nl9wZXJmX2NvdW50ZXJfc2V0X3BlcmlvZChjb3VudGVyLCBod2MsIGlkeCk7CisKKwlpZiAoY291bnRlci0+c3RhdGUgPT0gUEVSRl9DT1VOVEVSX1NUQVRFX0FDVElWRSkKKwkJaW50ZWxfcG11X2VuYWJsZV9jb3VudGVyKGh3YywgaWR4KTsKKworCXJldHVybiByZXQ7Cit9CisKK3N0YXRpYyB2b2lkIGludGVsX3BtdV9yZXNldCh2b2lkKQoreworCXVuc2lnbmVkIGxvbmcgZmxhZ3M7CisJaW50IGlkeDsKKworCWlmICgheDg2X3BtdS5udW1fY291bnRlcnMpCisJCXJldHVybjsKKworCWxvY2FsX2lycV9zYXZlKGZsYWdzKTsKKworCXByaW50aygiY2xlYXJpbmcgUE1VIHN0YXRlIG9uIENQVSMlZFxuIiwgc21wX3Byb2Nlc3Nvcl9pZCgpKTsKKworCWZvciAoaWR4ID0gMDsgaWR4IDwgeDg2X3BtdS5udW1fY291bnRlcnM7IGlkeCsrKSB7CisJCWNoZWNraW5nX3dybXNybCh4ODZfcG11LmV2ZW50c2VsICsgaWR4LCAwdWxsKTsKKwkJY2hlY2tpbmdfd3Jtc3JsKHg4Nl9wbXUucGVyZmN0ciAgKyBpZHgsIDB1bGwpOworCX0KKwlmb3IgKGlkeCA9IDA7IGlkeCA8IHg4Nl9wbXUubnVtX2NvdW50ZXJzX2ZpeGVkOyBpZHgrKykgeworCQljaGVja2luZ193cm1zcmwoTVNSX0FSQ0hfUEVSRk1PTl9GSVhFRF9DVFIwICsgaWR4LCAwdWxsKTsKKwl9CisKKwlsb2NhbF9pcnFfcmVzdG9yZShmbGFncyk7Cit9CisKKworLyoKKyAqIFRoaXMgaGFuZGxlciBpcyB0cmlnZ2VyZWQgYnkgdGhlIGxvY2FsIEFQSUMsIHNvIHRoZSBBUElDIElSUSBoYW5kbGluZworICogcnVsZXMgYXBwbHk6CisgKi8KK3N0YXRpYyBpbnQgaW50ZWxfcG11X2hhbmRsZV9pcnEoc3RydWN0IHB0X3JlZ3MgKnJlZ3MpCit7CisJc3RydWN0IHBlcmZfc2FtcGxlX2RhdGEgZGF0YTsKKwlzdHJ1Y3QgY3B1X2h3X2NvdW50ZXJzICpjcHVjOworCWludCBiaXQsIGNwdSwgbG9vcHM7CisJdTY0IGFjaywgc3RhdHVzOworCisJZGF0YS5yZWdzID0gcmVnczsKKwlkYXRhLmFkZHIgPSAwOworCisJY3B1ID0gc21wX3Byb2Nlc3Nvcl9pZCgpOworCWNwdWMgPSAmcGVyX2NwdShjcHVfaHdfY291bnRlcnMsIGNwdSk7CisKKwlwZXJmX2Rpc2FibGUoKTsKKwlzdGF0dXMgPSBpbnRlbF9wbXVfZ2V0X3N0YXR1cygpOworCWlmICghc3RhdHVzKSB7CisJCXBlcmZfZW5hYmxlKCk7CisJCXJldHVybiAwOworCX0KKworCWxvb3BzID0gMDsKK2FnYWluOgorCWlmICgrK2xvb3BzID4gMTAwKSB7CisJCVdBUk5fT05DRSgxLCAicGVyZmNvdW50ZXJzOiBpcnEgbG9vcCBzdHVjayFcbiIpOworCQlwZXJmX2NvdW50ZXJfcHJpbnRfZGVidWcoKTsKKwkJaW50ZWxfcG11X3Jlc2V0KCk7CisJCXBlcmZfZW5hYmxlKCk7CisJCXJldHVybiAxOworCX0KKworCWluY19pcnFfc3RhdChhcGljX3BlcmZfaXJxcyk7CisJYWNrID0gc3RhdHVzOworCWZvcl9lYWNoX2JpdChiaXQsICh1bnNpZ25lZCBsb25nICopJnN0YXR1cywgWDg2X1BNQ19JRFhfTUFYKSB7CisJCXN0cnVjdCBwZXJmX2NvdW50ZXIgKmNvdW50ZXIgPSBjcHVjLT5jb3VudGVyc1tiaXRdOworCisJCWNsZWFyX2JpdChiaXQsICh1bnNpZ25lZCBsb25nICopICZzdGF0dXMpOworCQlpZiAoIXRlc3RfYml0KGJpdCwgY3B1Yy0+YWN0aXZlX21hc2spKQorCQkJY29udGludWU7CisKKwkJaWYgKCFpbnRlbF9wbXVfc2F2ZV9hbmRfcmVzdGFydChjb3VudGVyKSkKKwkJCWNvbnRpbnVlOworCisJCWlmIChwZXJmX2NvdW50ZXJfb3ZlcmZsb3coY291bnRlciwgMSwgJmRhdGEpKQorCQkJaW50ZWxfcG11X2Rpc2FibGVfY291bnRlcigmY291bnRlci0+aHcsIGJpdCk7CisJfQorCisJaW50ZWxfcG11X2Fja19zdGF0dXMoYWNrKTsKKworCS8qCisJICogUmVwZWF0IGlmIHRoZXJlIGlzIG1vcmUgd29yayB0byBiZSBkb25lOgorCSAqLworCXN0YXR1cyA9IGludGVsX3BtdV9nZXRfc3RhdHVzKCk7CisJaWYgKHN0YXR1cykKKwkJZ290byBhZ2FpbjsKKworCXBlcmZfZW5hYmxlKCk7CisKKwlyZXR1cm4gMTsKK30KKworc3RhdGljIGludCBhbWRfcG11X2hhbmRsZV9pcnEoc3RydWN0IHB0X3JlZ3MgKnJlZ3MpCit7CisJc3RydWN0IHBlcmZfc2FtcGxlX2RhdGEgZGF0YTsKKwlzdHJ1Y3QgY3B1X2h3X2NvdW50ZXJzICpjcHVjOworCXN0cnVjdCBwZXJmX2NvdW50ZXIgKmNvdW50ZXI7CisJc3RydWN0IGh3X3BlcmZfY291bnRlciAqaHdjOworCWludCBjcHUsIGlkeCwgaGFuZGxlZCA9IDA7CisJdTY0IHZhbDsKKworCWRhdGEucmVncyA9IHJlZ3M7CisJZGF0YS5hZGRyID0gMDsKKworCWNwdSA9IHNtcF9wcm9jZXNzb3JfaWQoKTsKKwljcHVjID0gJnBlcl9jcHUoY3B1X2h3X2NvdW50ZXJzLCBjcHUpOworCisJZm9yIChpZHggPSAwOyBpZHggPCB4ODZfcG11Lm51bV9jb3VudGVyczsgaWR4KyspIHsKKwkJaWYgKCF0ZXN0X2JpdChpZHgsIGNwdWMtPmFjdGl2ZV9tYXNrKSkKKwkJCWNvbnRpbnVlOworCisJCWNvdW50ZXIgPSBjcHVjLT5jb3VudGVyc1tpZHhdOworCQlod2MgPSAmY291bnRlci0+aHc7CisKKwkJdmFsID0geDg2X3BlcmZfY291bnRlcl91cGRhdGUoY291bnRlciwgaHdjLCBpZHgpOworCQlpZiAodmFsICYgKDFVTEwgPDwgKHg4Nl9wbXUuY291bnRlcl9iaXRzIC0gMSkpKQorCQkJY29udGludWU7CisKKwkJLyoKKwkJICogY291bnRlciBvdmVyZmxvdworCQkgKi8KKwkJaGFuZGxlZAkJPSAxOworCQlkYXRhLnBlcmlvZAk9IGNvdW50ZXItPmh3Lmxhc3RfcGVyaW9kOworCisJCWlmICgheDg2X3BlcmZfY291bnRlcl9zZXRfcGVyaW9kKGNvdW50ZXIsIGh3YywgaWR4KSkKKwkJCWNvbnRpbnVlOworCisJCWlmIChwZXJmX2NvdW50ZXJfb3ZlcmZsb3coY291bnRlciwgMSwgJmRhdGEpKQorCQkJYW1kX3BtdV9kaXNhYmxlX2NvdW50ZXIoaHdjLCBpZHgpOworCX0KKworCWlmIChoYW5kbGVkKQorCQlpbmNfaXJxX3N0YXQoYXBpY19wZXJmX2lycXMpOworCisJcmV0dXJuIGhhbmRsZWQ7Cit9CisKK3ZvaWQgc21wX3BlcmZfcGVuZGluZ19pbnRlcnJ1cHQoc3RydWN0IHB0X3JlZ3MgKnJlZ3MpCit7CisJaXJxX2VudGVyKCk7CisJYWNrX0FQSUNfaXJxKCk7CisJaW5jX2lycV9zdGF0KGFwaWNfcGVuZGluZ19pcnFzKTsKKwlwZXJmX2NvdW50ZXJfZG9fcGVuZGluZygpOworCWlycV9leGl0KCk7Cit9CisKK3ZvaWQgc2V0X3BlcmZfY291bnRlcl9wZW5kaW5nKHZvaWQpCit7CisJYXBpYy0+c2VuZF9JUElfc2VsZihMT0NBTF9QRU5ESU5HX1ZFQ1RPUik7Cit9CisKK3ZvaWQgcGVyZl9jb3VudGVyc19sYXBpY19pbml0KHZvaWQpCit7CisJaWYgKCF4ODZfcG11X2luaXRpYWxpemVkKCkpCisJCXJldHVybjsKKworCS8qCisJICogQWx3YXlzIHVzZSBOTUkgZm9yIFBNVQorCSAqLworCWFwaWNfd3JpdGUoQVBJQ19MVlRQQywgQVBJQ19ETV9OTUkpOworfQorCitzdGF0aWMgaW50IF9fa3Byb2JlcworcGVyZl9jb3VudGVyX25taV9oYW5kbGVyKHN0cnVjdCBub3RpZmllcl9ibG9jayAqc2VsZiwKKwkJCSB1bnNpZ25lZCBsb25nIGNtZCwgdm9pZCAqX19hcmdzKQoreworCXN0cnVjdCBkaWVfYXJncyAqYXJncyA9IF9fYXJnczsKKwlzdHJ1Y3QgcHRfcmVncyAqcmVnczsKKworCWlmICghYXRvbWljX3JlYWQoJmFjdGl2ZV9jb3VudGVycykpCisJCXJldHVybiBOT1RJRllfRE9ORTsKKworCXN3aXRjaCAoY21kKSB7CisJY2FzZSBESUVfTk1JOgorCWNhc2UgRElFX05NSV9JUEk6CisJCWJyZWFrOworCisJZGVmYXVsdDoKKwkJcmV0dXJuIE5PVElGWV9ET05FOworCX0KKworCXJlZ3MgPSBhcmdzLT5yZWdzOworCisJYXBpY193cml0ZShBUElDX0xWVFBDLCBBUElDX0RNX05NSSk7CisJLyoKKwkgKiBDYW4ndCByZWx5IG9uIHRoZSBoYW5kbGVkIHJldHVybiB2YWx1ZSB0byBzYXkgaXQgd2FzIG91ciBOTUksIHR3bworCSAqIGNvdW50ZXJzIGNvdWxkIHRyaWdnZXIgJ3NpbXVsdGFuZW91c2x5JyByYWlzaW5nIHR3byBiYWNrLXRvLWJhY2sgTk1Jcy4KKwkgKgorCSAqIElmIHRoZSBmaXJzdCBOTUkgaGFuZGxlcyBib3RoLCB0aGUgbGF0dGVyIHdpbGwgYmUgZW1wdHkgYW5kIGRhemUKKwkgKiB0aGUgQ1BVLgorCSAqLworCXg4Nl9wbXUuaGFuZGxlX2lycShyZWdzKTsKKworCXJldHVybiBOT1RJRllfU1RPUDsKK30KKworc3RhdGljIF9fcmVhZF9tb3N0bHkgc3RydWN0IG5vdGlmaWVyX2Jsb2NrIHBlcmZfY291bnRlcl9ubWlfbm90aWZpZXIgPSB7CisJLm5vdGlmaWVyX2NhbGwJCT0gcGVyZl9jb3VudGVyX25taV9oYW5kbGVyLAorCS5uZXh0CQkJPSBOVUxMLAorCS5wcmlvcml0eQkJPSAxCit9OworCitzdGF0aWMgc3RydWN0IHg4Nl9wbXUgaW50ZWxfcG11ID0geworCS5uYW1lCQkJPSAiSW50ZWwiLAorCS5oYW5kbGVfaXJxCQk9IGludGVsX3BtdV9oYW5kbGVfaXJxLAorCS5kaXNhYmxlX2FsbAkJPSBpbnRlbF9wbXVfZGlzYWJsZV9hbGwsCisJLmVuYWJsZV9hbGwJCT0gaW50ZWxfcG11X2VuYWJsZV9hbGwsCisJLmVuYWJsZQkJCT0gaW50ZWxfcG11X2VuYWJsZV9jb3VudGVyLAorCS5kaXNhYmxlCQk9IGludGVsX3BtdV9kaXNhYmxlX2NvdW50ZXIsCisJLmV2ZW50c2VsCQk9IE1TUl9BUkNIX1BFUkZNT05fRVZFTlRTRUwwLAorCS5wZXJmY3RyCQk9IE1TUl9BUkNIX1BFUkZNT05fUEVSRkNUUjAsCisJLmV2ZW50X21hcAkJPSBpbnRlbF9wbXVfZXZlbnRfbWFwLAorCS5yYXdfZXZlbnQJCT0gaW50ZWxfcG11X3Jhd19ldmVudCwKKwkubWF4X2V2ZW50cwkJPSBBUlJBWV9TSVpFKGludGVsX3BlcmZtb25fZXZlbnRfbWFwKSwKKwkvKgorCSAqIEludGVsIFBNQ3MgY2Fubm90IGJlIGFjY2Vzc2VkIHNhbmVseSBhYm92ZSAzMiBiaXQgd2lkdGgsCisJICogc28gd2UgaW5zdGFsbCBhbiBhcnRpZmljaWFsIDE8PDMxIHBlcmlvZCByZWdhcmRsZXNzIG9mCisJICogdGhlIGdlbmVyaWMgY291bnRlciBwZXJpb2Q6CisJICovCisJLm1heF9wZXJpb2QJCT0gKDFVTEwgPDwgMzEpIC0gMSwKK307CisKK3N0YXRpYyBzdHJ1Y3QgeDg2X3BtdSBhbWRfcG11ID0geworCS5uYW1lCQkJPSAiQU1EIiwKKwkuaGFuZGxlX2lycQkJPSBhbWRfcG11X2hhbmRsZV9pcnEsCisJLmRpc2FibGVfYWxsCQk9IGFtZF9wbXVfZGlzYWJsZV9hbGwsCisJLmVuYWJsZV9hbGwJCT0gYW1kX3BtdV9lbmFibGVfYWxsLAorCS5lbmFibGUJCQk9IGFtZF9wbXVfZW5hYmxlX2NvdW50ZXIsCisJLmRpc2FibGUJCT0gYW1kX3BtdV9kaXNhYmxlX2NvdW50ZXIsCisJLmV2ZW50c2VsCQk9IE1TUl9LN19FVk5UU0VMMCwKKwkucGVyZmN0cgkJPSBNU1JfSzdfUEVSRkNUUjAsCisJLmV2ZW50X21hcAkJPSBhbWRfcG11X2V2ZW50X21hcCwKKwkucmF3X2V2ZW50CQk9IGFtZF9wbXVfcmF3X2V2ZW50LAorCS5tYXhfZXZlbnRzCQk9IEFSUkFZX1NJWkUoYW1kX3BlcmZtb25fZXZlbnRfbWFwKSwKKwkubnVtX2NvdW50ZXJzCQk9IDQsCisJLmNvdW50ZXJfYml0cwkJPSA0OCwKKwkuY291bnRlcl9tYXNrCQk9ICgxVUxMIDw8IDQ4KSAtIDEsCisJLyogdXNlIGhpZ2hlc3QgYml0IHRvIGRldGVjdCBvdmVyZmxvdyAqLworCS5tYXhfcGVyaW9kCQk9ICgxVUxMIDw8IDQ3KSAtIDEsCit9OworCitzdGF0aWMgaW50IGludGVsX3BtdV9pbml0KHZvaWQpCit7CisJdW5pb24gY3B1aWQxMF9lZHggZWR4OworCXVuaW9uIGNwdWlkMTBfZWF4IGVheDsKKwl1bnNpZ25lZCBpbnQgdW51c2VkOworCXVuc2lnbmVkIGludCBlYng7CisJaW50IHZlcnNpb247CisKKwlpZiAoIWNwdV9oYXMoJmJvb3RfY3B1X2RhdGEsIFg4Nl9GRUFUVVJFX0FSQ0hfUEVSRk1PTikpCisJCXJldHVybiAtRU5PREVWOworCisJLyoKKwkgKiBDaGVjayB3aGV0aGVyIHRoZSBBcmNoaXRlY3R1cmFsIFBlcmZNb24gc3VwcG9ydHMKKwkgKiBCcmFuY2ggTWlzc2VzIFJldGlyZWQgRXZlbnQgb3Igbm90LgorCSAqLworCWNwdWlkKDEwLCAmZWF4LmZ1bGwsICZlYngsICZ1bnVzZWQsICZlZHguZnVsbCk7CisJaWYgKGVheC5zcGxpdC5tYXNrX2xlbmd0aCA8PSBBUkNIX1BFUkZNT05fQlJBTkNIX01JU1NFU19SRVRJUkVEKQorCQlyZXR1cm4gLUVOT0RFVjsKKworCXZlcnNpb24gPSBlYXguc3BsaXQudmVyc2lvbl9pZDsKKwlpZiAodmVyc2lvbiA8IDIpCisJCXJldHVybiAtRU5PREVWOworCisJeDg2X3BtdQkJCQk9IGludGVsX3BtdTsKKwl4ODZfcG11LnZlcnNpb24JCQk9IHZlcnNpb247CisJeDg2X3BtdS5udW1fY291bnRlcnMJCT0gZWF4LnNwbGl0Lm51bV9jb3VudGVyczsKKwl4ODZfcG11LmNvdW50ZXJfYml0cwkJPSBlYXguc3BsaXQuYml0X3dpZHRoOworCXg4Nl9wbXUuY291bnRlcl9tYXNrCQk9ICgxVUxMIDw8IGVheC5zcGxpdC5iaXRfd2lkdGgpIC0gMTsKKworCS8qCisJICogUXVpcms6IHYyIHBlcmZtb24gZG9lcyBub3QgcmVwb3J0IGZpeGVkLXB1cnBvc2UgY291bnRlcnMsIHNvCisJICogYXNzdW1lIGF0IGxlYXN0IDMgY291bnRlcnM6CisJICovCisJeDg2X3BtdS5udW1fY291bnRlcnNfZml4ZWQJPSBtYXgoKGludCllZHguc3BsaXQubnVtX2NvdW50ZXJzX2ZpeGVkLCAzKTsKKworCXJkbXNybChNU1JfQ09SRV9QRVJGX0dMT0JBTF9DVFJMLCB4ODZfcG11LmludGVsX2N0cmwpOworCisJLyoKKwkgKiBJbnN0YWxsIHRoZSBody1jYWNoZS1ldmVudHMgdGFibGU6CisJICovCisJc3dpdGNoIChib290X2NwdV9kYXRhLng4Nl9tb2RlbCkgeworCWNhc2UgMTU6IC8qIG9yaWdpbmFsIDY1IG5tIGNlbGVyb24vcGVudGl1bS9jb3JlMi94ZW9uLCAiTWVyb20iLyJDb25yb2UiICovCisJY2FzZSAyMjogLyogc2luZ2xlLWNvcmUgNjUgbm0gY2VsZXJvbi9jb3JlMnNvbG8gIk1lcm9tLUwiLyJDb25yb2UtTCIgKi8KKwljYXNlIDIzOiAvKiBjdXJyZW50IDQ1IG5tIGNlbGVyb24vY29yZTIveGVvbiAiUGVucnluIi8iV29sZmRhbGUiICovCisJY2FzZSAyOTogLyogc2l4LWNvcmUgNDUgbm0geGVvbiAiRHVubmluZ3RvbiIgKi8KKwkJbWVtY3B5KGh3X2NhY2hlX2V2ZW50X2lkcywgY29yZTJfaHdfY2FjaGVfZXZlbnRfaWRzLAorCQkgICAgICAgc2l6ZW9mKGh3X2NhY2hlX2V2ZW50X2lkcykpOworCisJCXByX2NvbnQoIkNvcmUyIGV2ZW50cywgIik7CisJCWJyZWFrOworCWRlZmF1bHQ6CisJY2FzZSAyNjoKKwkJbWVtY3B5KGh3X2NhY2hlX2V2ZW50X2lkcywgbmVoYWxlbV9od19jYWNoZV9ldmVudF9pZHMsCisJCSAgICAgICBzaXplb2YoaHdfY2FjaGVfZXZlbnRfaWRzKSk7CisKKwkJcHJfY29udCgiTmVoYWxlbS9Db3JlaTcgZXZlbnRzLCAiKTsKKwkJYnJlYWs7CisJY2FzZSAyODoKKwkJbWVtY3B5KGh3X2NhY2hlX2V2ZW50X2lkcywgYXRvbV9od19jYWNoZV9ldmVudF9pZHMsCisJCSAgICAgICBzaXplb2YoaHdfY2FjaGVfZXZlbnRfaWRzKSk7CisKKwkJcHJfY29udCgiQXRvbSBldmVudHMsICIpOworCQlicmVhazsKKwl9CisJcmV0dXJuIDA7Cit9CisKK3N0YXRpYyBpbnQgYW1kX3BtdV9pbml0KHZvaWQpCit7CisJeDg2X3BtdSA9IGFtZF9wbXU7CisKKwlzd2l0Y2ggKGJvb3RfY3B1X2RhdGEueDg2KSB7CisJY2FzZSAweDBmOgorCWNhc2UgMHgxMDoKKwljYXNlIDB4MTE6CisJCW1lbWNweShod19jYWNoZV9ldmVudF9pZHMsIGFtZF8wZl9od19jYWNoZV9ldmVudF9pZHMsCisJCSAgICAgICBzaXplb2YoaHdfY2FjaGVfZXZlbnRfaWRzKSk7CisKKwkJcHJfY29udCgiQU1EIEZhbWlseSAwZi8xMC8xMSBldmVudHMsICIpOworCQlicmVhazsKKwl9CisJcmV0dXJuIDA7Cit9CisKK3ZvaWQgX19pbml0IGluaXRfaHdfcGVyZl9jb3VudGVycyh2b2lkKQoreworCWludCBlcnI7CisKKwlwcl9pbmZvKCJQZXJmb3JtYW5jZSBDb3VudGVyczogIik7CisKKwlzd2l0Y2ggKGJvb3RfY3B1X2RhdGEueDg2X3ZlbmRvcikgeworCWNhc2UgWDg2X1ZFTkRPUl9JTlRFTDoKKwkJZXJyID0gaW50ZWxfcG11X2luaXQoKTsKKwkJYnJlYWs7CisJY2FzZSBYODZfVkVORE9SX0FNRDoKKwkJZXJyID0gYW1kX3BtdV9pbml0KCk7CisJCWJyZWFrOworCWRlZmF1bHQ6CisJCXJldHVybjsKKwl9CisJaWYgKGVyciAhPSAwKSB7CisJCXByX2NvbnQoIm5vIFBNVSBkcml2ZXIsIHNvZnR3YXJlIGNvdW50ZXJzIG9ubHkuXG4iKTsKKwkJcmV0dXJuOworCX0KKworCXByX2NvbnQoIiVzIFBNVSBkcml2ZXIuXG4iLCB4ODZfcG11Lm5hbWUpOworCisJaWYgKHg4Nl9wbXUubnVtX2NvdW50ZXJzID4gWDg2X1BNQ19NQVhfR0VORVJJQykgeworCQl4ODZfcG11Lm51bV9jb3VudGVycyA9IFg4Nl9QTUNfTUFYX0dFTkVSSUM7CisJCVdBUk4oMSwgS0VSTl9FUlIgImh3IHBlcmYgY291bnRlcnMgJWQgPiBtYXgoJWQpLCBjbGlwcGluZyEiLAorCQkgICAgIHg4Nl9wbXUubnVtX2NvdW50ZXJzLCBYODZfUE1DX01BWF9HRU5FUklDKTsKKwl9CisJcGVyZl9jb3VudGVyX21hc2sgPSAoMSA8PCB4ODZfcG11Lm51bV9jb3VudGVycykgLSAxOworCXBlcmZfbWF4X2NvdW50ZXJzID0geDg2X3BtdS5udW1fY291bnRlcnM7CisKKwlpZiAoeDg2X3BtdS5udW1fY291bnRlcnNfZml4ZWQgPiBYODZfUE1DX01BWF9GSVhFRCkgeworCQl4ODZfcG11Lm51bV9jb3VudGVyc19maXhlZCA9IFg4Nl9QTUNfTUFYX0ZJWEVEOworCQlXQVJOKDEsIEtFUk5fRVJSICJodyBwZXJmIGNvdW50ZXJzIGZpeGVkICVkID4gbWF4KCVkKSwgY2xpcHBpbmchIiwKKwkJICAgICB4ODZfcG11Lm51bV9jb3VudGVyc19maXhlZCwgWDg2X1BNQ19NQVhfRklYRUQpOworCX0KKworCXBlcmZfY291bnRlcl9tYXNrIHw9CisJCSgoMUxMIDw8IHg4Nl9wbXUubnVtX2NvdW50ZXJzX2ZpeGVkKS0xKSA8PCBYODZfUE1DX0lEWF9GSVhFRDsKKworCXBlcmZfY291bnRlcnNfbGFwaWNfaW5pdCgpOworCXJlZ2lzdGVyX2RpZV9ub3RpZmllcigmcGVyZl9jb3VudGVyX25taV9ub3RpZmllcik7CisKKwlwcl9pbmZvKCIuLi4gdmVyc2lvbjogICAgICAgICAgICAgICAgICVkXG4iLCAgICAgeDg2X3BtdS52ZXJzaW9uKTsKKwlwcl9pbmZvKCIuLi4gYml0IHdpZHRoOiAgICAgICAgICAgICAgICVkXG4iLCAgICAgeDg2X3BtdS5jb3VudGVyX2JpdHMpOworCXByX2luZm8oIi4uLiBnZW5lcmljIGNvdW50ZXJzOiAgICAgICAgJWRcbiIsICAgICB4ODZfcG11Lm51bV9jb3VudGVycyk7CisJcHJfaW5mbygiLi4uIHZhbHVlIG1hc2s6ICAgICAgICAgICAgICAlMDE2THhcbiIsIHg4Nl9wbXUuY291bnRlcl9tYXNrKTsKKwlwcl9pbmZvKCIuLi4gbWF4IHBlcmlvZDogICAgICAgICAgICAgICUwMTZMeFxuIiwgeDg2X3BtdS5tYXhfcGVyaW9kKTsKKwlwcl9pbmZvKCIuLi4gZml4ZWQtcHVycG9zZSBjb3VudGVyczogICVkXG4iLCAgICAgeDg2X3BtdS5udW1fY291bnRlcnNfZml4ZWQpOworCXByX2luZm8oIi4uLiBjb3VudGVyIG1hc2s6ICAgICAgICAgICAgJTAxNkx4XG4iLCBwZXJmX2NvdW50ZXJfbWFzayk7Cit9CisKK3N0YXRpYyBpbmxpbmUgdm9pZCB4ODZfcG11X3JlYWQoc3RydWN0IHBlcmZfY291bnRlciAqY291bnRlcikKK3sKKwl4ODZfcGVyZl9jb3VudGVyX3VwZGF0ZShjb3VudGVyLCAmY291bnRlci0+aHcsIGNvdW50ZXItPmh3LmlkeCk7Cit9CisKK3N0YXRpYyBjb25zdCBzdHJ1Y3QgcG11IHBtdSA9IHsKKwkuZW5hYmxlCQk9IHg4Nl9wbXVfZW5hYmxlLAorCS5kaXNhYmxlCT0geDg2X3BtdV9kaXNhYmxlLAorCS5yZWFkCQk9IHg4Nl9wbXVfcmVhZCwKKwkudW50aHJvdHRsZQk9IHg4Nl9wbXVfdW50aHJvdHRsZSwKK307CisKK2NvbnN0IHN0cnVjdCBwbXUgKmh3X3BlcmZfY291bnRlcl9pbml0KHN0cnVjdCBwZXJmX2NvdW50ZXIgKmNvdW50ZXIpCit7CisJaW50IGVycjsKKworCWVyciA9IF9faHdfcGVyZl9jb3VudGVyX2luaXQoY291bnRlcik7CisJaWYgKGVycikKKwkJcmV0dXJuIEVSUl9QVFIoZXJyKTsKKworCXJldHVybiAmcG11OworfQorCisvKgorICogY2FsbGNoYWluIHN1cHBvcnQKKyAqLworCitzdGF0aWMgaW5saW5lCit2b2lkIGNhbGxjaGFpbl9zdG9yZShzdHJ1Y3QgcGVyZl9jYWxsY2hhaW5fZW50cnkgKmVudHJ5LCB1bnNpZ25lZCBsb25nIGlwKQoreworCWlmIChlbnRyeS0+bnIgPCBNQVhfU1RBQ0tfREVQVEgpCisJCWVudHJ5LT5pcFtlbnRyeS0+bnIrK10gPSBpcDsKK30KKworc3RhdGljIERFRklORV9QRVJfQ1BVKHN0cnVjdCBwZXJmX2NhbGxjaGFpbl9lbnRyeSwgaXJxX2VudHJ5KTsKK3N0YXRpYyBERUZJTkVfUEVSX0NQVShzdHJ1Y3QgcGVyZl9jYWxsY2hhaW5fZW50cnksIG5taV9lbnRyeSk7CisKKworc3RhdGljIHZvaWQKK2JhY2t0cmFjZV93YXJuaW5nX3N5bWJvbCh2b2lkICpkYXRhLCBjaGFyICptc2csIHVuc2lnbmVkIGxvbmcgc3ltYm9sKQoreworCS8qIElnbm9yZSB3YXJuaW5ncyAqLworfQorCitzdGF0aWMgdm9pZCBiYWNrdHJhY2Vfd2FybmluZyh2b2lkICpkYXRhLCBjaGFyICptc2cpCit7CisJLyogSWdub3JlIHdhcm5pbmdzICovCit9CisKK3N0YXRpYyBpbnQgYmFja3RyYWNlX3N0YWNrKHZvaWQgKmRhdGEsIGNoYXIgKm5hbWUpCit7CisJLyogRG9uJ3QgYm90aGVyIHdpdGggSVJRIHN0YWNrcyBmb3Igbm93ICovCisJcmV0dXJuIC0xOworfQorCitzdGF0aWMgdm9pZCBiYWNrdHJhY2VfYWRkcmVzcyh2b2lkICpkYXRhLCB1bnNpZ25lZCBsb25nIGFkZHIsIGludCByZWxpYWJsZSkKK3sKKwlzdHJ1Y3QgcGVyZl9jYWxsY2hhaW5fZW50cnkgKmVudHJ5ID0gZGF0YTsKKworCWlmIChyZWxpYWJsZSkKKwkJY2FsbGNoYWluX3N0b3JlKGVudHJ5LCBhZGRyKTsKK30KKworc3RhdGljIGNvbnN0IHN0cnVjdCBzdGFja3RyYWNlX29wcyBiYWNrdHJhY2Vfb3BzID0geworCS53YXJuaW5nCQk9IGJhY2t0cmFjZV93YXJuaW5nLAorCS53YXJuaW5nX3N5bWJvbAkJPSBiYWNrdHJhY2Vfd2FybmluZ19zeW1ib2wsCisJLnN0YWNrCQkJPSBiYWNrdHJhY2Vfc3RhY2ssCisJLmFkZHJlc3MJCT0gYmFja3RyYWNlX2FkZHJlc3MsCit9OworCitzdGF0aWMgdm9pZAorcGVyZl9jYWxsY2hhaW5fa2VybmVsKHN0cnVjdCBwdF9yZWdzICpyZWdzLCBzdHJ1Y3QgcGVyZl9jYWxsY2hhaW5fZW50cnkgKmVudHJ5KQoreworCXVuc2lnbmVkIGxvbmcgYnA7CisJY2hhciAqc3RhY2s7CisJaW50IG5yID0gZW50cnktPm5yOworCisJY2FsbGNoYWluX3N0b3JlKGVudHJ5LCBpbnN0cnVjdGlvbl9wb2ludGVyKHJlZ3MpKTsKKworCXN0YWNrID0gKChjaGFyICopcmVncyArIHNpemVvZihzdHJ1Y3QgcHRfcmVncykpOworI2lmZGVmIENPTkZJR19GUkFNRV9QT0lOVEVSCisJYnAgPSBmcmFtZV9wb2ludGVyKHJlZ3MpOworI2Vsc2UKKwlicCA9IDA7CisjZW5kaWYKKworCWR1bXBfdHJhY2UoTlVMTCwgcmVncywgKHZvaWQgKilzdGFjaywgYnAsICZiYWNrdHJhY2Vfb3BzLCBlbnRyeSk7CisKKwllbnRyeS0+a2VybmVsID0gZW50cnktPm5yIC0gbnI7Cit9CisKKworc3RydWN0IHN0YWNrX2ZyYW1lIHsKKwljb25zdCB2b2lkIF9fdXNlcgkqbmV4dF9mcDsKKwl1bnNpZ25lZCBsb25nCQlyZXR1cm5fYWRkcmVzczsKK307CisKK3N0YXRpYyBpbnQgY29weV9zdGFja19mcmFtZShjb25zdCB2b2lkIF9fdXNlciAqZnAsIHN0cnVjdCBzdGFja19mcmFtZSAqZnJhbWUpCit7CisJaW50IHJldDsKKworCWlmICghYWNjZXNzX29rKFZFUklGWV9SRUFELCBmcCwgc2l6ZW9mKCpmcmFtZSkpKQorCQlyZXR1cm4gMDsKKworCXJldCA9IDE7CisJcGFnZWZhdWx0X2Rpc2FibGUoKTsKKwlpZiAoX19jb3B5X2Zyb21fdXNlcl9pbmF0b21pYyhmcmFtZSwgZnAsIHNpemVvZigqZnJhbWUpKSkKKwkJcmV0ID0gMDsKKwlwYWdlZmF1bHRfZW5hYmxlKCk7CisKKwlyZXR1cm4gcmV0OworfQorCitzdGF0aWMgdm9pZAorcGVyZl9jYWxsY2hhaW5fdXNlcihzdHJ1Y3QgcHRfcmVncyAqcmVncywgc3RydWN0IHBlcmZfY2FsbGNoYWluX2VudHJ5ICplbnRyeSkKK3sKKwlzdHJ1Y3Qgc3RhY2tfZnJhbWUgZnJhbWU7CisJY29uc3Qgdm9pZCBfX3VzZXIgKmZwOworCWludCBuciA9IGVudHJ5LT5ucjsKKworCXJlZ3MgPSAoc3RydWN0IHB0X3JlZ3MgKiljdXJyZW50LT50aHJlYWQuc3AwIC0gMTsKKwlmcCAgID0gKHZvaWQgX191c2VyICopcmVncy0+YnA7CisKKwljYWxsY2hhaW5fc3RvcmUoZW50cnksIHJlZ3MtPmlwKTsKKworCXdoaWxlIChlbnRyeS0+bnIgPCBNQVhfU1RBQ0tfREVQVEgpIHsKKwkJZnJhbWUubmV4dF9mcAkgICAgID0gTlVMTDsKKwkJZnJhbWUucmV0dXJuX2FkZHJlc3MgPSAwOworCisJCWlmICghY29weV9zdGFja19mcmFtZShmcCwgJmZyYW1lKSkKKwkJCWJyZWFrOworCisJCWlmICgodW5zaWduZWQgbG9uZylmcCA8IHVzZXJfc3RhY2tfcG9pbnRlcihyZWdzKSkKKwkJCWJyZWFrOworCisJCWNhbGxjaGFpbl9zdG9yZShlbnRyeSwgZnJhbWUucmV0dXJuX2FkZHJlc3MpOworCQlmcCA9IGZyYW1lLm5leHRfZnA7CisJfQorCisJZW50cnktPnVzZXIgPSBlbnRyeS0+bnIgLSBucjsKK30KKworc3RhdGljIHZvaWQKK3BlcmZfZG9fY2FsbGNoYWluKHN0cnVjdCBwdF9yZWdzICpyZWdzLCBzdHJ1Y3QgcGVyZl9jYWxsY2hhaW5fZW50cnkgKmVudHJ5KQoreworCWludCBpc191c2VyOworCisJaWYgKCFyZWdzKQorCQlyZXR1cm47CisKKwlpc191c2VyID0gdXNlcl9tb2RlKHJlZ3MpOworCisJaWYgKCFjdXJyZW50IHx8IGN1cnJlbnQtPnBpZCA9PSAwKQorCQlyZXR1cm47CisKKwlpZiAoaXNfdXNlciAmJiBjdXJyZW50LT5zdGF0ZSAhPSBUQVNLX1JVTk5JTkcpCisJCXJldHVybjsKKworCWlmICghaXNfdXNlcikKKwkJcGVyZl9jYWxsY2hhaW5fa2VybmVsKHJlZ3MsIGVudHJ5KTsKKworCWlmIChjdXJyZW50LT5tbSkKKwkJcGVyZl9jYWxsY2hhaW5fdXNlcihyZWdzLCBlbnRyeSk7Cit9CisKK3N0cnVjdCBwZXJmX2NhbGxjaGFpbl9lbnRyeSAqcGVyZl9jYWxsY2hhaW4oc3RydWN0IHB0X3JlZ3MgKnJlZ3MpCit7CisJc3RydWN0IHBlcmZfY2FsbGNoYWluX2VudHJ5ICplbnRyeTsKKworCWlmIChpbl9ubWkoKSkKKwkJZW50cnkgPSAmX19nZXRfY3B1X3ZhcihubWlfZW50cnkpOworCWVsc2UKKwkJZW50cnkgPSAmX19nZXRfY3B1X3ZhcihpcnFfZW50cnkpOworCisJZW50cnktPm5yID0gMDsKKwllbnRyeS0+aHYgPSAwOworCWVudHJ5LT5rZXJuZWwgPSAwOworCWVudHJ5LT51c2VyID0gMDsKKworCXBlcmZfZG9fY2FsbGNoYWluKHJlZ3MsIGVudHJ5KTsKKworCXJldHVybiBlbnRyeTsKK30KZGlmZiAtLWdpdCBhL2FyY2gveDg2L2tlcm5lbC9jcHUvcGVyZmN0ci13YXRjaGRvZy5jIGIvYXJjaC94ODYva2VybmVsL2NwdS9wZXJmY3RyLXdhdGNoZG9nLmMKaW5kZXggZjZjNzBhMS4uZDZmNWI5ZiAxMDA2NDQKLS0tIGEvYXJjaC94ODYva2VybmVsL2NwdS9wZXJmY3RyLXdhdGNoZG9nLmMKKysrIGIvYXJjaC94ODYva2VybmVsL2NwdS9wZXJmY3RyLXdhdGNoZG9nLmMKQEAgLTE5LDggKzE5LDggQEAKICNpbmNsdWRlIDxsaW51eC9ubWkuaD4KICNpbmNsdWRlIDxsaW51eC9rcHJvYmVzLmg+CiAKLSNpbmNsdWRlIDxhc20vZ2VuYXBpYy5oPgotI2luY2x1ZGUgPGFzbS9pbnRlbF9hcmNoX3BlcmZtb24uaD4KKyNpbmNsdWRlIDxhc20vYXBpYy5oPgorI2luY2x1ZGUgPGFzbS9wZXJmX2NvdW50ZXIuaD4KIAogc3RydWN0IG5taV93YXRjaGRvZ19jdGxibGsgewogCXVuc2lnbmVkIGludCBjY2NyX21zcjsKZGlmZiAtLWdpdCBhL2FyY2gveDg2L2tlcm5lbC9lbnRyeV82NC5TIGIvYXJjaC94ODYva2VybmVsL2VudHJ5XzY0LlMKaW5kZXggMWMxN2Q3Yy4uYTQ3NDJhMyAxMDA2NDQKLS0tIGEvYXJjaC94ODYva2VybmVsL2VudHJ5XzY0LlMKKysrIGIvYXJjaC94ODYva2VybmVsL2VudHJ5XzY0LlMKQEAgLTEwMTIsNiArMTAxMiwxMSBAQAogYXBpY2ludGVycnVwdCBTUFVSSU9VU19BUElDX1ZFQ1RPUiBcCiAJc3B1cmlvdXNfaW50ZXJydXB0IHNtcF9zcHVyaW91c19pbnRlcnJ1cHQKIAorI2lmZGVmIENPTkZJR19QRVJGX0NPVU5URVJTCithcGljaW50ZXJydXB0IExPQ0FMX1BFTkRJTkdfVkVDVE9SIFwKKwlwZXJmX3BlbmRpbmdfaW50ZXJydXB0IHNtcF9wZXJmX3BlbmRpbmdfaW50ZXJydXB0CisjZW5kaWYKKwogLyoKICAqIEV4Y2VwdGlvbiBlbnRyeSBwb2ludHMuCiAgKi8KZGlmZiAtLWdpdCBhL2FyY2gveDg2L2tlcm5lbC9pcnEuYyBiL2FyY2gveDg2L2tlcm5lbC9pcnEuYwppbmRleCA5YTM5MWJiLi4zODI4N2I1IDEwMDY0NAotLS0gYS9hcmNoL3g4Ni9rZXJuZWwvaXJxLmMKKysrIGIvYXJjaC94ODYva2VybmVsL2lycS5jCkBAIC02Miw2ICs2MiwxNCBAQAogCWZvcl9lYWNoX29ubGluZV9jcHUoaikKIAkJc2VxX3ByaW50ZihwLCAiJTEwdSAiLCBpcnFfc3RhdHMoaiktPmlycV9zcHVyaW91c19jb3VudCk7CiAJc2VxX3ByaW50ZihwLCAiICBTcHVyaW91cyBpbnRlcnJ1cHRzXG4iKTsKKwlzZXFfcHJpbnRmKHAsICIlKnM6ICIsIHByZWMsICJDTlQiKTsKKwlmb3JfZWFjaF9vbmxpbmVfY3B1KGopCisJCXNlcV9wcmludGYocCwgIiUxMHUgIiwgaXJxX3N0YXRzKGopLT5hcGljX3BlcmZfaXJxcyk7CisJc2VxX3ByaW50ZihwLCAiICBQZXJmb3JtYW5jZSBjb3VudGVyIGludGVycnVwdHNcbiIpOworCXNlcV9wcmludGYocCwgIiUqczogIiwgcHJlYywgIlBORCIpOworCWZvcl9lYWNoX29ubGluZV9jcHUoaikKKwkJc2VxX3ByaW50ZihwLCAiJTEwdSAiLCBpcnFfc3RhdHMoaiktPmFwaWNfcGVuZGluZ19pcnFzKTsKKwlzZXFfcHJpbnRmKHAsICIgIFBlcmZvcm1hbmNlIHBlbmRpbmcgd29ya1xuIik7CiAjZW5kaWYKIAlpZiAoZ2VuZXJpY19pbnRlcnJ1cHRfZXh0ZW5zaW9uKSB7CiAJCXNlcV9wcmludGYocCwgIiUqczogIiwgcHJlYywgIlBMVCIpOwpAQCAtMTY1LDYgKzE3Myw4IEBACiAjaWZkZWYgQ09ORklHX1g4Nl9MT0NBTF9BUElDCiAJc3VtICs9IGlycV9zdGF0cyhjcHUpLT5hcGljX3RpbWVyX2lycXM7CiAJc3VtICs9IGlycV9zdGF0cyhjcHUpLT5pcnFfc3B1cmlvdXNfY291bnQ7CisJc3VtICs9IGlycV9zdGF0cyhjcHUpLT5hcGljX3BlcmZfaXJxczsKKwlzdW0gKz0gaXJxX3N0YXRzKGNwdSktPmFwaWNfcGVuZGluZ19pcnFzOwogI2VuZGlmCiAJaWYgKGdlbmVyaWNfaW50ZXJydXB0X2V4dGVuc2lvbikKIAkJc3VtICs9IGlycV9zdGF0cyhjcHUpLT5nZW5lcmljX2lycXM7CmRpZmYgLS1naXQgYS9hcmNoL3g4Ni9rZXJuZWwvaXJxaW5pdC5jIGIvYXJjaC94ODYva2VybmVsL2lycWluaXQuYwppbmRleCAyZTA4YjEwLi4yNjdjNjYyIDEwMDY0NAotLS0gYS9hcmNoL3g4Ni9rZXJuZWwvaXJxaW5pdC5jCisrKyBiL2FyY2gveDg2L2tlcm5lbC9pcnFpbml0LmMKQEAgLTE4MSwxMCArMTgxLDE1IEBACiB7CiAJc21wX2ludHJfaW5pdCgpOwogCi0jaWZkZWYgQ09ORklHX1g4Nl82NAorI2lmZGVmIENPTkZJR19YODZfVEhFUk1BTF9WRUNUT1IKIAlhbGxvY19pbnRyX2dhdGUoVEhFUk1BTF9BUElDX1ZFQ1RPUiwgdGhlcm1hbF9pbnRlcnJ1cHQpOworI2VuZGlmCisjaWZkZWYgQ09ORklHX1g4Nl9USFJFU0hPTEQKIAlhbGxvY19pbnRyX2dhdGUoVEhSRVNIT0xEX0FQSUNfVkVDVE9SLCB0aHJlc2hvbGRfaW50ZXJydXB0KTsKICNlbmRpZgorI2lmIGRlZmluZWQoQ09ORklHX1g4Nl9ORVdfTUNFKSAmJiBkZWZpbmVkKENPTkZJR19YODZfTE9DQUxfQVBJQykKKwlhbGxvY19pbnRyX2dhdGUoTUNFX1NFTEZfVkVDVE9SLCBtY2Vfc2VsZl9pbnRlcnJ1cHQpOworI2VuZGlmCiAKICNpZiBkZWZpbmVkKENPTkZJR19YODZfNjQpIHx8IGRlZmluZWQoQ09ORklHX1g4Nl9MT0NBTF9BUElDKQogCS8qIHNlbGYgZ2VuZXJhdGVkIElQSSBmb3IgbG9jYWwgQVBJQyB0aW1lciAqLwpAQCAtMTk5LDE4ICsyMDQsMTAgQEAKIAogCS8qIFBlcmZvcm1hbmNlIG1vbml0b3JpbmcgaW50ZXJydXB0czogKi8KICMgaWZkZWYgQ09ORklHX1BFUkZfQ09VTlRFUlMKLQlhbGxvY19pbnRyX2dhdGUoTE9DQUxfUEVSRl9WRUNUT1IsIHBlcmZfY291bnRlcl9pbnRlcnJ1cHQpOwogCWFsbG9jX2ludHJfZ2F0ZShMT0NBTF9QRU5ESU5HX1ZFQ1RPUiwgcGVyZl9wZW5kaW5nX2ludGVycnVwdCk7CiAjIGVuZGlmCiAKICNlbmRpZgotCi0jaWZkZWYgQ09ORklHX1g4Nl8zMgotI2lmIGRlZmluZWQoQ09ORklHX1g4Nl9MT0NBTF9BUElDKSAmJiBkZWZpbmVkKENPTkZJR19YODZfTUNFX1A0VEhFUk1BTCkKLQkvKiB0aGVybWFsIG1vbml0b3IgTFZUIGludGVycnVwdCAqLwotCWFsbG9jX2ludHJfZ2F0ZShUSEVSTUFMX0FQSUNfVkVDVE9SLCB0aGVybWFsX2ludGVycnVwdCk7Ci0jZW5kaWYKLSNlbmRpZgogfQogCiAvKioKZGlmZiAtLWdpdCBhL2FyY2gveDg2L2tlcm5lbC9zaWduYWwuYyBiL2FyY2gveDg2L2tlcm5lbC9zaWduYWwuYwppbmRleCAxNDQyNTE2Li4wYTgxM2IxIDEwMDY0NAotLS0gYS9hcmNoL3g4Ni9rZXJuZWwvc2lnbmFsLmMKKysrIGIvYXJjaC94ODYva2VybmVsL3NpZ25hbC5jCkBAIC02LDcgKzYsNiBAQAogICogIDIwMDAtMDYtMjAgIFBlbnRpdW0gSUlJIEZYU1IsIFNTRSBzdXBwb3J0IGJ5IEdhcmV0aCBIdWdoZXMKICAqICAyMDAwLTIwMDIgICB4ODYtNjQgc3VwcG9ydCBieSBBbmRpIEtsZWVuCiAgKi8KLQogI2luY2x1ZGUgPGxpbnV4L3NjaGVkLmg+CiAjaW5jbHVkZSA8bGludXgvbW0uaD4KICNpbmNsdWRlIDxsaW51eC9zbXAuaD4KZGlmZiAtLWdpdCBhL2FyY2gveDg2L2tlcm5lbC9zeXNjYWxsX3RhYmxlXzMyLlMgYi9hcmNoL3g4Ni9rZXJuZWwvc3lzY2FsbF90YWJsZV8zMi5TCmluZGV4IDczNGY5MmMuLmQ1MTMyMWQgMTAwNjQ0Ci0tLSBhL2FyY2gveDg2L2tlcm5lbC9zeXNjYWxsX3RhYmxlXzMyLlMKKysrIGIvYXJjaC94ODYva2VybmVsL3N5c2NhbGxfdGFibGVfMzIuUwpAQCAtMzM1LDMgKzMzNSw0IEBACiAJLmxvbmcgc3lzX3ByZWFkdgogCS5sb25nIHN5c19wd3JpdGV2CiAJLmxvbmcgc3lzX3J0X3Rnc2lncXVldWVpbmZvCS8qIDMzNSAqLworCS5sb25nIHN5c19wZXJmX2NvdW50ZXJfb3BlbgpkaWZmIC0tZ2l0IGEvYXJjaC94ODYva2VybmVsL3RyYXBzLmMgYi9hcmNoL3g4Ni9rZXJuZWwvdHJhcHMuYwppbmRleCBlZGUwMjQ1Li4wN2Q2MGM4IDEwMDY0NAotLS0gYS9hcmNoL3g4Ni9rZXJuZWwvdHJhcHMuYworKysgYi9hcmNoL3g4Ni9rZXJuZWwvdHJhcHMuYwpAQCAtOTQyLDggKzk0MiwxMyBAQAogI2VuZGlmCiAJc2V0X2ludHJfZ2F0ZSgxOSwgJnNpbWRfY29wcm9jZXNzb3JfZXJyb3IpOwogCisJLyogUmVzZXJ2ZSBhbGwgdGhlIGJ1aWx0aW4gYW5kIHRoZSBzeXNjYWxsIHZlY3RvcjogKi8KKwlmb3IgKGkgPSAwOyBpIDwgRklSU1RfRVhURVJOQUxfVkVDVE9SOyBpKyspCisJCXNldF9iaXQoaSwgdXNlZF92ZWN0b3JzKTsKKwogI2lmZGVmIENPTkZJR19JQTMyX0VNVUxBVElPTgogCXNldF9zeXN0ZW1faW50cl9nYXRlKElBMzJfU1lTQ0FMTF9WRUNUT1IsIGlhMzJfc3lzY2FsbCk7CisJc2V0X2JpdChJQTMyX1NZU0NBTExfVkVDVE9SLCB1c2VkX3ZlY3RvcnMpOwogI2VuZGlmCiAKICNpZmRlZiBDT05GSUdfWDg2XzMyCkBAIC05NjAsMTQgKzk2NSw5IEBACiAJfQogCiAJc2V0X3N5c3RlbV90cmFwX2dhdGUoU1lTQ0FMTF9WRUNUT1IsICZzeXN0ZW1fY2FsbCk7CisJc2V0X2JpdChTWVNDQUxMX1ZFQ1RPUiwgdXNlZF92ZWN0b3JzKTsKICNlbmRpZgogCi0JLyogUmVzZXJ2ZSBhbGwgdGhlIGJ1aWx0aW4gYW5kIHRoZSBzeXNjYWxsIHZlY3RvcjogKi8KLQlmb3IgKGkgPSAwOyBpIDwgRklSU1RfRVhURVJOQUxfVkVDVE9SOyBpKyspCi0JCXNldF9iaXQoaSwgdXNlZF92ZWN0b3JzKTsKLQotCXNldF9iaXQoSUEzMl9TWVNDQUxMX1ZFQ1RPUiwgdXNlZF92ZWN0b3JzKTsKLQogCS8qCiAJICogU2hvdWxkIGJlIGEgYmFycmllciBmb3IgYW55IGV4dGVybmFsIENQVSBzdGF0ZToKIAkgKi8KZGlmZiAtLWdpdCBhL2FyY2gveDg2L21tL2ZhdWx0LmMgYi9hcmNoL3g4Ni9tbS9mYXVsdC5jCmluZGV4IDVlYzdhZTMuLmM2YWNjNjMgMTAwNjQ0Ci0tLSBhL2FyY2gveDg2L21tL2ZhdWx0LmMKKysrIGIvYXJjaC94ODYvbW0vZmF1bHQuYwpAQCAtMTAsNiArMTAsNyBAQAogI2luY2x1ZGUgPGxpbnV4L2Jvb3RtZW0uaD4JCS8qIG1heF9sb3dfcGZuCQkJKi8KICNpbmNsdWRlIDxsaW51eC9rcHJvYmVzLmg+CQkvKiBfX2twcm9iZXMsIC4uLgkJKi8KICNpbmNsdWRlIDxsaW51eC9tbWlvdHJhY2UuaD4JCS8qIGttbWlvX2hhbmRsZXIsIC4uLgkJKi8KKyNpbmNsdWRlIDxsaW51eC9wZXJmX2NvdW50ZXIuaD4JCS8qIHBlcmZfc3djb3VudGVyX2V2ZW50CQkqLwogCiAjaW5jbHVkZSA8YXNtL3RyYXBzLmg+CQkJLyogZG90cmFwbGlua2FnZSwgLi4uCQkqLwogI2luY2x1ZGUgPGFzbS9wZ2FsbG9jLmg+CQkvKiBwZ2RfKigpLCAuLi4JCQkqLwpAQCAtMTAxMyw2ICsxMDE0LDggQEAKIAlpZiAodW5saWtlbHkoZXJyb3JfY29kZSAmIFBGX1JTVkQpKQogCQlwZ3RhYmxlX2JhZChyZWdzLCBlcnJvcl9jb2RlLCBhZGRyZXNzKTsKIAorCXBlcmZfc3djb3VudGVyX2V2ZW50KFBFUkZfQ09VTlRfU1dfUEFHRV9GQVVMVFMsIDEsIDAsIHJlZ3MsIGFkZHJlc3MpOworCiAJLyoKIAkgKiBJZiB3ZSdyZSBpbiBhbiBpbnRlcnJ1cHQsIGhhdmUgbm8gdXNlciBjb250ZXh0IG9yIGFyZSBydW5uaW5nCiAJICogaW4gYW4gYXRvbWljIHJlZ2lvbiB0aGVuIHdlIG11c3Qgbm90IHRha2UgdGhlIGZhdWx0OgpAQCAtMTEwNiwxMCArMTEwOSwxNSBAQAogCQlyZXR1cm47CiAJfQogCi0JaWYgKGZhdWx0ICYgVk1fRkFVTFRfTUFKT1IpCisJaWYgKGZhdWx0ICYgVk1fRkFVTFRfTUFKT1IpIHsKIAkJdHNrLT5tYWpfZmx0Kys7Ci0JZWxzZQorCQlwZXJmX3N3Y291bnRlcl9ldmVudChQRVJGX0NPVU5UX1NXX1BBR0VfRkFVTFRTX01BSiwgMSwgMCwKKwkJCQkgICAgIHJlZ3MsIGFkZHJlc3MpOworCX0gZWxzZSB7CiAJCXRzay0+bWluX2ZsdCsrOworCQlwZXJmX3N3Y291bnRlcl9ldmVudChQRVJGX0NPVU5UX1NXX1BBR0VfRkFVTFRTX01JTiwgMSwgMCwKKwkJCQkgICAgIHJlZ3MsIGFkZHJlc3MpOworCX0KIAogCWNoZWNrX3Y4MDg2X21vZGUocmVncywgYWRkcmVzcywgdHNrKTsKIApkaWZmIC0tZ2l0IGEvYXJjaC94ODYvbW0vbWVtdGVzdC5jIGIvYXJjaC94ODYvbW0vbWVtdGVzdC5jCmluZGV4IGMwYmVkY2QuLjE4ZDI0NGYgMTAwNjQ0Ci0tLSBhL2FyY2gveDg2L21tL21lbXRlc3QuYworKysgYi9hcmNoL3g4Ni9tbS9tZW10ZXN0LmMKQEAgLTQwLDIxICs0MCwyMCBAQAogCiBzdGF0aWMgdm9pZCBfX2luaXQgbWVtdGVzdCh1NjQgcGF0dGVybiwgdTY0IHN0YXJ0X3BoeXMsIHU2NCBzaXplKQogewotCXU2NCAqcDsKLQl2b2lkICpzdGFydCwgKmVuZDsKKwl1NjQgKnAsICpzdGFydCwgKmVuZDsKIAl1NjQgc3RhcnRfYmFkLCBsYXN0X2JhZDsKIAl1NjQgc3RhcnRfcGh5c19hbGlnbmVkOwotCXNpemVfdCBpbmNyOworCWNvbnN0IHNpemVfdCBpbmNyID0gc2l6ZW9mKHBhdHRlcm4pOwogCi0JaW5jciA9IHNpemVvZihwYXR0ZXJuKTsKIAlzdGFydF9waHlzX2FsaWduZWQgPSBBTElHTihzdGFydF9waHlzLCBpbmNyKTsKIAlzdGFydCA9IF9fdmEoc3RhcnRfcGh5c19hbGlnbmVkKTsKLQllbmQgPSBzdGFydCArIHNpemUgLSAoc3RhcnRfcGh5c19hbGlnbmVkIC0gc3RhcnRfcGh5cyk7CisJZW5kID0gc3RhcnQgKyAoc2l6ZSAtIChzdGFydF9waHlzX2FsaWduZWQgLSBzdGFydF9waHlzKSkgLyBpbmNyOwogCXN0YXJ0X2JhZCA9IDA7CiAJbGFzdF9iYWQgPSAwOwogCiAJZm9yIChwID0gc3RhcnQ7IHAgPCBlbmQ7IHArKykKIAkJKnAgPSBwYXR0ZXJuOworCiAJZm9yIChwID0gc3RhcnQ7IHAgPCBlbmQ7IHArKywgc3RhcnRfcGh5c19hbGlnbmVkICs9IGluY3IpIHsKIAkJaWYgKCpwID09IHBhdHRlcm4pCiAJCQljb250aW51ZTsKZGlmZiAtLWdpdCBhL2FyY2gveDg2L29wcm9maWxlL25taV9pbnQuYyBiL2FyY2gveDg2L29wcm9maWxlL25taV9pbnQuYwppbmRleCAzYjI4NWU2Li5iMDdkZDhkIDEwMDY0NAotLS0gYS9hcmNoL3g4Ni9vcHJvZmlsZS9ubWlfaW50LmMKKysrIGIvYXJjaC94ODYvb3Byb2ZpbGUvbm1pX2ludC5jCkBAIC00MCw4ICs0MCw5IEBACiAKIAlzd2l0Y2ggKHZhbCkgewogCWNhc2UgRElFX05NSToKLQkJaWYgKG1vZGVsLT5jaGVja19jdHJzKGFyZ3MtPnJlZ3MsICZwZXJfY3B1KGNwdV9tc3JzLCBjcHUpKSkKLQkJCXJldCA9IE5PVElGWV9TVE9QOworCWNhc2UgRElFX05NSV9JUEk6CisJCW1vZGVsLT5jaGVja19jdHJzKGFyZ3MtPnJlZ3MsICZwZXJfY3B1KGNwdV9tc3JzLCBjcHUpKTsKKwkJcmV0ID0gTk9USUZZX1NUT1A7CiAJCWJyZWFrOwogCWRlZmF1bHQ6CiAJCWJyZWFrOwpAQCAtMTM0LDcgKzEzNSw3IEBACiBzdGF0aWMgc3RydWN0IG5vdGlmaWVyX2Jsb2NrIHByb2ZpbGVfZXhjZXB0aW9uc19uYiA9IHsKIAkubm90aWZpZXJfY2FsbCA9IHByb2ZpbGVfZXhjZXB0aW9uc19ub3RpZnksCiAJLm5leHQgPSBOVUxMLAotCS5wcmlvcml0eSA9IDAKKwkucHJpb3JpdHkgPSAyCiB9OwogCiBzdGF0aWMgaW50IG5taV9zZXR1cCh2b2lkKQpkaWZmIC0tZ2l0IGEvYXJjaC94ODYvb3Byb2ZpbGUvb3BfbW9kZWxfcHByby5jIGIvYXJjaC94ODYvb3Byb2ZpbGUvb3BfbW9kZWxfcHByby5jCmluZGV4IDEwMTMxZmIuLjRkYTcyMzAgMTAwNjQ0Ci0tLSBhL2FyY2gveDg2L29wcm9maWxlL29wX21vZGVsX3Bwcm8uYworKysgYi9hcmNoL3g4Ni9vcHJvZmlsZS9vcF9tb2RlbF9wcHJvLmMKQEAgLTE4LDcgKzE4LDcgQEAKICNpbmNsdWRlIDxhc20vbXNyLmg+CiAjaW5jbHVkZSA8YXNtL2FwaWMuaD4KICNpbmNsdWRlIDxhc20vbm1pLmg+Ci0jaW5jbHVkZSA8YXNtL2ludGVsX2FyY2hfcGVyZm1vbi5oPgorI2luY2x1ZGUgPGFzbS9wZXJmX2NvdW50ZXIuaD4KIAogI2luY2x1ZGUgIm9wX3g4Nl9tb2RlbC5oIgogI2luY2x1ZGUgIm9wX2NvdW50ZXIuaCIKQEAgLTEzNiw2ICsxMzYsMTMgQEAKIAl1NjQgdmFsOwogCWludCBpOwogCisJLyoKKwkgKiBUaGlzIGNhbiBoYXBwZW4gaWYgcGVyZiBjb3VudGVycyBhcmUgaW4gdXNlIHdoZW4KKwkgKiB3ZSBzdGVhbCB0aGUgZGllIG5vdGlmaWVyIE5NSS4KKwkgKi8KKwlpZiAodW5saWtlbHkoIXJlc2V0X3ZhbHVlKSkKKwkJZ290byBvdXQ7CisKIAlmb3IgKGkgPSAwIDsgaSA8IG51bV9jb3VudGVyczsgKytpKSB7CiAJCWlmICghcmVzZXRfdmFsdWVbaV0pCiAJCQljb250aW51ZTsKQEAgLTE0Niw2ICsxNTMsNyBAQAogCQl9CiAJfQogCitvdXQ6CiAJLyogT25seSBQNiBiYXNlZCBQZW50aXVtIE0gbmVlZCB0byByZS11bm1hc2sgdGhlIGFwaWMgdmVjdG9yIGJ1dCBpdAogCSAqIGRvZXNuJ3QgaHVydCBvdGhlciBQNiB2YXJpYW50ICovCiAJYXBpY193cml0ZShBUElDX0xWVFBDLCBhcGljX3JlYWQoQVBJQ19MVlRQQykgJiB+QVBJQ19MVlRfTUFTS0VEKTsKZGlmZiAtLWdpdCBhL2FyY2gveDg2L3Zkc28vdmRzbzMyLXNldHVwLmMgYi9hcmNoL3g4Ni92ZHNvL3Zkc28zMi1zZXR1cC5jCmluZGV4IDEyNDFmMTEuLjU4YmMwMGYgMTAwNjQ0Ci0tLSBhL2FyY2gveDg2L3Zkc28vdmRzbzMyLXNldHVwLmMKKysrIGIvYXJjaC94ODYvdmRzby92ZHNvMzItc2V0dXAuYwpAQCAtMzM4LDYgKzMzOCw4IEBACiAJCX0KIAl9CiAKKwljdXJyZW50LT5tbS0+Y29udGV4dC52ZHNvID0gKHZvaWQgKilhZGRyOworCiAJaWYgKGNvbXBhdF91c2VzX3ZtYSB8fCAhY29tcGF0KSB7CiAJCS8qCiAJCSAqIE1BWVdSSVRFIHRvIGFsbG93IGdkYiB0byBDT1cgYW5kIHNldCBicmVha3BvaW50cwpAQCAtMzU4LDExICszNjAsMTMgQEAKIAkJCWdvdG8gdXBfZmFpbDsKIAl9CiAKLQljdXJyZW50LT5tbS0+Y29udGV4dC52ZHNvID0gKHZvaWQgKilhZGRyOwogCWN1cnJlbnRfdGhyZWFkX2luZm8oKS0+c3lzZW50ZXJfcmV0dXJuID0KIAkJVkRTTzMyX1NZTUJPTChhZGRyLCBTWVNFTlRFUl9SRVRVUk4pOwogCiAgIHVwX2ZhaWw6CisJaWYgKHJldCkKKwkJY3VycmVudC0+bW0tPmNvbnRleHQudmRzbyA9IE5VTEw7CisKIAl1cF93cml0ZSgmbW0tPm1tYXBfc2VtKTsKIAogCXJldHVybiByZXQ7CmRpZmYgLS1naXQgYS9hcmNoL3g4Ni92ZHNvL3ZtYS5jIGIvYXJjaC94ODYvdmRzby92bWEuYwppbmRleCBjYWMwODMzLi4yMWUxYWViIDEwMDY0NAotLS0gYS9hcmNoL3g4Ni92ZHNvL3ZtYS5jCisrKyBiL2FyY2gveDg2L3Zkc28vdm1hLmMKQEAgLTExNiwxNSArMTE2LDE4IEBACiAJCWdvdG8gdXBfZmFpbDsKIAl9CiAKKwljdXJyZW50LT5tbS0+Y29udGV4dC52ZHNvID0gKHZvaWQgKilhZGRyOworCiAJcmV0ID0gaW5zdGFsbF9zcGVjaWFsX21hcHBpbmcobW0sIGFkZHIsIHZkc29fc2l6ZSwKIAkJCQkgICAgICBWTV9SRUFEfFZNX0VYRUN8CiAJCQkJICAgICAgVk1fTUFZUkVBRHxWTV9NQVlXUklURXxWTV9NQVlFWEVDfAogCQkJCSAgICAgIFZNX0FMV0FZU0RVTVAsCiAJCQkJICAgICAgdmRzb19wYWdlcyk7Ci0JaWYgKHJldCkKKwlpZiAocmV0KSB7CisJCWN1cnJlbnQtPm1tLT5jb250ZXh0LnZkc28gPSBOVUxMOwogCQlnb3RvIHVwX2ZhaWw7CisJfQogCi0JY3VycmVudC0+bW0tPmNvbnRleHQudmRzbyA9ICh2b2lkICopYWRkcjsKIHVwX2ZhaWw6CiAJdXBfd3JpdGUoJm1tLT5tbWFwX3NlbSk7CiAJcmV0dXJuIHJldDsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvYXRhL2FoY2kuYyBiL2RyaXZlcnMvYXRhL2FoY2kuYwppbmRleCA2YjkxYzI2Li4xNWEyMzAzIDEwMDY0NAotLS0gYS9kcml2ZXJzL2F0YS9haGNpLmMKKysrIGIvZHJpdmVycy9hdGEvYWhjaS5jCkBAIC03Nyw4ICs3Nyw2IEBACiAJCQkgICAgICBzaXplX3Qgc2l6ZSk7CiBzdGF0aWMgc3NpemVfdCBhaGNpX3RyYW5zbWl0X2xlZF9tZXNzYWdlKHN0cnVjdCBhdGFfcG9ydCAqYXAsIHUzMiBzdGF0ZSwKIAkJCQkJc3NpemVfdCBzaXplKTsKLSNkZWZpbmUgTUFYX1NMT1RTIDgKLSNkZWZpbmUgTUFYX1JFVFJZIDE1CiAKIGVudW0gewogCUFIQ0lfUENJX0JBUgkJPSA1LApAQCAtMjMxLDYgKzIyOSwxMCBAQAogCiAJSUNIX01BUAkJCQk9IDB4OTAsIC8qIElDSCBNQVAgcmVnaXN0ZXIgKi8KIAorCS8qIGVtIGNvbnN0YW50cyAqLworCUVNX01BWF9TTE9UUwkJCT0gOCwKKwlFTV9NQVhfUkVUUlkJCQk9IDUsCisKIAkvKiBlbV9jdGwgYml0cyAqLwogCUVNX0NUTF9SU1QJCQk9ICgxIDw8IDkpLCAvKiBSZXNldCAqLwogCUVNX0NUTF9UTQkJCT0gKDEgPDwgOCksIC8qIFRyYW5zbWl0IE1lc3NhZ2UgKi8KQEAgLTI4Miw4ICsyODQsOCBAQAogCXVuc2lnbmVkIGludAkJbmNxX3Nhd19kbWFzOjE7CiAJdW5zaWduZWQgaW50CQluY3Ffc2F3X3NkYjoxOwogCXUzMiAJCQlpbnRyX21hc2s7CS8qIGludGVycnVwdHMgdG8gZW5hYmxlICovCi0Jc3RydWN0IGFoY2lfZW1fcHJpdgllbV9wcml2W01BWF9TTE9UU107LyogZW5jbG9zdXJlIG1hbmFnZW1lbnQgaW5mbwotCQkJCQkgCSAqIHBlciBQTSBzbG90ICovCisJLyogZW5jbG9zdXJlIG1hbmFnZW1lbnQgaW5mbyBwZXIgUE0gc2xvdCAqLworCXN0cnVjdCBhaGNpX2VtX3ByaXYJZW1fcHJpdltFTV9NQVhfU0xPVFNdOwogfTsKIAogc3RhdGljIGludCBhaGNpX3Njcl9yZWFkKHN0cnVjdCBhdGFfbGluayAqbGluaywgdW5zaWduZWQgaW50IHNjX3JlZywgdTMyICp2YWwpOwpAQCAtMzEzLDcgKzMxNSw2IEBACiBzdGF0aWMgdm9pZCBhaGNpX3Bvc3RfaW50ZXJuYWxfY21kKHN0cnVjdCBhdGFfcXVldWVkX2NtZCAqcWMpOwogc3RhdGljIGludCBhaGNpX3BvcnRfcmVzdW1lKHN0cnVjdCBhdGFfcG9ydCAqYXApOwogc3RhdGljIHZvaWQgYWhjaV9kZXZfY29uZmlnKHN0cnVjdCBhdGFfZGV2aWNlICpkZXYpOwotc3RhdGljIHVuc2lnbmVkIGludCBhaGNpX2ZpbGxfc2coc3RydWN0IGF0YV9xdWV1ZWRfY21kICpxYywgdm9pZCAqY21kX3RibCk7CiBzdGF0aWMgdm9pZCBhaGNpX2ZpbGxfY21kX3Nsb3Qoc3RydWN0IGFoY2lfcG9ydF9wcml2ICpwcCwgdW5zaWduZWQgaW50IHRhZywKIAkJCSAgICAgICB1MzIgb3B0cyk7CiAjaWZkZWYgQ09ORklHX1BNCkBAIC00MDQsMTQgKzQwNSwxNCBAQAogI2RlZmluZSBBSENJX0hGTEFHUyhmbGFncykJLnByaXZhdGVfZGF0YQk9ICh2b2lkICopKGZsYWdzKQogCiBzdGF0aWMgY29uc3Qgc3RydWN0IGF0YV9wb3J0X2luZm8gYWhjaV9wb3J0X2luZm9bXSA9IHsKLQkvKiBib2FyZF9haGNpICovCisJW2JvYXJkX2FoY2ldID0KIAl7CiAJCS5mbGFncwkJPSBBSENJX0ZMQUdfQ09NTU9OLAogCQkucGlvX21hc2sJPSBBVEFfUElPNCwKIAkJLnVkbWFfbWFzawk9IEFUQV9VRE1BNiwKIAkJLnBvcnRfb3BzCT0gJmFoY2lfb3BzLAogCX0sCi0JLyogYm9hcmRfYWhjaV92dDgyNTEgKi8KKwlbYm9hcmRfYWhjaV92dDgyNTFdID0KIAl7CiAJCUFIQ0lfSEZMQUdTCShBSENJX0hGTEFHX05PX05DUSB8IEFIQ0lfSEZMQUdfTk9fUE1QKSwKIAkJLmZsYWdzCQk9IEFIQ0lfRkxBR19DT01NT04sCkBAIC00MTksNyArNDIwLDcgQEAKIAkJLnVkbWFfbWFzawk9IEFUQV9VRE1BNiwKIAkJLnBvcnRfb3BzCT0gJmFoY2lfdnQ4MjUxX29wcywKIAl9LAotCS8qIGJvYXJkX2FoY2lfaWduX2lmZXJyICovCisJW2JvYXJkX2FoY2lfaWduX2lmZXJyXSA9CiAJewogCQlBSENJX0hGTEFHUwkoQUhDSV9IRkxBR19JR05fSVJRX0lGX0VSUiksCiAJCS5mbGFncwkJPSBBSENJX0ZMQUdfQ09NTU9OLApAQCAtNDI3LDE3ICs0MjgsMTYgQEAKIAkJLnVkbWFfbWFzawk9IEFUQV9VRE1BNiwKIAkJLnBvcnRfb3BzCT0gJmFoY2lfb3BzLAogCX0sCi0JLyogYm9hcmRfYWhjaV9zYjYwMCAqLworCVtib2FyZF9haGNpX3NiNjAwXSA9CiAJewogCQlBSENJX0hGTEFHUwkoQUhDSV9IRkxBR19JR05fU0VSUl9JTlRFUk5BTCB8Ci0JCQkJIEFIQ0lfSEZMQUdfMzJCSVRfT05MWSB8IEFIQ0lfSEZMQUdfTk9fTVNJIHwKLQkJCQkgQUhDSV9IRkxBR19TRUNUMjU1KSwKKwkJCQkgQUhDSV9IRkxBR19OT19NU0kgfCBBSENJX0hGTEFHX1NFQ1QyNTUpLAogCQkuZmxhZ3MJCT0gQUhDSV9GTEFHX0NPTU1PTiwKIAkJLnBpb19tYXNrCT0gQVRBX1BJTzQsCiAJCS51ZG1hX21hc2sJPSBBVEFfVURNQTYsCiAJCS5wb3J0X29wcwk9ICZhaGNpX3NiNjAwX29wcywKIAl9LAotCS8qIGJvYXJkX2FoY2lfbXYgKi8KKwlbYm9hcmRfYWhjaV9tdl0gPQogCXsKIAkJQUhDSV9IRkxBR1MJKEFIQ0lfSEZMQUdfTk9fTkNRIHwgQUhDSV9IRkxBR19OT19NU0kgfAogCQkJCSBBSENJX0hGTEFHX01WX1BBVEEgfCBBSENJX0hGTEFHX05PX1BNUCksCkBAIC00NDcsNyArNDQ3LDcgQEAKIAkJLnVkbWFfbWFzawk9IEFUQV9VRE1BNiwKIAkJLnBvcnRfb3BzCT0gJmFoY2lfb3BzLAogCX0sCi0JLyogYm9hcmRfYWhjaV9zYjcwMCwgZm9yIFNCNzAwIGFuZCBTQjgwMCAqLworCVtib2FyZF9haGNpX3NiNzAwXSA9CS8qIGZvciBTQjcwMCBhbmQgU0I4MDAgKi8KIAl7CiAJCUFIQ0lfSEZMQUdTCShBSENJX0hGTEFHX0lHTl9TRVJSX0lOVEVSTkFMKSwKIAkJLmZsYWdzCQk9IEFIQ0lfRkxBR19DT01NT04sCkBAIC00NTUsNyArNDU1LDcgQEAKIAkJLnVkbWFfbWFzawk9IEFUQV9VRE1BNiwKIAkJLnBvcnRfb3BzCT0gJmFoY2lfc2I2MDBfb3BzLAogCX0sCi0JLyogYm9hcmRfYWhjaV9tY3A2NSAqLworCVtib2FyZF9haGNpX21jcDY1XSA9CiAJewogCQlBSENJX0hGTEFHUwkoQUhDSV9IRkxBR19ZRVNfTkNRKSwKIAkJLmZsYWdzCQk9IEFIQ0lfRkxBR19DT01NT04sCkBAIC00NjMsNyArNDYzLDcgQEAKIAkJLnVkbWFfbWFzawk9IEFUQV9VRE1BNiwKIAkJLnBvcnRfb3BzCT0gJmFoY2lfb3BzLAogCX0sCi0JLyogYm9hcmRfYWhjaV9ub3BtcCAqLworCVtib2FyZF9haGNpX25vcG1wXSA9CiAJewogCQlBSENJX0hGTEFHUwkoQUhDSV9IRkxBR19OT19QTVApLAogCQkuZmxhZ3MJCT0gQUhDSV9GTEFHX0NPTU1PTiwKQEAgLTExNDEsMTIgKzExNDEsMTIgQEAKIAkJCWVtcCA9ICZwcC0+ZW1fcHJpdltsaW5rLT5wbXBdOwogCiAJCQkvKiBFTSBUcmFuc21pdCBiaXQgbWF5YmUgYnVzeSBkdXJpbmcgaW5pdCAqLwotCQkJZm9yIChpID0gMDsgaSA8IE1BWF9SRVRSWTsgaSsrKSB7CisJCQlmb3IgKGkgPSAwOyBpIDwgRU1fTUFYX1JFVFJZOyBpKyspIHsKIAkJCQlyYyA9IGFoY2lfdHJhbnNtaXRfbGVkX21lc3NhZ2UoYXAsCiAJCQkJCQkJICAgICAgIGVtcC0+bGVkX3N0YXRlLAogCQkJCQkJCSAgICAgICA0KTsKIAkJCQlpZiAocmMgPT0gLUVCVVNZKQotCQkJCQl1ZGVsYXkoMTAwKTsKKwkJCQkJbXNsZWVwKDEpOwogCQkJCWVsc2UKIAkJCQkJYnJlYWs7CiAJCQl9CkBAIC0xMzQwLDcgKzEzNDAsNyBAQAogCiAJLyogZ2V0IHRoZSBzbG90IG51bWJlciBmcm9tIHRoZSBtZXNzYWdlICovCiAJcG1wID0gKHN0YXRlICYgRU1fTVNHX0xFRF9QTVBfU0xPVCkgPj4gODsKLQlpZiAocG1wIDwgTUFYX1NMT1RTKQorCWlmIChwbXAgPCBFTV9NQVhfU0xPVFMpCiAJCWVtcCA9ICZwcC0+ZW1fcHJpdltwbXBdOwogCWVsc2UKIAkJcmV0dXJuIC1FSU5WQUw7CkBAIC0xNDA4LDcgKzE0MDgsNyBAQAogCiAJLyogZ2V0IHRoZSBzbG90IG51bWJlciBmcm9tIHRoZSBtZXNzYWdlICovCiAJcG1wID0gKHN0YXRlICYgRU1fTVNHX0xFRF9QTVBfU0xPVCkgPj4gODsKLQlpZiAocG1wIDwgTUFYX1NMT1RTKQorCWlmIChwbXAgPCBFTV9NQVhfU0xPVFMpCiAJCWVtcCA9ICZwcC0+ZW1fcHJpdltwbXBdOwogCWVsc2UKIAkJcmV0dXJuIC1FSU5WQUw7CkBAIC0yNTg0LDYgKzI1ODQsNTEgQEAKIAl9CiB9CiAKKy8qCisgKiBTQjYwMCBhaGNpIGNvbnRyb2xsZXIgb24gQVNVUyBNMkEtVk0gY2FuJ3QgZG8gNjRiaXQgRE1BIHdpdGggb2xkZXIKKyAqIEJJT1MuICBUaGUgb2xkZXN0IHZlcnNpb24ga25vd24gdG8gYmUgYnJva2VuIGlzIDA5MDEgYW5kIHdvcmtpbmcgaXMKKyAqIDE1MDEgd2hpY2ggd2FzIHJlbGVhc2VkIG9uIDIwMDctMTAtMjYuICBGb3JjZSAzMmJpdCBETUEgb24gYW55dGhpbmcKKyAqIG9sZGVyIHRoYW4gMTUwMS4gIFBsZWFzZSByZWFkIGJrbyM5NDEyIGZvciBtb3JlIGluZm8uCisgKi8KK3N0YXRpYyBib29sIGFoY2lfYXN1c19tMmFfdm1fMzJiaXRfb25seShzdHJ1Y3QgcGNpX2RldiAqcGRldikKK3sKKwlzdGF0aWMgY29uc3Qgc3RydWN0IGRtaV9zeXN0ZW1faWQgc3lzaWRzW10gPSB7CisJCXsKKwkJCS5pZGVudCA9ICJBU1VTIE0yQS1WTSIsCisJCQkubWF0Y2hlcyA9IHsKKwkJCQlETUlfTUFUQ0goRE1JX0JPQVJEX1ZFTkRPUiwKKwkJCQkJICAiQVNVU1RlSyBDb21wdXRlciBJTkMuIiksCisJCQkJRE1JX01BVENIKERNSV9CT0FSRF9OQU1FLCAiTTJBLVZNIiksCisJCQl9LAorCQl9LAorCQl7IH0KKwl9OworCWNvbnN0IGNoYXIgKmN1dG9mZl9tbWRkID0gIjEwLzI2IjsKKwljb25zdCBjaGFyICpkYXRlOworCWludCB5ZWFyOworCisJaWYgKHBkZXYtPmJ1cy0+bnVtYmVyICE9IDAgfHwgcGRldi0+ZGV2Zm4gIT0gUENJX0RFVkZOKDB4MTIsIDApIHx8CisJICAgICFkbWlfY2hlY2tfc3lzdGVtKHN5c2lkcykpCisJCXJldHVybiBmYWxzZTsKKworCS8qCisJICogQXJnaC4uLi4gYm90aCB2ZXJzaW9uIGFuZCBkYXRlIGFyZSBmcmVlIGZvcm0gc3RyaW5ncy4KKwkgKiBMZXQncyBob3BlIHRoZXkncmUgdXNpbmcgdGhlIHNhbWUgZGF0ZSBmb3JtYXQgYWNyb3NzCisJICogZGlmZmVyZW50IHZlcnNpb25zLgorCSAqLworCWRhdGUgPSBkbWlfZ2V0X3N5c3RlbV9pbmZvKERNSV9CSU9TX0RBVEUpOworCXllYXIgPSBkbWlfZ2V0X3llYXIoRE1JX0JJT1NfREFURSk7CisJaWYgKGRhdGUgJiYgc3RybGVuKGRhdGUpID49IDEwICYmIGRhdGVbMl0gPT0gJy8nICYmIGRhdGVbNV0gPT0gJy8nICYmCisJICAgICh5ZWFyID4gMjAwNyB8fAorCSAgICAgKHllYXIgPT0gMjAwNyAmJiBzdHJuY21wKGRhdGUsIGN1dG9mZl9tbWRkLCA1KSA+PSAwKSkpCisJCXJldHVybiBmYWxzZTsKKworCWRldl9wcmludGsoS0VSTl9XQVJOSU5HLCAmcGRldi0+ZGV2LCAiQVNVUyBNMkEtVk06IEJJT1MgdG9vIG9sZCwgIgorCQkgICAiZm9yY2luZyAzMmJpdCBETUEsIHVwZGF0ZSBCSU9TXG4iKTsKKworCXJldHVybiB0cnVlOworfQorCiBzdGF0aWMgYm9vbCBhaGNpX2Jyb2tlbl9zeXN0ZW1fcG93ZXJvZmYoc3RydWN0IHBjaV9kZXYgKnBkZXYpCiB7CiAJc3RhdGljIGNvbnN0IHN0cnVjdCBkbWlfc3lzdGVtX2lkIGJyb2tlbl9zeXN0ZW1zW10gPSB7CkBAIC0yNzQ0LDYgKzI3ODksMTAgQEAKIAlpZiAoYm9hcmRfaWQgPT0gYm9hcmRfYWhjaV9zYjcwMCAmJiBwZGV2LT5yZXZpc2lvbiA+PSAweDQwKQogCQlocHJpdi0+ZmxhZ3MgJj0gfkFIQ0lfSEZMQUdfSUdOX1NFUlJfSU5URVJOQUw7CiAKKwkvKiBhcHBseSBBU1VTIE0yQV9WTSBxdWlyayAqLworCWlmIChhaGNpX2FzdXNfbTJhX3ZtXzMyYml0X29ubHkocGRldikpCisJCWhwcml2LT5mbGFncyB8PSBBSENJX0hGTEFHXzMyQklUX09OTFk7CisKIAlpZiAoIShocHJpdi0+ZmxhZ3MgJiBBSENJX0hGTEFHX05PX01TSSkpCiAJCXBjaV9lbmFibGVfbXNpKHBkZXYpOwogCmRpZmYgLS1naXQgYS9kcml2ZXJzL2F0YS9hdGFfcGlpeC5jIGIvZHJpdmVycy9hdGEvYXRhX3BpaXguYwppbmRleCAxYWViNzA4Li5kMGExNGNmIDEwMDY0NAotLS0gYS9kcml2ZXJzL2F0YS9hdGFfcGlpeC5jCisrKyBiL2RyaXZlcnMvYXRhL2F0YV9waWl4LmMKQEAgLTIyMywxMCArMjIzLDggQEAKIAkvKiBJQ0g4IE1vYmlsZSBQQVRBIENvbnRyb2xsZXIgKi8KIAl7IDB4ODA4NiwgMHgyODUwLCBQQ0lfQU5ZX0lELCBQQ0lfQU5ZX0lELCAwLCAwLCBpY2hfcGF0YV8xMDAgfSwKIAotCS8qIE5PVEU6IFRoZSBmb2xsb3dpbmcgUENJIGlkcyBtdXN0IGJlIGtlcHQgaW4gc3luYyB3aXRoIHRoZQotCSAqIGxpc3QgaW4gZHJpdmVycy9wY2kvcXVpcmtzLmMuCi0JICovCi0KKwkvKiBTQVRBIHBvcnRzICovCisJCiAJLyogODI4MDFFQiAoSUNINSkgKi8KIAl7IDB4ODA4NiwgMHgyNGQxLCBQQ0lfQU5ZX0lELCBQQ0lfQU5ZX0lELCAwLCAwLCBpY2g1X3NhdGEgfSwKIAkvKiA4MjgwMUVCIChJQ0g1KSAqLwpAQCAtMTUwOSw4ICsxNTA3LDggQEAKIAkJZGV2X3ByaW50ayhLRVJOX0RFQlVHLCAmcGRldi0+ZGV2LAogCQkJICAgInZlcnNpb24gIiBEUlZfVkVSU0lPTiAiXG4iKTsKIAotCS8qIG5vIGhvdHBsdWdnaW5nIHN1cHBvcnQgKEZJWE1FKSAqLwotCWlmICghaW5fbW9kdWxlX2luaXQpCisJLyogbm8gaG90cGx1Z2dpbmcgc3VwcG9ydCBmb3IgbGF0ZXIgZGV2aWNlcyAoRklYTUUpICovCisJaWYgKCFpbl9tb2R1bGVfaW5pdCAmJiBlbnQtPmRyaXZlcl9kYXRhID49IGljaDVfc2F0YSkKIAkJcmV0dXJuIC1FTk9ERVY7CiAKIAlpZiAocGlpeF9icm9rZW5fc3lzdGVtX3Bvd2Vyb2ZmKHBkZXYpKSB7CkBAIC0xNTkxLDYgKzE1ODksNyBAQAogCQlob3N0LT5wb3J0c1sxXS0+bXdkbWFfbWFzayA9IDA7CiAJCWhvc3QtPnBvcnRzWzFdLT51ZG1hX21hc2sgPSAwOwogCX0KKwlob3N0LT5mbGFncyB8PSBBVEFfSE9TVF9QQVJBTExFTF9TQ0FOOwogCiAJcGNpX3NldF9tYXN0ZXIocGRldik7CiAJcmV0dXJuIGF0YV9wY2lfc2ZmX2FjdGl2YXRlX2hvc3QoaG9zdCwgYXRhX3NmZl9pbnRlcnJ1cHQsICZwaWl4X3NodCk7CmRpZmYgLS1naXQgYS9kcml2ZXJzL2F0YS9saWJhdGEtY29yZS5jIGIvZHJpdmVycy9hdGEvbGliYXRhLWNvcmUuYwppbmRleCBjOTI0MjMwLi5jYTRkMjA4IDEwMDY0NAotLS0gYS9kcml2ZXJzL2F0YS9saWJhdGEtY29yZS5jCisrKyBiL2RyaXZlcnMvYXRhL2xpYmF0YS1jb3JlLmMKQEAgLTUwMzEsNyArNTAzMSw2IEBACiB7CiAJaW50IG5yX2RvbmUgPSAwOwogCXUzMiBkb25lX21hc2s7Ci0JaW50IGk7CiAKIAlkb25lX21hc2sgPSBhcC0+cWNfYWN0aXZlIF4gcWNfYWN0aXZlOwogCkBAIC01MDQxLDE2ICs1MDQwLDE2IEBACiAJCXJldHVybiAtRUlOVkFMOwogCX0KIAotCWZvciAoaSA9IDA7IGkgPCBBVEFfTUFYX1FVRVVFOyBpKyspIHsKKwl3aGlsZSAoZG9uZV9tYXNrKSB7CiAJCXN0cnVjdCBhdGFfcXVldWVkX2NtZCAqcWM7CisJCXVuc2lnbmVkIGludCB0YWcgPSBfX2Zmcyhkb25lX21hc2spOwogCi0JCWlmICghKGRvbmVfbWFzayAmICgxIDw8IGkpKSkKLQkJCWNvbnRpbnVlOwotCi0JCWlmICgocWMgPSBhdGFfcWNfZnJvbV90YWcoYXAsIGkpKSkgeworCQlxYyA9IGF0YV9xY19mcm9tX3RhZyhhcCwgdGFnKTsKKwkJaWYgKHFjKSB7CiAJCQlhdGFfcWNfY29tcGxldGUocWMpOwogCQkJbnJfZG9uZSsrOwogCQl9CisJCWRvbmVfbWFzayAmPSB+KDEgPDwgdGFnKTsKIAl9CiAKIAlyZXR1cm4gbnJfZG9uZTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvYXRhL2xpYmF0YS1zZmYuYyBiL2RyaXZlcnMvYXRhL2xpYmF0YS1zZmYuYwppbmRleCBiYjE4NDE1Li5iYmJiMWZhIDEwMDY0NAotLS0gYS9kcml2ZXJzL2F0YS9saWJhdGEtc2ZmLmMKKysrIGIvZHJpdmVycy9hdGEvbGliYXRhLXNmZi5jCkBAIC03MjcsMTcgKzcyNywyMyBAQAogCWVsc2UKIAkJaW93cml0ZTE2X3JlcChkYXRhX2FkZHIsIGJ1Ziwgd29yZHMpOwogCi0JLyogVHJhbnNmZXIgdHJhaWxpbmcgMSBieXRlLCBpZiBhbnkuICovCisJLyogVHJhbnNmZXIgdHJhaWxpbmcgYnl0ZSwgaWYgYW55LiAqLwogCWlmICh1bmxpa2VseShidWZsZW4gJiAweDAxKSkgewotCQlfX2xlMTYgYWxpZ25fYnVmWzFdID0geyAwIH07Ci0JCXVuc2lnbmVkIGNoYXIgKnRyYWlsaW5nX2J1ZiA9IGJ1ZiArIGJ1ZmxlbiAtIDE7CisJCXVuc2lnbmVkIGNoYXIgcGFkWzJdOwogCisJCS8qIFBvaW50IGJ1ZiB0byB0aGUgdGFpbCBvZiBidWZmZXIgKi8KKwkJYnVmICs9IGJ1ZmxlbiAtIDE7CisKKwkJLyoKKwkJICogVXNlIGlvKjE2X3JlcCgpIGFjY2Vzc29ycyBoZXJlIGFzIHdlbGwgdG8gYXZvaWQgcG9pbnRsZXNzbHkKKwkJICogc3dhcHBpbmcgYnl0ZXMgdG8gYW5kIGZybyBvbiB0aGUgYmlnIGVuZGlhbiBtYWNoaW5lcy4uLgorCQkgKi8KIAkJaWYgKHJ3ID09IFJFQUQpIHsKLQkJCWFsaWduX2J1ZlswXSA9IGNwdV90b19sZTE2KGlvcmVhZDE2KGRhdGFfYWRkcikpOwotCQkJbWVtY3B5KHRyYWlsaW5nX2J1ZiwgYWxpZ25fYnVmLCAxKTsKKwkJCWlvcmVhZDE2X3JlcChkYXRhX2FkZHIsIHBhZCwgMSk7CisJCQkqYnVmID0gcGFkWzBdOwogCQl9IGVsc2UgewotCQkJbWVtY3B5KGFsaWduX2J1ZiwgdHJhaWxpbmdfYnVmLCAxKTsKLQkJCWlvd3JpdGUxNihsZTE2X3RvX2NwdShhbGlnbl9idWZbMF0pLCBkYXRhX2FkZHIpOworCQkJcGFkWzBdID0gKmJ1ZjsKKwkJCWlvd3JpdGUxNl9yZXAoZGF0YV9hZGRyLCBwYWQsIDEpOwogCQl9CiAJCXdvcmRzKys7CiAJfQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9hdGEvc2F0YV9udi5jIGIvZHJpdmVycy9hdGEvc2F0YV9udi5jCmluZGV4IDZjZGExMmIuLmIyZDExZjMgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvYXRhL3NhdGFfbnYuYworKysgYi9kcml2ZXJzL2F0YS9zYXRhX252LmMKQEAgLTMwNSw4ICszMDUsOCBAQAogc3RhdGljIGludCBudl9zY3JfcmVhZChzdHJ1Y3QgYXRhX2xpbmsgKmxpbmssIHVuc2lnbmVkIGludCBzY19yZWcsIHUzMiAqdmFsKTsKIHN0YXRpYyBpbnQgbnZfc2NyX3dyaXRlKHN0cnVjdCBhdGFfbGluayAqbGluaywgdW5zaWduZWQgaW50IHNjX3JlZywgdTMyIHZhbCk7CiAKLXN0YXRpYyBpbnQgbnZfbm9jbGFzc2lmeV9oYXJkcmVzZXQoc3RydWN0IGF0YV9saW5rICpsaW5rLCB1bnNpZ25lZCBpbnQgKmNsYXNzLAotCQkJCSAgIHVuc2lnbmVkIGxvbmcgZGVhZGxpbmUpOworc3RhdGljIGludCBudl9oYXJkcmVzZXQoc3RydWN0IGF0YV9saW5rICpsaW5rLCB1bnNpZ25lZCBpbnQgKmNsYXNzLAorCQkJdW5zaWduZWQgbG9uZyBkZWFkbGluZSk7CiBzdGF0aWMgdm9pZCBudl9uZjJfZnJlZXplKHN0cnVjdCBhdGFfcG9ydCAqYXApOwogc3RhdGljIHZvaWQgbnZfbmYyX3RoYXcoc3RydWN0IGF0YV9wb3J0ICphcCk7CiBzdGF0aWMgdm9pZCBudl9jazgwNF9mcmVlemUoc3RydWN0IGF0YV9wb3J0ICphcCk7CkBAIC00MDYsNDkgKzQwNiw4MiBAQAogCS5zbGF2ZV9jb25maWd1cmUJPSBudl9zd25jcV9zbGF2ZV9jb25maWcsCiB9OwogCi1zdGF0aWMgc3RydWN0IGF0YV9wb3J0X29wZXJhdGlvbnMgbnZfY29tbW9uX29wcyA9IHsKKy8qCisgKiBOViBTQVRBIGNvbnRyb2xsZXJzIGhhdmUgdmFyaW91cyBkaWZmZXJlbnQgcHJvYmxlbXMgd2l0aCBoYXJkcmVzZXQKKyAqIHByb3RvY29sIGRlcGVuZGluZyBvbiB0aGUgc3BlY2lmaWMgY29udHJvbGxlciBhbmQgZGV2aWNlLgorICoKKyAqIEdFTkVSSUM6CisgKgorICogIGJrbzExMTk1IHJlcG9ydHMgdGhhdCBsaW5rIGRvZXNuJ3QgY29tZSBvbmxpbmUgYWZ0ZXIgaGFyZHJlc2V0IG9uCisgKiAgZ2VuZXJpYyBudidzIGFuZCB0aGVyZSBoYXZlIGJlZW4gc2V2ZXJhbCBvdGhlciBzaW1pbGFyIHJlcG9ydHMgb24KKyAqICBsaW51eC1pZGUuCisgKgorICogIGJrbzEyMzUxI2MyMyByZXBvcnRzIHRoYXQgd2FybXBsdWcgb24gTUNQNjEgZG9lc24ndCB3b3JrIHdpdGgKKyAqICBzb2Z0cmVzZXQuCisgKgorICogTkYyLzM6CisgKgorICogIGJrbzMzNTIgcmVwb3J0cyBuZjIvMyBjb250cm9sbGVycyBjYW4ndCBkZXRlcm1pbmUgZGV2aWNlIHNpZ25hdHVyZQorICogIHJlbGlhYmx5IGFmdGVyIGhhcmRyZXNldC4gIFRoZSBmb2xsb3dpbmcgdGhyZWFkIHJlcG9ydHMgZGV0ZWN0aW9uCisgKiAgZmFpbHVyZSBvbiBjb2xkIGJvb3Qgd2l0aCB0aGUgc3RhbmRhcmQgZGVib3VuY2luZyB0aW1pbmcuCisgKgorICogIGh0dHA6Ly90aHJlYWQuZ21hbmUub3JnL2dtYW5lLmxpbnV4LmlkZS8zNDA5OAorICoKKyAqICBia28xMjE3NiByZXBvcnRzIHRoYXQgaGFyZHJlc2V0IGZhaWxzIHRvIGJyaW5nIHVwIHRoZSBsaW5rIGR1cmluZworICogIGJvb3Qgb24gbmYyLgorICoKKyAqIENLODA0OgorICoKKyAqICBGb3IgaW5pdGlhbCBwcm9iaW5nIGFmdGVyIGJvb3QgYW5kIGhvdCBwbHVnZ2luZywgaGFyZHJlc2V0IG1vc3RseQorICogIHdvcmtzIGZpbmUgb24gQ0s4MDQgYnV0IGN1cmlvdXNseSwgcmVwcm9iaW5nIG9uIHRoZSBpbml0aWFsIHBvcnQKKyAqICBieSByZXNjYW5uaW5nIG9yIHJtbW9kL2luc21vZCBmYWlscyB0byBhY3F1aXJlIHRoZSBpbml0aWFsIEQySCBSZWcKKyAqICBGSVMgaW4gc29tZXdoYXQgdW5kZXRlcm1pbmlzdGljIHdheS4KKyAqCisgKiBTV05DUToKKyAqCisgKiAgYmtvMTIzNTEgcmVwb3J0cyB0aGF0IHdoZW4gU1dOQ1EgaXMgZW5hYmxlZCwgZm9yIGhvdHBsdWcgdG8gd29yaywKKyAqICBoYXJkcmVzZXQgc2hvdWxkIGJlIHVzZWQgYW5kIGhhcmRyZXNldCBjYW4ndCByZXBvcnQgcHJvcGVyCisgKiAgc2lnbmF0dXJlLCB3aGljaCBzdWdnZXN0cyB0aGF0IG1jcDV4IGlzIGNsb3NlciB0byBuZjIgYXMgbG9uZyBhcworICogIHJlc2V0IHF1aXJraW5lc3MgaXMgY29uY2VybmVkLgorICoKKyAqICBia28xMjcwMyByZXBvcnRzIHRoYXQgYm9vdCBwcm9iaW5nIGZhaWxzIGZvciBpbnRlbCBTU0Qgd2l0aAorICogIGhhcmRyZXNldC4gIExpbmsgZmFpbHMgdG8gY29tZSBvbmxpbmUuICBTb2Z0cmVzZXQgd29ya3MgZmluZS4KKyAqCisgKiBUaGUgZmFpbHVyZXMgYXJlIHZhcmllZCBidXQgdGhlIGZvbGxvd2luZyBwYXR0ZXJucyBzZWVtIHRydWUgZm9yCisgKiBhbGwgZmxhdm9ycy4KKyAqCisgKiAtIFNvZnRyZXNldCBkdXJpbmcgYm9vdCBhbHdheXMgd29ya3MuCisgKgorICogLSBIYXJkcmVzZXQgZHVyaW5nIGJvb3Qgc29tZXRpbWVzIGZhaWxzIHRvIGJyaW5nIHVwIHRoZSBsaW5rIG9uCisgKiAgIGNlcnRhaW4gY29taWJuYXRpb25zIGFuZCBkZXZpY2Ugc2lnbmF0dXJlIGFjcXVpc2l0aW9uIGlzCisgKiAgIHVucmVsaWFibGUuCisgKgorICogLSBIYXJkcmVzZXQgaXMgb2Z0ZW4gbmVjZXNzYXJ5IGFmdGVyIGhvdHBsdWcuCisgKgorICogU28sIHByZWZlcnJpbmcgc29mdHJlc2V0IGZvciBib290IHByb2JpbmcgYW5kIGVycm9yIGhhbmRsaW5nIChhcworICogaGFyZHJlc2V0IG1pZ2h0IGJyaW5nIGRvd24gdGhlIGxpbmspIGJ1dCB1c2luZyBoYXJkcmVzZXQgZm9yCisgKiBwb3N0LWJvb3QgcHJvYmluZyBzaG91bGQgd29yayBhcm91bmQgdGhlIGFib3ZlIGlzc3VlcyBpbiBtb3N0CisgKiBjYXNlcy4gIERlZmluZSBudl9oYXJkcmVzZXQoKSB3aGljaCBvbmx5IGtpY2tzIGluIGZvciBwb3N0LWJvb3QKKyAqIHByb2JpbmcgYW5kIHVzZSBpdCBmb3IgYWxsIHZhcmlhbnRzLgorICovCitzdGF0aWMgc3RydWN0IGF0YV9wb3J0X29wZXJhdGlvbnMgbnZfZ2VuZXJpY19vcHMgPSB7CiAJLmluaGVyaXRzCQk9ICZhdGFfYm1kbWFfcG9ydF9vcHMsCiAJLmxvc3RfaW50ZXJydXB0CQk9IEFUQV9PUF9OVUxMLAogCS5zY3JfcmVhZAkJPSBudl9zY3JfcmVhZCwKIAkuc2NyX3dyaXRlCQk9IG52X3Njcl93cml0ZSwKKwkuaGFyZHJlc2V0CQk9IG52X2hhcmRyZXNldCwKIH07CiAKLS8qIE9TREwgYnoxMTE5NSByZXBvcnRzIHRoYXQgbGluayBkb2Vzbid0IGNvbWUgb25saW5lIGFmdGVyIGhhcmRyZXNldAotICogb24gZ2VuZXJpYyBudidzIGFuZCB0aGVyZSBoYXZlIGJlZW4gc2V2ZXJhbCBvdGhlciBzaW1pbGFyIHJlcG9ydHMKLSAqIG9uIGxpbnV4LWlkZS4gIERpc2FibGUgaGFyZHJlc2V0IGZvciBnZW5lcmljIG52J3MuCi0gKi8KLXN0YXRpYyBzdHJ1Y3QgYXRhX3BvcnRfb3BlcmF0aW9ucyBudl9nZW5lcmljX29wcyA9IHsKLQkuaW5oZXJpdHMJCT0gJm52X2NvbW1vbl9vcHMsCi0JLmhhcmRyZXNldAkJPSBBVEFfT1BfTlVMTCwKLX07Ci0KLS8qIG5mMiBpcyByaXBlIHdpdGggaGFyZHJlc2V0IHJlbGF0ZWQgcHJvYmxlbXMuCi0gKgotICoga2VybmVsIGJ6IzMzNTIgcmVwb3J0cyBuZjIvMyBjb250cm9sbGVycyBjYW4ndCBkZXRlcm1pbmUgZGV2aWNlCi0gKiBzaWduYXR1cmUgcmVsaWFibHkuICBUaGUgZm9sbG93aW5nIHRocmVhZCByZXBvcnRzIGRldGVjdGlvbiBmYWlsdXJlCi0gKiBvbiBjb2xkIGJvb3Qgd2l0aCB0aGUgc3RhbmRhcmQgZGVib3VuY2luZyB0aW1pbmcuCi0gKgotICogaHR0cDovL3RocmVhZC5nbWFuZS5vcmcvZ21hbmUubGludXguaWRlLzM0MDk4Ci0gKgotICogQW5kIGJ6IzEyMTc2IHJlcG9ydHMgdGhhdCBoYXJkcmVzZXQgc2ltcGx5IGRvZXNuJ3Qgd29yayBvbiBuZjIuCi0gKiBHaXZlIHVwIG9uIGl0IGFuZCBqdXN0IGRvbid0IGRvIGhhcmRyZXNldC4KLSAqLwogc3RhdGljIHN0cnVjdCBhdGFfcG9ydF9vcGVyYXRpb25zIG52X25mMl9vcHMgPSB7CiAJLmluaGVyaXRzCQk9ICZudl9nZW5lcmljX29wcywKIAkuZnJlZXplCQkJPSBudl9uZjJfZnJlZXplLAogCS50aGF3CQkJPSBudl9uZjJfdGhhdywKIH07CiAKLS8qIEZvciBpbml0aWFsIHByb2JpbmcgYWZ0ZXIgYm9vdCBhbmQgaG90IHBsdWdnaW5nLCBoYXJkcmVzZXQgbW9zdGx5Ci0gKiB3b3JrcyBmaW5lIG9uIENLODA0IGJ1dCBjdXJpb3VzbHksIHJlcHJvYmluZyBvbiB0aGUgaW5pdGlhbCBwb3J0IGJ5Ci0gKiByZXNjYW5uaW5nIG9yIHJtbW9kL2luc21vZCBmYWlscyB0byBhY3F1aXJlIHRoZSBpbml0aWFsIEQySCBSZWcgRklTCi0gKiBpbiBzb21ld2hhdCB1bmRldGVybWluaXN0aWMgd2F5LiAgVXNlIG5vY2xhc3NpZnkgaGFyZHJlc2V0LgotICovCiBzdGF0aWMgc3RydWN0IGF0YV9wb3J0X29wZXJhdGlvbnMgbnZfY2s4MDRfb3BzID0gewotCS5pbmhlcml0cwkJPSAmbnZfY29tbW9uX29wcywKKwkuaW5oZXJpdHMJCT0gJm52X2dlbmVyaWNfb3BzLAogCS5mcmVlemUJCQk9IG52X2NrODA0X2ZyZWV6ZSwKIAkudGhhdwkJCT0gbnZfY2s4MDRfdGhhdywKLQkuaGFyZHJlc2V0CQk9IG52X25vY2xhc3NpZnlfaGFyZHJlc2V0LAogCS5ob3N0X3N0b3AJCT0gbnZfY2s4MDRfaG9zdF9zdG9wLAogfTsKIApAQCAtNDc2LDE5ICs1MDksOCBAQAogCS5ob3N0X3N0b3AJCT0gbnZfYWRtYV9ob3N0X3N0b3AsCiB9OwogCi0vKiBLZXJuZWwgYnojMTIzNTEgcmVwb3J0cyB0aGF0IHdoZW4gU1dOQ1EgaXMgZW5hYmxlZCwgZm9yIGhvdHBsdWcgdG8KLSAqIHdvcmssIGhhcmRyZXNldCBzaG91bGQgYmUgdXNlZCBhbmQgaGFyZHJlc2V0IGNhbid0IHJlcG9ydCBwcm9wZXIKLSAqIHNpZ25hdHVyZSwgd2hpY2ggc3VnZ2VzdHMgdGhhdCBtY3A1eCBpcyBjbG9zZXIgdG8gbmYyIGFzIGxvbmcgYXMKLSAqIHJlc2V0IHF1aXJraW5lc3MgaXMgY29uY2VybmVkLiAgRGVmaW5lIHNlcGFyYXRlIG9wcyBmb3IgbWNwNXggd2l0aAotICogbnZfbm9jbGFzc2lmeV9oYXJkcmVzZXQoKS4KLSAqLwotc3RhdGljIHN0cnVjdCBhdGFfcG9ydF9vcGVyYXRpb25zIG52X21jcDV4X29wcyA9IHsKLQkuaW5oZXJpdHMJCT0gJm52X2NvbW1vbl9vcHMsCi0JLmhhcmRyZXNldAkJPSBudl9ub2NsYXNzaWZ5X2hhcmRyZXNldCwKLX07Ci0KIHN0YXRpYyBzdHJ1Y3QgYXRhX3BvcnRfb3BlcmF0aW9ucyBudl9zd25jcV9vcHMgPSB7Ci0JLmluaGVyaXRzCQk9ICZudl9tY3A1eF9vcHMsCisJLmluaGVyaXRzCQk9ICZudl9nZW5lcmljX29wcywKIAogCS5xY19kZWZlcgkJPSBhdGFfc3RkX3FjX2RlZmVyLAogCS5xY19wcmVwCQk9IG52X3N3bmNxX3FjX3ByZXAsCkBAIC01NTcsNyArNTc5LDcgQEAKIAkJLnBpb19tYXNrCT0gTlZfUElPX01BU0ssCiAJCS5td2RtYV9tYXNrCT0gTlZfTVdETUFfTUFTSywKIAkJLnVkbWFfbWFzawk9IE5WX1VETUFfTUFTSywKLQkJLnBvcnRfb3BzCT0gJm52X21jcDV4X29wcywKKwkJLnBvcnRfb3BzCT0gJm52X2dlbmVyaWNfb3BzLAogCQkucHJpdmF0ZV9kYXRhCT0gTlZfUElfUFJJVihudl9nZW5lcmljX2ludGVycnVwdCwgJm52X3NodCksCiAJfSwKIAkvKiBTV05DUSAqLwpAQCAtMTU1OSwxNSArMTU4MSwyNCBAQAogCXJldHVybiAwOwogfQogCi1zdGF0aWMgaW50IG52X25vY2xhc3NpZnlfaGFyZHJlc2V0KHN0cnVjdCBhdGFfbGluayAqbGluaywgdW5zaWduZWQgaW50ICpjbGFzcywKLQkJCQkgICB1bnNpZ25lZCBsb25nIGRlYWRsaW5lKQorc3RhdGljIGludCBudl9oYXJkcmVzZXQoc3RydWN0IGF0YV9saW5rICpsaW5rLCB1bnNpZ25lZCBpbnQgKmNsYXNzLAorCQkJdW5zaWduZWQgbG9uZyBkZWFkbGluZSkKIHsKLQlib29sIG9ubGluZTsKLQlpbnQgcmM7CisJc3RydWN0IGF0YV9laF9jb250ZXh0ICplaGMgPSAmbGluay0+ZWhfY29udGV4dDsKIAotCXJjID0gc2F0YV9saW5rX2hhcmRyZXNldChsaW5rLCBzYXRhX2RlYl90aW1pbmdfaG90cGx1ZywgZGVhZGxpbmUsCi0JCQkJICZvbmxpbmUsIE5VTEwpOwotCXJldHVybiBvbmxpbmUgPyAtRUFHQUlOIDogcmM7CisJLyogRG8gaGFyZHJlc2V0IGlmZiBpdCdzIHBvc3QtYm9vdCBwcm9iaW5nLCBwbGVhc2UgcmVhZCB0aGUKKwkgKiBjb21tZW50IGFib3ZlIHBvcnQgb3BzIGZvciBkZXRhaWxzLgorCSAqLworCWlmICghKGxpbmstPmFwLT5wZmxhZ3MgJiBBVEFfUEZMQUdfTE9BRElORykgJiYKKwkgICAgIWF0YV9kZXZfZW5hYmxlZChsaW5rLT5kZXZpY2UpKQorCQlzYXRhX2xpbmtfaGFyZHJlc2V0KGxpbmssIHNhdGFfZGViX3RpbWluZ19ob3RwbHVnLCBkZWFkbGluZSwKKwkJCQkgICAgTlVMTCwgTlVMTCk7CisJZWxzZSBpZiAoIShlaGMtPmkuZmxhZ3MgJiBBVEFfRUhJX1FVSUVUKSkKKwkJYXRhX2xpbmtfcHJpbnRrKGxpbmssIEtFUk5fSU5GTywKKwkJCQkibnY6IHNraXBwaW5nIGhhcmRyZXNldCBvbiBvY2N1cGllZCBwb3J0XG4iKTsKKworCS8qIGRldmljZSBzaWduYXR1cmUgYWNxdWlzaXRpb24gaXMgdW5yZWxpYWJsZSAqLworCXJldHVybiAtRUFHQUlOOwogfQogCiBzdGF0aWMgdm9pZCBudl9uZjJfZnJlZXplKHN0cnVjdCBhdGFfcG9ydCAqYXApCmRpZmYgLS1naXQgYS9kcml2ZXJzL2F0YS9zYXRhX3NpbC5jIGIvZHJpdmVycy9hdGEvc2F0YV9zaWwuYwppbmRleCBlNjdjZThlLi4wMzBlYzA3IDEwMDY0NAotLS0gYS9kcml2ZXJzL2F0YS9zYXRhX3NpbC5jCisrKyBiL2RyaXZlcnMvYXRhL3NhdGFfc2lsLmMKQEAgLTE4Myw3ICsxODMsNyBAQAogfTsKIAogc3RhdGljIHN0cnVjdCBhdGFfcG9ydF9vcGVyYXRpb25zIHNpbF9vcHMgPSB7Ci0JLmluaGVyaXRzCQk9ICZhdGFfYm1kbWFfcG9ydF9vcHMsCisJLmluaGVyaXRzCQk9ICZhdGFfYm1kbWEzMl9wb3J0X29wcywKIAkuZGV2X2NvbmZpZwkJPSBzaWxfZGV2X2NvbmZpZywKIAkuc2V0X21vZGUJCT0gc2lsX3NldF9tb2RlLAogCS5ibWRtYV9zZXR1cCAgICAgICAgICAgID0gc2lsX2JtZG1hX3NldHVwLApkaWZmIC0tZ2l0IGEvZHJpdmVycy9hdGEvc2F0YV9zeDQuYyBiL2RyaXZlcnMvYXRhL3NhdGFfc3g0LmMKaW5kZXggZWIwNWEzYy4uYmJjZjk3MCAxMDA2NDQKLS0tIGEvZHJpdmVycy9hdGEvc2F0YV9zeDQuYworKysgYi9kcml2ZXJzL2F0YS9zYXRhX3N4NC5jCkBAIC0xOTMsNiArMTkzLDcgQEAKIAkJCQkJICBQRENfVElNRVJfTUFTS19JTlQsCiB9OwogCisjZGVmaW5lIEVDQ19FUkFTRV9CVUZfU1ogKDEyOCAqIDEwMjQpCiAKIHN0cnVjdCBwZGNfcG9ydF9wcml2IHsKIAl1OAkJCWRpbW1fYnVmWyhBVEFfUFJEX1NaICogQVRBX01BWF9QUkQpICsgNTEyXTsKQEAgLTEyODAsNyArMTI4MSw2IEBACiB7CiAJaW50IHNwZWVkLCBzaXplLCBsZW5ndGg7CiAJdTMyIGFkZHIsIHNwZDAsIHBjaV9zdGF0dXM7Ci0JdTMyIHRtcCA9IDA7CiAJdTMyIHRpbWVfcGVyaW9kID0gMDsKIAl1MzIgdGNvdW50ID0gMDsKIAl1MzIgdGlja3MgPSAwOwpAQCAtMTM5NSwxNCArMTM5NSwxNyBAQAogCXBkYzIwNjIxX2kyY19yZWFkKGhvc3QsIFBEQ19ESU1NMF9TUERfREVWX0FERFJFU1MsCiAJCQkgIFBEQ19ESU1NX1NQRF9UWVBFLCAmc3BkMCk7CiAJaWYgKHNwZDAgPT0gMHgwMikgeworCQl2b2lkICpidWY7CiAJCVZQUklOVEsoIlN0YXJ0IEVDQyBpbml0aWFsaXphdGlvblxuIik7CiAJCWFkZHIgPSAwOwogCQlsZW5ndGggPSBzaXplICogMTAyNCAqIDEwMjQ7CisJCWJ1ZiA9IGt6YWxsb2MoRUNDX0VSQVNFX0JVRl9TWiwgR0ZQX0tFUk5FTCk7CiAJCXdoaWxlIChhZGRyIDwgbGVuZ3RoKSB7Ci0JCQlwZGMyMDYyMV9wdXRfdG9fZGltbShob3N0LCAodm9pZCAqKSAmdG1wLCBhZGRyLAotCQkJCQkgICAgIHNpemVvZih1MzIpKTsKLQkJCWFkZHIgKz0gc2l6ZW9mKHUzMik7CisJCQlwZGMyMDYyMV9wdXRfdG9fZGltbShob3N0LCBidWYsIGFkZHIsCisJCQkJCSAgICAgRUNDX0VSQVNFX0JVRl9TWik7CisJCQlhZGRyICs9IEVDQ19FUkFTRV9CVUZfU1o7CiAJCX0KKwkJa2ZyZWUoYnVmKTsKIAkJVlBSSU5USygiRmluaXNoIEVDQyBpbml0aWFsaXphdGlvblxuIik7CiAJfQogCXJldHVybiAwOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9jaGFyL3N5c3JxLmMgYi9kcml2ZXJzL2NoYXIvc3lzcnEuYwppbmRleCBkNmE4MDdmLi4zOWEwNWI1IDEwMDY0NAotLS0gYS9kcml2ZXJzL2NoYXIvc3lzcnEuYworKysgYi9kcml2ZXJzL2NoYXIvc3lzcnEuYwpAQCAtMjUsNiArMjUsNyBAQAogI2luY2x1ZGUgPGxpbnV4L2tiZF9rZXJuLmg+CiAjaW5jbHVkZSA8bGludXgvcHJvY19mcy5oPgogI2luY2x1ZGUgPGxpbnV4L3F1b3Rhb3BzLmg+CisjaW5jbHVkZSA8bGludXgvcGVyZl9jb3VudGVyLmg+CiAjaW5jbHVkZSA8bGludXgva2VybmVsLmg+CiAjaW5jbHVkZSA8bGludXgvbW9kdWxlLmg+CiAjaW5jbHVkZSA8bGludXgvc3VzcGVuZC5oPgpAQCAtMjQzLDYgKzI0NCw3IEBACiAJc3RydWN0IHB0X3JlZ3MgKnJlZ3MgPSBnZXRfaXJxX3JlZ3MoKTsKIAlpZiAocmVncykKIAkJc2hvd19yZWdzKHJlZ3MpOworCXBlcmZfY291bnRlcl9wcmludF9kZWJ1ZygpOwogfQogc3RhdGljIHN0cnVjdCBzeXNycV9rZXlfb3Agc3lzcnFfc2hvd3JlZ3Nfb3AgPSB7CiAJLmhhbmRsZXIJPSBzeXNycV9oYW5kbGVfc2hvd3JlZ3MsCmRpZmYgLS1naXQgYS9kcml2ZXJzL2NoYXIvdnQuYyBiL2RyaXZlcnMvY2hhci92dC5jCmluZGV4IDA4MTUxZDQuLmRlOWViZWUgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvY2hhci92dC5jCisrKyBiL2RyaXZlcnMvY2hhci92dC5jCkBAIC05NSw3ICs5NSw2IEBACiAjaW5jbHVkZSA8bGludXgvdGltZXIuaD4KICNpbmNsdWRlIDxsaW51eC9pbnRlcnJ1cHQuaD4KICNpbmNsdWRlIDxsaW51eC93b3JrcXVldWUuaD4KLSNpbmNsdWRlIDxsaW51eC9ib290bWVtLmg+CiAjaW5jbHVkZSA8bGludXgvcG0uaD4KICNpbmNsdWRlIDxsaW51eC9mb250Lmg+CiAjaW5jbHVkZSA8bGludXgvYml0b3BzLmg+CkBAIC0xMDQsNiArMTAzLDcgQEAKICNpbmNsdWRlIDxsaW51eC9pby5oPgogI2luY2x1ZGUgPGFzbS9zeXN0ZW0uaD4KICNpbmNsdWRlIDxsaW51eC91YWNjZXNzLmg+CisjaW5jbHVkZSA8bGludXgva21lbWxlYWsuaD4KIAogI2RlZmluZSBNQVhfTlJfQ09OX0RSSVZFUiAxNgogCkBAIC0yODc1LDE0ICsyODc1LDExIEBACiAJCW1vZF90aW1lcigmY29uc29sZV90aW1lciwgamlmZmllcyArIGJsYW5raW50ZXJ2YWwpOwogCX0KIAotCS8qCi0JICoga21hbGxvYyBpcyBub3QgcnVubmluZyB5ZXQgLSB3ZSB1c2UgdGhlIGJvb3RtZW0gYWxsb2NhdG9yLgotCSAqLwogCWZvciAoY3VycmNvbnMgPSAwOyBjdXJyY29ucyA8IE1JTl9OUl9DT05TT0xFUzsgY3VycmNvbnMrKykgewotCQl2Y19jb25zW2N1cnJjb25zXS5kID0gdmMgPSBhbGxvY19ib290bWVtKHNpemVvZihzdHJ1Y3QgdmNfZGF0YSkpOworCQl2Y19jb25zW2N1cnJjb25zXS5kID0gdmMgPSBremFsbG9jKHNpemVvZihzdHJ1Y3QgdmNfZGF0YSksIEdGUF9OT1dBSVQpOwogCQlJTklUX1dPUksoJnZjX2NvbnNbY3VycmNvbnNdLlNBS193b3JrLCB2Y19TQUspOwogCQl2aXN1YWxfaW5pdCh2YywgY3VycmNvbnMsIDEpOwotCQl2Yy0+dmNfc2NyZWVuYnVmID0gKHVuc2lnbmVkIHNob3J0ICopYWxsb2NfYm9vdG1lbSh2Yy0+dmNfc2NyZWVuYnVmX3NpemUpOworCQl2Yy0+dmNfc2NyZWVuYnVmID0ga3phbGxvYyh2Yy0+dmNfc2NyZWVuYnVmX3NpemUsIEdGUF9OT1dBSVQpOwogCQl2Yy0+dmNfa21hbGxvY2VkID0gMDsKIAkJdmNfaW5pdCh2YywgdmMtPnZjX3Jvd3MsIHZjLT52Y19jb2xzLAogCQkJY3VycmNvbnMgfHwgIXZjLT52Y19zdy0+Y29uX3NhdmVfc2NyZWVuKTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvZmlybXdhcmUvZG1pX3NjYW4uYyBiL2RyaXZlcnMvZmlybXdhcmUvZG1pX3NjYW4uYwppbmRleCA1ZjFiNTQwLi4yNGM4NGFlIDEwMDY0NAotLS0gYS9kcml2ZXJzL2Zpcm13YXJlL2RtaV9zY2FuLmMKKysrIGIvZHJpdmVycy9maXJtd2FyZS9kbWlfc2Nhbi5jCkBAIC01OTYsNiArNTk2LDcgQEAKIAogCXJldHVybiB5ZWFyOwogfQorRVhQT1JUX1NZTUJPTChkbWlfZ2V0X3llYXIpOwogCiAvKioKICAqCWRtaV93YWxrIC0gV2FsayB0aGUgRE1JIHRhYmxlIGFuZCBnZXQgY2FsbGVkIGJhY2sgZm9yIGV2ZXJ5IHJlY29yZApkaWZmIC0tZ2l0IGEvZHJpdmVycy92aWRlby9jb25zb2xlL3ZnYWNvbi5jIGIvZHJpdmVycy92aWRlby9jb25zb2xlL3ZnYWNvbi5jCmluZGV4IDM4ZTg2YjguLjU5ZDdkNWUgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvdmlkZW8vY29uc29sZS92Z2Fjb24uYworKysgYi9kcml2ZXJzL3ZpZGVvL2NvbnNvbGUvdmdhY29uLmMKQEAgLTE4MCw3ICsxODAsNyBAQAogfQogCiAjaWZkZWYgQ09ORklHX1ZHQUNPTl9TT0ZUX1NDUk9MTEJBQ0sKLSNpbmNsdWRlIDxsaW51eC9ib290bWVtLmg+CisjaW5jbHVkZSA8bGludXgvc2xhYi5oPgogLyogc29mdHdhcmUgc2Nyb2xsYmFjayAqLwogc3RhdGljIHZvaWQgKnZnYWNvbl9zY3JvbGxiYWNrOwogc3RhdGljIGludCB2Z2Fjb25fc2Nyb2xsYmFja190YWlsOwpAQCAtMjEwLDggKzIxMCw3IEBACiAgKi8KIHN0YXRpYyB2b2lkIF9faW5pdF9yZWZvayB2Z2Fjb25fc2Nyb2xsYmFja19zdGFydHVwKHZvaWQpCiB7Ci0JdmdhY29uX3Njcm9sbGJhY2sgPSBhbGxvY19ib290bWVtKENPTkZJR19WR0FDT05fU09GVF9TQ1JPTExCQUNLX1NJWkUKLQkJCQkJICAqIDEwMjQpOworCXZnYWNvbl9zY3JvbGxiYWNrID0ga2NhbGxvYyhDT05GSUdfVkdBQ09OX1NPRlRfU0NST0xMQkFDS19TSVpFLCAxMDI0LCBHRlBfTk9XQUlUKTsKIAl2Z2Fjb25fc2Nyb2xsYmFja19pbml0KHZnYV92aWRlb19udW1fY29sdW1ucyAqIDIpOwogfQogCmRpZmYgLS1naXQgYS9mcy9ibG9ja19kZXYuYyBiL2ZzL2Jsb2NrX2Rldi5jCmluZGV4IDJkZmM2Y2QuLjkzMWY2YjggMTAwNjQ0Ci0tLSBhL2ZzL2Jsb2NrX2Rldi5jCisrKyBiL2ZzL2Jsb2NrX2Rldi5jCkBAIC0yNSw2ICsyNSw3IEBACiAjaW5jbHVkZSA8bGludXgvdWlvLmg+CiAjaW5jbHVkZSA8bGludXgvbmFtZWkuaD4KICNpbmNsdWRlIDxsaW51eC9sb2cyLmg+CisjaW5jbHVkZSA8bGludXgva21lbWxlYWsuaD4KICNpbmNsdWRlIDxhc20vdWFjY2Vzcy5oPgogI2luY2x1ZGUgImludGVybmFsLmgiCiAKQEAgLTQ5Miw2ICs0OTMsMTEgQEAKIAliZF9tbnQgPSBrZXJuX21vdW50KCZiZF90eXBlKTsKIAlpZiAoSVNfRVJSKGJkX21udCkpCiAJCXBhbmljKCJDYW5ub3QgY3JlYXRlIGJkZXYgcHNldWRvLWZzIik7CisJLyoKKwkgKiBUaGlzIHZmc21vdW50IHN0cnVjdHVyZSBpcyBvbmx5IHVzZWQgdG8gb2J0YWluIHRoZQorCSAqIGJsb2NrZGV2X3N1cGVyYmxvY2ssIHNvIHRlbGwga21lbWxlYWsgbm90IHRvIHJlcG9ydCBpdC4KKwkgKi8KKwlrbWVtbGVha19ub3RfbGVhayhiZF9tbnQpOwogCWJsb2NrZGV2X3N1cGVyYmxvY2sgPSBiZF9tbnQtPm1udF9zYjsJLyogRm9yIHdyaXRlYmFjayAqLwogfQogCmRpZmYgLS1naXQgYS9mcy9leGVjLmMgYi9mcy9leGVjLmMKaW5kZXggYTdmY2Q5Ny4uZTYzOTk1NyAxMDA2NDQKLS0tIGEvZnMvZXhlYy5jCisrKyBiL2ZzL2V4ZWMuYwpAQCAtMzMsNiArMzMsNyBAQAogI2luY2x1ZGUgPGxpbnV4L3N0cmluZy5oPgogI2luY2x1ZGUgPGxpbnV4L2luaXQuaD4KICNpbmNsdWRlIDxsaW51eC9wYWdlbWFwLmg+CisjaW5jbHVkZSA8bGludXgvcGVyZl9jb3VudGVyLmg+CiAjaW5jbHVkZSA8bGludXgvaGlnaG1lbS5oPgogI2luY2x1ZGUgPGxpbnV4L3NwaW5sb2NrLmg+CiAjaW5jbHVkZSA8bGludXgva2V5Lmg+CkBAIC05MjIsNiArOTIzLDcgQEAKIAl0YXNrX2xvY2sodHNrKTsKIAlzdHJsY3B5KHRzay0+Y29tbSwgYnVmLCBzaXplb2YodHNrLT5jb21tKSk7CiAJdGFza191bmxvY2sodHNrKTsKKwlwZXJmX2NvdW50ZXJfY29tbSh0c2spOwogfQogCiBpbnQgZmx1c2hfb2xkX2V4ZWMoc3RydWN0IGxpbnV4X2JpbnBybSAqIGJwcm0pCkBAIC05OTAsNiArOTkyLDEzIEBACiAKIAljdXJyZW50LT5wZXJzb25hbGl0eSAmPSB+YnBybS0+cGVyX2NsZWFyOwogCisJLyoKKwkgKiBGbHVzaCBwZXJmb3JtYW5jZSBjb3VudGVycyB3aGVuIGNyb3NzaW5nIGEKKwkgKiBzZWN1cml0eSBkb21haW46CisJICovCisJaWYgKCFnZXRfZHVtcGFibGUoY3VycmVudC0+bW0pKQorCQlwZXJmX2NvdW50ZXJfZXhpdF90YXNrKGN1cnJlbnQpOworCiAJLyogQW4gZXhlYyBjaGFuZ2VzIG91ciBkb21haW4uIFdlIGFyZSBubyBsb25nZXIgcGFydCBvZiB0aGUgdGhyZWFkCiAJICAgZ3JvdXAgKi8KIApkaWZmIC0tZ2l0IGEvZnMvamZzL2pmc19pbWFwLmMgYi9mcy9qZnMvamZzX2ltYXAuYwppbmRleCAzNDYwNTcyLi4wZmMzMDQwIDEwMDY0NAotLS0gYS9mcy9qZnMvamZzX2ltYXAuYworKysgYi9mcy9qZnMvamZzX2ltYXAuYwpAQCAtMjU3MSw2ICsyNTcxLDcgQEAKIAogCQkJdHhBYm9ydCh0aWQsIDApOwogCQkJdHhFbmQodGlkKTsKKwkJCW11dGV4X3VubG9jaygmSkZTX0lQKGlwaW1hcCktPmNvbW1pdF9tdXRleCk7CiAKIAkJCS8qIHJlbGVhc2UgdGhlIGlub2RlIG1hcCBsb2NrICovCiAJCQlJV1JJVEVfVU5MT0NLKGlwaW1hcCk7CmRpZmYgLS1naXQgYS9mcy9qZnMvc3VwZXIuYyBiL2ZzL2pmcy9zdXBlci5jCmluZGV4IDZmMjFhZGYuLmQ5YjBlOTIgMTAwNjQ0Ci0tLSBhL2ZzL2pmcy9zdXBlci5jCisrKyBiL2ZzL2pmcy9zdXBlci5jCkBAIC03MjAsOCArNzIwLDEwIEBACiAJCWJsaysrOwogCX0KIG91dDoKLQlpZiAobGVuID09IHRvd3JpdGUpCisJaWYgKGxlbiA9PSB0b3dyaXRlKSB7CisJCW11dGV4X3VubG9jaygmaW5vZGUtPmlfbXV0ZXgpOwogCQlyZXR1cm4gZXJyOworCX0KIAlpZiAoaW5vZGUtPmlfc2l6ZSA8IG9mZitsZW4tdG93cml0ZSkKIAkJaV9zaXplX3dyaXRlKGlub2RlLCBvZmYrbGVuLXRvd3JpdGUpOwogCWlub2RlLT5pX3ZlcnNpb24rKzsKZGlmZiAtLWdpdCBhL2luY2x1ZGUvYXNtLWdlbmVyaWMvYXRvbWljLmggYi9pbmNsdWRlL2FzbS1nZW5lcmljL2F0b21pYy5oCmluZGV4IDM2NzNhMTMuLjgxZDNiZTQgMTAwNjQ0Ci0tLSBhL2luY2x1ZGUvYXNtLWdlbmVyaWMvYXRvbWljLmgKKysrIGIvaW5jbHVkZS9hc20tZ2VuZXJpYy9hdG9taWMuaApAQCAtMTM0LDcgKzEzNCw3IEBACiAjZGVmaW5lIGF0b21pY19sb25nX2NtcHhjaGcobCwgb2xkLCBuZXcpIFwKIAkoYXRvbWljNjRfY21weGNoZygoYXRvbWljNjRfdCAqKShsKSwgKG9sZCksIChuZXcpKSkKICNkZWZpbmUgYXRvbWljX2xvbmdfeGNoZyh2LCBuZXcpIFwKLQkoYXRvbWljNjRfeGNoZygoYXRvbWljNjRfdCAqKShsKSwgKG5ldykpKQorCShhdG9taWM2NF94Y2hnKChhdG9taWM2NF90ICopKHYpLCAobmV3KSkpCiAKICNlbHNlICAvKiAgQklUU19QRVJfTE9ORyA9PSA2NCAgKi8KIApkaWZmIC0tZ2l0IGEvaW5jbHVkZS9saW51eC9pbml0X3Rhc2suaCBiL2luY2x1ZGUvbGludXgvaW5pdF90YXNrLmgKaW5kZXggNjY0NmJmYy4uMjhiMWYzMCAxMDA2NDQKLS0tIGEvaW5jbHVkZS9saW51eC9pbml0X3Rhc2suaAorKysgYi9pbmNsdWRlL2xpbnV4L2luaXRfdGFzay5oCkBAIC0xMDgsNiArMTA4LDE1IEBACiAKIGV4dGVybiBzdHJ1Y3QgY3JlZCBpbml0X2NyZWQ7CiAKKyNpZmRlZiBDT05GSUdfUEVSRl9DT1VOVEVSUworIyBkZWZpbmUgSU5JVF9QRVJGX0NPVU5URVJTKHRzaykJCQkJCVwKKwkucGVyZl9jb3VudGVyX211dGV4ID0gCQkJCQkJXAorCQkgX19NVVRFWF9JTklUSUFMSVpFUih0c2sucGVyZl9jb3VudGVyX211dGV4KSwJCVwKKwkucGVyZl9jb3VudGVyX2xpc3QgPSBMSVNUX0hFQURfSU5JVCh0c2sucGVyZl9jb3VudGVyX2xpc3QpLAorI2Vsc2UKKyMgZGVmaW5lIElOSVRfUEVSRl9DT1VOVEVSUyh0c2spCisjZW5kaWYKKwogLyoKICAqICBJTklUX1RBU0sgaXMgdXNlZCB0byBzZXQgdXAgdGhlIGZpcnN0IHRhc2sgdGFibGUsIHRvdWNoIGF0CiAgKiB5b3VyIG93biByaXNrIS4gQmFzZT0wLCBsaW1pdD0weDFmZmZmZiAoPTJNQikKQEAgLTE3MSw2ICsxODAsNyBAQAogCX0sCQkJCQkJCQlcCiAJLmRpcnRpZXMgPSBJTklUX1BST1BfTE9DQUxfU0lOR0xFKGRpcnRpZXMpLAkJCVwKIAlJTklUX0lEUwkJCQkJCQlcCisJSU5JVF9QRVJGX0NPVU5URVJTKHRzaykJCQkJCQlcCiAJSU5JVF9UUkFDRV9JUlFGTEFHUwkJCQkJCVwKIAlJTklUX0xPQ0tERVAJCQkJCQkJXAogCUlOSVRfRlRSQUNFX0dSQVBICQkJCQkJXApkaWZmIC0tZ2l0IGEvaW5jbHVkZS9saW51eC9pcnEuaCBiL2luY2x1ZGUvbGludXgvaXJxLmgKaW5kZXggZWVkYmI4ZS4uMWU1MGMzNGYgMTAwNjQ0Ci0tLSBhL2luY2x1ZGUvbGludXgvaXJxLmgKKysrIGIvaW5jbHVkZS9saW51eC9pcnEuaApAQCAtNDMwLDIzICs0MzAsMTkgQEAKICAqIFJldHVybnMgdHJ1ZSBpZiBzdWNjZXNzZnVsIChvciBub3QgcmVxdWlyZWQpLgogICovCiBzdGF0aWMgaW5saW5lIGJvb2wgYWxsb2NfZGVzY19tYXNrcyhzdHJ1Y3QgaXJxX2Rlc2MgKmRlc2MsIGludCBub2RlLAotCQkJCQkJCQlib29sIGJvb3QpCisJCQkJCQkJYm9vbCBib290KQogeworCWdmcF90IGdmcCA9IEdGUF9BVE9NSUM7CisKKwlpZiAoYm9vdCkKKwkJZ2ZwID0gR0ZQX05PV0FJVDsKKwogI2lmZGVmIENPTkZJR19DUFVNQVNLX09GRlNUQUNLCi0JaWYgKGJvb3QpIHsKLQkJYWxsb2NfYm9vdG1lbV9jcHVtYXNrX3ZhcigmZGVzYy0+YWZmaW5pdHkpOwotCi0jaWZkZWYgQ09ORklHX0dFTkVSSUNfUEVORElOR19JUlEKLQkJYWxsb2NfYm9vdG1lbV9jcHVtYXNrX3ZhcigmZGVzYy0+cGVuZGluZ19tYXNrKTsKLSNlbmRpZgotCQlyZXR1cm4gdHJ1ZTsKLQl9Ci0KLQlpZiAoIWFsbG9jX2NwdW1hc2tfdmFyX25vZGUoJmRlc2MtPmFmZmluaXR5LCBHRlBfQVRPTUlDLCBub2RlKSkKKwlpZiAoIWFsbG9jX2NwdW1hc2tfdmFyX25vZGUoJmRlc2MtPmFmZmluaXR5LCBnZnAsIG5vZGUpKQogCQlyZXR1cm4gZmFsc2U7CiAKICNpZmRlZiBDT05GSUdfR0VORVJJQ19QRU5ESU5HX0lSUQotCWlmICghYWxsb2NfY3B1bWFza192YXJfbm9kZSgmZGVzYy0+cGVuZGluZ19tYXNrLCBHRlBfQVRPTUlDLCBub2RlKSkgeworCWlmICghYWxsb2NfY3B1bWFza192YXJfbm9kZSgmZGVzYy0+cGVuZGluZ19tYXNrLCBnZnAsIG5vZGUpKSB7CiAJCWZyZWVfY3B1bWFza192YXIoZGVzYy0+YWZmaW5pdHkpOwogCQlyZXR1cm4gZmFsc2U7CiAJfQpkaWZmIC0tZ2l0IGEvaW5jbHVkZS9saW51eC9rZXJuZWxfc3RhdC5oIGIvaW5jbHVkZS9saW51eC9rZXJuZWxfc3RhdC5oCmluZGV4IDBjOGI4OWYuLmE3N2M2MDAgMTAwNjQ0Ci0tLSBhL2luY2x1ZGUvbGludXgva2VybmVsX3N0YXQuaAorKysgYi9pbmNsdWRlL2xpbnV4L2tlcm5lbF9zdGF0LmgKQEAgLTgxLDcgKzgxLDEyIEBACiAJcmV0dXJuIHN1bTsKIH0KIAorCisvKgorICogTG9jay91bmxvY2sgdGhlIGN1cnJlbnQgcnVucXVldWUgLSB0byBleHRyYWN0IHRhc2sgc3RhdGlzdGljczoKKyAqLwogZXh0ZXJuIHVuc2lnbmVkIGxvbmcgbG9uZyB0YXNrX2RlbHRhX2V4ZWMoc3RydWN0IHRhc2tfc3RydWN0ICopOworCiBleHRlcm4gdm9pZCBhY2NvdW50X3VzZXJfdGltZShzdHJ1Y3QgdGFza19zdHJ1Y3QgKiwgY3B1dGltZV90LCBjcHV0aW1lX3QpOwogZXh0ZXJuIHZvaWQgYWNjb3VudF9zeXN0ZW1fdGltZShzdHJ1Y3QgdGFza19zdHJ1Y3QgKiwgaW50LCBjcHV0aW1lX3QsIGNwdXRpbWVfdCk7CiBleHRlcm4gdm9pZCBhY2NvdW50X3N0ZWFsX3RpbWUoY3B1dGltZV90KTsKZGlmZiAtLWdpdCBhL2luY2x1ZGUvbGludXgva21lbWxlYWsuaCBiL2luY2x1ZGUvbGludXgva21lbWxlYWsuaApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi43Nzk2YWVkCi0tLSAvZGV2L251bGwKKysrIGIvaW5jbHVkZS9saW51eC9rbWVtbGVhay5oCkBAIC0wLDAgKzEsOTYgQEAKKy8qCisgKiBpbmNsdWRlL2xpbnV4L2ttZW1sZWFrLmgKKyAqCisgKiBDb3B5cmlnaHQgKEMpIDIwMDggQVJNIExpbWl0ZWQKKyAqIFdyaXR0ZW4gYnkgQ2F0YWxpbiBNYXJpbmFzIDxjYXRhbGluLm1hcmluYXNAYXJtLmNvbT4KKyAqCisgKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeQorICogaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSB2ZXJzaW9uIDIgYXMKKyAqIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uLgorICoKKyAqIFRoaXMgcHJvZ3JhbSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLAorICogYnV0IFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKKyAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUKKyAqIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCisgKgorICogWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29weSBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UKKyAqIGFsb25nIHdpdGggdGhpcyBwcm9ncmFtOyBpZiBub3QsIHdyaXRlIHRvIHRoZSBGcmVlIFNvZnR3YXJlCisgKiBGb3VuZGF0aW9uLCBJbmMuLCA1OSBUZW1wbGUgUGxhY2UsIFN1aXRlIDMzMCwgQm9zdG9uLCBNQSAwMjExMS0xMzA3IFVTQQorICovCisKKyNpZm5kZWYgX19LTUVNTEVBS19ICisjZGVmaW5lIF9fS01FTUxFQUtfSAorCisjaWZkZWYgQ09ORklHX0RFQlVHX0tNRU1MRUFLCisKK2V4dGVybiB2b2lkIGttZW1sZWFrX2luaXQodm9pZCk7CitleHRlcm4gdm9pZCBrbWVtbGVha19hbGxvYyhjb25zdCB2b2lkICpwdHIsIHNpemVfdCBzaXplLCBpbnQgbWluX2NvdW50LAorCQkJICAgZ2ZwX3QgZ2ZwKTsKK2V4dGVybiB2b2lkIGttZW1sZWFrX2ZyZWUoY29uc3Qgdm9pZCAqcHRyKTsKK2V4dGVybiB2b2lkIGttZW1sZWFrX3BhZGRpbmcoY29uc3Qgdm9pZCAqcHRyLCB1bnNpZ25lZCBsb25nIG9mZnNldCwKKwkJCSAgICAgc2l6ZV90IHNpemUpOworZXh0ZXJuIHZvaWQga21lbWxlYWtfbm90X2xlYWsoY29uc3Qgdm9pZCAqcHRyKTsKK2V4dGVybiB2b2lkIGttZW1sZWFrX2lnbm9yZShjb25zdCB2b2lkICpwdHIpOworZXh0ZXJuIHZvaWQga21lbWxlYWtfc2Nhbl9hcmVhKGNvbnN0IHZvaWQgKnB0ciwgdW5zaWduZWQgbG9uZyBvZmZzZXQsCisJCQkgICAgICAgc2l6ZV90IGxlbmd0aCwgZ2ZwX3QgZ2ZwKTsKK2V4dGVybiB2b2lkIGttZW1sZWFrX25vX3NjYW4oY29uc3Qgdm9pZCAqcHRyKTsKKworc3RhdGljIGlubGluZSB2b2lkIGttZW1sZWFrX2FsbG9jX3JlY3Vyc2l2ZShjb25zdCB2b2lkICpwdHIsIHNpemVfdCBzaXplLAorCQkJCQkgICAgaW50IG1pbl9jb3VudCwgdW5zaWduZWQgbG9uZyBmbGFncywKKwkJCQkJICAgIGdmcF90IGdmcCkKK3sKKwlpZiAoIShmbGFncyAmIFNMQUJfTk9MRUFLVFJBQ0UpKQorCQlrbWVtbGVha19hbGxvYyhwdHIsIHNpemUsIG1pbl9jb3VudCwgZ2ZwKTsKK30KKworc3RhdGljIGlubGluZSB2b2lkIGttZW1sZWFrX2ZyZWVfcmVjdXJzaXZlKGNvbnN0IHZvaWQgKnB0ciwgdW5zaWduZWQgbG9uZyBmbGFncykKK3sKKwlpZiAoIShmbGFncyAmIFNMQUJfTk9MRUFLVFJBQ0UpKQorCQlrbWVtbGVha19mcmVlKHB0cik7Cit9CisKK3N0YXRpYyBpbmxpbmUgdm9pZCBrbWVtbGVha19lcmFzZSh2b2lkICoqcHRyKQoreworCSpwdHIgPSBOVUxMOworfQorCisjZWxzZQorCitzdGF0aWMgaW5saW5lIHZvaWQga21lbWxlYWtfaW5pdCh2b2lkKQoreworfQorc3RhdGljIGlubGluZSB2b2lkIGttZW1sZWFrX2FsbG9jKGNvbnN0IHZvaWQgKnB0ciwgc2l6ZV90IHNpemUsIGludCBtaW5fY291bnQsCisJCQkJICBnZnBfdCBnZnApCit7Cit9CitzdGF0aWMgaW5saW5lIHZvaWQga21lbWxlYWtfYWxsb2NfcmVjdXJzaXZlKGNvbnN0IHZvaWQgKnB0ciwgc2l6ZV90IHNpemUsCisJCQkJCSAgICBpbnQgbWluX2NvdW50LCB1bnNpZ25lZCBsb25nIGZsYWdzLAorCQkJCQkgICAgZ2ZwX3QgZ2ZwKQoreworfQorc3RhdGljIGlubGluZSB2b2lkIGttZW1sZWFrX2ZyZWUoY29uc3Qgdm9pZCAqcHRyKQoreworfQorc3RhdGljIGlubGluZSB2b2lkIGttZW1sZWFrX2ZyZWVfcmVjdXJzaXZlKGNvbnN0IHZvaWQgKnB0ciwgdW5zaWduZWQgbG9uZyBmbGFncykKK3sKK30KK3N0YXRpYyBpbmxpbmUgdm9pZCBrbWVtbGVha19ub3RfbGVhayhjb25zdCB2b2lkICpwdHIpCit7Cit9CitzdGF0aWMgaW5saW5lIHZvaWQga21lbWxlYWtfaWdub3JlKGNvbnN0IHZvaWQgKnB0cikKK3sKK30KK3N0YXRpYyBpbmxpbmUgdm9pZCBrbWVtbGVha19zY2FuX2FyZWEoY29uc3Qgdm9pZCAqcHRyLCB1bnNpZ25lZCBsb25nIG9mZnNldCwKKwkJCQkgICAgICBzaXplX3QgbGVuZ3RoLCBnZnBfdCBnZnApCit7Cit9CitzdGF0aWMgaW5saW5lIHZvaWQga21lbWxlYWtfZXJhc2Uodm9pZCAqKnB0cikKK3sKK30KK3N0YXRpYyBpbmxpbmUgdm9pZCBrbWVtbGVha19ub19zY2FuKGNvbnN0IHZvaWQgKnB0cikKK3sKK30KKworI2VuZGlmCS8qIENPTkZJR19ERUJVR19LTUVNTEVBSyAqLworCisjZW5kaWYJLyogX19LTUVNTEVBS19IICovCmRpZmYgLS1naXQgYS9pbmNsdWRlL2xpbnV4L3BlcmNwdS5oIGIvaW5jbHVkZS9saW51eC9wZXJjcHUuaAppbmRleCAxNTgxZmYyLi4yNmZkOWQxIDEwMDY0NAotLS0gYS9pbmNsdWRlL2xpbnV4L3BlcmNwdS5oCisrKyBiL2luY2x1ZGUvbGludXgvcGVyY3B1LmgKQEAgLTg2LDcgKzg2LDEyIEBACiAJdm9pZCAqcHRyc1sxXTsKIH07CiAKKy8qIHBvaW50ZXIgZGlzZ3Vpc2luZyBtZXNzZXMgdXAgdGhlIGttZW1sZWFrIG9iamVjdHMgdHJhY2tpbmcgKi8KKyNpZm5kZWYgQ09ORklHX0RFQlVHX0tNRU1MRUFLCiAjZGVmaW5lIF9fcGVyY3B1X2Rpc2d1aXNlKHBkYXRhKSAoc3RydWN0IHBlcmNwdV9kYXRhICopfih1bnNpZ25lZCBsb25nKShwZGF0YSkKKyNlbHNlCisjZGVmaW5lIF9fcGVyY3B1X2Rpc2d1aXNlKHBkYXRhKSAoc3RydWN0IHBlcmNwdV9kYXRhICopKHBkYXRhKQorI2VuZGlmCiAKICNkZWZpbmUgcGVyX2NwdV9wdHIocHRyLCBjcHUpCQkJCQkJXAogKHsJCQkJCQkJCQlcCmRpZmYgLS1naXQgYS9pbmNsdWRlL2xpbnV4L3BlcmZfY291bnRlci5oIGIvaW5jbHVkZS9saW51eC9wZXJmX2NvdW50ZXIuaApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi42ZTEzMzk1Ci0tLSAvZGV2L251bGwKKysrIGIvaW5jbHVkZS9saW51eC9wZXJmX2NvdW50ZXIuaApAQCAtMCwwICsxLDY5NyBAQAorLyoKKyAqICBQZXJmb3JtYW5jZSBjb3VudGVyczoKKyAqCisgKiAgICBDb3B5cmlnaHQgKEMpIDIwMDgtMjAwOSwgVGhvbWFzIEdsZWl4bmVyIDx0Z2x4QGxpbnV0cm9uaXguZGU+CisgKiAgICBDb3B5cmlnaHQgKEMpIDIwMDgtMjAwOSwgUmVkIEhhdCwgSW5jLiwgSW5nbyBNb2xuYXIKKyAqICAgIENvcHlyaWdodCAoQykgMjAwOC0yMDA5LCBSZWQgSGF0LCBJbmMuLCBQZXRlciBaaWpsc3RyYQorICoKKyAqICBEYXRhIHR5cGUgZGVmaW5pdGlvbnMsIGRlY2xhcmF0aW9ucywgcHJvdG90eXBlcy4KKyAqCisgKiAgICBTdGFydGVkIGJ5OiBUaG9tYXMgR2xlaXhuZXIgYW5kIEluZ28gTW9sbmFyCisgKgorICogIEZvciBsaWNlbmNpbmcgZGV0YWlscyBzZWUga2VybmVsLWJhc2UvQ09QWUlORworICovCisjaWZuZGVmIF9MSU5VWF9QRVJGX0NPVU5URVJfSAorI2RlZmluZSBfTElOVVhfUEVSRl9DT1VOVEVSX0gKKworI2luY2x1ZGUgPGxpbnV4L3R5cGVzLmg+CisjaW5jbHVkZSA8bGludXgvaW9jdGwuaD4KKyNpbmNsdWRlIDxhc20vYnl0ZW9yZGVyLmg+CisKKy8qCisgKiBVc2VyLXNwYWNlIEFCSSBiaXRzOgorICovCisKKy8qCisgKiBhdHRyLnR5cGUKKyAqLworZW51bSBwZXJmX3R5cGVfaWQgeworCVBFUkZfVFlQRV9IQVJEV0FSRQkJCT0gMCwKKwlQRVJGX1RZUEVfU09GVFdBUkUJCQk9IDEsCisJUEVSRl9UWVBFX1RSQUNFUE9JTlQJCQk9IDIsCisJUEVSRl9UWVBFX0hXX0NBQ0hFCQkJPSAzLAorCVBFUkZfVFlQRV9SQVcJCQkJPSA0LAorCisJUEVSRl9UWVBFX01BWCwJCQkJLyogbm9uLUFCSSAqLworfTsKKworLyoKKyAqIEdlbmVyYWxpemVkIHBlcmZvcm1hbmNlIGNvdW50ZXIgZXZlbnQgdHlwZXMsIHVzZWQgYnkgdGhlCisgKiBhdHRyLmV2ZW50X2lkIHBhcmFtZXRlciBvZiB0aGUgc3lzX3BlcmZfY291bnRlcl9vcGVuKCkKKyAqIHN5c2NhbGw6CisgKi8KK2VudW0gcGVyZl9od19pZCB7CisJLyoKKwkgKiBDb21tb24gaGFyZHdhcmUgZXZlbnRzLCBnZW5lcmFsaXplZCBieSB0aGUga2VybmVsOgorCSAqLworCVBFUkZfQ09VTlRfSFdfQ1BVX0NZQ0xFUwkJPSAwLAorCVBFUkZfQ09VTlRfSFdfSU5TVFJVQ1RJT05TCQk9IDEsCisJUEVSRl9DT1VOVF9IV19DQUNIRV9SRUZFUkVOQ0VTCQk9IDIsCisJUEVSRl9DT1VOVF9IV19DQUNIRV9NSVNTRVMJCT0gMywKKwlQRVJGX0NPVU5UX0hXX0JSQU5DSF9JTlNUUlVDVElPTlMJPSA0LAorCVBFUkZfQ09VTlRfSFdfQlJBTkNIX01JU1NFUwkJPSA1LAorCVBFUkZfQ09VTlRfSFdfQlVTX0NZQ0xFUwkJPSA2LAorCisJUEVSRl9DT1VOVF9IV19NQVgsCQkJLyogbm9uLUFCSSAqLworfTsKKworLyoKKyAqIEdlbmVyYWxpemVkIGhhcmR3YXJlIGNhY2hlIGNvdW50ZXJzOgorICoKKyAqICAgICAgIHsgTDEtRCwgTDEtSSwgTExDLCBJVExCLCBEVExCLCBCUFUgfSB4CisgKiAgICAgICB7IHJlYWQsIHdyaXRlLCBwcmVmZXRjaCB9IHgKKyAqICAgICAgIHsgYWNjZXNzZXMsIG1pc3NlcyB9CisgKi8KK2VudW0gcGVyZl9od19jYWNoZV9pZCB7CisJUEVSRl9DT1VOVF9IV19DQUNIRV9MMUQJCQk9IDAsCisJUEVSRl9DT1VOVF9IV19DQUNIRV9MMUkJCQk9IDEsCisJUEVSRl9DT1VOVF9IV19DQUNIRV9MTAkJCT0gMiwKKwlQRVJGX0NPVU5UX0hXX0NBQ0hFX0RUTEIJCT0gMywKKwlQRVJGX0NPVU5UX0hXX0NBQ0hFX0lUTEIJCT0gNCwKKwlQRVJGX0NPVU5UX0hXX0NBQ0hFX0JQVQkJCT0gNSwKKworCVBFUkZfQ09VTlRfSFdfQ0FDSEVfTUFYLAkJLyogbm9uLUFCSSAqLworfTsKKworZW51bSBwZXJmX2h3X2NhY2hlX29wX2lkIHsKKwlQRVJGX0NPVU5UX0hXX0NBQ0hFX09QX1JFQUQJCT0gMCwKKwlQRVJGX0NPVU5UX0hXX0NBQ0hFX09QX1dSSVRFCQk9IDEsCisJUEVSRl9DT1VOVF9IV19DQUNIRV9PUF9QUkVGRVRDSAkJPSAyLAorCisJUEVSRl9DT1VOVF9IV19DQUNIRV9PUF9NQVgsCQkvKiBub24tQUJJICovCit9OworCitlbnVtIHBlcmZfaHdfY2FjaGVfb3BfcmVzdWx0X2lkIHsKKwlQRVJGX0NPVU5UX0hXX0NBQ0hFX1JFU1VMVF9BQ0NFU1MJPSAwLAorCVBFUkZfQ09VTlRfSFdfQ0FDSEVfUkVTVUxUX01JU1MJCT0gMSwKKworCVBFUkZfQ09VTlRfSFdfQ0FDSEVfUkVTVUxUX01BWCwJCS8qIG5vbi1BQkkgKi8KK307CisKKy8qCisgKiBTcGVjaWFsICJzb2Z0d2FyZSIgY291bnRlcnMgcHJvdmlkZWQgYnkgdGhlIGtlcm5lbCwgZXZlbiBpZiB0aGUgaGFyZHdhcmUKKyAqIGRvZXMgbm90IHN1cHBvcnQgcGVyZm9ybWFuY2UgY291bnRlcnMuIFRoZXNlIGNvdW50ZXJzIG1lYXN1cmUgdmFyaW91cworICogcGh5c2ljYWwgYW5kIHN3IGV2ZW50cyBvZiB0aGUga2VybmVsIChhbmQgYWxsb3cgdGhlIHByb2ZpbGluZyBvZiB0aGVtIGFzCisgKiB3ZWxsKToKKyAqLworZW51bSBwZXJmX3N3X2lkcyB7CisJUEVSRl9DT1VOVF9TV19DUFVfQ0xPQ0sJCQk9IDAsCisJUEVSRl9DT1VOVF9TV19UQVNLX0NMT0NLCQk9IDEsCisJUEVSRl9DT1VOVF9TV19QQUdFX0ZBVUxUUwkJPSAyLAorCVBFUkZfQ09VTlRfU1dfQ09OVEVYVF9TV0lUQ0hFUwkJPSAzLAorCVBFUkZfQ09VTlRfU1dfQ1BVX01JR1JBVElPTlMJCT0gNCwKKwlQRVJGX0NPVU5UX1NXX1BBR0VfRkFVTFRTX01JTgkJPSA1LAorCVBFUkZfQ09VTlRfU1dfUEFHRV9GQVVMVFNfTUFKCQk9IDYsCisKKwlQRVJGX0NPVU5UX1NXX01BWCwJCQkvKiBub24tQUJJICovCit9OworCisvKgorICogQml0cyB0aGF0IGNhbiBiZSBzZXQgaW4gYXR0ci5zYW1wbGVfdHlwZSB0byByZXF1ZXN0IGluZm9ybWF0aW9uCisgKiBpbiB0aGUgb3ZlcmZsb3cgcGFja2V0cy4KKyAqLworZW51bSBwZXJmX2NvdW50ZXJfc2FtcGxlX2Zvcm1hdCB7CisJUEVSRl9TQU1QTEVfSVAJCQkJPSAxVSA8PCAwLAorCVBFUkZfU0FNUExFX1RJRAkJCQk9IDFVIDw8IDEsCisJUEVSRl9TQU1QTEVfVElNRQkJCT0gMVUgPDwgMiwKKwlQRVJGX1NBTVBMRV9BRERSCQkJPSAxVSA8PCAzLAorCVBFUkZfU0FNUExFX0dST1VQCQkJPSAxVSA8PCA0LAorCVBFUkZfU0FNUExFX0NBTExDSEFJTgkJCT0gMVUgPDwgNSwKKwlQRVJGX1NBTVBMRV9JRAkJCQk9IDFVIDw8IDYsCisJUEVSRl9TQU1QTEVfQ1BVCQkJCT0gMVUgPDwgNywKKwlQRVJGX1NBTVBMRV9QRVJJT0QJCQk9IDFVIDw8IDgsCit9OworCisvKgorICogQml0cyB0aGF0IGNhbiBiZSBzZXQgaW4gYXR0ci5yZWFkX2Zvcm1hdCB0byByZXF1ZXN0IHRoYXQKKyAqIHJlYWRzIG9uIHRoZSBjb3VudGVyIHNob3VsZCByZXR1cm4gdGhlIGluZGljYXRlZCBxdWFudGl0aWVzLAorICogaW4gaW5jcmVhc2luZyBvcmRlciBvZiBiaXQgdmFsdWUsIGFmdGVyIHRoZSBjb3VudGVyIHZhbHVlLgorICovCitlbnVtIHBlcmZfY291bnRlcl9yZWFkX2Zvcm1hdCB7CisJUEVSRl9GT1JNQVRfVE9UQUxfVElNRV9FTkFCTEVECQk9IDFVIDw8IDAsCisJUEVSRl9GT1JNQVRfVE9UQUxfVElNRV9SVU5OSU5HCQk9IDFVIDw8IDEsCisJUEVSRl9GT1JNQVRfSUQJCQkJPSAxVSA8PCAyLAorfTsKKworLyoKKyAqIEhhcmR3YXJlIGV2ZW50IHRvIG1vbml0b3IgdmlhIGEgcGVyZm9ybWFuY2UgbW9uaXRvcmluZyBjb3VudGVyOgorICovCitzdHJ1Y3QgcGVyZl9jb3VudGVyX2F0dHIgeworCS8qCisJICogTWFqb3IgdHlwZTogaGFyZHdhcmUvc29mdHdhcmUvdHJhY2Vwb2ludC9ldGMuCisJICovCisJX191MzIJCQl0eXBlOworCV9fdTMyCQkJX19yZXNlcnZlZF8xOworCisJLyoKKwkgKiBUeXBlIHNwZWNpZmljIGNvbmZpZ3VyYXRpb24gaW5mb3JtYXRpb24uCisJICovCisJX191NjQJCQljb25maWc7CisKKwl1bmlvbiB7CisJCV9fdTY0CQlzYW1wbGVfcGVyaW9kOworCQlfX3U2NAkJc2FtcGxlX2ZyZXE7CisJfTsKKworCV9fdTY0CQkJc2FtcGxlX3R5cGU7CisJX191NjQJCQlyZWFkX2Zvcm1hdDsKKworCV9fdTY0CQkJZGlzYWJsZWQgICAgICAgOiAgMSwgLyogb2ZmIGJ5IGRlZmF1bHQgICAgICAgICovCisJCQkJaW5oZXJpdAkgICAgICAgOiAgMSwgLyogY2hpbGRyZW4gaW5oZXJpdCBpdCAgICovCisJCQkJcGlubmVkCSAgICAgICA6ICAxLCAvKiBtdXN0IGFsd2F5cyBiZSBvbiBQTVUgKi8KKwkJCQlleGNsdXNpdmUgICAgICA6ICAxLCAvKiBvbmx5IGdyb3VwIG9uIFBNVSAgICAgKi8KKwkJCQlleGNsdWRlX3VzZXIgICA6ICAxLCAvKiBkb24ndCBjb3VudCB1c2VyICAgICAgKi8KKwkJCQlleGNsdWRlX2tlcm5lbCA6ICAxLCAvKiBkaXR0byBrZXJuZWwgICAgICAgICAgKi8KKwkJCQlleGNsdWRlX2h2ICAgICA6ICAxLCAvKiBkaXR0byBoeXBlcnZpc29yICAgICAgKi8KKwkJCQlleGNsdWRlX2lkbGUgICA6ICAxLCAvKiBkb24ndCBjb3VudCB3aGVuIGlkbGUgKi8KKwkJCQltbWFwICAgICAgICAgICA6ICAxLCAvKiBpbmNsdWRlIG1tYXAgZGF0YSAgICAgKi8KKwkJCQljb21tCSAgICAgICA6ICAxLCAvKiBpbmNsdWRlIGNvbW0gZGF0YSAgICAgKi8KKwkJCQlmcmVxICAgICAgICAgICA6ICAxLCAvKiB1c2UgZnJlcSwgbm90IHBlcmlvZCAgKi8KKworCQkJCV9fcmVzZXJ2ZWRfMiAgIDogNTM7CisKKwlfX3UzMgkJCXdha2V1cF9ldmVudHM7CS8qIHdha2V1cCBldmVyeSBuIGV2ZW50cyAqLworCV9fdTMyCQkJX19yZXNlcnZlZF8zOworCisJX191NjQJCQlfX3Jlc2VydmVkXzQ7Cit9OworCisvKgorICogSW9jdGxzIHRoYXQgY2FuIGJlIGRvbmUgb24gYSBwZXJmIGNvdW50ZXIgZmQ6CisgKi8KKyNkZWZpbmUgUEVSRl9DT1VOVEVSX0lPQ19FTkFCTEUJCV9JTyAoJyQnLCAwKQorI2RlZmluZSBQRVJGX0NPVU5URVJfSU9DX0RJU0FCTEUJX0lPICgnJCcsIDEpCisjZGVmaW5lIFBFUkZfQ09VTlRFUl9JT0NfUkVGUkVTSAlfSU8gKCckJywgMikKKyNkZWZpbmUgUEVSRl9DT1VOVEVSX0lPQ19SRVNFVAkJX0lPICgnJCcsIDMpCisjZGVmaW5lIFBFUkZfQ09VTlRFUl9JT0NfUEVSSU9ECQlfSU9XKCckJywgNCwgdTY0KQorCitlbnVtIHBlcmZfY291bnRlcl9pb2NfZmxhZ3MgeworCVBFUkZfSU9DX0ZMQUdfR1JPVVAJCT0gMVUgPDwgMCwKK307CisKKy8qCisgKiBTdHJ1Y3R1cmUgb2YgdGhlIHBhZ2UgdGhhdCBjYW4gYmUgbWFwcGVkIHZpYSBtbWFwCisgKi8KK3N0cnVjdCBwZXJmX2NvdW50ZXJfbW1hcF9wYWdlIHsKKwlfX3UzMgl2ZXJzaW9uOwkJLyogdmVyc2lvbiBudW1iZXIgb2YgdGhpcyBzdHJ1Y3R1cmUgKi8KKwlfX3UzMgljb21wYXRfdmVyc2lvbjsJCS8qIGxvd2VzdCB2ZXJzaW9uIHRoaXMgaXMgY29tcGF0IHdpdGggKi8KKworCS8qCisJICogQml0cyBuZWVkZWQgdG8gcmVhZCB0aGUgaHcgY291bnRlcnMgaW4gdXNlci1zcGFjZS4KKwkgKgorCSAqICAgdTMyIHNlcTsKKwkgKiAgIHM2NCBjb3VudDsKKwkgKgorCSAqICAgZG8geworCSAqICAgICBzZXEgPSBwYy0+bG9jazsKKwkgKgorCSAqICAgICBiYXJyaWVyKCkKKwkgKiAgICAgaWYgKHBjLT5pbmRleCkgeworCSAqICAgICAgIGNvdW50ID0gcG1jX3JlYWQocGMtPmluZGV4IC0gMSk7CisJICogICAgICAgY291bnQgKz0gcGMtPm9mZnNldDsKKwkgKiAgICAgfSBlbHNlCisJICogICAgICAgZ290byByZWd1bGFyX3JlYWQ7CisJICoKKwkgKiAgICAgYmFycmllcigpOworCSAqICAgfSB3aGlsZSAocGMtPmxvY2sgIT0gc2VxKTsKKwkgKgorCSAqIE5PVEU6IGZvciBvYnZpb3VzIHJlYXNvbiB0aGlzIG9ubHkgd29ya3Mgb24gc2VsZi1tb25pdG9yaW5nCisJICogICAgICAgcHJvY2Vzc2VzLgorCSAqLworCV9fdTMyCWxvY2s7CQkJLyogc2VxbG9jayBmb3Igc3luY2hyb25pemF0aW9uICovCisJX191MzIJaW5kZXg7CQkJLyogaGFyZHdhcmUgY291bnRlciBpZGVudGlmaWVyICovCisJX19zNjQJb2Zmc2V0OwkJCS8qIGFkZCB0byBoYXJkd2FyZSBjb3VudGVyIHZhbHVlICovCisKKwkvKgorCSAqIENvbnRyb2wgZGF0YSBmb3IgdGhlIG1tYXAoKSBkYXRhIGJ1ZmZlci4KKwkgKgorCSAqIFVzZXItc3BhY2UgcmVhZGluZyB0aGlzIHZhbHVlIHNob3VsZCBpc3N1ZSBhbiBybWIoKSwgb24gU01QIGNhcGFibGUKKwkgKiBwbGF0Zm9ybXMsIGFmdGVyIHJlYWRpbmcgdGhpcyB2YWx1ZSAtLSBzZWUgcGVyZl9jb3VudGVyX3dha2V1cCgpLgorCSAqLworCV9fdTY0ICAgZGF0YV9oZWFkOwkJLyogaGVhZCBpbiB0aGUgZGF0YSBzZWN0aW9uICovCit9OworCisjZGVmaW5lIFBFUkZfRVZFTlRfTUlTQ19DUFVNT0RFX01BU0sJCSgzIDw8IDApCisjZGVmaW5lIFBFUkZfRVZFTlRfTUlTQ19DUFVNT0RFX1VOS05PV04JCSgwIDw8IDApCisjZGVmaW5lIFBFUkZfRVZFTlRfTUlTQ19LRVJORUwJCQkoMSA8PCAwKQorI2RlZmluZSBQRVJGX0VWRU5UX01JU0NfVVNFUgkJCSgyIDw8IDApCisjZGVmaW5lIFBFUkZfRVZFTlRfTUlTQ19IWVBFUlZJU09SCQkoMyA8PCAwKQorI2RlZmluZSBQRVJGX0VWRU5UX01JU0NfT1ZFUkZMT1cJCSgxIDw8IDIpCisKK3N0cnVjdCBwZXJmX2V2ZW50X2hlYWRlciB7CisJX191MzIJdHlwZTsKKwlfX3UxNgltaXNjOworCV9fdTE2CXNpemU7Cit9OworCitlbnVtIHBlcmZfZXZlbnRfdHlwZSB7CisKKwkvKgorCSAqIFRoZSBNTUFQIGV2ZW50cyByZWNvcmQgdGhlIFBST1RfRVhFQyBtYXBwaW5ncyBzbyB0aGF0IHdlIGNhbgorCSAqIGNvcnJlbGF0ZSB1c2Vyc3BhY2UgSVBzIHRvIGNvZGUuIFRoZXkgaGF2ZSB0aGUgZm9sbG93aW5nIHN0cnVjdHVyZToKKwkgKgorCSAqIHN0cnVjdCB7CisJICoJc3RydWN0IHBlcmZfZXZlbnRfaGVhZGVyCWhlYWRlcjsKKwkgKgorCSAqCXUzMgkJCQlwaWQsIHRpZDsKKwkgKgl1NjQJCQkJYWRkcjsKKwkgKgl1NjQJCQkJbGVuOworCSAqCXU2NAkJCQlwZ29mZjsKKwkgKgljaGFyCQkJCWZpbGVuYW1lW107CisJICogfTsKKwkgKi8KKwlQRVJGX0VWRU5UX01NQVAJCQk9IDEsCisKKwkvKgorCSAqIHN0cnVjdCB7CisJICoJc3RydWN0IHBlcmZfZXZlbnRfaGVhZGVyCWhlYWRlcjsKKwkgKgorCSAqCXUzMgkJCQlwaWQsIHRpZDsKKwkgKgljaGFyCQkJCWNvbW1bXTsKKwkgKiB9OworCSAqLworCVBFUkZfRVZFTlRfQ09NTQkJCT0gMywKKworCS8qCisJICogc3RydWN0IHsKKwkgKglzdHJ1Y3QgcGVyZl9ldmVudF9oZWFkZXIJaGVhZGVyOworCSAqCXU2NAkJCQl0aW1lOworCSAqCXU2NAkJCQlpZDsKKwkgKgl1NjQJCQkJc2FtcGxlX3BlcmlvZDsKKwkgKiB9OworCSAqLworCVBFUkZfRVZFTlRfUEVSSU9ECQk9IDQsCisKKwkvKgorCSAqIHN0cnVjdCB7CisJICoJc3RydWN0IHBlcmZfZXZlbnRfaGVhZGVyCWhlYWRlcjsKKwkgKgl1NjQJCQkJdGltZTsKKwkgKgl1NjQJCQkJaWQ7CisJICogfTsKKwkgKi8KKwlQRVJGX0VWRU5UX1RIUk9UVExFCQk9IDUsCisJUEVSRl9FVkVOVF9VTlRIUk9UVExFCQk9IDYsCisKKwkvKgorCSAqIHN0cnVjdCB7CisJICoJc3RydWN0IHBlcmZfZXZlbnRfaGVhZGVyCWhlYWRlcjsKKwkgKgl1MzIJCQkJcGlkLCBwcGlkOworCSAqIH07CisJICovCisJUEVSRl9FVkVOVF9GT1JLCQkJPSA3LAorCisJLyoKKwkgKiBXaGVuIGhlYWRlci5taXNjICYgUEVSRl9FVkVOVF9NSVNDX09WRVJGTE9XIHRoZSBldmVudF90eXBlIGZpZWxkCisJICogd2lsbCBiZSBQRVJGX1JFQ09SRF8qCisJICoKKwkgKiBzdHJ1Y3QgeworCSAqCXN0cnVjdCBwZXJmX2V2ZW50X2hlYWRlcgloZWFkZXI7CisJICoKKwkgKgl7IHU2NAkJCWlwOwkgIH0gJiYgUEVSRl9SRUNPUkRfSVAKKwkgKgl7IHUzMgkJCXBpZCwgdGlkOyB9ICYmIFBFUkZfUkVDT1JEX1RJRAorCSAqCXsgdTY0CQkJdGltZTsgICAgIH0gJiYgUEVSRl9SRUNPUkRfVElNRQorCSAqCXsgdTY0CQkJYWRkcjsgICAgIH0gJiYgUEVSRl9SRUNPUkRfQUREUgorCSAqCXsgdTY0CQkJY29uZmlnOyAgIH0gJiYgUEVSRl9SRUNPUkRfQ09ORklHCisJICoJeyB1MzIJCQljcHUsIHJlczsgfSAmJiBQRVJGX1JFQ09SRF9DUFUKKwkgKgorCSAqCXsgdTY0CQkJbnI7CisJICoJICB7IHU2NCBpZCwgdmFsOyB9CWNudFtucl07ICB9ICYmIFBFUkZfUkVDT1JEX0dST1VQCisJICoKKwkgKgl7IHUxNgkJCW5yLAorCSAqCQkJCWh2LAorCSAqCQkJCWtlcm5lbCwKKwkgKgkJCQl1c2VyOworCSAqCSAgdTY0CQkJaXBzW25yXTsgIH0gJiYgUEVSRl9SRUNPUkRfQ0FMTENIQUlOCisJICogfTsKKwkgKi8KK307CisKKyNpZmRlZiBfX0tFUk5FTF9fCisvKgorICogS2VybmVsLWludGVybmFsIGRhdGEgdHlwZXMgYW5kIGRlZmluaXRpb25zOgorICovCisKKyNpZmRlZiBDT05GSUdfUEVSRl9DT1VOVEVSUworIyBpbmNsdWRlIDxhc20vcGVyZl9jb3VudGVyLmg+CisjZW5kaWYKKworI2luY2x1ZGUgPGxpbnV4L2xpc3QuaD4KKyNpbmNsdWRlIDxsaW51eC9tdXRleC5oPgorI2luY2x1ZGUgPGxpbnV4L3JjdWxpc3QuaD4KKyNpbmNsdWRlIDxsaW51eC9yY3VwZGF0ZS5oPgorI2luY2x1ZGUgPGxpbnV4L3NwaW5sb2NrLmg+CisjaW5jbHVkZSA8bGludXgvaHJ0aW1lci5oPgorI2luY2x1ZGUgPGxpbnV4L2ZzLmg+CisjaW5jbHVkZSA8bGludXgvcGlkX25hbWVzcGFjZS5oPgorI2luY2x1ZGUgPGFzbS9hdG9taWMuaD4KKworc3RydWN0IHRhc2tfc3RydWN0OworCisvKioKKyAqIHN0cnVjdCBod19wZXJmX2NvdW50ZXIgLSBwZXJmb3JtYW5jZSBjb3VudGVyIGhhcmR3YXJlIGRldGFpbHM6CisgKi8KK3N0cnVjdCBod19wZXJmX2NvdW50ZXIgeworI2lmZGVmIENPTkZJR19QRVJGX0NPVU5URVJTCisJdW5pb24geworCQlzdHJ1Y3QgeyAvKiBoYXJkd2FyZSAqLworCQkJdTY0CQljb25maWc7CisJCQl1bnNpZ25lZCBsb25nCWNvbmZpZ19iYXNlOworCQkJdW5zaWduZWQgbG9uZwljb3VudGVyX2Jhc2U7CisJCQlpbnQJCWlkeDsKKwkJfTsKKwkJdW5pb24geyAvKiBzb2Z0d2FyZSAqLworCQkJYXRvbWljNjRfdAljb3VudDsKKwkJCXN0cnVjdCBocnRpbWVyCWhydGltZXI7CisJCX07CisJfTsKKwlhdG9taWM2NF90CQkJcHJldl9jb3VudDsKKwl1NjQJCQkJc2FtcGxlX3BlcmlvZDsKKwl1NjQJCQkJbGFzdF9wZXJpb2Q7CisJYXRvbWljNjRfdAkJCXBlcmlvZF9sZWZ0OworCXU2NAkJCQlpbnRlcnJ1cHRzOworCisJdTY0CQkJCWZyZXFfY291bnQ7CisJdTY0CQkJCWZyZXFfaW50ZXJydXB0czsKKwl1NjQJCQkJZnJlcV9zdGFtcDsKKyNlbmRpZgorfTsKKworc3RydWN0IHBlcmZfY291bnRlcjsKKworLyoqCisgKiBzdHJ1Y3QgcG11IC0gZ2VuZXJpYyBwZXJmb3JtYW5jZSBtb25pdG9yaW5nIHVuaXQKKyAqLworc3RydWN0IHBtdSB7CisJaW50ICgqZW5hYmxlKQkJCShzdHJ1Y3QgcGVyZl9jb3VudGVyICpjb3VudGVyKTsKKwl2b2lkICgqZGlzYWJsZSkJCQkoc3RydWN0IHBlcmZfY291bnRlciAqY291bnRlcik7CisJdm9pZCAoKnJlYWQpCQkJKHN0cnVjdCBwZXJmX2NvdW50ZXIgKmNvdW50ZXIpOworCXZvaWQgKCp1bnRocm90dGxlKQkJKHN0cnVjdCBwZXJmX2NvdW50ZXIgKmNvdW50ZXIpOworfTsKKworLyoqCisgKiBlbnVtIHBlcmZfY291bnRlcl9hY3RpdmVfc3RhdGUgLSB0aGUgc3RhdGVzIG9mIGEgY291bnRlcgorICovCitlbnVtIHBlcmZfY291bnRlcl9hY3RpdmVfc3RhdGUgeworCVBFUkZfQ09VTlRFUl9TVEFURV9FUlJPUgk9IC0yLAorCVBFUkZfQ09VTlRFUl9TVEFURV9PRkYJCT0gLTEsCisJUEVSRl9DT1VOVEVSX1NUQVRFX0lOQUNUSVZFCT0gIDAsCisJUEVSRl9DT1VOVEVSX1NUQVRFX0FDVElWRQk9ICAxLAorfTsKKworc3RydWN0IGZpbGU7CisKK3N0cnVjdCBwZXJmX21tYXBfZGF0YSB7CisJc3RydWN0IHJjdV9oZWFkCQkJcmN1X2hlYWQ7CisJaW50CQkJCW5yX3BhZ2VzOwkvKiBuciBvZiBkYXRhIHBhZ2VzICAqLworCWludAkJCQlucl9sb2NrZWQ7CS8qIG5yIHBhZ2VzIG1sb2NrZWQgICovCisKKwlhdG9taWNfdAkJCXBvbGw7CQkvKiBQT0xMXyBmb3Igd2FrZXVwcyAqLworCWF0b21pY190CQkJZXZlbnRzOwkJLyogZXZlbnQgbGltaXQgICAgICAgKi8KKworCWF0b21pY19sb25nX3QJCQloZWFkOwkJLyogd3JpdGUgcG9zaXRpb24gICAgKi8KKwlhdG9taWNfbG9uZ190CQkJZG9uZV9oZWFkOwkvKiBjb21wbGV0ZWQgaGVhZCAgICAqLworCisJYXRvbWljX3QJCQlsb2NrOwkJLyogY29uY3VycmVudCB3cml0ZXMgKi8KKworCWF0b21pY190CQkJd2FrZXVwOwkJLyogbmVlZHMgYSB3YWtldXAgICAgKi8KKworCXN0cnVjdCBwZXJmX2NvdW50ZXJfbW1hcF9wYWdlICAgKnVzZXJfcGFnZTsKKwl2b2lkCQkJCSpkYXRhX3BhZ2VzWzBdOworfTsKKworc3RydWN0IHBlcmZfcGVuZGluZ19lbnRyeSB7CisJc3RydWN0IHBlcmZfcGVuZGluZ19lbnRyeSAqbmV4dDsKKwl2b2lkICgqZnVuYykoc3RydWN0IHBlcmZfcGVuZGluZ19lbnRyeSAqKTsKK307CisKKy8qKgorICogc3RydWN0IHBlcmZfY291bnRlciAtIHBlcmZvcm1hbmNlIGNvdW50ZXIga2VybmVsIHJlcHJlc2VudGF0aW9uOgorICovCitzdHJ1Y3QgcGVyZl9jb3VudGVyIHsKKyNpZmRlZiBDT05GSUdfUEVSRl9DT1VOVEVSUworCXN0cnVjdCBsaXN0X2hlYWQJCWxpc3RfZW50cnk7CisJc3RydWN0IGxpc3RfaGVhZAkJZXZlbnRfZW50cnk7CisJc3RydWN0IGxpc3RfaGVhZAkJc2libGluZ19saXN0OworCWludAkJCQlucl9zaWJsaW5nczsKKwlzdHJ1Y3QgcGVyZl9jb3VudGVyCQkqZ3JvdXBfbGVhZGVyOworCWNvbnN0IHN0cnVjdCBwbXUJCSpwbXU7CisKKwllbnVtIHBlcmZfY291bnRlcl9hY3RpdmVfc3RhdGUJc3RhdGU7CisJYXRvbWljNjRfdAkJCWNvdW50OworCisJLyoKKwkgKiBUaGVzZSBhcmUgdGhlIHRvdGFsIHRpbWUgaW4gbmFub3NlY29uZHMgdGhhdCB0aGUgY291bnRlcgorCSAqIGhhcyBiZWVuIGVuYWJsZWQgKGkuZS4gZWxpZ2libGUgdG8gcnVuLCBhbmQgdGhlIHRhc2sgaGFzCisJICogYmVlbiBzY2hlZHVsZWQgaW4sIGlmIHRoaXMgaXMgYSBwZXItdGFzayBjb3VudGVyKQorCSAqIGFuZCBydW5uaW5nIChzY2hlZHVsZWQgb250byB0aGUgQ1BVKSwgcmVzcGVjdGl2ZWx5LgorCSAqCisJICogVGhleSBhcmUgY29tcHV0ZWQgZnJvbSB0c3RhbXBfZW5hYmxlZCwgdHN0YW1wX3J1bm5pbmcgYW5kCisJICogdHN0YW1wX3N0b3BwZWQgd2hlbiB0aGUgY291bnRlciBpcyBpbiBJTkFDVElWRSBvciBBQ1RJVkUgc3RhdGUuCisJICovCisJdTY0CQkJCXRvdGFsX3RpbWVfZW5hYmxlZDsKKwl1NjQJCQkJdG90YWxfdGltZV9ydW5uaW5nOworCisJLyoKKwkgKiBUaGVzZSBhcmUgdGltZXN0YW1wcyB1c2VkIGZvciBjb21wdXRpbmcgdG90YWxfdGltZV9lbmFibGVkCisJICogYW5kIHRvdGFsX3RpbWVfcnVubmluZyB3aGVuIHRoZSBjb3VudGVyIGlzIGluIElOQUNUSVZFIG9yCisJICogQUNUSVZFIHN0YXRlLCBtZWFzdXJlZCBpbiBuYW5vc2Vjb25kcyBmcm9tIGFuIGFyYml0cmFyeSBwb2ludAorCSAqIGluIHRpbWUuCisJICogdHN0YW1wX2VuYWJsZWQ6IHRoZSBub3Rpb25hbCB0aW1lIHdoZW4gdGhlIGNvdW50ZXIgd2FzIGVuYWJsZWQKKwkgKiB0c3RhbXBfcnVubmluZzogdGhlIG5vdGlvbmFsIHRpbWUgd2hlbiB0aGUgY291bnRlciB3YXMgc2NoZWR1bGVkIG9uCisJICogdHN0YW1wX3N0b3BwZWQ6IGluIElOQUNUSVZFIHN0YXRlLCB0aGUgbm90aW9uYWwgdGltZSB3aGVuIHRoZQorCSAqCWNvdW50ZXIgd2FzIHNjaGVkdWxlZCBvZmYuCisJICovCisJdTY0CQkJCXRzdGFtcF9lbmFibGVkOworCXU2NAkJCQl0c3RhbXBfcnVubmluZzsKKwl1NjQJCQkJdHN0YW1wX3N0b3BwZWQ7CisKKwlzdHJ1Y3QgcGVyZl9jb3VudGVyX2F0dHIJYXR0cjsKKwlzdHJ1Y3QgaHdfcGVyZl9jb3VudGVyCQlodzsKKworCXN0cnVjdCBwZXJmX2NvdW50ZXJfY29udGV4dAkqY3R4OworCXN0cnVjdCBmaWxlCQkJKmZpbHA7CisKKwkvKgorCSAqIFRoZXNlIGFjY3VtdWxhdGUgdG90YWwgdGltZSAoaW4gbmFub3NlY29uZHMpIHRoYXQgY2hpbGRyZW4KKwkgKiBjb3VudGVycyBoYXZlIGJlZW4gZW5hYmxlZCBhbmQgcnVubmluZywgcmVzcGVjdGl2ZWx5LgorCSAqLworCWF0b21pYzY0X3QJCQljaGlsZF90b3RhbF90aW1lX2VuYWJsZWQ7CisJYXRvbWljNjRfdAkJCWNoaWxkX3RvdGFsX3RpbWVfcnVubmluZzsKKworCS8qCisJICogUHJvdGVjdCBhdHRhY2gvZGV0YWNoIGFuZCBjaGlsZF9saXN0OgorCSAqLworCXN0cnVjdCBtdXRleAkJCWNoaWxkX211dGV4OworCXN0cnVjdCBsaXN0X2hlYWQJCWNoaWxkX2xpc3Q7CisJc3RydWN0IHBlcmZfY291bnRlcgkJKnBhcmVudDsKKworCWludAkJCQlvbmNwdTsKKwlpbnQJCQkJY3B1OworCisJc3RydWN0IGxpc3RfaGVhZAkJb3duZXJfZW50cnk7CisJc3RydWN0IHRhc2tfc3RydWN0CQkqb3duZXI7CisKKwkvKiBtbWFwIGJpdHMgKi8KKwlzdHJ1Y3QgbXV0ZXgJCQltbWFwX211dGV4OworCWF0b21pY190CQkJbW1hcF9jb3VudDsKKwlzdHJ1Y3QgcGVyZl9tbWFwX2RhdGEJCSpkYXRhOworCisJLyogcG9sbCByZWxhdGVkICovCisJd2FpdF9xdWV1ZV9oZWFkX3QJCXdhaXRxOworCXN0cnVjdCBmYXN5bmNfc3RydWN0CQkqZmFzeW5jOworCisJLyogZGVsYXllZCB3b3JrIGZvciBOTUlzIGFuZCBzdWNoICovCisJaW50CQkJCXBlbmRpbmdfd2FrZXVwOworCWludAkJCQlwZW5kaW5nX2tpbGw7CisJaW50CQkJCXBlbmRpbmdfZGlzYWJsZTsKKwlzdHJ1Y3QgcGVyZl9wZW5kaW5nX2VudHJ5CXBlbmRpbmc7CisKKwlhdG9taWNfdAkJCWV2ZW50X2xpbWl0OworCisJdm9pZCAoKmRlc3Ryb3kpKHN0cnVjdCBwZXJmX2NvdW50ZXIgKik7CisJc3RydWN0IHJjdV9oZWFkCQkJcmN1X2hlYWQ7CisKKwlzdHJ1Y3QgcGlkX25hbWVzcGFjZQkJKm5zOworCXU2NAkJCQlpZDsKKyNlbmRpZgorfTsKKworLyoqCisgKiBzdHJ1Y3QgcGVyZl9jb3VudGVyX2NvbnRleHQgLSBjb3VudGVyIGNvbnRleHQgc3RydWN0dXJlCisgKgorICogVXNlZCBhcyBhIGNvbnRhaW5lciBmb3IgdGFzayBjb3VudGVycyBhbmQgQ1BVIGNvdW50ZXJzIGFzIHdlbGw6CisgKi8KK3N0cnVjdCBwZXJmX2NvdW50ZXJfY29udGV4dCB7CisJLyoKKwkgKiBQcm90ZWN0IHRoZSBzdGF0ZXMgb2YgdGhlIGNvdW50ZXJzIGluIHRoZSBsaXN0LAorCSAqIG5yX2FjdGl2ZSwgYW5kIHRoZSBsaXN0OgorCSAqLworCXNwaW5sb2NrX3QJCQlsb2NrOworCS8qCisJICogUHJvdGVjdCB0aGUgbGlzdCBvZiBjb3VudGVycy4gIExvY2tpbmcgZWl0aGVyIG11dGV4IG9yIGxvY2sKKwkgKiBpcyBzdWZmaWNpZW50IHRvIGVuc3VyZSB0aGUgbGlzdCBkb2Vzbid0IGNoYW5nZTsgdG8gY2hhbmdlCisJICogdGhlIGxpc3QgeW91IG5lZWQgdG8gbG9jayBib3RoIHRoZSBtdXRleCBhbmQgdGhlIHNwaW5sb2NrLgorCSAqLworCXN0cnVjdCBtdXRleAkJCW11dGV4OworCisJc3RydWN0IGxpc3RfaGVhZAkJY291bnRlcl9saXN0OworCXN0cnVjdCBsaXN0X2hlYWQJCWV2ZW50X2xpc3Q7CisJaW50CQkJCW5yX2NvdW50ZXJzOworCWludAkJCQlucl9hY3RpdmU7CisJaW50CQkJCWlzX2FjdGl2ZTsKKwlhdG9taWNfdAkJCXJlZmNvdW50OworCXN0cnVjdCB0YXNrX3N0cnVjdAkJKnRhc2s7CisKKwkvKgorCSAqIENvbnRleHQgY2xvY2ssIHJ1bnMgd2hlbiBjb250ZXh0IGVuYWJsZWQuCisJICovCisJdTY0CQkJCXRpbWU7CisJdTY0CQkJCXRpbWVzdGFtcDsKKworCS8qCisJICogVGhlc2UgZmllbGRzIGxldCB1cyBkZXRlY3Qgd2hlbiB0d28gY29udGV4dHMgaGF2ZSBib3RoCisJICogYmVlbiBjbG9uZWQgKGluaGVyaXRlZCkgZnJvbSBhIGNvbW1vbiBhbmNlc3Rvci4KKwkgKi8KKwlzdHJ1Y3QgcGVyZl9jb3VudGVyX2NvbnRleHQJKnBhcmVudF9jdHg7CisJdTY0CQkJCXBhcmVudF9nZW47CisJdTY0CQkJCWdlbmVyYXRpb247CisJaW50CQkJCXBpbl9jb3VudDsKKwlzdHJ1Y3QgcmN1X2hlYWQJCQlyY3VfaGVhZDsKK307CisKKy8qKgorICogc3RydWN0IHBlcmZfY291bnRlcl9jcHVfY29udGV4dCAtIHBlciBjcHUgY291bnRlciBjb250ZXh0IHN0cnVjdHVyZQorICovCitzdHJ1Y3QgcGVyZl9jcHVfY29udGV4dCB7CisJc3RydWN0IHBlcmZfY291bnRlcl9jb250ZXh0CWN0eDsKKwlzdHJ1Y3QgcGVyZl9jb3VudGVyX2NvbnRleHQJKnRhc2tfY3R4OworCWludAkJCQlhY3RpdmVfb25jcHU7CisJaW50CQkJCW1heF9wZXJ0YXNrOworCWludAkJCQlleGNsdXNpdmU7CisKKwkvKgorCSAqIFJlY3Vyc2lvbiBhdm9pZGFuY2U6CisJICoKKwkgKiB0YXNrLCBzb2Z0aXJxLCBpcnEsIG5taSBjb250ZXh0CisJICovCisJaW50CQkJCXJlY3Vyc2lvbls0XTsKK307CisKKyNpZmRlZiBDT05GSUdfUEVSRl9DT1VOVEVSUworCisvKgorICogU2V0IGJ5IGFyY2hpdGVjdHVyZSBjb2RlOgorICovCitleHRlcm4gaW50IHBlcmZfbWF4X2NvdW50ZXJzOworCitleHRlcm4gY29uc3Qgc3RydWN0IHBtdSAqaHdfcGVyZl9jb3VudGVyX2luaXQoc3RydWN0IHBlcmZfY291bnRlciAqY291bnRlcik7CisKK2V4dGVybiB2b2lkIHBlcmZfY291bnRlcl90YXNrX3NjaGVkX2luKHN0cnVjdCB0YXNrX3N0cnVjdCAqdGFzaywgaW50IGNwdSk7CitleHRlcm4gdm9pZCBwZXJmX2NvdW50ZXJfdGFza19zY2hlZF9vdXQoc3RydWN0IHRhc2tfc3RydWN0ICp0YXNrLAorCQkJCQlzdHJ1Y3QgdGFza19zdHJ1Y3QgKm5leHQsIGludCBjcHUpOworZXh0ZXJuIHZvaWQgcGVyZl9jb3VudGVyX3Rhc2tfdGljayhzdHJ1Y3QgdGFza19zdHJ1Y3QgKnRhc2ssIGludCBjcHUpOworZXh0ZXJuIGludCBwZXJmX2NvdW50ZXJfaW5pdF90YXNrKHN0cnVjdCB0YXNrX3N0cnVjdCAqY2hpbGQpOworZXh0ZXJuIHZvaWQgcGVyZl9jb3VudGVyX2V4aXRfdGFzayhzdHJ1Y3QgdGFza19zdHJ1Y3QgKmNoaWxkKTsKK2V4dGVybiB2b2lkIHBlcmZfY291bnRlcl9mcmVlX3Rhc2soc3RydWN0IHRhc2tfc3RydWN0ICp0YXNrKTsKK2V4dGVybiB2b2lkIHBlcmZfY291bnRlcl9kb19wZW5kaW5nKHZvaWQpOworZXh0ZXJuIHZvaWQgcGVyZl9jb3VudGVyX3ByaW50X2RlYnVnKHZvaWQpOworZXh0ZXJuIHZvaWQgX19wZXJmX2Rpc2FibGUodm9pZCk7CitleHRlcm4gYm9vbCBfX3BlcmZfZW5hYmxlKHZvaWQpOworZXh0ZXJuIHZvaWQgcGVyZl9kaXNhYmxlKHZvaWQpOworZXh0ZXJuIHZvaWQgcGVyZl9lbmFibGUodm9pZCk7CitleHRlcm4gaW50IHBlcmZfY291bnRlcl90YXNrX2Rpc2FibGUodm9pZCk7CitleHRlcm4gaW50IHBlcmZfY291bnRlcl90YXNrX2VuYWJsZSh2b2lkKTsKK2V4dGVybiBpbnQgaHdfcGVyZl9ncm91cF9zY2hlZF9pbihzdHJ1Y3QgcGVyZl9jb3VudGVyICpncm91cF9sZWFkZXIsCisJICAgICAgIHN0cnVjdCBwZXJmX2NwdV9jb250ZXh0ICpjcHVjdHgsCisJICAgICAgIHN0cnVjdCBwZXJmX2NvdW50ZXJfY29udGV4dCAqY3R4LCBpbnQgY3B1KTsKK2V4dGVybiB2b2lkIHBlcmZfY291bnRlcl91cGRhdGVfdXNlcnBhZ2Uoc3RydWN0IHBlcmZfY291bnRlciAqY291bnRlcik7CisKK3N0cnVjdCBwZXJmX3NhbXBsZV9kYXRhIHsKKwlzdHJ1Y3QgcHRfcmVncwkJCSpyZWdzOworCXU2NAkJCQlhZGRyOworCXU2NAkJCQlwZXJpb2Q7Cit9OworCitleHRlcm4gaW50IHBlcmZfY291bnRlcl9vdmVyZmxvdyhzdHJ1Y3QgcGVyZl9jb3VudGVyICpjb3VudGVyLCBpbnQgbm1pLAorCQkJCSBzdHJ1Y3QgcGVyZl9zYW1wbGVfZGF0YSAqZGF0YSk7CisKKy8qCisgKiBSZXR1cm4gMSBmb3IgYSBzb2Z0d2FyZSBjb3VudGVyLCAwIGZvciBhIGhhcmR3YXJlIGNvdW50ZXIKKyAqLworc3RhdGljIGlubGluZSBpbnQgaXNfc29mdHdhcmVfY291bnRlcihzdHJ1Y3QgcGVyZl9jb3VudGVyICpjb3VudGVyKQoreworCXJldHVybiAoY291bnRlci0+YXR0ci50eXBlICE9IFBFUkZfVFlQRV9SQVcpICYmCisJCShjb3VudGVyLT5hdHRyLnR5cGUgIT0gUEVSRl9UWVBFX0hBUkRXQVJFKTsKK30KKworZXh0ZXJuIHZvaWQgcGVyZl9zd2NvdW50ZXJfZXZlbnQodTMyLCB1NjQsIGludCwgc3RydWN0IHB0X3JlZ3MgKiwgdTY0KTsKKworZXh0ZXJuIHZvaWQgX19wZXJmX2NvdW50ZXJfbW1hcChzdHJ1Y3Qgdm1fYXJlYV9zdHJ1Y3QgKnZtYSk7CisKK3N0YXRpYyBpbmxpbmUgdm9pZCBwZXJmX2NvdW50ZXJfbW1hcChzdHJ1Y3Qgdm1fYXJlYV9zdHJ1Y3QgKnZtYSkKK3sKKwlpZiAodm1hLT52bV9mbGFncyAmIFZNX0VYRUMpCisJCV9fcGVyZl9jb3VudGVyX21tYXAodm1hKTsKK30KKworZXh0ZXJuIHZvaWQgcGVyZl9jb3VudGVyX2NvbW0oc3RydWN0IHRhc2tfc3RydWN0ICp0c2spOworZXh0ZXJuIHZvaWQgcGVyZl9jb3VudGVyX2Zvcmsoc3RydWN0IHRhc2tfc3RydWN0ICp0c2spOworCitleHRlcm4gdm9pZCBwZXJmX2NvdW50ZXJfdGFza19taWdyYXRpb24oc3RydWN0IHRhc2tfc3RydWN0ICp0YXNrLCBpbnQgY3B1KTsKKworI2RlZmluZSBNQVhfU1RBQ0tfREVQVEgJCQkyNTUKKworc3RydWN0IHBlcmZfY2FsbGNoYWluX2VudHJ5IHsKKwl1MTYJCQkJbnI7CisJdTE2CQkJCWh2OworCXUxNgkJCQlrZXJuZWw7CisJdTE2CQkJCXVzZXI7CisJdTY0CQkJCWlwW01BWF9TVEFDS19ERVBUSF07Cit9OworCitleHRlcm4gc3RydWN0IHBlcmZfY2FsbGNoYWluX2VudHJ5ICpwZXJmX2NhbGxjaGFpbihzdHJ1Y3QgcHRfcmVncyAqcmVncyk7CisKK2V4dGVybiBpbnQgc3lzY3RsX3BlcmZfY291bnRlcl9wYXJhbm9pZDsKK2V4dGVybiBpbnQgc3lzY3RsX3BlcmZfY291bnRlcl9tbG9jazsKK2V4dGVybiBpbnQgc3lzY3RsX3BlcmZfY291bnRlcl9zYW1wbGVfcmF0ZTsKKworZXh0ZXJuIHZvaWQgcGVyZl9jb3VudGVyX2luaXQodm9pZCk7CisKKyNpZm5kZWYgcGVyZl9taXNjX2ZsYWdzCisjZGVmaW5lIHBlcmZfbWlzY19mbGFncyhyZWdzKQkodXNlcl9tb2RlKHJlZ3MpID8gUEVSRl9FVkVOVF9NSVNDX1VTRVIgOiBcCisJCQkJIFBFUkZfRVZFTlRfTUlTQ19LRVJORUwpCisjZGVmaW5lIHBlcmZfaW5zdHJ1Y3Rpb25fcG9pbnRlcihyZWdzKQlpbnN0cnVjdGlvbl9wb2ludGVyKHJlZ3MpCisjZW5kaWYKKworI2Vsc2UKK3N0YXRpYyBpbmxpbmUgdm9pZAorcGVyZl9jb3VudGVyX3Rhc2tfc2NoZWRfaW4oc3RydWN0IHRhc2tfc3RydWN0ICp0YXNrLCBpbnQgY3B1KQkJeyB9CitzdGF0aWMgaW5saW5lIHZvaWQKK3BlcmZfY291bnRlcl90YXNrX3NjaGVkX291dChzdHJ1Y3QgdGFza19zdHJ1Y3QgKnRhc2ssCisJCQkgICAgc3RydWN0IHRhc2tfc3RydWN0ICpuZXh0LCBpbnQgY3B1KQkJeyB9CitzdGF0aWMgaW5saW5lIHZvaWQKK3BlcmZfY291bnRlcl90YXNrX3RpY2soc3RydWN0IHRhc2tfc3RydWN0ICp0YXNrLCBpbnQgY3B1KQkJeyB9CitzdGF0aWMgaW5saW5lIGludCBwZXJmX2NvdW50ZXJfaW5pdF90YXNrKHN0cnVjdCB0YXNrX3N0cnVjdCAqY2hpbGQpCXsgcmV0dXJuIDA7IH0KK3N0YXRpYyBpbmxpbmUgdm9pZCBwZXJmX2NvdW50ZXJfZXhpdF90YXNrKHN0cnVjdCB0YXNrX3N0cnVjdCAqY2hpbGQpCXsgfQorc3RhdGljIGlubGluZSB2b2lkIHBlcmZfY291bnRlcl9mcmVlX3Rhc2soc3RydWN0IHRhc2tfc3RydWN0ICp0YXNrKQl7IH0KK3N0YXRpYyBpbmxpbmUgdm9pZCBwZXJmX2NvdW50ZXJfZG9fcGVuZGluZyh2b2lkKQkJCXsgfQorc3RhdGljIGlubGluZSB2b2lkIHBlcmZfY291bnRlcl9wcmludF9kZWJ1Zyh2b2lkKQkJCXsgfQorc3RhdGljIGlubGluZSB2b2lkIHBlcmZfZGlzYWJsZSh2b2lkKQkJCQkJeyB9CitzdGF0aWMgaW5saW5lIHZvaWQgcGVyZl9lbmFibGUodm9pZCkJCQkJCXsgfQorc3RhdGljIGlubGluZSBpbnQgcGVyZl9jb3VudGVyX3Rhc2tfZGlzYWJsZSh2b2lkKQl7IHJldHVybiAtRUlOVkFMOyB9CitzdGF0aWMgaW5saW5lIGludCBwZXJmX2NvdW50ZXJfdGFza19lbmFibGUodm9pZCkJeyByZXR1cm4gLUVJTlZBTDsgfQorCitzdGF0aWMgaW5saW5lIHZvaWQKK3BlcmZfc3djb3VudGVyX2V2ZW50KHUzMiBldmVudCwgdTY0IG5yLCBpbnQgbm1pLAorCQkgICAgIHN0cnVjdCBwdF9yZWdzICpyZWdzLCB1NjQgYWRkcikJCQl7IH0KKworc3RhdGljIGlubGluZSB2b2lkIHBlcmZfY291bnRlcl9tbWFwKHN0cnVjdCB2bV9hcmVhX3N0cnVjdCAqdm1hKQl7IH0KK3N0YXRpYyBpbmxpbmUgdm9pZCBwZXJmX2NvdW50ZXJfY29tbShzdHJ1Y3QgdGFza19zdHJ1Y3QgKnRzaykJCXsgfQorc3RhdGljIGlubGluZSB2b2lkIHBlcmZfY291bnRlcl9mb3JrKHN0cnVjdCB0YXNrX3N0cnVjdCAqdHNrKQkJeyB9CitzdGF0aWMgaW5saW5lIHZvaWQgcGVyZl9jb3VudGVyX2luaXQodm9pZCkJCQkJeyB9CitzdGF0aWMgaW5saW5lIHZvaWQgcGVyZl9jb3VudGVyX3Rhc2tfbWlncmF0aW9uKHN0cnVjdCB0YXNrX3N0cnVjdCAqdGFzaywKKwkJCQkJICAgICAgIGludCBjcHUpCQkJeyB9CisjZW5kaWYKKworI2VuZGlmIC8qIF9fS0VSTkVMX18gKi8KKyNlbmRpZiAvKiBfTElOVVhfUEVSRl9DT1VOVEVSX0ggKi8KZGlmZiAtLWdpdCBhL2luY2x1ZGUvbGludXgvcHJjdGwuaCBiL2luY2x1ZGUvbGludXgvcHJjdGwuaAppbmRleCA0OGQ4ODdlLi5iMDBkZjRjIDEwMDY0NAotLS0gYS9pbmNsdWRlL2xpbnV4L3ByY3RsLmgKKysrIGIvaW5jbHVkZS9saW51eC9wcmN0bC5oCkBAIC04NSw0ICs4NSw3IEBACiAjZGVmaW5lIFBSX1NFVF9USU1FUlNMQUNLIDI5CiAjZGVmaW5lIFBSX0dFVF9USU1FUlNMQUNLIDMwCiAKKyNkZWZpbmUgUFJfVEFTS19QRVJGX0NPVU5URVJTX0RJU0FCTEUJCTMxCisjZGVmaW5lIFBSX1RBU0tfUEVSRl9DT1VOVEVSU19FTkFCTEUJCTMyCisKICNlbmRpZiAvKiBfTElOVVhfUFJDVExfSCAqLwpkaWZmIC0tZ2l0IGEvaW5jbHVkZS9saW51eC9zY2hlZC5oIGIvaW5jbHVkZS9saW51eC9zY2hlZC5oCmluZGV4IDQyYmYyNzYuLjQ4OTZmZGZlIDEwMDY0NAotLS0gYS9pbmNsdWRlL2xpbnV4L3NjaGVkLmgKKysrIGIvaW5jbHVkZS9saW51eC9zY2hlZC5oCkBAIC05OSw2ICs5OSw3IEBACiBzdHJ1Y3QgYmlvOwogc3RydWN0IGZzX3N0cnVjdDsKIHN0cnVjdCBidHNfY29udGV4dDsKK3N0cnVjdCBwZXJmX2NvdW50ZXJfY29udGV4dDsKIAogLyoKICAqIExpc3Qgb2YgZmxhZ3Mgd2Ugd2FudCB0byBzaGFyZSBmb3Iga2VybmVsIHRocmVhZHMsCkBAIC0xMzksNiArMTQwLDcgQEAKIGV4dGVybiB1bnNpZ25lZCBsb25nIG5yX3VuaW50ZXJydXB0aWJsZSh2b2lkKTsKIGV4dGVybiB1bnNpZ25lZCBsb25nIG5yX2lvd2FpdCh2b2lkKTsKIGV4dGVybiB2b2lkIGNhbGNfZ2xvYmFsX2xvYWQodm9pZCk7CitleHRlcm4gdTY0IGNwdV9ucl9taWdyYXRpb25zKGludCBjcHUpOwogCiBleHRlcm4gdW5zaWduZWQgbG9uZyBnZXRfcGFyZW50X2lwKHVuc2lnbmVkIGxvbmcgYWRkcik7CiAKQEAgLTY3NCw2ICs2NzYsMTAgQEAKIAlzdHJ1Y3Qgd29ya19zdHJ1Y3Qgd29yazsKICNlbmRpZgogI2VuZGlmCisKKyNpZmRlZiBDT05GSUdfUEVSRl9DT1VOVEVSUworCWF0b21pY19sb25nX3QgbG9ja2VkX3ZtOworI2VuZGlmCiB9OwogCiBleHRlcm4gaW50IHVpZHNfc3lzZnNfaW5pdCh2b2lkKTsKQEAgLTEwNzMsOSArMTA3OSwxMCBAQAogCXU2NAkJCWxhc3Rfd2FrZXVwOwogCXU2NAkJCWF2Z19vdmVybGFwOwogCisJdTY0CQkJbnJfbWlncmF0aW9uczsKKwogCXU2NAkJCXN0YXJ0X3J1bnRpbWU7CiAJdTY0CQkJYXZnX3dha2V1cDsKLQl1NjQJCQlucl9taWdyYXRpb25zOwogCiAjaWZkZWYgQ09ORklHX1NDSEVEU1RBVFMKIAl1NjQJCQl3YWl0X3N0YXJ0OwpAQCAtMTM5Niw2ICsxNDAzLDExIEBACiAJc3RydWN0IGxpc3RfaGVhZCBwaV9zdGF0ZV9saXN0OwogCXN0cnVjdCBmdXRleF9waV9zdGF0ZSAqcGlfc3RhdGVfY2FjaGU7CiAjZW5kaWYKKyNpZmRlZiBDT05GSUdfUEVSRl9DT1VOVEVSUworCXN0cnVjdCBwZXJmX2NvdW50ZXJfY29udGV4dCAqcGVyZl9jb3VudGVyX2N0eHA7CisJc3RydWN0IG11dGV4IHBlcmZfY291bnRlcl9tdXRleDsKKwlzdHJ1Y3QgbGlzdF9oZWFkIHBlcmZfY291bnRlcl9saXN0OworI2VuZGlmCiAjaWZkZWYgQ09ORklHX05VTUEKIAlzdHJ1Y3QgbWVtcG9saWN5ICptZW1wb2xpY3k7CiAJc2hvcnQgaWxfbmV4dDsKQEAgLTI0MTAsNiArMjQyMiwxMyBAQAogI2RlZmluZSBUQVNLX1NJWkVfT0YodHNrKQlUQVNLX1NJWkUKICNlbmRpZgogCisvKgorICogQ2FsbCB0aGUgZnVuY3Rpb24gaWYgdGhlIHRhcmdldCB0YXNrIGlzIGV4ZWN1dGluZyBvbiBhIENQVSByaWdodCBub3c6CisgKi8KK2V4dGVybiB2b2lkIHRhc2tfb25jcHVfZnVuY3Rpb25fY2FsbChzdHJ1Y3QgdGFza19zdHJ1Y3QgKnAsCisJCQkJICAgICB2b2lkICgqZnVuYykgKHZvaWQgKmluZm8pLCB2b2lkICppbmZvKTsKKworCiAjaWZkZWYgQ09ORklHX01NX09XTkVSCiBleHRlcm4gdm9pZCBtbV91cGRhdGVfbmV4dF9vd25lcihzdHJ1Y3QgbW1fc3RydWN0ICptbSk7CiBleHRlcm4gdm9pZCBtbV9pbml0X293bmVyKHN0cnVjdCBtbV9zdHJ1Y3QgKm1tLCBzdHJ1Y3QgdGFza19zdHJ1Y3QgKnApOwpkaWZmIC0tZ2l0IGEvaW5jbHVkZS9saW51eC9zbGFiLmggYi9pbmNsdWRlL2xpbnV4L3NsYWIuaAppbmRleCAyNGM1NjAyLi40ODgwMzA2IDEwMDY0NAotLS0gYS9pbmNsdWRlL2xpbnV4L3NsYWIuaAorKysgYi9pbmNsdWRlL2xpbnV4L3NsYWIuaApAQCAtNjIsNiArNjIsOCBAQAogIyBkZWZpbmUgU0xBQl9ERUJVR19PQkpFQ1RTCTB4MDAwMDAwMDBVTAogI2VuZGlmCiAKKyNkZWZpbmUgU0xBQl9OT0xFQUtUUkFDRQkweDAwODAwMDAwVUwJLyogQXZvaWQga21lbWxlYWsgdHJhY2luZyAqLworCiAvKiBUaGUgZm9sbG93aW5nIGZsYWdzIGFmZmVjdCB0aGUgcGFnZSBhbGxvY2F0b3IgZ3JvdXBpbmcgcGFnZXMgYnkgbW9iaWxpdHkgKi8KICNkZWZpbmUgU0xBQl9SRUNMQUlNX0FDQ09VTlQJMHgwMDAyMDAwMFVMCQkvKiBPYmplY3RzIGFyZSByZWNsYWltYWJsZSAqLwogI2RlZmluZSBTTEFCX1RFTVBPUkFSWQkJU0xBQl9SRUNMQUlNX0FDQ09VTlQJLyogT2JqZWN0cyBhcmUgc2hvcnQtbGl2ZWQgKi8KZGlmZiAtLWdpdCBhL2luY2x1ZGUvbGludXgvc3lzY2FsbHMuaCBiL2luY2x1ZGUvbGludXgvc3lzY2FsbHMuaAppbmRleCAzMDUyMDg0Li5jNmM4NGFkIDEwMDY0NAotLS0gYS9pbmNsdWRlL2xpbnV4L3N5c2NhbGxzLmgKKysrIGIvaW5jbHVkZS9saW51eC9zeXNjYWxscy5oCkBAIC01NSw2ICs1NSw3IEBACiBzdHJ1Y3Qgcm9idXN0X2xpc3RfaGVhZDsKIHN0cnVjdCBnZXRjcHVfY2FjaGU7CiBzdHJ1Y3Qgb2xkX2xpbnV4X2RpcmVudDsKK3N0cnVjdCBwZXJmX2NvdW50ZXJfYXR0cjsKIAogI2luY2x1ZGUgPGxpbnV4L3R5cGVzLmg+CiAjaW5jbHVkZSA8bGludXgvYWlvX2FiaS5oPgpAQCAtNzU1LDQgKzc1Niw4IEBACiAKIGludCBrZXJuZWxfZXhlY3ZlKGNvbnN0IGNoYXIgKmZpbGVuYW1lLCBjaGFyICpjb25zdCBhcmd2W10sIGNoYXIgKmNvbnN0IGVudnBbXSk7CiAKKworYXNtbGlua2FnZSBsb25nIHN5c19wZXJmX2NvdW50ZXJfb3BlbigKKwkJY29uc3Qgc3RydWN0IHBlcmZfY291bnRlcl9hdHRyIF9fdXNlciAqYXR0cl91cHRyLAorCQlwaWRfdCBwaWQsIGludCBjcHUsIGludCBncm91cF9mZCwgdW5zaWduZWQgbG9uZyBmbGFncyk7CiAjZW5kaWYKZGlmZiAtLWdpdCBhL2luaXQvS2NvbmZpZyBiL2luaXQvS2NvbmZpZwppbmRleCA1ZGUxYzE3Yy4uYzY0OTY1NyAxMDA2NDQKLS0tIGEvaW5pdC9LY29uZmlnCisrKyBiL2luaXQvS2NvbmZpZwpAQCAtOTM0LDYgKzkzNCw0MCBAQAogICAgICAgICAgIGJ5IHNvbWUgaGlnaCBwZXJmb3JtYW5jZSB0aHJlYWRlZCBhcHBsaWNhdGlvbnMuIERpc2FibGluZwogICAgICAgICAgIHRoaXMgb3B0aW9uIHNhdmVzIGFib3V0IDdrLgogCitjb25maWcgSEFWRV9QRVJGX0NPVU5URVJTCisJYm9vbAorCittZW51ICJQZXJmb3JtYW5jZSBDb3VudGVycyIKKworY29uZmlnIFBFUkZfQ09VTlRFUlMKKwlib29sICJLZXJuZWwgUGVyZm9ybWFuY2UgQ291bnRlcnMiCisJZGVwZW5kcyBvbiBIQVZFX1BFUkZfQ09VTlRFUlMKKwlzZWxlY3QgQU5PTl9JTk9ERVMKKwloZWxwCisJICBFbmFibGUga2VybmVsIHN1cHBvcnQgZm9yIHBlcmZvcm1hbmNlIGNvdW50ZXIgaGFyZHdhcmUuCisKKwkgIFBlcmZvcm1hbmNlIGNvdW50ZXJzIGFyZSBzcGVjaWFsIGhhcmR3YXJlIHJlZ2lzdGVycyBhdmFpbGFibGUKKwkgIG9uIG1vc3QgbW9kZXJuIENQVXMuIFRoZXNlIHJlZ2lzdGVycyBjb3VudCB0aGUgbnVtYmVyIG9mIGNlcnRhaW4KKwkgIHR5cGVzIG9mIGh3IGV2ZW50czogc3VjaCBhcyBpbnN0cnVjdGlvbnMgZXhlY3V0ZWQsIGNhY2hlbWlzc2VzCisJICBzdWZmZXJlZCwgb3IgYnJhbmNoZXMgbWlzLXByZWRpY3RlZCAtIHdpdGhvdXQgc2xvd2luZyBkb3duIHRoZQorCSAga2VybmVsIG9yIGFwcGxpY2F0aW9ucy4gVGhlc2UgcmVnaXN0ZXJzIGNhbiBhbHNvIHRyaWdnZXIgaW50ZXJydXB0cworCSAgd2hlbiBhIHRocmVzaG9sZCBudW1iZXIgb2YgZXZlbnRzIGhhdmUgcGFzc2VkIC0gYW5kIGNhbiB0aHVzIGJlCisJICB1c2VkIHRvIHByb2ZpbGUgdGhlIGNvZGUgdGhhdCBydW5zIG9uIHRoYXQgQ1BVLgorCisJICBUaGUgTGludXggUGVyZm9ybWFuY2UgQ291bnRlciBzdWJzeXN0ZW0gcHJvdmlkZXMgYW4gYWJzdHJhY3Rpb24gb2YKKwkgIHRoZXNlIGhhcmR3YXJlIGNhcGFiaWxpdGllcywgYXZhaWxhYmxlIHZpYSBhIHN5c3RlbSBjYWxsLiBJdAorCSAgcHJvdmlkZXMgcGVyIHRhc2sgYW5kIHBlciBDUFUgY291bnRlcnMsIGFuZCBpdCBwcm92aWRlcyBldmVudAorCSAgY2FwYWJpbGl0aWVzIG9uIHRvcCBvZiB0aG9zZS4KKworCSAgU2F5IFkgaWYgdW5zdXJlLgorCitjb25maWcgRVZFTlRfUFJPRklMRQorCWJvb2wgIlRyYWNlcG9pbnQgcHJvZmlsZSBzb3VyY2VzIgorCWRlcGVuZHMgb24gUEVSRl9DT1VOVEVSUyAmJiBFVkVOVF9UUkFDRVIKKwlkZWZhdWx0IHkKKworZW5kbWVudQorCiBjb25maWcgVk1fRVZFTlRfQ09VTlRFUlMKIAlkZWZhdWx0IHkKIAlib29sICJFbmFibGUgVk0gZXZlbnQgY291bnRlcnMgZm9yIC9wcm9jL3Ztc3RhdCIgaWYgRU1CRURERUQKZGlmZiAtLWdpdCBhL2luaXQvbWFpbi5jIGIvaW5pdC9tYWluLmMKaW5kZXggYmI3ZGM1Ny4uNTYxNjY2MSAxMDA2NDQKLS0tIGEvaW5pdC9tYWluLmMKKysrIGIvaW5pdC9tYWluLmMKQEAgLTU2LDYgKzU2LDcgQEAKICNpbmNsdWRlIDxsaW51eC9kZWJ1Z19sb2Nrcy5oPgogI2luY2x1ZGUgPGxpbnV4L2RlYnVnb2JqZWN0cy5oPgogI2luY2x1ZGUgPGxpbnV4L2xvY2tkZXAuaD4KKyNpbmNsdWRlIDxsaW51eC9rbWVtbGVhay5oPgogI2luY2x1ZGUgPGxpbnV4L3BpZF9uYW1lc3BhY2UuaD4KICNpbmNsdWRlIDxsaW51eC9kZXZpY2UuaD4KICNpbmNsdWRlIDxsaW51eC9rdGhyZWFkLmg+CkBAIC01MzMsNiArNTM0LDE2IEBACiB7CiB9CiAKKy8qCisgKiBTZXQgdXAga2VybmVsIG1lbW9yeSBhbGxvY2F0b3JzCisgKi8KK3N0YXRpYyB2b2lkIF9faW5pdCBtbV9pbml0KHZvaWQpCit7CisJbWVtX2luaXQoKTsKKwlrbWVtX2NhY2hlX2luaXQoKTsKKwl2bWFsbG9jX2luaXQoKTsKK30KKwogYXNtbGlua2FnZSB2b2lkIF9faW5pdCBzdGFydF9rZXJuZWwodm9pZCkKIHsKIAljaGFyICogY29tbWFuZF9saW5lOwpAQCAtNTc0LDYgKzU4NSwyMyBAQAogCXNldHVwX25yX2NwdV9pZHMoKTsKIAlzbXBfcHJlcGFyZV9ib290X2NwdSgpOwkvKiBhcmNoLXNwZWNpZmljIGJvb3QtY3B1IGhvb2tzICovCiAKKwlidWlsZF9hbGxfem9uZWxpc3RzKCk7CisJcGFnZV9hbGxvY19pbml0KCk7CisKKwlwcmludGsoS0VSTl9OT1RJQ0UgIktlcm5lbCBjb21tYW5kIGxpbmU6ICVzXG4iLCBib290X2NvbW1hbmRfbGluZSk7CisJcGFyc2VfZWFybHlfcGFyYW0oKTsKKwlwYXJzZV9hcmdzKCJCb290aW5nIGtlcm5lbCIsIHN0YXRpY19jb21tYW5kX2xpbmUsIF9fc3RhcnRfX19wYXJhbSwKKwkJICAgX19zdG9wX19fcGFyYW0gLSBfX3N0YXJ0X19fcGFyYW0sCisJCSAgICZ1bmtub3duX2Jvb3RvcHRpb24pOworCS8qCisJICogVGhlc2UgdXNlIGxhcmdlIGJvb3RtZW0gYWxsb2NhdGlvbnMgYW5kIG11c3QgcHJlY2VkZQorCSAqIGttZW1fY2FjaGVfaW5pdCgpCisJICovCisJcGlkaGFzaF9pbml0KCk7CisJdmZzX2NhY2hlc19pbml0X2Vhcmx5KCk7CisJc29ydF9tYWluX2V4dGFibGUoKTsKKwl0cmFwX2luaXQoKTsKKwltbV9pbml0KCk7CiAJLyoKIAkgKiBTZXQgdXAgdGhlIHNjaGVkdWxlciBwcmlvciBzdGFydGluZyBhbnkgaW50ZXJydXB0cyAoc3VjaCBhcyB0aGUKIAkgKiB0aW1lciBpbnRlcnJ1cHQpLiBGdWxsIHRvcG9sb2d5IHNldHVwIGhhcHBlbnMgYXQgc21wX2luaXQoKQpAQCAtNTg1LDI1ICs2MTMsMTYgQEAKIAkgKiBmcmFnaWxlIHVudGlsIHdlIGNwdV9pZGxlKCkgZm9yIHRoZSBmaXJzdCB0aW1lLgogCSAqLwogCXByZWVtcHRfZGlzYWJsZSgpOwotCWJ1aWxkX2FsbF96b25lbGlzdHMoKTsKLQlwYWdlX2FsbG9jX2luaXQoKTsKLQlwcmludGsoS0VSTl9OT1RJQ0UgIktlcm5lbCBjb21tYW5kIGxpbmU6ICVzXG4iLCBib290X2NvbW1hbmRfbGluZSk7Ci0JcGFyc2VfZWFybHlfcGFyYW0oKTsKLQlwYXJzZV9hcmdzKCJCb290aW5nIGtlcm5lbCIsIHN0YXRpY19jb21tYW5kX2xpbmUsIF9fc3RhcnRfX19wYXJhbSwKLQkJICAgX19zdG9wX19fcGFyYW0gLSBfX3N0YXJ0X19fcGFyYW0sCi0JCSAgICZ1bmtub3duX2Jvb3RvcHRpb24pOwogCWlmICghaXJxc19kaXNhYmxlZCgpKSB7CiAJCXByaW50ayhLRVJOX1dBUk5JTkcgInN0YXJ0X2tlcm5lbCgpOiBidWc6IGludGVycnVwdHMgd2VyZSAiCiAJCQkJImVuYWJsZWQgKnZlcnkqIGVhcmx5LCBmaXhpbmcgaXRcbiIpOwogCQlsb2NhbF9pcnFfZGlzYWJsZSgpOwogCX0KLQlzb3J0X21haW5fZXh0YWJsZSgpOwotCXRyYXBfaW5pdCgpOwogCXJjdV9pbml0KCk7CiAJLyogaW5pdCBzb21lIGxpbmtzIGJlZm9yZSBpbml0X0lTQV9pcnFzKCkgKi8KIAllYXJseV9pcnFfaW5pdCgpOwogCWluaXRfSVJRKCk7Ci0JcGlkaGFzaF9pbml0KCk7CisJcHJpb190cmVlX2luaXQoKTsKIAlpbml0X3RpbWVycygpOwogCWhydGltZXJzX2luaXQoKTsKIAlzb2Z0aXJxX2luaXQoKTsKQEAgLTY0NSwxNSArNjY0LDEyIEBACiAJCWluaXRyZF9zdGFydCA9IDA7CiAJfQogI2VuZGlmCi0Jdm1hbGxvY19pbml0KCk7Ci0JdmZzX2NhY2hlc19pbml0X2Vhcmx5KCk7CiAJY3B1c2V0X2luaXRfZWFybHkoKTsKIAlwYWdlX2Nncm91cF9pbml0KCk7Ci0JbWVtX2luaXQoKTsKIAllbmFibGVfZGVidWdfcGFnZWFsbG9jKCk7CiAJY3B1X2hvdHBsdWdfaW5pdCgpOwotCWttZW1fY2FjaGVfaW5pdCgpOwogCWttZW10cmFjZV9pbml0KCk7CisJa21lbWxlYWtfaW5pdCgpOwogCWRlYnVnX29iamVjdHNfbWVtX2luaXQoKTsKIAlpZHJfaW5pdF9jYWNoZSgpOwogCXNldHVwX3Blcl9jcHVfcGFnZXNldCgpOwpAQCAtNjYzLDcgKzY3OSw2IEBACiAJY2FsaWJyYXRlX2RlbGF5KCk7CiAJcGlkbWFwX2luaXQoKTsKIAlwZ3RhYmxlX2NhY2hlX2luaXQoKTsKLQlwcmlvX3RyZWVfaW5pdCgpOwogCWFub25fdm1hX2luaXQoKTsKICNpZmRlZiBDT05GSUdfWDg2CiAJaWYgKGVmaV9lbmFibGVkKQpkaWZmIC0tZ2l0IGEva2VybmVsL01ha2VmaWxlIGIva2VybmVsL01ha2VmaWxlCmluZGV4IGEzNWVlZTMuLjkwYjUzZjYgMTAwNjQ0Ci0tLSBhL2tlcm5lbC9NYWtlZmlsZQorKysgYi9rZXJuZWwvTWFrZWZpbGUKQEAgLTk2LDYgKzk2LDcgQEAKIG9iai0kKENPTkZJR19YODZfRFMpICs9IHRyYWNlLwogb2JqLSQoQ09ORklHX1NNUCkgKz0gc2NoZWRfY3B1cHJpLm8KIG9iai0kKENPTkZJR19TTE9XX1dPUkspICs9IHNsb3ctd29yay5vCitvYmotJChDT05GSUdfUEVSRl9DT1VOVEVSUykgKz0gcGVyZl9jb3VudGVyLm8KIAogaWZuZXEgKCQoQ09ORklHX1NDSEVEX09NSVRfRlJBTUVfUE9JTlRFUikseSkKICMgQWNjb3JkaW5nIHRvIEFsYW4gTW9kcmEgPGFsYW5AbGludXhjYXJlLmNvbS5hdT4sIHRoZSAtZm5vLW9taXQtZnJhbWUtcG9pbnRlciBpcwpkaWZmIC0tZ2l0IGEva2VybmVsL2NwdXNldC5jIGIva2VybmVsL2NwdXNldC5jCmluZGV4IDAyNmZhY2MuLmQ1YTdlMTcgMTAwNjQ0Ci0tLSBhL2tlcm5lbC9jcHVzZXQuYworKysgYi9rZXJuZWwvY3B1c2V0LmMKQEAgLTE4NTcsNyArMTg1Nyw3IEBACiAKIGludCBfX2luaXQgY3B1c2V0X2luaXRfZWFybHkodm9pZCkKIHsKLQlhbGxvY19ib290bWVtX2NwdW1hc2tfdmFyKCZ0b3BfY3B1c2V0LmNwdXNfYWxsb3dlZCk7CisJYWxsb2NfY3B1bWFza192YXIoJnRvcF9jcHVzZXQuY3B1c19hbGxvd2VkLCBHRlBfTk9XQUlUKTsKIAogCXRvcF9jcHVzZXQubWVtc19nZW5lcmF0aW9uID0gY3B1c2V0X21lbXNfZ2VuZXJhdGlvbisrOwogCXJldHVybiAwOwpkaWZmIC0tZ2l0IGEva2VybmVsL2V4aXQuYyBiL2tlcm5lbC9leGl0LmMKaW5kZXggNTFkMWZlMy4uYjZjOTBiNSAxMDA2NDQKLS0tIGEva2VybmVsL2V4aXQuYworKysgYi9rZXJuZWwvZXhpdC5jCkBAIC00OCw2ICs0OCw3IEBACiAjaW5jbHVkZSA8bGludXgvdHJhY2Vob29rLmg+CiAjaW5jbHVkZSA8bGludXgvZnNfc3RydWN0Lmg+CiAjaW5jbHVkZSA8bGludXgvaW5pdF90YXNrLmg+CisjaW5jbHVkZSA8bGludXgvcGVyZl9jb3VudGVyLmg+CiAjaW5jbHVkZSA8dHJhY2UvZXZlbnRzL3NjaGVkLmg+CiAKICNpbmNsdWRlIDxhc20vdWFjY2Vzcy5oPgpAQCAtMTU0LDYgKzE1NSw5IEBACiB7CiAJc3RydWN0IHRhc2tfc3RydWN0ICp0c2sgPSBjb250YWluZXJfb2YocmhwLCBzdHJ1Y3QgdGFza19zdHJ1Y3QsIHJjdSk7CiAKKyNpZmRlZiBDT05GSUdfUEVSRl9DT1VOVEVSUworCVdBUk5fT05fT05DRSh0c2stPnBlcmZfY291bnRlcl9jdHhwKTsKKyNlbmRpZgogCXRyYWNlX3NjaGVkX3Byb2Nlc3NfZnJlZSh0c2spOwogCXB1dF90YXNrX3N0cnVjdCh0c2spOwogfQpAQCAtMTcwLDYgKzE3NCw3IEBACiAJYXRvbWljX2RlYygmX190YXNrX2NyZWQocCktPnVzZXItPnByb2Nlc3Nlcyk7CiAKIAlwcm9jX2ZsdXNoX3Rhc2socCk7CisKIAl3cml0ZV9sb2NrX2lycSgmdGFza2xpc3RfbG9jayk7CiAJdHJhY2Vob29rX2ZpbmlzaF9yZWxlYXNlX3Rhc2socCk7CiAJX19leGl0X3NpZ25hbChwKTsKQEAgLTk3MSwxNiArOTc2LDE5IEBACiAJCW1vZHVsZV9wdXQodHNrLT5iaW5mbXQtPm1vZHVsZSk7CiAKIAlwcm9jX2V4aXRfY29ubmVjdG9yKHRzayk7CisKKwkvKgorCSAqIEZsdXNoIGluaGVyaXRlZCBjb3VudGVycyB0byB0aGUgcGFyZW50IC0gYmVmb3JlIHRoZSBwYXJlbnQKKwkgKiBnZXRzIHdva2VuIHVwIGJ5IGNoaWxkLWV4aXQgbm90aWZpY2F0aW9ucy4KKwkgKi8KKwlwZXJmX2NvdW50ZXJfZXhpdF90YXNrKHRzayk7CisKIAlleGl0X25vdGlmeSh0c2ssIGdyb3VwX2RlYWQpOwogI2lmZGVmIENPTkZJR19OVU1BCiAJbXBvbF9wdXQodHNrLT5tZW1wb2xpY3kpOwogCXRzay0+bWVtcG9saWN5ID0gTlVMTDsKICNlbmRpZgogI2lmZGVmIENPTkZJR19GVVRFWAotCS8qCi0JICogVGhpcyBtdXN0IGhhcHBlbiBsYXRlLCBhZnRlciB0aGUgUElEIGlzIG5vdAotCSAqIGhhc2hlZCBhbnltb3JlOgotCSAqLwogCWlmICh1bmxpa2VseSghbGlzdF9lbXB0eSgmdHNrLT5waV9zdGF0ZV9saXN0KSkpCiAJCWV4aXRfcGlfc3RhdGVfbGlzdCh0c2spOwogCWlmICh1bmxpa2VseShjdXJyZW50LT5waV9zdGF0ZV9jYWNoZSkpCmRpZmYgLS1naXQgYS9rZXJuZWwvZm9yay5jIGIva2VybmVsL2ZvcmsuYwppbmRleCBiYjc2MmI0Li40NDMwZWIxIDEwMDY0NAotLS0gYS9rZXJuZWwvZm9yay5jCisrKyBiL2tlcm5lbC9mb3JrLmMKQEAgLTYyLDYgKzYyLDcgQEAKICNpbmNsdWRlIDxsaW51eC9ibGtkZXYuaD4KICNpbmNsdWRlIDxsaW51eC9mc19zdHJ1Y3QuaD4KICNpbmNsdWRlIDxsaW51eC9tYWdpYy5oPgorI2luY2x1ZGUgPGxpbnV4L3BlcmZfY291bnRlci5oPgogCiAjaW5jbHVkZSA8YXNtL3BndGFibGUuaD4KICNpbmNsdWRlIDxhc20vcGdhbGxvYy5oPgpAQCAtMTA5Niw2ICsxMDk3LDEwIEBACiAJLyogUGVyZm9ybSBzY2hlZHVsZXIgcmVsYXRlZCBzZXR1cC4gQXNzaWduIHRoaXMgdGFzayB0byBhIENQVS4gKi8KIAlzY2hlZF9mb3JrKHAsIGNsb25lX2ZsYWdzKTsKIAorCXJldHZhbCA9IHBlcmZfY291bnRlcl9pbml0X3Rhc2socCk7CisJaWYgKHJldHZhbCkKKwkJZ290byBiYWRfZm9ya19jbGVhbnVwX3BvbGljeTsKKwogCWlmICgocmV0dmFsID0gYXVkaXRfYWxsb2MocCkpKQogCQlnb3RvIGJhZF9mb3JrX2NsZWFudXBfcG9saWN5OwogCS8qIGNvcHkgYWxsIHRoZSBwcm9jZXNzIGluZm9ybWF0aW9uICovCkBAIC0xMjkwLDYgKzEyOTUsNyBAQAogYmFkX2ZvcmtfY2xlYW51cF9hdWRpdDoKIAlhdWRpdF9mcmVlKHApOwogYmFkX2ZvcmtfY2xlYW51cF9wb2xpY3k6CisJcGVyZl9jb3VudGVyX2ZyZWVfdGFzayhwKTsKICNpZmRlZiBDT05GSUdfTlVNQQogCW1wb2xfcHV0KHAtPm1lbXBvbGljeSk7CiBiYWRfZm9ya19jbGVhbnVwX2Nncm91cDoKQEAgLTE0MDMsNiArMTQwOSwxMiBAQAogCQlpZiAoY2xvbmVfZmxhZ3MgJiBDTE9ORV9WRk9SSykgewogCQkJcC0+dmZvcmtfZG9uZSA9ICZ2Zm9yazsKIAkJCWluaXRfY29tcGxldGlvbigmdmZvcmspOworCQl9IGVsc2UgaWYgKCEoY2xvbmVfZmxhZ3MgJiBDTE9ORV9WTSkpIHsKKwkJCS8qCisJCQkgKiB2Zm9yayB3aWxsIGRvIGFuIGV4ZWMgd2hpY2ggd2lsbCBjYWxsCisJCQkgKiBzZXRfdGFza19jb21tKCkKKwkJCSAqLworCQkJcGVyZl9jb3VudGVyX2ZvcmsocCk7CiAJCX0KIAogCQlhdWRpdF9maW5pc2hfZm9yayhwKTsKZGlmZiAtLWdpdCBhL2tlcm5lbC9pcnEvaGFuZGxlLmMgYi9rZXJuZWwvaXJxL2hhbmRsZS5jCmluZGV4IGE2MDAxODQuLjEwNDU3ODUgMTAwNjQ0Ci0tLSBhL2tlcm5lbC9pcnEvaGFuZGxlLmMKKysrIGIva2VybmVsL2lycS9oYW5kbGUuYwpAQCAtMTUwLDYgKzE1MCw3IEBACiB7CiAJc3RydWN0IGlycV9kZXNjICpkZXNjOwogCWludCBsZWdhY3lfY291bnQ7CisJaW50IG5vZGU7CiAJaW50IGk7CiAKIAlpbml0X2lycV9kZWZhdWx0X2FmZmluaXR5KCk7CkBAIC0xNjAsMjAgKzE2MSwyMCBAQAogCiAJZGVzYyA9IGlycV9kZXNjX2xlZ2FjeTsKIAlsZWdhY3lfY291bnQgPSBBUlJBWV9TSVpFKGlycV9kZXNjX2xlZ2FjeSk7CisgCW5vZGUgPSBmaXJzdF9vbmxpbmVfbm9kZTsKIAogCS8qIGFsbG9jYXRlIGlycV9kZXNjX3B0cnMgYXJyYXkgYmFzZWQgb24gbnJfaXJxcyAqLwotCWlycV9kZXNjX3B0cnMgPSBhbGxvY19ib290bWVtKG5yX2lycXMgKiBzaXplb2Yodm9pZCAqKSk7CisJaXJxX2Rlc2NfcHRycyA9IGtjYWxsb2MobnJfaXJxcywgc2l6ZW9mKHZvaWQgKiksIEdGUF9OT1dBSVQpOwogCiAJLyogYWxsb2NhdGUgYmFzZWQgb24gbnJfY3B1X2lkcyAqLwotCS8qIEZJWE1FOiBpbnZlcnQga3N0YXRfaXJncywgYW5kIGl0J2QgYmUgYSBwZXJfY3B1X2FsbG9jJ2QgdGhpbmcgKi8KLQlrc3RhdF9pcnFzX2xlZ2FjeSA9IGFsbG9jX2Jvb3RtZW0oTlJfSVJRU19MRUdBQ1kgKiBucl9jcHVfaWRzICoKLQkJCQkJICBzaXplb2YoaW50KSk7CisJa3N0YXRfaXJxc19sZWdhY3kgPSBremFsbG9jX25vZGUoTlJfSVJRU19MRUdBQ1kgKiBucl9jcHVfaWRzICoKKwkJCQkJICBzaXplb2YoaW50KSwgR0ZQX05PV0FJVCwgbm9kZSk7CiAKIAlmb3IgKGkgPSAwOyBpIDwgbGVnYWN5X2NvdW50OyBpKyspIHsKIAkJZGVzY1tpXS5pcnEgPSBpOwogCQlkZXNjW2ldLmtzdGF0X2lycXMgPSBrc3RhdF9pcnFzX2xlZ2FjeSArIGkgKiBucl9jcHVfaWRzOwogCQlsb2NrZGVwX3NldF9jbGFzcygmZGVzY1tpXS5sb2NrLCAmaXJxX2Rlc2NfbG9ja19jbGFzcyk7Ci0JCWFsbG9jX2Rlc2NfbWFza3MoJmRlc2NbaV0sIDAsIHRydWUpOworCQlhbGxvY19kZXNjX21hc2tzKCZkZXNjW2ldLCBub2RlLCB0cnVlKTsKIAkJaW5pdF9kZXNjX21hc2tzKCZkZXNjW2ldKTsKIAkJaXJxX2Rlc2NfcHRyc1tpXSA9IGRlc2MgKyBpOwogCX0KZGlmZiAtLWdpdCBhL2tlcm5lbC9tb2R1bGUuYyBiL2tlcm5lbC9tb2R1bGUuYwppbmRleCAyNzhlOWI2Li4zNWY3ZGUwIDEwMDY0NAotLS0gYS9rZXJuZWwvbW9kdWxlLmMKKysrIGIva2VybmVsL21vZHVsZS5jCkBAIC01Myw2ICs1Myw3IEBACiAjaW5jbHVkZSA8bGludXgvZnRyYWNlLmg+CiAjaW5jbHVkZSA8bGludXgvYXN5bmMuaD4KICNpbmNsdWRlIDxsaW51eC9wZXJjcHUuaD4KKyNpbmNsdWRlIDxsaW51eC9rbWVtbGVhay5oPgogCiAjaWYgMAogI2RlZmluZSBERUJVR1AgcHJpbnRrCkBAIC00MzMsNiArNDM0LDcgQEAKIAl1bnNpZ25lZCBsb25nIGV4dHJhOwogCXVuc2lnbmVkIGludCBpOwogCXZvaWQgKnB0cjsKKwlpbnQgY3B1OwogCiAJaWYgKGFsaWduID4gUEFHRV9TSVpFKSB7CiAJCXByaW50ayhLRVJOX1dBUk5JTkcgIiVzOiBwZXItY3B1IGFsaWdubWVudCAlbGkgPiAlbGlcbiIsCkBAIC00NjIsNiArNDY0LDExIEBACiAJCQlpZiAoIXNwbGl0X2Jsb2NrKGksIHNpemUpKQogCQkJCXJldHVybiBOVUxMOwogCisJCS8qIGFkZCB0aGUgcGVyLWNwdSBzY2FubmluZyBhcmVhcyAqLworCQlmb3JfZWFjaF9wb3NzaWJsZV9jcHUoY3B1KQorCQkJa21lbWxlYWtfYWxsb2MocHRyICsgcGVyX2NwdV9vZmZzZXQoY3B1KSwgc2l6ZSwgMCwKKwkJCQkgICAgICAgR0ZQX0tFUk5FTCk7CisKIAkJLyogTWFyayBhbGxvY2F0ZWQgKi8KIAkJcGNwdV9zaXplW2ldID0gLXBjcHVfc2l6ZVtpXTsKIAkJcmV0dXJuIHB0cjsKQEAgLTQ3Niw2ICs0ODMsNyBAQAogewogCXVuc2lnbmVkIGludCBpOwogCXZvaWQgKnB0ciA9IF9fcGVyX2NwdV9zdGFydCArIGJsb2NrX3NpemUocGNwdV9zaXplWzBdKTsKKwlpbnQgY3B1OwogCiAJLyogRmlyc3QgZW50cnkgaXMgY29yZSBrZXJuZWwgcGVyY3B1IGRhdGEuICovCiAJZm9yIChpID0gMTsgaSA8IHBjcHVfbnVtX3VzZWQ7IHB0ciArPSBibG9ja19zaXplKHBjcHVfc2l6ZVtpXSksIGkrKykgewpAQCAtNDg3LDYgKzQ5NSwxMCBAQAogCUJVRygpOwogCiAgZnJlZToKKwkvKiByZW1vdmUgdGhlIHBlci1jcHUgc2Nhbm5pbmcgYXJlYXMgKi8KKwlmb3JfZWFjaF9wb3NzaWJsZV9jcHUoY3B1KQorCQlrbWVtbGVha19mcmVlKGZyZWVtZSArIHBlcl9jcHVfb2Zmc2V0KGNwdSkpOworCiAJLyogTWVyZ2Ugd2l0aCBwcmV2aW91cz8gKi8KIAlpZiAocGNwdV9zaXplW2ktMV0gPj0gMCkgewogCQlwY3B1X3NpemVbaS0xXSArPSBwY3B1X3NpemVbaV07CkBAIC0xODc5LDYgKzE4OTEsMzYgQEAKIAlyZXR1cm4gcmV0OwogfQogCisjaWZkZWYgQ09ORklHX0RFQlVHX0tNRU1MRUFLCitzdGF0aWMgdm9pZCBrbWVtbGVha19sb2FkX21vZHVsZShzdHJ1Y3QgbW9kdWxlICptb2QsIEVsZl9FaGRyICpoZHIsCisJCQkJIEVsZl9TaGRyICpzZWNoZHJzLCBjaGFyICpzZWNzdHJpbmdzKQoreworCXVuc2lnbmVkIGludCBpOworCisJLyogb25seSBzY2FuIHRoZSBzZWN0aW9ucyBjb250YWluaW5nIGRhdGEgKi8KKwlrbWVtbGVha19zY2FuX2FyZWEobW9kLT5tb2R1bGVfY29yZSwgKHVuc2lnbmVkIGxvbmcpbW9kIC0KKwkJCSAgICh1bnNpZ25lZCBsb25nKW1vZC0+bW9kdWxlX2NvcmUsCisJCQkgICBzaXplb2Yoc3RydWN0IG1vZHVsZSksIEdGUF9LRVJORUwpOworCisJZm9yIChpID0gMTsgaSA8IGhkci0+ZV9zaG51bTsgaSsrKSB7CisJCWlmICghKHNlY2hkcnNbaV0uc2hfZmxhZ3MgJiBTSEZfQUxMT0MpKQorCQkJY29udGludWU7CisJCWlmIChzdHJuY21wKHNlY3N0cmluZ3MgKyBzZWNoZHJzW2ldLnNoX25hbWUsICIuZGF0YSIsIDUpICE9IDAKKwkJICAgICYmIHN0cm5jbXAoc2Vjc3RyaW5ncyArIHNlY2hkcnNbaV0uc2hfbmFtZSwgIi5ic3MiLCA0KSAhPSAwKQorCQkJY29udGludWU7CisKKwkJa21lbWxlYWtfc2Nhbl9hcmVhKG1vZC0+bW9kdWxlX2NvcmUsIHNlY2hkcnNbaV0uc2hfYWRkciAtCisJCQkJICAgKHVuc2lnbmVkIGxvbmcpbW9kLT5tb2R1bGVfY29yZSwKKwkJCQkgICBzZWNoZHJzW2ldLnNoX3NpemUsIEdGUF9LRVJORUwpOworCX0KK30KKyNlbHNlCitzdGF0aWMgaW5saW5lIHZvaWQga21lbWxlYWtfbG9hZF9tb2R1bGUoc3RydWN0IG1vZHVsZSAqbW9kLCBFbGZfRWhkciAqaGRyLAorCQkJCQlFbGZfU2hkciAqc2VjaGRycywgY2hhciAqc2Vjc3RyaW5ncykKK3sKK30KKyNlbmRpZgorCiAvKiBBbGxvY2F0ZSBhbmQgbG9hZCB0aGUgbW9kdWxlOiBub3RlIHRoYXQgc2l6ZSBvZiBzZWN0aW9uIDAgaXMgYWx3YXlzCiAgICB6ZXJvLCBhbmQgd2UgcmVseSBvbiB0aGlzIGZvciBvcHRpb25hbCBzZWN0aW9ucy4gKi8KIHN0YXRpYyBub2lubGluZSBzdHJ1Y3QgbW9kdWxlICpsb2FkX21vZHVsZSh2b2lkIF9fdXNlciAqdW1vZCwKQEAgLTIwNDksNiArMjA5MSwxMiBAQAogCiAJLyogRG8gdGhlIGFsbG9jcy4gKi8KIAlwdHIgPSBtb2R1bGVfYWxsb2NfdXBkYXRlX2JvdW5kcyhtb2QtPmNvcmVfc2l6ZSk7CisJLyoKKwkgKiBUaGUgcG9pbnRlciB0byB0aGlzIGJsb2NrIGlzIHN0b3JlZCBpbiB0aGUgbW9kdWxlIHN0cnVjdHVyZQorCSAqIHdoaWNoIGlzIGluc2lkZSB0aGUgYmxvY2suIEp1c3QgbWFyayBpdCBhcyBub3QgYmVpbmcgYQorCSAqIGxlYWsuCisJICovCisJa21lbWxlYWtfbm90X2xlYWsocHRyKTsKIAlpZiAoIXB0cikgewogCQllcnIgPSAtRU5PTUVNOwogCQlnb3RvIGZyZWVfcGVyY3B1OwpAQCAtMjA1Nyw2ICsyMTA1LDEzIEBACiAJbW9kLT5tb2R1bGVfY29yZSA9IHB0cjsKIAogCXB0ciA9IG1vZHVsZV9hbGxvY191cGRhdGVfYm91bmRzKG1vZC0+aW5pdF9zaXplKTsKKwkvKgorCSAqIFRoZSBwb2ludGVyIHRvIHRoaXMgYmxvY2sgaXMgc3RvcmVkIGluIHRoZSBtb2R1bGUgc3RydWN0dXJlCisJICogd2hpY2ggaXMgaW5zaWRlIHRoZSBibG9jay4gVGhpcyBibG9jayBkb2Vzbid0IG5lZWQgdG8gYmUKKwkgKiBzY2FubmVkIGFzIGl0IGNvbnRhaW5zIGRhdGEgYW5kIGNvZGUgdGhhdCB3aWxsIGJlIGZyZWVkCisJICogYWZ0ZXIgdGhlIG1vZHVsZSBpcyBpbml0aWFsaXplZC4KKwkgKi8KKwlrbWVtbGVha19pZ25vcmUocHRyKTsKIAlpZiAoIXB0ciAmJiBtb2QtPmluaXRfc2l6ZSkgewogCQllcnIgPSAtRU5PTUVNOwogCQlnb3RvIGZyZWVfY29yZTsKQEAgLTIwODcsNiArMjE0Miw3IEBACiAJfQogCS8qIE1vZHVsZSBoYXMgYmVlbiBtb3ZlZC4gKi8KIAltb2QgPSAodm9pZCAqKXNlY2hkcnNbbW9kaW5kZXhdLnNoX2FkZHI7CisJa21lbWxlYWtfbG9hZF9tb2R1bGUobW9kLCBoZHIsIHNlY2hkcnMsIHNlY3N0cmluZ3MpOwogCiAjaWYgZGVmaW5lZChDT05GSUdfTU9EVUxFX1VOTE9BRCkgJiYgZGVmaW5lZChDT05GSUdfU01QKQogCW1vZC0+cmVmcHRyID0gcGVyY3B1X21vZGFsbG9jKHNpemVvZihsb2NhbF90KSwgX19hbGlnbm9mX18obG9jYWxfdCksCmRpZmYgLS1naXQgYS9rZXJuZWwvbXV0ZXguYyBiL2tlcm5lbC9tdXRleC5jCmluZGV4IGU1Y2MwY2QuLjk0N2IzYWQgMTAwNjQ0Ci0tLSBhL2tlcm5lbC9tdXRleC5jCisrKyBiL2tlcm5lbC9tdXRleC5jCkBAIC04OSw3ICs4OSw3IEBACiAgKgogICogVGhpcyBmdW5jdGlvbiBpcyBzaW1pbGFyIHRvIChidXQgbm90IGVxdWl2YWxlbnQgdG8pIGRvd24oKS4KICAqLwotdm9pZCBpbmxpbmUgX19zY2hlZCBtdXRleF9sb2NrKHN0cnVjdCBtdXRleCAqbG9jaykKK3ZvaWQgX19zY2hlZCBtdXRleF9sb2NrKHN0cnVjdCBtdXRleCAqbG9jaykKIHsKIAltaWdodF9zbGVlcCgpOwogCS8qCmRpZmYgLS1naXQgYS9rZXJuZWwvcGVyZl9jb3VudGVyLmMgYi9rZXJuZWwvcGVyZl9jb3VudGVyLmMKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uZWY1ZDhhNQotLS0gL2Rldi9udWxsCisrKyBiL2tlcm5lbC9wZXJmX2NvdW50ZXIuYwpAQCAtMCwwICsxLDQyNjAgQEAKKy8qCisgKiBQZXJmb3JtYW5jZSBjb3VudGVyIGNvcmUgY29kZQorICoKKyAqICBDb3B5cmlnaHQgKEMpIDIwMDggVGhvbWFzIEdsZWl4bmVyIDx0Z2x4QGxpbnV0cm9uaXguZGU+CisgKiAgQ29weXJpZ2h0IChDKSAyMDA4LTIwMDkgUmVkIEhhdCwgSW5jLiwgSW5nbyBNb2xuYXIKKyAqICBDb3B5cmlnaHQgKEMpIDIwMDgtMjAwOSBSZWQgSGF0LCBJbmMuLCBQZXRlciBaaWpsc3RyYSA8cHppamxzdHJAcmVkaGF0LmNvbT4KKyAqICBDb3B5cmlnaHQgIKkgIDIwMDkgUGF1bCBNYWNrZXJyYXMsIElCTSBDb3JwLiA8cGF1bHVzQGF1MS5pYm0uY29tPgorICoKKyAqICBGb3IgbGljZW5zaW5nIGRldGFpbHMgc2VlIGtlcm5lbC1iYXNlL0NPUFlJTkcKKyAqLworCisjaW5jbHVkZSA8bGludXgvZnMuaD4KKyNpbmNsdWRlIDxsaW51eC9tbS5oPgorI2luY2x1ZGUgPGxpbnV4L2NwdS5oPgorI2luY2x1ZGUgPGxpbnV4L3NtcC5oPgorI2luY2x1ZGUgPGxpbnV4L2ZpbGUuaD4KKyNpbmNsdWRlIDxsaW51eC9wb2xsLmg+CisjaW5jbHVkZSA8bGludXgvc3lzZnMuaD4KKyNpbmNsdWRlIDxsaW51eC9kY2FjaGUuaD4KKyNpbmNsdWRlIDxsaW51eC9wZXJjcHUuaD4KKyNpbmNsdWRlIDxsaW51eC9wdHJhY2UuaD4KKyNpbmNsdWRlIDxsaW51eC92bXN0YXQuaD4KKyNpbmNsdWRlIDxsaW51eC9oYXJkaXJxLmg+CisjaW5jbHVkZSA8bGludXgvcmN1bGlzdC5oPgorI2luY2x1ZGUgPGxpbnV4L3VhY2Nlc3MuaD4KKyNpbmNsdWRlIDxsaW51eC9zeXNjYWxscy5oPgorI2luY2x1ZGUgPGxpbnV4L2Fub25faW5vZGVzLmg+CisjaW5jbHVkZSA8bGludXgva2VybmVsX3N0YXQuaD4KKyNpbmNsdWRlIDxsaW51eC9wZXJmX2NvdW50ZXIuaD4KKworI2luY2x1ZGUgPGFzbS9pcnFfcmVncy5oPgorCisvKgorICogRWFjaCBDUFUgaGFzIGEgbGlzdCBvZiBwZXIgQ1BVIGNvdW50ZXJzOgorICovCitERUZJTkVfUEVSX0NQVShzdHJ1Y3QgcGVyZl9jcHVfY29udGV4dCwgcGVyZl9jcHVfY29udGV4dCk7CisKK2ludCBwZXJmX21heF9jb3VudGVycyBfX3JlYWRfbW9zdGx5ID0gMTsKK3N0YXRpYyBpbnQgcGVyZl9yZXNlcnZlZF9wZXJjcHUgX19yZWFkX21vc3RseTsKK3N0YXRpYyBpbnQgcGVyZl9vdmVyY29tbWl0IF9fcmVhZF9tb3N0bHkgPSAxOworCitzdGF0aWMgYXRvbWljX3QgbnJfY291bnRlcnMgX19yZWFkX21vc3RseTsKK3N0YXRpYyBhdG9taWNfdCBucl9tbWFwX2NvdW50ZXJzIF9fcmVhZF9tb3N0bHk7CitzdGF0aWMgYXRvbWljX3QgbnJfY29tbV9jb3VudGVycyBfX3JlYWRfbW9zdGx5OworCisvKgorICogcGVyZiBjb3VudGVyIHBhcmFub2lhIGxldmVsOgorICogIDAgLSBub3QgcGFyYW5vaWQKKyAqICAxIC0gZGlzYWxsb3cgY3B1IGNvdW50ZXJzIHRvIHVucHJpdgorICogIDIgLSBkaXNhbGxvdyBrZXJuZWwgcHJvZmlsaW5nIHRvIHVucHJpdgorICovCitpbnQgc3lzY3RsX3BlcmZfY291bnRlcl9wYXJhbm9pZCBfX3JlYWRfbW9zdGx5OworCitzdGF0aWMgaW5saW5lIGJvb2wgcGVyZl9wYXJhbm9pZF9jcHUodm9pZCkKK3sKKwlyZXR1cm4gc3lzY3RsX3BlcmZfY291bnRlcl9wYXJhbm9pZCA+IDA7Cit9CisKK3N0YXRpYyBpbmxpbmUgYm9vbCBwZXJmX3BhcmFub2lkX2tlcm5lbCh2b2lkKQoreworCXJldHVybiBzeXNjdGxfcGVyZl9jb3VudGVyX3BhcmFub2lkID4gMTsKK30KKworaW50IHN5c2N0bF9wZXJmX2NvdW50ZXJfbWxvY2sgX19yZWFkX21vc3RseSA9IDUxMjsgLyogJ2ZyZWUnIGtiIHBlciB1c2VyICovCisKKy8qCisgKiBtYXggcGVyZiBjb3VudGVyIHNhbXBsZSByYXRlCisgKi8KK2ludCBzeXNjdGxfcGVyZl9jb3VudGVyX3NhbXBsZV9yYXRlIF9fcmVhZF9tb3N0bHkgPSAxMDAwMDA7CisKK3N0YXRpYyBhdG9taWM2NF90IHBlcmZfY291bnRlcl9pZDsKKworLyoKKyAqIExvY2sgZm9yIChzeXNhZG1pbi1jb25maWd1cmFibGUpIGNvdW50ZXIgcmVzZXJ2YXRpb25zOgorICovCitzdGF0aWMgREVGSU5FX1NQSU5MT0NLKHBlcmZfcmVzb3VyY2VfbG9jayk7CisKKy8qCisgKiBBcmNoaXRlY3R1cmUgcHJvdmlkZWQgQVBJcyAtIHdlYWsgYWxpYXNlczoKKyAqLworZXh0ZXJuIF9fd2VhayBjb25zdCBzdHJ1Y3QgcG11ICpod19wZXJmX2NvdW50ZXJfaW5pdChzdHJ1Y3QgcGVyZl9jb3VudGVyICpjb3VudGVyKQoreworCXJldHVybiBOVUxMOworfQorCit2b2lkIF9fd2VhayBod19wZXJmX2Rpc2FibGUodm9pZCkJCXsgYmFycmllcigpOyB9Cit2b2lkIF9fd2VhayBod19wZXJmX2VuYWJsZSh2b2lkKQkJeyBiYXJyaWVyKCk7IH0KKwordm9pZCBfX3dlYWsgaHdfcGVyZl9jb3VudGVyX3NldHVwKGludCBjcHUpCXsgYmFycmllcigpOyB9CisKK2ludCBfX3dlYWsKK2h3X3BlcmZfZ3JvdXBfc2NoZWRfaW4oc3RydWN0IHBlcmZfY291bnRlciAqZ3JvdXBfbGVhZGVyLAorCSAgICAgICBzdHJ1Y3QgcGVyZl9jcHVfY29udGV4dCAqY3B1Y3R4LAorCSAgICAgICBzdHJ1Y3QgcGVyZl9jb3VudGVyX2NvbnRleHQgKmN0eCwgaW50IGNwdSkKK3sKKwlyZXR1cm4gMDsKK30KKwordm9pZCBfX3dlYWsgcGVyZl9jb3VudGVyX3ByaW50X2RlYnVnKHZvaWQpCXsgfQorCitzdGF0aWMgREVGSU5FX1BFUl9DUFUoaW50LCBkaXNhYmxlX2NvdW50KTsKKwordm9pZCBfX3BlcmZfZGlzYWJsZSh2b2lkKQoreworCV9fZ2V0X2NwdV92YXIoZGlzYWJsZV9jb3VudCkrKzsKK30KKworYm9vbCBfX3BlcmZfZW5hYmxlKHZvaWQpCit7CisJcmV0dXJuICEtLV9fZ2V0X2NwdV92YXIoZGlzYWJsZV9jb3VudCk7Cit9CisKK3ZvaWQgcGVyZl9kaXNhYmxlKHZvaWQpCit7CisJX19wZXJmX2Rpc2FibGUoKTsKKwlod19wZXJmX2Rpc2FibGUoKTsKK30KKwordm9pZCBwZXJmX2VuYWJsZSh2b2lkKQoreworCWlmIChfX3BlcmZfZW5hYmxlKCkpCisJCWh3X3BlcmZfZW5hYmxlKCk7Cit9CisKK3N0YXRpYyB2b2lkIGdldF9jdHgoc3RydWN0IHBlcmZfY291bnRlcl9jb250ZXh0ICpjdHgpCit7CisJYXRvbWljX2luYygmY3R4LT5yZWZjb3VudCk7Cit9CisKK3N0YXRpYyB2b2lkIGZyZWVfY3R4KHN0cnVjdCByY3VfaGVhZCAqaGVhZCkKK3sKKwlzdHJ1Y3QgcGVyZl9jb3VudGVyX2NvbnRleHQgKmN0eDsKKworCWN0eCA9IGNvbnRhaW5lcl9vZihoZWFkLCBzdHJ1Y3QgcGVyZl9jb3VudGVyX2NvbnRleHQsIHJjdV9oZWFkKTsKKwlrZnJlZShjdHgpOworfQorCitzdGF0aWMgdm9pZCBwdXRfY3R4KHN0cnVjdCBwZXJmX2NvdW50ZXJfY29udGV4dCAqY3R4KQoreworCWlmIChhdG9taWNfZGVjX2FuZF90ZXN0KCZjdHgtPnJlZmNvdW50KSkgeworCQlpZiAoY3R4LT5wYXJlbnRfY3R4KQorCQkJcHV0X2N0eChjdHgtPnBhcmVudF9jdHgpOworCQlpZiAoY3R4LT50YXNrKQorCQkJcHV0X3Rhc2tfc3RydWN0KGN0eC0+dGFzayk7CisJCWNhbGxfcmN1KCZjdHgtPnJjdV9oZWFkLCBmcmVlX2N0eCk7CisJfQorfQorCisvKgorICogR2V0IHRoZSBwZXJmX2NvdW50ZXJfY29udGV4dCBmb3IgYSB0YXNrIGFuZCBsb2NrIGl0LgorICogVGhpcyBoYXMgdG8gY29wZSB3aXRoIHdpdGggdGhlIGZhY3QgdGhhdCB1bnRpbCBpdCBpcyBsb2NrZWQsCisgKiB0aGUgY29udGV4dCBjb3VsZCBnZXQgbW92ZWQgdG8gYW5vdGhlciB0YXNrLgorICovCitzdGF0aWMgc3RydWN0IHBlcmZfY291bnRlcl9jb250ZXh0ICoKK3BlcmZfbG9ja190YXNrX2NvbnRleHQoc3RydWN0IHRhc2tfc3RydWN0ICp0YXNrLCB1bnNpZ25lZCBsb25nICpmbGFncykKK3sKKwlzdHJ1Y3QgcGVyZl9jb3VudGVyX2NvbnRleHQgKmN0eDsKKworCXJjdV9yZWFkX2xvY2soKTsKKyByZXRyeToKKwljdHggPSByY3VfZGVyZWZlcmVuY2UodGFzay0+cGVyZl9jb3VudGVyX2N0eHApOworCWlmIChjdHgpIHsKKwkJLyoKKwkJICogSWYgdGhpcyBjb250ZXh0IGlzIGEgY2xvbmUgb2YgYW5vdGhlciwgaXQgbWlnaHQKKwkJICogZ2V0IHN3YXBwZWQgZm9yIGFub3RoZXIgdW5kZXJuZWF0aCB1cyBieQorCQkgKiBwZXJmX2NvdW50ZXJfdGFza19zY2hlZF9vdXQsIHRob3VnaCB0aGUKKwkJICogcmN1X3JlYWRfbG9jaygpIHByb3RlY3RzIHVzIGZyb20gYW55IGNvbnRleHQKKwkJICogZ2V0dGluZyBmcmVlZC4gIExvY2sgdGhlIGNvbnRleHQgYW5kIGNoZWNrIGlmIGl0CisJCSAqIGdvdCBzd2FwcGVkIGJlZm9yZSB3ZSBjb3VsZCBnZXQgdGhlIGxvY2ssIGFuZCByZXRyeQorCQkgKiBpZiBzby4gIElmIHdlIGxvY2tlZCB0aGUgcmlnaHQgY29udGV4dCwgdGhlbiBpdAorCQkgKiBjYW4ndCBnZXQgc3dhcHBlZCBvbiB1cyBhbnkgbW9yZS4KKwkJICovCisJCXNwaW5fbG9ja19pcnFzYXZlKCZjdHgtPmxvY2ssICpmbGFncyk7CisJCWlmIChjdHggIT0gcmN1X2RlcmVmZXJlbmNlKHRhc2stPnBlcmZfY291bnRlcl9jdHhwKSkgeworCQkJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmY3R4LT5sb2NrLCAqZmxhZ3MpOworCQkJZ290byByZXRyeTsKKwkJfQorCX0KKwlyY3VfcmVhZF91bmxvY2soKTsKKwlyZXR1cm4gY3R4OworfQorCisvKgorICogR2V0IHRoZSBjb250ZXh0IGZvciBhIHRhc2sgYW5kIGluY3JlbWVudCBpdHMgcGluX2NvdW50IHNvIGl0CisgKiBjYW4ndCBnZXQgc3dhcHBlZCB0byBhbm90aGVyIHRhc2suICBUaGlzIGFsc28gaW5jcmVtZW50cyBpdHMKKyAqIHJlZmVyZW5jZSBjb3VudCBzbyB0aGF0IHRoZSBjb250ZXh0IGNhbid0IGdldCBmcmVlZC4KKyAqLworc3RhdGljIHN0cnVjdCBwZXJmX2NvdW50ZXJfY29udGV4dCAqcGVyZl9waW5fdGFza19jb250ZXh0KHN0cnVjdCB0YXNrX3N0cnVjdCAqdGFzaykKK3sKKwlzdHJ1Y3QgcGVyZl9jb3VudGVyX2NvbnRleHQgKmN0eDsKKwl1bnNpZ25lZCBsb25nIGZsYWdzOworCisJY3R4ID0gcGVyZl9sb2NrX3Rhc2tfY29udGV4dCh0YXNrLCAmZmxhZ3MpOworCWlmIChjdHgpIHsKKwkJKytjdHgtPnBpbl9jb3VudDsKKwkJZ2V0X2N0eChjdHgpOworCQlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZjdHgtPmxvY2ssIGZsYWdzKTsKKwl9CisJcmV0dXJuIGN0eDsKK30KKworc3RhdGljIHZvaWQgcGVyZl91bnBpbl9jb250ZXh0KHN0cnVjdCBwZXJmX2NvdW50ZXJfY29udGV4dCAqY3R4KQoreworCXVuc2lnbmVkIGxvbmcgZmxhZ3M7CisKKwlzcGluX2xvY2tfaXJxc2F2ZSgmY3R4LT5sb2NrLCBmbGFncyk7CisJLS1jdHgtPnBpbl9jb3VudDsKKwlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZjdHgtPmxvY2ssIGZsYWdzKTsKKwlwdXRfY3R4KGN0eCk7Cit9CisKKy8qCisgKiBBZGQgYSBjb3VudGVyIGZyb20gdGhlIGxpc3RzIGZvciBpdHMgY29udGV4dC4KKyAqIE11c3QgYmUgY2FsbGVkIHdpdGggY3R4LT5tdXRleCBhbmQgY3R4LT5sb2NrIGhlbGQuCisgKi8KK3N0YXRpYyB2b2lkCitsaXN0X2FkZF9jb3VudGVyKHN0cnVjdCBwZXJmX2NvdW50ZXIgKmNvdW50ZXIsIHN0cnVjdCBwZXJmX2NvdW50ZXJfY29udGV4dCAqY3R4KQoreworCXN0cnVjdCBwZXJmX2NvdW50ZXIgKmdyb3VwX2xlYWRlciA9IGNvdW50ZXItPmdyb3VwX2xlYWRlcjsKKworCS8qCisJICogRGVwZW5kaW5nIG9uIHdoZXRoZXIgaXQgaXMgYSBzdGFuZGFsb25lIG9yIHNpYmxpbmcgY291bnRlciwKKwkgKiBhZGQgaXQgc3RyYWlnaHQgdG8gdGhlIGNvbnRleHQncyBjb3VudGVyIGxpc3QsIG9yIHRvIHRoZSBncm91cAorCSAqIGxlYWRlcidzIHNpYmxpbmcgbGlzdDoKKwkgKi8KKwlpZiAoZ3JvdXBfbGVhZGVyID09IGNvdW50ZXIpCisJCWxpc3RfYWRkX3RhaWwoJmNvdW50ZXItPmxpc3RfZW50cnksICZjdHgtPmNvdW50ZXJfbGlzdCk7CisJZWxzZSB7CisJCWxpc3RfYWRkX3RhaWwoJmNvdW50ZXItPmxpc3RfZW50cnksICZncm91cF9sZWFkZXItPnNpYmxpbmdfbGlzdCk7CisJCWdyb3VwX2xlYWRlci0+bnJfc2libGluZ3MrKzsKKwl9CisKKwlsaXN0X2FkZF9yY3UoJmNvdW50ZXItPmV2ZW50X2VudHJ5LCAmY3R4LT5ldmVudF9saXN0KTsKKwljdHgtPm5yX2NvdW50ZXJzKys7Cit9CisKKy8qCisgKiBSZW1vdmUgYSBjb3VudGVyIGZyb20gdGhlIGxpc3RzIGZvciBpdHMgY29udGV4dC4KKyAqIE11c3QgYmUgY2FsbGVkIHdpdGggY3R4LT5tdXRleCBhbmQgY3R4LT5sb2NrIGhlbGQuCisgKi8KK3N0YXRpYyB2b2lkCitsaXN0X2RlbF9jb3VudGVyKHN0cnVjdCBwZXJmX2NvdW50ZXIgKmNvdW50ZXIsIHN0cnVjdCBwZXJmX2NvdW50ZXJfY29udGV4dCAqY3R4KQoreworCXN0cnVjdCBwZXJmX2NvdW50ZXIgKnNpYmxpbmcsICp0bXA7CisKKwlpZiAobGlzdF9lbXB0eSgmY291bnRlci0+bGlzdF9lbnRyeSkpCisJCXJldHVybjsKKwljdHgtPm5yX2NvdW50ZXJzLS07CisKKwlsaXN0X2RlbF9pbml0KCZjb3VudGVyLT5saXN0X2VudHJ5KTsKKwlsaXN0X2RlbF9yY3UoJmNvdW50ZXItPmV2ZW50X2VudHJ5KTsKKworCWlmIChjb3VudGVyLT5ncm91cF9sZWFkZXIgIT0gY291bnRlcikKKwkJY291bnRlci0+Z3JvdXBfbGVhZGVyLT5ucl9zaWJsaW5ncy0tOworCisJLyoKKwkgKiBJZiB0aGlzIHdhcyBhIGdyb3VwIGNvdW50ZXIgd2l0aCBzaWJsaW5nIGNvdW50ZXJzIHRoZW4KKwkgKiB1cGdyYWRlIHRoZSBzaWJsaW5ncyB0byBzaW5nbGV0b24gY291bnRlcnMgYnkgYWRkaW5nIHRoZW0KKwkgKiB0byB0aGUgY29udGV4dCBsaXN0IGRpcmVjdGx5OgorCSAqLworCWxpc3RfZm9yX2VhY2hfZW50cnlfc2FmZShzaWJsaW5nLCB0bXAsCisJCQkJICZjb3VudGVyLT5zaWJsaW5nX2xpc3QsIGxpc3RfZW50cnkpIHsKKworCQlsaXN0X21vdmVfdGFpbCgmc2libGluZy0+bGlzdF9lbnRyeSwgJmN0eC0+Y291bnRlcl9saXN0KTsKKwkJc2libGluZy0+Z3JvdXBfbGVhZGVyID0gc2libGluZzsKKwl9Cit9CisKK3N0YXRpYyB2b2lkCitjb3VudGVyX3NjaGVkX291dChzdHJ1Y3QgcGVyZl9jb3VudGVyICpjb3VudGVyLAorCQkgIHN0cnVjdCBwZXJmX2NwdV9jb250ZXh0ICpjcHVjdHgsCisJCSAgc3RydWN0IHBlcmZfY291bnRlcl9jb250ZXh0ICpjdHgpCit7CisJaWYgKGNvdW50ZXItPnN0YXRlICE9IFBFUkZfQ09VTlRFUl9TVEFURV9BQ1RJVkUpCisJCXJldHVybjsKKworCWNvdW50ZXItPnN0YXRlID0gUEVSRl9DT1VOVEVSX1NUQVRFX0lOQUNUSVZFOworCWNvdW50ZXItPnRzdGFtcF9zdG9wcGVkID0gY3R4LT50aW1lOworCWNvdW50ZXItPnBtdS0+ZGlzYWJsZShjb3VudGVyKTsKKwljb3VudGVyLT5vbmNwdSA9IC0xOworCisJaWYgKCFpc19zb2Z0d2FyZV9jb3VudGVyKGNvdW50ZXIpKQorCQljcHVjdHgtPmFjdGl2ZV9vbmNwdS0tOworCWN0eC0+bnJfYWN0aXZlLS07CisJaWYgKGNvdW50ZXItPmF0dHIuZXhjbHVzaXZlIHx8ICFjcHVjdHgtPmFjdGl2ZV9vbmNwdSkKKwkJY3B1Y3R4LT5leGNsdXNpdmUgPSAwOworfQorCitzdGF0aWMgdm9pZAorZ3JvdXBfc2NoZWRfb3V0KHN0cnVjdCBwZXJmX2NvdW50ZXIgKmdyb3VwX2NvdW50ZXIsCisJCXN0cnVjdCBwZXJmX2NwdV9jb250ZXh0ICpjcHVjdHgsCisJCXN0cnVjdCBwZXJmX2NvdW50ZXJfY29udGV4dCAqY3R4KQoreworCXN0cnVjdCBwZXJmX2NvdW50ZXIgKmNvdW50ZXI7CisKKwlpZiAoZ3JvdXBfY291bnRlci0+c3RhdGUgIT0gUEVSRl9DT1VOVEVSX1NUQVRFX0FDVElWRSkKKwkJcmV0dXJuOworCisJY291bnRlcl9zY2hlZF9vdXQoZ3JvdXBfY291bnRlciwgY3B1Y3R4LCBjdHgpOworCisJLyoKKwkgKiBTY2hlZHVsZSBvdXQgc2libGluZ3MgKGlmIGFueSk6CisJICovCisJbGlzdF9mb3JfZWFjaF9lbnRyeShjb3VudGVyLCAmZ3JvdXBfY291bnRlci0+c2libGluZ19saXN0LCBsaXN0X2VudHJ5KQorCQljb3VudGVyX3NjaGVkX291dChjb3VudGVyLCBjcHVjdHgsIGN0eCk7CisKKwlpZiAoZ3JvdXBfY291bnRlci0+YXR0ci5leGNsdXNpdmUpCisJCWNwdWN0eC0+ZXhjbHVzaXZlID0gMDsKK30KKworLyoKKyAqIENyb3NzIENQVSBjYWxsIHRvIHJlbW92ZSBhIHBlcmZvcm1hbmNlIGNvdW50ZXIKKyAqCisgKiBXZSBkaXNhYmxlIHRoZSBjb3VudGVyIG9uIHRoZSBoYXJkd2FyZSBsZXZlbCBmaXJzdC4gQWZ0ZXIgdGhhdCB3ZQorICogcmVtb3ZlIGl0IGZyb20gdGhlIGNvbnRleHQgbGlzdC4KKyAqLworc3RhdGljIHZvaWQgX19wZXJmX2NvdW50ZXJfcmVtb3ZlX2Zyb21fY29udGV4dCh2b2lkICppbmZvKQoreworCXN0cnVjdCBwZXJmX2NwdV9jb250ZXh0ICpjcHVjdHggPSAmX19nZXRfY3B1X3ZhcihwZXJmX2NwdV9jb250ZXh0KTsKKwlzdHJ1Y3QgcGVyZl9jb3VudGVyICpjb3VudGVyID0gaW5mbzsKKwlzdHJ1Y3QgcGVyZl9jb3VudGVyX2NvbnRleHQgKmN0eCA9IGNvdW50ZXItPmN0eDsKKworCS8qCisJICogSWYgdGhpcyBpcyBhIHRhc2sgY29udGV4dCwgd2UgbmVlZCB0byBjaGVjayB3aGV0aGVyIGl0IGlzCisJICogdGhlIGN1cnJlbnQgdGFzayBjb250ZXh0IG9mIHRoaXMgY3B1LiBJZiBub3QgaXQgaGFzIGJlZW4KKwkgKiBzY2hlZHVsZWQgb3V0IGJlZm9yZSB0aGUgc21wIGNhbGwgYXJyaXZlZC4KKwkgKi8KKwlpZiAoY3R4LT50YXNrICYmIGNwdWN0eC0+dGFza19jdHggIT0gY3R4KQorCQlyZXR1cm47CisKKwlzcGluX2xvY2soJmN0eC0+bG9jayk7CisJLyoKKwkgKiBQcm90ZWN0IHRoZSBsaXN0IG9wZXJhdGlvbiBhZ2FpbnN0IE5NSSBieSBkaXNhYmxpbmcgdGhlCisJICogY291bnRlcnMgb24gYSBnbG9iYWwgbGV2ZWwuCisJICovCisJcGVyZl9kaXNhYmxlKCk7CisKKwljb3VudGVyX3NjaGVkX291dChjb3VudGVyLCBjcHVjdHgsIGN0eCk7CisKKwlsaXN0X2RlbF9jb3VudGVyKGNvdW50ZXIsIGN0eCk7CisKKwlpZiAoIWN0eC0+dGFzaykgeworCQkvKgorCQkgKiBBbGxvdyBtb3JlIHBlciB0YXNrIGNvdW50ZXJzIHdpdGggcmVzcGVjdCB0byB0aGUKKwkJICogcmVzZXJ2YXRpb246CisJCSAqLworCQljcHVjdHgtPm1heF9wZXJ0YXNrID0KKwkJCW1pbihwZXJmX21heF9jb3VudGVycyAtIGN0eC0+bnJfY291bnRlcnMsCisJCQkgICAgcGVyZl9tYXhfY291bnRlcnMgLSBwZXJmX3Jlc2VydmVkX3BlcmNwdSk7CisJfQorCisJcGVyZl9lbmFibGUoKTsKKwlzcGluX3VubG9jaygmY3R4LT5sb2NrKTsKK30KKworCisvKgorICogUmVtb3ZlIHRoZSBjb3VudGVyIGZyb20gYSB0YXNrJ3MgKG9yIGEgQ1BVJ3MpIGxpc3Qgb2YgY291bnRlcnMuCisgKgorICogTXVzdCBiZSBjYWxsZWQgd2l0aCBjdHgtPm11dGV4IGhlbGQuCisgKgorICogQ1BVIGNvdW50ZXJzIGFyZSByZW1vdmVkIHdpdGggYSBzbXAgY2FsbC4gRm9yIHRhc2sgY291bnRlcnMgd2Ugb25seQorICogY2FsbCB3aGVuIHRoZSB0YXNrIGlzIG9uIGEgQ1BVLgorICoKKyAqIElmIGNvdW50ZXItPmN0eCBpcyBhIGNsb25lZCBjb250ZXh0LCBjYWxsZXJzIG11c3QgbWFrZSBzdXJlIHRoYXQKKyAqIGV2ZXJ5IHRhc2sgc3RydWN0IHRoYXQgY291bnRlci0+Y3R4LT50YXNrIGNvdWxkIHBvc3NpYmx5IHBvaW50IHRvCisgKiByZW1haW5zIHZhbGlkLiAgVGhpcyBpcyBPSyB3aGVuIGNhbGxlZCBmcm9tIHBlcmZfcmVsZWFzZSBzaW5jZQorICogdGhhdCBvbmx5IGNhbGxzIHVzIG9uIHRoZSB0b3AtbGV2ZWwgY29udGV4dCwgd2hpY2ggY2FuJ3QgYmUgYSBjbG9uZS4KKyAqIFdoZW4gY2FsbGVkIGZyb20gcGVyZl9jb3VudGVyX2V4aXRfdGFzaywgaXQncyBPSyBiZWNhdXNlIHRoZQorICogY29udGV4dCBoYXMgYmVlbiBkZXRhY2hlZCBmcm9tIGl0cyB0YXNrLgorICovCitzdGF0aWMgdm9pZCBwZXJmX2NvdW50ZXJfcmVtb3ZlX2Zyb21fY29udGV4dChzdHJ1Y3QgcGVyZl9jb3VudGVyICpjb3VudGVyKQoreworCXN0cnVjdCBwZXJmX2NvdW50ZXJfY29udGV4dCAqY3R4ID0gY291bnRlci0+Y3R4OworCXN0cnVjdCB0YXNrX3N0cnVjdCAqdGFzayA9IGN0eC0+dGFzazsKKworCWlmICghdGFzaykgeworCQkvKgorCQkgKiBQZXIgY3B1IGNvdW50ZXJzIGFyZSByZW1vdmVkIHZpYSBhbiBzbXAgY2FsbCBhbmQKKwkJICogdGhlIHJlbW92YWwgaXMgYWx3YXlzIHN1Y2Vzc2Z1bC4KKwkJICovCisJCXNtcF9jYWxsX2Z1bmN0aW9uX3NpbmdsZShjb3VudGVyLT5jcHUsCisJCQkJCSBfX3BlcmZfY291bnRlcl9yZW1vdmVfZnJvbV9jb250ZXh0LAorCQkJCQkgY291bnRlciwgMSk7CisJCXJldHVybjsKKwl9CisKK3JldHJ5OgorCXRhc2tfb25jcHVfZnVuY3Rpb25fY2FsbCh0YXNrLCBfX3BlcmZfY291bnRlcl9yZW1vdmVfZnJvbV9jb250ZXh0LAorCQkJCSBjb3VudGVyKTsKKworCXNwaW5fbG9ja19pcnEoJmN0eC0+bG9jayk7CisJLyoKKwkgKiBJZiB0aGUgY29udGV4dCBpcyBhY3RpdmUgd2UgbmVlZCB0byByZXRyeSB0aGUgc21wIGNhbGwuCisJICovCisJaWYgKGN0eC0+bnJfYWN0aXZlICYmICFsaXN0X2VtcHR5KCZjb3VudGVyLT5saXN0X2VudHJ5KSkgeworCQlzcGluX3VubG9ja19pcnEoJmN0eC0+bG9jayk7CisJCWdvdG8gcmV0cnk7CisJfQorCisJLyoKKwkgKiBUaGUgbG9jayBwcmV2ZW50cyB0aGF0IHRoaXMgY29udGV4dCBpcyBzY2hlZHVsZWQgaW4gc28gd2UKKwkgKiBjYW4gcmVtb3ZlIHRoZSBjb3VudGVyIHNhZmVseSwgaWYgdGhlIGNhbGwgYWJvdmUgZGlkIG5vdAorCSAqIHN1Y2NlZWQuCisJICovCisJaWYgKCFsaXN0X2VtcHR5KCZjb3VudGVyLT5saXN0X2VudHJ5KSkgeworCQlsaXN0X2RlbF9jb3VudGVyKGNvdW50ZXIsIGN0eCk7CisJfQorCXNwaW5fdW5sb2NrX2lycSgmY3R4LT5sb2NrKTsKK30KKworc3RhdGljIGlubGluZSB1NjQgcGVyZl9jbG9jayh2b2lkKQoreworCXJldHVybiBjcHVfY2xvY2soc21wX3Byb2Nlc3Nvcl9pZCgpKTsKK30KKworLyoKKyAqIFVwZGF0ZSB0aGUgcmVjb3JkIG9mIHRoZSBjdXJyZW50IHRpbWUgaW4gYSBjb250ZXh0LgorICovCitzdGF0aWMgdm9pZCB1cGRhdGVfY29udGV4dF90aW1lKHN0cnVjdCBwZXJmX2NvdW50ZXJfY29udGV4dCAqY3R4KQoreworCXU2NCBub3cgPSBwZXJmX2Nsb2NrKCk7CisKKwljdHgtPnRpbWUgKz0gbm93IC0gY3R4LT50aW1lc3RhbXA7CisJY3R4LT50aW1lc3RhbXAgPSBub3c7Cit9CisKKy8qCisgKiBVcGRhdGUgdGhlIHRvdGFsX3RpbWVfZW5hYmxlZCBhbmQgdG90YWxfdGltZV9ydW5uaW5nIGZpZWxkcyBmb3IgYSBjb3VudGVyLgorICovCitzdGF0aWMgdm9pZCB1cGRhdGVfY291bnRlcl90aW1lcyhzdHJ1Y3QgcGVyZl9jb3VudGVyICpjb3VudGVyKQoreworCXN0cnVjdCBwZXJmX2NvdW50ZXJfY29udGV4dCAqY3R4ID0gY291bnRlci0+Y3R4OworCXU2NCBydW5fZW5kOworCisJaWYgKGNvdW50ZXItPnN0YXRlIDwgUEVSRl9DT1VOVEVSX1NUQVRFX0lOQUNUSVZFKQorCQlyZXR1cm47CisKKwljb3VudGVyLT50b3RhbF90aW1lX2VuYWJsZWQgPSBjdHgtPnRpbWUgLSBjb3VudGVyLT50c3RhbXBfZW5hYmxlZDsKKworCWlmIChjb3VudGVyLT5zdGF0ZSA9PSBQRVJGX0NPVU5URVJfU1RBVEVfSU5BQ1RJVkUpCisJCXJ1bl9lbmQgPSBjb3VudGVyLT50c3RhbXBfc3RvcHBlZDsKKwllbHNlCisJCXJ1bl9lbmQgPSBjdHgtPnRpbWU7CisKKwljb3VudGVyLT50b3RhbF90aW1lX3J1bm5pbmcgPSBydW5fZW5kIC0gY291bnRlci0+dHN0YW1wX3J1bm5pbmc7Cit9CisKKy8qCisgKiBVcGRhdGUgdG90YWxfdGltZV9lbmFibGVkIGFuZCB0b3RhbF90aW1lX3J1bm5pbmcgZm9yIGFsbCBjb3VudGVycyBpbiBhIGdyb3VwLgorICovCitzdGF0aWMgdm9pZCB1cGRhdGVfZ3JvdXBfdGltZXMoc3RydWN0IHBlcmZfY291bnRlciAqbGVhZGVyKQoreworCXN0cnVjdCBwZXJmX2NvdW50ZXIgKmNvdW50ZXI7CisKKwl1cGRhdGVfY291bnRlcl90aW1lcyhsZWFkZXIpOworCWxpc3RfZm9yX2VhY2hfZW50cnkoY291bnRlciwgJmxlYWRlci0+c2libGluZ19saXN0LCBsaXN0X2VudHJ5KQorCQl1cGRhdGVfY291bnRlcl90aW1lcyhjb3VudGVyKTsKK30KKworLyoKKyAqIENyb3NzIENQVSBjYWxsIHRvIGRpc2FibGUgYSBwZXJmb3JtYW5jZSBjb3VudGVyCisgKi8KK3N0YXRpYyB2b2lkIF9fcGVyZl9jb3VudGVyX2Rpc2FibGUodm9pZCAqaW5mbykKK3sKKwlzdHJ1Y3QgcGVyZl9jb3VudGVyICpjb3VudGVyID0gaW5mbzsKKwlzdHJ1Y3QgcGVyZl9jcHVfY29udGV4dCAqY3B1Y3R4ID0gJl9fZ2V0X2NwdV92YXIocGVyZl9jcHVfY29udGV4dCk7CisJc3RydWN0IHBlcmZfY291bnRlcl9jb250ZXh0ICpjdHggPSBjb3VudGVyLT5jdHg7CisKKwkvKgorCSAqIElmIHRoaXMgaXMgYSBwZXItdGFzayBjb3VudGVyLCBuZWVkIHRvIGNoZWNrIHdoZXRoZXIgdGhpcworCSAqIGNvdW50ZXIncyB0YXNrIGlzIHRoZSBjdXJyZW50IHRhc2sgb24gdGhpcyBjcHUuCisJICovCisJaWYgKGN0eC0+dGFzayAmJiBjcHVjdHgtPnRhc2tfY3R4ICE9IGN0eCkKKwkJcmV0dXJuOworCisJc3Bpbl9sb2NrKCZjdHgtPmxvY2spOworCisJLyoKKwkgKiBJZiB0aGUgY291bnRlciBpcyBvbiwgdHVybiBpdCBvZmYuCisJICogSWYgaXQgaXMgaW4gZXJyb3Igc3RhdGUsIGxlYXZlIGl0IGluIGVycm9yIHN0YXRlLgorCSAqLworCWlmIChjb3VudGVyLT5zdGF0ZSA+PSBQRVJGX0NPVU5URVJfU1RBVEVfSU5BQ1RJVkUpIHsKKwkJdXBkYXRlX2NvbnRleHRfdGltZShjdHgpOworCQl1cGRhdGVfY291bnRlcl90aW1lcyhjb3VudGVyKTsKKwkJaWYgKGNvdW50ZXIgPT0gY291bnRlci0+Z3JvdXBfbGVhZGVyKQorCQkJZ3JvdXBfc2NoZWRfb3V0KGNvdW50ZXIsIGNwdWN0eCwgY3R4KTsKKwkJZWxzZQorCQkJY291bnRlcl9zY2hlZF9vdXQoY291bnRlciwgY3B1Y3R4LCBjdHgpOworCQljb3VudGVyLT5zdGF0ZSA9IFBFUkZfQ09VTlRFUl9TVEFURV9PRkY7CisJfQorCisJc3Bpbl91bmxvY2soJmN0eC0+bG9jayk7Cit9CisKKy8qCisgKiBEaXNhYmxlIGEgY291bnRlci4KKyAqCisgKiBJZiBjb3VudGVyLT5jdHggaXMgYSBjbG9uZWQgY29udGV4dCwgY2FsbGVycyBtdXN0IG1ha2Ugc3VyZSB0aGF0CisgKiBldmVyeSB0YXNrIHN0cnVjdCB0aGF0IGNvdW50ZXItPmN0eC0+dGFzayBjb3VsZCBwb3NzaWJseSBwb2ludCB0bworICogcmVtYWlucyB2YWxpZC4gIFRoaXMgY29uZGl0aW9uIGlzIHNhdGlzaWZlZCB3aGVuIGNhbGxlZCB0aHJvdWdoCisgKiBwZXJmX2NvdW50ZXJfZm9yX2VhY2hfY2hpbGQgb3IgcGVyZl9jb3VudGVyX2Zvcl9lYWNoIGJlY2F1c2UgdGhleQorICogaG9sZCB0aGUgdG9wLWxldmVsIGNvdW50ZXIncyBjaGlsZF9tdXRleCwgc28gYW55IGRlc2NlbmRhbnQgdGhhdAorICogZ29lcyB0byBleGl0IHdpbGwgYmxvY2sgaW4gc3luY19jaGlsZF9jb3VudGVyLgorICogV2hlbiBjYWxsZWQgZnJvbSBwZXJmX3BlbmRpbmdfY291bnRlciBpdCdzIE9LIGJlY2F1c2UgY291bnRlci0+Y3R4CisgKiBpcyB0aGUgY3VycmVudCBjb250ZXh0IG9uIHRoaXMgQ1BVIGFuZCBwcmVlbXB0aW9uIGlzIGRpc2FibGVkLAorICogaGVuY2Ugd2UgY2FuJ3QgZ2V0IGludG8gcGVyZl9jb3VudGVyX3Rhc2tfc2NoZWRfb3V0IGZvciB0aGlzIGNvbnRleHQuCisgKi8KK3N0YXRpYyB2b2lkIHBlcmZfY291bnRlcl9kaXNhYmxlKHN0cnVjdCBwZXJmX2NvdW50ZXIgKmNvdW50ZXIpCit7CisJc3RydWN0IHBlcmZfY291bnRlcl9jb250ZXh0ICpjdHggPSBjb3VudGVyLT5jdHg7CisJc3RydWN0IHRhc2tfc3RydWN0ICp0YXNrID0gY3R4LT50YXNrOworCisJaWYgKCF0YXNrKSB7CisJCS8qCisJCSAqIERpc2FibGUgdGhlIGNvdW50ZXIgb24gdGhlIGNwdSB0aGF0IGl0J3Mgb24KKwkJICovCisJCXNtcF9jYWxsX2Z1bmN0aW9uX3NpbmdsZShjb3VudGVyLT5jcHUsIF9fcGVyZl9jb3VudGVyX2Rpc2FibGUsCisJCQkJCSBjb3VudGVyLCAxKTsKKwkJcmV0dXJuOworCX0KKworIHJldHJ5OgorCXRhc2tfb25jcHVfZnVuY3Rpb25fY2FsbCh0YXNrLCBfX3BlcmZfY291bnRlcl9kaXNhYmxlLCBjb3VudGVyKTsKKworCXNwaW5fbG9ja19pcnEoJmN0eC0+bG9jayk7CisJLyoKKwkgKiBJZiB0aGUgY291bnRlciBpcyBzdGlsbCBhY3RpdmUsIHdlIG5lZWQgdG8gcmV0cnkgdGhlIGNyb3NzLWNhbGwuCisJICovCisJaWYgKGNvdW50ZXItPnN0YXRlID09IFBFUkZfQ09VTlRFUl9TVEFURV9BQ1RJVkUpIHsKKwkJc3Bpbl91bmxvY2tfaXJxKCZjdHgtPmxvY2spOworCQlnb3RvIHJldHJ5OworCX0KKworCS8qCisJICogU2luY2Ugd2UgaGF2ZSB0aGUgbG9jayB0aGlzIGNvbnRleHQgY2FuJ3QgYmUgc2NoZWR1bGVkCisJICogaW4sIHNvIHdlIGNhbiBjaGFuZ2UgdGhlIHN0YXRlIHNhZmVseS4KKwkgKi8KKwlpZiAoY291bnRlci0+c3RhdGUgPT0gUEVSRl9DT1VOVEVSX1NUQVRFX0lOQUNUSVZFKSB7CisJCXVwZGF0ZV9jb3VudGVyX3RpbWVzKGNvdW50ZXIpOworCQljb3VudGVyLT5zdGF0ZSA9IFBFUkZfQ09VTlRFUl9TVEFURV9PRkY7CisJfQorCisJc3Bpbl91bmxvY2tfaXJxKCZjdHgtPmxvY2spOworfQorCitzdGF0aWMgaW50Citjb3VudGVyX3NjaGVkX2luKHN0cnVjdCBwZXJmX2NvdW50ZXIgKmNvdW50ZXIsCisJCSBzdHJ1Y3QgcGVyZl9jcHVfY29udGV4dCAqY3B1Y3R4LAorCQkgc3RydWN0IHBlcmZfY291bnRlcl9jb250ZXh0ICpjdHgsCisJCSBpbnQgY3B1KQoreworCWlmIChjb3VudGVyLT5zdGF0ZSA8PSBQRVJGX0NPVU5URVJfU1RBVEVfT0ZGKQorCQlyZXR1cm4gMDsKKworCWNvdW50ZXItPnN0YXRlID0gUEVSRl9DT1VOVEVSX1NUQVRFX0FDVElWRTsKKwljb3VudGVyLT5vbmNwdSA9IGNwdTsJLyogVE9ETzogcHV0ICdjcHUnIGludG8gY3B1Y3R4LT5jcHUgKi8KKwkvKgorCSAqIFRoZSBuZXcgc3RhdGUgbXVzdCBiZSB2aXNpYmxlIGJlZm9yZSB3ZSB0dXJuIGl0IG9uIGluIHRoZSBoYXJkd2FyZToKKwkgKi8KKwlzbXBfd21iKCk7CisKKwlpZiAoY291bnRlci0+cG11LT5lbmFibGUoY291bnRlcikpIHsKKwkJY291bnRlci0+c3RhdGUgPSBQRVJGX0NPVU5URVJfU1RBVEVfSU5BQ1RJVkU7CisJCWNvdW50ZXItPm9uY3B1ID0gLTE7CisJCXJldHVybiAtRUFHQUlOOworCX0KKworCWNvdW50ZXItPnRzdGFtcF9ydW5uaW5nICs9IGN0eC0+dGltZSAtIGNvdW50ZXItPnRzdGFtcF9zdG9wcGVkOworCisJaWYgKCFpc19zb2Z0d2FyZV9jb3VudGVyKGNvdW50ZXIpKQorCQljcHVjdHgtPmFjdGl2ZV9vbmNwdSsrOworCWN0eC0+bnJfYWN0aXZlKys7CisKKwlpZiAoY291bnRlci0+YXR0ci5leGNsdXNpdmUpCisJCWNwdWN0eC0+ZXhjbHVzaXZlID0gMTsKKworCXJldHVybiAwOworfQorCitzdGF0aWMgaW50Citncm91cF9zY2hlZF9pbihzdHJ1Y3QgcGVyZl9jb3VudGVyICpncm91cF9jb3VudGVyLAorCSAgICAgICBzdHJ1Y3QgcGVyZl9jcHVfY29udGV4dCAqY3B1Y3R4LAorCSAgICAgICBzdHJ1Y3QgcGVyZl9jb3VudGVyX2NvbnRleHQgKmN0eCwKKwkgICAgICAgaW50IGNwdSkKK3sKKwlzdHJ1Y3QgcGVyZl9jb3VudGVyICpjb3VudGVyLCAqcGFydGlhbF9ncm91cDsKKwlpbnQgcmV0OworCisJaWYgKGdyb3VwX2NvdW50ZXItPnN0YXRlID09IFBFUkZfQ09VTlRFUl9TVEFURV9PRkYpCisJCXJldHVybiAwOworCisJcmV0ID0gaHdfcGVyZl9ncm91cF9zY2hlZF9pbihncm91cF9jb3VudGVyLCBjcHVjdHgsIGN0eCwgY3B1KTsKKwlpZiAocmV0KQorCQlyZXR1cm4gcmV0IDwgMCA/IHJldCA6IDA7CisKKwlpZiAoY291bnRlcl9zY2hlZF9pbihncm91cF9jb3VudGVyLCBjcHVjdHgsIGN0eCwgY3B1KSkKKwkJcmV0dXJuIC1FQUdBSU47CisKKwkvKgorCSAqIFNjaGVkdWxlIGluIHNpYmxpbmdzIGFzIG9uZSBncm91cCAoaWYgYW55KToKKwkgKi8KKwlsaXN0X2Zvcl9lYWNoX2VudHJ5KGNvdW50ZXIsICZncm91cF9jb3VudGVyLT5zaWJsaW5nX2xpc3QsIGxpc3RfZW50cnkpIHsKKwkJaWYgKGNvdW50ZXJfc2NoZWRfaW4oY291bnRlciwgY3B1Y3R4LCBjdHgsIGNwdSkpIHsKKwkJCXBhcnRpYWxfZ3JvdXAgPSBjb3VudGVyOworCQkJZ290byBncm91cF9lcnJvcjsKKwkJfQorCX0KKworCXJldHVybiAwOworCitncm91cF9lcnJvcjoKKwkvKgorCSAqIEdyb3VwcyBjYW4gYmUgc2NoZWR1bGVkIGluIGFzIG9uZSB1bml0IG9ubHksIHNvIHVuZG8gYW55CisJICogcGFydGlhbCBncm91cCBiZWZvcmUgcmV0dXJuaW5nOgorCSAqLworCWxpc3RfZm9yX2VhY2hfZW50cnkoY291bnRlciwgJmdyb3VwX2NvdW50ZXItPnNpYmxpbmdfbGlzdCwgbGlzdF9lbnRyeSkgeworCQlpZiAoY291bnRlciA9PSBwYXJ0aWFsX2dyb3VwKQorCQkJYnJlYWs7CisJCWNvdW50ZXJfc2NoZWRfb3V0KGNvdW50ZXIsIGNwdWN0eCwgY3R4KTsKKwl9CisJY291bnRlcl9zY2hlZF9vdXQoZ3JvdXBfY291bnRlciwgY3B1Y3R4LCBjdHgpOworCisJcmV0dXJuIC1FQUdBSU47Cit9CisKKy8qCisgKiBSZXR1cm4gMSBmb3IgYSBncm91cCBjb25zaXN0aW5nIGVudGlyZWx5IG9mIHNvZnR3YXJlIGNvdW50ZXJzLAorICogMCBpZiB0aGUgZ3JvdXAgY29udGFpbnMgYW55IGhhcmR3YXJlIGNvdW50ZXJzLgorICovCitzdGF0aWMgaW50IGlzX3NvZnR3YXJlX29ubHlfZ3JvdXAoc3RydWN0IHBlcmZfY291bnRlciAqbGVhZGVyKQoreworCXN0cnVjdCBwZXJmX2NvdW50ZXIgKmNvdW50ZXI7CisKKwlpZiAoIWlzX3NvZnR3YXJlX2NvdW50ZXIobGVhZGVyKSkKKwkJcmV0dXJuIDA7CisKKwlsaXN0X2Zvcl9lYWNoX2VudHJ5KGNvdW50ZXIsICZsZWFkZXItPnNpYmxpbmdfbGlzdCwgbGlzdF9lbnRyeSkKKwkJaWYgKCFpc19zb2Z0d2FyZV9jb3VudGVyKGNvdW50ZXIpKQorCQkJcmV0dXJuIDA7CisKKwlyZXR1cm4gMTsKK30KKworLyoKKyAqIFdvcmsgb3V0IHdoZXRoZXIgd2UgY2FuIHB1dCB0aGlzIGNvdW50ZXIgZ3JvdXAgb24gdGhlIENQVSBub3cuCisgKi8KK3N0YXRpYyBpbnQgZ3JvdXBfY2FuX2dvX29uKHN0cnVjdCBwZXJmX2NvdW50ZXIgKmNvdW50ZXIsCisJCQkgICBzdHJ1Y3QgcGVyZl9jcHVfY29udGV4dCAqY3B1Y3R4LAorCQkJICAgaW50IGNhbl9hZGRfaHcpCit7CisJLyoKKwkgKiBHcm91cHMgY29uc2lzdGluZyBlbnRpcmVseSBvZiBzb2Z0d2FyZSBjb3VudGVycyBjYW4gYWx3YXlzIGdvIG9uLgorCSAqLworCWlmIChpc19zb2Z0d2FyZV9vbmx5X2dyb3VwKGNvdW50ZXIpKQorCQlyZXR1cm4gMTsKKwkvKgorCSAqIElmIGFuIGV4Y2x1c2l2ZSBncm91cCBpcyBhbHJlYWR5IG9uLCBubyBvdGhlciBoYXJkd2FyZQorCSAqIGNvdW50ZXJzIGNhbiBnbyBvbi4KKwkgKi8KKwlpZiAoY3B1Y3R4LT5leGNsdXNpdmUpCisJCXJldHVybiAwOworCS8qCisJICogSWYgdGhpcyBncm91cCBpcyBleGNsdXNpdmUgYW5kIHRoZXJlIGFyZSBhbHJlYWR5CisJICogY291bnRlcnMgb24gdGhlIENQVSwgaXQgY2FuJ3QgZ28gb24uCisJICovCisJaWYgKGNvdW50ZXItPmF0dHIuZXhjbHVzaXZlICYmIGNwdWN0eC0+YWN0aXZlX29uY3B1KQorCQlyZXR1cm4gMDsKKwkvKgorCSAqIE90aGVyd2lzZSwgdHJ5IHRvIGFkZCBpdCBpZiBhbGwgcHJldmlvdXMgZ3JvdXBzIHdlcmUgYWJsZQorCSAqIHRvIGdvIG9uLgorCSAqLworCXJldHVybiBjYW5fYWRkX2h3OworfQorCitzdGF0aWMgdm9pZCBhZGRfY291bnRlcl90b19jdHgoc3RydWN0IHBlcmZfY291bnRlciAqY291bnRlciwKKwkJCSAgICAgICBzdHJ1Y3QgcGVyZl9jb3VudGVyX2NvbnRleHQgKmN0eCkKK3sKKwlsaXN0X2FkZF9jb3VudGVyKGNvdW50ZXIsIGN0eCk7CisJY291bnRlci0+dHN0YW1wX2VuYWJsZWQgPSBjdHgtPnRpbWU7CisJY291bnRlci0+dHN0YW1wX3J1bm5pbmcgPSBjdHgtPnRpbWU7CisJY291bnRlci0+dHN0YW1wX3N0b3BwZWQgPSBjdHgtPnRpbWU7Cit9CisKKy8qCisgKiBDcm9zcyBDUFUgY2FsbCB0byBpbnN0YWxsIGFuZCBlbmFibGUgYSBwZXJmb3JtYW5jZSBjb3VudGVyCisgKgorICogTXVzdCBiZSBjYWxsZWQgd2l0aCBjdHgtPm11dGV4IGhlbGQKKyAqLworc3RhdGljIHZvaWQgX19wZXJmX2luc3RhbGxfaW5fY29udGV4dCh2b2lkICppbmZvKQoreworCXN0cnVjdCBwZXJmX2NwdV9jb250ZXh0ICpjcHVjdHggPSAmX19nZXRfY3B1X3ZhcihwZXJmX2NwdV9jb250ZXh0KTsKKwlzdHJ1Y3QgcGVyZl9jb3VudGVyICpjb3VudGVyID0gaW5mbzsKKwlzdHJ1Y3QgcGVyZl9jb3VudGVyX2NvbnRleHQgKmN0eCA9IGNvdW50ZXItPmN0eDsKKwlzdHJ1Y3QgcGVyZl9jb3VudGVyICpsZWFkZXIgPSBjb3VudGVyLT5ncm91cF9sZWFkZXI7CisJaW50IGNwdSA9IHNtcF9wcm9jZXNzb3JfaWQoKTsKKwlpbnQgZXJyOworCisJLyoKKwkgKiBJZiB0aGlzIGlzIGEgdGFzayBjb250ZXh0LCB3ZSBuZWVkIHRvIGNoZWNrIHdoZXRoZXIgaXQgaXMKKwkgKiB0aGUgY3VycmVudCB0YXNrIGNvbnRleHQgb2YgdGhpcyBjcHUuIElmIG5vdCBpdCBoYXMgYmVlbgorCSAqIHNjaGVkdWxlZCBvdXQgYmVmb3JlIHRoZSBzbXAgY2FsbCBhcnJpdmVkLgorCSAqIE9yIHBvc3NpYmx5IHRoaXMgaXMgdGhlIHJpZ2h0IGNvbnRleHQgYnV0IGl0IGlzbid0CisJICogb24gdGhpcyBjcHUgYmVjYXVzZSBpdCBoYWQgbm8gY291bnRlcnMuCisJICovCisJaWYgKGN0eC0+dGFzayAmJiBjcHVjdHgtPnRhc2tfY3R4ICE9IGN0eCkgeworCQlpZiAoY3B1Y3R4LT50YXNrX2N0eCB8fCBjdHgtPnRhc2sgIT0gY3VycmVudCkKKwkJCXJldHVybjsKKwkJY3B1Y3R4LT50YXNrX2N0eCA9IGN0eDsKKwl9CisKKwlzcGluX2xvY2soJmN0eC0+bG9jayk7CisJY3R4LT5pc19hY3RpdmUgPSAxOworCXVwZGF0ZV9jb250ZXh0X3RpbWUoY3R4KTsKKworCS8qCisJICogUHJvdGVjdCB0aGUgbGlzdCBvcGVyYXRpb24gYWdhaW5zdCBOTUkgYnkgZGlzYWJsaW5nIHRoZQorCSAqIGNvdW50ZXJzIG9uIGEgZ2xvYmFsIGxldmVsLiBOT1AgZm9yIG5vbiBOTUkgYmFzZWQgY291bnRlcnMuCisJICovCisJcGVyZl9kaXNhYmxlKCk7CisKKwlhZGRfY291bnRlcl90b19jdHgoY291bnRlciwgY3R4KTsKKworCS8qCisJICogRG9uJ3QgcHV0IHRoZSBjb3VudGVyIG9uIGlmIGl0IGlzIGRpc2FibGVkIG9yIGlmCisJICogaXQgaXMgaW4gYSBncm91cCBhbmQgdGhlIGdyb3VwIGlzbid0IG9uLgorCSAqLworCWlmIChjb3VudGVyLT5zdGF0ZSAhPSBQRVJGX0NPVU5URVJfU1RBVEVfSU5BQ1RJVkUgfHwKKwkgICAgKGxlYWRlciAhPSBjb3VudGVyICYmIGxlYWRlci0+c3RhdGUgIT0gUEVSRl9DT1VOVEVSX1NUQVRFX0FDVElWRSkpCisJCWdvdG8gdW5sb2NrOworCisJLyoKKwkgKiBBbiBleGNsdXNpdmUgY291bnRlciBjYW4ndCBnbyBvbiBpZiB0aGVyZSBhcmUgYWxyZWFkeSBhY3RpdmUKKwkgKiBoYXJkd2FyZSBjb3VudGVycywgYW5kIG5vIGhhcmR3YXJlIGNvdW50ZXIgY2FuIGdvIG9uIGlmIHRoZXJlCisJICogaXMgYWxyZWFkeSBhbiBleGNsdXNpdmUgY291bnRlciBvbi4KKwkgKi8KKwlpZiAoIWdyb3VwX2Nhbl9nb19vbihjb3VudGVyLCBjcHVjdHgsIDEpKQorCQllcnIgPSAtRUVYSVNUOworCWVsc2UKKwkJZXJyID0gY291bnRlcl9zY2hlZF9pbihjb3VudGVyLCBjcHVjdHgsIGN0eCwgY3B1KTsKKworCWlmIChlcnIpIHsKKwkJLyoKKwkJICogVGhpcyBjb3VudGVyIGNvdWxkbid0IGdvIG9uLiAgSWYgaXQgaXMgaW4gYSBncm91cAorCQkgKiB0aGVuIHdlIGhhdmUgdG8gcHVsbCB0aGUgd2hvbGUgZ3JvdXAgb2ZmLgorCQkgKiBJZiB0aGUgY291bnRlciBncm91cCBpcyBwaW5uZWQgdGhlbiBwdXQgaXQgaW4gZXJyb3Igc3RhdGUuCisJCSAqLworCQlpZiAobGVhZGVyICE9IGNvdW50ZXIpCisJCQlncm91cF9zY2hlZF9vdXQobGVhZGVyLCBjcHVjdHgsIGN0eCk7CisJCWlmIChsZWFkZXItPmF0dHIucGlubmVkKSB7CisJCQl1cGRhdGVfZ3JvdXBfdGltZXMobGVhZGVyKTsKKwkJCWxlYWRlci0+c3RhdGUgPSBQRVJGX0NPVU5URVJfU1RBVEVfRVJST1I7CisJCX0KKwl9CisKKwlpZiAoIWVyciAmJiAhY3R4LT50YXNrICYmIGNwdWN0eC0+bWF4X3BlcnRhc2spCisJCWNwdWN0eC0+bWF4X3BlcnRhc2stLTsKKworIHVubG9jazoKKwlwZXJmX2VuYWJsZSgpOworCisJc3Bpbl91bmxvY2soJmN0eC0+bG9jayk7Cit9CisKKy8qCisgKiBBdHRhY2ggYSBwZXJmb3JtYW5jZSBjb3VudGVyIHRvIGEgY29udGV4dAorICoKKyAqIEZpcnN0IHdlIGFkZCB0aGUgY291bnRlciB0byB0aGUgbGlzdCB3aXRoIHRoZSBoYXJkd2FyZSBlbmFibGUgYml0CisgKiBpbiBjb3VudGVyLT5od19jb25maWcgY2xlYXJlZC4KKyAqCisgKiBJZiB0aGUgY291bnRlciBpcyBhdHRhY2hlZCB0byBhIHRhc2sgd2hpY2ggaXMgb24gYSBDUFUgd2UgdXNlIGEgc21wCisgKiBjYWxsIHRvIGVuYWJsZSBpdCBpbiB0aGUgdGFzayBjb250ZXh0LiBUaGUgdGFzayBtaWdodCBoYXZlIGJlZW4KKyAqIHNjaGVkdWxlZCBhd2F5LCBidXQgd2UgY2hlY2sgdGhpcyBpbiB0aGUgc21wIGNhbGwgYWdhaW4uCisgKgorICogTXVzdCBiZSBjYWxsZWQgd2l0aCBjdHgtPm11dGV4IGhlbGQuCisgKi8KK3N0YXRpYyB2b2lkCitwZXJmX2luc3RhbGxfaW5fY29udGV4dChzdHJ1Y3QgcGVyZl9jb3VudGVyX2NvbnRleHQgKmN0eCwKKwkJCXN0cnVjdCBwZXJmX2NvdW50ZXIgKmNvdW50ZXIsCisJCQlpbnQgY3B1KQoreworCXN0cnVjdCB0YXNrX3N0cnVjdCAqdGFzayA9IGN0eC0+dGFzazsKKworCWlmICghdGFzaykgeworCQkvKgorCQkgKiBQZXIgY3B1IGNvdW50ZXJzIGFyZSBpbnN0YWxsZWQgdmlhIGFuIHNtcCBjYWxsIGFuZAorCQkgKiB0aGUgaW5zdGFsbCBpcyBhbHdheXMgc3VjZXNzZnVsLgorCQkgKi8KKwkJc21wX2NhbGxfZnVuY3Rpb25fc2luZ2xlKGNwdSwgX19wZXJmX2luc3RhbGxfaW5fY29udGV4dCwKKwkJCQkJIGNvdW50ZXIsIDEpOworCQlyZXR1cm47CisJfQorCityZXRyeToKKwl0YXNrX29uY3B1X2Z1bmN0aW9uX2NhbGwodGFzaywgX19wZXJmX2luc3RhbGxfaW5fY29udGV4dCwKKwkJCQkgY291bnRlcik7CisKKwlzcGluX2xvY2tfaXJxKCZjdHgtPmxvY2spOworCS8qCisJICogd2UgbmVlZCB0byByZXRyeSB0aGUgc21wIGNhbGwuCisJICovCisJaWYgKGN0eC0+aXNfYWN0aXZlICYmIGxpc3RfZW1wdHkoJmNvdW50ZXItPmxpc3RfZW50cnkpKSB7CisJCXNwaW5fdW5sb2NrX2lycSgmY3R4LT5sb2NrKTsKKwkJZ290byByZXRyeTsKKwl9CisKKwkvKgorCSAqIFRoZSBsb2NrIHByZXZlbnRzIHRoYXQgdGhpcyBjb250ZXh0IGlzIHNjaGVkdWxlZCBpbiBzbyB3ZQorCSAqIGNhbiBhZGQgdGhlIGNvdW50ZXIgc2FmZWx5LCBpZiBpdCB0aGUgY2FsbCBhYm92ZSBkaWQgbm90CisJICogc3VjY2VlZC4KKwkgKi8KKwlpZiAobGlzdF9lbXB0eSgmY291bnRlci0+bGlzdF9lbnRyeSkpCisJCWFkZF9jb3VudGVyX3RvX2N0eChjb3VudGVyLCBjdHgpOworCXNwaW5fdW5sb2NrX2lycSgmY3R4LT5sb2NrKTsKK30KKworLyoKKyAqIENyb3NzIENQVSBjYWxsIHRvIGVuYWJsZSBhIHBlcmZvcm1hbmNlIGNvdW50ZXIKKyAqLworc3RhdGljIHZvaWQgX19wZXJmX2NvdW50ZXJfZW5hYmxlKHZvaWQgKmluZm8pCit7CisJc3RydWN0IHBlcmZfY291bnRlciAqY291bnRlciA9IGluZm87CisJc3RydWN0IHBlcmZfY3B1X2NvbnRleHQgKmNwdWN0eCA9ICZfX2dldF9jcHVfdmFyKHBlcmZfY3B1X2NvbnRleHQpOworCXN0cnVjdCBwZXJmX2NvdW50ZXJfY29udGV4dCAqY3R4ID0gY291bnRlci0+Y3R4OworCXN0cnVjdCBwZXJmX2NvdW50ZXIgKmxlYWRlciA9IGNvdW50ZXItPmdyb3VwX2xlYWRlcjsKKwlpbnQgZXJyOworCisJLyoKKwkgKiBJZiB0aGlzIGlzIGEgcGVyLXRhc2sgY291bnRlciwgbmVlZCB0byBjaGVjayB3aGV0aGVyIHRoaXMKKwkgKiBjb3VudGVyJ3MgdGFzayBpcyB0aGUgY3VycmVudCB0YXNrIG9uIHRoaXMgY3B1LgorCSAqLworCWlmIChjdHgtPnRhc2sgJiYgY3B1Y3R4LT50YXNrX2N0eCAhPSBjdHgpIHsKKwkJaWYgKGNwdWN0eC0+dGFza19jdHggfHwgY3R4LT50YXNrICE9IGN1cnJlbnQpCisJCQlyZXR1cm47CisJCWNwdWN0eC0+dGFza19jdHggPSBjdHg7CisJfQorCisJc3Bpbl9sb2NrKCZjdHgtPmxvY2spOworCWN0eC0+aXNfYWN0aXZlID0gMTsKKwl1cGRhdGVfY29udGV4dF90aW1lKGN0eCk7CisKKwlpZiAoY291bnRlci0+c3RhdGUgPj0gUEVSRl9DT1VOVEVSX1NUQVRFX0lOQUNUSVZFKQorCQlnb3RvIHVubG9jazsKKwljb3VudGVyLT5zdGF0ZSA9IFBFUkZfQ09VTlRFUl9TVEFURV9JTkFDVElWRTsKKwljb3VudGVyLT50c3RhbXBfZW5hYmxlZCA9IGN0eC0+dGltZSAtIGNvdW50ZXItPnRvdGFsX3RpbWVfZW5hYmxlZDsKKworCS8qCisJICogSWYgdGhlIGNvdW50ZXIgaXMgaW4gYSBncm91cCBhbmQgaXNuJ3QgdGhlIGdyb3VwIGxlYWRlciwKKwkgKiB0aGVuIGRvbid0IHB1dCBpdCBvbiB1bmxlc3MgdGhlIGdyb3VwIGlzIG9uLgorCSAqLworCWlmIChsZWFkZXIgIT0gY291bnRlciAmJiBsZWFkZXItPnN0YXRlICE9IFBFUkZfQ09VTlRFUl9TVEFURV9BQ1RJVkUpCisJCWdvdG8gdW5sb2NrOworCisJaWYgKCFncm91cF9jYW5fZ29fb24oY291bnRlciwgY3B1Y3R4LCAxKSkgeworCQllcnIgPSAtRUVYSVNUOworCX0gZWxzZSB7CisJCXBlcmZfZGlzYWJsZSgpOworCQlpZiAoY291bnRlciA9PSBsZWFkZXIpCisJCQllcnIgPSBncm91cF9zY2hlZF9pbihjb3VudGVyLCBjcHVjdHgsIGN0eCwKKwkJCQkJICAgICBzbXBfcHJvY2Vzc29yX2lkKCkpOworCQllbHNlCisJCQllcnIgPSBjb3VudGVyX3NjaGVkX2luKGNvdW50ZXIsIGNwdWN0eCwgY3R4LAorCQkJCQkgICAgICAgc21wX3Byb2Nlc3Nvcl9pZCgpKTsKKwkJcGVyZl9lbmFibGUoKTsKKwl9CisKKwlpZiAoZXJyKSB7CisJCS8qCisJCSAqIElmIHRoaXMgY291bnRlciBjYW4ndCBnbyBvbiBhbmQgaXQncyBwYXJ0IG9mIGEKKwkJICogZ3JvdXAsIHRoZW4gdGhlIHdob2xlIGdyb3VwIGhhcyB0byBjb21lIG9mZi4KKwkJICovCisJCWlmIChsZWFkZXIgIT0gY291bnRlcikKKwkJCWdyb3VwX3NjaGVkX291dChsZWFkZXIsIGNwdWN0eCwgY3R4KTsKKwkJaWYgKGxlYWRlci0+YXR0ci5waW5uZWQpIHsKKwkJCXVwZGF0ZV9ncm91cF90aW1lcyhsZWFkZXIpOworCQkJbGVhZGVyLT5zdGF0ZSA9IFBFUkZfQ09VTlRFUl9TVEFURV9FUlJPUjsKKwkJfQorCX0KKworIHVubG9jazoKKwlzcGluX3VubG9jaygmY3R4LT5sb2NrKTsKK30KKworLyoKKyAqIEVuYWJsZSBhIGNvdW50ZXIuCisgKgorICogSWYgY291bnRlci0+Y3R4IGlzIGEgY2xvbmVkIGNvbnRleHQsIGNhbGxlcnMgbXVzdCBtYWtlIHN1cmUgdGhhdAorICogZXZlcnkgdGFzayBzdHJ1Y3QgdGhhdCBjb3VudGVyLT5jdHgtPnRhc2sgY291bGQgcG9zc2libHkgcG9pbnQgdG8KKyAqIHJlbWFpbnMgdmFsaWQuICBUaGlzIGNvbmRpdGlvbiBpcyBzYXRpc2ZpZWQgd2hlbiBjYWxsZWQgdGhyb3VnaAorICogcGVyZl9jb3VudGVyX2Zvcl9lYWNoX2NoaWxkIG9yIHBlcmZfY291bnRlcl9mb3JfZWFjaCBhcyBkZXNjcmliZWQKKyAqIGZvciBwZXJmX2NvdW50ZXJfZGlzYWJsZS4KKyAqLworc3RhdGljIHZvaWQgcGVyZl9jb3VudGVyX2VuYWJsZShzdHJ1Y3QgcGVyZl9jb3VudGVyICpjb3VudGVyKQoreworCXN0cnVjdCBwZXJmX2NvdW50ZXJfY29udGV4dCAqY3R4ID0gY291bnRlci0+Y3R4OworCXN0cnVjdCB0YXNrX3N0cnVjdCAqdGFzayA9IGN0eC0+dGFzazsKKworCWlmICghdGFzaykgeworCQkvKgorCQkgKiBFbmFibGUgdGhlIGNvdW50ZXIgb24gdGhlIGNwdSB0aGF0IGl0J3Mgb24KKwkJICovCisJCXNtcF9jYWxsX2Z1bmN0aW9uX3NpbmdsZShjb3VudGVyLT5jcHUsIF9fcGVyZl9jb3VudGVyX2VuYWJsZSwKKwkJCQkJIGNvdW50ZXIsIDEpOworCQlyZXR1cm47CisJfQorCisJc3Bpbl9sb2NrX2lycSgmY3R4LT5sb2NrKTsKKwlpZiAoY291bnRlci0+c3RhdGUgPj0gUEVSRl9DT1VOVEVSX1NUQVRFX0lOQUNUSVZFKQorCQlnb3RvIG91dDsKKworCS8qCisJICogSWYgdGhlIGNvdW50ZXIgaXMgaW4gZXJyb3Igc3RhdGUsIGNsZWFyIHRoYXQgZmlyc3QuCisJICogVGhhdCB3YXksIGlmIHdlIHNlZSB0aGUgY291bnRlciBpbiBlcnJvciBzdGF0ZSBiZWxvdywgd2UKKwkgKiBrbm93IHRoYXQgaXQgaGFzIGdvbmUgYmFjayBpbnRvIGVycm9yIHN0YXRlLCBhcyBkaXN0aW5jdAorCSAqIGZyb20gdGhlIHRhc2sgaGF2aW5nIGJlZW4gc2NoZWR1bGVkIGF3YXkgYmVmb3JlIHRoZQorCSAqIGNyb3NzLWNhbGwgYXJyaXZlZC4KKwkgKi8KKwlpZiAoY291bnRlci0+c3RhdGUgPT0gUEVSRl9DT1VOVEVSX1NUQVRFX0VSUk9SKQorCQljb3VudGVyLT5zdGF0ZSA9IFBFUkZfQ09VTlRFUl9TVEFURV9PRkY7CisKKyByZXRyeToKKwlzcGluX3VubG9ja19pcnEoJmN0eC0+bG9jayk7CisJdGFza19vbmNwdV9mdW5jdGlvbl9jYWxsKHRhc2ssIF9fcGVyZl9jb3VudGVyX2VuYWJsZSwgY291bnRlcik7CisKKwlzcGluX2xvY2tfaXJxKCZjdHgtPmxvY2spOworCisJLyoKKwkgKiBJZiB0aGUgY29udGV4dCBpcyBhY3RpdmUgYW5kIHRoZSBjb3VudGVyIGlzIHN0aWxsIG9mZiwKKwkgKiB3ZSBuZWVkIHRvIHJldHJ5IHRoZSBjcm9zcy1jYWxsLgorCSAqLworCWlmIChjdHgtPmlzX2FjdGl2ZSAmJiBjb3VudGVyLT5zdGF0ZSA9PSBQRVJGX0NPVU5URVJfU1RBVEVfT0ZGKQorCQlnb3RvIHJldHJ5OworCisJLyoKKwkgKiBTaW5jZSB3ZSBoYXZlIHRoZSBsb2NrIHRoaXMgY29udGV4dCBjYW4ndCBiZSBzY2hlZHVsZWQKKwkgKiBpbiwgc28gd2UgY2FuIGNoYW5nZSB0aGUgc3RhdGUgc2FmZWx5LgorCSAqLworCWlmIChjb3VudGVyLT5zdGF0ZSA9PSBQRVJGX0NPVU5URVJfU1RBVEVfT0ZGKSB7CisJCWNvdW50ZXItPnN0YXRlID0gUEVSRl9DT1VOVEVSX1NUQVRFX0lOQUNUSVZFOworCQljb3VudGVyLT50c3RhbXBfZW5hYmxlZCA9CisJCQljdHgtPnRpbWUgLSBjb3VudGVyLT50b3RhbF90aW1lX2VuYWJsZWQ7CisJfQorIG91dDoKKwlzcGluX3VubG9ja19pcnEoJmN0eC0+bG9jayk7Cit9CisKK3N0YXRpYyBpbnQgcGVyZl9jb3VudGVyX3JlZnJlc2goc3RydWN0IHBlcmZfY291bnRlciAqY291bnRlciwgaW50IHJlZnJlc2gpCit7CisJLyoKKwkgKiBub3Qgc3VwcG9ydGVkIG9uIGluaGVyaXRlZCBjb3VudGVycworCSAqLworCWlmIChjb3VudGVyLT5hdHRyLmluaGVyaXQpCisJCXJldHVybiAtRUlOVkFMOworCisJYXRvbWljX2FkZChyZWZyZXNoLCAmY291bnRlci0+ZXZlbnRfbGltaXQpOworCXBlcmZfY291bnRlcl9lbmFibGUoY291bnRlcik7CisKKwlyZXR1cm4gMDsKK30KKwordm9pZCBfX3BlcmZfY291bnRlcl9zY2hlZF9vdXQoc3RydWN0IHBlcmZfY291bnRlcl9jb250ZXh0ICpjdHgsCisJCQkgICAgICBzdHJ1Y3QgcGVyZl9jcHVfY29udGV4dCAqY3B1Y3R4KQoreworCXN0cnVjdCBwZXJmX2NvdW50ZXIgKmNvdW50ZXI7CisKKwlzcGluX2xvY2soJmN0eC0+bG9jayk7CisJY3R4LT5pc19hY3RpdmUgPSAwOworCWlmIChsaWtlbHkoIWN0eC0+bnJfY291bnRlcnMpKQorCQlnb3RvIG91dDsKKwl1cGRhdGVfY29udGV4dF90aW1lKGN0eCk7CisKKwlwZXJmX2Rpc2FibGUoKTsKKwlpZiAoY3R4LT5ucl9hY3RpdmUpIHsKKwkJbGlzdF9mb3JfZWFjaF9lbnRyeShjb3VudGVyLCAmY3R4LT5jb3VudGVyX2xpc3QsIGxpc3RfZW50cnkpIHsKKwkJCWlmIChjb3VudGVyICE9IGNvdW50ZXItPmdyb3VwX2xlYWRlcikKKwkJCQljb3VudGVyX3NjaGVkX291dChjb3VudGVyLCBjcHVjdHgsIGN0eCk7CisJCQllbHNlCisJCQkJZ3JvdXBfc2NoZWRfb3V0KGNvdW50ZXIsIGNwdWN0eCwgY3R4KTsKKwkJfQorCX0KKwlwZXJmX2VuYWJsZSgpOworIG91dDoKKwlzcGluX3VubG9jaygmY3R4LT5sb2NrKTsKK30KKworLyoKKyAqIFRlc3Qgd2hldGhlciB0d28gY29udGV4dHMgYXJlIGVxdWl2YWxlbnQsIGkuZS4gd2hldGhlciB0aGV5CisgKiBoYXZlIGJvdGggYmVlbiBjbG9uZWQgZnJvbSB0aGUgc2FtZSB2ZXJzaW9uIG9mIHRoZSBzYW1lIGNvbnRleHQKKyAqIGFuZCB0aGV5IGJvdGggaGF2ZSB0aGUgc2FtZSBudW1iZXIgb2YgZW5hYmxlZCBjb3VudGVycy4KKyAqIElmIHRoZSBudW1iZXIgb2YgZW5hYmxlZCBjb3VudGVycyBpcyB0aGUgc2FtZSwgdGhlbiB0aGUgc2V0CisgKiBvZiBlbmFibGVkIGNvdW50ZXJzIHNob3VsZCBiZSB0aGUgc2FtZSwgYmVjYXVzZSB0aGVzZSBhcmUgYm90aAorICogaW5oZXJpdGVkIGNvbnRleHRzLCB0aGVyZWZvcmUgd2UgY2FuJ3QgYWNjZXNzIGluZGl2aWR1YWwgY291bnRlcnMKKyAqIGluIHRoZW0gZGlyZWN0bHkgd2l0aCBhbiBmZDsgd2UgY2FuIG9ubHkgZW5hYmxlL2Rpc2FibGUgYWxsCisgKiBjb3VudGVycyB2aWEgcHJjdGwsIG9yIGVuYWJsZS9kaXNhYmxlIGFsbCBjb3VudGVycyBpbiBhIGZhbWlseQorICogdmlhIGlvY3RsLCB3aGljaCB3aWxsIGhhdmUgdGhlIHNhbWUgZWZmZWN0IG9uIGJvdGggY29udGV4dHMuCisgKi8KK3N0YXRpYyBpbnQgY29udGV4dF9lcXVpdihzdHJ1Y3QgcGVyZl9jb3VudGVyX2NvbnRleHQgKmN0eDEsCisJCQkgc3RydWN0IHBlcmZfY291bnRlcl9jb250ZXh0ICpjdHgyKQoreworCXJldHVybiBjdHgxLT5wYXJlbnRfY3R4ICYmIGN0eDEtPnBhcmVudF9jdHggPT0gY3R4Mi0+cGFyZW50X2N0eAorCQkmJiBjdHgxLT5wYXJlbnRfZ2VuID09IGN0eDItPnBhcmVudF9nZW4KKwkJJiYgIWN0eDEtPnBpbl9jb3VudCAmJiAhY3R4Mi0+cGluX2NvdW50OworfQorCisvKgorICogQ2FsbGVkIGZyb20gc2NoZWR1bGVyIHRvIHJlbW92ZSB0aGUgY291bnRlcnMgb2YgdGhlIGN1cnJlbnQgdGFzaywKKyAqIHdpdGggaW50ZXJydXB0cyBkaXNhYmxlZC4KKyAqCisgKiBXZSBzdG9wIGVhY2ggY291bnRlciBhbmQgdXBkYXRlIHRoZSBjb3VudGVyIHZhbHVlIGluIGNvdW50ZXItPmNvdW50LgorICoKKyAqIFRoaXMgZG9lcyBub3QgcHJvdGVjdCB1cyBhZ2FpbnN0IE5NSSwgYnV0IGRpc2FibGUoKQorICogc2V0cyB0aGUgZGlzYWJsZWQgYml0IGluIHRoZSBjb250cm9sIGZpZWxkIG9mIGNvdW50ZXIgX2JlZm9yZV8KKyAqIGFjY2Vzc2luZyB0aGUgY291bnRlciBjb250cm9sIHJlZ2lzdGVyLiBJZiBhIE5NSSBoaXRzLCB0aGVuIGl0IHdpbGwKKyAqIG5vdCByZXN0YXJ0IHRoZSBjb3VudGVyLgorICovCit2b2lkIHBlcmZfY291bnRlcl90YXNrX3NjaGVkX291dChzdHJ1Y3QgdGFza19zdHJ1Y3QgKnRhc2ssCisJCQkJIHN0cnVjdCB0YXNrX3N0cnVjdCAqbmV4dCwgaW50IGNwdSkKK3sKKwlzdHJ1Y3QgcGVyZl9jcHVfY29udGV4dCAqY3B1Y3R4ID0gJnBlcl9jcHUocGVyZl9jcHVfY29udGV4dCwgY3B1KTsKKwlzdHJ1Y3QgcGVyZl9jb3VudGVyX2NvbnRleHQgKmN0eCA9IHRhc2stPnBlcmZfY291bnRlcl9jdHhwOworCXN0cnVjdCBwZXJmX2NvdW50ZXJfY29udGV4dCAqbmV4dF9jdHg7CisJc3RydWN0IHBlcmZfY291bnRlcl9jb250ZXh0ICpwYXJlbnQ7CisJc3RydWN0IHB0X3JlZ3MgKnJlZ3M7CisJaW50IGRvX3N3aXRjaCA9IDE7CisKKwlyZWdzID0gdGFza19wdF9yZWdzKHRhc2spOworCXBlcmZfc3djb3VudGVyX2V2ZW50KFBFUkZfQ09VTlRfU1dfQ09OVEVYVF9TV0lUQ0hFUywgMSwgMSwgcmVncywgMCk7CisKKwlpZiAobGlrZWx5KCFjdHggfHwgIWNwdWN0eC0+dGFza19jdHgpKQorCQlyZXR1cm47CisKKwl1cGRhdGVfY29udGV4dF90aW1lKGN0eCk7CisKKwlyY3VfcmVhZF9sb2NrKCk7CisJcGFyZW50ID0gcmN1X2RlcmVmZXJlbmNlKGN0eC0+cGFyZW50X2N0eCk7CisJbmV4dF9jdHggPSBuZXh0LT5wZXJmX2NvdW50ZXJfY3R4cDsKKwlpZiAocGFyZW50ICYmIG5leHRfY3R4ICYmCisJICAgIHJjdV9kZXJlZmVyZW5jZShuZXh0X2N0eC0+cGFyZW50X2N0eCkgPT0gcGFyZW50KSB7CisJCS8qCisJCSAqIExvb2tzIGxpa2UgdGhlIHR3byBjb250ZXh0cyBhcmUgY2xvbmVzLCBzbyB3ZSBtaWdodCBiZQorCQkgKiBhYmxlIHRvIG9wdGltaXplIHRoZSBjb250ZXh0IHN3aXRjaC4gIFdlIGxvY2sgYm90aAorCQkgKiBjb250ZXh0cyBhbmQgY2hlY2sgdGhhdCB0aGV5IGFyZSBjbG9uZXMgdW5kZXIgdGhlCisJCSAqIGxvY2sgKGluY2x1ZGluZyByZS1jaGVja2luZyB0aGF0IG5laXRoZXIgaGFzIGJlZW4KKwkJICogdW5jbG9uZWQgaW4gdGhlIG1lYW50aW1lKS4gIEl0IGRvZXNuJ3QgbWF0dGVyIHdoaWNoCisJCSAqIG9yZGVyIHdlIHRha2UgdGhlIGxvY2tzIGJlY2F1c2Ugbm8gb3RoZXIgY3B1IGNvdWxkCisJCSAqIGJlIHRyeWluZyB0byBsb2NrIGJvdGggb2YgdGhlc2UgdGFza3MuCisJCSAqLworCQlzcGluX2xvY2soJmN0eC0+bG9jayk7CisJCXNwaW5fbG9ja19uZXN0ZWQoJm5leHRfY3R4LT5sb2NrLCBTSU5HTEVfREVQVEhfTkVTVElORyk7CisJCWlmIChjb250ZXh0X2VxdWl2KGN0eCwgbmV4dF9jdHgpKSB7CisJCQkvKgorCQkJICogWFhYIGRvIHdlIG5lZWQgYSBtZW1vcnkgYmFycmllciBvZiBzb3J0cworCQkJICogd3J0IHRvIHJjdV9kZXJlZmVyZW5jZSgpIG9mIHBlcmZfY291bnRlcl9jdHhwCisJCQkgKi8KKwkJCXRhc2stPnBlcmZfY291bnRlcl9jdHhwID0gbmV4dF9jdHg7CisJCQluZXh0LT5wZXJmX2NvdW50ZXJfY3R4cCA9IGN0eDsKKwkJCWN0eC0+dGFzayA9IG5leHQ7CisJCQluZXh0X2N0eC0+dGFzayA9IHRhc2s7CisJCQlkb19zd2l0Y2ggPSAwOworCQl9CisJCXNwaW5fdW5sb2NrKCZuZXh0X2N0eC0+bG9jayk7CisJCXNwaW5fdW5sb2NrKCZjdHgtPmxvY2spOworCX0KKwlyY3VfcmVhZF91bmxvY2soKTsKKworCWlmIChkb19zd2l0Y2gpIHsKKwkJX19wZXJmX2NvdW50ZXJfc2NoZWRfb3V0KGN0eCwgY3B1Y3R4KTsKKwkJY3B1Y3R4LT50YXNrX2N0eCA9IE5VTEw7CisJfQorfQorCisvKgorICogQ2FsbGVkIHdpdGggSVJRcyBkaXNhYmxlZAorICovCitzdGF0aWMgdm9pZCBfX3BlcmZfY291bnRlcl90YXNrX3NjaGVkX291dChzdHJ1Y3QgcGVyZl9jb3VudGVyX2NvbnRleHQgKmN0eCkKK3sKKwlzdHJ1Y3QgcGVyZl9jcHVfY29udGV4dCAqY3B1Y3R4ID0gJl9fZ2V0X2NwdV92YXIocGVyZl9jcHVfY29udGV4dCk7CisKKwlpZiAoIWNwdWN0eC0+dGFza19jdHgpCisJCXJldHVybjsKKworCWlmIChXQVJOX09OX09OQ0UoY3R4ICE9IGNwdWN0eC0+dGFza19jdHgpKQorCQlyZXR1cm47CisKKwlfX3BlcmZfY291bnRlcl9zY2hlZF9vdXQoY3R4LCBjcHVjdHgpOworCWNwdWN0eC0+dGFza19jdHggPSBOVUxMOworfQorCisvKgorICogQ2FsbGVkIHdpdGggSVJRcyBkaXNhYmxlZAorICovCitzdGF0aWMgdm9pZCBwZXJmX2NvdW50ZXJfY3B1X3NjaGVkX291dChzdHJ1Y3QgcGVyZl9jcHVfY29udGV4dCAqY3B1Y3R4KQoreworCV9fcGVyZl9jb3VudGVyX3NjaGVkX291dCgmY3B1Y3R4LT5jdHgsIGNwdWN0eCk7Cit9CisKK3N0YXRpYyB2b2lkCitfX3BlcmZfY291bnRlcl9zY2hlZF9pbihzdHJ1Y3QgcGVyZl9jb3VudGVyX2NvbnRleHQgKmN0eCwKKwkJCXN0cnVjdCBwZXJmX2NwdV9jb250ZXh0ICpjcHVjdHgsIGludCBjcHUpCit7CisJc3RydWN0IHBlcmZfY291bnRlciAqY291bnRlcjsKKwlpbnQgY2FuX2FkZF9odyA9IDE7CisKKwlzcGluX2xvY2soJmN0eC0+bG9jayk7CisJY3R4LT5pc19hY3RpdmUgPSAxOworCWlmIChsaWtlbHkoIWN0eC0+bnJfY291bnRlcnMpKQorCQlnb3RvIG91dDsKKworCWN0eC0+dGltZXN0YW1wID0gcGVyZl9jbG9jaygpOworCisJcGVyZl9kaXNhYmxlKCk7CisKKwkvKgorCSAqIEZpcnN0IGdvIHRocm91Z2ggdGhlIGxpc3QgYW5kIHB1dCBvbiBhbnkgcGlubmVkIGdyb3VwcworCSAqIGluIG9yZGVyIHRvIGdpdmUgdGhlbSB0aGUgYmVzdCBjaGFuY2Ugb2YgZ29pbmcgb24uCisJICovCisJbGlzdF9mb3JfZWFjaF9lbnRyeShjb3VudGVyLCAmY3R4LT5jb3VudGVyX2xpc3QsIGxpc3RfZW50cnkpIHsKKwkJaWYgKGNvdW50ZXItPnN0YXRlIDw9IFBFUkZfQ09VTlRFUl9TVEFURV9PRkYgfHwKKwkJICAgICFjb3VudGVyLT5hdHRyLnBpbm5lZCkKKwkJCWNvbnRpbnVlOworCQlpZiAoY291bnRlci0+Y3B1ICE9IC0xICYmIGNvdW50ZXItPmNwdSAhPSBjcHUpCisJCQljb250aW51ZTsKKworCQlpZiAoY291bnRlciAhPSBjb3VudGVyLT5ncm91cF9sZWFkZXIpCisJCQljb3VudGVyX3NjaGVkX2luKGNvdW50ZXIsIGNwdWN0eCwgY3R4LCBjcHUpOworCQllbHNlIHsKKwkJCWlmIChncm91cF9jYW5fZ29fb24oY291bnRlciwgY3B1Y3R4LCAxKSkKKwkJCQlncm91cF9zY2hlZF9pbihjb3VudGVyLCBjcHVjdHgsIGN0eCwgY3B1KTsKKwkJfQorCisJCS8qCisJCSAqIElmIHRoaXMgcGlubmVkIGdyb3VwIGhhc24ndCBiZWVuIHNjaGVkdWxlZCwKKwkJICogcHV0IGl0IGluIGVycm9yIHN0YXRlLgorCQkgKi8KKwkJaWYgKGNvdW50ZXItPnN0YXRlID09IFBFUkZfQ09VTlRFUl9TVEFURV9JTkFDVElWRSkgeworCQkJdXBkYXRlX2dyb3VwX3RpbWVzKGNvdW50ZXIpOworCQkJY291bnRlci0+c3RhdGUgPSBQRVJGX0NPVU5URVJfU1RBVEVfRVJST1I7CisJCX0KKwl9CisKKwlsaXN0X2Zvcl9lYWNoX2VudHJ5KGNvdW50ZXIsICZjdHgtPmNvdW50ZXJfbGlzdCwgbGlzdF9lbnRyeSkgeworCQkvKgorCQkgKiBJZ25vcmUgY291bnRlcnMgaW4gT0ZGIG9yIEVSUk9SIHN0YXRlLCBhbmQKKwkJICogaWdub3JlIHBpbm5lZCBjb3VudGVycyBzaW5jZSB3ZSBkaWQgdGhlbSBhbHJlYWR5LgorCQkgKi8KKwkJaWYgKGNvdW50ZXItPnN0YXRlIDw9IFBFUkZfQ09VTlRFUl9TVEFURV9PRkYgfHwKKwkJICAgIGNvdW50ZXItPmF0dHIucGlubmVkKQorCQkJY29udGludWU7CisKKwkJLyoKKwkJICogTGlzdGVuIHRvIHRoZSAnY3B1JyBzY2hlZHVsaW5nIGZpbHRlciBjb25zdHJhaW50CisJCSAqIG9mIGNvdW50ZXJzOgorCQkgKi8KKwkJaWYgKGNvdW50ZXItPmNwdSAhPSAtMSAmJiBjb3VudGVyLT5jcHUgIT0gY3B1KQorCQkJY29udGludWU7CisKKwkJaWYgKGNvdW50ZXIgIT0gY291bnRlci0+Z3JvdXBfbGVhZGVyKSB7CisJCQlpZiAoY291bnRlcl9zY2hlZF9pbihjb3VudGVyLCBjcHVjdHgsIGN0eCwgY3B1KSkKKwkJCQljYW5fYWRkX2h3ID0gMDsKKwkJfSBlbHNlIHsKKwkJCWlmIChncm91cF9jYW5fZ29fb24oY291bnRlciwgY3B1Y3R4LCBjYW5fYWRkX2h3KSkgeworCQkJCWlmIChncm91cF9zY2hlZF9pbihjb3VudGVyLCBjcHVjdHgsIGN0eCwgY3B1KSkKKwkJCQkJY2FuX2FkZF9odyA9IDA7CisJCQl9CisJCX0KKwl9CisJcGVyZl9lbmFibGUoKTsKKyBvdXQ6CisJc3Bpbl91bmxvY2soJmN0eC0+bG9jayk7Cit9CisKKy8qCisgKiBDYWxsZWQgZnJvbSBzY2hlZHVsZXIgdG8gYWRkIHRoZSBjb3VudGVycyBvZiB0aGUgY3VycmVudCB0YXNrCisgKiB3aXRoIGludGVycnVwdHMgZGlzYWJsZWQuCisgKgorICogV2UgcmVzdG9yZSB0aGUgY291bnRlciB2YWx1ZSBhbmQgdGhlbiBlbmFibGUgaXQuCisgKgorICogVGhpcyBkb2VzIG5vdCBwcm90ZWN0IHVzIGFnYWluc3QgTk1JLCBidXQgZW5hYmxlKCkKKyAqIHNldHMgdGhlIGVuYWJsZWQgYml0IGluIHRoZSBjb250cm9sIGZpZWxkIG9mIGNvdW50ZXIgX2JlZm9yZV8KKyAqIGFjY2Vzc2luZyB0aGUgY291bnRlciBjb250cm9sIHJlZ2lzdGVyLiBJZiBhIE5NSSBoaXRzLCB0aGVuIGl0IHdpbGwKKyAqIGtlZXAgdGhlIGNvdW50ZXIgcnVubmluZy4KKyAqLwordm9pZCBwZXJmX2NvdW50ZXJfdGFza19zY2hlZF9pbihzdHJ1Y3QgdGFza19zdHJ1Y3QgKnRhc2ssIGludCBjcHUpCit7CisJc3RydWN0IHBlcmZfY3B1X2NvbnRleHQgKmNwdWN0eCA9ICZwZXJfY3B1KHBlcmZfY3B1X2NvbnRleHQsIGNwdSk7CisJc3RydWN0IHBlcmZfY291bnRlcl9jb250ZXh0ICpjdHggPSB0YXNrLT5wZXJmX2NvdW50ZXJfY3R4cDsKKworCWlmIChsaWtlbHkoIWN0eCkpCisJCXJldHVybjsKKwlpZiAoY3B1Y3R4LT50YXNrX2N0eCA9PSBjdHgpCisJCXJldHVybjsKKwlfX3BlcmZfY291bnRlcl9zY2hlZF9pbihjdHgsIGNwdWN0eCwgY3B1KTsKKwljcHVjdHgtPnRhc2tfY3R4ID0gY3R4OworfQorCitzdGF0aWMgdm9pZCBwZXJmX2NvdW50ZXJfY3B1X3NjaGVkX2luKHN0cnVjdCBwZXJmX2NwdV9jb250ZXh0ICpjcHVjdHgsIGludCBjcHUpCit7CisJc3RydWN0IHBlcmZfY291bnRlcl9jb250ZXh0ICpjdHggPSAmY3B1Y3R4LT5jdHg7CisKKwlfX3BlcmZfY291bnRlcl9zY2hlZF9pbihjdHgsIGNwdWN0eCwgY3B1KTsKK30KKworI2RlZmluZSBNQVhfSU5URVJSVVBUUyAofjBVTEwpCisKK3N0YXRpYyB2b2lkIHBlcmZfbG9nX3Rocm90dGxlKHN0cnVjdCBwZXJmX2NvdW50ZXIgKmNvdW50ZXIsIGludCBlbmFibGUpOworc3RhdGljIHZvaWQgcGVyZl9sb2dfcGVyaW9kKHN0cnVjdCBwZXJmX2NvdW50ZXIgKmNvdW50ZXIsIHU2NCBwZXJpb2QpOworCitzdGF0aWMgdm9pZCBwZXJmX2FkanVzdF9wZXJpb2Qoc3RydWN0IHBlcmZfY291bnRlciAqY291bnRlciwgdTY0IGV2ZW50cykKK3sKKwlzdHJ1Y3QgaHdfcGVyZl9jb3VudGVyICpod2MgPSAmY291bnRlci0+aHc7CisJdTY0IHBlcmlvZCwgc2FtcGxlX3BlcmlvZDsKKwlzNjQgZGVsdGE7CisKKwlldmVudHMgKj0gaHdjLT5zYW1wbGVfcGVyaW9kOworCXBlcmlvZCA9IGRpdjY0X3U2NChldmVudHMsIGNvdW50ZXItPmF0dHIuc2FtcGxlX2ZyZXEpOworCisJZGVsdGEgPSAoczY0KShwZXJpb2QgLSBod2MtPnNhbXBsZV9wZXJpb2QpOworCWRlbHRhID0gKGRlbHRhICsgNykgLyA4OyAvKiBsb3cgcGFzcyBmaWx0ZXIgKi8KKworCXNhbXBsZV9wZXJpb2QgPSBod2MtPnNhbXBsZV9wZXJpb2QgKyBkZWx0YTsKKworCWlmICghc2FtcGxlX3BlcmlvZCkKKwkJc2FtcGxlX3BlcmlvZCA9IDE7CisKKwlwZXJmX2xvZ19wZXJpb2QoY291bnRlciwgc2FtcGxlX3BlcmlvZCk7CisKKwlod2MtPnNhbXBsZV9wZXJpb2QgPSBzYW1wbGVfcGVyaW9kOworfQorCitzdGF0aWMgdm9pZCBwZXJmX2N0eF9hZGp1c3RfZnJlcShzdHJ1Y3QgcGVyZl9jb3VudGVyX2NvbnRleHQgKmN0eCkKK3sKKwlzdHJ1Y3QgcGVyZl9jb3VudGVyICpjb3VudGVyOworCXN0cnVjdCBod19wZXJmX2NvdW50ZXIgKmh3YzsKKwl1NjQgaW50ZXJydXB0cywgZnJlcTsKKworCXNwaW5fbG9jaygmY3R4LT5sb2NrKTsKKwlsaXN0X2Zvcl9lYWNoX2VudHJ5KGNvdW50ZXIsICZjdHgtPmNvdW50ZXJfbGlzdCwgbGlzdF9lbnRyeSkgeworCQlpZiAoY291bnRlci0+c3RhdGUgIT0gUEVSRl9DT1VOVEVSX1NUQVRFX0FDVElWRSkKKwkJCWNvbnRpbnVlOworCisJCWh3YyA9ICZjb3VudGVyLT5odzsKKworCQlpbnRlcnJ1cHRzID0gaHdjLT5pbnRlcnJ1cHRzOworCQlod2MtPmludGVycnVwdHMgPSAwOworCisJCS8qCisJCSAqIHVudGhyb3R0bGUgY291bnRlcnMgb24gdGhlIHRpY2sKKwkJICovCisJCWlmIChpbnRlcnJ1cHRzID09IE1BWF9JTlRFUlJVUFRTKSB7CisJCQlwZXJmX2xvZ190aHJvdHRsZShjb3VudGVyLCAxKTsKKwkJCWNvdW50ZXItPnBtdS0+dW50aHJvdHRsZShjb3VudGVyKTsKKwkJCWludGVycnVwdHMgPSAyKnN5c2N0bF9wZXJmX2NvdW50ZXJfc2FtcGxlX3JhdGUvSFo7CisJCX0KKworCQlpZiAoIWNvdW50ZXItPmF0dHIuZnJlcSB8fCAhY291bnRlci0+YXR0ci5zYW1wbGVfZnJlcSkKKwkJCWNvbnRpbnVlOworCisJCS8qCisJCSAqIGlmIHRoZSBzcGVjaWZpZWQgZnJlcSA8IEhaIHRoZW4gd2UgbmVlZCB0byBza2lwIHRpY2tzCisJCSAqLworCQlpZiAoY291bnRlci0+YXR0ci5zYW1wbGVfZnJlcSA8IEhaKSB7CisJCQlmcmVxID0gY291bnRlci0+YXR0ci5zYW1wbGVfZnJlcTsKKworCQkJaHdjLT5mcmVxX2NvdW50ICs9IGZyZXE7CisJCQlod2MtPmZyZXFfaW50ZXJydXB0cyArPSBpbnRlcnJ1cHRzOworCisJCQlpZiAoaHdjLT5mcmVxX2NvdW50IDwgSFopCisJCQkJY29udGludWU7CisKKwkJCWludGVycnVwdHMgPSBod2MtPmZyZXFfaW50ZXJydXB0czsKKwkJCWh3Yy0+ZnJlcV9pbnRlcnJ1cHRzID0gMDsKKwkJCWh3Yy0+ZnJlcV9jb3VudCAtPSBIWjsKKwkJfSBlbHNlCisJCQlmcmVxID0gSFo7CisKKwkJcGVyZl9hZGp1c3RfcGVyaW9kKGNvdW50ZXIsIGZyZXEgKiBpbnRlcnJ1cHRzKTsKKworCQkvKgorCQkgKiBJbiBvcmRlciB0byBhdm9pZCBiZWluZyBzdGFsbGVkIGJ5IGFuIChhY2NpZGVudGFsKSBodWdlCisJCSAqIHNhbXBsZSBwZXJpb2QsIGZvcmNlIHJlc2V0IHRoZSBzYW1wbGUgcGVyaW9kIGlmIHdlIGRpZG4ndAorCQkgKiBnZXQgYW55IGV2ZW50cyBpbiB0aGlzIGZyZXEgcGVyaW9kLgorCQkgKi8KKwkJaWYgKCFpbnRlcnJ1cHRzKSB7CisJCQlwZXJmX2Rpc2FibGUoKTsKKwkJCWNvdW50ZXItPnBtdS0+ZGlzYWJsZShjb3VudGVyKTsKKwkJCWF0b21pY19zZXQoJmh3Yy0+cGVyaW9kX2xlZnQsIDApOworCQkJY291bnRlci0+cG11LT5lbmFibGUoY291bnRlcik7CisJCQlwZXJmX2VuYWJsZSgpOworCQl9CisJfQorCXNwaW5fdW5sb2NrKCZjdHgtPmxvY2spOworfQorCisvKgorICogUm91bmQtcm9iaW4gYSBjb250ZXh0J3MgY291bnRlcnM6CisgKi8KK3N0YXRpYyB2b2lkIHJvdGF0ZV9jdHgoc3RydWN0IHBlcmZfY291bnRlcl9jb250ZXh0ICpjdHgpCit7CisJc3RydWN0IHBlcmZfY291bnRlciAqY291bnRlcjsKKworCWlmICghY3R4LT5ucl9jb3VudGVycykKKwkJcmV0dXJuOworCisJc3Bpbl9sb2NrKCZjdHgtPmxvY2spOworCS8qCisJICogUm90YXRlIHRoZSBmaXJzdCBlbnRyeSBsYXN0ICh3b3JrcyBqdXN0IGZpbmUgZm9yIGdyb3VwIGNvdW50ZXJzIHRvbyk6CisJICovCisJcGVyZl9kaXNhYmxlKCk7CisJbGlzdF9mb3JfZWFjaF9lbnRyeShjb3VudGVyLCAmY3R4LT5jb3VudGVyX2xpc3QsIGxpc3RfZW50cnkpIHsKKwkJbGlzdF9tb3ZlX3RhaWwoJmNvdW50ZXItPmxpc3RfZW50cnksICZjdHgtPmNvdW50ZXJfbGlzdCk7CisJCWJyZWFrOworCX0KKwlwZXJmX2VuYWJsZSgpOworCisJc3Bpbl91bmxvY2soJmN0eC0+bG9jayk7Cit9CisKK3ZvaWQgcGVyZl9jb3VudGVyX3Rhc2tfdGljayhzdHJ1Y3QgdGFza19zdHJ1Y3QgKmN1cnIsIGludCBjcHUpCit7CisJc3RydWN0IHBlcmZfY3B1X2NvbnRleHQgKmNwdWN0eDsKKwlzdHJ1Y3QgcGVyZl9jb3VudGVyX2NvbnRleHQgKmN0eDsKKworCWlmICghYXRvbWljX3JlYWQoJm5yX2NvdW50ZXJzKSkKKwkJcmV0dXJuOworCisJY3B1Y3R4ID0gJnBlcl9jcHUocGVyZl9jcHVfY29udGV4dCwgY3B1KTsKKwljdHggPSBjdXJyLT5wZXJmX2NvdW50ZXJfY3R4cDsKKworCXBlcmZfY3R4X2FkanVzdF9mcmVxKCZjcHVjdHgtPmN0eCk7CisJaWYgKGN0eCkKKwkJcGVyZl9jdHhfYWRqdXN0X2ZyZXEoY3R4KTsKKworCXBlcmZfY291bnRlcl9jcHVfc2NoZWRfb3V0KGNwdWN0eCk7CisJaWYgKGN0eCkKKwkJX19wZXJmX2NvdW50ZXJfdGFza19zY2hlZF9vdXQoY3R4KTsKKworCXJvdGF0ZV9jdHgoJmNwdWN0eC0+Y3R4KTsKKwlpZiAoY3R4KQorCQlyb3RhdGVfY3R4KGN0eCk7CisKKwlwZXJmX2NvdW50ZXJfY3B1X3NjaGVkX2luKGNwdWN0eCwgY3B1KTsKKwlpZiAoY3R4KQorCQlwZXJmX2NvdW50ZXJfdGFza19zY2hlZF9pbihjdXJyLCBjcHUpOworfQorCisvKgorICogQ3Jvc3MgQ1BVIGNhbGwgdG8gcmVhZCB0aGUgaGFyZHdhcmUgY291bnRlcgorICovCitzdGF0aWMgdm9pZCBfX3JlYWQodm9pZCAqaW5mbykKK3sKKwlzdHJ1Y3QgcGVyZl9jb3VudGVyICpjb3VudGVyID0gaW5mbzsKKwlzdHJ1Y3QgcGVyZl9jb3VudGVyX2NvbnRleHQgKmN0eCA9IGNvdW50ZXItPmN0eDsKKwl1bnNpZ25lZCBsb25nIGZsYWdzOworCisJbG9jYWxfaXJxX3NhdmUoZmxhZ3MpOworCWlmIChjdHgtPmlzX2FjdGl2ZSkKKwkJdXBkYXRlX2NvbnRleHRfdGltZShjdHgpOworCWNvdW50ZXItPnBtdS0+cmVhZChjb3VudGVyKTsKKwl1cGRhdGVfY291bnRlcl90aW1lcyhjb3VudGVyKTsKKwlsb2NhbF9pcnFfcmVzdG9yZShmbGFncyk7Cit9CisKK3N0YXRpYyB1NjQgcGVyZl9jb3VudGVyX3JlYWQoc3RydWN0IHBlcmZfY291bnRlciAqY291bnRlcikKK3sKKwkvKgorCSAqIElmIGNvdW50ZXIgaXMgZW5hYmxlZCBhbmQgY3VycmVudGx5IGFjdGl2ZSBvbiBhIENQVSwgdXBkYXRlIHRoZQorCSAqIHZhbHVlIGluIHRoZSBjb3VudGVyIHN0cnVjdHVyZToKKwkgKi8KKwlpZiAoY291bnRlci0+c3RhdGUgPT0gUEVSRl9DT1VOVEVSX1NUQVRFX0FDVElWRSkgeworCQlzbXBfY2FsbF9mdW5jdGlvbl9zaW5nbGUoY291bnRlci0+b25jcHUsCisJCQkJCSBfX3JlYWQsIGNvdW50ZXIsIDEpOworCX0gZWxzZSBpZiAoY291bnRlci0+c3RhdGUgPT0gUEVSRl9DT1VOVEVSX1NUQVRFX0lOQUNUSVZFKSB7CisJCXVwZGF0ZV9jb3VudGVyX3RpbWVzKGNvdW50ZXIpOworCX0KKworCXJldHVybiBhdG9taWM2NF9yZWFkKCZjb3VudGVyLT5jb3VudCk7Cit9CisKKy8qCisgKiBJbml0aWFsaXplIHRoZSBwZXJmX2NvdW50ZXIgY29udGV4dCBpbiBhIHRhc2tfc3RydWN0OgorICovCitzdGF0aWMgdm9pZAorX19wZXJmX2NvdW50ZXJfaW5pdF9jb250ZXh0KHN0cnVjdCBwZXJmX2NvdW50ZXJfY29udGV4dCAqY3R4LAorCQkJICAgIHN0cnVjdCB0YXNrX3N0cnVjdCAqdGFzaykKK3sKKwltZW1zZXQoY3R4LCAwLCBzaXplb2YoKmN0eCkpOworCXNwaW5fbG9ja19pbml0KCZjdHgtPmxvY2spOworCW11dGV4X2luaXQoJmN0eC0+bXV0ZXgpOworCUlOSVRfTElTVF9IRUFEKCZjdHgtPmNvdW50ZXJfbGlzdCk7CisJSU5JVF9MSVNUX0hFQUQoJmN0eC0+ZXZlbnRfbGlzdCk7CisJYXRvbWljX3NldCgmY3R4LT5yZWZjb3VudCwgMSk7CisJY3R4LT50YXNrID0gdGFzazsKK30KKworc3RhdGljIHN0cnVjdCBwZXJmX2NvdW50ZXJfY29udGV4dCAqZmluZF9nZXRfY29udGV4dChwaWRfdCBwaWQsIGludCBjcHUpCit7CisJc3RydWN0IHBlcmZfY291bnRlcl9jb250ZXh0ICpwYXJlbnRfY3R4OworCXN0cnVjdCBwZXJmX2NvdW50ZXJfY29udGV4dCAqY3R4OworCXN0cnVjdCBwZXJmX2NwdV9jb250ZXh0ICpjcHVjdHg7CisJc3RydWN0IHRhc2tfc3RydWN0ICp0YXNrOworCXVuc2lnbmVkIGxvbmcgZmxhZ3M7CisJaW50IGVycjsKKworCS8qCisJICogSWYgY3B1IGlzIG5vdCBhIHdpbGRjYXJkIHRoZW4gdGhpcyBpcyBhIHBlcmNwdSBjb3VudGVyOgorCSAqLworCWlmIChjcHUgIT0gLTEpIHsKKwkJLyogTXVzdCBiZSByb290IHRvIG9wZXJhdGUgb24gYSBDUFUgY291bnRlcjogKi8KKwkJaWYgKHBlcmZfcGFyYW5vaWRfY3B1KCkgJiYgIWNhcGFibGUoQ0FQX1NZU19BRE1JTikpCisJCQlyZXR1cm4gRVJSX1BUUigtRUFDQ0VTKTsKKworCQlpZiAoY3B1IDwgMCB8fCBjcHUgPiBudW1fcG9zc2libGVfY3B1cygpKQorCQkJcmV0dXJuIEVSUl9QVFIoLUVJTlZBTCk7CisKKwkJLyoKKwkJICogV2UgY291bGQgYmUgY2xldmVyIGFuZCBhbGxvdyB0byBhdHRhY2ggYSBjb3VudGVyIHRvIGFuCisJCSAqIG9mZmxpbmUgQ1BVIGFuZCBhY3RpdmF0ZSBpdCB3aGVuIHRoZSBDUFUgY29tZXMgdXAsIGJ1dAorCQkgKiB0aGF0J3MgZm9yIGxhdGVyLgorCQkgKi8KKwkJaWYgKCFjcHVfaXNzZXQoY3B1LCBjcHVfb25saW5lX21hcCkpCisJCQlyZXR1cm4gRVJSX1BUUigtRU5PREVWKTsKKworCQljcHVjdHggPSAmcGVyX2NwdShwZXJmX2NwdV9jb250ZXh0LCBjcHUpOworCQljdHggPSAmY3B1Y3R4LT5jdHg7CisJCWdldF9jdHgoY3R4KTsKKworCQlyZXR1cm4gY3R4OworCX0KKworCXJjdV9yZWFkX2xvY2soKTsKKwlpZiAoIXBpZCkKKwkJdGFzayA9IGN1cnJlbnQ7CisJZWxzZQorCQl0YXNrID0gZmluZF90YXNrX2J5X3ZwaWQocGlkKTsKKwlpZiAodGFzaykKKwkJZ2V0X3Rhc2tfc3RydWN0KHRhc2spOworCXJjdV9yZWFkX3VubG9jaygpOworCisJaWYgKCF0YXNrKQorCQlyZXR1cm4gRVJSX1BUUigtRVNSQ0gpOworCisJLyoKKwkgKiBDYW4ndCBhdHRhY2ggY291bnRlcnMgdG8gYSBkeWluZyB0YXNrLgorCSAqLworCWVyciA9IC1FU1JDSDsKKwlpZiAodGFzay0+ZmxhZ3MgJiBQRl9FWElUSU5HKQorCQlnb3RvIGVycm91dDsKKworCS8qIFJldXNlIHB0cmFjZSBwZXJtaXNzaW9uIGNoZWNrcyBmb3Igbm93LiAqLworCWVyciA9IC1FQUNDRVM7CisJaWYgKCFwdHJhY2VfbWF5X2FjY2Vzcyh0YXNrLCBQVFJBQ0VfTU9ERV9SRUFEKSkKKwkJZ290byBlcnJvdXQ7CisKKyByZXRyeToKKwljdHggPSBwZXJmX2xvY2tfdGFza19jb250ZXh0KHRhc2ssICZmbGFncyk7CisJaWYgKGN0eCkgeworCQlwYXJlbnRfY3R4ID0gY3R4LT5wYXJlbnRfY3R4OworCQlpZiAocGFyZW50X2N0eCkgeworCQkJcHV0X2N0eChwYXJlbnRfY3R4KTsKKwkJCWN0eC0+cGFyZW50X2N0eCA9IE5VTEw7CQkvKiBubyBsb25nZXIgYSBjbG9uZSAqLworCQl9CisJCS8qCisJCSAqIEdldCBhbiBleHRyYSByZWZlcmVuY2UgYmVmb3JlIGRyb3BwaW5nIHRoZSBsb2NrIHNvIHRoYXQKKwkJICogdGhpcyBjb250ZXh0IHdvbid0IGdldCBmcmVlZCBpZiB0aGUgdGFzayBleGl0cy4KKwkJICovCisJCWdldF9jdHgoY3R4KTsKKwkJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmY3R4LT5sb2NrLCBmbGFncyk7CisJfQorCisJaWYgKCFjdHgpIHsKKwkJY3R4ID0ga21hbGxvYyhzaXplb2Yoc3RydWN0IHBlcmZfY291bnRlcl9jb250ZXh0KSwgR0ZQX0tFUk5FTCk7CisJCWVyciA9IC1FTk9NRU07CisJCWlmICghY3R4KQorCQkJZ290byBlcnJvdXQ7CisJCV9fcGVyZl9jb3VudGVyX2luaXRfY29udGV4dChjdHgsIHRhc2spOworCQlnZXRfY3R4KGN0eCk7CisJCWlmIChjbXB4Y2hnKCZ0YXNrLT5wZXJmX2NvdW50ZXJfY3R4cCwgTlVMTCwgY3R4KSkgeworCQkJLyoKKwkJCSAqIFdlIHJhY2VkIHdpdGggc29tZSBvdGhlciB0YXNrOyB1c2UKKwkJCSAqIHRoZSBjb250ZXh0IHRoZXkgc2V0LgorCQkJICovCisJCQlrZnJlZShjdHgpOworCQkJZ290byByZXRyeTsKKwkJfQorCQlnZXRfdGFza19zdHJ1Y3QodGFzayk7CisJfQorCisJcHV0X3Rhc2tfc3RydWN0KHRhc2spOworCXJldHVybiBjdHg7CisKKyBlcnJvdXQ6CisJcHV0X3Rhc2tfc3RydWN0KHRhc2spOworCXJldHVybiBFUlJfUFRSKGVycik7Cit9CisKK3N0YXRpYyB2b2lkIGZyZWVfY291bnRlcl9yY3Uoc3RydWN0IHJjdV9oZWFkICpoZWFkKQoreworCXN0cnVjdCBwZXJmX2NvdW50ZXIgKmNvdW50ZXI7CisKKwljb3VudGVyID0gY29udGFpbmVyX29mKGhlYWQsIHN0cnVjdCBwZXJmX2NvdW50ZXIsIHJjdV9oZWFkKTsKKwlpZiAoY291bnRlci0+bnMpCisJCXB1dF9waWRfbnMoY291bnRlci0+bnMpOworCWtmcmVlKGNvdW50ZXIpOworfQorCitzdGF0aWMgdm9pZCBwZXJmX3BlbmRpbmdfc3luYyhzdHJ1Y3QgcGVyZl9jb3VudGVyICpjb3VudGVyKTsKKworc3RhdGljIHZvaWQgZnJlZV9jb3VudGVyKHN0cnVjdCBwZXJmX2NvdW50ZXIgKmNvdW50ZXIpCit7CisJcGVyZl9wZW5kaW5nX3N5bmMoY291bnRlcik7CisKKwlhdG9taWNfZGVjKCZucl9jb3VudGVycyk7CisJaWYgKGNvdW50ZXItPmF0dHIubW1hcCkKKwkJYXRvbWljX2RlYygmbnJfbW1hcF9jb3VudGVycyk7CisJaWYgKGNvdW50ZXItPmF0dHIuY29tbSkKKwkJYXRvbWljX2RlYygmbnJfY29tbV9jb3VudGVycyk7CisKKwlpZiAoY291bnRlci0+ZGVzdHJveSkKKwkJY291bnRlci0+ZGVzdHJveShjb3VudGVyKTsKKworCXB1dF9jdHgoY291bnRlci0+Y3R4KTsKKwljYWxsX3JjdSgmY291bnRlci0+cmN1X2hlYWQsIGZyZWVfY291bnRlcl9yY3UpOworfQorCisvKgorICogQ2FsbGVkIHdoZW4gdGhlIGxhc3QgcmVmZXJlbmNlIHRvIHRoZSBmaWxlIGlzIGdvbmUuCisgKi8KK3N0YXRpYyBpbnQgcGVyZl9yZWxlYXNlKHN0cnVjdCBpbm9kZSAqaW5vZGUsIHN0cnVjdCBmaWxlICpmaWxlKQoreworCXN0cnVjdCBwZXJmX2NvdW50ZXIgKmNvdW50ZXIgPSBmaWxlLT5wcml2YXRlX2RhdGE7CisJc3RydWN0IHBlcmZfY291bnRlcl9jb250ZXh0ICpjdHggPSBjb3VudGVyLT5jdHg7CisKKwlmaWxlLT5wcml2YXRlX2RhdGEgPSBOVUxMOworCisJV0FSTl9PTl9PTkNFKGN0eC0+cGFyZW50X2N0eCk7CisJbXV0ZXhfbG9jaygmY3R4LT5tdXRleCk7CisJcGVyZl9jb3VudGVyX3JlbW92ZV9mcm9tX2NvbnRleHQoY291bnRlcik7CisJbXV0ZXhfdW5sb2NrKCZjdHgtPm11dGV4KTsKKworCW11dGV4X2xvY2soJmNvdW50ZXItPm93bmVyLT5wZXJmX2NvdW50ZXJfbXV0ZXgpOworCWxpc3RfZGVsX2luaXQoJmNvdW50ZXItPm93bmVyX2VudHJ5KTsKKwltdXRleF91bmxvY2soJmNvdW50ZXItPm93bmVyLT5wZXJmX2NvdW50ZXJfbXV0ZXgpOworCXB1dF90YXNrX3N0cnVjdChjb3VudGVyLT5vd25lcik7CisKKwlmcmVlX2NvdW50ZXIoY291bnRlcik7CisKKwlyZXR1cm4gMDsKK30KKworLyoKKyAqIFJlYWQgdGhlIHBlcmZvcm1hbmNlIGNvdW50ZXIgLSBzaW1wbGUgbm9uIGJsb2NraW5nIHZlcnNpb24gZm9yIG5vdworICovCitzdGF0aWMgc3NpemVfdAorcGVyZl9yZWFkX2h3KHN0cnVjdCBwZXJmX2NvdW50ZXIgKmNvdW50ZXIsIGNoYXIgX191c2VyICpidWYsIHNpemVfdCBjb3VudCkKK3sKKwl1NjQgdmFsdWVzWzNdOworCWludCBuOworCisJLyoKKwkgKiBSZXR1cm4gZW5kLW9mLWZpbGUgZm9yIGEgcmVhZCBvbiBhIGNvdW50ZXIgdGhhdCBpcyBpbgorCSAqIGVycm9yIHN0YXRlIChpLmUuIGJlY2F1c2UgaXQgd2FzIHBpbm5lZCBidXQgaXQgY291bGRuJ3QgYmUKKwkgKiBzY2hlZHVsZWQgb24gdG8gdGhlIENQVSBhdCBzb21lIHBvaW50KS4KKwkgKi8KKwlpZiAoY291bnRlci0+c3RhdGUgPT0gUEVSRl9DT1VOVEVSX1NUQVRFX0VSUk9SKQorCQlyZXR1cm4gMDsKKworCVdBUk5fT05fT05DRShjb3VudGVyLT5jdHgtPnBhcmVudF9jdHgpOworCW11dGV4X2xvY2soJmNvdW50ZXItPmNoaWxkX211dGV4KTsKKwl2YWx1ZXNbMF0gPSBwZXJmX2NvdW50ZXJfcmVhZChjb3VudGVyKTsKKwluID0gMTsKKwlpZiAoY291bnRlci0+YXR0ci5yZWFkX2Zvcm1hdCAmIFBFUkZfRk9STUFUX1RPVEFMX1RJTUVfRU5BQkxFRCkKKwkJdmFsdWVzW24rK10gPSBjb3VudGVyLT50b3RhbF90aW1lX2VuYWJsZWQgKworCQkJYXRvbWljNjRfcmVhZCgmY291bnRlci0+Y2hpbGRfdG90YWxfdGltZV9lbmFibGVkKTsKKwlpZiAoY291bnRlci0+YXR0ci5yZWFkX2Zvcm1hdCAmIFBFUkZfRk9STUFUX1RPVEFMX1RJTUVfUlVOTklORykKKwkJdmFsdWVzW24rK10gPSBjb3VudGVyLT50b3RhbF90aW1lX3J1bm5pbmcgKworCQkJYXRvbWljNjRfcmVhZCgmY291bnRlci0+Y2hpbGRfdG90YWxfdGltZV9ydW5uaW5nKTsKKwlpZiAoY291bnRlci0+YXR0ci5yZWFkX2Zvcm1hdCAmIFBFUkZfRk9STUFUX0lEKQorCQl2YWx1ZXNbbisrXSA9IGNvdW50ZXItPmlkOworCW11dGV4X3VubG9jaygmY291bnRlci0+Y2hpbGRfbXV0ZXgpOworCisJaWYgKGNvdW50IDwgbiAqIHNpemVvZih1NjQpKQorCQlyZXR1cm4gLUVJTlZBTDsKKwljb3VudCA9IG4gKiBzaXplb2YodTY0KTsKKworCWlmIChjb3B5X3RvX3VzZXIoYnVmLCB2YWx1ZXMsIGNvdW50KSkKKwkJcmV0dXJuIC1FRkFVTFQ7CisKKwlyZXR1cm4gY291bnQ7Cit9CisKK3N0YXRpYyBzc2l6ZV90CitwZXJmX3JlYWQoc3RydWN0IGZpbGUgKmZpbGUsIGNoYXIgX191c2VyICpidWYsIHNpemVfdCBjb3VudCwgbG9mZl90ICpwcG9zKQoreworCXN0cnVjdCBwZXJmX2NvdW50ZXIgKmNvdW50ZXIgPSBmaWxlLT5wcml2YXRlX2RhdGE7CisKKwlyZXR1cm4gcGVyZl9yZWFkX2h3KGNvdW50ZXIsIGJ1ZiwgY291bnQpOworfQorCitzdGF0aWMgdW5zaWduZWQgaW50IHBlcmZfcG9sbChzdHJ1Y3QgZmlsZSAqZmlsZSwgcG9sbF90YWJsZSAqd2FpdCkKK3sKKwlzdHJ1Y3QgcGVyZl9jb3VudGVyICpjb3VudGVyID0gZmlsZS0+cHJpdmF0ZV9kYXRhOworCXN0cnVjdCBwZXJmX21tYXBfZGF0YSAqZGF0YTsKKwl1bnNpZ25lZCBpbnQgZXZlbnRzID0gUE9MTF9IVVA7CisKKwlyY3VfcmVhZF9sb2NrKCk7CisJZGF0YSA9IHJjdV9kZXJlZmVyZW5jZShjb3VudGVyLT5kYXRhKTsKKwlpZiAoZGF0YSkKKwkJZXZlbnRzID0gYXRvbWljX3hjaGcoJmRhdGEtPnBvbGwsIDApOworCXJjdV9yZWFkX3VubG9jaygpOworCisJcG9sbF93YWl0KGZpbGUsICZjb3VudGVyLT53YWl0cSwgd2FpdCk7CisKKwlyZXR1cm4gZXZlbnRzOworfQorCitzdGF0aWMgdm9pZCBwZXJmX2NvdW50ZXJfcmVzZXQoc3RydWN0IHBlcmZfY291bnRlciAqY291bnRlcikKK3sKKwkodm9pZClwZXJmX2NvdW50ZXJfcmVhZChjb3VudGVyKTsKKwlhdG9taWM2NF9zZXQoJmNvdW50ZXItPmNvdW50LCAwKTsKKwlwZXJmX2NvdW50ZXJfdXBkYXRlX3VzZXJwYWdlKGNvdW50ZXIpOworfQorCitzdGF0aWMgdm9pZCBwZXJmX2NvdW50ZXJfZm9yX2VhY2hfc2libGluZyhzdHJ1Y3QgcGVyZl9jb3VudGVyICpjb3VudGVyLAorCQkJCQkgIHZvaWQgKCpmdW5jKShzdHJ1Y3QgcGVyZl9jb3VudGVyICopKQoreworCXN0cnVjdCBwZXJmX2NvdW50ZXJfY29udGV4dCAqY3R4ID0gY291bnRlci0+Y3R4OworCXN0cnVjdCBwZXJmX2NvdW50ZXIgKnNpYmxpbmc7CisKKwlXQVJOX09OX09OQ0UoY3R4LT5wYXJlbnRfY3R4KTsKKwltdXRleF9sb2NrKCZjdHgtPm11dGV4KTsKKwljb3VudGVyID0gY291bnRlci0+Z3JvdXBfbGVhZGVyOworCisJZnVuYyhjb3VudGVyKTsKKwlsaXN0X2Zvcl9lYWNoX2VudHJ5KHNpYmxpbmcsICZjb3VudGVyLT5zaWJsaW5nX2xpc3QsIGxpc3RfZW50cnkpCisJCWZ1bmMoc2libGluZyk7CisJbXV0ZXhfdW5sb2NrKCZjdHgtPm11dGV4KTsKK30KKworLyoKKyAqIEhvbGRpbmcgdGhlIHRvcC1sZXZlbCBjb3VudGVyJ3MgY2hpbGRfbXV0ZXggbWVhbnMgdGhhdCBhbnkKKyAqIGRlc2NlbmRhbnQgcHJvY2VzcyB0aGF0IGhhcyBpbmhlcml0ZWQgdGhpcyBjb3VudGVyIHdpbGwgYmxvY2sKKyAqIGluIHN5bmNfY2hpbGRfY291bnRlciBpZiBpdCBnb2VzIHRvIGV4aXQsIHRodXMgc2F0aXNmeWluZyB0aGUKKyAqIHRhc2sgZXhpc3RlbmNlIHJlcXVpcmVtZW50cyBvZiBwZXJmX2NvdW50ZXJfZW5hYmxlL2Rpc2FibGUuCisgKi8KK3N0YXRpYyB2b2lkIHBlcmZfY291bnRlcl9mb3JfZWFjaF9jaGlsZChzdHJ1Y3QgcGVyZl9jb3VudGVyICpjb3VudGVyLAorCQkJCQl2b2lkICgqZnVuYykoc3RydWN0IHBlcmZfY291bnRlciAqKSkKK3sKKwlzdHJ1Y3QgcGVyZl9jb3VudGVyICpjaGlsZDsKKworCVdBUk5fT05fT05DRShjb3VudGVyLT5jdHgtPnBhcmVudF9jdHgpOworCW11dGV4X2xvY2soJmNvdW50ZXItPmNoaWxkX211dGV4KTsKKwlmdW5jKGNvdW50ZXIpOworCWxpc3RfZm9yX2VhY2hfZW50cnkoY2hpbGQsICZjb3VudGVyLT5jaGlsZF9saXN0LCBjaGlsZF9saXN0KQorCQlmdW5jKGNoaWxkKTsKKwltdXRleF91bmxvY2soJmNvdW50ZXItPmNoaWxkX211dGV4KTsKK30KKworc3RhdGljIHZvaWQgcGVyZl9jb3VudGVyX2Zvcl9lYWNoKHN0cnVjdCBwZXJmX2NvdW50ZXIgKmNvdW50ZXIsCisJCQkJICB2b2lkICgqZnVuYykoc3RydWN0IHBlcmZfY291bnRlciAqKSkKK3sKKwlzdHJ1Y3QgcGVyZl9jb3VudGVyICpjaGlsZDsKKworCVdBUk5fT05fT05DRShjb3VudGVyLT5jdHgtPnBhcmVudF9jdHgpOworCW11dGV4X2xvY2soJmNvdW50ZXItPmNoaWxkX211dGV4KTsKKwlwZXJmX2NvdW50ZXJfZm9yX2VhY2hfc2libGluZyhjb3VudGVyLCBmdW5jKTsKKwlsaXN0X2Zvcl9lYWNoX2VudHJ5KGNoaWxkLCAmY291bnRlci0+Y2hpbGRfbGlzdCwgY2hpbGRfbGlzdCkKKwkJcGVyZl9jb3VudGVyX2Zvcl9lYWNoX3NpYmxpbmcoY2hpbGQsIGZ1bmMpOworCW11dGV4X3VubG9jaygmY291bnRlci0+Y2hpbGRfbXV0ZXgpOworfQorCitzdGF0aWMgaW50IHBlcmZfY291bnRlcl9wZXJpb2Qoc3RydWN0IHBlcmZfY291bnRlciAqY291bnRlciwgdTY0IF9fdXNlciAqYXJnKQoreworCXN0cnVjdCBwZXJmX2NvdW50ZXJfY29udGV4dCAqY3R4ID0gY291bnRlci0+Y3R4OworCXVuc2lnbmVkIGxvbmcgc2l6ZTsKKwlpbnQgcmV0ID0gMDsKKwl1NjQgdmFsdWU7CisKKwlpZiAoIWNvdW50ZXItPmF0dHIuc2FtcGxlX3BlcmlvZCkKKwkJcmV0dXJuIC1FSU5WQUw7CisKKwlzaXplID0gY29weV9mcm9tX3VzZXIoJnZhbHVlLCBhcmcsIHNpemVvZih2YWx1ZSkpOworCWlmIChzaXplICE9IHNpemVvZih2YWx1ZSkpCisJCXJldHVybiAtRUZBVUxUOworCisJaWYgKCF2YWx1ZSkKKwkJcmV0dXJuIC1FSU5WQUw7CisKKwlzcGluX2xvY2tfaXJxKCZjdHgtPmxvY2spOworCWlmIChjb3VudGVyLT5hdHRyLmZyZXEpIHsKKwkJaWYgKHZhbHVlID4gc3lzY3RsX3BlcmZfY291bnRlcl9zYW1wbGVfcmF0ZSkgeworCQkJcmV0ID0gLUVJTlZBTDsKKwkJCWdvdG8gdW5sb2NrOworCQl9CisKKwkJY291bnRlci0+YXR0ci5zYW1wbGVfZnJlcSA9IHZhbHVlOworCX0gZWxzZSB7CisJCXBlcmZfbG9nX3BlcmlvZChjb3VudGVyLCB2YWx1ZSk7CisKKwkJY291bnRlci0+YXR0ci5zYW1wbGVfcGVyaW9kID0gdmFsdWU7CisJCWNvdW50ZXItPmh3LnNhbXBsZV9wZXJpb2QgPSB2YWx1ZTsKKwl9Cit1bmxvY2s6CisJc3Bpbl91bmxvY2tfaXJxKCZjdHgtPmxvY2spOworCisJcmV0dXJuIHJldDsKK30KKworc3RhdGljIGxvbmcgcGVyZl9pb2N0bChzdHJ1Y3QgZmlsZSAqZmlsZSwgdW5zaWduZWQgaW50IGNtZCwgdW5zaWduZWQgbG9uZyBhcmcpCit7CisJc3RydWN0IHBlcmZfY291bnRlciAqY291bnRlciA9IGZpbGUtPnByaXZhdGVfZGF0YTsKKwl2b2lkICgqZnVuYykoc3RydWN0IHBlcmZfY291bnRlciAqKTsKKwl1MzIgZmxhZ3MgPSBhcmc7CisKKwlzd2l0Y2ggKGNtZCkgeworCWNhc2UgUEVSRl9DT1VOVEVSX0lPQ19FTkFCTEU6CisJCWZ1bmMgPSBwZXJmX2NvdW50ZXJfZW5hYmxlOworCQlicmVhazsKKwljYXNlIFBFUkZfQ09VTlRFUl9JT0NfRElTQUJMRToKKwkJZnVuYyA9IHBlcmZfY291bnRlcl9kaXNhYmxlOworCQlicmVhazsKKwljYXNlIFBFUkZfQ09VTlRFUl9JT0NfUkVTRVQ6CisJCWZ1bmMgPSBwZXJmX2NvdW50ZXJfcmVzZXQ7CisJCWJyZWFrOworCisJY2FzZSBQRVJGX0NPVU5URVJfSU9DX1JFRlJFU0g6CisJCXJldHVybiBwZXJmX2NvdW50ZXJfcmVmcmVzaChjb3VudGVyLCBhcmcpOworCisJY2FzZSBQRVJGX0NPVU5URVJfSU9DX1BFUklPRDoKKwkJcmV0dXJuIHBlcmZfY291bnRlcl9wZXJpb2QoY291bnRlciwgKHU2NCBfX3VzZXIgKilhcmcpOworCisJZGVmYXVsdDoKKwkJcmV0dXJuIC1FTk9UVFk7CisJfQorCisJaWYgKGZsYWdzICYgUEVSRl9JT0NfRkxBR19HUk9VUCkKKwkJcGVyZl9jb3VudGVyX2Zvcl9lYWNoKGNvdW50ZXIsIGZ1bmMpOworCWVsc2UKKwkJcGVyZl9jb3VudGVyX2Zvcl9lYWNoX2NoaWxkKGNvdW50ZXIsIGZ1bmMpOworCisJcmV0dXJuIDA7Cit9CisKK2ludCBwZXJmX2NvdW50ZXJfdGFza19lbmFibGUodm9pZCkKK3sKKwlzdHJ1Y3QgcGVyZl9jb3VudGVyICpjb3VudGVyOworCisJbXV0ZXhfbG9jaygmY3VycmVudC0+cGVyZl9jb3VudGVyX211dGV4KTsKKwlsaXN0X2Zvcl9lYWNoX2VudHJ5KGNvdW50ZXIsICZjdXJyZW50LT5wZXJmX2NvdW50ZXJfbGlzdCwgb3duZXJfZW50cnkpCisJCXBlcmZfY291bnRlcl9mb3JfZWFjaF9jaGlsZChjb3VudGVyLCBwZXJmX2NvdW50ZXJfZW5hYmxlKTsKKwltdXRleF91bmxvY2soJmN1cnJlbnQtPnBlcmZfY291bnRlcl9tdXRleCk7CisKKwlyZXR1cm4gMDsKK30KKworaW50IHBlcmZfY291bnRlcl90YXNrX2Rpc2FibGUodm9pZCkKK3sKKwlzdHJ1Y3QgcGVyZl9jb3VudGVyICpjb3VudGVyOworCisJbXV0ZXhfbG9jaygmY3VycmVudC0+cGVyZl9jb3VudGVyX211dGV4KTsKKwlsaXN0X2Zvcl9lYWNoX2VudHJ5KGNvdW50ZXIsICZjdXJyZW50LT5wZXJmX2NvdW50ZXJfbGlzdCwgb3duZXJfZW50cnkpCisJCXBlcmZfY291bnRlcl9mb3JfZWFjaF9jaGlsZChjb3VudGVyLCBwZXJmX2NvdW50ZXJfZGlzYWJsZSk7CisJbXV0ZXhfdW5sb2NrKCZjdXJyZW50LT5wZXJmX2NvdW50ZXJfbXV0ZXgpOworCisJcmV0dXJuIDA7Cit9CisKKy8qCisgKiBDYWxsZXJzIG5lZWQgdG8gZW5zdXJlIHRoZXJlIGNhbiBiZSBubyBuZXN0aW5nIG9mIHRoaXMgZnVuY3Rpb24sIG90aGVyd2lzZQorICogdGhlIHNlcWxvY2sgbG9naWMgZ29lcyBiYWQuIFdlIGNhbiBub3Qgc2VyaWFsaXplIHRoaXMgYmVjYXVzZSB0aGUgYXJjaAorICogY29kZSBjYWxscyB0aGlzIGZyb20gTk1JIGNvbnRleHQuCisgKi8KK3ZvaWQgcGVyZl9jb3VudGVyX3VwZGF0ZV91c2VycGFnZShzdHJ1Y3QgcGVyZl9jb3VudGVyICpjb3VudGVyKQoreworCXN0cnVjdCBwZXJmX2NvdW50ZXJfbW1hcF9wYWdlICp1c2VycGc7CisJc3RydWN0IHBlcmZfbW1hcF9kYXRhICpkYXRhOworCisJcmN1X3JlYWRfbG9jaygpOworCWRhdGEgPSByY3VfZGVyZWZlcmVuY2UoY291bnRlci0+ZGF0YSk7CisJaWYgKCFkYXRhKQorCQlnb3RvIHVubG9jazsKKworCXVzZXJwZyA9IGRhdGEtPnVzZXJfcGFnZTsKKworCS8qCisJICogRGlzYWJsZSBwcmVlbXB0aW9uIHNvIGFzIHRvIG5vdCBsZXQgdGhlIGNvcnJlc3BvbmRpbmcgdXNlci1zcGFjZQorCSAqIHNwaW4gdG9vIGxvbmcgaWYgd2UgZ2V0IHByZWVtcHRlZC4KKwkgKi8KKwlwcmVlbXB0X2Rpc2FibGUoKTsKKwkrK3VzZXJwZy0+bG9jazsKKwliYXJyaWVyKCk7CisJdXNlcnBnLT5pbmRleCA9IGNvdW50ZXItPmh3LmlkeDsKKwl1c2VycGctPm9mZnNldCA9IGF0b21pYzY0X3JlYWQoJmNvdW50ZXItPmNvdW50KTsKKwlpZiAoY291bnRlci0+c3RhdGUgPT0gUEVSRl9DT1VOVEVSX1NUQVRFX0FDVElWRSkKKwkJdXNlcnBnLT5vZmZzZXQgLT0gYXRvbWljNjRfcmVhZCgmY291bnRlci0+aHcucHJldl9jb3VudCk7CisKKwliYXJyaWVyKCk7CisJKyt1c2VycGctPmxvY2s7CisJcHJlZW1wdF9lbmFibGUoKTsKK3VubG9jazoKKwlyY3VfcmVhZF91bmxvY2soKTsKK30KKworc3RhdGljIGludCBwZXJmX21tYXBfZmF1bHQoc3RydWN0IHZtX2FyZWFfc3RydWN0ICp2bWEsIHN0cnVjdCB2bV9mYXVsdCAqdm1mKQoreworCXN0cnVjdCBwZXJmX2NvdW50ZXIgKmNvdW50ZXIgPSB2bWEtPnZtX2ZpbGUtPnByaXZhdGVfZGF0YTsKKwlzdHJ1Y3QgcGVyZl9tbWFwX2RhdGEgKmRhdGE7CisJaW50IHJldCA9IFZNX0ZBVUxUX1NJR0JVUzsKKworCXJjdV9yZWFkX2xvY2soKTsKKwlkYXRhID0gcmN1X2RlcmVmZXJlbmNlKGNvdW50ZXItPmRhdGEpOworCWlmICghZGF0YSkKKwkJZ290byB1bmxvY2s7CisKKwlpZiAodm1mLT5wZ29mZiA9PSAwKSB7CisJCXZtZi0+cGFnZSA9IHZpcnRfdG9fcGFnZShkYXRhLT51c2VyX3BhZ2UpOworCX0gZWxzZSB7CisJCWludCBuciA9IHZtZi0+cGdvZmYgLSAxOworCisJCWlmICgodW5zaWduZWQpbnIgPiBkYXRhLT5ucl9wYWdlcykKKwkJCWdvdG8gdW5sb2NrOworCisJCXZtZi0+cGFnZSA9IHZpcnRfdG9fcGFnZShkYXRhLT5kYXRhX3BhZ2VzW25yXSk7CisJfQorCWdldF9wYWdlKHZtZi0+cGFnZSk7CisJcmV0ID0gMDsKK3VubG9jazoKKwlyY3VfcmVhZF91bmxvY2soKTsKKworCXJldHVybiByZXQ7Cit9CisKK3N0YXRpYyBpbnQgcGVyZl9tbWFwX2RhdGFfYWxsb2Moc3RydWN0IHBlcmZfY291bnRlciAqY291bnRlciwgaW50IG5yX3BhZ2VzKQoreworCXN0cnVjdCBwZXJmX21tYXBfZGF0YSAqZGF0YTsKKwl1bnNpZ25lZCBsb25nIHNpemU7CisJaW50IGk7CisKKwlXQVJOX09OKGF0b21pY19yZWFkKCZjb3VudGVyLT5tbWFwX2NvdW50KSk7CisKKwlzaXplID0gc2l6ZW9mKHN0cnVjdCBwZXJmX21tYXBfZGF0YSk7CisJc2l6ZSArPSBucl9wYWdlcyAqIHNpemVvZih2b2lkICopOworCisJZGF0YSA9IGt6YWxsb2Moc2l6ZSwgR0ZQX0tFUk5FTCk7CisJaWYgKCFkYXRhKQorCQlnb3RvIGZhaWw7CisKKwlkYXRhLT51c2VyX3BhZ2UgPSAodm9pZCAqKWdldF96ZXJvZWRfcGFnZShHRlBfS0VSTkVMKTsKKwlpZiAoIWRhdGEtPnVzZXJfcGFnZSkKKwkJZ290byBmYWlsX3VzZXJfcGFnZTsKKworCWZvciAoaSA9IDA7IGkgPCBucl9wYWdlczsgaSsrKSB7CisJCWRhdGEtPmRhdGFfcGFnZXNbaV0gPSAodm9pZCAqKWdldF96ZXJvZWRfcGFnZShHRlBfS0VSTkVMKTsKKwkJaWYgKCFkYXRhLT5kYXRhX3BhZ2VzW2ldKQorCQkJZ290byBmYWlsX2RhdGFfcGFnZXM7CisJfQorCisJZGF0YS0+bnJfcGFnZXMgPSBucl9wYWdlczsKKwlhdG9taWNfc2V0KCZkYXRhLT5sb2NrLCAtMSk7CisKKwlyY3VfYXNzaWduX3BvaW50ZXIoY291bnRlci0+ZGF0YSwgZGF0YSk7CisKKwlyZXR1cm4gMDsKKworZmFpbF9kYXRhX3BhZ2VzOgorCWZvciAoaS0tOyBpID49IDA7IGktLSkKKwkJZnJlZV9wYWdlKCh1bnNpZ25lZCBsb25nKWRhdGEtPmRhdGFfcGFnZXNbaV0pOworCisJZnJlZV9wYWdlKCh1bnNpZ25lZCBsb25nKWRhdGEtPnVzZXJfcGFnZSk7CisKK2ZhaWxfdXNlcl9wYWdlOgorCWtmcmVlKGRhdGEpOworCitmYWlsOgorCXJldHVybiAtRU5PTUVNOworfQorCitzdGF0aWMgdm9pZCBfX3BlcmZfbW1hcF9kYXRhX2ZyZWUoc3RydWN0IHJjdV9oZWFkICpyY3VfaGVhZCkKK3sKKwlzdHJ1Y3QgcGVyZl9tbWFwX2RhdGEgKmRhdGE7CisJaW50IGk7CisKKwlkYXRhID0gY29udGFpbmVyX29mKHJjdV9oZWFkLCBzdHJ1Y3QgcGVyZl9tbWFwX2RhdGEsIHJjdV9oZWFkKTsKKworCWZyZWVfcGFnZSgodW5zaWduZWQgbG9uZylkYXRhLT51c2VyX3BhZ2UpOworCWZvciAoaSA9IDA7IGkgPCBkYXRhLT5ucl9wYWdlczsgaSsrKQorCQlmcmVlX3BhZ2UoKHVuc2lnbmVkIGxvbmcpZGF0YS0+ZGF0YV9wYWdlc1tpXSk7CisJa2ZyZWUoZGF0YSk7Cit9CisKK3N0YXRpYyB2b2lkIHBlcmZfbW1hcF9kYXRhX2ZyZWUoc3RydWN0IHBlcmZfY291bnRlciAqY291bnRlcikKK3sKKwlzdHJ1Y3QgcGVyZl9tbWFwX2RhdGEgKmRhdGEgPSBjb3VudGVyLT5kYXRhOworCisJV0FSTl9PTihhdG9taWNfcmVhZCgmY291bnRlci0+bW1hcF9jb3VudCkpOworCisJcmN1X2Fzc2lnbl9wb2ludGVyKGNvdW50ZXItPmRhdGEsIE5VTEwpOworCWNhbGxfcmN1KCZkYXRhLT5yY3VfaGVhZCwgX19wZXJmX21tYXBfZGF0YV9mcmVlKTsKK30KKworc3RhdGljIHZvaWQgcGVyZl9tbWFwX29wZW4oc3RydWN0IHZtX2FyZWFfc3RydWN0ICp2bWEpCit7CisJc3RydWN0IHBlcmZfY291bnRlciAqY291bnRlciA9IHZtYS0+dm1fZmlsZS0+cHJpdmF0ZV9kYXRhOworCisJYXRvbWljX2luYygmY291bnRlci0+bW1hcF9jb3VudCk7Cit9CisKK3N0YXRpYyB2b2lkIHBlcmZfbW1hcF9jbG9zZShzdHJ1Y3Qgdm1fYXJlYV9zdHJ1Y3QgKnZtYSkKK3sKKwlzdHJ1Y3QgcGVyZl9jb3VudGVyICpjb3VudGVyID0gdm1hLT52bV9maWxlLT5wcml2YXRlX2RhdGE7CisKKwlXQVJOX09OX09OQ0UoY291bnRlci0+Y3R4LT5wYXJlbnRfY3R4KTsKKwlpZiAoYXRvbWljX2RlY19hbmRfbXV0ZXhfbG9jaygmY291bnRlci0+bW1hcF9jb3VudCwgJmNvdW50ZXItPm1tYXBfbXV0ZXgpKSB7CisJCXN0cnVjdCB1c2VyX3N0cnVjdCAqdXNlciA9IGN1cnJlbnRfdXNlcigpOworCisJCWF0b21pY19sb25nX3N1Yihjb3VudGVyLT5kYXRhLT5ucl9wYWdlcyArIDEsICZ1c2VyLT5sb2NrZWRfdm0pOworCQl2bWEtPnZtX21tLT5sb2NrZWRfdm0gLT0gY291bnRlci0+ZGF0YS0+bnJfbG9ja2VkOworCQlwZXJmX21tYXBfZGF0YV9mcmVlKGNvdW50ZXIpOworCQltdXRleF91bmxvY2soJmNvdW50ZXItPm1tYXBfbXV0ZXgpOworCX0KK30KKworc3RhdGljIHN0cnVjdCB2bV9vcGVyYXRpb25zX3N0cnVjdCBwZXJmX21tYXBfdm1vcHMgPSB7CisJLm9wZW4gID0gcGVyZl9tbWFwX29wZW4sCisJLmNsb3NlID0gcGVyZl9tbWFwX2Nsb3NlLAorCS5mYXVsdCA9IHBlcmZfbW1hcF9mYXVsdCwKK307CisKK3N0YXRpYyBpbnQgcGVyZl9tbWFwKHN0cnVjdCBmaWxlICpmaWxlLCBzdHJ1Y3Qgdm1fYXJlYV9zdHJ1Y3QgKnZtYSkKK3sKKwlzdHJ1Y3QgcGVyZl9jb3VudGVyICpjb3VudGVyID0gZmlsZS0+cHJpdmF0ZV9kYXRhOworCXVuc2lnbmVkIGxvbmcgdXNlcl9sb2NrZWQsIHVzZXJfbG9ja19saW1pdDsKKwlzdHJ1Y3QgdXNlcl9zdHJ1Y3QgKnVzZXIgPSBjdXJyZW50X3VzZXIoKTsKKwl1bnNpZ25lZCBsb25nIGxvY2tlZCwgbG9ja19saW1pdDsKKwl1bnNpZ25lZCBsb25nIHZtYV9zaXplOworCXVuc2lnbmVkIGxvbmcgbnJfcGFnZXM7CisJbG9uZyB1c2VyX2V4dHJhLCBleHRyYTsKKwlpbnQgcmV0ID0gMDsKKworCWlmICghKHZtYS0+dm1fZmxhZ3MgJiBWTV9TSEFSRUQpIHx8ICh2bWEtPnZtX2ZsYWdzICYgVk1fV1JJVEUpKQorCQlyZXR1cm4gLUVJTlZBTDsKKworCXZtYV9zaXplID0gdm1hLT52bV9lbmQgLSB2bWEtPnZtX3N0YXJ0OworCW5yX3BhZ2VzID0gKHZtYV9zaXplIC8gUEFHRV9TSVpFKSAtIDE7CisKKwkvKgorCSAqIElmIHdlIGhhdmUgZGF0YSBwYWdlcyBlbnN1cmUgdGhleSdyZSBhIHBvd2VyLW9mLXR3byBudW1iZXIsIHNvIHdlCisJICogY2FuIGRvIGJpdG1hc2tzIGluc3RlYWQgb2YgbW9kdWxvLgorCSAqLworCWlmIChucl9wYWdlcyAhPSAwICYmICFpc19wb3dlcl9vZl8yKG5yX3BhZ2VzKSkKKwkJcmV0dXJuIC1FSU5WQUw7CisKKwlpZiAodm1hX3NpemUgIT0gUEFHRV9TSVpFICogKDEgKyBucl9wYWdlcykpCisJCXJldHVybiAtRUlOVkFMOworCisJaWYgKHZtYS0+dm1fcGdvZmYgIT0gMCkKKwkJcmV0dXJuIC1FSU5WQUw7CisKKwlXQVJOX09OX09OQ0UoY291bnRlci0+Y3R4LT5wYXJlbnRfY3R4KTsKKwltdXRleF9sb2NrKCZjb3VudGVyLT5tbWFwX211dGV4KTsKKwlpZiAoYXRvbWljX2luY19ub3RfemVybygmY291bnRlci0+bW1hcF9jb3VudCkpIHsKKwkJaWYgKG5yX3BhZ2VzICE9IGNvdW50ZXItPmRhdGEtPm5yX3BhZ2VzKQorCQkJcmV0ID0gLUVJTlZBTDsKKwkJZ290byB1bmxvY2s7CisJfQorCisJdXNlcl9leHRyYSA9IG5yX3BhZ2VzICsgMTsKKwl1c2VyX2xvY2tfbGltaXQgPSBzeXNjdGxfcGVyZl9jb3VudGVyX21sb2NrID4+IChQQUdFX1NISUZUIC0gMTApOworCisJLyoKKwkgKiBJbmNyZWFzZSB0aGUgbGltaXQgbGluZWFybHkgd2l0aCBtb3JlIENQVXM6CisJICovCisJdXNlcl9sb2NrX2xpbWl0ICo9IG51bV9vbmxpbmVfY3B1cygpOworCisJdXNlcl9sb2NrZWQgPSBhdG9taWNfbG9uZ19yZWFkKCZ1c2VyLT5sb2NrZWRfdm0pICsgdXNlcl9leHRyYTsKKworCWV4dHJhID0gMDsKKwlpZiAodXNlcl9sb2NrZWQgPiB1c2VyX2xvY2tfbGltaXQpCisJCWV4dHJhID0gdXNlcl9sb2NrZWQgLSB1c2VyX2xvY2tfbGltaXQ7CisKKwlsb2NrX2xpbWl0ID0gY3VycmVudC0+c2lnbmFsLT5ybGltW1JMSU1JVF9NRU1MT0NLXS5ybGltX2N1cjsKKwlsb2NrX2xpbWl0ID4+PSBQQUdFX1NISUZUOworCWxvY2tlZCA9IHZtYS0+dm1fbW0tPmxvY2tlZF92bSArIGV4dHJhOworCisJaWYgKChsb2NrZWQgPiBsb2NrX2xpbWl0KSAmJiAhY2FwYWJsZShDQVBfSVBDX0xPQ0spKSB7CisJCXJldCA9IC1FUEVSTTsKKwkJZ290byB1bmxvY2s7CisJfQorCisJV0FSTl9PTihjb3VudGVyLT5kYXRhKTsKKwlyZXQgPSBwZXJmX21tYXBfZGF0YV9hbGxvYyhjb3VudGVyLCBucl9wYWdlcyk7CisJaWYgKHJldCkKKwkJZ290byB1bmxvY2s7CisKKwlhdG9taWNfc2V0KCZjb3VudGVyLT5tbWFwX2NvdW50LCAxKTsKKwlhdG9taWNfbG9uZ19hZGQodXNlcl9leHRyYSwgJnVzZXItPmxvY2tlZF92bSk7CisJdm1hLT52bV9tbS0+bG9ja2VkX3ZtICs9IGV4dHJhOworCWNvdW50ZXItPmRhdGEtPm5yX2xvY2tlZCA9IGV4dHJhOwordW5sb2NrOgorCW11dGV4X3VubG9jaygmY291bnRlci0+bW1hcF9tdXRleCk7CisKKwl2bWEtPnZtX2ZsYWdzICY9IH5WTV9NQVlXUklURTsKKwl2bWEtPnZtX2ZsYWdzIHw9IFZNX1JFU0VSVkVEOworCXZtYS0+dm1fb3BzID0gJnBlcmZfbW1hcF92bW9wczsKKworCXJldHVybiByZXQ7Cit9CisKK3N0YXRpYyBpbnQgcGVyZl9mYXN5bmMoaW50IGZkLCBzdHJ1Y3QgZmlsZSAqZmlscCwgaW50IG9uKQoreworCXN0cnVjdCBpbm9kZSAqaW5vZGUgPSBmaWxwLT5mX3BhdGguZGVudHJ5LT5kX2lub2RlOworCXN0cnVjdCBwZXJmX2NvdW50ZXIgKmNvdW50ZXIgPSBmaWxwLT5wcml2YXRlX2RhdGE7CisJaW50IHJldHZhbDsKKworCW11dGV4X2xvY2soJmlub2RlLT5pX211dGV4KTsKKwlyZXR2YWwgPSBmYXN5bmNfaGVscGVyKGZkLCBmaWxwLCBvbiwgJmNvdW50ZXItPmZhc3luYyk7CisJbXV0ZXhfdW5sb2NrKCZpbm9kZS0+aV9tdXRleCk7CisKKwlpZiAocmV0dmFsIDwgMCkKKwkJcmV0dXJuIHJldHZhbDsKKworCXJldHVybiAwOworfQorCitzdGF0aWMgY29uc3Qgc3RydWN0IGZpbGVfb3BlcmF0aW9ucyBwZXJmX2ZvcHMgPSB7CisJLnJlbGVhc2UJCT0gcGVyZl9yZWxlYXNlLAorCS5yZWFkCQkJPSBwZXJmX3JlYWQsCisJLnBvbGwJCQk9IHBlcmZfcG9sbCwKKwkudW5sb2NrZWRfaW9jdGwJCT0gcGVyZl9pb2N0bCwKKwkuY29tcGF0X2lvY3RsCQk9IHBlcmZfaW9jdGwsCisJLm1tYXAJCQk9IHBlcmZfbW1hcCwKKwkuZmFzeW5jCQkJPSBwZXJmX2Zhc3luYywKK307CisKKy8qCisgKiBQZXJmIGNvdW50ZXIgd2FrZXVwCisgKgorICogSWYgdGhlcmUncyBkYXRhLCBlbnN1cmUgd2Ugc2V0IHRoZSBwb2xsKCkgc3RhdGUgYW5kIHB1Ymxpc2ggZXZlcnl0aGluZworICogdG8gdXNlci1zcGFjZSBiZWZvcmUgd2FraW5nIGV2ZXJ5Ym9keSB1cC4KKyAqLworCit2b2lkIHBlcmZfY291bnRlcl93YWtldXAoc3RydWN0IHBlcmZfY291bnRlciAqY291bnRlcikKK3sKKwl3YWtlX3VwX2FsbCgmY291bnRlci0+d2FpdHEpOworCisJaWYgKGNvdW50ZXItPnBlbmRpbmdfa2lsbCkgeworCQlraWxsX2Zhc3luYygmY291bnRlci0+ZmFzeW5jLCBTSUdJTywgY291bnRlci0+cGVuZGluZ19raWxsKTsKKwkJY291bnRlci0+cGVuZGluZ19raWxsID0gMDsKKwl9Cit9CisKKy8qCisgKiBQZW5kaW5nIHdha2V1cHMKKyAqCisgKiBIYW5kbGUgdGhlIGNhc2Ugd2hlcmUgd2UgbmVlZCB0byB3YWtldXAgdXAgZnJvbSBOTUkgKG9yIHJxLT5sb2NrKSBjb250ZXh0LgorICoKKyAqIFRoZSBOTUkgYml0IG1lYW5zIHdlIGNhbm5vdCBwb3NzaWJseSB0YWtlIGxvY2tzLiBUaGVyZWZvcmUsIG1haW50YWluIGEKKyAqIHNpbmdsZSBsaW5rZWQgbGlzdCBhbmQgdXNlIGNtcHhjaGcoKSB0byBhZGQgZW50cmllcyBsb2NrbGVzcy4KKyAqLworCitzdGF0aWMgdm9pZCBwZXJmX3BlbmRpbmdfY291bnRlcihzdHJ1Y3QgcGVyZl9wZW5kaW5nX2VudHJ5ICplbnRyeSkKK3sKKwlzdHJ1Y3QgcGVyZl9jb3VudGVyICpjb3VudGVyID0gY29udGFpbmVyX29mKGVudHJ5LAorCQkJc3RydWN0IHBlcmZfY291bnRlciwgcGVuZGluZyk7CisKKwlpZiAoY291bnRlci0+cGVuZGluZ19kaXNhYmxlKSB7CisJCWNvdW50ZXItPnBlbmRpbmdfZGlzYWJsZSA9IDA7CisJCXBlcmZfY291bnRlcl9kaXNhYmxlKGNvdW50ZXIpOworCX0KKworCWlmIChjb3VudGVyLT5wZW5kaW5nX3dha2V1cCkgeworCQljb3VudGVyLT5wZW5kaW5nX3dha2V1cCA9IDA7CisJCXBlcmZfY291bnRlcl93YWtldXAoY291bnRlcik7CisJfQorfQorCisjZGVmaW5lIFBFTkRJTkdfVEFJTCAoKHN0cnVjdCBwZXJmX3BlbmRpbmdfZW50cnkgKiktMVVMKQorCitzdGF0aWMgREVGSU5FX1BFUl9DUFUoc3RydWN0IHBlcmZfcGVuZGluZ19lbnRyeSAqLCBwZXJmX3BlbmRpbmdfaGVhZCkgPSB7CisJUEVORElOR19UQUlMLAorfTsKKworc3RhdGljIHZvaWQgcGVyZl9wZW5kaW5nX3F1ZXVlKHN0cnVjdCBwZXJmX3BlbmRpbmdfZW50cnkgKmVudHJ5LAorCQkJICAgICAgIHZvaWQgKCpmdW5jKShzdHJ1Y3QgcGVyZl9wZW5kaW5nX2VudHJ5ICopKQoreworCXN0cnVjdCBwZXJmX3BlbmRpbmdfZW50cnkgKipoZWFkOworCisJaWYgKGNtcHhjaGcoJmVudHJ5LT5uZXh0LCBOVUxMLCBQRU5ESU5HX1RBSUwpICE9IE5VTEwpCisJCXJldHVybjsKKworCWVudHJ5LT5mdW5jID0gZnVuYzsKKworCWhlYWQgPSAmZ2V0X2NwdV92YXIocGVyZl9wZW5kaW5nX2hlYWQpOworCisJZG8geworCQllbnRyeS0+bmV4dCA9ICpoZWFkOworCX0gd2hpbGUgKGNtcHhjaGcoaGVhZCwgZW50cnktPm5leHQsIGVudHJ5KSAhPSBlbnRyeS0+bmV4dCk7CisKKwlzZXRfcGVyZl9jb3VudGVyX3BlbmRpbmcoKTsKKworCXB1dF9jcHVfdmFyKHBlcmZfcGVuZGluZ19oZWFkKTsKK30KKworc3RhdGljIGludCBfX3BlcmZfcGVuZGluZ19ydW4odm9pZCkKK3sKKwlzdHJ1Y3QgcGVyZl9wZW5kaW5nX2VudHJ5ICpsaXN0OworCWludCBuciA9IDA7CisKKwlsaXN0ID0geGNoZygmX19nZXRfY3B1X3ZhcihwZXJmX3BlbmRpbmdfaGVhZCksIFBFTkRJTkdfVEFJTCk7CisJd2hpbGUgKGxpc3QgIT0gUEVORElOR19UQUlMKSB7CisJCXZvaWQgKCpmdW5jKShzdHJ1Y3QgcGVyZl9wZW5kaW5nX2VudHJ5ICopOworCQlzdHJ1Y3QgcGVyZl9wZW5kaW5nX2VudHJ5ICplbnRyeSA9IGxpc3Q7CisKKwkJbGlzdCA9IGxpc3QtPm5leHQ7CisKKwkJZnVuYyA9IGVudHJ5LT5mdW5jOworCQllbnRyeS0+bmV4dCA9IE5VTEw7CisJCS8qCisJCSAqIEVuc3VyZSB3ZSBvYnNlcnZlIHRoZSB1bnF1ZXVlIGJlZm9yZSB3ZSBpc3N1ZSB0aGUgd2FrZXVwLAorCQkgKiBzbyB0aGF0IHdlIHdvbid0IGJlIHdhaXRpbmcgZm9yZXZlci4KKwkJICogLS0gc2VlIHBlcmZfbm90X3BlbmRpbmcoKS4KKwkJICovCisJCXNtcF93bWIoKTsKKworCQlmdW5jKGVudHJ5KTsKKwkJbnIrKzsKKwl9CisKKwlyZXR1cm4gbnI7Cit9CisKK3N0YXRpYyBpbmxpbmUgaW50IHBlcmZfbm90X3BlbmRpbmcoc3RydWN0IHBlcmZfY291bnRlciAqY291bnRlcikKK3sKKwkvKgorCSAqIElmIHdlIGZsdXNoIG9uIHdoYXRldmVyIGNwdSB3ZSBydW4sIHRoZXJlIGlzIGEgY2hhbmNlIHdlIGRvbid0CisJICogbmVlZCB0byB3YWl0LgorCSAqLworCWdldF9jcHUoKTsKKwlfX3BlcmZfcGVuZGluZ19ydW4oKTsKKwlwdXRfY3B1KCk7CisKKwkvKgorCSAqIEVuc3VyZSB3ZSBzZWUgdGhlIHByb3BlciBxdWV1ZSBzdGF0ZSBiZWZvcmUgZ29pbmcgdG8gc2xlZXAKKwkgKiBzbyB0aGF0IHdlIGRvIG5vdCBtaXNzIHRoZSB3YWtldXAuIC0tIHNlZSBwZXJmX3BlbmRpbmdfaGFuZGxlKCkKKwkgKi8KKwlzbXBfcm1iKCk7CisJcmV0dXJuIGNvdW50ZXItPnBlbmRpbmcubmV4dCA9PSBOVUxMOworfQorCitzdGF0aWMgdm9pZCBwZXJmX3BlbmRpbmdfc3luYyhzdHJ1Y3QgcGVyZl9jb3VudGVyICpjb3VudGVyKQoreworCXdhaXRfZXZlbnQoY291bnRlci0+d2FpdHEsIHBlcmZfbm90X3BlbmRpbmcoY291bnRlcikpOworfQorCit2b2lkIHBlcmZfY291bnRlcl9kb19wZW5kaW5nKHZvaWQpCit7CisJX19wZXJmX3BlbmRpbmdfcnVuKCk7Cit9CisKKy8qCisgKiBDYWxsY2hhaW4gc3VwcG9ydCAtLSBhcmNoIHNwZWNpZmljCisgKi8KKworX193ZWFrIHN0cnVjdCBwZXJmX2NhbGxjaGFpbl9lbnRyeSAqcGVyZl9jYWxsY2hhaW4oc3RydWN0IHB0X3JlZ3MgKnJlZ3MpCit7CisJcmV0dXJuIE5VTEw7Cit9CisKKy8qCisgKiBPdXRwdXQKKyAqLworCitzdHJ1Y3QgcGVyZl9vdXRwdXRfaGFuZGxlIHsKKwlzdHJ1Y3QgcGVyZl9jb3VudGVyCSpjb3VudGVyOworCXN0cnVjdCBwZXJmX21tYXBfZGF0YQkqZGF0YTsKKwl1bnNpZ25lZCBsb25nCQloZWFkOworCXVuc2lnbmVkIGxvbmcJCW9mZnNldDsKKwlpbnQJCQlubWk7CisJaW50CQkJb3ZlcmZsb3c7CisJaW50CQkJbG9ja2VkOworCXVuc2lnbmVkIGxvbmcJCWZsYWdzOworfTsKKworc3RhdGljIHZvaWQgcGVyZl9vdXRwdXRfd2FrZXVwKHN0cnVjdCBwZXJmX291dHB1dF9oYW5kbGUgKmhhbmRsZSkKK3sKKwlhdG9taWNfc2V0KCZoYW5kbGUtPmRhdGEtPnBvbGwsIFBPTExfSU4pOworCisJaWYgKGhhbmRsZS0+bm1pKSB7CisJCWhhbmRsZS0+Y291bnRlci0+cGVuZGluZ193YWtldXAgPSAxOworCQlwZXJmX3BlbmRpbmdfcXVldWUoJmhhbmRsZS0+Y291bnRlci0+cGVuZGluZywKKwkJCQkgICBwZXJmX3BlbmRpbmdfY291bnRlcik7CisJfSBlbHNlCisJCXBlcmZfY291bnRlcl93YWtldXAoaGFuZGxlLT5jb3VudGVyKTsKK30KKworLyoKKyAqIEN1cmlvdXMgbG9ja2luZyBjb25zdHJ1Y3QuCisgKgorICogV2UgbmVlZCB0byBlbnN1cmUgYSBsYXRlciBldmVudCBkb2Vzbid0IHB1Ymxpc2ggYSBoZWFkIHdoZW4gYSBmb3JtZXIKKyAqIGV2ZW50IGlzbid0IGRvbmUgd3JpdGluZy4gSG93ZXZlciBzaW5jZSB3ZSBuZWVkIHRvIGRlYWwgd2l0aCBOTUlzIHdlCisgKiBjYW5ub3QgZnVsbHkgc2VyaWFsaXplIHRoaW5ncy4KKyAqCisgKiBXaGF0IHdlIGRvIGlzIHNlcmlhbGl6ZSBiZXR3ZWVuIENQVXMgc28gd2Ugb25seSBoYXZlIHRvIGRlYWwgd2l0aCBOTUkKKyAqIG5lc3Rpbmcgb24gYSBzaW5nbGUgQ1BVLgorICoKKyAqIFdlIG9ubHkgcHVibGlzaCB0aGUgaGVhZCAoYW5kIGdlbmVyYXRlIGEgd2FrZXVwKSB3aGVuIHRoZSBvdXRlci1tb3N0CisgKiBldmVudCBjb21wbGV0ZXMuCisgKi8KK3N0YXRpYyB2b2lkIHBlcmZfb3V0cHV0X2xvY2soc3RydWN0IHBlcmZfb3V0cHV0X2hhbmRsZSAqaGFuZGxlKQoreworCXN0cnVjdCBwZXJmX21tYXBfZGF0YSAqZGF0YSA9IGhhbmRsZS0+ZGF0YTsKKwlpbnQgY3B1OworCisJaGFuZGxlLT5sb2NrZWQgPSAwOworCisJbG9jYWxfaXJxX3NhdmUoaGFuZGxlLT5mbGFncyk7CisJY3B1ID0gc21wX3Byb2Nlc3Nvcl9pZCgpOworCisJaWYgKGluX25taSgpICYmIGF0b21pY19yZWFkKCZkYXRhLT5sb2NrKSA9PSBjcHUpCisJCXJldHVybjsKKworCXdoaWxlIChhdG9taWNfY21weGNoZygmZGF0YS0+bG9jaywgLTEsIGNwdSkgIT0gLTEpCisJCWNwdV9yZWxheCgpOworCisJaGFuZGxlLT5sb2NrZWQgPSAxOworfQorCitzdGF0aWMgdm9pZCBwZXJmX291dHB1dF91bmxvY2soc3RydWN0IHBlcmZfb3V0cHV0X2hhbmRsZSAqaGFuZGxlKQoreworCXN0cnVjdCBwZXJmX21tYXBfZGF0YSAqZGF0YSA9IGhhbmRsZS0+ZGF0YTsKKwl1bnNpZ25lZCBsb25nIGhlYWQ7CisJaW50IGNwdTsKKworCWRhdGEtPmRvbmVfaGVhZCA9IGRhdGEtPmhlYWQ7CisKKwlpZiAoIWhhbmRsZS0+bG9ja2VkKQorCQlnb3RvIG91dDsKKworYWdhaW46CisJLyoKKwkgKiBUaGUgeGNoZyBpbXBsaWVzIGEgZnVsbCBiYXJyaWVyIHRoYXQgZW5zdXJlcyBhbGwgd3JpdGVzIGFyZSBkb25lCisJICogYmVmb3JlIHdlIHB1Ymxpc2ggdGhlIG5ldyBoZWFkLCBtYXRjaGVkIGJ5IGEgcm1iKCkgaW4gdXNlcnNwYWNlIHdoZW4KKwkgKiByZWFkaW5nIHRoaXMgcG9zaXRpb24uCisJICovCisJd2hpbGUgKChoZWFkID0gYXRvbWljX2xvbmdfeGNoZygmZGF0YS0+ZG9uZV9oZWFkLCAwKSkpCisJCWRhdGEtPnVzZXJfcGFnZS0+ZGF0YV9oZWFkID0gaGVhZDsKKworCS8qCisJICogTk1JIGNhbiBoYXBwZW4gaGVyZSwgd2hpY2ggbWVhbnMgd2UgY2FuIG1pc3MgYSBkb25lX2hlYWQgdXBkYXRlLgorCSAqLworCisJY3B1ID0gYXRvbWljX3hjaGcoJmRhdGEtPmxvY2ssIC0xKTsKKwlXQVJOX09OX09OQ0UoY3B1ICE9IHNtcF9wcm9jZXNzb3JfaWQoKSk7CisKKwkvKgorCSAqIFRoZXJlZm9yZSB3ZSBoYXZlIHRvIHZhbGlkYXRlIHdlIGRpZCBub3QgaW5kZWVkIGRvIHNvLgorCSAqLworCWlmICh1bmxpa2VseShhdG9taWNfbG9uZ19yZWFkKCZkYXRhLT5kb25lX2hlYWQpKSkgeworCQkvKgorCQkgKiBTaW5jZSB3ZSBoYWQgaXQgbG9ja2VkLCB3ZSBjYW4gbG9jayBpdCBhZ2Fpbi4KKwkJICovCisJCXdoaWxlIChhdG9taWNfY21weGNoZygmZGF0YS0+bG9jaywgLTEsIGNwdSkgIT0gLTEpCisJCQljcHVfcmVsYXgoKTsKKworCQlnb3RvIGFnYWluOworCX0KKworCWlmIChhdG9taWNfeGNoZygmZGF0YS0+d2FrZXVwLCAwKSkKKwkJcGVyZl9vdXRwdXRfd2FrZXVwKGhhbmRsZSk7CitvdXQ6CisJbG9jYWxfaXJxX3Jlc3RvcmUoaGFuZGxlLT5mbGFncyk7Cit9CisKK3N0YXRpYyBpbnQgcGVyZl9vdXRwdXRfYmVnaW4oc3RydWN0IHBlcmZfb3V0cHV0X2hhbmRsZSAqaGFuZGxlLAorCQkJICAgICBzdHJ1Y3QgcGVyZl9jb3VudGVyICpjb3VudGVyLCB1bnNpZ25lZCBpbnQgc2l6ZSwKKwkJCSAgICAgaW50IG5taSwgaW50IG92ZXJmbG93KQoreworCXN0cnVjdCBwZXJmX21tYXBfZGF0YSAqZGF0YTsKKwl1bnNpZ25lZCBpbnQgb2Zmc2V0LCBoZWFkOworCisJLyoKKwkgKiBGb3IgaW5oZXJpdGVkIGNvdW50ZXJzIHdlIHNlbmQgYWxsIHRoZSBvdXRwdXQgdG93YXJkcyB0aGUgcGFyZW50LgorCSAqLworCWlmIChjb3VudGVyLT5wYXJlbnQpCisJCWNvdW50ZXIgPSBjb3VudGVyLT5wYXJlbnQ7CisKKwlyY3VfcmVhZF9sb2NrKCk7CisJZGF0YSA9IHJjdV9kZXJlZmVyZW5jZShjb3VudGVyLT5kYXRhKTsKKwlpZiAoIWRhdGEpCisJCWdvdG8gb3V0OworCisJaGFuZGxlLT5kYXRhCSA9IGRhdGE7CisJaGFuZGxlLT5jb3VudGVyCSA9IGNvdW50ZXI7CisJaGFuZGxlLT5ubWkJID0gbm1pOworCWhhbmRsZS0+b3ZlcmZsb3cgPSBvdmVyZmxvdzsKKworCWlmICghZGF0YS0+bnJfcGFnZXMpCisJCWdvdG8gZmFpbDsKKworCXBlcmZfb3V0cHV0X2xvY2soaGFuZGxlKTsKKworCWRvIHsKKwkJb2Zmc2V0ID0gaGVhZCA9IGF0b21pY19sb25nX3JlYWQoJmRhdGEtPmhlYWQpOworCQloZWFkICs9IHNpemU7CisJfSB3aGlsZSAoYXRvbWljX2xvbmdfY21weGNoZygmZGF0YS0+aGVhZCwgb2Zmc2V0LCBoZWFkKSAhPSBvZmZzZXQpOworCisJaGFuZGxlLT5vZmZzZXQJPSBvZmZzZXQ7CisJaGFuZGxlLT5oZWFkCT0gaGVhZDsKKworCWlmICgob2Zmc2V0ID4+IFBBR0VfU0hJRlQpICE9IChoZWFkID4+IFBBR0VfU0hJRlQpKQorCQlhdG9taWNfc2V0KCZkYXRhLT53YWtldXAsIDEpOworCisJcmV0dXJuIDA7CisKK2ZhaWw6CisJcGVyZl9vdXRwdXRfd2FrZXVwKGhhbmRsZSk7CitvdXQ6CisJcmN1X3JlYWRfdW5sb2NrKCk7CisKKwlyZXR1cm4gLUVOT1NQQzsKK30KKworc3RhdGljIHZvaWQgcGVyZl9vdXRwdXRfY29weShzdHJ1Y3QgcGVyZl9vdXRwdXRfaGFuZGxlICpoYW5kbGUsCisJCQkgICAgIGNvbnN0IHZvaWQgKmJ1ZiwgdW5zaWduZWQgaW50IGxlbikKK3sKKwl1bnNpZ25lZCBpbnQgcGFnZXNfbWFzazsKKwl1bnNpZ25lZCBpbnQgb2Zmc2V0OworCXVuc2lnbmVkIGludCBzaXplOworCXZvaWQgKipwYWdlczsKKworCW9mZnNldAkJPSBoYW5kbGUtPm9mZnNldDsKKwlwYWdlc19tYXNrCT0gaGFuZGxlLT5kYXRhLT5ucl9wYWdlcyAtIDE7CisJcGFnZXMJCT0gaGFuZGxlLT5kYXRhLT5kYXRhX3BhZ2VzOworCisJZG8geworCQl1bnNpZ25lZCBpbnQgcGFnZV9vZmZzZXQ7CisJCWludCBucjsKKworCQlucgkgICAgPSAob2Zmc2V0ID4+IFBBR0VfU0hJRlQpICYgcGFnZXNfbWFzazsKKwkJcGFnZV9vZmZzZXQgPSBvZmZzZXQgJiAoUEFHRV9TSVpFIC0gMSk7CisJCXNpemUJICAgID0gbWluX3QodW5zaWduZWQgaW50LCBQQUdFX1NJWkUgLSBwYWdlX29mZnNldCwgbGVuKTsKKworCQltZW1jcHkocGFnZXNbbnJdICsgcGFnZV9vZmZzZXQsIGJ1Ziwgc2l6ZSk7CisKKwkJbGVuCSAgICAtPSBzaXplOworCQlidWYJICAgICs9IHNpemU7CisJCW9mZnNldAkgICAgKz0gc2l6ZTsKKwl9IHdoaWxlIChsZW4pOworCisJaGFuZGxlLT5vZmZzZXQgPSBvZmZzZXQ7CisKKwkvKgorCSAqIENoZWNrIHdlIGRpZG4ndCBjb3B5IHBhc3Qgb3VyIHJlc2VydmF0aW9uIHdpbmRvdywgdGFraW5nIHRoZQorCSAqIHBvc3NpYmxlIHVuc2lnbmVkIGludCB3cmFwIGludG8gYWNjb3VudC4KKwkgKi8KKwlXQVJOX09OX09OQ0UoKChsb25nKShoYW5kbGUtPmhlYWQgLSBoYW5kbGUtPm9mZnNldCkpIDwgMCk7Cit9CisKKyNkZWZpbmUgcGVyZl9vdXRwdXRfcHV0KGhhbmRsZSwgeCkgXAorCXBlcmZfb3V0cHV0X2NvcHkoKGhhbmRsZSksICYoeCksIHNpemVvZih4KSkKKworc3RhdGljIHZvaWQgcGVyZl9vdXRwdXRfZW5kKHN0cnVjdCBwZXJmX291dHB1dF9oYW5kbGUgKmhhbmRsZSkKK3sKKwlzdHJ1Y3QgcGVyZl9jb3VudGVyICpjb3VudGVyID0gaGFuZGxlLT5jb3VudGVyOworCXN0cnVjdCBwZXJmX21tYXBfZGF0YSAqZGF0YSA9IGhhbmRsZS0+ZGF0YTsKKworCWludCB3YWtldXBfZXZlbnRzID0gY291bnRlci0+YXR0ci53YWtldXBfZXZlbnRzOworCisJaWYgKGhhbmRsZS0+b3ZlcmZsb3cgJiYgd2FrZXVwX2V2ZW50cykgeworCQlpbnQgZXZlbnRzID0gYXRvbWljX2luY19yZXR1cm4oJmRhdGEtPmV2ZW50cyk7CisJCWlmIChldmVudHMgPj0gd2FrZXVwX2V2ZW50cykgeworCQkJYXRvbWljX3N1Yih3YWtldXBfZXZlbnRzLCAmZGF0YS0+ZXZlbnRzKTsKKwkJCWF0b21pY19zZXQoJmRhdGEtPndha2V1cCwgMSk7CisJCX0KKwl9CisKKwlwZXJmX291dHB1dF91bmxvY2soaGFuZGxlKTsKKwlyY3VfcmVhZF91bmxvY2soKTsKK30KKworc3RhdGljIHUzMiBwZXJmX2NvdW50ZXJfcGlkKHN0cnVjdCBwZXJmX2NvdW50ZXIgKmNvdW50ZXIsIHN0cnVjdCB0YXNrX3N0cnVjdCAqcCkKK3sKKwkvKgorCSAqIG9ubHkgdG9wIGxldmVsIGNvdW50ZXJzIGhhdmUgdGhlIHBpZCBuYW1lc3BhY2UgdGhleSB3ZXJlIGNyZWF0ZWQgaW4KKwkgKi8KKwlpZiAoY291bnRlci0+cGFyZW50KQorCQljb3VudGVyID0gY291bnRlci0+cGFyZW50OworCisJcmV0dXJuIHRhc2tfdGdpZF9ucl9ucyhwLCBjb3VudGVyLT5ucyk7Cit9CisKK3N0YXRpYyB1MzIgcGVyZl9jb3VudGVyX3RpZChzdHJ1Y3QgcGVyZl9jb3VudGVyICpjb3VudGVyLCBzdHJ1Y3QgdGFza19zdHJ1Y3QgKnApCit7CisJLyoKKwkgKiBvbmx5IHRvcCBsZXZlbCBjb3VudGVycyBoYXZlIHRoZSBwaWQgbmFtZXNwYWNlIHRoZXkgd2VyZSBjcmVhdGVkIGluCisJICovCisJaWYgKGNvdW50ZXItPnBhcmVudCkKKwkJY291bnRlciA9IGNvdW50ZXItPnBhcmVudDsKKworCXJldHVybiB0YXNrX3BpZF9ucl9ucyhwLCBjb3VudGVyLT5ucyk7Cit9CisKK3N0YXRpYyB2b2lkIHBlcmZfY291bnRlcl9vdXRwdXQoc3RydWN0IHBlcmZfY291bnRlciAqY291bnRlciwgaW50IG5taSwKKwkJCQlzdHJ1Y3QgcGVyZl9zYW1wbGVfZGF0YSAqZGF0YSkKK3sKKwlpbnQgcmV0OworCXU2NCBzYW1wbGVfdHlwZSA9IGNvdW50ZXItPmF0dHIuc2FtcGxlX3R5cGU7CisJc3RydWN0IHBlcmZfb3V0cHV0X2hhbmRsZSBoYW5kbGU7CisJc3RydWN0IHBlcmZfZXZlbnRfaGVhZGVyIGhlYWRlcjsKKwl1NjQgaXA7CisJc3RydWN0IHsKKwkJdTMyIHBpZCwgdGlkOworCX0gdGlkX2VudHJ5OworCXN0cnVjdCB7CisJCXU2NCBpZDsKKwkJdTY0IGNvdW50ZXI7CisJfSBncm91cF9lbnRyeTsKKwlzdHJ1Y3QgcGVyZl9jYWxsY2hhaW5fZW50cnkgKmNhbGxjaGFpbiA9IE5VTEw7CisJaW50IGNhbGxjaGFpbl9zaXplID0gMDsKKwl1NjQgdGltZTsKKwlzdHJ1Y3QgeworCQl1MzIgY3B1LCByZXNlcnZlZDsKKwl9IGNwdV9lbnRyeTsKKworCWhlYWRlci50eXBlID0gMDsKKwloZWFkZXIuc2l6ZSA9IHNpemVvZihoZWFkZXIpOworCisJaGVhZGVyLm1pc2MgPSBQRVJGX0VWRU5UX01JU0NfT1ZFUkZMT1c7CisJaGVhZGVyLm1pc2MgfD0gcGVyZl9taXNjX2ZsYWdzKGRhdGEtPnJlZ3MpOworCisJaWYgKHNhbXBsZV90eXBlICYgUEVSRl9TQU1QTEVfSVApIHsKKwkJaXAgPSBwZXJmX2luc3RydWN0aW9uX3BvaW50ZXIoZGF0YS0+cmVncyk7CisJCWhlYWRlci50eXBlIHw9IFBFUkZfU0FNUExFX0lQOworCQloZWFkZXIuc2l6ZSArPSBzaXplb2YoaXApOworCX0KKworCWlmIChzYW1wbGVfdHlwZSAmIFBFUkZfU0FNUExFX1RJRCkgeworCQkvKiBuYW1lc3BhY2UgaXNzdWVzICovCisJCXRpZF9lbnRyeS5waWQgPSBwZXJmX2NvdW50ZXJfcGlkKGNvdW50ZXIsIGN1cnJlbnQpOworCQl0aWRfZW50cnkudGlkID0gcGVyZl9jb3VudGVyX3RpZChjb3VudGVyLCBjdXJyZW50KTsKKworCQloZWFkZXIudHlwZSB8PSBQRVJGX1NBTVBMRV9USUQ7CisJCWhlYWRlci5zaXplICs9IHNpemVvZih0aWRfZW50cnkpOworCX0KKworCWlmIChzYW1wbGVfdHlwZSAmIFBFUkZfU0FNUExFX1RJTUUpIHsKKwkJLyoKKwkJICogTWF5YmUgZG8gYmV0dGVyIG9uIHg4NiBhbmQgcHJvdmlkZSBjcHVfY2xvY2tfbm1pKCkKKwkJICovCisJCXRpbWUgPSBzY2hlZF9jbG9jaygpOworCisJCWhlYWRlci50eXBlIHw9IFBFUkZfU0FNUExFX1RJTUU7CisJCWhlYWRlci5zaXplICs9IHNpemVvZih1NjQpOworCX0KKworCWlmIChzYW1wbGVfdHlwZSAmIFBFUkZfU0FNUExFX0FERFIpIHsKKwkJaGVhZGVyLnR5cGUgfD0gUEVSRl9TQU1QTEVfQUREUjsKKwkJaGVhZGVyLnNpemUgKz0gc2l6ZW9mKHU2NCk7CisJfQorCisJaWYgKHNhbXBsZV90eXBlICYgUEVSRl9TQU1QTEVfSUQpIHsKKwkJaGVhZGVyLnR5cGUgfD0gUEVSRl9TQU1QTEVfSUQ7CisJCWhlYWRlci5zaXplICs9IHNpemVvZih1NjQpOworCX0KKworCWlmIChzYW1wbGVfdHlwZSAmIFBFUkZfU0FNUExFX0NQVSkgeworCQloZWFkZXIudHlwZSB8PSBQRVJGX1NBTVBMRV9DUFU7CisJCWhlYWRlci5zaXplICs9IHNpemVvZihjcHVfZW50cnkpOworCisJCWNwdV9lbnRyeS5jcHUgPSByYXdfc21wX3Byb2Nlc3Nvcl9pZCgpOworCX0KKworCWlmIChzYW1wbGVfdHlwZSAmIFBFUkZfU0FNUExFX1BFUklPRCkgeworCQloZWFkZXIudHlwZSB8PSBQRVJGX1NBTVBMRV9QRVJJT0Q7CisJCWhlYWRlci5zaXplICs9IHNpemVvZih1NjQpOworCX0KKworCWlmIChzYW1wbGVfdHlwZSAmIFBFUkZfU0FNUExFX0dST1VQKSB7CisJCWhlYWRlci50eXBlIHw9IFBFUkZfU0FNUExFX0dST1VQOworCQloZWFkZXIuc2l6ZSArPSBzaXplb2YodTY0KSArCisJCQljb3VudGVyLT5ucl9zaWJsaW5ncyAqIHNpemVvZihncm91cF9lbnRyeSk7CisJfQorCisJaWYgKHNhbXBsZV90eXBlICYgUEVSRl9TQU1QTEVfQ0FMTENIQUlOKSB7CisJCWNhbGxjaGFpbiA9IHBlcmZfY2FsbGNoYWluKGRhdGEtPnJlZ3MpOworCisJCWlmIChjYWxsY2hhaW4pIHsKKwkJCWNhbGxjaGFpbl9zaXplID0gKDEgKyBjYWxsY2hhaW4tPm5yKSAqIHNpemVvZih1NjQpOworCisJCQloZWFkZXIudHlwZSB8PSBQRVJGX1NBTVBMRV9DQUxMQ0hBSU47CisJCQloZWFkZXIuc2l6ZSArPSBjYWxsY2hhaW5fc2l6ZTsKKwkJfQorCX0KKworCXJldCA9IHBlcmZfb3V0cHV0X2JlZ2luKCZoYW5kbGUsIGNvdW50ZXIsIGhlYWRlci5zaXplLCBubWksIDEpOworCWlmIChyZXQpCisJCXJldHVybjsKKworCXBlcmZfb3V0cHV0X3B1dCgmaGFuZGxlLCBoZWFkZXIpOworCisJaWYgKHNhbXBsZV90eXBlICYgUEVSRl9TQU1QTEVfSVApCisJCXBlcmZfb3V0cHV0X3B1dCgmaGFuZGxlLCBpcCk7CisKKwlpZiAoc2FtcGxlX3R5cGUgJiBQRVJGX1NBTVBMRV9USUQpCisJCXBlcmZfb3V0cHV0X3B1dCgmaGFuZGxlLCB0aWRfZW50cnkpOworCisJaWYgKHNhbXBsZV90eXBlICYgUEVSRl9TQU1QTEVfVElNRSkKKwkJcGVyZl9vdXRwdXRfcHV0KCZoYW5kbGUsIHRpbWUpOworCisJaWYgKHNhbXBsZV90eXBlICYgUEVSRl9TQU1QTEVfQUREUikKKwkJcGVyZl9vdXRwdXRfcHV0KCZoYW5kbGUsIGRhdGEtPmFkZHIpOworCisJaWYgKHNhbXBsZV90eXBlICYgUEVSRl9TQU1QTEVfSUQpCisJCXBlcmZfb3V0cHV0X3B1dCgmaGFuZGxlLCBjb3VudGVyLT5pZCk7CisKKwlpZiAoc2FtcGxlX3R5cGUgJiBQRVJGX1NBTVBMRV9DUFUpCisJCXBlcmZfb3V0cHV0X3B1dCgmaGFuZGxlLCBjcHVfZW50cnkpOworCisJaWYgKHNhbXBsZV90eXBlICYgUEVSRl9TQU1QTEVfUEVSSU9EKQorCQlwZXJmX291dHB1dF9wdXQoJmhhbmRsZSwgZGF0YS0+cGVyaW9kKTsKKworCS8qCisJICogWFhYIFBFUkZfU0FNUExFX0dST1VQIHZzIGluaGVyaXRlZCBjb3VudGVycyBzZWVtcyBkaWZmaWN1bHQuCisJICovCisJaWYgKHNhbXBsZV90eXBlICYgUEVSRl9TQU1QTEVfR1JPVVApIHsKKwkJc3RydWN0IHBlcmZfY291bnRlciAqbGVhZGVyLCAqc3ViOworCQl1NjQgbnIgPSBjb3VudGVyLT5ucl9zaWJsaW5nczsKKworCQlwZXJmX291dHB1dF9wdXQoJmhhbmRsZSwgbnIpOworCisJCWxlYWRlciA9IGNvdW50ZXItPmdyb3VwX2xlYWRlcjsKKwkJbGlzdF9mb3JfZWFjaF9lbnRyeShzdWIsICZsZWFkZXItPnNpYmxpbmdfbGlzdCwgbGlzdF9lbnRyeSkgeworCQkJaWYgKHN1YiAhPSBjb3VudGVyKQorCQkJCXN1Yi0+cG11LT5yZWFkKHN1Yik7CisKKwkJCWdyb3VwX2VudHJ5LmlkID0gc3ViLT5pZDsKKwkJCWdyb3VwX2VudHJ5LmNvdW50ZXIgPSBhdG9taWM2NF9yZWFkKCZzdWItPmNvdW50KTsKKworCQkJcGVyZl9vdXRwdXRfcHV0KCZoYW5kbGUsIGdyb3VwX2VudHJ5KTsKKwkJfQorCX0KKworCWlmIChjYWxsY2hhaW4pCisJCXBlcmZfb3V0cHV0X2NvcHkoJmhhbmRsZSwgY2FsbGNoYWluLCBjYWxsY2hhaW5fc2l6ZSk7CisKKwlwZXJmX291dHB1dF9lbmQoJmhhbmRsZSk7Cit9CisKKy8qCisgKiBmb3JrIHRyYWNraW5nCisgKi8KKworc3RydWN0IHBlcmZfZm9ya19ldmVudCB7CisJc3RydWN0IHRhc2tfc3RydWN0CSp0YXNrOworCisJc3RydWN0IHsKKwkJc3RydWN0IHBlcmZfZXZlbnRfaGVhZGVyCWhlYWRlcjsKKworCQl1MzIJCQkJcGlkOworCQl1MzIJCQkJcHBpZDsKKwl9IGV2ZW50OworfTsKKworc3RhdGljIHZvaWQgcGVyZl9jb3VudGVyX2Zvcmtfb3V0cHV0KHN0cnVjdCBwZXJmX2NvdW50ZXIgKmNvdW50ZXIsCisJCQkJICAgICBzdHJ1Y3QgcGVyZl9mb3JrX2V2ZW50ICpmb3JrX2V2ZW50KQoreworCXN0cnVjdCBwZXJmX291dHB1dF9oYW5kbGUgaGFuZGxlOworCWludCBzaXplID0gZm9ya19ldmVudC0+ZXZlbnQuaGVhZGVyLnNpemU7CisJc3RydWN0IHRhc2tfc3RydWN0ICp0YXNrID0gZm9ya19ldmVudC0+dGFzazsKKwlpbnQgcmV0ID0gcGVyZl9vdXRwdXRfYmVnaW4oJmhhbmRsZSwgY291bnRlciwgc2l6ZSwgMCwgMCk7CisKKwlpZiAocmV0KQorCQlyZXR1cm47CisKKwlmb3JrX2V2ZW50LT5ldmVudC5waWQgPSBwZXJmX2NvdW50ZXJfcGlkKGNvdW50ZXIsIHRhc2spOworCWZvcmtfZXZlbnQtPmV2ZW50LnBwaWQgPSBwZXJmX2NvdW50ZXJfcGlkKGNvdW50ZXIsIHRhc2stPnJlYWxfcGFyZW50KTsKKworCXBlcmZfb3V0cHV0X3B1dCgmaGFuZGxlLCBmb3JrX2V2ZW50LT5ldmVudCk7CisJcGVyZl9vdXRwdXRfZW5kKCZoYW5kbGUpOworfQorCitzdGF0aWMgaW50IHBlcmZfY291bnRlcl9mb3JrX21hdGNoKHN0cnVjdCBwZXJmX2NvdW50ZXIgKmNvdW50ZXIpCit7CisJaWYgKGNvdW50ZXItPmF0dHIuY29tbSB8fCBjb3VudGVyLT5hdHRyLm1tYXApCisJCXJldHVybiAxOworCisJcmV0dXJuIDA7Cit9CisKK3N0YXRpYyB2b2lkIHBlcmZfY291bnRlcl9mb3JrX2N0eChzdHJ1Y3QgcGVyZl9jb3VudGVyX2NvbnRleHQgKmN0eCwKKwkJCQkgIHN0cnVjdCBwZXJmX2ZvcmtfZXZlbnQgKmZvcmtfZXZlbnQpCit7CisJc3RydWN0IHBlcmZfY291bnRlciAqY291bnRlcjsKKworCWlmIChzeXN0ZW1fc3RhdGUgIT0gU1lTVEVNX1JVTk5JTkcgfHwgbGlzdF9lbXB0eSgmY3R4LT5ldmVudF9saXN0KSkKKwkJcmV0dXJuOworCisJcmN1X3JlYWRfbG9jaygpOworCWxpc3RfZm9yX2VhY2hfZW50cnlfcmN1KGNvdW50ZXIsICZjdHgtPmV2ZW50X2xpc3QsIGV2ZW50X2VudHJ5KSB7CisJCWlmIChwZXJmX2NvdW50ZXJfZm9ya19tYXRjaChjb3VudGVyKSkKKwkJCXBlcmZfY291bnRlcl9mb3JrX291dHB1dChjb3VudGVyLCBmb3JrX2V2ZW50KTsKKwl9CisJcmN1X3JlYWRfdW5sb2NrKCk7Cit9CisKK3N0YXRpYyB2b2lkIHBlcmZfY291bnRlcl9mb3JrX2V2ZW50KHN0cnVjdCBwZXJmX2ZvcmtfZXZlbnQgKmZvcmtfZXZlbnQpCit7CisJc3RydWN0IHBlcmZfY3B1X2NvbnRleHQgKmNwdWN0eDsKKwlzdHJ1Y3QgcGVyZl9jb3VudGVyX2NvbnRleHQgKmN0eDsKKworCWNwdWN0eCA9ICZnZXRfY3B1X3ZhcihwZXJmX2NwdV9jb250ZXh0KTsKKwlwZXJmX2NvdW50ZXJfZm9ya19jdHgoJmNwdWN0eC0+Y3R4LCBmb3JrX2V2ZW50KTsKKwlwdXRfY3B1X3ZhcihwZXJmX2NwdV9jb250ZXh0KTsKKworCXJjdV9yZWFkX2xvY2soKTsKKwkvKgorCSAqIGRvZXNuJ3QgcmVhbGx5IG1hdHRlciB3aGljaCBvZiB0aGUgY2hpbGQgY29udGV4dHMgdGhlCisJICogZXZlbnRzIGVuZHMgdXAgaW4uCisJICovCisJY3R4ID0gcmN1X2RlcmVmZXJlbmNlKGN1cnJlbnQtPnBlcmZfY291bnRlcl9jdHhwKTsKKwlpZiAoY3R4KQorCQlwZXJmX2NvdW50ZXJfZm9ya19jdHgoY3R4LCBmb3JrX2V2ZW50KTsKKwlyY3VfcmVhZF91bmxvY2soKTsKK30KKwordm9pZCBwZXJmX2NvdW50ZXJfZm9yayhzdHJ1Y3QgdGFza19zdHJ1Y3QgKnRhc2spCit7CisJc3RydWN0IHBlcmZfZm9ya19ldmVudCBmb3JrX2V2ZW50OworCisJaWYgKCFhdG9taWNfcmVhZCgmbnJfY29tbV9jb3VudGVycykgJiYKKwkgICAgIWF0b21pY19yZWFkKCZucl9tbWFwX2NvdW50ZXJzKSkKKwkJcmV0dXJuOworCisJZm9ya19ldmVudCA9IChzdHJ1Y3QgcGVyZl9mb3JrX2V2ZW50KXsKKwkJLnRhc2sJPSB0YXNrLAorCQkuZXZlbnQgID0geworCQkJLmhlYWRlciA9IHsKKwkJCQkudHlwZSA9IFBFUkZfRVZFTlRfRk9SSywKKwkJCQkuc2l6ZSA9IHNpemVvZihmb3JrX2V2ZW50LmV2ZW50KSwKKwkJCX0sCisJCX0sCisJfTsKKworCXBlcmZfY291bnRlcl9mb3JrX2V2ZW50KCZmb3JrX2V2ZW50KTsKK30KKworLyoKKyAqIGNvbW0gdHJhY2tpbmcKKyAqLworCitzdHJ1Y3QgcGVyZl9jb21tX2V2ZW50IHsKKwlzdHJ1Y3QgdGFza19zdHJ1Y3QJKnRhc2s7CisJY2hhcgkJCSpjb21tOworCWludAkJCWNvbW1fc2l6ZTsKKworCXN0cnVjdCB7CisJCXN0cnVjdCBwZXJmX2V2ZW50X2hlYWRlcgloZWFkZXI7CisKKwkJdTMyCQkJCXBpZDsKKwkJdTMyCQkJCXRpZDsKKwl9IGV2ZW50OworfTsKKworc3RhdGljIHZvaWQgcGVyZl9jb3VudGVyX2NvbW1fb3V0cHV0KHN0cnVjdCBwZXJmX2NvdW50ZXIgKmNvdW50ZXIsCisJCQkJICAgICBzdHJ1Y3QgcGVyZl9jb21tX2V2ZW50ICpjb21tX2V2ZW50KQoreworCXN0cnVjdCBwZXJmX291dHB1dF9oYW5kbGUgaGFuZGxlOworCWludCBzaXplID0gY29tbV9ldmVudC0+ZXZlbnQuaGVhZGVyLnNpemU7CisJaW50IHJldCA9IHBlcmZfb3V0cHV0X2JlZ2luKCZoYW5kbGUsIGNvdW50ZXIsIHNpemUsIDAsIDApOworCisJaWYgKHJldCkKKwkJcmV0dXJuOworCisJY29tbV9ldmVudC0+ZXZlbnQucGlkID0gcGVyZl9jb3VudGVyX3BpZChjb3VudGVyLCBjb21tX2V2ZW50LT50YXNrKTsKKwljb21tX2V2ZW50LT5ldmVudC50aWQgPSBwZXJmX2NvdW50ZXJfdGlkKGNvdW50ZXIsIGNvbW1fZXZlbnQtPnRhc2spOworCisJcGVyZl9vdXRwdXRfcHV0KCZoYW5kbGUsIGNvbW1fZXZlbnQtPmV2ZW50KTsKKwlwZXJmX291dHB1dF9jb3B5KCZoYW5kbGUsIGNvbW1fZXZlbnQtPmNvbW0sCisJCQkJICAgY29tbV9ldmVudC0+Y29tbV9zaXplKTsKKwlwZXJmX291dHB1dF9lbmQoJmhhbmRsZSk7Cit9CisKK3N0YXRpYyBpbnQgcGVyZl9jb3VudGVyX2NvbW1fbWF0Y2goc3RydWN0IHBlcmZfY291bnRlciAqY291bnRlcikKK3sKKwlpZiAoY291bnRlci0+YXR0ci5jb21tKQorCQlyZXR1cm4gMTsKKworCXJldHVybiAwOworfQorCitzdGF0aWMgdm9pZCBwZXJmX2NvdW50ZXJfY29tbV9jdHgoc3RydWN0IHBlcmZfY291bnRlcl9jb250ZXh0ICpjdHgsCisJCQkJICBzdHJ1Y3QgcGVyZl9jb21tX2V2ZW50ICpjb21tX2V2ZW50KQoreworCXN0cnVjdCBwZXJmX2NvdW50ZXIgKmNvdW50ZXI7CisKKwlpZiAoc3lzdGVtX3N0YXRlICE9IFNZU1RFTV9SVU5OSU5HIHx8IGxpc3RfZW1wdHkoJmN0eC0+ZXZlbnRfbGlzdCkpCisJCXJldHVybjsKKworCXJjdV9yZWFkX2xvY2soKTsKKwlsaXN0X2Zvcl9lYWNoX2VudHJ5X3JjdShjb3VudGVyLCAmY3R4LT5ldmVudF9saXN0LCBldmVudF9lbnRyeSkgeworCQlpZiAocGVyZl9jb3VudGVyX2NvbW1fbWF0Y2goY291bnRlcikpCisJCQlwZXJmX2NvdW50ZXJfY29tbV9vdXRwdXQoY291bnRlciwgY29tbV9ldmVudCk7CisJfQorCXJjdV9yZWFkX3VubG9jaygpOworfQorCitzdGF0aWMgdm9pZCBwZXJmX2NvdW50ZXJfY29tbV9ldmVudChzdHJ1Y3QgcGVyZl9jb21tX2V2ZW50ICpjb21tX2V2ZW50KQoreworCXN0cnVjdCBwZXJmX2NwdV9jb250ZXh0ICpjcHVjdHg7CisJc3RydWN0IHBlcmZfY291bnRlcl9jb250ZXh0ICpjdHg7CisJdW5zaWduZWQgaW50IHNpemU7CisJY2hhciAqY29tbSA9IGNvbW1fZXZlbnQtPnRhc2stPmNvbW07CisKKwlzaXplID0gQUxJR04oc3RybGVuKGNvbW0pKzEsIHNpemVvZih1NjQpKTsKKworCWNvbW1fZXZlbnQtPmNvbW0gPSBjb21tOworCWNvbW1fZXZlbnQtPmNvbW1fc2l6ZSA9IHNpemU7CisKKwljb21tX2V2ZW50LT5ldmVudC5oZWFkZXIuc2l6ZSA9IHNpemVvZihjb21tX2V2ZW50LT5ldmVudCkgKyBzaXplOworCisJY3B1Y3R4ID0gJmdldF9jcHVfdmFyKHBlcmZfY3B1X2NvbnRleHQpOworCXBlcmZfY291bnRlcl9jb21tX2N0eCgmY3B1Y3R4LT5jdHgsIGNvbW1fZXZlbnQpOworCXB1dF9jcHVfdmFyKHBlcmZfY3B1X2NvbnRleHQpOworCisJcmN1X3JlYWRfbG9jaygpOworCS8qCisJICogZG9lc24ndCByZWFsbHkgbWF0dGVyIHdoaWNoIG9mIHRoZSBjaGlsZCBjb250ZXh0cyB0aGUKKwkgKiBldmVudHMgZW5kcyB1cCBpbi4KKwkgKi8KKwljdHggPSByY3VfZGVyZWZlcmVuY2UoY3VycmVudC0+cGVyZl9jb3VudGVyX2N0eHApOworCWlmIChjdHgpCisJCXBlcmZfY291bnRlcl9jb21tX2N0eChjdHgsIGNvbW1fZXZlbnQpOworCXJjdV9yZWFkX3VubG9jaygpOworfQorCit2b2lkIHBlcmZfY291bnRlcl9jb21tKHN0cnVjdCB0YXNrX3N0cnVjdCAqdGFzaykKK3sKKwlzdHJ1Y3QgcGVyZl9jb21tX2V2ZW50IGNvbW1fZXZlbnQ7CisKKwlpZiAoIWF0b21pY19yZWFkKCZucl9jb21tX2NvdW50ZXJzKSkKKwkJcmV0dXJuOworCisJY29tbV9ldmVudCA9IChzdHJ1Y3QgcGVyZl9jb21tX2V2ZW50KXsKKwkJLnRhc2sJPSB0YXNrLAorCQkuZXZlbnQgID0geworCQkJLmhlYWRlciA9IHsgLnR5cGUgPSBQRVJGX0VWRU5UX0NPTU0sIH0sCisJCX0sCisJfTsKKworCXBlcmZfY291bnRlcl9jb21tX2V2ZW50KCZjb21tX2V2ZW50KTsKK30KKworLyoKKyAqIG1tYXAgdHJhY2tpbmcKKyAqLworCitzdHJ1Y3QgcGVyZl9tbWFwX2V2ZW50IHsKKwlzdHJ1Y3Qgdm1fYXJlYV9zdHJ1Y3QJKnZtYTsKKworCWNvbnN0IGNoYXIJCSpmaWxlX25hbWU7CisJaW50CQkJZmlsZV9zaXplOworCisJc3RydWN0IHsKKwkJc3RydWN0IHBlcmZfZXZlbnRfaGVhZGVyCWhlYWRlcjsKKworCQl1MzIJCQkJcGlkOworCQl1MzIJCQkJdGlkOworCQl1NjQJCQkJc3RhcnQ7CisJCXU2NAkJCQlsZW47CisJCXU2NAkJCQlwZ29mZjsKKwl9IGV2ZW50OworfTsKKworc3RhdGljIHZvaWQgcGVyZl9jb3VudGVyX21tYXBfb3V0cHV0KHN0cnVjdCBwZXJmX2NvdW50ZXIgKmNvdW50ZXIsCisJCQkJICAgICBzdHJ1Y3QgcGVyZl9tbWFwX2V2ZW50ICptbWFwX2V2ZW50KQoreworCXN0cnVjdCBwZXJmX291dHB1dF9oYW5kbGUgaGFuZGxlOworCWludCBzaXplID0gbW1hcF9ldmVudC0+ZXZlbnQuaGVhZGVyLnNpemU7CisJaW50IHJldCA9IHBlcmZfb3V0cHV0X2JlZ2luKCZoYW5kbGUsIGNvdW50ZXIsIHNpemUsIDAsIDApOworCisJaWYgKHJldCkKKwkJcmV0dXJuOworCisJbW1hcF9ldmVudC0+ZXZlbnQucGlkID0gcGVyZl9jb3VudGVyX3BpZChjb3VudGVyLCBjdXJyZW50KTsKKwltbWFwX2V2ZW50LT5ldmVudC50aWQgPSBwZXJmX2NvdW50ZXJfdGlkKGNvdW50ZXIsIGN1cnJlbnQpOworCisJcGVyZl9vdXRwdXRfcHV0KCZoYW5kbGUsIG1tYXBfZXZlbnQtPmV2ZW50KTsKKwlwZXJmX291dHB1dF9jb3B5KCZoYW5kbGUsIG1tYXBfZXZlbnQtPmZpbGVfbmFtZSwKKwkJCQkgICBtbWFwX2V2ZW50LT5maWxlX3NpemUpOworCXBlcmZfb3V0cHV0X2VuZCgmaGFuZGxlKTsKK30KKworc3RhdGljIGludCBwZXJmX2NvdW50ZXJfbW1hcF9tYXRjaChzdHJ1Y3QgcGVyZl9jb3VudGVyICpjb3VudGVyLAorCQkJCSAgIHN0cnVjdCBwZXJmX21tYXBfZXZlbnQgKm1tYXBfZXZlbnQpCit7CisJaWYgKGNvdW50ZXItPmF0dHIubW1hcCkKKwkJcmV0dXJuIDE7CisKKwlyZXR1cm4gMDsKK30KKworc3RhdGljIHZvaWQgcGVyZl9jb3VudGVyX21tYXBfY3R4KHN0cnVjdCBwZXJmX2NvdW50ZXJfY29udGV4dCAqY3R4LAorCQkJCSAgc3RydWN0IHBlcmZfbW1hcF9ldmVudCAqbW1hcF9ldmVudCkKK3sKKwlzdHJ1Y3QgcGVyZl9jb3VudGVyICpjb3VudGVyOworCisJaWYgKHN5c3RlbV9zdGF0ZSAhPSBTWVNURU1fUlVOTklORyB8fCBsaXN0X2VtcHR5KCZjdHgtPmV2ZW50X2xpc3QpKQorCQlyZXR1cm47CisKKwlyY3VfcmVhZF9sb2NrKCk7CisJbGlzdF9mb3JfZWFjaF9lbnRyeV9yY3UoY291bnRlciwgJmN0eC0+ZXZlbnRfbGlzdCwgZXZlbnRfZW50cnkpIHsKKwkJaWYgKHBlcmZfY291bnRlcl9tbWFwX21hdGNoKGNvdW50ZXIsIG1tYXBfZXZlbnQpKQorCQkJcGVyZl9jb3VudGVyX21tYXBfb3V0cHV0KGNvdW50ZXIsIG1tYXBfZXZlbnQpOworCX0KKwlyY3VfcmVhZF91bmxvY2soKTsKK30KKworc3RhdGljIHZvaWQgcGVyZl9jb3VudGVyX21tYXBfZXZlbnQoc3RydWN0IHBlcmZfbW1hcF9ldmVudCAqbW1hcF9ldmVudCkKK3sKKwlzdHJ1Y3QgcGVyZl9jcHVfY29udGV4dCAqY3B1Y3R4OworCXN0cnVjdCBwZXJmX2NvdW50ZXJfY29udGV4dCAqY3R4OworCXN0cnVjdCB2bV9hcmVhX3N0cnVjdCAqdm1hID0gbW1hcF9ldmVudC0+dm1hOworCXN0cnVjdCBmaWxlICpmaWxlID0gdm1hLT52bV9maWxlOworCXVuc2lnbmVkIGludCBzaXplOworCWNoYXIgdG1wWzE2XTsKKwljaGFyICpidWYgPSBOVUxMOworCWNvbnN0IGNoYXIgKm5hbWU7CisKKwlpZiAoZmlsZSkgeworCQlidWYgPSBremFsbG9jKFBBVEhfTUFYLCBHRlBfS0VSTkVMKTsKKwkJaWYgKCFidWYpIHsKKwkJCW5hbWUgPSBzdHJuY3B5KHRtcCwgIi8vZW5vbWVtIiwgc2l6ZW9mKHRtcCkpOworCQkJZ290byBnb3RfbmFtZTsKKwkJfQorCQluYW1lID0gZF9wYXRoKCZmaWxlLT5mX3BhdGgsIGJ1ZiwgUEFUSF9NQVgpOworCQlpZiAoSVNfRVJSKG5hbWUpKSB7CisJCQluYW1lID0gc3RybmNweSh0bXAsICIvL3Rvb2xvbmciLCBzaXplb2YodG1wKSk7CisJCQlnb3RvIGdvdF9uYW1lOworCQl9CisJfSBlbHNlIHsKKwkJbmFtZSA9IGFyY2hfdm1hX25hbWUobW1hcF9ldmVudC0+dm1hKTsKKwkJaWYgKG5hbWUpCisJCQlnb3RvIGdvdF9uYW1lOworCisJCWlmICghdm1hLT52bV9tbSkgeworCQkJbmFtZSA9IHN0cm5jcHkodG1wLCAiW3Zkc29dIiwgc2l6ZW9mKHRtcCkpOworCQkJZ290byBnb3RfbmFtZTsKKwkJfQorCisJCW5hbWUgPSBzdHJuY3B5KHRtcCwgIi8vYW5vbiIsIHNpemVvZih0bXApKTsKKwkJZ290byBnb3RfbmFtZTsKKwl9CisKK2dvdF9uYW1lOgorCXNpemUgPSBBTElHTihzdHJsZW4obmFtZSkrMSwgc2l6ZW9mKHU2NCkpOworCisJbW1hcF9ldmVudC0+ZmlsZV9uYW1lID0gbmFtZTsKKwltbWFwX2V2ZW50LT5maWxlX3NpemUgPSBzaXplOworCisJbW1hcF9ldmVudC0+ZXZlbnQuaGVhZGVyLnNpemUgPSBzaXplb2YobW1hcF9ldmVudC0+ZXZlbnQpICsgc2l6ZTsKKworCWNwdWN0eCA9ICZnZXRfY3B1X3ZhcihwZXJmX2NwdV9jb250ZXh0KTsKKwlwZXJmX2NvdW50ZXJfbW1hcF9jdHgoJmNwdWN0eC0+Y3R4LCBtbWFwX2V2ZW50KTsKKwlwdXRfY3B1X3ZhcihwZXJmX2NwdV9jb250ZXh0KTsKKworCXJjdV9yZWFkX2xvY2soKTsKKwkvKgorCSAqIGRvZXNuJ3QgcmVhbGx5IG1hdHRlciB3aGljaCBvZiB0aGUgY2hpbGQgY29udGV4dHMgdGhlCisJICogZXZlbnRzIGVuZHMgdXAgaW4uCisJICovCisJY3R4ID0gcmN1X2RlcmVmZXJlbmNlKGN1cnJlbnQtPnBlcmZfY291bnRlcl9jdHhwKTsKKwlpZiAoY3R4KQorCQlwZXJmX2NvdW50ZXJfbW1hcF9jdHgoY3R4LCBtbWFwX2V2ZW50KTsKKwlyY3VfcmVhZF91bmxvY2soKTsKKworCWtmcmVlKGJ1Zik7Cit9CisKK3ZvaWQgX19wZXJmX2NvdW50ZXJfbW1hcChzdHJ1Y3Qgdm1fYXJlYV9zdHJ1Y3QgKnZtYSkKK3sKKwlzdHJ1Y3QgcGVyZl9tbWFwX2V2ZW50IG1tYXBfZXZlbnQ7CisKKwlpZiAoIWF0b21pY19yZWFkKCZucl9tbWFwX2NvdW50ZXJzKSkKKwkJcmV0dXJuOworCisJbW1hcF9ldmVudCA9IChzdHJ1Y3QgcGVyZl9tbWFwX2V2ZW50KXsKKwkJLnZtYQk9IHZtYSwKKwkJLmV2ZW50ICA9IHsKKwkJCS5oZWFkZXIgPSB7IC50eXBlID0gUEVSRl9FVkVOVF9NTUFQLCB9LAorCQkJLnN0YXJ0ICA9IHZtYS0+dm1fc3RhcnQsCisJCQkubGVuICAgID0gdm1hLT52bV9lbmQgLSB2bWEtPnZtX3N0YXJ0LAorCQkJLnBnb2ZmICA9IHZtYS0+dm1fcGdvZmYsCisJCX0sCisJfTsKKworCXBlcmZfY291bnRlcl9tbWFwX2V2ZW50KCZtbWFwX2V2ZW50KTsKK30KKworLyoKKyAqIExvZyBzYW1wbGVfcGVyaW9kIGNoYW5nZXMgc28gdGhhdCBhbmFseXppbmcgdG9vbHMgY2FuIHJlLW5vcm1hbGl6ZSB0aGUKKyAqIGV2ZW50IGZsb3cuCisgKi8KKworc3RydWN0IGZyZXFfZXZlbnQgeworCXN0cnVjdCBwZXJmX2V2ZW50X2hlYWRlcgloZWFkZXI7CisJdTY0CQkJCXRpbWU7CisJdTY0CQkJCWlkOworCXU2NAkJCQlwZXJpb2Q7Cit9OworCitzdGF0aWMgdm9pZCBwZXJmX2xvZ19wZXJpb2Qoc3RydWN0IHBlcmZfY291bnRlciAqY291bnRlciwgdTY0IHBlcmlvZCkKK3sKKwlzdHJ1Y3QgcGVyZl9vdXRwdXRfaGFuZGxlIGhhbmRsZTsKKwlzdHJ1Y3QgZnJlcV9ldmVudCBldmVudDsKKwlpbnQgcmV0OworCisJaWYgKGNvdW50ZXItPmh3LnNhbXBsZV9wZXJpb2QgPT0gcGVyaW9kKQorCQlyZXR1cm47CisKKwlpZiAoY291bnRlci0+YXR0ci5zYW1wbGVfdHlwZSAmIFBFUkZfU0FNUExFX1BFUklPRCkKKwkJcmV0dXJuOworCisJZXZlbnQgPSAoc3RydWN0IGZyZXFfZXZlbnQpIHsKKwkJLmhlYWRlciA9IHsKKwkJCS50eXBlID0gUEVSRl9FVkVOVF9QRVJJT0QsCisJCQkubWlzYyA9IDAsCisJCQkuc2l6ZSA9IHNpemVvZihldmVudCksCisJCX0sCisJCS50aW1lID0gc2NoZWRfY2xvY2soKSwKKwkJLmlkID0gY291bnRlci0+aWQsCisJCS5wZXJpb2QgPSBwZXJpb2QsCisJfTsKKworCXJldCA9IHBlcmZfb3V0cHV0X2JlZ2luKCZoYW5kbGUsIGNvdW50ZXIsIHNpemVvZihldmVudCksIDEsIDApOworCWlmIChyZXQpCisJCXJldHVybjsKKworCXBlcmZfb3V0cHV0X3B1dCgmaGFuZGxlLCBldmVudCk7CisJcGVyZl9vdXRwdXRfZW5kKCZoYW5kbGUpOworfQorCisvKgorICogSVJRIHRocm90dGxlIGxvZ2dpbmcKKyAqLworCitzdGF0aWMgdm9pZCBwZXJmX2xvZ190aHJvdHRsZShzdHJ1Y3QgcGVyZl9jb3VudGVyICpjb3VudGVyLCBpbnQgZW5hYmxlKQoreworCXN0cnVjdCBwZXJmX291dHB1dF9oYW5kbGUgaGFuZGxlOworCWludCByZXQ7CisKKwlzdHJ1Y3QgeworCQlzdHJ1Y3QgcGVyZl9ldmVudF9oZWFkZXIJaGVhZGVyOworCQl1NjQJCQkJdGltZTsKKwkJdTY0CQkJCWlkOworCX0gdGhyb3R0bGVfZXZlbnQgPSB7CisJCS5oZWFkZXIgPSB7CisJCQkudHlwZSA9IFBFUkZfRVZFTlRfVEhST1RUTEUgKyAxLAorCQkJLm1pc2MgPSAwLAorCQkJLnNpemUgPSBzaXplb2YodGhyb3R0bGVfZXZlbnQpLAorCQl9LAorCQkudGltZQk9IHNjaGVkX2Nsb2NrKCksCisJCS5pZAk9IGNvdW50ZXItPmlkLAorCX07CisKKwlyZXQgPSBwZXJmX291dHB1dF9iZWdpbigmaGFuZGxlLCBjb3VudGVyLCBzaXplb2YodGhyb3R0bGVfZXZlbnQpLCAxLCAwKTsKKwlpZiAocmV0KQorCQlyZXR1cm47CisKKwlwZXJmX291dHB1dF9wdXQoJmhhbmRsZSwgdGhyb3R0bGVfZXZlbnQpOworCXBlcmZfb3V0cHV0X2VuZCgmaGFuZGxlKTsKK30KKworLyoKKyAqIEdlbmVyaWMgY291bnRlciBvdmVyZmxvdyBoYW5kbGluZy4KKyAqLworCitpbnQgcGVyZl9jb3VudGVyX292ZXJmbG93KHN0cnVjdCBwZXJmX2NvdW50ZXIgKmNvdW50ZXIsIGludCBubWksCisJCQkgIHN0cnVjdCBwZXJmX3NhbXBsZV9kYXRhICpkYXRhKQoreworCWludCBldmVudHMgPSBhdG9taWNfcmVhZCgmY291bnRlci0+ZXZlbnRfbGltaXQpOworCWludCB0aHJvdHRsZSA9IGNvdW50ZXItPnBtdS0+dW50aHJvdHRsZSAhPSBOVUxMOworCXN0cnVjdCBod19wZXJmX2NvdW50ZXIgKmh3YyA9ICZjb3VudGVyLT5odzsKKwlpbnQgcmV0ID0gMDsKKworCWlmICghdGhyb3R0bGUpIHsKKwkJaHdjLT5pbnRlcnJ1cHRzKys7CisJfSBlbHNlIHsKKwkJaWYgKGh3Yy0+aW50ZXJydXB0cyAhPSBNQVhfSU5URVJSVVBUUykgeworCQkJaHdjLT5pbnRlcnJ1cHRzKys7CisJCQlpZiAoSFogKiBod2MtPmludGVycnVwdHMgPgorCQkJCQkodTY0KXN5c2N0bF9wZXJmX2NvdW50ZXJfc2FtcGxlX3JhdGUpIHsKKwkJCQlod2MtPmludGVycnVwdHMgPSBNQVhfSU5URVJSVVBUUzsKKwkJCQlwZXJmX2xvZ190aHJvdHRsZShjb3VudGVyLCAwKTsKKwkJCQlyZXQgPSAxOworCQkJfQorCQl9IGVsc2UgeworCQkJLyoKKwkJCSAqIEtlZXAgcmUtZGlzYWJsaW5nIGNvdW50ZXJzIGV2ZW4gdGhvdWdoIG9uIHRoZSBwcmV2aW91cworCQkJICogcGFzcyB3ZSBkaXNhYmxlZCBpdCAtIGp1c3QgaW4gY2FzZSB3ZSByYWNlZCB3aXRoIGEKKwkJCSAqIHNjaGVkLWluIGFuZCB0aGUgY291bnRlciBnb3QgZW5hYmxlZCBhZ2FpbjoKKwkJCSAqLworCQkJcmV0ID0gMTsKKwkJfQorCX0KKworCWlmIChjb3VudGVyLT5hdHRyLmZyZXEpIHsKKwkJdTY0IG5vdyA9IHNjaGVkX2Nsb2NrKCk7CisJCXM2NCBkZWx0YSA9IG5vdyAtIGh3Yy0+ZnJlcV9zdGFtcDsKKworCQlod2MtPmZyZXFfc3RhbXAgPSBub3c7CisKKwkJaWYgKGRlbHRhID4gMCAmJiBkZWx0YSA8IFRJQ0tfTlNFQykKKwkJCXBlcmZfYWRqdXN0X3BlcmlvZChjb3VudGVyLCBOU0VDX1BFUl9TRUMgLyAoaW50KWRlbHRhKTsKKwl9CisKKwkvKgorCSAqIFhYWCBldmVudF9saW1pdCBtaWdodCBub3QgcXVpdGUgd29yayBhcyBleHBlY3RlZCBvbiBpbmhlcml0ZWQKKwkgKiBjb3VudGVycworCSAqLworCisJY291bnRlci0+cGVuZGluZ19raWxsID0gUE9MTF9JTjsKKwlpZiAoZXZlbnRzICYmIGF0b21pY19kZWNfYW5kX3Rlc3QoJmNvdW50ZXItPmV2ZW50X2xpbWl0KSkgeworCQlyZXQgPSAxOworCQljb3VudGVyLT5wZW5kaW5nX2tpbGwgPSBQT0xMX0hVUDsKKwkJaWYgKG5taSkgeworCQkJY291bnRlci0+cGVuZGluZ19kaXNhYmxlID0gMTsKKwkJCXBlcmZfcGVuZGluZ19xdWV1ZSgmY291bnRlci0+cGVuZGluZywKKwkJCQkJICAgcGVyZl9wZW5kaW5nX2NvdW50ZXIpOworCQl9IGVsc2UKKwkJCXBlcmZfY291bnRlcl9kaXNhYmxlKGNvdW50ZXIpOworCX0KKworCXBlcmZfY291bnRlcl9vdXRwdXQoY291bnRlciwgbm1pLCBkYXRhKTsKKwlyZXR1cm4gcmV0OworfQorCisvKgorICogR2VuZXJpYyBzb2Z0d2FyZSBjb3VudGVyIGluZnJhc3RydWN0dXJlCisgKi8KKworc3RhdGljIHZvaWQgcGVyZl9zd2NvdW50ZXJfdXBkYXRlKHN0cnVjdCBwZXJmX2NvdW50ZXIgKmNvdW50ZXIpCit7CisJc3RydWN0IGh3X3BlcmZfY291bnRlciAqaHdjID0gJmNvdW50ZXItPmh3OworCXU2NCBwcmV2LCBub3c7CisJczY0IGRlbHRhOworCithZ2FpbjoKKwlwcmV2ID0gYXRvbWljNjRfcmVhZCgmaHdjLT5wcmV2X2NvdW50KTsKKwlub3cgPSBhdG9taWM2NF9yZWFkKCZod2MtPmNvdW50KTsKKwlpZiAoYXRvbWljNjRfY21weGNoZygmaHdjLT5wcmV2X2NvdW50LCBwcmV2LCBub3cpICE9IHByZXYpCisJCWdvdG8gYWdhaW47CisKKwlkZWx0YSA9IG5vdyAtIHByZXY7CisKKwlhdG9taWM2NF9hZGQoZGVsdGEsICZjb3VudGVyLT5jb3VudCk7CisJYXRvbWljNjRfc3ViKGRlbHRhLCAmaHdjLT5wZXJpb2RfbGVmdCk7Cit9CisKK3N0YXRpYyB2b2lkIHBlcmZfc3djb3VudGVyX3NldF9wZXJpb2Qoc3RydWN0IHBlcmZfY291bnRlciAqY291bnRlcikKK3sKKwlzdHJ1Y3QgaHdfcGVyZl9jb3VudGVyICpod2MgPSAmY291bnRlci0+aHc7CisJczY0IGxlZnQgPSBhdG9taWM2NF9yZWFkKCZod2MtPnBlcmlvZF9sZWZ0KTsKKwlzNjQgcGVyaW9kID0gaHdjLT5zYW1wbGVfcGVyaW9kOworCisJaWYgKHVubGlrZWx5KGxlZnQgPD0gLXBlcmlvZCkpIHsKKwkJbGVmdCA9IHBlcmlvZDsKKwkJYXRvbWljNjRfc2V0KCZod2MtPnBlcmlvZF9sZWZ0LCBsZWZ0KTsKKwkJaHdjLT5sYXN0X3BlcmlvZCA9IHBlcmlvZDsKKwl9CisKKwlpZiAodW5saWtlbHkobGVmdCA8PSAwKSkgeworCQlsZWZ0ICs9IHBlcmlvZDsKKwkJYXRvbWljNjRfYWRkKHBlcmlvZCwgJmh3Yy0+cGVyaW9kX2xlZnQpOworCQlod2MtPmxhc3RfcGVyaW9kID0gcGVyaW9kOworCX0KKworCWF0b21pYzY0X3NldCgmaHdjLT5wcmV2X2NvdW50LCAtbGVmdCk7CisJYXRvbWljNjRfc2V0KCZod2MtPmNvdW50LCAtbGVmdCk7Cit9CisKK3N0YXRpYyBlbnVtIGhydGltZXJfcmVzdGFydCBwZXJmX3N3Y291bnRlcl9ocnRpbWVyKHN0cnVjdCBocnRpbWVyICpocnRpbWVyKQoreworCWVudW0gaHJ0aW1lcl9yZXN0YXJ0IHJldCA9IEhSVElNRVJfUkVTVEFSVDsKKwlzdHJ1Y3QgcGVyZl9zYW1wbGVfZGF0YSBkYXRhOworCXN0cnVjdCBwZXJmX2NvdW50ZXIgKmNvdW50ZXI7CisJdTY0IHBlcmlvZDsKKworCWNvdW50ZXIJPSBjb250YWluZXJfb2YoaHJ0aW1lciwgc3RydWN0IHBlcmZfY291bnRlciwgaHcuaHJ0aW1lcik7CisJY291bnRlci0+cG11LT5yZWFkKGNvdW50ZXIpOworCisJZGF0YS5hZGRyID0gMDsKKwlkYXRhLnJlZ3MgPSBnZXRfaXJxX3JlZ3MoKTsKKwkvKgorCSAqIEluIGNhc2Ugd2UgZXhjbHVkZSBrZXJuZWwgSVBzIG9yIGFyZSBzb21laG93IG5vdCBpbiBpbnRlcnJ1cHQKKwkgKiBjb250ZXh0LCBwcm92aWRlIHRoZSBuZXh0IGJlc3QgdGhpbmcsIHRoZSB1c2VyIElQLgorCSAqLworCWlmICgoY291bnRlci0+YXR0ci5leGNsdWRlX2tlcm5lbCB8fCAhZGF0YS5yZWdzKSAmJgorCQkJIWNvdW50ZXItPmF0dHIuZXhjbHVkZV91c2VyKQorCQlkYXRhLnJlZ3MgPSB0YXNrX3B0X3JlZ3MoY3VycmVudCk7CisKKwlpZiAoZGF0YS5yZWdzKSB7CisJCWlmIChwZXJmX2NvdW50ZXJfb3ZlcmZsb3coY291bnRlciwgMCwgJmRhdGEpKQorCQkJcmV0ID0gSFJUSU1FUl9OT1JFU1RBUlQ7CisJfQorCisJcGVyaW9kID0gbWF4X3QodTY0LCAxMDAwMCwgY291bnRlci0+aHcuc2FtcGxlX3BlcmlvZCk7CisJaHJ0aW1lcl9mb3J3YXJkX25vdyhocnRpbWVyLCBuc190b19rdGltZShwZXJpb2QpKTsKKworCXJldHVybiByZXQ7Cit9CisKK3N0YXRpYyB2b2lkIHBlcmZfc3djb3VudGVyX292ZXJmbG93KHN0cnVjdCBwZXJmX2NvdW50ZXIgKmNvdW50ZXIsCisJCQkJICAgIGludCBubWksIHN0cnVjdCBwdF9yZWdzICpyZWdzLCB1NjQgYWRkcikKK3sKKwlzdHJ1Y3QgcGVyZl9zYW1wbGVfZGF0YSBkYXRhID0geworCQkucmVncwk9IHJlZ3MsCisJCS5hZGRyCT0gYWRkciwKKwkJLnBlcmlvZAk9IGNvdW50ZXItPmh3Lmxhc3RfcGVyaW9kLAorCX07CisKKwlwZXJmX3N3Y291bnRlcl91cGRhdGUoY291bnRlcik7CisJcGVyZl9zd2NvdW50ZXJfc2V0X3BlcmlvZChjb3VudGVyKTsKKwlpZiAocGVyZl9jb3VudGVyX292ZXJmbG93KGNvdW50ZXIsIG5taSwgJmRhdGEpKQorCQkvKiBzb2Z0LWRpc2FibGUgdGhlIGNvdW50ZXIgKi8KKwkJOworCit9CisKK3N0YXRpYyBpbnQgcGVyZl9zd2NvdW50ZXJfaXNfY291bnRpbmcoc3RydWN0IHBlcmZfY291bnRlciAqY291bnRlcikKK3sKKwlzdHJ1Y3QgcGVyZl9jb3VudGVyX2NvbnRleHQgKmN0eDsKKwl1bnNpZ25lZCBsb25nIGZsYWdzOworCWludCBjb3VudDsKKworCWlmIChjb3VudGVyLT5zdGF0ZSA9PSBQRVJGX0NPVU5URVJfU1RBVEVfQUNUSVZFKQorCQlyZXR1cm4gMTsKKworCWlmIChjb3VudGVyLT5zdGF0ZSAhPSBQRVJGX0NPVU5URVJfU1RBVEVfSU5BQ1RJVkUpCisJCXJldHVybiAwOworCisJLyoKKwkgKiBJZiB0aGUgY291bnRlciBpcyBpbmFjdGl2ZSwgaXQgY291bGQgYmUganVzdCBiZWNhdXNlCisJICogaXRzIHRhc2sgaXMgc2NoZWR1bGVkIG91dCwgb3IgYmVjYXVzZSBpdCdzIGluIGEgZ3JvdXAKKwkgKiB3aGljaCBjb3VsZCBub3QgZ28gb24gdGhlIFBNVS4gIFdlIHdhbnQgdG8gY291bnQgaW4KKwkgKiB0aGUgZmlyc3QgY2FzZSBidXQgbm90IHRoZSBzZWNvbmQuICBJZiB0aGUgY29udGV4dCBpcworCSAqIGN1cnJlbnRseSBhY3RpdmUgdGhlbiBhbiBpbmFjdGl2ZSBzb2Z0d2FyZSBjb3VudGVyIG11c3QKKwkgKiBiZSB0aGUgc2Vjb25kIGNhc2UuICBJZiBpdCdzIG5vdCBjdXJyZW50bHkgYWN0aXZlIHRoZW4KKwkgKiB3ZSBuZWVkIHRvIGtub3cgd2hldGhlciB0aGUgY291bnRlciB3YXMgYWN0aXZlIHdoZW4gdGhlCisJICogY29udGV4dCB3YXMgbGFzdCBhY3RpdmUsIHdoaWNoIHdlIGNhbiBkZXRlcm1pbmUgYnkKKwkgKiBjb21wYXJpbmcgY291bnRlci0+dHN0YW1wX3N0b3BwZWQgd2l0aCBjdHgtPnRpbWUuCisJICoKKwkgKiBXZSBhcmUgd2l0aGluIGFuIFJDVSByZWFkLXNpZGUgY3JpdGljYWwgc2VjdGlvbiwKKwkgKiB3aGljaCBwcm90ZWN0cyB0aGUgZXhpc3RlbmNlIG9mICpjdHguCisJICovCisJY3R4ID0gY291bnRlci0+Y3R4OworCXNwaW5fbG9ja19pcnFzYXZlKCZjdHgtPmxvY2ssIGZsYWdzKTsKKwljb3VudCA9IDE7CisJLyogUmUtY2hlY2sgc3RhdGUgbm93IHdlIGhhdmUgdGhlIGxvY2sgKi8KKwlpZiAoY291bnRlci0+c3RhdGUgPCBQRVJGX0NPVU5URVJfU1RBVEVfSU5BQ1RJVkUgfHwKKwkgICAgY291bnRlci0+Y3R4LT5pc19hY3RpdmUgfHwKKwkgICAgY291bnRlci0+dHN0YW1wX3N0b3BwZWQgPCBjdHgtPnRpbWUpCisJCWNvdW50ID0gMDsKKwlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZjdHgtPmxvY2ssIGZsYWdzKTsKKwlyZXR1cm4gY291bnQ7Cit9CisKK3N0YXRpYyBpbnQgcGVyZl9zd2NvdW50ZXJfbWF0Y2goc3RydWN0IHBlcmZfY291bnRlciAqY291bnRlciwKKwkJCQllbnVtIHBlcmZfdHlwZV9pZCB0eXBlLAorCQkJCXUzMiBldmVudCwgc3RydWN0IHB0X3JlZ3MgKnJlZ3MpCit7CisJaWYgKCFwZXJmX3N3Y291bnRlcl9pc19jb3VudGluZyhjb3VudGVyKSkKKwkJcmV0dXJuIDA7CisKKwlpZiAoY291bnRlci0+YXR0ci50eXBlICE9IHR5cGUpCisJCXJldHVybiAwOworCWlmIChjb3VudGVyLT5hdHRyLmNvbmZpZyAhPSBldmVudCkKKwkJcmV0dXJuIDA7CisKKwlpZiAocmVncykgeworCQlpZiAoY291bnRlci0+YXR0ci5leGNsdWRlX3VzZXIgJiYgdXNlcl9tb2RlKHJlZ3MpKQorCQkJcmV0dXJuIDA7CisKKwkJaWYgKGNvdW50ZXItPmF0dHIuZXhjbHVkZV9rZXJuZWwgJiYgIXVzZXJfbW9kZShyZWdzKSkKKwkJCXJldHVybiAwOworCX0KKworCXJldHVybiAxOworfQorCitzdGF0aWMgdm9pZCBwZXJmX3N3Y291bnRlcl9hZGQoc3RydWN0IHBlcmZfY291bnRlciAqY291bnRlciwgdTY0IG5yLAorCQkJICAgICAgIGludCBubWksIHN0cnVjdCBwdF9yZWdzICpyZWdzLCB1NjQgYWRkcikKK3sKKwlpbnQgbmVnID0gYXRvbWljNjRfYWRkX25lZ2F0aXZlKG5yLCAmY291bnRlci0+aHcuY291bnQpOworCisJaWYgKGNvdW50ZXItPmh3LnNhbXBsZV9wZXJpb2QgJiYgIW5lZyAmJiByZWdzKQorCQlwZXJmX3N3Y291bnRlcl9vdmVyZmxvdyhjb3VudGVyLCBubWksIHJlZ3MsIGFkZHIpOworfQorCitzdGF0aWMgdm9pZCBwZXJmX3N3Y291bnRlcl9jdHhfZXZlbnQoc3RydWN0IHBlcmZfY291bnRlcl9jb250ZXh0ICpjdHgsCisJCQkJICAgICBlbnVtIHBlcmZfdHlwZV9pZCB0eXBlLCB1MzIgZXZlbnQsCisJCQkJICAgICB1NjQgbnIsIGludCBubWksIHN0cnVjdCBwdF9yZWdzICpyZWdzLAorCQkJCSAgICAgdTY0IGFkZHIpCit7CisJc3RydWN0IHBlcmZfY291bnRlciAqY291bnRlcjsKKworCWlmIChzeXN0ZW1fc3RhdGUgIT0gU1lTVEVNX1JVTk5JTkcgfHwgbGlzdF9lbXB0eSgmY3R4LT5ldmVudF9saXN0KSkKKwkJcmV0dXJuOworCisJcmN1X3JlYWRfbG9jaygpOworCWxpc3RfZm9yX2VhY2hfZW50cnlfcmN1KGNvdW50ZXIsICZjdHgtPmV2ZW50X2xpc3QsIGV2ZW50X2VudHJ5KSB7CisJCWlmIChwZXJmX3N3Y291bnRlcl9tYXRjaChjb3VudGVyLCB0eXBlLCBldmVudCwgcmVncykpCisJCQlwZXJmX3N3Y291bnRlcl9hZGQoY291bnRlciwgbnIsIG5taSwgcmVncywgYWRkcik7CisJfQorCXJjdV9yZWFkX3VubG9jaygpOworfQorCitzdGF0aWMgaW50ICpwZXJmX3N3Y291bnRlcl9yZWN1cnNpb25fY29udGV4dChzdHJ1Y3QgcGVyZl9jcHVfY29udGV4dCAqY3B1Y3R4KQoreworCWlmIChpbl9ubWkoKSkKKwkJcmV0dXJuICZjcHVjdHgtPnJlY3Vyc2lvblszXTsKKworCWlmIChpbl9pcnEoKSkKKwkJcmV0dXJuICZjcHVjdHgtPnJlY3Vyc2lvblsyXTsKKworCWlmIChpbl9zb2Z0aXJxKCkpCisJCXJldHVybiAmY3B1Y3R4LT5yZWN1cnNpb25bMV07CisKKwlyZXR1cm4gJmNwdWN0eC0+cmVjdXJzaW9uWzBdOworfQorCitzdGF0aWMgdm9pZCBfX3BlcmZfc3djb3VudGVyX2V2ZW50KGVudW0gcGVyZl90eXBlX2lkIHR5cGUsIHUzMiBldmVudCwKKwkJCQkgICB1NjQgbnIsIGludCBubWksIHN0cnVjdCBwdF9yZWdzICpyZWdzLAorCQkJCSAgIHU2NCBhZGRyKQoreworCXN0cnVjdCBwZXJmX2NwdV9jb250ZXh0ICpjcHVjdHggPSAmZ2V0X2NwdV92YXIocGVyZl9jcHVfY29udGV4dCk7CisJaW50ICpyZWN1cnNpb24gPSBwZXJmX3N3Y291bnRlcl9yZWN1cnNpb25fY29udGV4dChjcHVjdHgpOworCXN0cnVjdCBwZXJmX2NvdW50ZXJfY29udGV4dCAqY3R4OworCisJaWYgKCpyZWN1cnNpb24pCisJCWdvdG8gb3V0OworCisJKCpyZWN1cnNpb24pKys7CisJYmFycmllcigpOworCisJcGVyZl9zd2NvdW50ZXJfY3R4X2V2ZW50KCZjcHVjdHgtPmN0eCwgdHlwZSwgZXZlbnQsCisJCQkJIG5yLCBubWksIHJlZ3MsIGFkZHIpOworCXJjdV9yZWFkX2xvY2soKTsKKwkvKgorCSAqIGRvZXNuJ3QgcmVhbGx5IG1hdHRlciB3aGljaCBvZiB0aGUgY2hpbGQgY29udGV4dHMgdGhlCisJICogZXZlbnRzIGVuZHMgdXAgaW4uCisJICovCisJY3R4ID0gcmN1X2RlcmVmZXJlbmNlKGN1cnJlbnQtPnBlcmZfY291bnRlcl9jdHhwKTsKKwlpZiAoY3R4KQorCQlwZXJmX3N3Y291bnRlcl9jdHhfZXZlbnQoY3R4LCB0eXBlLCBldmVudCwgbnIsIG5taSwgcmVncywgYWRkcik7CisJcmN1X3JlYWRfdW5sb2NrKCk7CisKKwliYXJyaWVyKCk7CisJKCpyZWN1cnNpb24pLS07CisKK291dDoKKwlwdXRfY3B1X3ZhcihwZXJmX2NwdV9jb250ZXh0KTsKK30KKwordm9pZAorcGVyZl9zd2NvdW50ZXJfZXZlbnQodTMyIGV2ZW50LCB1NjQgbnIsIGludCBubWksIHN0cnVjdCBwdF9yZWdzICpyZWdzLCB1NjQgYWRkcikKK3sKKwlfX3BlcmZfc3djb3VudGVyX2V2ZW50KFBFUkZfVFlQRV9TT0ZUV0FSRSwgZXZlbnQsIG5yLCBubWksIHJlZ3MsIGFkZHIpOworfQorCitzdGF0aWMgdm9pZCBwZXJmX3N3Y291bnRlcl9yZWFkKHN0cnVjdCBwZXJmX2NvdW50ZXIgKmNvdW50ZXIpCit7CisJcGVyZl9zd2NvdW50ZXJfdXBkYXRlKGNvdW50ZXIpOworfQorCitzdGF0aWMgaW50IHBlcmZfc3djb3VudGVyX2VuYWJsZShzdHJ1Y3QgcGVyZl9jb3VudGVyICpjb3VudGVyKQoreworCXBlcmZfc3djb3VudGVyX3NldF9wZXJpb2QoY291bnRlcik7CisJcmV0dXJuIDA7Cit9CisKK3N0YXRpYyB2b2lkIHBlcmZfc3djb3VudGVyX2Rpc2FibGUoc3RydWN0IHBlcmZfY291bnRlciAqY291bnRlcikKK3sKKwlwZXJmX3N3Y291bnRlcl91cGRhdGUoY291bnRlcik7Cit9CisKK3N0YXRpYyBjb25zdCBzdHJ1Y3QgcG11IHBlcmZfb3BzX2dlbmVyaWMgPSB7CisJLmVuYWJsZQkJPSBwZXJmX3N3Y291bnRlcl9lbmFibGUsCisJLmRpc2FibGUJPSBwZXJmX3N3Y291bnRlcl9kaXNhYmxlLAorCS5yZWFkCQk9IHBlcmZfc3djb3VudGVyX3JlYWQsCit9OworCisvKgorICogU29mdHdhcmUgY291bnRlcjogY3B1IHdhbGwgdGltZSBjbG9jaworICovCisKK3N0YXRpYyB2b2lkIGNwdV9jbG9ja19wZXJmX2NvdW50ZXJfdXBkYXRlKHN0cnVjdCBwZXJmX2NvdW50ZXIgKmNvdW50ZXIpCit7CisJaW50IGNwdSA9IHJhd19zbXBfcHJvY2Vzc29yX2lkKCk7CisJczY0IHByZXY7CisJdTY0IG5vdzsKKworCW5vdyA9IGNwdV9jbG9jayhjcHUpOworCXByZXYgPSBhdG9taWM2NF9yZWFkKCZjb3VudGVyLT5ody5wcmV2X2NvdW50KTsKKwlhdG9taWM2NF9zZXQoJmNvdW50ZXItPmh3LnByZXZfY291bnQsIG5vdyk7CisJYXRvbWljNjRfYWRkKG5vdyAtIHByZXYsICZjb3VudGVyLT5jb3VudCk7Cit9CisKK3N0YXRpYyBpbnQgY3B1X2Nsb2NrX3BlcmZfY291bnRlcl9lbmFibGUoc3RydWN0IHBlcmZfY291bnRlciAqY291bnRlcikKK3sKKwlzdHJ1Y3QgaHdfcGVyZl9jb3VudGVyICpod2MgPSAmY291bnRlci0+aHc7CisJaW50IGNwdSA9IHJhd19zbXBfcHJvY2Vzc29yX2lkKCk7CisKKwlhdG9taWM2NF9zZXQoJmh3Yy0+cHJldl9jb3VudCwgY3B1X2Nsb2NrKGNwdSkpOworCWhydGltZXJfaW5pdCgmaHdjLT5ocnRpbWVyLCBDTE9DS19NT05PVE9OSUMsIEhSVElNRVJfTU9ERV9SRUwpOworCWh3Yy0+aHJ0aW1lci5mdW5jdGlvbiA9IHBlcmZfc3djb3VudGVyX2hydGltZXI7CisJaWYgKGh3Yy0+c2FtcGxlX3BlcmlvZCkgeworCQl1NjQgcGVyaW9kID0gbWF4X3QodTY0LCAxMDAwMCwgaHdjLT5zYW1wbGVfcGVyaW9kKTsKKwkJX19ocnRpbWVyX3N0YXJ0X3JhbmdlX25zKCZod2MtPmhydGltZXIsCisJCQkJbnNfdG9fa3RpbWUocGVyaW9kKSwgMCwKKwkJCQlIUlRJTUVSX01PREVfUkVMLCAwKTsKKwl9CisKKwlyZXR1cm4gMDsKK30KKworc3RhdGljIHZvaWQgY3B1X2Nsb2NrX3BlcmZfY291bnRlcl9kaXNhYmxlKHN0cnVjdCBwZXJmX2NvdW50ZXIgKmNvdW50ZXIpCit7CisJaWYgKGNvdW50ZXItPmh3LnNhbXBsZV9wZXJpb2QpCisJCWhydGltZXJfY2FuY2VsKCZjb3VudGVyLT5ody5ocnRpbWVyKTsKKwljcHVfY2xvY2tfcGVyZl9jb3VudGVyX3VwZGF0ZShjb3VudGVyKTsKK30KKworc3RhdGljIHZvaWQgY3B1X2Nsb2NrX3BlcmZfY291bnRlcl9yZWFkKHN0cnVjdCBwZXJmX2NvdW50ZXIgKmNvdW50ZXIpCit7CisJY3B1X2Nsb2NrX3BlcmZfY291bnRlcl91cGRhdGUoY291bnRlcik7Cit9CisKK3N0YXRpYyBjb25zdCBzdHJ1Y3QgcG11IHBlcmZfb3BzX2NwdV9jbG9jayA9IHsKKwkuZW5hYmxlCQk9IGNwdV9jbG9ja19wZXJmX2NvdW50ZXJfZW5hYmxlLAorCS5kaXNhYmxlCT0gY3B1X2Nsb2NrX3BlcmZfY291bnRlcl9kaXNhYmxlLAorCS5yZWFkCQk9IGNwdV9jbG9ja19wZXJmX2NvdW50ZXJfcmVhZCwKK307CisKKy8qCisgKiBTb2Z0d2FyZSBjb3VudGVyOiB0YXNrIHRpbWUgY2xvY2sKKyAqLworCitzdGF0aWMgdm9pZCB0YXNrX2Nsb2NrX3BlcmZfY291bnRlcl91cGRhdGUoc3RydWN0IHBlcmZfY291bnRlciAqY291bnRlciwgdTY0IG5vdykKK3sKKwl1NjQgcHJldjsKKwlzNjQgZGVsdGE7CisKKwlwcmV2ID0gYXRvbWljNjRfeGNoZygmY291bnRlci0+aHcucHJldl9jb3VudCwgbm93KTsKKwlkZWx0YSA9IG5vdyAtIHByZXY7CisJYXRvbWljNjRfYWRkKGRlbHRhLCAmY291bnRlci0+Y291bnQpOworfQorCitzdGF0aWMgaW50IHRhc2tfY2xvY2tfcGVyZl9jb3VudGVyX2VuYWJsZShzdHJ1Y3QgcGVyZl9jb3VudGVyICpjb3VudGVyKQoreworCXN0cnVjdCBod19wZXJmX2NvdW50ZXIgKmh3YyA9ICZjb3VudGVyLT5odzsKKwl1NjQgbm93OworCisJbm93ID0gY291bnRlci0+Y3R4LT50aW1lOworCisJYXRvbWljNjRfc2V0KCZod2MtPnByZXZfY291bnQsIG5vdyk7CisJaHJ0aW1lcl9pbml0KCZod2MtPmhydGltZXIsIENMT0NLX01PTk9UT05JQywgSFJUSU1FUl9NT0RFX1JFTCk7CisJaHdjLT5ocnRpbWVyLmZ1bmN0aW9uID0gcGVyZl9zd2NvdW50ZXJfaHJ0aW1lcjsKKwlpZiAoaHdjLT5zYW1wbGVfcGVyaW9kKSB7CisJCXU2NCBwZXJpb2QgPSBtYXhfdCh1NjQsIDEwMDAwLCBod2MtPnNhbXBsZV9wZXJpb2QpOworCQlfX2hydGltZXJfc3RhcnRfcmFuZ2VfbnMoJmh3Yy0+aHJ0aW1lciwKKwkJCQluc190b19rdGltZShwZXJpb2QpLCAwLAorCQkJCUhSVElNRVJfTU9ERV9SRUwsIDApOworCX0KKworCXJldHVybiAwOworfQorCitzdGF0aWMgdm9pZCB0YXNrX2Nsb2NrX3BlcmZfY291bnRlcl9kaXNhYmxlKHN0cnVjdCBwZXJmX2NvdW50ZXIgKmNvdW50ZXIpCit7CisJaWYgKGNvdW50ZXItPmh3LnNhbXBsZV9wZXJpb2QpCisJCWhydGltZXJfY2FuY2VsKCZjb3VudGVyLT5ody5ocnRpbWVyKTsKKwl0YXNrX2Nsb2NrX3BlcmZfY291bnRlcl91cGRhdGUoY291bnRlciwgY291bnRlci0+Y3R4LT50aW1lKTsKKworfQorCitzdGF0aWMgdm9pZCB0YXNrX2Nsb2NrX3BlcmZfY291bnRlcl9yZWFkKHN0cnVjdCBwZXJmX2NvdW50ZXIgKmNvdW50ZXIpCit7CisJdTY0IHRpbWU7CisKKwlpZiAoIWluX25taSgpKSB7CisJCXVwZGF0ZV9jb250ZXh0X3RpbWUoY291bnRlci0+Y3R4KTsKKwkJdGltZSA9IGNvdW50ZXItPmN0eC0+dGltZTsKKwl9IGVsc2UgeworCQl1NjQgbm93ID0gcGVyZl9jbG9jaygpOworCQl1NjQgZGVsdGEgPSBub3cgLSBjb3VudGVyLT5jdHgtPnRpbWVzdGFtcDsKKwkJdGltZSA9IGNvdW50ZXItPmN0eC0+dGltZSArIGRlbHRhOworCX0KKworCXRhc2tfY2xvY2tfcGVyZl9jb3VudGVyX3VwZGF0ZShjb3VudGVyLCB0aW1lKTsKK30KKworc3RhdGljIGNvbnN0IHN0cnVjdCBwbXUgcGVyZl9vcHNfdGFza19jbG9jayA9IHsKKwkuZW5hYmxlCQk9IHRhc2tfY2xvY2tfcGVyZl9jb3VudGVyX2VuYWJsZSwKKwkuZGlzYWJsZQk9IHRhc2tfY2xvY2tfcGVyZl9jb3VudGVyX2Rpc2FibGUsCisJLnJlYWQJCT0gdGFza19jbG9ja19wZXJmX2NvdW50ZXJfcmVhZCwKK307CisKKy8qCisgKiBTb2Z0d2FyZSBjb3VudGVyOiBjcHUgbWlncmF0aW9ucworICovCit2b2lkIHBlcmZfY291bnRlcl90YXNrX21pZ3JhdGlvbihzdHJ1Y3QgdGFza19zdHJ1Y3QgKnRhc2ssIGludCBjcHUpCit7CisJc3RydWN0IHBlcmZfY3B1X2NvbnRleHQgKmNwdWN0eCA9ICZwZXJfY3B1KHBlcmZfY3B1X2NvbnRleHQsIGNwdSk7CisJc3RydWN0IHBlcmZfY291bnRlcl9jb250ZXh0ICpjdHg7CisKKwlwZXJmX3N3Y291bnRlcl9jdHhfZXZlbnQoJmNwdWN0eC0+Y3R4LCBQRVJGX1RZUEVfU09GVFdBUkUsCisJCQkJIFBFUkZfQ09VTlRfU1dfQ1BVX01JR1JBVElPTlMsCisJCQkJIDEsIDEsIE5VTEwsIDApOworCisJY3R4ID0gcGVyZl9waW5fdGFza19jb250ZXh0KHRhc2spOworCWlmIChjdHgpIHsKKwkJcGVyZl9zd2NvdW50ZXJfY3R4X2V2ZW50KGN0eCwgUEVSRl9UWVBFX1NPRlRXQVJFLAorCQkJCQkgUEVSRl9DT1VOVF9TV19DUFVfTUlHUkFUSU9OUywKKwkJCQkJIDEsIDEsIE5VTEwsIDApOworCQlwZXJmX3VucGluX2NvbnRleHQoY3R4KTsKKwl9Cit9CisKKyNpZmRlZiBDT05GSUdfRVZFTlRfUFJPRklMRQordm9pZCBwZXJmX3RwY291bnRlcl9ldmVudChpbnQgZXZlbnRfaWQpCit7CisJc3RydWN0IHB0X3JlZ3MgKnJlZ3MgPSBnZXRfaXJxX3JlZ3MoKTsKKworCWlmICghcmVncykKKwkJcmVncyA9IHRhc2tfcHRfcmVncyhjdXJyZW50KTsKKworCV9fcGVyZl9zd2NvdW50ZXJfZXZlbnQoUEVSRl9UWVBFX1RSQUNFUE9JTlQsIGV2ZW50X2lkLCAxLCAxLCByZWdzLCAwKTsKK30KK0VYUE9SVF9TWU1CT0xfR1BMKHBlcmZfdHBjb3VudGVyX2V2ZW50KTsKKworZXh0ZXJuIGludCBmdHJhY2VfcHJvZmlsZV9lbmFibGUoaW50KTsKK2V4dGVybiB2b2lkIGZ0cmFjZV9wcm9maWxlX2Rpc2FibGUoaW50KTsKKworc3RhdGljIHZvaWQgdHBfcGVyZl9jb3VudGVyX2Rlc3Ryb3koc3RydWN0IHBlcmZfY291bnRlciAqY291bnRlcikKK3sKKwlmdHJhY2VfcHJvZmlsZV9kaXNhYmxlKHBlcmZfZXZlbnRfaWQoJmNvdW50ZXItPmF0dHIpKTsKK30KKworc3RhdGljIGNvbnN0IHN0cnVjdCBwbXUgKnRwX3BlcmZfY291bnRlcl9pbml0KHN0cnVjdCBwZXJmX2NvdW50ZXIgKmNvdW50ZXIpCit7CisJaW50IGV2ZW50X2lkID0gcGVyZl9ldmVudF9pZCgmY291bnRlci0+YXR0cik7CisJaW50IHJldDsKKworCXJldCA9IGZ0cmFjZV9wcm9maWxlX2VuYWJsZShldmVudF9pZCk7CisJaWYgKHJldCkKKwkJcmV0dXJuIE5VTEw7CisKKwljb3VudGVyLT5kZXN0cm95ID0gdHBfcGVyZl9jb3VudGVyX2Rlc3Ryb3k7CisKKwlyZXR1cm4gJnBlcmZfb3BzX2dlbmVyaWM7Cit9CisjZWxzZQorc3RhdGljIGNvbnN0IHN0cnVjdCBwbXUgKnRwX3BlcmZfY291bnRlcl9pbml0KHN0cnVjdCBwZXJmX2NvdW50ZXIgKmNvdW50ZXIpCit7CisJcmV0dXJuIE5VTEw7Cit9CisjZW5kaWYKKworc3RhdGljIGNvbnN0IHN0cnVjdCBwbXUgKnN3X3BlcmZfY291bnRlcl9pbml0KHN0cnVjdCBwZXJmX2NvdW50ZXIgKmNvdW50ZXIpCit7CisJY29uc3Qgc3RydWN0IHBtdSAqcG11ID0gTlVMTDsKKworCS8qCisJICogU29mdHdhcmUgY291bnRlcnMgKGN1cnJlbnRseSkgY2FuJ3QgaW4gZ2VuZXJhbCBkaXN0aW5ndWlzaAorCSAqIGJldHdlZW4gdXNlciwga2VybmVsIGFuZCBoeXBlcnZpc29yIGV2ZW50cy4KKwkgKiBIb3dldmVyLCBjb250ZXh0IHN3aXRjaGVzIGFuZCBjcHUgbWlncmF0aW9ucyBhcmUgY29uc2lkZXJlZAorCSAqIHRvIGJlIGtlcm5lbCBldmVudHMsIGFuZCBwYWdlIGZhdWx0cyBhcmUgbmV2ZXIgaHlwZXJ2aXNvcgorCSAqIGV2ZW50cy4KKwkgKi8KKwlzd2l0Y2ggKGNvdW50ZXItPmF0dHIuY29uZmlnKSB7CisJY2FzZSBQRVJGX0NPVU5UX1NXX0NQVV9DTE9DSzoKKwkJcG11ID0gJnBlcmZfb3BzX2NwdV9jbG9jazsKKworCQlicmVhazsKKwljYXNlIFBFUkZfQ09VTlRfU1dfVEFTS19DTE9DSzoKKwkJLyoKKwkJICogSWYgdGhlIHVzZXIgaW5zdGFudGlhdGVzIHRoaXMgYXMgYSBwZXItY3B1IGNvdW50ZXIsCisJCSAqIHVzZSB0aGUgY3B1X2Nsb2NrIGNvdW50ZXIgaW5zdGVhZC4KKwkJICovCisJCWlmIChjb3VudGVyLT5jdHgtPnRhc2spCisJCQlwbXUgPSAmcGVyZl9vcHNfdGFza19jbG9jazsKKwkJZWxzZQorCQkJcG11ID0gJnBlcmZfb3BzX2NwdV9jbG9jazsKKworCQlicmVhazsKKwljYXNlIFBFUkZfQ09VTlRfU1dfUEFHRV9GQVVMVFM6CisJY2FzZSBQRVJGX0NPVU5UX1NXX1BBR0VfRkFVTFRTX01JTjoKKwljYXNlIFBFUkZfQ09VTlRfU1dfUEFHRV9GQVVMVFNfTUFKOgorCWNhc2UgUEVSRl9DT1VOVF9TV19DT05URVhUX1NXSVRDSEVTOgorCWNhc2UgUEVSRl9DT1VOVF9TV19DUFVfTUlHUkFUSU9OUzoKKwkJcG11ID0gJnBlcmZfb3BzX2dlbmVyaWM7CisJCWJyZWFrOworCX0KKworCXJldHVybiBwbXU7Cit9CisKKy8qCisgKiBBbGxvY2F0ZSBhbmQgaW5pdGlhbGl6ZSBhIGNvdW50ZXIgc3RydWN0dXJlCisgKi8KK3N0YXRpYyBzdHJ1Y3QgcGVyZl9jb3VudGVyICoKK3BlcmZfY291bnRlcl9hbGxvYyhzdHJ1Y3QgcGVyZl9jb3VudGVyX2F0dHIgKmF0dHIsCisJCSAgIGludCBjcHUsCisJCSAgIHN0cnVjdCBwZXJmX2NvdW50ZXJfY29udGV4dCAqY3R4LAorCQkgICBzdHJ1Y3QgcGVyZl9jb3VudGVyICpncm91cF9sZWFkZXIsCisJCSAgIGdmcF90IGdmcGZsYWdzKQoreworCWNvbnN0IHN0cnVjdCBwbXUgKnBtdTsKKwlzdHJ1Y3QgcGVyZl9jb3VudGVyICpjb3VudGVyOworCXN0cnVjdCBod19wZXJmX2NvdW50ZXIgKmh3YzsKKwlsb25nIGVycjsKKworCWNvdW50ZXIgPSBremFsbG9jKHNpemVvZigqY291bnRlciksIGdmcGZsYWdzKTsKKwlpZiAoIWNvdW50ZXIpCisJCXJldHVybiBFUlJfUFRSKC1FTk9NRU0pOworCisJLyoKKwkgKiBTaW5nbGUgY291bnRlcnMgYXJlIHRoZWlyIG93biBncm91cCBsZWFkZXJzLCB3aXRoIGFuCisJICogZW1wdHkgc2libGluZyBsaXN0OgorCSAqLworCWlmICghZ3JvdXBfbGVhZGVyKQorCQlncm91cF9sZWFkZXIgPSBjb3VudGVyOworCisJbXV0ZXhfaW5pdCgmY291bnRlci0+Y2hpbGRfbXV0ZXgpOworCUlOSVRfTElTVF9IRUFEKCZjb3VudGVyLT5jaGlsZF9saXN0KTsKKworCUlOSVRfTElTVF9IRUFEKCZjb3VudGVyLT5saXN0X2VudHJ5KTsKKwlJTklUX0xJU1RfSEVBRCgmY291bnRlci0+ZXZlbnRfZW50cnkpOworCUlOSVRfTElTVF9IRUFEKCZjb3VudGVyLT5zaWJsaW5nX2xpc3QpOworCWluaXRfd2FpdHF1ZXVlX2hlYWQoJmNvdW50ZXItPndhaXRxKTsKKworCW11dGV4X2luaXQoJmNvdW50ZXItPm1tYXBfbXV0ZXgpOworCisJY291bnRlci0+Y3B1CQk9IGNwdTsKKwljb3VudGVyLT5hdHRyCQk9ICphdHRyOworCWNvdW50ZXItPmdyb3VwX2xlYWRlcgk9IGdyb3VwX2xlYWRlcjsKKwljb3VudGVyLT5wbXUJCT0gTlVMTDsKKwljb3VudGVyLT5jdHgJCT0gY3R4OworCWNvdW50ZXItPm9uY3B1CQk9IC0xOworCisJY291bnRlci0+bnMJCT0gZ2V0X3BpZF9ucyhjdXJyZW50LT5uc3Byb3h5LT5waWRfbnMpOworCWNvdW50ZXItPmlkCQk9IGF0b21pYzY0X2luY19yZXR1cm4oJnBlcmZfY291bnRlcl9pZCk7CisKKwljb3VudGVyLT5zdGF0ZQkJPSBQRVJGX0NPVU5URVJfU1RBVEVfSU5BQ1RJVkU7CisKKwlpZiAoYXR0ci0+ZGlzYWJsZWQpCisJCWNvdW50ZXItPnN0YXRlID0gUEVSRl9DT1VOVEVSX1NUQVRFX09GRjsKKworCXBtdSA9IE5VTEw7CisKKwlod2MgPSAmY291bnRlci0+aHc7CisJaHdjLT5zYW1wbGVfcGVyaW9kID0gYXR0ci0+c2FtcGxlX3BlcmlvZDsKKwlpZiAoYXR0ci0+ZnJlcSAmJiBhdHRyLT5zYW1wbGVfZnJlcSkKKwkJaHdjLT5zYW1wbGVfcGVyaW9kID0gMTsKKworCWF0b21pYzY0X3NldCgmaHdjLT5wZXJpb2RfbGVmdCwgaHdjLT5zYW1wbGVfcGVyaW9kKTsKKworCS8qCisJICogd2UgY3VycmVudGx5IGRvIG5vdCBzdXBwb3J0IFBFUkZfU0FNUExFX0dST1VQIG9uIGluaGVyaXRlZCBjb3VudGVycworCSAqLworCWlmIChhdHRyLT5pbmhlcml0ICYmIChhdHRyLT5zYW1wbGVfdHlwZSAmIFBFUkZfU0FNUExFX0dST1VQKSkKKwkJZ290byBkb25lOworCisJaWYgKGF0dHItPnR5cGUgPT0gUEVSRl9UWVBFX1JBVykgeworCQlwbXUgPSBod19wZXJmX2NvdW50ZXJfaW5pdChjb3VudGVyKTsKKwkJZ290byBkb25lOworCX0KKworCXN3aXRjaCAoYXR0ci0+dHlwZSkgeworCWNhc2UgUEVSRl9UWVBFX0hBUkRXQVJFOgorCWNhc2UgUEVSRl9UWVBFX0hXX0NBQ0hFOgorCQlwbXUgPSBod19wZXJmX2NvdW50ZXJfaW5pdChjb3VudGVyKTsKKwkJYnJlYWs7CisKKwljYXNlIFBFUkZfVFlQRV9TT0ZUV0FSRToKKwkJcG11ID0gc3dfcGVyZl9jb3VudGVyX2luaXQoY291bnRlcik7CisJCWJyZWFrOworCisJY2FzZSBQRVJGX1RZUEVfVFJBQ0VQT0lOVDoKKwkJcG11ID0gdHBfcGVyZl9jb3VudGVyX2luaXQoY291bnRlcik7CisJCWJyZWFrOworCX0KK2RvbmU6CisJZXJyID0gMDsKKwlpZiAoIXBtdSkKKwkJZXJyID0gLUVJTlZBTDsKKwllbHNlIGlmIChJU19FUlIocG11KSkKKwkJZXJyID0gUFRSX0VSUihwbXUpOworCisJaWYgKGVycikgeworCQlpZiAoY291bnRlci0+bnMpCisJCQlwdXRfcGlkX25zKGNvdW50ZXItPm5zKTsKKwkJa2ZyZWUoY291bnRlcik7CisJCXJldHVybiBFUlJfUFRSKGVycik7CisJfQorCisJY291bnRlci0+cG11ID0gcG11OworCisJYXRvbWljX2luYygmbnJfY291bnRlcnMpOworCWlmIChjb3VudGVyLT5hdHRyLm1tYXApCisJCWF0b21pY19pbmMoJm5yX21tYXBfY291bnRlcnMpOworCWlmIChjb3VudGVyLT5hdHRyLmNvbW0pCisJCWF0b21pY19pbmMoJm5yX2NvbW1fY291bnRlcnMpOworCisJcmV0dXJuIGNvdW50ZXI7Cit9CisKKy8qKgorICogc3lzX3BlcmZfY291bnRlcl9vcGVuIC0gb3BlbiBhIHBlcmZvcm1hbmNlIGNvdW50ZXIsIGFzc29jaWF0ZSBpdCB0byBhIHRhc2svY3B1CisgKgorICogQGF0dHJfdXB0cjoJZXZlbnQgdHlwZSBhdHRyaWJ1dGVzIGZvciBtb25pdG9yaW5nL3NhbXBsaW5nCisgKiBAcGlkOgkJdGFyZ2V0IHBpZAorICogQGNwdToJCXRhcmdldCBjcHUKKyAqIEBncm91cF9mZDoJCWdyb3VwIGxlYWRlciBjb3VudGVyIGZkCisgKi8KK1NZU0NBTExfREVGSU5FNShwZXJmX2NvdW50ZXJfb3BlbiwKKwkJY29uc3Qgc3RydWN0IHBlcmZfY291bnRlcl9hdHRyIF9fdXNlciAqLCBhdHRyX3VwdHIsCisJCXBpZF90LCBwaWQsIGludCwgY3B1LCBpbnQsIGdyb3VwX2ZkLCB1bnNpZ25lZCBsb25nLCBmbGFncykKK3sKKwlzdHJ1Y3QgcGVyZl9jb3VudGVyICpjb3VudGVyLCAqZ3JvdXBfbGVhZGVyOworCXN0cnVjdCBwZXJmX2NvdW50ZXJfYXR0ciBhdHRyOworCXN0cnVjdCBwZXJmX2NvdW50ZXJfY29udGV4dCAqY3R4OworCXN0cnVjdCBmaWxlICpjb3VudGVyX2ZpbGUgPSBOVUxMOworCXN0cnVjdCBmaWxlICpncm91cF9maWxlID0gTlVMTDsKKwlpbnQgZnB1dF9uZWVkZWQgPSAwOworCWludCBmcHV0X25lZWRlZDIgPSAwOworCWludCByZXQ7CisKKwkvKiBmb3IgZnV0dXJlIGV4cGFuZGFiaWxpdHkuLi4gKi8KKwlpZiAoZmxhZ3MpCisJCXJldHVybiAtRUlOVkFMOworCisJaWYgKGNvcHlfZnJvbV91c2VyKCZhdHRyLCBhdHRyX3VwdHIsIHNpemVvZihhdHRyKSkgIT0gMCkKKwkJcmV0dXJuIC1FRkFVTFQ7CisKKwlpZiAoIWF0dHIuZXhjbHVkZV9rZXJuZWwpIHsKKwkJaWYgKHBlcmZfcGFyYW5vaWRfa2VybmVsKCkgJiYgIWNhcGFibGUoQ0FQX1NZU19BRE1JTikpCisJCQlyZXR1cm4gLUVBQ0NFUzsKKwl9CisKKwlpZiAoYXR0ci5mcmVxKSB7CisJCWlmIChhdHRyLnNhbXBsZV9mcmVxID4gc3lzY3RsX3BlcmZfY291bnRlcl9zYW1wbGVfcmF0ZSkKKwkJCXJldHVybiAtRUlOVkFMOworCX0KKworCS8qCisJICogR2V0IHRoZSB0YXJnZXQgY29udGV4dCAodGFzayBvciBwZXJjcHUpOgorCSAqLworCWN0eCA9IGZpbmRfZ2V0X2NvbnRleHQocGlkLCBjcHUpOworCWlmIChJU19FUlIoY3R4KSkKKwkJcmV0dXJuIFBUUl9FUlIoY3R4KTsKKworCS8qCisJICogTG9vayB1cCB0aGUgZ3JvdXAgbGVhZGVyICh3ZSB3aWxsIGF0dGFjaCB0aGlzIGNvdW50ZXIgdG8gaXQpOgorCSAqLworCWdyb3VwX2xlYWRlciA9IE5VTEw7CisJaWYgKGdyb3VwX2ZkICE9IC0xKSB7CisJCXJldCA9IC1FSU5WQUw7CisJCWdyb3VwX2ZpbGUgPSBmZ2V0X2xpZ2h0KGdyb3VwX2ZkLCAmZnB1dF9uZWVkZWQpOworCQlpZiAoIWdyb3VwX2ZpbGUpCisJCQlnb3RvIGVycl9wdXRfY29udGV4dDsKKwkJaWYgKGdyb3VwX2ZpbGUtPmZfb3AgIT0gJnBlcmZfZm9wcykKKwkJCWdvdG8gZXJyX3B1dF9jb250ZXh0OworCisJCWdyb3VwX2xlYWRlciA9IGdyb3VwX2ZpbGUtPnByaXZhdGVfZGF0YTsKKwkJLyoKKwkJICogRG8gbm90IGFsbG93IGEgcmVjdXJzaXZlIGhpZXJhcmNoeSAodGhpcyBuZXcgc2libGluZworCQkgKiBiZWNvbWluZyBwYXJ0IG9mIGFub3RoZXIgZ3JvdXAtc2libGluZyk6CisJCSAqLworCQlpZiAoZ3JvdXBfbGVhZGVyLT5ncm91cF9sZWFkZXIgIT0gZ3JvdXBfbGVhZGVyKQorCQkJZ290byBlcnJfcHV0X2NvbnRleHQ7CisJCS8qCisJCSAqIERvIG5vdCBhbGxvdyB0byBhdHRhY2ggdG8gYSBncm91cCBpbiBhIGRpZmZlcmVudAorCQkgKiB0YXNrIG9yIENQVSBjb250ZXh0OgorCQkgKi8KKwkJaWYgKGdyb3VwX2xlYWRlci0+Y3R4ICE9IGN0eCkKKwkJCWdvdG8gZXJyX3B1dF9jb250ZXh0OworCQkvKgorCQkgKiBPbmx5IGEgZ3JvdXAgbGVhZGVyIGNhbiBiZSBleGNsdXNpdmUgb3IgcGlubmVkCisJCSAqLworCQlpZiAoYXR0ci5leGNsdXNpdmUgfHwgYXR0ci5waW5uZWQpCisJCQlnb3RvIGVycl9wdXRfY29udGV4dDsKKwl9CisKKwljb3VudGVyID0gcGVyZl9jb3VudGVyX2FsbG9jKCZhdHRyLCBjcHUsIGN0eCwgZ3JvdXBfbGVhZGVyLAorCQkJCSAgICAgR0ZQX0tFUk5FTCk7CisJcmV0ID0gUFRSX0VSUihjb3VudGVyKTsKKwlpZiAoSVNfRVJSKGNvdW50ZXIpKQorCQlnb3RvIGVycl9wdXRfY29udGV4dDsKKworCXJldCA9IGFub25faW5vZGVfZ2V0ZmQoIltwZXJmX2NvdW50ZXJdIiwgJnBlcmZfZm9wcywgY291bnRlciwgMCk7CisJaWYgKHJldCA8IDApCisJCWdvdG8gZXJyX2ZyZWVfcHV0X2NvbnRleHQ7CisKKwljb3VudGVyX2ZpbGUgPSBmZ2V0X2xpZ2h0KHJldCwgJmZwdXRfbmVlZGVkMik7CisJaWYgKCFjb3VudGVyX2ZpbGUpCisJCWdvdG8gZXJyX2ZyZWVfcHV0X2NvbnRleHQ7CisKKwljb3VudGVyLT5maWxwID0gY291bnRlcl9maWxlOworCVdBUk5fT05fT05DRShjdHgtPnBhcmVudF9jdHgpOworCW11dGV4X2xvY2soJmN0eC0+bXV0ZXgpOworCXBlcmZfaW5zdGFsbF9pbl9jb250ZXh0KGN0eCwgY291bnRlciwgY3B1KTsKKwkrK2N0eC0+Z2VuZXJhdGlvbjsKKwltdXRleF91bmxvY2soJmN0eC0+bXV0ZXgpOworCisJY291bnRlci0+b3duZXIgPSBjdXJyZW50OworCWdldF90YXNrX3N0cnVjdChjdXJyZW50KTsKKwltdXRleF9sb2NrKCZjdXJyZW50LT5wZXJmX2NvdW50ZXJfbXV0ZXgpOworCWxpc3RfYWRkX3RhaWwoJmNvdW50ZXItPm93bmVyX2VudHJ5LCAmY3VycmVudC0+cGVyZl9jb3VudGVyX2xpc3QpOworCW11dGV4X3VubG9jaygmY3VycmVudC0+cGVyZl9jb3VudGVyX211dGV4KTsKKworCWZwdXRfbGlnaHQoY291bnRlcl9maWxlLCBmcHV0X25lZWRlZDIpOworCitvdXRfZnB1dDoKKwlmcHV0X2xpZ2h0KGdyb3VwX2ZpbGUsIGZwdXRfbmVlZGVkKTsKKworCXJldHVybiByZXQ7CisKK2Vycl9mcmVlX3B1dF9jb250ZXh0OgorCWtmcmVlKGNvdW50ZXIpOworCitlcnJfcHV0X2NvbnRleHQ6CisJcHV0X2N0eChjdHgpOworCisJZ290byBvdXRfZnB1dDsKK30KKworLyoKKyAqIGluaGVyaXQgYSBjb3VudGVyIGZyb20gcGFyZW50IHRhc2sgdG8gY2hpbGQgdGFzazoKKyAqLworc3RhdGljIHN0cnVjdCBwZXJmX2NvdW50ZXIgKgoraW5oZXJpdF9jb3VudGVyKHN0cnVjdCBwZXJmX2NvdW50ZXIgKnBhcmVudF9jb3VudGVyLAorCSAgICAgIHN0cnVjdCB0YXNrX3N0cnVjdCAqcGFyZW50LAorCSAgICAgIHN0cnVjdCBwZXJmX2NvdW50ZXJfY29udGV4dCAqcGFyZW50X2N0eCwKKwkgICAgICBzdHJ1Y3QgdGFza19zdHJ1Y3QgKmNoaWxkLAorCSAgICAgIHN0cnVjdCBwZXJmX2NvdW50ZXIgKmdyb3VwX2xlYWRlciwKKwkgICAgICBzdHJ1Y3QgcGVyZl9jb3VudGVyX2NvbnRleHQgKmNoaWxkX2N0eCkKK3sKKwlzdHJ1Y3QgcGVyZl9jb3VudGVyICpjaGlsZF9jb3VudGVyOworCisJLyoKKwkgKiBJbnN0ZWFkIG9mIGNyZWF0aW5nIHJlY3Vyc2l2ZSBoaWVyYXJjaGllcyBvZiBjb3VudGVycywKKwkgKiB3ZSBsaW5rIGluaGVyaXRlZCBjb3VudGVycyBiYWNrIHRvIHRoZSBvcmlnaW5hbCBwYXJlbnQsCisJICogd2hpY2ggaGFzIGEgZmlscCBmb3Igc3VyZSwgd2hpY2ggd2UgdXNlIGFzIHRoZSByZWZlcmVuY2UKKwkgKiBjb3VudDoKKwkgKi8KKwlpZiAocGFyZW50X2NvdW50ZXItPnBhcmVudCkKKwkJcGFyZW50X2NvdW50ZXIgPSBwYXJlbnRfY291bnRlci0+cGFyZW50OworCisJY2hpbGRfY291bnRlciA9IHBlcmZfY291bnRlcl9hbGxvYygmcGFyZW50X2NvdW50ZXItPmF0dHIsCisJCQkJCSAgIHBhcmVudF9jb3VudGVyLT5jcHUsIGNoaWxkX2N0eCwKKwkJCQkJICAgZ3JvdXBfbGVhZGVyLCBHRlBfS0VSTkVMKTsKKwlpZiAoSVNfRVJSKGNoaWxkX2NvdW50ZXIpKQorCQlyZXR1cm4gY2hpbGRfY291bnRlcjsKKwlnZXRfY3R4KGNoaWxkX2N0eCk7CisKKwkvKgorCSAqIE1ha2UgdGhlIGNoaWxkIHN0YXRlIGZvbGxvdyB0aGUgc3RhdGUgb2YgdGhlIHBhcmVudCBjb3VudGVyLAorCSAqIG5vdCBpdHMgYXR0ci5kaXNhYmxlZCBiaXQuICBXZSBob2xkIHRoZSBwYXJlbnQncyBtdXRleCwKKwkgKiBzbyB3ZSB3b24ndCByYWNlIHdpdGggcGVyZl9jb3VudGVyX3tlbiwgZGlzfWFibGVfZmFtaWx5LgorCSAqLworCWlmIChwYXJlbnRfY291bnRlci0+c3RhdGUgPj0gUEVSRl9DT1VOVEVSX1NUQVRFX0lOQUNUSVZFKQorCQljaGlsZF9jb3VudGVyLT5zdGF0ZSA9IFBFUkZfQ09VTlRFUl9TVEFURV9JTkFDVElWRTsKKwllbHNlCisJCWNoaWxkX2NvdW50ZXItPnN0YXRlID0gUEVSRl9DT1VOVEVSX1NUQVRFX09GRjsKKworCWlmIChwYXJlbnRfY291bnRlci0+YXR0ci5mcmVxKQorCQljaGlsZF9jb3VudGVyLT5ody5zYW1wbGVfcGVyaW9kID0gcGFyZW50X2NvdW50ZXItPmh3LnNhbXBsZV9wZXJpb2Q7CisKKwkvKgorCSAqIExpbmsgaXQgdXAgaW4gdGhlIGNoaWxkJ3MgY29udGV4dDoKKwkgKi8KKwlhZGRfY291bnRlcl90b19jdHgoY2hpbGRfY291bnRlciwgY2hpbGRfY3R4KTsKKworCWNoaWxkX2NvdW50ZXItPnBhcmVudCA9IHBhcmVudF9jb3VudGVyOworCS8qCisJICogaW5oZXJpdCBpbnRvIGNoaWxkJ3MgY2hpbGQgYXMgd2VsbDoKKwkgKi8KKwljaGlsZF9jb3VudGVyLT5hdHRyLmluaGVyaXQgPSAxOworCisJLyoKKwkgKiBHZXQgYSByZWZlcmVuY2UgdG8gdGhlIHBhcmVudCBmaWxwIC0gd2Ugd2lsbCBmcHV0IGl0CisJICogd2hlbiB0aGUgY2hpbGQgY291bnRlciBleGl0cy4gVGhpcyBpcyBzYWZlIHRvIGRvIGJlY2F1c2UKKwkgKiB3ZSBhcmUgaW4gdGhlIHBhcmVudCBhbmQgd2Uga25vdyB0aGF0IHRoZSBmaWxwIHN0aWxsCisJICogZXhpc3RzIGFuZCBoYXMgYSBub256ZXJvIGNvdW50OgorCSAqLworCWF0b21pY19sb25nX2luYygmcGFyZW50X2NvdW50ZXItPmZpbHAtPmZfY291bnQpOworCisJLyoKKwkgKiBMaW5rIHRoaXMgaW50byB0aGUgcGFyZW50IGNvdW50ZXIncyBjaGlsZCBsaXN0CisJICovCisJV0FSTl9PTl9PTkNFKHBhcmVudF9jb3VudGVyLT5jdHgtPnBhcmVudF9jdHgpOworCW11dGV4X2xvY2soJnBhcmVudF9jb3VudGVyLT5jaGlsZF9tdXRleCk7CisJbGlzdF9hZGRfdGFpbCgmY2hpbGRfY291bnRlci0+Y2hpbGRfbGlzdCwgJnBhcmVudF9jb3VudGVyLT5jaGlsZF9saXN0KTsKKwltdXRleF91bmxvY2soJnBhcmVudF9jb3VudGVyLT5jaGlsZF9tdXRleCk7CisKKwlyZXR1cm4gY2hpbGRfY291bnRlcjsKK30KKworc3RhdGljIGludCBpbmhlcml0X2dyb3VwKHN0cnVjdCBwZXJmX2NvdW50ZXIgKnBhcmVudF9jb3VudGVyLAorCSAgICAgIHN0cnVjdCB0YXNrX3N0cnVjdCAqcGFyZW50LAorCSAgICAgIHN0cnVjdCBwZXJmX2NvdW50ZXJfY29udGV4dCAqcGFyZW50X2N0eCwKKwkgICAgICBzdHJ1Y3QgdGFza19zdHJ1Y3QgKmNoaWxkLAorCSAgICAgIHN0cnVjdCBwZXJmX2NvdW50ZXJfY29udGV4dCAqY2hpbGRfY3R4KQoreworCXN0cnVjdCBwZXJmX2NvdW50ZXIgKmxlYWRlcjsKKwlzdHJ1Y3QgcGVyZl9jb3VudGVyICpzdWI7CisJc3RydWN0IHBlcmZfY291bnRlciAqY2hpbGRfY3RyOworCisJbGVhZGVyID0gaW5oZXJpdF9jb3VudGVyKHBhcmVudF9jb3VudGVyLCBwYXJlbnQsIHBhcmVudF9jdHgsCisJCQkJIGNoaWxkLCBOVUxMLCBjaGlsZF9jdHgpOworCWlmIChJU19FUlIobGVhZGVyKSkKKwkJcmV0dXJuIFBUUl9FUlIobGVhZGVyKTsKKwlsaXN0X2Zvcl9lYWNoX2VudHJ5KHN1YiwgJnBhcmVudF9jb3VudGVyLT5zaWJsaW5nX2xpc3QsIGxpc3RfZW50cnkpIHsKKwkJY2hpbGRfY3RyID0gaW5oZXJpdF9jb3VudGVyKHN1YiwgcGFyZW50LCBwYXJlbnRfY3R4LAorCQkJCQkgICAgY2hpbGQsIGxlYWRlciwgY2hpbGRfY3R4KTsKKwkJaWYgKElTX0VSUihjaGlsZF9jdHIpKQorCQkJcmV0dXJuIFBUUl9FUlIoY2hpbGRfY3RyKTsKKwl9CisJcmV0dXJuIDA7Cit9CisKK3N0YXRpYyB2b2lkIHN5bmNfY2hpbGRfY291bnRlcihzdHJ1Y3QgcGVyZl9jb3VudGVyICpjaGlsZF9jb3VudGVyLAorCQkJICAgICAgIHN0cnVjdCBwZXJmX2NvdW50ZXIgKnBhcmVudF9jb3VudGVyKQoreworCXU2NCBjaGlsZF92YWw7CisKKwljaGlsZF92YWwgPSBhdG9taWM2NF9yZWFkKCZjaGlsZF9jb3VudGVyLT5jb3VudCk7CisKKwkvKgorCSAqIEFkZCBiYWNrIHRoZSBjaGlsZCdzIGNvdW50IHRvIHRoZSBwYXJlbnQncyBjb3VudDoKKwkgKi8KKwlhdG9taWM2NF9hZGQoY2hpbGRfdmFsLCAmcGFyZW50X2NvdW50ZXItPmNvdW50KTsKKwlhdG9taWM2NF9hZGQoY2hpbGRfY291bnRlci0+dG90YWxfdGltZV9lbmFibGVkLAorCQkgICAgICZwYXJlbnRfY291bnRlci0+Y2hpbGRfdG90YWxfdGltZV9lbmFibGVkKTsKKwlhdG9taWM2NF9hZGQoY2hpbGRfY291bnRlci0+dG90YWxfdGltZV9ydW5uaW5nLAorCQkgICAgICZwYXJlbnRfY291bnRlci0+Y2hpbGRfdG90YWxfdGltZV9ydW5uaW5nKTsKKworCS8qCisJICogUmVtb3ZlIHRoaXMgY291bnRlciBmcm9tIHRoZSBwYXJlbnQncyBsaXN0CisJICovCisJV0FSTl9PTl9PTkNFKHBhcmVudF9jb3VudGVyLT5jdHgtPnBhcmVudF9jdHgpOworCW11dGV4X2xvY2soJnBhcmVudF9jb3VudGVyLT5jaGlsZF9tdXRleCk7CisJbGlzdF9kZWxfaW5pdCgmY2hpbGRfY291bnRlci0+Y2hpbGRfbGlzdCk7CisJbXV0ZXhfdW5sb2NrKCZwYXJlbnRfY291bnRlci0+Y2hpbGRfbXV0ZXgpOworCisJLyoKKwkgKiBSZWxlYXNlIHRoZSBwYXJlbnQgY291bnRlciwgaWYgdGhpcyB3YXMgdGhlIGxhc3QKKwkgKiByZWZlcmVuY2UgdG8gaXQuCisJICovCisJZnB1dChwYXJlbnRfY291bnRlci0+ZmlscCk7Cit9CisKK3N0YXRpYyB2b2lkCitfX3BlcmZfY291bnRlcl9leGl0X3Rhc2soc3RydWN0IHBlcmZfY291bnRlciAqY2hpbGRfY291bnRlciwKKwkJCSBzdHJ1Y3QgcGVyZl9jb3VudGVyX2NvbnRleHQgKmNoaWxkX2N0eCkKK3sKKwlzdHJ1Y3QgcGVyZl9jb3VudGVyICpwYXJlbnRfY291bnRlcjsKKworCXVwZGF0ZV9jb3VudGVyX3RpbWVzKGNoaWxkX2NvdW50ZXIpOworCXBlcmZfY291bnRlcl9yZW1vdmVfZnJvbV9jb250ZXh0KGNoaWxkX2NvdW50ZXIpOworCisJcGFyZW50X2NvdW50ZXIgPSBjaGlsZF9jb3VudGVyLT5wYXJlbnQ7CisJLyoKKwkgKiBJdCBjYW4gaGFwcGVuIHRoYXQgcGFyZW50IGV4aXRzIGZpcnN0LCBhbmQgaGFzIGNvdW50ZXJzCisJICogdGhhdCBhcmUgc3RpbGwgYXJvdW5kIGR1ZSB0byB0aGUgY2hpbGQgcmVmZXJlbmNlLiBUaGVzZQorCSAqIGNvdW50ZXJzIG5lZWQgdG8gYmUgemFwcGVkIC0gYnV0IG90aGVyd2lzZSBsaW5nZXIuCisJICovCisJaWYgKHBhcmVudF9jb3VudGVyKSB7CisJCXN5bmNfY2hpbGRfY291bnRlcihjaGlsZF9jb3VudGVyLCBwYXJlbnRfY291bnRlcik7CisJCWZyZWVfY291bnRlcihjaGlsZF9jb3VudGVyKTsKKwl9Cit9CisKKy8qCisgKiBXaGVuIGEgY2hpbGQgdGFzayBleGl0cywgZmVlZCBiYWNrIGNvdW50ZXIgdmFsdWVzIHRvIHBhcmVudCBjb3VudGVycy4KKyAqLwordm9pZCBwZXJmX2NvdW50ZXJfZXhpdF90YXNrKHN0cnVjdCB0YXNrX3N0cnVjdCAqY2hpbGQpCit7CisJc3RydWN0IHBlcmZfY291bnRlciAqY2hpbGRfY291bnRlciwgKnRtcDsKKwlzdHJ1Y3QgcGVyZl9jb3VudGVyX2NvbnRleHQgKmNoaWxkX2N0eDsKKwl1bnNpZ25lZCBsb25nIGZsYWdzOworCisJaWYgKGxpa2VseSghY2hpbGQtPnBlcmZfY291bnRlcl9jdHhwKSkKKwkJcmV0dXJuOworCisJbG9jYWxfaXJxX3NhdmUoZmxhZ3MpOworCS8qCisJICogV2UgY2FuJ3QgcmVzY2hlZHVsZSBoZXJlIGJlY2F1c2UgaW50ZXJydXB0cyBhcmUgZGlzYWJsZWQsCisJICogYW5kIGVpdGhlciBjaGlsZCBpcyBjdXJyZW50IG9yIGl0IGlzIGEgdGFzayB0aGF0IGNhbid0IGJlCisJICogc2NoZWR1bGVkLCBzbyB3ZSBhcmUgbm93IHNhZmUgZnJvbSByZXNjaGVkdWxpbmcgY2hhbmdpbmcKKwkgKiBvdXIgY29udGV4dC4KKwkgKi8KKwljaGlsZF9jdHggPSBjaGlsZC0+cGVyZl9jb3VudGVyX2N0eHA7CisJX19wZXJmX2NvdW50ZXJfdGFza19zY2hlZF9vdXQoY2hpbGRfY3R4KTsKKworCS8qCisJICogVGFrZSB0aGUgY29udGV4dCBsb2NrIGhlcmUgc28gdGhhdCBpZiBmaW5kX2dldF9jb250ZXh0IGlzCisJICogcmVhZGluZyBjaGlsZC0+cGVyZl9jb3VudGVyX2N0eHAsIHdlIHdhaXQgdW50aWwgaXQgaGFzCisJICogaW5jcmVtZW50ZWQgdGhlIGNvbnRleHQncyByZWZjb3VudCBiZWZvcmUgd2UgZG8gcHV0X2N0eCBiZWxvdy4KKwkgKi8KKwlzcGluX2xvY2soJmNoaWxkX2N0eC0+bG9jayk7CisJY2hpbGQtPnBlcmZfY291bnRlcl9jdHhwID0gTlVMTDsKKwlpZiAoY2hpbGRfY3R4LT5wYXJlbnRfY3R4KSB7CisJCS8qCisJCSAqIFRoaXMgY29udGV4dCBpcyBhIGNsb25lOyB1bmNsb25lIGl0IHNvIGl0IGNhbid0IGdldAorCQkgKiBzd2FwcGVkIHRvIGFub3RoZXIgcHJvY2VzcyB3aGlsZSB3ZSdyZSByZW1vdmluZyBhbGwKKwkJICogdGhlIGNvdW50ZXJzIGZyb20gaXQuCisJCSAqLworCQlwdXRfY3R4KGNoaWxkX2N0eC0+cGFyZW50X2N0eCk7CisJCWNoaWxkX2N0eC0+cGFyZW50X2N0eCA9IE5VTEw7CisJfQorCXNwaW5fdW5sb2NrKCZjaGlsZF9jdHgtPmxvY2spOworCWxvY2FsX2lycV9yZXN0b3JlKGZsYWdzKTsKKworCS8qCisJICogV2UgY2FuIHJlY3Vyc2Ugb24gdGhlIHNhbWUgbG9jayB0eXBlIHRocm91Z2g6CisJICoKKwkgKiAgIF9fcGVyZl9jb3VudGVyX2V4aXRfdGFzaygpCisJICogICAgIHN5bmNfY2hpbGRfY291bnRlcigpCisJICogICAgICAgZnB1dChwYXJlbnRfY291bnRlci0+ZmlscCkKKwkgKiAgICAgICAgIHBlcmZfcmVsZWFzZSgpCisJICogICAgICAgICAgIG11dGV4X2xvY2soJmN0eC0+bXV0ZXgpCisJICoKKwkgKiBCdXQgc2luY2UgaXRzIHRoZSBwYXJlbnQgY29udGV4dCBpdCB3b24ndCBiZSB0aGUgc2FtZSBpbnN0YW5jZS4KKwkgKi8KKwltdXRleF9sb2NrX25lc3RlZCgmY2hpbGRfY3R4LT5tdXRleCwgU0lOR0xFX0RFUFRIX05FU1RJTkcpOworCithZ2FpbjoKKwlsaXN0X2Zvcl9lYWNoX2VudHJ5X3NhZmUoY2hpbGRfY291bnRlciwgdG1wLCAmY2hpbGRfY3R4LT5jb3VudGVyX2xpc3QsCisJCQkJIGxpc3RfZW50cnkpCisJCV9fcGVyZl9jb3VudGVyX2V4aXRfdGFzayhjaGlsZF9jb3VudGVyLCBjaGlsZF9jdHgpOworCisJLyoKKwkgKiBJZiB0aGUgbGFzdCBjb3VudGVyIHdhcyBhIGdyb3VwIGNvdW50ZXIsIGl0IHdpbGwgaGF2ZSBhcHBlbmRlZCBhbGwKKwkgKiBpdHMgc2libGluZ3MgdG8gdGhlIGxpc3QsIGJ1dCB3ZSBvYnRhaW5lZCAndG1wJyBiZWZvcmUgdGhhdCB3aGljaAorCSAqIHdpbGwgc3RpbGwgcG9pbnQgdG8gdGhlIGxpc3QgaGVhZCB0ZXJtaW5hdGluZyB0aGUgaXRlcmF0aW9uLgorCSAqLworCWlmICghbGlzdF9lbXB0eSgmY2hpbGRfY3R4LT5jb3VudGVyX2xpc3QpKQorCQlnb3RvIGFnYWluOworCisJbXV0ZXhfdW5sb2NrKCZjaGlsZF9jdHgtPm11dGV4KTsKKworCXB1dF9jdHgoY2hpbGRfY3R4KTsKK30KKworLyoKKyAqIGZyZWUgYW4gdW5leHBvc2VkLCB1bnVzZWQgY29udGV4dCBhcyBjcmVhdGVkIGJ5IGluaGVyaXRhbmNlIGJ5CisgKiBpbml0X3Rhc2sgYmVsb3csIHVzZWQgYnkgZm9yaygpIGluIGNhc2Ugb2YgZmFpbC4KKyAqLwordm9pZCBwZXJmX2NvdW50ZXJfZnJlZV90YXNrKHN0cnVjdCB0YXNrX3N0cnVjdCAqdGFzaykKK3sKKwlzdHJ1Y3QgcGVyZl9jb3VudGVyX2NvbnRleHQgKmN0eCA9IHRhc2stPnBlcmZfY291bnRlcl9jdHhwOworCXN0cnVjdCBwZXJmX2NvdW50ZXIgKmNvdW50ZXIsICp0bXA7CisKKwlpZiAoIWN0eCkKKwkJcmV0dXJuOworCisJbXV0ZXhfbG9jaygmY3R4LT5tdXRleCk7CithZ2FpbjoKKwlsaXN0X2Zvcl9lYWNoX2VudHJ5X3NhZmUoY291bnRlciwgdG1wLCAmY3R4LT5jb3VudGVyX2xpc3QsIGxpc3RfZW50cnkpIHsKKwkJc3RydWN0IHBlcmZfY291bnRlciAqcGFyZW50ID0gY291bnRlci0+cGFyZW50OworCisJCWlmIChXQVJOX09OX09OQ0UoIXBhcmVudCkpCisJCQljb250aW51ZTsKKworCQltdXRleF9sb2NrKCZwYXJlbnQtPmNoaWxkX211dGV4KTsKKwkJbGlzdF9kZWxfaW5pdCgmY291bnRlci0+Y2hpbGRfbGlzdCk7CisJCW11dGV4X3VubG9jaygmcGFyZW50LT5jaGlsZF9tdXRleCk7CisKKwkJZnB1dChwYXJlbnQtPmZpbHApOworCisJCWxpc3RfZGVsX2NvdW50ZXIoY291bnRlciwgY3R4KTsKKwkJZnJlZV9jb3VudGVyKGNvdW50ZXIpOworCX0KKworCWlmICghbGlzdF9lbXB0eSgmY3R4LT5jb3VudGVyX2xpc3QpKQorCQlnb3RvIGFnYWluOworCisJbXV0ZXhfdW5sb2NrKCZjdHgtPm11dGV4KTsKKworCXB1dF9jdHgoY3R4KTsKK30KKworLyoKKyAqIEluaXRpYWxpemUgdGhlIHBlcmZfY291bnRlciBjb250ZXh0IGluIHRhc2tfc3RydWN0CisgKi8KK2ludCBwZXJmX2NvdW50ZXJfaW5pdF90YXNrKHN0cnVjdCB0YXNrX3N0cnVjdCAqY2hpbGQpCit7CisJc3RydWN0IHBlcmZfY291bnRlcl9jb250ZXh0ICpjaGlsZF9jdHgsICpwYXJlbnRfY3R4OworCXN0cnVjdCBwZXJmX2NvdW50ZXJfY29udGV4dCAqY2xvbmVkX2N0eDsKKwlzdHJ1Y3QgcGVyZl9jb3VudGVyICpjb3VudGVyOworCXN0cnVjdCB0YXNrX3N0cnVjdCAqcGFyZW50ID0gY3VycmVudDsKKwlpbnQgaW5oZXJpdGVkX2FsbCA9IDE7CisJaW50IHJldCA9IDA7CisKKwljaGlsZC0+cGVyZl9jb3VudGVyX2N0eHAgPSBOVUxMOworCisJbXV0ZXhfaW5pdCgmY2hpbGQtPnBlcmZfY291bnRlcl9tdXRleCk7CisJSU5JVF9MSVNUX0hFQUQoJmNoaWxkLT5wZXJmX2NvdW50ZXJfbGlzdCk7CisKKwlpZiAobGlrZWx5KCFwYXJlbnQtPnBlcmZfY291bnRlcl9jdHhwKSkKKwkJcmV0dXJuIDA7CisKKwkvKgorCSAqIFRoaXMgaXMgZXhlY3V0ZWQgZnJvbSB0aGUgcGFyZW50IHRhc2sgY29udGV4dCwgc28gaW5oZXJpdAorCSAqIGNvdW50ZXJzIHRoYXQgaGF2ZSBiZWVuIG1hcmtlZCBmb3IgY2xvbmluZy4KKwkgKiBGaXJzdCBhbGxvY2F0ZSBhbmQgaW5pdGlhbGl6ZSBhIGNvbnRleHQgZm9yIHRoZSBjaGlsZC4KKwkgKi8KKworCWNoaWxkX2N0eCA9IGttYWxsb2Moc2l6ZW9mKHN0cnVjdCBwZXJmX2NvdW50ZXJfY29udGV4dCksIEdGUF9LRVJORUwpOworCWlmICghY2hpbGRfY3R4KQorCQlyZXR1cm4gLUVOT01FTTsKKworCV9fcGVyZl9jb3VudGVyX2luaXRfY29udGV4dChjaGlsZF9jdHgsIGNoaWxkKTsKKwljaGlsZC0+cGVyZl9jb3VudGVyX2N0eHAgPSBjaGlsZF9jdHg7CisJZ2V0X3Rhc2tfc3RydWN0KGNoaWxkKTsKKworCS8qCisJICogSWYgdGhlIHBhcmVudCdzIGNvbnRleHQgaXMgYSBjbG9uZSwgcGluIGl0IHNvIGl0IHdvbid0IGdldAorCSAqIHN3YXBwZWQgdW5kZXIgdXMuCisJICovCisJcGFyZW50X2N0eCA9IHBlcmZfcGluX3Rhc2tfY29udGV4dChwYXJlbnQpOworCisJLyoKKwkgKiBObyBuZWVkIHRvIGNoZWNrIGlmIHBhcmVudF9jdHggIT0gTlVMTCBoZXJlOyBzaW5jZSB3ZSBzYXcKKwkgKiBpdCBub24tTlVMTCBlYXJsaWVyLCB0aGUgb25seSByZWFzb24gZm9yIGl0IHRvIGJlY29tZSBOVUxMCisJICogaXMgaWYgd2UgZXhpdCwgYW5kIHNpbmNlIHdlJ3JlIGN1cnJlbnRseSBpbiB0aGUgbWlkZGxlIG9mCisJICogYSBmb3JrIHdlIGNhbid0IGJlIGV4aXRpbmcgYXQgdGhlIHNhbWUgdGltZS4KKwkgKi8KKworCS8qCisJICogTG9jayB0aGUgcGFyZW50IGxpc3QuIE5vIG5lZWQgdG8gbG9jayB0aGUgY2hpbGQgLSBub3QgUElECisJICogaGFzaGVkIHlldCBhbmQgbm90IHJ1bm5pbmcsIHNvIG5vYm9keSBjYW4gYWNjZXNzIGl0LgorCSAqLworCW11dGV4X2xvY2soJnBhcmVudF9jdHgtPm11dGV4KTsKKworCS8qCisJICogV2UgZG9udCBoYXZlIHRvIGRpc2FibGUgTk1JcyAtIHdlIGFyZSBvbmx5IGxvb2tpbmcgYXQKKwkgKiB0aGUgbGlzdCwgbm90IG1hbmlwdWxhdGluZyBpdDoKKwkgKi8KKwlsaXN0X2Zvcl9lYWNoX2VudHJ5X3JjdShjb3VudGVyLCAmcGFyZW50X2N0eC0+ZXZlbnRfbGlzdCwgZXZlbnRfZW50cnkpIHsKKwkJaWYgKGNvdW50ZXIgIT0gY291bnRlci0+Z3JvdXBfbGVhZGVyKQorCQkJY29udGludWU7CisKKwkJaWYgKCFjb3VudGVyLT5hdHRyLmluaGVyaXQpIHsKKwkJCWluaGVyaXRlZF9hbGwgPSAwOworCQkJY29udGludWU7CisJCX0KKworCQlyZXQgPSBpbmhlcml0X2dyb3VwKGNvdW50ZXIsIHBhcmVudCwgcGFyZW50X2N0eCwKKwkJCQkJICAgICBjaGlsZCwgY2hpbGRfY3R4KTsKKwkJaWYgKHJldCkgeworCQkJaW5oZXJpdGVkX2FsbCA9IDA7CisJCQlicmVhazsKKwkJfQorCX0KKworCWlmIChpbmhlcml0ZWRfYWxsKSB7CisJCS8qCisJCSAqIE1hcmsgdGhlIGNoaWxkIGNvbnRleHQgYXMgYSBjbG9uZSBvZiB0aGUgcGFyZW50CisJCSAqIGNvbnRleHQsIG9yIG9mIHdoYXRldmVyIHRoZSBwYXJlbnQgaXMgYSBjbG9uZSBvZi4KKwkJICogTm90ZSB0aGF0IGlmIHRoZSBwYXJlbnQgaXMgYSBjbG9uZSwgaXQgY291bGQgZ2V0CisJCSAqIHVuY2xvbmVkIGF0IGFueSBwb2ludCwgYnV0IHRoYXQgZG9lc24ndCBtYXR0ZXIKKwkJICogYmVjYXVzZSB0aGUgbGlzdCBvZiBjb3VudGVycyBhbmQgdGhlIGdlbmVyYXRpb24KKwkJICogY291bnQgY2FuJ3QgaGF2ZSBjaGFuZ2VkIHNpbmNlIHdlIHRvb2sgdGhlIG11dGV4LgorCQkgKi8KKwkJY2xvbmVkX2N0eCA9IHJjdV9kZXJlZmVyZW5jZShwYXJlbnRfY3R4LT5wYXJlbnRfY3R4KTsKKwkJaWYgKGNsb25lZF9jdHgpIHsKKwkJCWNoaWxkX2N0eC0+cGFyZW50X2N0eCA9IGNsb25lZF9jdHg7CisJCQljaGlsZF9jdHgtPnBhcmVudF9nZW4gPSBwYXJlbnRfY3R4LT5wYXJlbnRfZ2VuOworCQl9IGVsc2UgeworCQkJY2hpbGRfY3R4LT5wYXJlbnRfY3R4ID0gcGFyZW50X2N0eDsKKwkJCWNoaWxkX2N0eC0+cGFyZW50X2dlbiA9IHBhcmVudF9jdHgtPmdlbmVyYXRpb247CisJCX0KKwkJZ2V0X2N0eChjaGlsZF9jdHgtPnBhcmVudF9jdHgpOworCX0KKworCW11dGV4X3VubG9jaygmcGFyZW50X2N0eC0+bXV0ZXgpOworCisJcGVyZl91bnBpbl9jb250ZXh0KHBhcmVudF9jdHgpOworCisJcmV0dXJuIHJldDsKK30KKworc3RhdGljIHZvaWQgX19jcHVpbml0IHBlcmZfY291bnRlcl9pbml0X2NwdShpbnQgY3B1KQoreworCXN0cnVjdCBwZXJmX2NwdV9jb250ZXh0ICpjcHVjdHg7CisKKwljcHVjdHggPSAmcGVyX2NwdShwZXJmX2NwdV9jb250ZXh0LCBjcHUpOworCV9fcGVyZl9jb3VudGVyX2luaXRfY29udGV4dCgmY3B1Y3R4LT5jdHgsIE5VTEwpOworCisJc3Bpbl9sb2NrKCZwZXJmX3Jlc291cmNlX2xvY2spOworCWNwdWN0eC0+bWF4X3BlcnRhc2sgPSBwZXJmX21heF9jb3VudGVycyAtIHBlcmZfcmVzZXJ2ZWRfcGVyY3B1OworCXNwaW5fdW5sb2NrKCZwZXJmX3Jlc291cmNlX2xvY2spOworCisJaHdfcGVyZl9jb3VudGVyX3NldHVwKGNwdSk7Cit9CisKKyNpZmRlZiBDT05GSUdfSE9UUExVR19DUFUKK3N0YXRpYyB2b2lkIF9fcGVyZl9jb3VudGVyX2V4aXRfY3B1KHZvaWQgKmluZm8pCit7CisJc3RydWN0IHBlcmZfY3B1X2NvbnRleHQgKmNwdWN0eCA9ICZfX2dldF9jcHVfdmFyKHBlcmZfY3B1X2NvbnRleHQpOworCXN0cnVjdCBwZXJmX2NvdW50ZXJfY29udGV4dCAqY3R4ID0gJmNwdWN0eC0+Y3R4OworCXN0cnVjdCBwZXJmX2NvdW50ZXIgKmNvdW50ZXIsICp0bXA7CisKKwlsaXN0X2Zvcl9lYWNoX2VudHJ5X3NhZmUoY291bnRlciwgdG1wLCAmY3R4LT5jb3VudGVyX2xpc3QsIGxpc3RfZW50cnkpCisJCV9fcGVyZl9jb3VudGVyX3JlbW92ZV9mcm9tX2NvbnRleHQoY291bnRlcik7Cit9CitzdGF0aWMgdm9pZCBwZXJmX2NvdW50ZXJfZXhpdF9jcHUoaW50IGNwdSkKK3sKKwlzdHJ1Y3QgcGVyZl9jcHVfY29udGV4dCAqY3B1Y3R4ID0gJnBlcl9jcHUocGVyZl9jcHVfY29udGV4dCwgY3B1KTsKKwlzdHJ1Y3QgcGVyZl9jb3VudGVyX2NvbnRleHQgKmN0eCA9ICZjcHVjdHgtPmN0eDsKKworCW11dGV4X2xvY2soJmN0eC0+bXV0ZXgpOworCXNtcF9jYWxsX2Z1bmN0aW9uX3NpbmdsZShjcHUsIF9fcGVyZl9jb3VudGVyX2V4aXRfY3B1LCBOVUxMLCAxKTsKKwltdXRleF91bmxvY2soJmN0eC0+bXV0ZXgpOworfQorI2Vsc2UKK3N0YXRpYyBpbmxpbmUgdm9pZCBwZXJmX2NvdW50ZXJfZXhpdF9jcHUoaW50IGNwdSkgeyB9CisjZW5kaWYKKworc3RhdGljIGludCBfX2NwdWluaXQKK3BlcmZfY3B1X25vdGlmeShzdHJ1Y3Qgbm90aWZpZXJfYmxvY2sgKnNlbGYsIHVuc2lnbmVkIGxvbmcgYWN0aW9uLCB2b2lkICpoY3B1KQoreworCXVuc2lnbmVkIGludCBjcHUgPSAobG9uZyloY3B1OworCisJc3dpdGNoIChhY3Rpb24pIHsKKworCWNhc2UgQ1BVX1VQX1BSRVBBUkU6CisJY2FzZSBDUFVfVVBfUFJFUEFSRV9GUk9aRU46CisJCXBlcmZfY291bnRlcl9pbml0X2NwdShjcHUpOworCQlicmVhazsKKworCWNhc2UgQ1BVX0RPV05fUFJFUEFSRToKKwljYXNlIENQVV9ET1dOX1BSRVBBUkVfRlJPWkVOOgorCQlwZXJmX2NvdW50ZXJfZXhpdF9jcHUoY3B1KTsKKwkJYnJlYWs7CisKKwlkZWZhdWx0OgorCQlicmVhazsKKwl9CisKKwlyZXR1cm4gTk9USUZZX09LOworfQorCisvKgorICogVGhpcyBoYXMgdG8gaGF2ZSBhIGhpZ2hlciBwcmlvcml0eSB0aGFuIG1pZ3JhdGlvbl9ub3RpZmllciBpbiBzY2hlZC5jLgorICovCitzdGF0aWMgc3RydWN0IG5vdGlmaWVyX2Jsb2NrIF9fY3B1aW5pdGRhdGEgcGVyZl9jcHVfbmIgPSB7CisJLm5vdGlmaWVyX2NhbGwJCT0gcGVyZl9jcHVfbm90aWZ5LAorCS5wcmlvcml0eQkJPSAyMCwKK307CisKK3ZvaWQgX19pbml0IHBlcmZfY291bnRlcl9pbml0KHZvaWQpCit7CisJcGVyZl9jcHVfbm90aWZ5KCZwZXJmX2NwdV9uYiwgKHVuc2lnbmVkIGxvbmcpQ1BVX1VQX1BSRVBBUkUsCisJCQkodm9pZCAqKShsb25nKXNtcF9wcm9jZXNzb3JfaWQoKSk7CisJcmVnaXN0ZXJfY3B1X25vdGlmaWVyKCZwZXJmX2NwdV9uYik7Cit9CisKK3N0YXRpYyBzc2l6ZV90IHBlcmZfc2hvd19yZXNlcnZlX3BlcmNwdShzdHJ1Y3Qgc3lzZGV2X2NsYXNzICpjbGFzcywgY2hhciAqYnVmKQoreworCXJldHVybiBzcHJpbnRmKGJ1ZiwgIiVkXG4iLCBwZXJmX3Jlc2VydmVkX3BlcmNwdSk7Cit9CisKK3N0YXRpYyBzc2l6ZV90CitwZXJmX3NldF9yZXNlcnZlX3BlcmNwdShzdHJ1Y3Qgc3lzZGV2X2NsYXNzICpjbGFzcywKKwkJCWNvbnN0IGNoYXIgKmJ1ZiwKKwkJCXNpemVfdCBjb3VudCkKK3sKKwlzdHJ1Y3QgcGVyZl9jcHVfY29udGV4dCAqY3B1Y3R4OworCXVuc2lnbmVkIGxvbmcgdmFsOworCWludCBlcnIsIGNwdSwgbXB0OworCisJZXJyID0gc3RyaWN0X3N0cnRvdWwoYnVmLCAxMCwgJnZhbCk7CisJaWYgKGVycikKKwkJcmV0dXJuIGVycjsKKwlpZiAodmFsID4gcGVyZl9tYXhfY291bnRlcnMpCisJCXJldHVybiAtRUlOVkFMOworCisJc3Bpbl9sb2NrKCZwZXJmX3Jlc291cmNlX2xvY2spOworCXBlcmZfcmVzZXJ2ZWRfcGVyY3B1ID0gdmFsOworCWZvcl9lYWNoX29ubGluZV9jcHUoY3B1KSB7CisJCWNwdWN0eCA9ICZwZXJfY3B1KHBlcmZfY3B1X2NvbnRleHQsIGNwdSk7CisJCXNwaW5fbG9ja19pcnEoJmNwdWN0eC0+Y3R4LmxvY2spOworCQltcHQgPSBtaW4ocGVyZl9tYXhfY291bnRlcnMgLSBjcHVjdHgtPmN0eC5ucl9jb3VudGVycywKKwkJCSAgcGVyZl9tYXhfY291bnRlcnMgLSBwZXJmX3Jlc2VydmVkX3BlcmNwdSk7CisJCWNwdWN0eC0+bWF4X3BlcnRhc2sgPSBtcHQ7CisJCXNwaW5fdW5sb2NrX2lycSgmY3B1Y3R4LT5jdHgubG9jayk7CisJfQorCXNwaW5fdW5sb2NrKCZwZXJmX3Jlc291cmNlX2xvY2spOworCisJcmV0dXJuIGNvdW50OworfQorCitzdGF0aWMgc3NpemVfdCBwZXJmX3Nob3dfb3ZlcmNvbW1pdChzdHJ1Y3Qgc3lzZGV2X2NsYXNzICpjbGFzcywgY2hhciAqYnVmKQoreworCXJldHVybiBzcHJpbnRmKGJ1ZiwgIiVkXG4iLCBwZXJmX292ZXJjb21taXQpOworfQorCitzdGF0aWMgc3NpemVfdAorcGVyZl9zZXRfb3ZlcmNvbW1pdChzdHJ1Y3Qgc3lzZGV2X2NsYXNzICpjbGFzcywgY29uc3QgY2hhciAqYnVmLCBzaXplX3QgY291bnQpCit7CisJdW5zaWduZWQgbG9uZyB2YWw7CisJaW50IGVycjsKKworCWVyciA9IHN0cmljdF9zdHJ0b3VsKGJ1ZiwgMTAsICZ2YWwpOworCWlmIChlcnIpCisJCXJldHVybiBlcnI7CisJaWYgKHZhbCA+IDEpCisJCXJldHVybiAtRUlOVkFMOworCisJc3Bpbl9sb2NrKCZwZXJmX3Jlc291cmNlX2xvY2spOworCXBlcmZfb3ZlcmNvbW1pdCA9IHZhbDsKKwlzcGluX3VubG9jaygmcGVyZl9yZXNvdXJjZV9sb2NrKTsKKworCXJldHVybiBjb3VudDsKK30KKworc3RhdGljIFNZU0RFVl9DTEFTU19BVFRSKAorCQkJCXJlc2VydmVfcGVyY3B1LAorCQkJCTA2NDQsCisJCQkJcGVyZl9zaG93X3Jlc2VydmVfcGVyY3B1LAorCQkJCXBlcmZfc2V0X3Jlc2VydmVfcGVyY3B1CisJCQkpOworCitzdGF0aWMgU1lTREVWX0NMQVNTX0FUVFIoCisJCQkJb3ZlcmNvbW1pdCwKKwkJCQkwNjQ0LAorCQkJCXBlcmZfc2hvd19vdmVyY29tbWl0LAorCQkJCXBlcmZfc2V0X292ZXJjb21taXQKKwkJCSk7CisKK3N0YXRpYyBzdHJ1Y3QgYXR0cmlidXRlICpwZXJmY2xhc3NfYXR0cnNbXSA9IHsKKwkmYXR0cl9yZXNlcnZlX3BlcmNwdS5hdHRyLAorCSZhdHRyX292ZXJjb21taXQuYXR0ciwKKwlOVUxMCit9OworCitzdGF0aWMgc3RydWN0IGF0dHJpYnV0ZV9ncm91cCBwZXJmY2xhc3NfYXR0cl9ncm91cCA9IHsKKwkuYXR0cnMJCQk9IHBlcmZjbGFzc19hdHRycywKKwkubmFtZQkJCT0gInBlcmZfY291bnRlcnMiLAorfTsKKworc3RhdGljIGludCBfX2luaXQgcGVyZl9jb3VudGVyX3N5c2ZzX2luaXQodm9pZCkKK3sKKwlyZXR1cm4gc3lzZnNfY3JlYXRlX2dyb3VwKCZjcHVfc3lzZGV2X2NsYXNzLmtzZXQua29iaiwKKwkJCQkgICZwZXJmY2xhc3NfYXR0cl9ncm91cCk7Cit9CitkZXZpY2VfaW5pdGNhbGwocGVyZl9jb3VudGVyX3N5c2ZzX2luaXQpOwpkaWZmIC0tZ2l0IGEva2VybmVsL3Byb2ZpbGUuYyBiL2tlcm5lbC9wcm9maWxlLmMKaW5kZXggNzcyNGUwNC4uMjhjZjI2YSAxMDA2NDQKLS0tIGEva2VybmVsL3Byb2ZpbGUuYworKysgYi9rZXJuZWwvcHJvZmlsZS5jCkBAIC0xMTEsMTIgKzExMSw2IEBACiAJLyogb25seSB0ZXh0IGlzIHByb2ZpbGVkICovCiAJcHJvZl9sZW4gPSAoX2V0ZXh0IC0gX3N0ZXh0KSA+PiBwcm9mX3NoaWZ0OwogCWJ1ZmZlcl9ieXRlcyA9IHByb2ZfbGVuKnNpemVvZihhdG9taWNfdCk7Ci0JaWYgKCFzbGFiX2lzX2F2YWlsYWJsZSgpKSB7Ci0JCXByb2ZfYnVmZmVyID0gYWxsb2NfYm9vdG1lbShidWZmZXJfYnl0ZXMpOwotCQlhbGxvY19ib290bWVtX2NwdW1hc2tfdmFyKCZwcm9mX2NwdV9tYXNrKTsKLQkJY3B1bWFza19jb3B5KHByb2ZfY3B1X21hc2ssIGNwdV9wb3NzaWJsZV9tYXNrKTsKLQkJcmV0dXJuIDA7Ci0JfQogCiAJaWYgKCFhbGxvY19jcHVtYXNrX3ZhcigmcHJvZl9jcHVfbWFzaywgR0ZQX0tFUk5FTCkpCiAJCXJldHVybiAtRU5PTUVNOwpkaWZmIC0tZ2l0IGEva2VybmVsL3NjaGVkLmMgYi9rZXJuZWwvc2NoZWQuYwppbmRleCAxNGM0NDdhLi5mMDRhYTk2IDEwMDY0NAotLS0gYS9rZXJuZWwvc2NoZWQuYworKysgYi9rZXJuZWwvc2NoZWQuYwpAQCAtMzksNiArMzksNyBAQAogI2luY2x1ZGUgPGxpbnV4L2NvbXBsZXRpb24uaD4KICNpbmNsdWRlIDxsaW51eC9rZXJuZWxfc3RhdC5oPgogI2luY2x1ZGUgPGxpbnV4L2RlYnVnX2xvY2tzLmg+CisjaW5jbHVkZSA8bGludXgvcGVyZl9jb3VudGVyLmg+CiAjaW5jbHVkZSA8bGludXgvc2VjdXJpdHkuaD4KICNpbmNsdWRlIDxsaW51eC9ub3RpZmllci5oPgogI2luY2x1ZGUgPGxpbnV4L3Byb2ZpbGUuaD4KQEAgLTY4LDcgKzY5LDYgQEAKICNpbmNsdWRlIDxsaW51eC9wYWdlbWFwLmg+CiAjaW5jbHVkZSA8bGludXgvaHJ0aW1lci5oPgogI2luY2x1ZGUgPGxpbnV4L3RpY2suaD4KLSNpbmNsdWRlIDxsaW51eC9ib290bWVtLmg+CiAjaW5jbHVkZSA8bGludXgvZGVidWdmcy5oPgogI2luY2x1ZGUgPGxpbnV4L2N0eXBlLmg+CiAjaW5jbHVkZSA8bGludXgvZnRyYWNlLmg+CkBAIC01ODAsNiArNTgwLDcgQEAKIAlzdHJ1Y3QgbG9hZF93ZWlnaHQgbG9hZDsKIAl1bnNpZ25lZCBsb25nIG5yX2xvYWRfdXBkYXRlczsKIAl1NjQgbnJfc3dpdGNoZXM7CisJdTY0IG5yX21pZ3JhdGlvbnNfaW47CiAKIAlzdHJ1Y3QgY2ZzX3JxIGNmczsKIAlzdHJ1Y3QgcnRfcnEgcnQ7CkBAIC02OTIsNyArNjkzLDcgQEAKICNkZWZpbmUgdGFza19ycShwKQkJY3B1X3JxKHRhc2tfY3B1KHApKQogI2RlZmluZSBjcHVfY3VycihjcHUpCQkoY3B1X3JxKGNwdSktPmN1cnIpCiAKLXN0YXRpYyBpbmxpbmUgdm9pZCB1cGRhdGVfcnFfY2xvY2soc3RydWN0IHJxICpycSkKK2lubGluZSB2b2lkIHVwZGF0ZV9ycV9jbG9jayhzdHJ1Y3QgcnEgKnJxKQogewogCXJxLT5jbG9jayA9IHNjaGVkX2Nsb2NrX2NwdShjcHVfb2YocnEpKTsKIH0KQEAgLTE5NjksMTIgKzE5NzAsMTYgQEAKIAkJcC0+c2Uuc2xlZXBfc3RhcnQgLT0gY2xvY2tfb2Zmc2V0OwogCWlmIChwLT5zZS5ibG9ja19zdGFydCkKIAkJcC0+c2UuYmxvY2tfc3RhcnQgLT0gY2xvY2tfb2Zmc2V0OworI2VuZGlmCiAJaWYgKG9sZF9jcHUgIT0gbmV3X2NwdSkgewotCQlzY2hlZHN0YXRfaW5jKHAsIHNlLm5yX21pZ3JhdGlvbnMpOworCQlwLT5zZS5ucl9taWdyYXRpb25zKys7CisJCW5ld19ycS0+bnJfbWlncmF0aW9uc19pbisrOworI2lmZGVmIENPTkZJR19TQ0hFRFNUQVRTCiAJCWlmICh0YXNrX2hvdChwLCBvbGRfcnEtPmNsb2NrLCBOVUxMKSkKIAkJCXNjaGVkc3RhdF9pbmMocCwgc2UubnJfZm9yY2VkMl9taWdyYXRpb25zKTsKLQl9CiAjZW5kaWYKKwkJcGVyZl9jb3VudGVyX3Rhc2tfbWlncmF0aW9uKHAsIG5ld19jcHUpOworCX0KIAlwLT5zZS52cnVudGltZSAtPSBvbGRfY2ZzcnEtPm1pbl92cnVudGltZSAtCiAJCQkJCSBuZXdfY2ZzcnEtPm1pbl92cnVudGltZTsKIApAQCAtMjM2OSw2ICsyMzc0LDI3IEBACiAKICNlbmRpZiAvKiBDT05GSUdfU01QICovCiAKKy8qKgorICogdGFza19vbmNwdV9mdW5jdGlvbl9jYWxsIC0gY2FsbCBhIGZ1bmN0aW9uIG9uIHRoZSBjcHUgb24gd2hpY2ggYSB0YXNrIHJ1bnMKKyAqIEBwOgkJdGhlIHRhc2sgdG8gZXZhbHVhdGUKKyAqIEBmdW5jOgl0aGUgZnVuY3Rpb24gdG8gYmUgY2FsbGVkCisgKiBAaW5mbzoJdGhlIGZ1bmN0aW9uIGNhbGwgYXJndW1lbnQKKyAqCisgKiBDYWxscyB0aGUgZnVuY3Rpb24gQGZ1bmMgd2hlbiB0aGUgdGFzayBpcyBjdXJyZW50bHkgcnVubmluZy4gVGhpcyBtaWdodAorICogYmUgb24gdGhlIGN1cnJlbnQgQ1BVLCB3aGljaCBqdXN0IGNhbGxzIHRoZSBmdW5jdGlvbiBkaXJlY3RseQorICovCit2b2lkIHRhc2tfb25jcHVfZnVuY3Rpb25fY2FsbChzdHJ1Y3QgdGFza19zdHJ1Y3QgKnAsCisJCQkgICAgICB2b2lkICgqZnVuYykgKHZvaWQgKmluZm8pLCB2b2lkICppbmZvKQoreworCWludCBjcHU7CisKKwlwcmVlbXB0X2Rpc2FibGUoKTsKKwljcHUgPSB0YXNrX2NwdShwKTsKKwlpZiAodGFza19jdXJyKHApKQorCQlzbXBfY2FsbF9mdW5jdGlvbl9zaW5nbGUoY3B1LCBmdW5jLCBpbmZvLCAxKTsKKwlwcmVlbXB0X2VuYWJsZSgpOworfQorCiAvKioqCiAgKiB0cnlfdG9fd2FrZV91cCAtIHdha2UgdXAgYSB0aHJlYWQKICAqIEBwOiB0aGUgdG8tYmUtd29rZW4tdXAgdGhyZWFkCkBAIC0yNTM2LDYgKzI1NjIsNyBAQAogCXAtPnNlLmV4ZWNfc3RhcnQJCT0gMDsKIAlwLT5zZS5zdW1fZXhlY19ydW50aW1lCQk9IDA7CiAJcC0+c2UucHJldl9zdW1fZXhlY19ydW50aW1lCT0gMDsKKwlwLT5zZS5ucl9taWdyYXRpb25zCQk9IDA7CiAJcC0+c2UubGFzdF93YWtldXAJCT0gMDsKIAlwLT5zZS5hdmdfb3ZlcmxhcAkJPSAwOwogCXAtPnNlLnN0YXJ0X3J1bnRpbWUJCT0gMDsKQEAgLTI3NjYsNiArMjc5Myw3IEBACiAJICovCiAJcHJldl9zdGF0ZSA9IHByZXYtPnN0YXRlOwogCWZpbmlzaF9hcmNoX3N3aXRjaChwcmV2KTsKKwlwZXJmX2NvdW50ZXJfdGFza19zY2hlZF9pbihjdXJyZW50LCBjcHVfb2YocnEpKTsKIAlmaW5pc2hfbG9ja19zd2l0Y2gocnEsIHByZXYpOwogI2lmZGVmIENPTkZJR19TTVAKIAlpZiAocG9zdF9zY2hlZHVsZSkKQEAgLTI5ODEsNiArMzAwOSwxNSBAQAogfQogCiAvKgorICogRXh0ZXJuYWxseSB2aXNpYmxlIHBlci1jcHUgc2NoZWR1bGVyIHN0YXRpc3RpY3M6CisgKiBjcHVfbnJfbWlncmF0aW9ucyhjcHUpIC0gbnVtYmVyIG9mIG1pZ3JhdGlvbnMgaW50byB0aGF0IGNwdQorICovCit1NjQgY3B1X25yX21pZ3JhdGlvbnMoaW50IGNwdSkKK3sKKwlyZXR1cm4gY3B1X3JxKGNwdSktPm5yX21pZ3JhdGlvbnNfaW47Cit9CisKKy8qCiAgKiBVcGRhdGUgcnEtPmNwdV9sb2FkW10gc3RhdGlzdGljcy4gVGhpcyBmdW5jdGlvbiBpcyB1c3VhbGx5IGNhbGxlZCBldmVyeQogICogc2NoZWR1bGVyIHRpY2sgKFRJQ0tfTlNFQykuCiAgKi8KQEAgLTUwNzgsNiArNTExNSw4IEBACiAJY3Vyci0+c2NoZWRfY2xhc3MtPnRhc2tfdGljayhycSwgY3VyciwgMCk7CiAJc3Bpbl91bmxvY2soJnJxLT5sb2NrKTsKIAorCXBlcmZfY291bnRlcl90YXNrX3RpY2soY3VyciwgY3B1KTsKKwogI2lmZGVmIENPTkZJR19TTVAKIAlycS0+aWRsZV9hdF90aWNrID0gaWRsZV9jcHUoY3B1KTsKIAl0cmlnZ2VyX2xvYWRfYmFsYW5jZShycSwgY3B1KTsKQEAgLTUyOTMsNiArNTMzMiw3IEBACiAKIAlpZiAobGlrZWx5KHByZXYgIT0gbmV4dCkpIHsKIAkJc2NoZWRfaW5mb19zd2l0Y2gocHJldiwgbmV4dCk7CisJCXBlcmZfY291bnRlcl90YXNrX3NjaGVkX291dChwcmV2LCBuZXh0LCBjcHUpOwogCiAJCXJxLT5ucl9zd2l0Y2hlcysrOwogCQlycS0+Y3VyciA9IG5leHQ7CkBAIC03NTM2LDggKzc1NzYsMTAgQEAKIAlyZXR1cm4gTk9USUZZX09LOwogfQogCi0vKiBSZWdpc3RlciBhdCBoaWdoZXN0IHByaW9yaXR5IHNvIHRoYXQgdGFzayBtaWdyYXRpb24gKG1pZ3JhdGVfYWxsX3Rhc2tzKQotICogaGFwcGVucyBiZWZvcmUgZXZlcnl0aGluZyBlbHNlLgorLyoKKyAqIFJlZ2lzdGVyIGF0IGhpZ2ggcHJpb3JpdHkgc28gdGhhdCB0YXNrIG1pZ3JhdGlvbiAobWlncmF0ZV9hbGxfdGFza3MpCisgKiBoYXBwZW5zIGJlZm9yZSBldmVyeXRoaW5nIGVsc2UuICBUaGlzIGhhcyB0byBiZSBsb3dlciBwcmlvcml0eSB0aGFuCisgKiB0aGUgbm90aWZpZXIgaW4gdGhlIHBlcmZfY291bnRlciBzdWJzeXN0ZW0sIHRob3VnaC4KICAqLwogc3RhdGljIHN0cnVjdCBub3RpZmllcl9ibG9jayBfX2NwdWluaXRkYXRhIG1pZ3JhdGlvbl9ub3RpZmllciA9IHsKIAkubm90aWZpZXJfY2FsbCA9IG1pZ3JhdGlvbl9jYWxsLApAQCAtNzc4MiwyNCArNzgyNCwyMSBAQAogCiBzdGF0aWMgaW50IF9faW5pdF9yZWZvayBpbml0X3Jvb3Rkb21haW4oc3RydWN0IHJvb3RfZG9tYWluICpyZCwgYm9vbCBib290bWVtKQogeworCWdmcF90IGdmcCA9IEdGUF9LRVJORUw7CisKIAltZW1zZXQocmQsIDAsIHNpemVvZigqcmQpKTsKIAotCWlmIChib290bWVtKSB7Ci0JCWFsbG9jX2Jvb3RtZW1fY3B1bWFza192YXIoJmRlZl9yb290X2RvbWFpbi5zcGFuKTsKLQkJYWxsb2NfYm9vdG1lbV9jcHVtYXNrX3ZhcigmZGVmX3Jvb3RfZG9tYWluLm9ubGluZSk7Ci0JCWFsbG9jX2Jvb3RtZW1fY3B1bWFza192YXIoJmRlZl9yb290X2RvbWFpbi5ydG9fbWFzayk7Ci0JCWNwdXByaV9pbml0KCZyZC0+Y3B1cHJpLCB0cnVlKTsKLQkJcmV0dXJuIDA7Ci0JfQorCWlmIChib290bWVtKQorCQlnZnAgPSBHRlBfTk9XQUlUOwogCi0JaWYgKCFhbGxvY19jcHVtYXNrX3ZhcigmcmQtPnNwYW4sIEdGUF9LRVJORUwpKQorCWlmICghYWxsb2NfY3B1bWFza192YXIoJnJkLT5zcGFuLCBnZnApKQogCQlnb3RvIG91dDsKLQlpZiAoIWFsbG9jX2NwdW1hc2tfdmFyKCZyZC0+b25saW5lLCBHRlBfS0VSTkVMKSkKKwlpZiAoIWFsbG9jX2NwdW1hc2tfdmFyKCZyZC0+b25saW5lLCBnZnApKQogCQlnb3RvIGZyZWVfc3BhbjsKLQlpZiAoIWFsbG9jX2NwdW1hc2tfdmFyKCZyZC0+cnRvX21hc2ssIEdGUF9LRVJORUwpKQorCWlmICghYWxsb2NfY3B1bWFza192YXIoJnJkLT5ydG9fbWFzaywgZ2ZwKSkKIAkJZ290byBmcmVlX29ubGluZTsKIAotCWlmIChjcHVwcmlfaW5pdCgmcmQtPmNwdXByaSwgZmFsc2UpICE9IDApCisJaWYgKGNwdXByaV9pbml0KCZyZC0+Y3B1cHJpLCBib290bWVtKSAhPSAwKQogCQlnb3RvIGZyZWVfcnRvX21hc2s7CiAJcmV0dXJuIDA7CiAKQEAgLTkxMjMsNyArOTE2Miw3IEBACiAJICogd2UgdXNlIGFsbG9jX2Jvb3RtZW0oKS4KIAkgKi8KIAlpZiAoYWxsb2Nfc2l6ZSkgewotCQlwdHIgPSAodW5zaWduZWQgbG9uZylhbGxvY19ib290bWVtKGFsbG9jX3NpemUpOworCQlwdHIgPSAodW5zaWduZWQgbG9uZylremFsbG9jKGFsbG9jX3NpemUsIEdGUF9OT1dBSVQpOwogCiAjaWZkZWYgQ09ORklHX0ZBSVJfR1JPVVBfU0NIRUQKIAkJaW5pdF90YXNrX2dyb3VwLnNlID0gKHN0cnVjdCBzY2hlZF9lbnRpdHkgKiopcHRyOwpAQCAtOTIxOCw3ICs5MjU3LDcgQEAKIAkJICogMTAyNCkgYW5kIHR3byBjaGlsZCBncm91cHMgQTAgYW5kIEExIChvZiB3ZWlnaHQgMTAyNCBlYWNoKSwKIAkJICogdGhlbiBBMCdzIHNoYXJlIG9mIHRoZSBjcHUgcmVzb3VyY2UgaXM6CiAJCSAqCi0JCSAqIAlBMCdzIGJhbmR3aWR0aCA9IDEwMjQgLyAoMTAqMTAyNCArIDEwMjQgKyAxMDI0KSA9IDguMzMlCisJCSAqCUEwJ3MgYmFuZHdpZHRoID0gMTAyNCAvICgxMCoxMDI0ICsgMTAyNCArIDEwMjQpID0gOC4zMyUKIAkJICoKIAkJICogV2UgYWNoaWV2ZSB0aGlzIGJ5IGxldHRpbmcgaW5pdF90YXNrX2dyb3VwJ3MgdGFza3Mgc2l0CiAJCSAqIGRpcmVjdGx5IGluIHJxLT5jZnMgKGkuZSBpbml0X3Rhc2tfZ3JvdXAtPnNlW10gPSBOVUxMKS4KQEAgLTkzMTQsMTUgKzkzNTMsMTcgQEAKIAljdXJyZW50LT5zY2hlZF9jbGFzcyA9ICZmYWlyX3NjaGVkX2NsYXNzOwogCiAJLyogQWxsb2NhdGUgdGhlIG5vaHpfY3B1X21hc2sgaWYgQ09ORklHX0NQVU1BU0tfT0ZGU1RBQ0sgKi8KLQlhbGxvY19ib290bWVtX2NwdW1hc2tfdmFyKCZub2h6X2NwdV9tYXNrKTsKKwlhbGxvY19jcHVtYXNrX3Zhcigmbm9oel9jcHVfbWFzaywgR0ZQX05PV0FJVCk7CiAjaWZkZWYgQ09ORklHX1NNUAogI2lmZGVmIENPTkZJR19OT19IWgotCWFsbG9jX2Jvb3RtZW1fY3B1bWFza192YXIoJm5vaHouY3B1X21hc2spOwotCWFsbG9jX2Jvb3RtZW1fY3B1bWFza192YXIoJm5vaHouaWxiX2dycF9ub2h6X21hc2spOworCWFsbG9jX2NwdW1hc2tfdmFyKCZub2h6LmNwdV9tYXNrLCBHRlBfTk9XQUlUKTsKKwlhbGxvY19jcHVtYXNrX3Zhcigmbm9oei5pbGJfZ3JwX25vaHpfbWFzaywgR0ZQX05PV0FJVCk7CiAjZW5kaWYKLQlhbGxvY19ib290bWVtX2NwdW1hc2tfdmFyKCZjcHVfaXNvbGF0ZWRfbWFwKTsKKwlhbGxvY19jcHVtYXNrX3ZhcigmY3B1X2lzb2xhdGVkX21hcCwgR0ZQX05PV0FJVCk7CiAjZW5kaWYgLyogU01QICovCiAKKwlwZXJmX2NvdW50ZXJfaW5pdCgpOworCiAJc2NoZWR1bGVyX3J1bm5pbmcgPSAxOwogfQogCmRpZmYgLS1naXQgYS9rZXJuZWwvc2NoZWRfY3B1cHJpLmMgYi9rZXJuZWwvc2NoZWRfY3B1cHJpLmMKaW5kZXggMzQ0NzEyYS4uN2RlZmZjOSAxMDA2NDQKLS0tIGEva2VybmVsL3NjaGVkX2NwdXByaS5jCisrKyBiL2tlcm5lbC9zY2hlZF9jcHVwcmkuYwpAQCAtMTU0LDggKzE1NCwxMiBAQAogICovCiBpbnQgX19pbml0X3JlZm9rIGNwdXByaV9pbml0KHN0cnVjdCBjcHVwcmkgKmNwLCBib29sIGJvb3RtZW0pCiB7CisJZ2ZwX3QgZ2ZwID0gR0ZQX0tFUk5FTDsKIAlpbnQgaTsKIAorCWlmIChib290bWVtKQorCQlnZnAgPSBHRlBfTk9XQUlUOworCiAJbWVtc2V0KGNwLCAwLCBzaXplb2YoKmNwKSk7CiAKIAlmb3IgKGkgPSAwOyBpIDwgQ1BVUFJJX05SX1BSSU9SSVRJRVM7IGkrKykgewpAQCAtMTYzLDkgKzE2Nyw3IEBACiAKIAkJc3Bpbl9sb2NrX2luaXQoJnZlYy0+bG9jayk7CiAJCXZlYy0+Y291bnQgPSAwOwotCQlpZiAoYm9vdG1lbSkKLQkJCWFsbG9jX2Jvb3RtZW1fY3B1bWFza192YXIoJnZlYy0+bWFzayk7Ci0JCWVsc2UgaWYgKCF6YWxsb2NfY3B1bWFza192YXIoJnZlYy0+bWFzaywgR0ZQX0tFUk5FTCkpCisJCWlmICghemFsbG9jX2NwdW1hc2tfdmFyKCZ2ZWMtPm1hc2ssIGdmcCkpCiAJCQlnb3RvIGNsZWFudXA7CiAJfQogCmRpZmYgLS1naXQgYS9rZXJuZWwvc2xvdy13b3JrLmMgYi9rZXJuZWwvc2xvdy13b3JrLmMKaW5kZXggYjI4ZDE5MTMuLjUyMWVkMjAgMTAwNjQ0Ci0tLSBhL2tlcm5lbC9zbG93LXdvcmsuYworKysgYi9rZXJuZWwvc2xvdy13b3JrLmMKQEAgLTM3Miw4ICszNzIsOCBAQAogCQl2c21heCAqPSBhdG9taWNfcmVhZCgmc2xvd193b3JrX3RocmVhZF9jb3VudCk7CiAJCXZzbWF4IC89IDEwMDsKIAotCQlwcmVwYXJlX3RvX3dhaXQoJnNsb3dfd29ya190aHJlYWRfd3EsICZ3YWl0LAotCQkJCVRBU0tfSU5URVJSVVBUSUJMRSk7CisJCXByZXBhcmVfdG9fd2FpdF9leGNsdXNpdmUoJnNsb3dfd29ya190aHJlYWRfd3EsICZ3YWl0LAorCQkJCQkgIFRBU0tfSU5URVJSVVBUSUJMRSk7CiAJCWlmICghZnJlZXppbmcoY3VycmVudCkgJiYKIAkJICAgICFzbG93X3dvcmtfdGhyZWFkc19zaG91bGRfZXhpdCAmJgogCQkgICAgIXNsb3dfd29ya19hdmFpbGFibGUodnNtYXgpICYmCmRpZmYgLS1naXQgYS9rZXJuZWwvc3lzLmMgYi9rZXJuZWwvc3lzLmMKaW5kZXggZTc5OThjZi4uNDM4ZDk5YSAxMDA2NDQKLS0tIGEva2VybmVsL3N5cy5jCisrKyBiL2tlcm5lbC9zeXMuYwpAQCAtMTQsNiArMTQsNyBAQAogI2luY2x1ZGUgPGxpbnV4L3ByY3RsLmg+CiAjaW5jbHVkZSA8bGludXgvaGlnaHVpZC5oPgogI2luY2x1ZGUgPGxpbnV4L2ZzLmg+CisjaW5jbHVkZSA8bGludXgvcGVyZl9jb3VudGVyLmg+CiAjaW5jbHVkZSA8bGludXgvcmVzb3VyY2UuaD4KICNpbmNsdWRlIDxsaW51eC9rZXJuZWwuaD4KICNpbmNsdWRlIDxsaW51eC9rZXhlYy5oPgpAQCAtMTc5Myw2ICsxNzk0LDEyIEBACiAJCWNhc2UgUFJfU0VUX1RTQzoKIAkJCWVycm9yID0gU0VUX1RTQ19DVEwoYXJnMik7CiAJCQlicmVhazsKKwkJY2FzZSBQUl9UQVNLX1BFUkZfQ09VTlRFUlNfRElTQUJMRToKKwkJCWVycm9yID0gcGVyZl9jb3VudGVyX3Rhc2tfZGlzYWJsZSgpOworCQkJYnJlYWs7CisJCWNhc2UgUFJfVEFTS19QRVJGX0NPVU5URVJTX0VOQUJMRToKKwkJCWVycm9yID0gcGVyZl9jb3VudGVyX3Rhc2tfZW5hYmxlKCk7CisJCQlicmVhazsKIAkJY2FzZSBQUl9HRVRfVElNRVJTTEFDSzoKIAkJCWVycm9yID0gY3VycmVudC0+dGltZXJfc2xhY2tfbnM7CiAJCQlicmVhazsKZGlmZiAtLWdpdCBhL2tlcm5lbC9zeXNfbmkuYyBiL2tlcm5lbC9zeXNfbmkuYwppbmRleCAyN2RhZDI5Li42ODMyMGY2IDEwMDY0NAotLS0gYS9rZXJuZWwvc3lzX25pLmMKKysrIGIva2VybmVsL3N5c19uaS5jCkBAIC0xNzUsMyArMTc1LDYgQEAKIGNvbmRfc3lzY2FsbChjb21wYXRfc3lzX3RpbWVyZmRfZ2V0dGltZSk7CiBjb25kX3N5c2NhbGwoc3lzX2V2ZW50ZmQpOwogY29uZF9zeXNjYWxsKHN5c19ldmVudGZkMik7CisKKy8qIHBlcmZvcm1hbmNlIGNvdW50ZXJzOiAqLworY29uZF9zeXNjYWxsKHN5c19wZXJmX2NvdW50ZXJfb3Blbik7CmRpZmYgLS1naXQgYS9rZXJuZWwvc3lzY3RsLmMgYi9rZXJuZWwvc3lzY3RsLmMKaW5kZXggOTQ0YmEwMy4uY2U2NjRmOSAxMDA2NDQKLS0tIGEva2VybmVsL3N5c2N0bC5jCisrKyBiL2tlcm5lbC9zeXNjdGwuYwpAQCAtNDksNiArNDksNyBAQAogI2luY2x1ZGUgPGxpbnV4L3JlYm9vdC5oPgogI2luY2x1ZGUgPGxpbnV4L2Z0cmFjZS5oPgogI2luY2x1ZGUgPGxpbnV4L3Nsb3ctd29yay5oPgorI2luY2x1ZGUgPGxpbnV4L3BlcmZfY291bnRlci5oPgogCiAjaW5jbHVkZSA8YXNtL3VhY2Nlc3MuaD4KICNpbmNsdWRlIDxhc20vcHJvY2Vzc29yLmg+CkBAIC05MzIsNiArOTMzLDMyIEBACiAJCS5jaGlsZAkJPSBzbG93X3dvcmtfc3lzY3RscywKIAl9LAogI2VuZGlmCisjaWZkZWYgQ09ORklHX1BFUkZfQ09VTlRFUlMKKwl7CisJCS5jdGxfbmFtZQk9IENUTF9VTk5VTUJFUkVELAorCQkucHJvY25hbWUJPSAicGVyZl9jb3VudGVyX3BhcmFub2lkIiwKKwkJLmRhdGEJCT0gJnN5c2N0bF9wZXJmX2NvdW50ZXJfcGFyYW5vaWQsCisJCS5tYXhsZW4JCT0gc2l6ZW9mKHN5c2N0bF9wZXJmX2NvdW50ZXJfcGFyYW5vaWQpLAorCQkubW9kZQkJPSAwNjQ0LAorCQkucHJvY19oYW5kbGVyCT0gJnByb2NfZG9pbnR2ZWMsCisJfSwKKwl7CisJCS5jdGxfbmFtZQk9IENUTF9VTk5VTUJFUkVELAorCQkucHJvY25hbWUJPSAicGVyZl9jb3VudGVyX21sb2NrX2tiIiwKKwkJLmRhdGEJCT0gJnN5c2N0bF9wZXJmX2NvdW50ZXJfbWxvY2ssCisJCS5tYXhsZW4JCT0gc2l6ZW9mKHN5c2N0bF9wZXJmX2NvdW50ZXJfbWxvY2spLAorCQkubW9kZQkJPSAwNjQ0LAorCQkucHJvY19oYW5kbGVyCT0gJnByb2NfZG9pbnR2ZWMsCisJfSwKKwl7CisJCS5jdGxfbmFtZQk9IENUTF9VTk5VTUJFUkVELAorCQkucHJvY25hbWUJPSAicGVyZl9jb3VudGVyX21heF9zYW1wbGVfcmF0ZSIsCisJCS5kYXRhCQk9ICZzeXNjdGxfcGVyZl9jb3VudGVyX3NhbXBsZV9yYXRlLAorCQkubWF4bGVuCQk9IHNpemVvZihzeXNjdGxfcGVyZl9jb3VudGVyX3NhbXBsZV9yYXRlKSwKKwkJLm1vZGUJCT0gMDY0NCwKKwkJLnByb2NfaGFuZGxlcgk9ICZwcm9jX2RvaW50dmVjLAorCX0sCisjZW5kaWYKIC8qCiAgKiBOT1RFOiBkbyBub3QgYWRkIG5ldyBlbnRyaWVzIHRvIHRoaXMgdGFibGUgdW5sZXNzIHlvdSBoYXZlIHJlYWQKICAqIERvY3VtZW50YXRpb24vc3lzY3RsL2N0bF91bm51bWJlcmVkLnR4dApkaWZmIC0tZ2l0IGEva2VybmVsL3RpbWVyLmMgYi9rZXJuZWwvdGltZXIuYwppbmRleCBhMjZlZDI5Li5jMDFlNTY4IDEwMDY0NAotLS0gYS9rZXJuZWwvdGltZXIuYworKysgYi9rZXJuZWwvdGltZXIuYwpAQCAtMzcsNiArMzcsNyBAQAogI2luY2x1ZGUgPGxpbnV4L2RlbGF5Lmg+CiAjaW5jbHVkZSA8bGludXgvdGljay5oPgogI2luY2x1ZGUgPGxpbnV4L2thbGxzeW1zLmg+CisjaW5jbHVkZSA8bGludXgvcGVyZl9jb3VudGVyLmg+CiAKICNpbmNsdWRlIDxhc20vdWFjY2Vzcy5oPgogI2luY2x1ZGUgPGFzbS91bmlzdGQuaD4KQEAgLTExMjksNiArMTEzMCw4IEBACiB7CiAJc3RydWN0IHR2ZWNfYmFzZSAqYmFzZSA9IF9fZ2V0X2NwdV92YXIodHZlY19iYXNlcyk7CiAKKwlwZXJmX2NvdW50ZXJfZG9fcGVuZGluZygpOworCiAJaHJ0aW1lcl9ydW5fcGVuZGluZygpOwogCiAJaWYgKHRpbWVfYWZ0ZXJfZXEoamlmZmllcywgYmFzZS0+dGltZXJfamlmZmllcykpCmRpZmYgLS1naXQgYS9saWIvS2NvbmZpZy5kZWJ1ZyBiL2xpYi9LY29uZmlnLmRlYnVnCmluZGV4IDZjZGNmMzguLjExNmEzNTAgMTAwNjQ0Ci0tLSBhL2xpYi9LY29uZmlnLmRlYnVnCisrKyBiL2xpYi9LY29uZmlnLmRlYnVnCkBAIC0zMzYsNiArMzM2LDM4IEBACiAJICBvdXQgd2hpY2ggc2xhYnMgYXJlIHJlbGV2YW50IHRvIGEgcGFydGljdWxhciBsb2FkLgogCSAgVHJ5IHJ1bm5pbmc6IHNsYWJpbmZvIC1EQQogCitjb25maWcgREVCVUdfS01FTUxFQUsKKwlib29sICJLZXJuZWwgbWVtb3J5IGxlYWsgZGV0ZWN0b3IiCisJZGVwZW5kcyBvbiBERUJVR19LRVJORUwgJiYgRVhQRVJJTUVOVEFMICYmIChYODYgfHwgQVJNKSAmJiBcCisJCSFNRU1PUllfSE9UUExVRworCXNlbGVjdCBERUJVR19TTEFCIGlmIFNMQUIKKwlzZWxlY3QgU0xVQl9ERUJVRyBpZiBTTFVCCisJc2VsZWN0IERFQlVHX0ZTIGlmIFNZU0ZTCisJc2VsZWN0IFNUQUNLVFJBQ0UgaWYgU1RBQ0tUUkFDRV9TVVBQT1JUCisJc2VsZWN0IEtBTExTWU1TCisJaGVscAorCSAgU2F5IFkgaGVyZSBpZiB5b3Ugd2FudCB0byBlbmFibGUgdGhlIG1lbW9yeSBsZWFrCisJICBkZXRlY3Rvci4gVGhlIG1lbW9yeSBhbGxvY2F0aW9uL2ZyZWVpbmcgaXMgdHJhY2VkIGluIGEgd2F5CisJICBzaW1pbGFyIHRvIHRoZSBCb2VobSdzIGNvbnNlcnZhdGl2ZSBnYXJiYWdlIGNvbGxlY3RvciwgdGhlCisJICBkaWZmZXJlbmNlIGJlaW5nIHRoYXQgdGhlIG9ycGhhbiBvYmplY3RzIGFyZSBub3QgZnJlZWQgYnV0CisJICBvbmx5IHNob3duIGluIC9zeXMva2VybmVsL2RlYnVnL2ttZW1sZWFrLiBFbmFibGluZyB0aGlzCisJICBmZWF0dXJlIHdpbGwgaW50cm9kdWNlIGFuIG92ZXJoZWFkIHRvIG1lbW9yeQorCSAgYWxsb2NhdGlvbnMuIFNlZSBEb2N1bWVudGF0aW9uL2ttZW1sZWFrLnR4dCBmb3IgbW9yZQorCSAgZGV0YWlscy4KKworCSAgSW4gb3JkZXIgdG8gYWNjZXNzIHRoZSBrbWVtbGVhayBmaWxlLCBkZWJ1Z2ZzIG5lZWRzIHRvIGJlCisJICBtb3VudGVkICh1c3VhbGx5IGF0IC9zeXMva2VybmVsL2RlYnVnKS4KKworY29uZmlnIERFQlVHX0tNRU1MRUFLX1RFU1QKKwl0cmlzdGF0ZSAiU2ltcGxlIHRlc3QgZm9yIHRoZSBrZXJuZWwgbWVtb3J5IGxlYWsgZGV0ZWN0b3IiCisJZGVwZW5kcyBvbiBERUJVR19LTUVNTEVBSworCWhlbHAKKwkgIFNheSBZIG9yIE0gaGVyZSB0byBidWlsZCBhIHRlc3QgZm9yIHRoZSBrZXJuZWwgbWVtb3J5IGxlYWsKKwkgIGRldGVjdG9yLiBUaGlzIG9wdGlvbiBlbmFibGVzIGEgbW9kdWxlIHRoYXQgZXhwbGljaXRseSBsZWFrcworCSAgbWVtb3J5LgorCisJICBJZiB1bnN1cmUsIHNheSBOLgorCiBjb25maWcgREVCVUdfUFJFRU1QVAogCWJvb2wgIkRlYnVnIHByZWVtcHRpYmxlIGtlcm5lbCIKIAlkZXBlbmRzIG9uIERFQlVHX0tFUk5FTCAmJiBQUkVFTVBUICYmIChUUkFDRV9JUlFGTEFHU19TVVBQT1JUIHx8IFBQQzY0KQpkaWZmIC0tZ2l0IGEvbGliL2NwdW1hc2suYyBiL2xpYi9jcHVtYXNrLmMKaW5kZXggZWIyM2FhYS4uN2JiNDE0MiAxMDA2NDQKLS0tIGEvbGliL2NwdW1hc2suYworKysgYi9saWIvY3B1bWFzay5jCkBAIC05MiwxNSArOTIsOCBAQAogICovCiBib29sIGFsbG9jX2NwdW1hc2tfdmFyX25vZGUoY3B1bWFza192YXJfdCAqbWFzaywgZ2ZwX3QgZmxhZ3MsIGludCBub2RlKQogewotCWlmIChsaWtlbHkoc2xhYl9pc19hdmFpbGFibGUoKSkpCi0JCSptYXNrID0ga21hbGxvY19ub2RlKGNwdW1hc2tfc2l6ZSgpLCBmbGFncywgbm9kZSk7Ci0JZWxzZSB7Ci0jaWZkZWYgQ09ORklHX0RFQlVHX1BFUl9DUFVfTUFQUwotCQlwcmludGsoS0VSTl9FUlIKLQkJCSI9PiBhbGxvY19jcHVtYXNrX3Zhcjoga21hbGxvYyBub3QgYXZhaWxhYmxlIVxuIik7Ci0jZW5kaWYKLQkJKm1hc2sgPSBOVUxMOwotCX0KKwkqbWFzayA9IGttYWxsb2Nfbm9kZShjcHVtYXNrX3NpemUoKSwgZmxhZ3MsIG5vZGUpOworCiAjaWZkZWYgQ09ORklHX0RFQlVHX1BFUl9DUFVfTUFQUwogCWlmICghKm1hc2spIHsKIAkJcHJpbnRrKEtFUk5fRVJSICI9PiBhbGxvY19jcHVtYXNrX3ZhcjogZmFpbGVkIVxuIik7CmRpZmYgLS1naXQgYS9tbS9NYWtlZmlsZSBiL21tL01ha2VmaWxlCmluZGV4IGVjNzNjNjguLmU4OWFjYjAgMTAwNjQ0Ci0tLSBhL21tL01ha2VmaWxlCisrKyBiL21tL01ha2VmaWxlCkBAIC0zOCwzICszOCw1IEBACiBlbmRpZgogb2JqLSQoQ09ORklHX1FVSUNLTElTVCkgKz0gcXVpY2tsaXN0Lm8KIG9iai0kKENPTkZJR19DR1JPVVBfTUVNX1JFU19DVExSKSArPSBtZW1jb250cm9sLm8gcGFnZV9jZ3JvdXAubworb2JqLSQoQ09ORklHX0RFQlVHX0tNRU1MRUFLKSArPSBrbWVtbGVhay5vCitvYmotJChDT05GSUdfREVCVUdfS01FTUxFQUtfVEVTVCkgKz0ga21lbWxlYWstdGVzdC5vCmRpZmYgLS1naXQgYS9tbS9ib290bWVtLmMgYi9tbS9ib290bWVtLmMKaW5kZXggZGFmOTI3MS4uMjgyZGYwYSAxMDA2NDQKLS0tIGEvbW0vYm9vdG1lbS5jCisrKyBiL21tL2Jvb3RtZW0uYwpAQCAtNTMyLDYgKzUzMiw5IEBACiAJCQkJCXVuc2lnbmVkIGxvbmcgc2l6ZSwgdW5zaWduZWQgbG9uZyBhbGlnbiwKIAkJCQkJdW5zaWduZWQgbG9uZyBnb2FsLCB1bnNpZ25lZCBsb25nIGxpbWl0KQogeworCWlmIChXQVJOX09OX09OQ0Uoc2xhYl9pc19hdmFpbGFibGUoKSkpCisJCXJldHVybiBremFsbG9jKHNpemUsIEdGUF9OT1dBSVQpOworCiAjaWZkZWYgQ09ORklHX0hBVkVfQVJDSF9CT09UTUVNCiAJYm9vdG1lbV9kYXRhX3QgKnBfYmRhdGE7CiAKQEAgLTY2Miw2ICs2NjUsOSBAQAogdm9pZCAqIF9faW5pdCBfX2FsbG9jX2Jvb3RtZW1fbm9kZShwZ19kYXRhX3QgKnBnZGF0LCB1bnNpZ25lZCBsb25nIHNpemUsCiAJCQkJICAgdW5zaWduZWQgbG9uZyBhbGlnbiwgdW5zaWduZWQgbG9uZyBnb2FsKQogeworCWlmIChXQVJOX09OX09OQ0Uoc2xhYl9pc19hdmFpbGFibGUoKSkpCisJCXJldHVybiBremFsbG9jX25vZGUoc2l6ZSwgR0ZQX05PV0FJVCwgcGdkYXQtPm5vZGVfaWQpOworCiAJcmV0dXJuIF9fX2FsbG9jX2Jvb3RtZW1fbm9kZShwZ2RhdC0+YmRhdGEsIHNpemUsIGFsaWduLCBnb2FsLCAwKTsKIH0KIApAQCAtNjkzLDYgKzY5OSw5IEBACiB7CiAJdm9pZCAqcHRyOwogCisJaWYgKFdBUk5fT05fT05DRShzbGFiX2lzX2F2YWlsYWJsZSgpKSkKKwkJcmV0dXJuIGt6YWxsb2Nfbm9kZShzaXplLCBHRlBfTk9XQUlULCBwZ2RhdC0+bm9kZV9pZCk7CisKIAlwdHIgPSBhbGxvY19hcmNoX3ByZWZlcnJlZF9ib290bWVtKHBnZGF0LT5iZGF0YSwgc2l6ZSwgYWxpZ24sIGdvYWwsIDApOwogCWlmIChwdHIpCiAJCXJldHVybiBwdHI7CkBAIC03NDUsNiArNzU0LDkgQEAKIHZvaWQgKiBfX2luaXQgX19hbGxvY19ib290bWVtX2xvd19ub2RlKHBnX2RhdGFfdCAqcGdkYXQsIHVuc2lnbmVkIGxvbmcgc2l6ZSwKIAkJCQkgICAgICAgdW5zaWduZWQgbG9uZyBhbGlnbiwgdW5zaWduZWQgbG9uZyBnb2FsKQogeworCWlmIChXQVJOX09OX09OQ0Uoc2xhYl9pc19hdmFpbGFibGUoKSkpCisJCXJldHVybiBremFsbG9jX25vZGUoc2l6ZSwgR0ZQX05PV0FJVCwgcGdkYXQtPm5vZGVfaWQpOworCiAJcmV0dXJuIF9fX2FsbG9jX2Jvb3RtZW1fbm9kZShwZ2RhdC0+YmRhdGEsIHNpemUsIGFsaWduLAogCQkJCWdvYWwsIEFSQ0hfTE9XX0FERFJFU1NfTElNSVQpOwogfQpkaWZmIC0tZ2l0IGEvbW0va21lbWxlYWstdGVzdC5jIGIvbW0va21lbWxlYWstdGVzdC5jCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLmQ1MjkyZmMKLS0tIC9kZXYvbnVsbAorKysgYi9tbS9rbWVtbGVhay10ZXN0LmMKQEAgLTAsMCArMSwxMTEgQEAKKy8qCisgKiBtbS9rbWVtbGVhay10ZXN0LmMKKyAqCisgKiBDb3B5cmlnaHQgKEMpIDIwMDggQVJNIExpbWl0ZWQKKyAqIFdyaXR0ZW4gYnkgQ2F0YWxpbiBNYXJpbmFzIDxjYXRhbGluLm1hcmluYXNAYXJtLmNvbT4KKyAqCisgKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeQorICogaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSB2ZXJzaW9uIDIgYXMKKyAqIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uLgorICoKKyAqIFRoaXMgcHJvZ3JhbSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLAorICogYnV0IFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKKyAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUKKyAqIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCisgKgorICogWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29weSBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UKKyAqIGFsb25nIHdpdGggdGhpcyBwcm9ncmFtOyBpZiBub3QsIHdyaXRlIHRvIHRoZSBGcmVlIFNvZnR3YXJlCisgKiBGb3VuZGF0aW9uLCBJbmMuLCA1OSBUZW1wbGUgUGxhY2UsIFN1aXRlIDMzMCwgQm9zdG9uLCBNQSAwMjExMS0xMzA3IFVTQQorICovCisKKyNpbmNsdWRlIDxsaW51eC9pbml0Lmg+CisjaW5jbHVkZSA8bGludXgva2VybmVsLmg+CisjaW5jbHVkZSA8bGludXgvbW9kdWxlLmg+CisjaW5jbHVkZSA8bGludXgvc2xhYi5oPgorI2luY2x1ZGUgPGxpbnV4L3ZtYWxsb2MuaD4KKyNpbmNsdWRlIDxsaW51eC9saXN0Lmg+CisjaW5jbHVkZSA8bGludXgvcGVyY3B1Lmg+CisjaW5jbHVkZSA8bGludXgvZmR0YWJsZS5oPgorCisjaW5jbHVkZSA8bGludXgva21lbWxlYWsuaD4KKworc3RydWN0IHRlc3Rfbm9kZSB7CisJbG9uZyBoZWFkZXJbMjVdOworCXN0cnVjdCBsaXN0X2hlYWQgbGlzdDsKKwlsb25nIGZvb3RlclsyNV07Cit9OworCitzdGF0aWMgTElTVF9IRUFEKHRlc3RfbGlzdCk7CitzdGF0aWMgREVGSU5FX1BFUl9DUFUodm9pZCAqLCB0ZXN0X3BvaW50ZXIpOworCisvKgorICogU29tZSB2ZXJ5IHNpbXBsZSB0ZXN0aW5nLiBUaGlzIGZ1bmN0aW9uIG5lZWRzIHRvIGJlIGV4dGVuZGVkIGZvcgorICogcHJvcGVyIHRlc3RpbmcuCisgKi8KK3N0YXRpYyBpbnQgX19pbml0IGttZW1sZWFrX3Rlc3RfaW5pdCh2b2lkKQoreworCXN0cnVjdCB0ZXN0X25vZGUgKmVsZW07CisJaW50IGk7CisKKwlwcmludGsoS0VSTl9JTkZPICJLbWVtbGVhayB0ZXN0aW5nXG4iKTsKKworCS8qIG1ha2Ugc29tZSBvcnBoYW4gb2JqZWN0cyAqLworCXByX2luZm8oImttZW1sZWFrOiBrbWFsbG9jKDMyKSA9ICVwXG4iLCBrbWFsbG9jKDMyLCBHRlBfS0VSTkVMKSk7CisJcHJfaW5mbygia21lbWxlYWs6IGttYWxsb2MoMzIpID0gJXBcbiIsIGttYWxsb2MoMzIsIEdGUF9LRVJORUwpKTsKKwlwcl9pbmZvKCJrbWVtbGVhazoga21hbGxvYygxMDI0KSA9ICVwXG4iLCBrbWFsbG9jKDEwMjQsIEdGUF9LRVJORUwpKTsKKwlwcl9pbmZvKCJrbWVtbGVhazoga21hbGxvYygxMDI0KSA9ICVwXG4iLCBrbWFsbG9jKDEwMjQsIEdGUF9LRVJORUwpKTsKKwlwcl9pbmZvKCJrbWVtbGVhazoga21hbGxvYygyMDQ4KSA9ICVwXG4iLCBrbWFsbG9jKDIwNDgsIEdGUF9LRVJORUwpKTsKKwlwcl9pbmZvKCJrbWVtbGVhazoga21hbGxvYygyMDQ4KSA9ICVwXG4iLCBrbWFsbG9jKDIwNDgsIEdGUF9LRVJORUwpKTsKKwlwcl9pbmZvKCJrbWVtbGVhazoga21hbGxvYyg0MDk2KSA9ICVwXG4iLCBrbWFsbG9jKDQwOTYsIEdGUF9LRVJORUwpKTsKKwlwcl9pbmZvKCJrbWVtbGVhazoga21hbGxvYyg0MDk2KSA9ICVwXG4iLCBrbWFsbG9jKDQwOTYsIEdGUF9LRVJORUwpKTsKKyNpZm5kZWYgQ09ORklHX01PRFVMRVMKKwlwcl9pbmZvKCJrbWVtbGVhazoga21lbV9jYWNoZV9hbGxvYyhmaWxlc19jYWNoZXApID0gJXBcbiIsCisJCWttZW1fY2FjaGVfYWxsb2MoZmlsZXNfY2FjaGVwLCBHRlBfS0VSTkVMKSk7CisJcHJfaW5mbygia21lbWxlYWs6IGttZW1fY2FjaGVfYWxsb2MoZmlsZXNfY2FjaGVwKSA9ICVwXG4iLAorCQlrbWVtX2NhY2hlX2FsbG9jKGZpbGVzX2NhY2hlcCwgR0ZQX0tFUk5FTCkpOworI2VuZGlmCisJcHJfaW5mbygia21lbWxlYWs6IHZtYWxsb2MoNjQpID0gJXBcbiIsIHZtYWxsb2MoNjQpKTsKKwlwcl9pbmZvKCJrbWVtbGVhazogdm1hbGxvYyg2NCkgPSAlcFxuIiwgdm1hbGxvYyg2NCkpOworCXByX2luZm8oImttZW1sZWFrOiB2bWFsbG9jKDY0KSA9ICVwXG4iLCB2bWFsbG9jKDY0KSk7CisJcHJfaW5mbygia21lbWxlYWs6IHZtYWxsb2MoNjQpID0gJXBcbiIsIHZtYWxsb2MoNjQpKTsKKwlwcl9pbmZvKCJrbWVtbGVhazogdm1hbGxvYyg2NCkgPSAlcFxuIiwgdm1hbGxvYyg2NCkpOworCisJLyoKKwkgKiBBZGQgZWxlbWVudHMgdG8gYSBsaXN0LiBUaGV5IHNob3VsZCBvbmx5IGFwcGVhciBhcyBvcnBoYW4KKwkgKiBhZnRlciB0aGUgbW9kdWxlIGlzIHJlbW92ZWQuCisJICovCisJZm9yIChpID0gMDsgaSA8IDEwOyBpKyspIHsKKwkJZWxlbSA9IGttYWxsb2Moc2l6ZW9mKCplbGVtKSwgR0ZQX0tFUk5FTCk7CisJCXByX2luZm8oImttZW1sZWFrOiBrbWFsbG9jKHNpemVvZigqZWxlbSkpID0gJXBcbiIsIGVsZW0pOworCQlpZiAoIWVsZW0pCisJCQlyZXR1cm4gLUVOT01FTTsKKwkJbWVtc2V0KGVsZW0sIDAsIHNpemVvZigqZWxlbSkpOworCQlJTklUX0xJU1RfSEVBRCgmZWxlbS0+bGlzdCk7CisKKwkJbGlzdF9hZGRfdGFpbCgmZWxlbS0+bGlzdCwgJnRlc3RfbGlzdCk7CisJfQorCisJZm9yX2VhY2hfcG9zc2libGVfY3B1KGkpIHsKKwkJcGVyX2NwdSh0ZXN0X3BvaW50ZXIsIGkpID0ga21hbGxvYygxMjksIEdGUF9LRVJORUwpOworCQlwcl9pbmZvKCJrbWVtbGVhazoga21hbGxvYygxMjkpID0gJXBcbiIsCisJCQlwZXJfY3B1KHRlc3RfcG9pbnRlciwgaSkpOworCX0KKworCXJldHVybiAwOworfQorbW9kdWxlX2luaXQoa21lbWxlYWtfdGVzdF9pbml0KTsKKworc3RhdGljIHZvaWQgX19leGl0IGttZW1sZWFrX3Rlc3RfZXhpdCh2b2lkKQoreworCXN0cnVjdCB0ZXN0X25vZGUgKmVsZW0sICp0bXA7CisKKwkvKgorCSAqIFJlbW92ZSB0aGUgbGlzdCBlbGVtZW50cyB3aXRob3V0IGFjdHVhbGx5IGZyZWVpbmcgdGhlCisJICogbWVtb3J5LgorCSAqLworCWxpc3RfZm9yX2VhY2hfZW50cnlfc2FmZShlbGVtLCB0bXAsICZ0ZXN0X2xpc3QsIGxpc3QpCisJCWxpc3RfZGVsKCZlbGVtLT5saXN0KTsKK30KK21vZHVsZV9leGl0KGttZW1sZWFrX3Rlc3RfZXhpdCk7CisKK01PRFVMRV9MSUNFTlNFKCJHUEwiKTsKZGlmZiAtLWdpdCBhL21tL2ttZW1sZWFrLmMgYi9tbS9rbWVtbGVhay5jCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjU4ZWM4NmMKLS0tIC9kZXYvbnVsbAorKysgYi9tbS9rbWVtbGVhay5jCkBAIC0wLDAgKzEsMTQ5OCBAQAorLyoKKyAqIG1tL2ttZW1sZWFrLmMKKyAqCisgKiBDb3B5cmlnaHQgKEMpIDIwMDggQVJNIExpbWl0ZWQKKyAqIFdyaXR0ZW4gYnkgQ2F0YWxpbiBNYXJpbmFzIDxjYXRhbGluLm1hcmluYXNAYXJtLmNvbT4KKyAqCisgKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeQorICogaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSB2ZXJzaW9uIDIgYXMKKyAqIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uLgorICoKKyAqIFRoaXMgcHJvZ3JhbSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLAorICogYnV0IFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKKyAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUKKyAqIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCisgKgorICogWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29weSBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UKKyAqIGFsb25nIHdpdGggdGhpcyBwcm9ncmFtOyBpZiBub3QsIHdyaXRlIHRvIHRoZSBGcmVlIFNvZnR3YXJlCisgKiBGb3VuZGF0aW9uLCBJbmMuLCA1OSBUZW1wbGUgUGxhY2UsIFN1aXRlIDMzMCwgQm9zdG9uLCBNQSAwMjExMS0xMzA3IFVTQQorICoKKyAqCisgKiBGb3IgbW9yZSBpbmZvcm1hdGlvbiBvbiB0aGUgYWxnb3JpdGhtIGFuZCBrbWVtbGVhayB1c2FnZSwgcGxlYXNlIHNlZQorICogRG9jdW1lbnRhdGlvbi9rbWVtbGVhay50eHQuCisgKgorICogTm90ZXMgb24gbG9ja2luZworICogLS0tLS0tLS0tLS0tLS0tLQorICoKKyAqIFRoZSBmb2xsb3dpbmcgbG9ja3MgYW5kIG11dGV4ZXMgYXJlIHVzZWQgYnkga21lbWxlYWs6CisgKgorICogLSBrbWVtbGVha19sb2NrIChyd2xvY2spOiBwcm90ZWN0cyB0aGUgb2JqZWN0X2xpc3QgbW9kaWZpY2F0aW9ucyBhbmQKKyAqICAgYWNjZXNzZXMgdG8gdGhlIG9iamVjdF90cmVlX3Jvb3QuIFRoZSBvYmplY3RfbGlzdCBpcyB0aGUgbWFpbiBsaXN0CisgKiAgIGhvbGRpbmcgdGhlIG1ldGFkYXRhIChzdHJ1Y3Qga21lbWxlYWtfb2JqZWN0KSBmb3IgdGhlIGFsbG9jYXRlZCBtZW1vcnkKKyAqICAgYmxvY2tzLiBUaGUgb2JqZWN0X3RyZWVfcm9vdCBpcyBhIHByaW9yaXR5IHNlYXJjaCB0cmVlIHVzZWQgdG8gbG9vay11cAorICogICBtZXRhZGF0YSBiYXNlZCBvbiBhIHBvaW50ZXIgdG8gdGhlIGNvcnJlc3BvbmRpbmcgbWVtb3J5IGJsb2NrLiAgVGhlCisgKiAgIGttZW1sZWFrX29iamVjdCBzdHJ1Y3R1cmVzIGFyZSBhZGRlZCB0byB0aGUgb2JqZWN0X2xpc3QgYW5kCisgKiAgIG9iamVjdF90cmVlX3Jvb3QgaW4gdGhlIGNyZWF0ZV9vYmplY3QoKSBmdW5jdGlvbiBjYWxsZWQgZnJvbSB0aGUKKyAqICAga21lbWxlYWtfYWxsb2MoKSBjYWxsYmFjayBhbmQgcmVtb3ZlZCBpbiBkZWxldGVfb2JqZWN0KCkgY2FsbGVkIGZyb20gdGhlCisgKiAgIGttZW1sZWFrX2ZyZWUoKSBjYWxsYmFjaworICogLSBrbWVtbGVha19vYmplY3QubG9jayAoc3BpbmxvY2spOiBwcm90ZWN0cyBhIGttZW1sZWFrX29iamVjdC4gQWNjZXNzZXMgdG8KKyAqICAgdGhlIG1ldGFkYXRhIChlLmcuIGNvdW50KSBhcmUgcHJvdGVjdGVkIGJ5IHRoaXMgbG9jay4gTm90ZSB0aGF0IHNvbWUKKyAqICAgbWVtYmVycyBvZiB0aGlzIHN0cnVjdHVyZSBtYXkgYmUgcHJvdGVjdGVkIGJ5IG90aGVyIG1lYW5zIChhdG9taWMgb3IKKyAqICAga21lbWxlYWtfbG9jaykuIFRoaXMgbG9jayBpcyBhbHNvIGhlbGQgd2hlbiBzY2FubmluZyB0aGUgY29ycmVzcG9uZGluZworICogICBtZW1vcnkgYmxvY2sgdG8gYXZvaWQgdGhlIGtlcm5lbCBmcmVlaW5nIGl0IHZpYSB0aGUga21lbWxlYWtfZnJlZSgpCisgKiAgIGNhbGxiYWNrLiBUaGlzIGlzIGxlc3MgaGVhdnl3ZWlnaHQgdGhhbiBob2xkaW5nIGEgZ2xvYmFsIGxvY2sgbGlrZQorICogICBrbWVtbGVha19sb2NrIGR1cmluZyBzY2FubmluZworICogLSBzY2FuX211dGV4IChtdXRleCk6IGVuc3VyZXMgdGhhdCBvbmx5IG9uZSB0aHJlYWQgbWF5IHNjYW4gdGhlIG1lbW9yeSBmb3IKKyAqICAgdW5yZWZlcmVuY2VkIG9iamVjdHMgYXQgYSB0aW1lLiBUaGUgZ3JheV9saXN0IGNvbnRhaW5zIHRoZSBvYmplY3RzIHdoaWNoCisgKiAgIGFyZSBhbHJlYWR5IHJlZmVyZW5jZWQgb3IgbWFya2VkIGFzIGZhbHNlIHBvc2l0aXZlcyBhbmQgbmVlZCB0byBiZQorICogICBzY2FubmVkLiBUaGlzIGxpc3QgaXMgb25seSBtb2RpZmllZCBkdXJpbmcgYSBzY2FubmluZyBlcGlzb2RlIHdoZW4gdGhlCisgKiAgIHNjYW5fbXV0ZXggaXMgaGVsZC4gQXQgdGhlIGVuZCBvZiBhIHNjYW4sIHRoZSBncmF5X2xpc3QgaXMgYWx3YXlzIGVtcHR5LgorICogICBOb3RlIHRoYXQgdGhlIGttZW1sZWFrX29iamVjdC51c2VfY291bnQgaXMgaW5jcmVtZW50ZWQgd2hlbiBhbiBvYmplY3QgaXMKKyAqICAgYWRkZWQgdG8gdGhlIGdyYXlfbGlzdCBhbmQgdGhlcmVmb3JlIGNhbm5vdCBiZSBmcmVlZAorICogLSBrbWVtbGVha19tdXRleCAobXV0ZXgpOiBwcmV2ZW50cyBtdWx0aXBsZSB1c2VycyBvZiB0aGUgImttZW1sZWFrIiBkZWJ1Z2ZzCisgKiAgIGZpbGUgdG9nZXRoZXIgd2l0aCBtb2RpZmljYXRpb25zIHRvIHRoZSBtZW1vcnkgc2Nhbm5pbmcgcGFyYW1ldGVycworICogICBpbmNsdWRpbmcgdGhlIHNjYW5fdGhyZWFkIHBvaW50ZXIKKyAqCisgKiBUaGUga21lbWxlYWtfb2JqZWN0IHN0cnVjdHVyZXMgaGF2ZSBhIHVzZV9jb3VudCBpbmNyZW1lbnRlZCBvciBkZWNyZW1lbnRlZAorICogdXNpbmcgdGhlIGdldF9vYmplY3QoKS9wdXRfb2JqZWN0KCkgZnVuY3Rpb25zLiBXaGVuIHRoZSB1c2VfY291bnQgYmVjb21lcworICogMCwgdGhpcyBjb3VudCBjYW4gbm8gbG9uZ2VyIGJlIGluY3JlbWVudGVkIGFuZCBwdXRfb2JqZWN0KCkgc2NoZWR1bGVzIHRoZQorICoga21lbWxlYWtfb2JqZWN0IGZyZWVpbmcgdmlhIGFuIFJDVSBjYWxsYmFjay4gQWxsIGNhbGxzIHRvIHRoZSBnZXRfb2JqZWN0KCkKKyAqIGZ1bmN0aW9uIG11c3QgYmUgcHJvdGVjdGVkIGJ5IHJjdV9yZWFkX2xvY2soKSB0byBhdm9pZCBhY2Nlc3NpbmcgYSBmcmVlZAorICogc3RydWN0dXJlLgorICovCisKKyNpbmNsdWRlIDxsaW51eC9pbml0Lmg+CisjaW5jbHVkZSA8bGludXgva2VybmVsLmg+CisjaW5jbHVkZSA8bGludXgvbGlzdC5oPgorI2luY2x1ZGUgPGxpbnV4L3NjaGVkLmg+CisjaW5jbHVkZSA8bGludXgvamlmZmllcy5oPgorI2luY2x1ZGUgPGxpbnV4L2RlbGF5Lmg+CisjaW5jbHVkZSA8bGludXgvbW9kdWxlLmg+CisjaW5jbHVkZSA8bGludXgva3RocmVhZC5oPgorI2luY2x1ZGUgPGxpbnV4L3ByaW9fdHJlZS5oPgorI2luY2x1ZGUgPGxpbnV4L2dmcC5oPgorI2luY2x1ZGUgPGxpbnV4L2ZzLmg+CisjaW5jbHVkZSA8bGludXgvZGVidWdmcy5oPgorI2luY2x1ZGUgPGxpbnV4L3NlcV9maWxlLmg+CisjaW5jbHVkZSA8bGludXgvY3B1bWFzay5oPgorI2luY2x1ZGUgPGxpbnV4L3NwaW5sb2NrLmg+CisjaW5jbHVkZSA8bGludXgvbXV0ZXguaD4KKyNpbmNsdWRlIDxsaW51eC9yY3VwZGF0ZS5oPgorI2luY2x1ZGUgPGxpbnV4L3N0YWNrdHJhY2UuaD4KKyNpbmNsdWRlIDxsaW51eC9jYWNoZS5oPgorI2luY2x1ZGUgPGxpbnV4L3BlcmNwdS5oPgorI2luY2x1ZGUgPGxpbnV4L2hhcmRpcnEuaD4KKyNpbmNsdWRlIDxsaW51eC9tbXpvbmUuaD4KKyNpbmNsdWRlIDxsaW51eC9zbGFiLmg+CisjaW5jbHVkZSA8bGludXgvdGhyZWFkX2luZm8uaD4KKyNpbmNsdWRlIDxsaW51eC9lcnIuaD4KKyNpbmNsdWRlIDxsaW51eC91YWNjZXNzLmg+CisjaW5jbHVkZSA8bGludXgvc3RyaW5nLmg+CisjaW5jbHVkZSA8bGludXgvbm9kZW1hc2suaD4KKyNpbmNsdWRlIDxsaW51eC9tbS5oPgorCisjaW5jbHVkZSA8YXNtL3NlY3Rpb25zLmg+CisjaW5jbHVkZSA8YXNtL3Byb2Nlc3Nvci5oPgorI2luY2x1ZGUgPGFzbS9hdG9taWMuaD4KKworI2luY2x1ZGUgPGxpbnV4L2ttZW1sZWFrLmg+CisKKy8qCisgKiBLbWVtbGVhayBjb25maWd1cmF0aW9uIGFuZCBjb21tb24gZGVmaW5lcy4KKyAqLworI2RlZmluZSBNQVhfVFJBQ0UJCTE2CS8qIHN0YWNrIHRyYWNlIGxlbmd0aCAqLworI2RlZmluZSBSRVBPUlRTX05SCQk1MAkvKiBtYXhpbXVtIG51bWJlciBvZiByZXBvcnRlZCBsZWFrcyAqLworI2RlZmluZSBNU0VDU19NSU5fQUdFCQk1MDAwCS8qIG1pbmltdW0gb2JqZWN0IGFnZSBmb3IgcmVwb3J0aW5nICovCisjZGVmaW5lIE1TRUNTX1NDQU5fWUlFTEQJMTAJLyogQ1BVIHlpZWxkaW5nIHBlcmlvZCAqLworI2RlZmluZSBTRUNTX0ZJUlNUX1NDQU4JCTYwCS8qIGRlbGF5IGJlZm9yZSB0aGUgZmlyc3Qgc2NhbiAqLworI2RlZmluZSBTRUNTX1NDQU5fV0FJVAkJNjAwCS8qIHN1YnNlcXVlbnQgYXV0byBzY2FubmluZyBkZWxheSAqLworCisjZGVmaW5lIEJZVEVTX1BFUl9QT0lOVEVSCXNpemVvZih2b2lkICopCisKKy8qIHNjYW5uaW5nIGFyZWEgaW5zaWRlIGEgbWVtb3J5IGJsb2NrICovCitzdHJ1Y3Qga21lbWxlYWtfc2Nhbl9hcmVhIHsKKwlzdHJ1Y3QgaGxpc3Rfbm9kZSBub2RlOworCXVuc2lnbmVkIGxvbmcgb2Zmc2V0OworCXNpemVfdCBsZW5ndGg7Cit9OworCisvKgorICogU3RydWN0dXJlIGhvbGRpbmcgdGhlIG1ldGFkYXRhIGZvciBlYWNoIGFsbG9jYXRlZCBtZW1vcnkgYmxvY2suCisgKiBNb2RpZmljYXRpb25zIHRvIHN1Y2ggb2JqZWN0cyBzaG91bGQgYmUgbWFkZSB3aGlsZSBob2xkaW5nIHRoZQorICogb2JqZWN0LT5sb2NrLiBJbnNlcnRpb25zIG9yIGRlbGV0aW9ucyBmcm9tIG9iamVjdF9saXN0LCBncmF5X2xpc3Qgb3IKKyAqIHRyZWVfbm9kZSBhcmUgYWxyZWFkeSBwcm90ZWN0ZWQgYnkgdGhlIGNvcnJlc3BvbmRpbmcgbG9ja3Mgb3IgbXV0ZXggKHNlZQorICogdGhlIG5vdGVzIG9uIGxvY2tpbmcgYWJvdmUpLiBUaGVzZSBvYmplY3RzIGFyZSByZWZlcmVuY2UtY291bnRlZAorICogKHVzZV9jb3VudCkgYW5kIGZyZWVkIHVzaW5nIHRoZSBSQ1UgbWVjaGFuaXNtLgorICovCitzdHJ1Y3Qga21lbWxlYWtfb2JqZWN0IHsKKwlzcGlubG9ja190IGxvY2s7CisJdW5zaWduZWQgbG9uZyBmbGFnczsJCS8qIG9iamVjdCBzdGF0dXMgZmxhZ3MgKi8KKwlzdHJ1Y3QgbGlzdF9oZWFkIG9iamVjdF9saXN0OworCXN0cnVjdCBsaXN0X2hlYWQgZ3JheV9saXN0OworCXN0cnVjdCBwcmlvX3RyZWVfbm9kZSB0cmVlX25vZGU7CisJc3RydWN0IHJjdV9oZWFkIHJjdTsJCS8qIG9iamVjdF9saXN0IGxvY2tsZXNzIHRyYXZlcnNhbCAqLworCS8qIG9iamVjdCB1c2FnZSBjb3VudDsgb2JqZWN0IGZyZWVkIHdoZW4gdXNlX2NvdW50ID09IDAgKi8KKwlhdG9taWNfdCB1c2VfY291bnQ7CisJdW5zaWduZWQgbG9uZyBwb2ludGVyOworCXNpemVfdCBzaXplOworCS8qIG1pbmltdW0gbnVtYmVyIG9mIGEgcG9pbnRlcnMgZm91bmQgYmVmb3JlIGl0IGlzIGNvbnNpZGVyZWQgbGVhayAqLworCWludCBtaW5fY291bnQ7CisJLyogdGhlIHRvdGFsIG51bWJlciBvZiBwb2ludGVycyBmb3VuZCBwb2ludGluZyB0byB0aGlzIG9iamVjdCAqLworCWludCBjb3VudDsKKwkvKiBtZW1vcnkgcmFuZ2VzIHRvIGJlIHNjYW5uZWQgaW5zaWRlIGFuIG9iamVjdCAoZW1wdHkgZm9yIGFsbCkgKi8KKwlzdHJ1Y3QgaGxpc3RfaGVhZCBhcmVhX2xpc3Q7CisJdW5zaWduZWQgbG9uZyB0cmFjZVtNQVhfVFJBQ0VdOworCXVuc2lnbmVkIGludCB0cmFjZV9sZW47CisJdW5zaWduZWQgbG9uZyBqaWZmaWVzOwkJLyogY3JlYXRpb24gdGltZXN0YW1wICovCisJcGlkX3QgcGlkOwkJCS8qIHBpZCBvZiB0aGUgY3VycmVudCB0YXNrICovCisJY2hhciBjb21tW1RBU0tfQ09NTV9MRU5dOwkvKiBleGVjdXRhYmxlIG5hbWUgKi8KK307CisKKy8qIGZsYWcgcmVwcmVzZW50aW5nIHRoZSBtZW1vcnkgYmxvY2sgYWxsb2NhdGlvbiBzdGF0dXMgKi8KKyNkZWZpbmUgT0JKRUNUX0FMTE9DQVRFRAkoMSA8PCAwKQorLyogZmxhZyBzZXQgYWZ0ZXIgdGhlIGZpcnN0IHJlcG9ydGluZyBvZiBhbiB1bnJlZmVyZW5jZSBvYmplY3QgKi8KKyNkZWZpbmUgT0JKRUNUX1JFUE9SVEVECQkoMSA8PCAxKQorLyogZmxhZyBzZXQgdG8gbm90IHNjYW4gdGhlIG9iamVjdCAqLworI2RlZmluZSBPQkpFQ1RfTk9fU0NBTgkJKDEgPDwgMikKKworLyogdGhlIGxpc3Qgb2YgYWxsIGFsbG9jYXRlZCBvYmplY3RzICovCitzdGF0aWMgTElTVF9IRUFEKG9iamVjdF9saXN0KTsKKy8qIHRoZSBsaXN0IG9mIGdyYXktY29sb3JlZCBvYmplY3RzIChzZWUgY29sb3JfZ3JheSBjb21tZW50IGJlbG93KSAqLworc3RhdGljIExJU1RfSEVBRChncmF5X2xpc3QpOworLyogcHJpbyBzZWFyY2ggdHJlZSBmb3Igb2JqZWN0IGJvdW5kYXJpZXMgKi8KK3N0YXRpYyBzdHJ1Y3QgcHJpb190cmVlX3Jvb3Qgb2JqZWN0X3RyZWVfcm9vdDsKKy8qIHJ3X2xvY2sgcHJvdGVjdGluZyB0aGUgYWNjZXNzIHRvIG9iamVjdF9saXN0IGFuZCBwcmlvX3RyZWVfcm9vdCAqLworc3RhdGljIERFRklORV9SV0xPQ0soa21lbWxlYWtfbG9jayk7CisKKy8qIGFsbG9jYXRpb24gY2FjaGVzIGZvciBrbWVtbGVhayBpbnRlcm5hbCBkYXRhICovCitzdGF0aWMgc3RydWN0IGttZW1fY2FjaGUgKm9iamVjdF9jYWNoZTsKK3N0YXRpYyBzdHJ1Y3Qga21lbV9jYWNoZSAqc2Nhbl9hcmVhX2NhY2hlOworCisvKiBzZXQgaWYgdHJhY2luZyBtZW1vcnkgb3BlcmF0aW9ucyBpcyBlbmFibGVkICovCitzdGF0aWMgYXRvbWljX3Qga21lbWxlYWtfZW5hYmxlZCA9IEFUT01JQ19JTklUKDApOworLyogc2V0IGluIHRoZSBsYXRlX2luaXRjYWxsIGlmIHRoZXJlIHdlcmUgbm8gZXJyb3JzICovCitzdGF0aWMgYXRvbWljX3Qga21lbWxlYWtfaW5pdGlhbGl6ZWQgPSBBVE9NSUNfSU5JVCgwKTsKKy8qIGVuYWJsZXMgb3IgZGlzYWJsZXMgZWFybHkgbG9nZ2luZyBvZiB0aGUgbWVtb3J5IG9wZXJhdGlvbnMgKi8KK3N0YXRpYyBhdG9taWNfdCBrbWVtbGVha19lYXJseV9sb2cgPSBBVE9NSUNfSU5JVCgxKTsKKy8qIHNldCBpZiBhIGZhdGEga21lbWxlYWsgZXJyb3IgaGFzIG9jY3VycmVkICovCitzdGF0aWMgYXRvbWljX3Qga21lbWxlYWtfZXJyb3IgPSBBVE9NSUNfSU5JVCgwKTsKKworLyogbWluaW11bSBhbmQgbWF4aW11bSBhZGRyZXNzIHRoYXQgbWF5IGJlIHZhbGlkIHBvaW50ZXJzICovCitzdGF0aWMgdW5zaWduZWQgbG9uZyBtaW5fYWRkciA9IFVMT05HX01BWDsKK3N0YXRpYyB1bnNpZ25lZCBsb25nIG1heF9hZGRyOworCisvKiB1c2VkIGZvciB5aWVsZGluZyB0aGUgQ1BVIHRvIG90aGVyIHRhc2tzIGR1cmluZyBzY2FubmluZyAqLworc3RhdGljIHVuc2lnbmVkIGxvbmcgbmV4dF9zY2FuX3lpZWxkOworc3RhdGljIHN0cnVjdCB0YXNrX3N0cnVjdCAqc2Nhbl90aHJlYWQ7CitzdGF0aWMgdW5zaWduZWQgbG9uZyBqaWZmaWVzX3NjYW5feWllbGQ7CitzdGF0aWMgdW5zaWduZWQgbG9uZyBqaWZmaWVzX21pbl9hZ2U7CisvKiBkZWxheSBiZXR3ZWVuIGF1dG9tYXRpYyBtZW1vcnkgc2Nhbm5pbmdzICovCitzdGF0aWMgc2lnbmVkIGxvbmcgamlmZmllc19zY2FuX3dhaXQ7CisvKiBlbmFibGVzIG9yIGRpc2FibGVzIHRoZSB0YXNrIHN0YWNrcyBzY2FubmluZyAqLworc3RhdGljIGludCBrbWVtbGVha19zdGFja19zY2FuOworLyogbXV0ZXggcHJvdGVjdGluZyB0aGUgbWVtb3J5IHNjYW5uaW5nICovCitzdGF0aWMgREVGSU5FX01VVEVYKHNjYW5fbXV0ZXgpOworLyogbXV0ZXggcHJvdGVjdGluZyB0aGUgYWNjZXNzIHRvIHRoZSAvc3lzL2tlcm5lbC9kZWJ1Zy9rbWVtbGVhayBmaWxlICovCitzdGF0aWMgREVGSU5FX01VVEVYKGttZW1sZWFrX211dGV4KTsKKworLyogbnVtYmVyIG9mIGxlYWtzIHJlcG9ydGVkIChmb3IgbGltaXRhdGlvbiBwdXJwb3NlcykgKi8KK3N0YXRpYyBpbnQgcmVwb3J0ZWRfbGVha3M7CisKKy8qCisgKiBFYXJseSBvYmplY3QgYWxsb2NhdGlvbi9mcmVlaW5nIGxvZ2dpbmcuIEtrbWVtbGVhayBpcyBpbml0aWFsaXplZCBhZnRlciB0aGUKKyAqIGtlcm5lbCBhbGxvY2F0b3IuIEhvd2V2ZXIsIGJvdGggdGhlIGtlcm5lbCBhbGxvY2F0b3IgYW5kIGttZW1sZWFrIG1heQorICogYWxsb2NhdGUgbWVtb3J5IGJsb2NrcyB3aGljaCBuZWVkIHRvIGJlIHRyYWNrZWQuIEtrbWVtbGVhayBkZWZpbmVzIGFuCisgKiBhcmJpdHJhcnkgYnVmZmVyIHRvIGhvbGQgdGhlIGFsbG9jYXRpb24vZnJlZWluZyBpbmZvcm1hdGlvbiBiZWZvcmUgaXQgaXMKKyAqIGZ1bGx5IGluaXRpYWxpemVkLgorICovCisKKy8qIGttZW1sZWFrIG9wZXJhdGlvbiB0eXBlIGZvciBlYXJseSBsb2dnaW5nICovCitlbnVtIHsKKwlLTUVNTEVBS19BTExPQywKKwlLTUVNTEVBS19GUkVFLAorCUtNRU1MRUFLX05PVF9MRUFLLAorCUtNRU1MRUFLX0lHTk9SRSwKKwlLTUVNTEVBS19TQ0FOX0FSRUEsCisJS01FTUxFQUtfTk9fU0NBTgorfTsKKworLyoKKyAqIFN0cnVjdHVyZSBob2xkaW5nIHRoZSBpbmZvcm1hdGlvbiBwYXNzZWQgdG8ga21lbWxlYWsgY2FsbGJhY2tzIGR1cmluZyB0aGUKKyAqIGVhcmx5IGxvZ2dpbmcuCisgKi8KK3N0cnVjdCBlYXJseV9sb2cgeworCWludCBvcF90eXBlOwkJCS8qIGttZW1sZWFrIG9wZXJhdGlvbiB0eXBlICovCisJY29uc3Qgdm9pZCAqcHRyOwkJLyogYWxsb2NhdGVkL2ZyZWVkIG1lbW9yeSBibG9jayAqLworCXNpemVfdCBzaXplOwkJCS8qIG1lbW9yeSBibG9jayBzaXplICovCisJaW50IG1pbl9jb3VudDsJCQkvKiBtaW5pbXVtIHJlZmVyZW5jZSBjb3VudCAqLworCXVuc2lnbmVkIGxvbmcgb2Zmc2V0OwkJLyogc2NhbiBhcmVhIG9mZnNldCAqLworCXNpemVfdCBsZW5ndGg7CQkJLyogc2NhbiBhcmVhIGxlbmd0aCAqLworfTsKKworLyogZWFybHkgbG9nZ2luZyBidWZmZXIgYW5kIGN1cnJlbnQgcG9zaXRpb24gKi8KK3N0YXRpYyBzdHJ1Y3QgZWFybHlfbG9nIGVhcmx5X2xvZ1syMDBdOworc3RhdGljIGludCBjcnRfZWFybHlfbG9nOworCitzdGF0aWMgdm9pZCBrbWVtbGVha19kaXNhYmxlKHZvaWQpOworCisvKgorICogUHJpbnQgYSB3YXJuaW5nIGFuZCBkdW1wIHRoZSBzdGFjayB0cmFjZS4KKyAqLworI2RlZmluZSBrbWVtbGVha193YXJuKHguLi4pCWRvIHsJXAorCXByX3dhcm5pbmcoeCk7CQkJXAorCWR1bXBfc3RhY2soKTsJCQlcCit9IHdoaWxlICgwKQorCisvKgorICogTWFjcm8gaW52b2tlZCB3aGVuIGEgc2VyaW91cyBrbWVtbGVhayBjb25kaXRpb24gb2NjdXJlZCBhbmQgY2Fubm90IGJlCisgKiByZWNvdmVyZWQgZnJvbS4gS2ttZW1sZWFrIHdpbGwgYmUgZGlzYWJsZWQgYW5kIGZ1cnRoZXIgYWxsb2NhdGlvbi9mcmVlaW5nCisgKiB0cmFjaW5nIG5vIGxvbmdlciBhdmFpbGFibGUuCisgKi8KKyNkZWZpbmUga21lbWxlYWtfcGFuaWMoeC4uLikJZG8gewlcCisJa21lbWxlYWtfd2Fybih4KTsJCVwKKwlrbWVtbGVha19kaXNhYmxlKCk7CQlcCit9IHdoaWxlICgwKQorCisvKgorICogT2JqZWN0IGNvbG9ycywgZW5jb2RlZCB3aXRoIGNvdW50IGFuZCBtaW5fY291bnQ6CisgKiAtIHdoaXRlIC0gb3JwaGFuIG9iamVjdCwgbm90IGVub3VnaCByZWZlcmVuY2VzIHRvIGl0IChjb3VudCA8IG1pbl9jb3VudCkKKyAqIC0gZ3JheSAgLSBub3Qgb3JwaGFuLCBub3QgbWFya2VkIGFzIGZhbHNlIHBvc2l0aXZlIChtaW5fY291bnQgPT0gMCkgb3IKKyAqCQlzdWZmaWNpZW50IHJlZmVyZW5jZXMgdG8gaXQgKGNvdW50ID49IG1pbl9jb3VudCkKKyAqIC0gYmxhY2sgLSBpZ25vcmUsIGl0IGRvZXNuJ3QgY29udGFpbiByZWZlcmVuY2VzIChlLmcuIHRleHQgc2VjdGlvbikKKyAqCQkobWluX2NvdW50ID09IC0xKS4gTm8gZnVuY3Rpb24gZGVmaW5lZCBmb3IgdGhpcyBjb2xvci4KKyAqIE5ld2x5IGNyZWF0ZWQgb2JqZWN0cyBkb24ndCBoYXZlIGFueSBjb2xvciBhc3NpZ25lZCAob2JqZWN0LT5jb3VudCA9PSAtMSkKKyAqIGJlZm9yZSB0aGUgbmV4dCBtZW1vcnkgc2NhbiB3aGVuIHRoZXkgYmVjb21lIHdoaXRlLgorICovCitzdGF0aWMgaW50IGNvbG9yX3doaXRlKGNvbnN0IHN0cnVjdCBrbWVtbGVha19vYmplY3QgKm9iamVjdCkKK3sKKwlyZXR1cm4gb2JqZWN0LT5jb3VudCAhPSAtMSAmJiBvYmplY3QtPmNvdW50IDwgb2JqZWN0LT5taW5fY291bnQ7Cit9CisKK3N0YXRpYyBpbnQgY29sb3JfZ3JheShjb25zdCBzdHJ1Y3Qga21lbWxlYWtfb2JqZWN0ICpvYmplY3QpCit7CisJcmV0dXJuIG9iamVjdC0+bWluX2NvdW50ICE9IC0xICYmIG9iamVjdC0+Y291bnQgPj0gb2JqZWN0LT5taW5fY291bnQ7Cit9CisKKy8qCisgKiBPYmplY3RzIGFyZSBjb25zaWRlcmVkIHJlZmVyZW5jZWQgaWYgdGhlaXIgY29sb3IgaXMgZ3JheSBhbmQgdGhleSBoYXZlIG5vdAorICogYmVlbiBkZWxldGVkLgorICovCitzdGF0aWMgaW50IHJlZmVyZW5jZWRfb2JqZWN0KHN0cnVjdCBrbWVtbGVha19vYmplY3QgKm9iamVjdCkKK3sKKwlyZXR1cm4gKG9iamVjdC0+ZmxhZ3MgJiBPQkpFQ1RfQUxMT0NBVEVEKSAmJiBjb2xvcl9ncmF5KG9iamVjdCk7Cit9CisKKy8qCisgKiBPYmplY3RzIGFyZSBjb25zaWRlcmVkIHVucmVmZXJlbmNlZCBvbmx5IGlmIHRoZWlyIGNvbG9yIGlzIHdoaXRlLCB0aGV5IGhhdmUKKyAqIG5vdCBiZSBkZWxldGVkIGFuZCBoYXZlIGEgbWluaW11bSBhZ2UgdG8gYXZvaWQgZmFsc2UgcG9zaXRpdmVzIGNhdXNlZCBieQorICogcG9pbnRlcnMgdGVtcG9yYXJpbHkgc3RvcmVkIGluIENQVSByZWdpc3RlcnMuCisgKi8KK3N0YXRpYyBpbnQgdW5yZWZlcmVuY2VkX29iamVjdChzdHJ1Y3Qga21lbWxlYWtfb2JqZWN0ICpvYmplY3QpCit7CisJcmV0dXJuIChvYmplY3QtPmZsYWdzICYgT0JKRUNUX0FMTE9DQVRFRCkgJiYgY29sb3Jfd2hpdGUob2JqZWN0KSAmJgorCQl0aW1lX2lzX2JlZm9yZV9lcV9qaWZmaWVzKG9iamVjdC0+amlmZmllcyArIGppZmZpZXNfbWluX2FnZSk7Cit9CisKKy8qCisgKiBQcmludGluZyBvZiB0aGUgKHVuKXJlZmVyZW5jZWQgb2JqZWN0cyBpbmZvcm1hdGlvbiwgZWl0aGVyIHRvIHRoZSBzZXEgZmlsZQorICogb3IgdG8gdGhlIGtlcm5lbCBsb2cuIFRoZSBwcmludF9yZWZlcmVuY2VkL3ByaW50X3VucmVmZXJlbmNlZCBmdW5jdGlvbnMKKyAqIG11c3QgYmUgY2FsbGVkIHdpdGggdGhlIG9iamVjdC0+bG9jayBoZWxkLgorICovCisjZGVmaW5lIHByaW50X2hlbHBlcihzZXEsIHguLi4pCWRvIHsJXAorCXN0cnVjdCBzZXFfZmlsZSAqcyA9IChzZXEpOwlcCisJaWYgKHMpCQkJCVwKKwkJc2VxX3ByaW50ZihzLCB4KTsJXAorCWVsc2UJCQkJXAorCQlwcl9pbmZvKHgpOwkJXAorfSB3aGlsZSAoMCkKKworc3RhdGljIHZvaWQgcHJpbnRfcmVmZXJlbmNlZChzdHJ1Y3Qga21lbWxlYWtfb2JqZWN0ICpvYmplY3QpCit7CisJcHJfaW5mbygia21lbWxlYWs6IHJlZmVyZW5jZWQgb2JqZWN0IDB4JTA4bHggKHNpemUgJXp1KVxuIiwKKwkJb2JqZWN0LT5wb2ludGVyLCBvYmplY3QtPnNpemUpOworfQorCitzdGF0aWMgdm9pZCBwcmludF91bnJlZmVyZW5jZWQoc3RydWN0IHNlcV9maWxlICpzZXEsCisJCQkgICAgICAgc3RydWN0IGttZW1sZWFrX29iamVjdCAqb2JqZWN0KQoreworCWludCBpOworCisJcHJpbnRfaGVscGVyKHNlcSwgImttZW1sZWFrOiB1bnJlZmVyZW5jZWQgb2JqZWN0IDB4JTA4bHggKHNpemUgJXp1KTpcbiIsCisJCSAgICAgb2JqZWN0LT5wb2ludGVyLCBvYmplY3QtPnNpemUpOworCXByaW50X2hlbHBlcihzZXEsICIgIGNvbW0gXCIlc1wiLCBwaWQgJWQsIGppZmZpZXMgJWx1XG4iLAorCQkgICAgIG9iamVjdC0+Y29tbSwgb2JqZWN0LT5waWQsIG9iamVjdC0+amlmZmllcyk7CisJcHJpbnRfaGVscGVyKHNlcSwgIiAgYmFja3RyYWNlOlxuIik7CisKKwlmb3IgKGkgPSAwOyBpIDwgb2JqZWN0LT50cmFjZV9sZW47IGkrKykgeworCQl2b2lkICpwdHIgPSAodm9pZCAqKW9iamVjdC0+dHJhY2VbaV07CisJCXByaW50X2hlbHBlcihzZXEsICIgICAgWzwlcD5dICVwU1xuIiwgcHRyLCBwdHIpOworCX0KK30KKworLyoKKyAqIFByaW50IHRoZSBrbWVtbGVha19vYmplY3QgaW5mb3JtYXRpb24uIFRoaXMgZnVuY3Rpb24gaXMgdXNlZCBtYWlubHkgZm9yCisgKiBkZWJ1Z2dpbmcgc3BlY2lhbCBjYXNlcyB3aGVuIGttZW1sZWFrIG9wZXJhdGlvbnMuIEl0IG11c3QgYmUgY2FsbGVkIHdpdGgKKyAqIHRoZSBvYmplY3QtPmxvY2sgaGVsZC4KKyAqLworc3RhdGljIHZvaWQgZHVtcF9vYmplY3RfaW5mbyhzdHJ1Y3Qga21lbWxlYWtfb2JqZWN0ICpvYmplY3QpCit7CisJc3RydWN0IHN0YWNrX3RyYWNlIHRyYWNlOworCisJdHJhY2UubnJfZW50cmllcyA9IG9iamVjdC0+dHJhY2VfbGVuOworCXRyYWNlLmVudHJpZXMgPSBvYmplY3QtPnRyYWNlOworCisJcHJfbm90aWNlKCJrbWVtbGVhazogT2JqZWN0IDB4JTA4bHggKHNpemUgJXp1KTpcbiIsCisJCSAgb2JqZWN0LT50cmVlX25vZGUuc3RhcnQsIG9iamVjdC0+c2l6ZSk7CisJcHJfbm90aWNlKCIgIGNvbW0gXCIlc1wiLCBwaWQgJWQsIGppZmZpZXMgJWx1XG4iLAorCQkgIG9iamVjdC0+Y29tbSwgb2JqZWN0LT5waWQsIG9iamVjdC0+amlmZmllcyk7CisJcHJfbm90aWNlKCIgIG1pbl9jb3VudCA9ICVkXG4iLCBvYmplY3QtPm1pbl9jb3VudCk7CisJcHJfbm90aWNlKCIgIGNvdW50ID0gJWRcbiIsIG9iamVjdC0+Y291bnQpOworCXByX25vdGljZSgiICBiYWNrdHJhY2U6XG4iKTsKKwlwcmludF9zdGFja190cmFjZSgmdHJhY2UsIDQpOworfQorCisvKgorICogTG9vay11cCBhIG1lbW9yeSBibG9jayBtZXRhZGF0YSAoa21lbWxlYWtfb2JqZWN0KSBpbiB0aGUgcHJpb3JpdHkgc2VhcmNoCisgKiB0cmVlIGJhc2VkIG9uIGEgcG9pbnRlciB2YWx1ZS4gSWYgYWxpYXMgaXMgMCwgb25seSB2YWx1ZXMgcG9pbnRpbmcgdG8gdGhlCisgKiBiZWdpbm5pbmcgb2YgdGhlIG1lbW9yeSBibG9jayBhcmUgYWxsb3dlZC4gVGhlIGttZW1sZWFrX2xvY2sgbXVzdCBiZSBoZWxkCisgKiB3aGVuIGNhbGxpbmcgdGhpcyBmdW5jdGlvbi4KKyAqLworc3RhdGljIHN0cnVjdCBrbWVtbGVha19vYmplY3QgKmxvb2t1cF9vYmplY3QodW5zaWduZWQgbG9uZyBwdHIsIGludCBhbGlhcykKK3sKKwlzdHJ1Y3QgcHJpb190cmVlX25vZGUgKm5vZGU7CisJc3RydWN0IHByaW9fdHJlZV9pdGVyIGl0ZXI7CisJc3RydWN0IGttZW1sZWFrX29iamVjdCAqb2JqZWN0OworCisJcHJpb190cmVlX2l0ZXJfaW5pdCgmaXRlciwgJm9iamVjdF90cmVlX3Jvb3QsIHB0ciwgcHRyKTsKKwlub2RlID0gcHJpb190cmVlX25leHQoJml0ZXIpOworCWlmIChub2RlKSB7CisJCW9iamVjdCA9IHByaW9fdHJlZV9lbnRyeShub2RlLCBzdHJ1Y3Qga21lbWxlYWtfb2JqZWN0LAorCQkJCQkgdHJlZV9ub2RlKTsKKwkJaWYgKCFhbGlhcyAmJiBvYmplY3QtPnBvaW50ZXIgIT0gcHRyKSB7CisJCQlrbWVtbGVha193YXJuKCJrbWVtbGVhazogRm91bmQgb2JqZWN0IGJ5IGFsaWFzIik7CisJCQlvYmplY3QgPSBOVUxMOworCQl9CisJfSBlbHNlCisJCW9iamVjdCA9IE5VTEw7CisKKwlyZXR1cm4gb2JqZWN0OworfQorCisvKgorICogSW5jcmVtZW50IHRoZSBvYmplY3QgdXNlX2NvdW50LiBSZXR1cm4gMSBpZiBzdWNjZXNzZnVsIG9yIDAgb3RoZXJ3aXNlLiBOb3RlCisgKiB0aGF0IG9uY2UgYW4gb2JqZWN0J3MgdXNlX2NvdW50IHJlYWNoZWQgMCwgdGhlIFJDVSBmcmVlaW5nIHdhcyBhbHJlYWR5CisgKiByZWdpc3RlcmVkIGFuZCB0aGUgb2JqZWN0IHNob3VsZCBubyBsb25nZXIgYmUgdXNlZC4gVGhpcyBmdW5jdGlvbiBtdXN0IGJlCisgKiBjYWxsZWQgdW5kZXIgdGhlIHByb3RlY3Rpb24gb2YgcmN1X3JlYWRfbG9jaygpLgorICovCitzdGF0aWMgaW50IGdldF9vYmplY3Qoc3RydWN0IGttZW1sZWFrX29iamVjdCAqb2JqZWN0KQoreworCXJldHVybiBhdG9taWNfaW5jX25vdF96ZXJvKCZvYmplY3QtPnVzZV9jb3VudCk7Cit9CisKKy8qCisgKiBSQ1UgY2FsbGJhY2sgdG8gZnJlZSBhIGttZW1sZWFrX29iamVjdC4KKyAqLworc3RhdGljIHZvaWQgZnJlZV9vYmplY3RfcmN1KHN0cnVjdCByY3VfaGVhZCAqcmN1KQoreworCXN0cnVjdCBobGlzdF9ub2RlICplbGVtLCAqdG1wOworCXN0cnVjdCBrbWVtbGVha19zY2FuX2FyZWEgKmFyZWE7CisJc3RydWN0IGttZW1sZWFrX29iamVjdCAqb2JqZWN0ID0KKwkJY29udGFpbmVyX29mKHJjdSwgc3RydWN0IGttZW1sZWFrX29iamVjdCwgcmN1KTsKKworCS8qCisJICogT25jZSB1c2VfY291bnQgaXMgMCAoZ3VhcmFudGVlZCBieSBwdXRfb2JqZWN0KSwgdGhlcmUgaXMgbm8gb3RoZXIKKwkgKiBjb2RlIGFjY2Vzc2luZyB0aGlzIG9iamVjdCwgaGVuY2Ugbm8gbmVlZCBmb3IgbG9ja2luZy4KKwkgKi8KKwlobGlzdF9mb3JfZWFjaF9lbnRyeV9zYWZlKGFyZWEsIGVsZW0sIHRtcCwgJm9iamVjdC0+YXJlYV9saXN0LCBub2RlKSB7CisJCWhsaXN0X2RlbChlbGVtKTsKKwkJa21lbV9jYWNoZV9mcmVlKHNjYW5fYXJlYV9jYWNoZSwgYXJlYSk7CisJfQorCWttZW1fY2FjaGVfZnJlZShvYmplY3RfY2FjaGUsIG9iamVjdCk7Cit9CisKKy8qCisgKiBEZWNyZW1lbnQgdGhlIG9iamVjdCB1c2VfY291bnQuIE9uY2UgdGhlIGNvdW50IGlzIDAsIGZyZWUgdGhlIG9iamVjdCB1c2luZworICogYW4gUkNVIGNhbGxiYWNrLiBTaW5jZSBwdXRfb2JqZWN0KCkgbWF5IGJlIGNhbGxlZCB2aWEgdGhlIGttZW1sZWFrX2ZyZWUoKSAtPgorICogZGVsZXRlX29iamVjdCgpIHBhdGgsIHRoZSBkZWxheWVkIFJDVSBmcmVlaW5nIGVuc3VyZXMgdGhhdCB0aGVyZSBpcyBubworICogcmVjdXJzaXZlIGNhbGwgdG8gdGhlIGtlcm5lbCBhbGxvY2F0b3IuIExvY2stbGVzcyBSQ1Ugb2JqZWN0X2xpc3QgdHJhdmVyc2FsCisgKiBpcyBhbHNvIHBvc3NpYmxlLgorICovCitzdGF0aWMgdm9pZCBwdXRfb2JqZWN0KHN0cnVjdCBrbWVtbGVha19vYmplY3QgKm9iamVjdCkKK3sKKwlpZiAoIWF0b21pY19kZWNfYW5kX3Rlc3QoJm9iamVjdC0+dXNlX2NvdW50KSkKKwkJcmV0dXJuOworCisJLyogc2hvdWxkIG9ubHkgZ2V0IGhlcmUgYWZ0ZXIgZGVsZXRlX29iamVjdCB3YXMgY2FsbGVkICovCisJV0FSTl9PTihvYmplY3QtPmZsYWdzICYgT0JKRUNUX0FMTE9DQVRFRCk7CisKKwljYWxsX3JjdSgmb2JqZWN0LT5yY3UsIGZyZWVfb2JqZWN0X3JjdSk7Cit9CisKKy8qCisgKiBMb29rIHVwIGFuIG9iamVjdCBpbiB0aGUgcHJpbyBzZWFyY2ggdHJlZSBhbmQgaW5jcmVhc2UgaXRzIHVzZV9jb3VudC4KKyAqLworc3RhdGljIHN0cnVjdCBrbWVtbGVha19vYmplY3QgKmZpbmRfYW5kX2dldF9vYmplY3QodW5zaWduZWQgbG9uZyBwdHIsIGludCBhbGlhcykKK3sKKwl1bnNpZ25lZCBsb25nIGZsYWdzOworCXN0cnVjdCBrbWVtbGVha19vYmplY3QgKm9iamVjdCA9IE5VTEw7CisKKwlyY3VfcmVhZF9sb2NrKCk7CisJcmVhZF9sb2NrX2lycXNhdmUoJmttZW1sZWFrX2xvY2ssIGZsYWdzKTsKKwlpZiAocHRyID49IG1pbl9hZGRyICYmIHB0ciA8IG1heF9hZGRyKQorCQlvYmplY3QgPSBsb29rdXBfb2JqZWN0KHB0ciwgYWxpYXMpOworCXJlYWRfdW5sb2NrX2lycXJlc3RvcmUoJmttZW1sZWFrX2xvY2ssIGZsYWdzKTsKKworCS8qIGNoZWNrIHdoZXRoZXIgdGhlIG9iamVjdCBpcyBzdGlsbCBhdmFpbGFibGUgKi8KKwlpZiAob2JqZWN0ICYmICFnZXRfb2JqZWN0KG9iamVjdCkpCisJCW9iamVjdCA9IE5VTEw7CisJcmN1X3JlYWRfdW5sb2NrKCk7CisKKwlyZXR1cm4gb2JqZWN0OworfQorCisvKgorICogQ3JlYXRlIHRoZSBtZXRhZGF0YSAoc3RydWN0IGttZW1sZWFrX29iamVjdCkgY29ycmVzcG9uZGluZyB0byBhbiBhbGxvY2F0ZWQKKyAqIG1lbW9yeSBibG9jayBhbmQgYWRkIGl0IHRvIHRoZSBvYmplY3RfbGlzdCBhbmQgb2JqZWN0X3RyZWVfcm9vdC4KKyAqLworc3RhdGljIHZvaWQgY3JlYXRlX29iamVjdCh1bnNpZ25lZCBsb25nIHB0ciwgc2l6ZV90IHNpemUsIGludCBtaW5fY291bnQsCisJCQkgIGdmcF90IGdmcCkKK3sKKwl1bnNpZ25lZCBsb25nIGZsYWdzOworCXN0cnVjdCBrbWVtbGVha19vYmplY3QgKm9iamVjdDsKKwlzdHJ1Y3QgcHJpb190cmVlX25vZGUgKm5vZGU7CisJc3RydWN0IHN0YWNrX3RyYWNlIHRyYWNlOworCisJb2JqZWN0ID0ga21lbV9jYWNoZV9hbGxvYyhvYmplY3RfY2FjaGUsIGdmcCAmIH5HRlBfU0xBQl9CVUdfTUFTSyk7CisJaWYgKCFvYmplY3QpIHsKKwkJa21lbWxlYWtfcGFuaWMoImttZW1sZWFrOiBDYW5ub3QgYWxsb2NhdGUgYSBrbWVtbGVha19vYmplY3QgIgorCQkJICAgICAgICJzdHJ1Y3R1cmVcbiIpOworCQlyZXR1cm47CisJfQorCisJSU5JVF9MSVNUX0hFQUQoJm9iamVjdC0+b2JqZWN0X2xpc3QpOworCUlOSVRfTElTVF9IRUFEKCZvYmplY3QtPmdyYXlfbGlzdCk7CisJSU5JVF9ITElTVF9IRUFEKCZvYmplY3QtPmFyZWFfbGlzdCk7CisJc3Bpbl9sb2NrX2luaXQoJm9iamVjdC0+bG9jayk7CisJYXRvbWljX3NldCgmb2JqZWN0LT51c2VfY291bnQsIDEpOworCW9iamVjdC0+ZmxhZ3MgPSBPQkpFQ1RfQUxMT0NBVEVEOworCW9iamVjdC0+cG9pbnRlciA9IHB0cjsKKwlvYmplY3QtPnNpemUgPSBzaXplOworCW9iamVjdC0+bWluX2NvdW50ID0gbWluX2NvdW50OworCW9iamVjdC0+Y291bnQgPSAtMTsJCQkvKiBubyBjb2xvciBpbml0aWFsbHkgKi8KKwlvYmplY3QtPmppZmZpZXMgPSBqaWZmaWVzOworCisJLyogdGFzayBpbmZvcm1hdGlvbiAqLworCWlmIChpbl9pcnEoKSkgeworCQlvYmplY3QtPnBpZCA9IDA7CisJCXN0cm5jcHkob2JqZWN0LT5jb21tLCAiaGFyZGlycSIsIHNpemVvZihvYmplY3QtPmNvbW0pKTsKKwl9IGVsc2UgaWYgKGluX3NvZnRpcnEoKSkgeworCQlvYmplY3QtPnBpZCA9IDA7CisJCXN0cm5jcHkob2JqZWN0LT5jb21tLCAic29mdGlycSIsIHNpemVvZihvYmplY3QtPmNvbW0pKTsKKwl9IGVsc2UgeworCQlvYmplY3QtPnBpZCA9IGN1cnJlbnQtPnBpZDsKKwkJLyoKKwkJICogVGhlcmUgaXMgYSBzbWFsbCBjaGFuY2Ugb2YgYSByYWNlIHdpdGggc2V0X3Rhc2tfY29tbSgpLAorCQkgKiBob3dldmVyIHVzaW5nIGdldF90YXNrX2NvbW0oKSBoZXJlIG1heSBjYXVzZSBsb2NraW5nCisJCSAqIGRlcGVuZGVuY3kgaXNzdWVzIHdpdGggY3VycmVudC0+YWxsb2NfbG9jay4gSW4gdGhlIHdvcnN0CisJCSAqIGNhc2UsIHRoZSBjb21tYW5kIGxpbmUgaXMgbm90IGNvcnJlY3QuCisJCSAqLworCQlzdHJuY3B5KG9iamVjdC0+Y29tbSwgY3VycmVudC0+Y29tbSwgc2l6ZW9mKG9iamVjdC0+Y29tbSkpOworCX0KKworCS8qIGtlcm5lbCBiYWNrdHJhY2UgKi8KKwl0cmFjZS5tYXhfZW50cmllcyA9IE1BWF9UUkFDRTsKKwl0cmFjZS5ucl9lbnRyaWVzID0gMDsKKwl0cmFjZS5lbnRyaWVzID0gb2JqZWN0LT50cmFjZTsKKwl0cmFjZS5za2lwID0gMTsKKwlzYXZlX3N0YWNrX3RyYWNlKCZ0cmFjZSk7CisJb2JqZWN0LT50cmFjZV9sZW4gPSB0cmFjZS5ucl9lbnRyaWVzOworCisJSU5JVF9QUklPX1RSRUVfTk9ERSgmb2JqZWN0LT50cmVlX25vZGUpOworCW9iamVjdC0+dHJlZV9ub2RlLnN0YXJ0ID0gcHRyOworCW9iamVjdC0+dHJlZV9ub2RlLmxhc3QgPSBwdHIgKyBzaXplIC0gMTsKKworCXdyaXRlX2xvY2tfaXJxc2F2ZSgma21lbWxlYWtfbG9jaywgZmxhZ3MpOworCW1pbl9hZGRyID0gbWluKG1pbl9hZGRyLCBwdHIpOworCW1heF9hZGRyID0gbWF4KG1heF9hZGRyLCBwdHIgKyBzaXplKTsKKwlub2RlID0gcHJpb190cmVlX2luc2VydCgmb2JqZWN0X3RyZWVfcm9vdCwgJm9iamVjdC0+dHJlZV9ub2RlKTsKKwkvKgorCSAqIFRoZSBjb2RlIGNhbGxpbmcgdGhlIGtlcm5lbCBkb2VzIG5vdCB5ZXQgaGF2ZSB0aGUgcG9pbnRlciB0byB0aGUKKwkgKiBtZW1vcnkgYmxvY2sgdG8gYmUgYWJsZSB0byBmcmVlIGl0LiAgSG93ZXZlciwgd2Ugc3RpbGwgaG9sZCB0aGUKKwkgKiBrbWVtbGVha19sb2NrIGhlcmUgaW4gY2FzZSBwYXJ0cyBvZiB0aGUga2VybmVsIHN0YXJ0ZWQgZnJlZWluZworCSAqIHJhbmRvbSBtZW1vcnkgYmxvY2tzLgorCSAqLworCWlmIChub2RlICE9ICZvYmplY3QtPnRyZWVfbm9kZSkgeworCQl1bnNpZ25lZCBsb25nIGZsYWdzOworCisJCWttZW1sZWFrX3BhbmljKCJrbWVtbGVhazogQ2Fubm90IGluc2VydCAweCVseCBpbnRvIHRoZSBvYmplY3QgIgorCQkJICAgICAgICJzZWFyY2ggdHJlZSAoYWxyZWFkeSBleGlzdGluZylcbiIsIHB0cik7CisJCW9iamVjdCA9IGxvb2t1cF9vYmplY3QocHRyLCAxKTsKKwkJc3Bpbl9sb2NrX2lycXNhdmUoJm9iamVjdC0+bG9jaywgZmxhZ3MpOworCQlkdW1wX29iamVjdF9pbmZvKG9iamVjdCk7CisJCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJm9iamVjdC0+bG9jaywgZmxhZ3MpOworCisJCWdvdG8gb3V0OworCX0KKwlsaXN0X2FkZF90YWlsX3JjdSgmb2JqZWN0LT5vYmplY3RfbGlzdCwgJm9iamVjdF9saXN0KTsKK291dDoKKwl3cml0ZV91bmxvY2tfaXJxcmVzdG9yZSgma21lbWxlYWtfbG9jaywgZmxhZ3MpOworfQorCisvKgorICogUmVtb3ZlIHRoZSBtZXRhZGF0YSAoc3RydWN0IGttZW1sZWFrX29iamVjdCkgZm9yIGEgbWVtb3J5IGJsb2NrIGZyb20gdGhlCisgKiBvYmplY3RfbGlzdCBhbmQgb2JqZWN0X3RyZWVfcm9vdCBhbmQgZGVjcmVtZW50IGl0cyB1c2VfY291bnQuCisgKi8KK3N0YXRpYyB2b2lkIGRlbGV0ZV9vYmplY3QodW5zaWduZWQgbG9uZyBwdHIpCit7CisJdW5zaWduZWQgbG9uZyBmbGFnczsKKwlzdHJ1Y3Qga21lbWxlYWtfb2JqZWN0ICpvYmplY3Q7CisKKwl3cml0ZV9sb2NrX2lycXNhdmUoJmttZW1sZWFrX2xvY2ssIGZsYWdzKTsKKwlvYmplY3QgPSBsb29rdXBfb2JqZWN0KHB0ciwgMCk7CisJaWYgKCFvYmplY3QpIHsKKwkJa21lbWxlYWtfd2Fybigia21lbWxlYWs6IEZyZWVpbmcgdW5rbm93biBvYmplY3QgYXQgMHglMDhseFxuIiwKKwkJCSAgICAgIHB0cik7CisJCXdyaXRlX3VubG9ja19pcnFyZXN0b3JlKCZrbWVtbGVha19sb2NrLCBmbGFncyk7CisJCXJldHVybjsKKwl9CisJcHJpb190cmVlX3JlbW92ZSgmb2JqZWN0X3RyZWVfcm9vdCwgJm9iamVjdC0+dHJlZV9ub2RlKTsKKwlsaXN0X2RlbF9yY3UoJm9iamVjdC0+b2JqZWN0X2xpc3QpOworCXdyaXRlX3VubG9ja19pcnFyZXN0b3JlKCZrbWVtbGVha19sb2NrLCBmbGFncyk7CisKKwlXQVJOX09OKCEob2JqZWN0LT5mbGFncyAmIE9CSkVDVF9BTExPQ0FURUQpKTsKKwlXQVJOX09OKGF0b21pY19yZWFkKCZvYmplY3QtPnVzZV9jb3VudCkgPCAxKTsKKworCS8qCisJICogTG9ja2luZyBoZXJlIGFsc28gZW5zdXJlcyB0aGF0IHRoZSBjb3JyZXNwb25kaW5nIG1lbW9yeSBibG9jaworCSAqIGNhbm5vdCBiZSBmcmVlZCB3aGVuIGl0IGlzIGJlaW5nIHNjYW5uZWQuCisJICovCisJc3Bpbl9sb2NrX2lycXNhdmUoJm9iamVjdC0+bG9jaywgZmxhZ3MpOworCWlmIChvYmplY3QtPmZsYWdzICYgT0JKRUNUX1JFUE9SVEVEKQorCQlwcmludF9yZWZlcmVuY2VkKG9iamVjdCk7CisJb2JqZWN0LT5mbGFncyAmPSB+T0JKRUNUX0FMTE9DQVRFRDsKKwlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZvYmplY3QtPmxvY2ssIGZsYWdzKTsKKwlwdXRfb2JqZWN0KG9iamVjdCk7Cit9CisKKy8qCisgKiBNYWtlIGEgb2JqZWN0IHBlcm1hbmVudGx5IGFzIGdyYXktY29sb3JlZCBzbyB0aGF0IGl0IGNhbiBubyBsb25nZXIgYmUKKyAqIHJlcG9ydGVkIGFzIGEgbGVhay4gVGhpcyBpcyB1c2VkIGluIGdlbmVyYWwgdG8gbWFyayBhIGZhbHNlIHBvc2l0aXZlLgorICovCitzdGF0aWMgdm9pZCBtYWtlX2dyYXlfb2JqZWN0KHVuc2lnbmVkIGxvbmcgcHRyKQoreworCXVuc2lnbmVkIGxvbmcgZmxhZ3M7CisJc3RydWN0IGttZW1sZWFrX29iamVjdCAqb2JqZWN0OworCisJb2JqZWN0ID0gZmluZF9hbmRfZ2V0X29iamVjdChwdHIsIDApOworCWlmICghb2JqZWN0KSB7CisJCWttZW1sZWFrX3dhcm4oImttZW1sZWFrOiBHcmF5aW5nIHVua25vd24gb2JqZWN0IGF0IDB4JTA4bHhcbiIsCisJCQkgICAgICBwdHIpOworCQlyZXR1cm47CisJfQorCisJc3Bpbl9sb2NrX2lycXNhdmUoJm9iamVjdC0+bG9jaywgZmxhZ3MpOworCW9iamVjdC0+bWluX2NvdW50ID0gMDsKKwlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZvYmplY3QtPmxvY2ssIGZsYWdzKTsKKwlwdXRfb2JqZWN0KG9iamVjdCk7Cit9CisKKy8qCisgKiBNYXJrIHRoZSBvYmplY3QgYXMgYmxhY2stY29sb3JlZCBzbyB0aGF0IGl0IGlzIGlnbm9yZWQgZnJvbSBzY2FucyBhbmQKKyAqIHJlcG9ydGluZy4KKyAqLworc3RhdGljIHZvaWQgbWFrZV9ibGFja19vYmplY3QodW5zaWduZWQgbG9uZyBwdHIpCit7CisJdW5zaWduZWQgbG9uZyBmbGFnczsKKwlzdHJ1Y3Qga21lbWxlYWtfb2JqZWN0ICpvYmplY3Q7CisKKwlvYmplY3QgPSBmaW5kX2FuZF9nZXRfb2JqZWN0KHB0ciwgMCk7CisJaWYgKCFvYmplY3QpIHsKKwkJa21lbWxlYWtfd2Fybigia21lbWxlYWs6IEJsYWNraW5nIHVua25vd24gb2JqZWN0IGF0IDB4JTA4bHhcbiIsCisJCQkgICAgICBwdHIpOworCQlyZXR1cm47CisJfQorCisJc3Bpbl9sb2NrX2lycXNhdmUoJm9iamVjdC0+bG9jaywgZmxhZ3MpOworCW9iamVjdC0+bWluX2NvdW50ID0gLTE7CisJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmb2JqZWN0LT5sb2NrLCBmbGFncyk7CisJcHV0X29iamVjdChvYmplY3QpOworfQorCisvKgorICogQWRkIGEgc2Nhbm5pbmcgYXJlYSB0byB0aGUgb2JqZWN0LiBJZiBhdCBsZWFzdCBvbmUgc3VjaCBhcmVhIGlzIGFkZGVkLAorICoga21lbWxlYWsgd2lsbCBvbmx5IHNjYW4gdGhlc2UgcmFuZ2VzIHJhdGhlciB0aGFuIHRoZSB3aG9sZSBtZW1vcnkgYmxvY2suCisgKi8KK3N0YXRpYyB2b2lkIGFkZF9zY2FuX2FyZWEodW5zaWduZWQgbG9uZyBwdHIsIHVuc2lnbmVkIGxvbmcgb2Zmc2V0LAorCQkJICBzaXplX3QgbGVuZ3RoLCBnZnBfdCBnZnApCit7CisJdW5zaWduZWQgbG9uZyBmbGFnczsKKwlzdHJ1Y3Qga21lbWxlYWtfb2JqZWN0ICpvYmplY3Q7CisJc3RydWN0IGttZW1sZWFrX3NjYW5fYXJlYSAqYXJlYTsKKworCW9iamVjdCA9IGZpbmRfYW5kX2dldF9vYmplY3QocHRyLCAwKTsKKwlpZiAoIW9iamVjdCkgeworCQlrbWVtbGVha193YXJuKCJrbWVtbGVhazogQWRkaW5nIHNjYW4gYXJlYSB0byB1bmtub3duICIKKwkJCSAgICAgICJvYmplY3QgYXQgMHglMDhseFxuIiwgcHRyKTsKKwkJcmV0dXJuOworCX0KKworCWFyZWEgPSBrbWVtX2NhY2hlX2FsbG9jKHNjYW5fYXJlYV9jYWNoZSwgZ2ZwICYgfkdGUF9TTEFCX0JVR19NQVNLKTsKKwlpZiAoIWFyZWEpIHsKKwkJa21lbWxlYWtfd2Fybigia21lbWxlYWs6IENhbm5vdCBhbGxvY2F0ZSBhIHNjYW4gYXJlYVxuIik7CisJCWdvdG8gb3V0OworCX0KKworCXNwaW5fbG9ja19pcnFzYXZlKCZvYmplY3QtPmxvY2ssIGZsYWdzKTsKKwlpZiAob2Zmc2V0ICsgbGVuZ3RoID4gb2JqZWN0LT5zaXplKSB7CisJCWttZW1sZWFrX3dhcm4oImttZW1sZWFrOiBTY2FuIGFyZWEgbGFyZ2VyIHRoYW4gb2JqZWN0ICIKKwkJCSAgICAgICIweCUwOGx4XG4iLCBwdHIpOworCQlkdW1wX29iamVjdF9pbmZvKG9iamVjdCk7CisJCWttZW1fY2FjaGVfZnJlZShzY2FuX2FyZWFfY2FjaGUsIGFyZWEpOworCQlnb3RvIG91dF91bmxvY2s7CisJfQorCisJSU5JVF9ITElTVF9OT0RFKCZhcmVhLT5ub2RlKTsKKwlhcmVhLT5vZmZzZXQgPSBvZmZzZXQ7CisJYXJlYS0+bGVuZ3RoID0gbGVuZ3RoOworCisJaGxpc3RfYWRkX2hlYWQoJmFyZWEtPm5vZGUsICZvYmplY3QtPmFyZWFfbGlzdCk7CitvdXRfdW5sb2NrOgorCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJm9iamVjdC0+bG9jaywgZmxhZ3MpOworb3V0OgorCXB1dF9vYmplY3Qob2JqZWN0KTsKK30KKworLyoKKyAqIFNldCB0aGUgT0JKRUNUX05PX1NDQU4gZmxhZyBmb3IgdGhlIG9iamVjdCBjb3JyZXNwb25kaW5nIHRvIHRoZSBnaXZlCisgKiBwb2ludGVyLiBTdWNoIG9iamVjdCB3aWxsIG5vdCBiZSBzY2FubmVkIGJ5IGttZW1sZWFrIGJ1dCByZWZlcmVuY2VzIHRvIGl0CisgKiBhcmUgc2VhcmNoZWQuCisgKi8KK3N0YXRpYyB2b2lkIG9iamVjdF9ub19zY2FuKHVuc2lnbmVkIGxvbmcgcHRyKQoreworCXVuc2lnbmVkIGxvbmcgZmxhZ3M7CisJc3RydWN0IGttZW1sZWFrX29iamVjdCAqb2JqZWN0OworCisJb2JqZWN0ID0gZmluZF9hbmRfZ2V0X29iamVjdChwdHIsIDApOworCWlmICghb2JqZWN0KSB7CisJCWttZW1sZWFrX3dhcm4oImttZW1sZWFrOiBOb3Qgc2Nhbm5pbmcgdW5rbm93biBvYmplY3QgYXQgIgorCQkJICAgICAgIjB4JTA4bHhcbiIsIHB0cik7CisJCXJldHVybjsKKwl9CisKKwlzcGluX2xvY2tfaXJxc2F2ZSgmb2JqZWN0LT5sb2NrLCBmbGFncyk7CisJb2JqZWN0LT5mbGFncyB8PSBPQkpFQ1RfTk9fU0NBTjsKKwlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZvYmplY3QtPmxvY2ssIGZsYWdzKTsKKwlwdXRfb2JqZWN0KG9iamVjdCk7Cit9CisKKy8qCisgKiBMb2cgYW4gZWFybHkga21lbWxlYWtfKiBjYWxsIHRvIHRoZSBlYXJseV9sb2cgYnVmZmVyLiBUaGVzZSBjYWxscyB3aWxsIGJlCisgKiBwcm9jZXNzZWQgbGF0ZXIgb25jZSBrbWVtbGVhayBpcyBmdWxseSBpbml0aWFsaXplZC4KKyAqLworc3RhdGljIHZvaWQgbG9nX2Vhcmx5KGludCBvcF90eXBlLCBjb25zdCB2b2lkICpwdHIsIHNpemVfdCBzaXplLAorCQkgICAgICBpbnQgbWluX2NvdW50LCB1bnNpZ25lZCBsb25nIG9mZnNldCwgc2l6ZV90IGxlbmd0aCkKK3sKKwl1bnNpZ25lZCBsb25nIGZsYWdzOworCXN0cnVjdCBlYXJseV9sb2cgKmxvZzsKKworCWlmIChjcnRfZWFybHlfbG9nID49IEFSUkFZX1NJWkUoZWFybHlfbG9nKSkgeworCQlrbWVtbGVha19wYW5pYygia21lbWxlYWs6IEVhcmx5IGxvZyBidWZmZXIgZXhjZWVkZWRcbiIpOworCQlyZXR1cm47CisJfQorCisJLyoKKwkgKiBUaGVyZSBpcyBubyBuZWVkIGZvciBsb2NraW5nIHNpbmNlIHRoZSBrZXJuZWwgaXMgc3RpbGwgaW4gVVAgbW9kZQorCSAqIGF0IHRoaXMgc3RhZ2UuIERpc2FibGluZyB0aGUgSVJRcyBpcyBlbm91Z2guCisJICovCisJbG9jYWxfaXJxX3NhdmUoZmxhZ3MpOworCWxvZyA9ICZlYXJseV9sb2dbY3J0X2Vhcmx5X2xvZ107CisJbG9nLT5vcF90eXBlID0gb3BfdHlwZTsKKwlsb2ctPnB0ciA9IHB0cjsKKwlsb2ctPnNpemUgPSBzaXplOworCWxvZy0+bWluX2NvdW50ID0gbWluX2NvdW50OworCWxvZy0+b2Zmc2V0ID0gb2Zmc2V0OworCWxvZy0+bGVuZ3RoID0gbGVuZ3RoOworCWNydF9lYXJseV9sb2crKzsKKwlsb2NhbF9pcnFfcmVzdG9yZShmbGFncyk7Cit9CisKKy8qCisgKiBNZW1vcnkgYWxsb2NhdGlvbiBmdW5jdGlvbiBjYWxsYmFjay4gVGhpcyBmdW5jdGlvbiBpcyBjYWxsZWQgZnJvbSB0aGUKKyAqIGtlcm5lbCBhbGxvY2F0b3JzIHdoZW4gYSBuZXcgYmxvY2sgaXMgYWxsb2NhdGVkIChrbWVtX2NhY2hlX2FsbG9jLCBrbWFsbG9jLAorICogdm1hbGxvYyBldGMuKS4KKyAqLwordm9pZCBrbWVtbGVha19hbGxvYyhjb25zdCB2b2lkICpwdHIsIHNpemVfdCBzaXplLCBpbnQgbWluX2NvdW50LCBnZnBfdCBnZnApCit7CisJcHJfZGVidWcoIiVzKDB4JXAsICV6dSwgJWQpXG4iLCBfX2Z1bmNfXywgcHRyLCBzaXplLCBtaW5fY291bnQpOworCisJaWYgKGF0b21pY19yZWFkKCZrbWVtbGVha19lbmFibGVkKSAmJiBwdHIgJiYgIUlTX0VSUihwdHIpKQorCQljcmVhdGVfb2JqZWN0KCh1bnNpZ25lZCBsb25nKXB0ciwgc2l6ZSwgbWluX2NvdW50LCBnZnApOworCWVsc2UgaWYgKGF0b21pY19yZWFkKCZrbWVtbGVha19lYXJseV9sb2cpKQorCQlsb2dfZWFybHkoS01FTUxFQUtfQUxMT0MsIHB0ciwgc2l6ZSwgbWluX2NvdW50LCAwLCAwKTsKK30KK0VYUE9SVF9TWU1CT0xfR1BMKGttZW1sZWFrX2FsbG9jKTsKKworLyoKKyAqIE1lbW9yeSBmcmVlaW5nIGZ1bmN0aW9uIGNhbGxiYWNrLiBUaGlzIGZ1bmN0aW9uIGlzIGNhbGxlZCBmcm9tIHRoZSBrZXJuZWwKKyAqIGFsbG9jYXRvcnMgd2hlbiBhIGJsb2NrIGlzIGZyZWVkIChrbWVtX2NhY2hlX2ZyZWUsIGtmcmVlLCB2ZnJlZSBldGMuKS4KKyAqLwordm9pZCBrbWVtbGVha19mcmVlKGNvbnN0IHZvaWQgKnB0cikKK3sKKwlwcl9kZWJ1ZygiJXMoMHglcClcbiIsIF9fZnVuY19fLCBwdHIpOworCisJaWYgKGF0b21pY19yZWFkKCZrbWVtbGVha19lbmFibGVkKSAmJiBwdHIgJiYgIUlTX0VSUihwdHIpKQorCQlkZWxldGVfb2JqZWN0KCh1bnNpZ25lZCBsb25nKXB0cik7CisJZWxzZSBpZiAoYXRvbWljX3JlYWQoJmttZW1sZWFrX2Vhcmx5X2xvZykpCisJCWxvZ19lYXJseShLTUVNTEVBS19GUkVFLCBwdHIsIDAsIDAsIDAsIDApOworfQorRVhQT1JUX1NZTUJPTF9HUEwoa21lbWxlYWtfZnJlZSk7CisKKy8qCisgKiBNYXJrIGFuIGFscmVhZHkgYWxsb2NhdGVkIG1lbW9yeSBibG9jayBhcyBhIGZhbHNlIHBvc2l0aXZlLiBUaGlzIHdpbGwgY2F1c2UKKyAqIHRoZSBibG9jayB0byBubyBsb25nZXIgYmUgcmVwb3J0ZWQgYXMgbGVhayBhbmQgYWx3YXlzIGJlIHNjYW5uZWQuCisgKi8KK3ZvaWQga21lbWxlYWtfbm90X2xlYWsoY29uc3Qgdm9pZCAqcHRyKQoreworCXByX2RlYnVnKCIlcygweCVwKVxuIiwgX19mdW5jX18sIHB0cik7CisKKwlpZiAoYXRvbWljX3JlYWQoJmttZW1sZWFrX2VuYWJsZWQpICYmIHB0ciAmJiAhSVNfRVJSKHB0cikpCisJCW1ha2VfZ3JheV9vYmplY3QoKHVuc2lnbmVkIGxvbmcpcHRyKTsKKwllbHNlIGlmIChhdG9taWNfcmVhZCgma21lbWxlYWtfZWFybHlfbG9nKSkKKwkJbG9nX2Vhcmx5KEtNRU1MRUFLX05PVF9MRUFLLCBwdHIsIDAsIDAsIDAsIDApOworfQorRVhQT1JUX1NZTUJPTChrbWVtbGVha19ub3RfbGVhayk7CisKKy8qCisgKiBJZ25vcmUgYSBtZW1vcnkgYmxvY2suIFRoaXMgaXMgdXN1YWxseSBkb25lIHdoZW4gaXQgaXMga25vd24gdGhhdCB0aGUKKyAqIGNvcnJlc3BvbmRpbmcgYmxvY2sgaXMgbm90IGEgbGVhayBhbmQgZG9lcyBub3QgY29udGFpbiBhbnkgcmVmZXJlbmNlcyB0bworICogb3RoZXIgYWxsb2NhdGVkIG1lbW9yeSBibG9ja3MuCisgKi8KK3ZvaWQga21lbWxlYWtfaWdub3JlKGNvbnN0IHZvaWQgKnB0cikKK3sKKwlwcl9kZWJ1ZygiJXMoMHglcClcbiIsIF9fZnVuY19fLCBwdHIpOworCisJaWYgKGF0b21pY19yZWFkKCZrbWVtbGVha19lbmFibGVkKSAmJiBwdHIgJiYgIUlTX0VSUihwdHIpKQorCQltYWtlX2JsYWNrX29iamVjdCgodW5zaWduZWQgbG9uZylwdHIpOworCWVsc2UgaWYgKGF0b21pY19yZWFkKCZrbWVtbGVha19lYXJseV9sb2cpKQorCQlsb2dfZWFybHkoS01FTUxFQUtfSUdOT1JFLCBwdHIsIDAsIDAsIDAsIDApOworfQorRVhQT1JUX1NZTUJPTChrbWVtbGVha19pZ25vcmUpOworCisvKgorICogTGltaXQgdGhlIHJhbmdlIHRvIGJlIHNjYW5uZWQgaW4gYW4gYWxsb2NhdGVkIG1lbW9yeSBibG9jay4KKyAqLwordm9pZCBrbWVtbGVha19zY2FuX2FyZWEoY29uc3Qgdm9pZCAqcHRyLCB1bnNpZ25lZCBsb25nIG9mZnNldCwgc2l6ZV90IGxlbmd0aCwKKwkJCWdmcF90IGdmcCkKK3sKKwlwcl9kZWJ1ZygiJXMoMHglcClcbiIsIF9fZnVuY19fLCBwdHIpOworCisJaWYgKGF0b21pY19yZWFkKCZrbWVtbGVha19lbmFibGVkKSAmJiBwdHIgJiYgIUlTX0VSUihwdHIpKQorCQlhZGRfc2Nhbl9hcmVhKCh1bnNpZ25lZCBsb25nKXB0ciwgb2Zmc2V0LCBsZW5ndGgsIGdmcCk7CisJZWxzZSBpZiAoYXRvbWljX3JlYWQoJmttZW1sZWFrX2Vhcmx5X2xvZykpCisJCWxvZ19lYXJseShLTUVNTEVBS19TQ0FOX0FSRUEsIHB0ciwgMCwgMCwgb2Zmc2V0LCBsZW5ndGgpOworfQorRVhQT1JUX1NZTUJPTChrbWVtbGVha19zY2FuX2FyZWEpOworCisvKgorICogSW5mb3JtIGttZW1sZWFrIG5vdCB0byBzY2FuIHRoZSBnaXZlbiBtZW1vcnkgYmxvY2suCisgKi8KK3ZvaWQga21lbWxlYWtfbm9fc2Nhbihjb25zdCB2b2lkICpwdHIpCit7CisJcHJfZGVidWcoIiVzKDB4JXApXG4iLCBfX2Z1bmNfXywgcHRyKTsKKworCWlmIChhdG9taWNfcmVhZCgma21lbWxlYWtfZW5hYmxlZCkgJiYgcHRyICYmICFJU19FUlIocHRyKSkKKwkJb2JqZWN0X25vX3NjYW4oKHVuc2lnbmVkIGxvbmcpcHRyKTsKKwllbHNlIGlmIChhdG9taWNfcmVhZCgma21lbWxlYWtfZWFybHlfbG9nKSkKKwkJbG9nX2Vhcmx5KEtNRU1MRUFLX05PX1NDQU4sIHB0ciwgMCwgMCwgMCwgMCk7Cit9CitFWFBPUlRfU1lNQk9MKGttZW1sZWFrX25vX3NjYW4pOworCisvKgorICogWWllbGQgdGhlIENQVSBzbyB0aGF0IG90aGVyIHRhc2tzIGdldCBhIGNoYW5jZSB0byBydW4uICBUaGUgeWllbGRpbmcgaXMKKyAqIHJhdGUtbGltaXRlZCB0byBhdm9pZCBleGNlc3NpdmUgbnVtYmVyIG9mIGNhbGxzIHRvIHRoZSBzY2hlZHVsZSgpIGZ1bmN0aW9uCisgKiBkdXJpbmcgbWVtb3J5IHNjYW5uaW5nLgorICovCitzdGF0aWMgdm9pZCBzY2FuX3lpZWxkKHZvaWQpCit7CisJbWlnaHRfc2xlZXAoKTsKKworCWlmICh0aW1lX2lzX2JlZm9yZV9lcV9qaWZmaWVzKG5leHRfc2Nhbl95aWVsZCkpIHsKKwkJc2NoZWR1bGUoKTsKKwkJbmV4dF9zY2FuX3lpZWxkID0gamlmZmllcyArIGppZmZpZXNfc2Nhbl95aWVsZDsKKwl9Cit9CisKKy8qCisgKiBNZW1vcnkgc2Nhbm5pbmcgaXMgYSBsb25nIHByb2Nlc3MgYW5kIGl0IG5lZWRzIHRvIGJlIGludGVycnVwdGFibGUuIFRoaXMKKyAqIGZ1bmN0aW9uIGNoZWNrcyB3aGV0aGVyIHN1Y2ggaW50ZXJydXB0IGNvbmRpdGlvbiBvY2N1cmVkLgorICovCitzdGF0aWMgaW50IHNjYW5fc2hvdWxkX3N0b3Aodm9pZCkKK3sKKwlpZiAoIWF0b21pY19yZWFkKCZrbWVtbGVha19lbmFibGVkKSkKKwkJcmV0dXJuIDE7CisKKwkvKgorCSAqIFRoaXMgZnVuY3Rpb24gbWF5IGJlIGNhbGxlZCBmcm9tIGVpdGhlciBwcm9jZXNzIG9yIGt0aHJlYWQgY29udGV4dCwKKwkgKiBoZW5jZSB0aGUgbmVlZCB0byBjaGVjayBmb3IgYm90aCBzdG9wIGNvbmRpdGlvbnMuCisJICovCisJaWYgKGN1cnJlbnQtPm1tKQorCQlyZXR1cm4gc2lnbmFsX3BlbmRpbmcoY3VycmVudCk7CisJZWxzZQorCQlyZXR1cm4ga3RocmVhZF9zaG91bGRfc3RvcCgpOworCisJcmV0dXJuIDA7Cit9CisKKy8qCisgKiBTY2FuIGEgbWVtb3J5IGJsb2NrIChleGNsdXNpdmUgcmFuZ2UpIGZvciB2YWxpZCBwb2ludGVycyBhbmQgYWRkIHRob3NlCisgKiBmb3VuZCB0byB0aGUgZ3JheSBsaXN0LgorICovCitzdGF0aWMgdm9pZCBzY2FuX2Jsb2NrKHZvaWQgKl9zdGFydCwgdm9pZCAqX2VuZCwKKwkJICAgICAgIHN0cnVjdCBrbWVtbGVha19vYmplY3QgKnNjYW5uZWQpCit7CisJdW5zaWduZWQgbG9uZyAqcHRyOworCXVuc2lnbmVkIGxvbmcgKnN0YXJ0ID0gUFRSX0FMSUdOKF9zdGFydCwgQllURVNfUEVSX1BPSU5URVIpOworCXVuc2lnbmVkIGxvbmcgKmVuZCA9IF9lbmQgLSAoQllURVNfUEVSX1BPSU5URVIgLSAxKTsKKworCWZvciAocHRyID0gc3RhcnQ7IHB0ciA8IGVuZDsgcHRyKyspIHsKKwkJdW5zaWduZWQgbG9uZyBmbGFnczsKKwkJdW5zaWduZWQgbG9uZyBwb2ludGVyID0gKnB0cjsKKwkJc3RydWN0IGttZW1sZWFrX29iamVjdCAqb2JqZWN0OworCisJCWlmIChzY2FuX3Nob3VsZF9zdG9wKCkpCisJCQlicmVhazsKKworCQkvKgorCQkgKiBXaGVuIHNjYW5uaW5nIGEgbWVtb3J5IGJsb2NrIHdpdGggYSBjb3JyZXNwb25kaW5nCisJCSAqIGttZW1sZWFrX29iamVjdCwgdGhlIENQVSB5aWVsZGluZyBpcyBoYW5kbGVkIGluIHRoZSBjYWxsaW5nCisJCSAqIGNvZGUgc2luY2UgaXQgaG9sZHMgdGhlIG9iamVjdC0+bG9jayB0byBhdm9pZCB0aGUgYmxvY2sKKwkJICogZnJlZWluZy4KKwkJICovCisJCWlmICghc2Nhbm5lZCkKKwkJCXNjYW5feWllbGQoKTsKKworCQlvYmplY3QgPSBmaW5kX2FuZF9nZXRfb2JqZWN0KHBvaW50ZXIsIDEpOworCQlpZiAoIW9iamVjdCkKKwkJCWNvbnRpbnVlOworCQlpZiAob2JqZWN0ID09IHNjYW5uZWQpIHsKKwkJCS8qIHNlbGYgcmVmZXJlbmNlZCwgaWdub3JlICovCisJCQlwdXRfb2JqZWN0KG9iamVjdCk7CisJCQljb250aW51ZTsKKwkJfQorCisJCS8qCisJCSAqIEF2b2lkIHRoZSBsb2NrZGVwIHJlY3Vyc2l2ZSB3YXJuaW5nIG9uIG9iamVjdC0+bG9jayBiZWluZworCQkgKiBwcmV2aW91c2x5IGFjcXVpcmVkIGluIHNjYW5fb2JqZWN0KCkuIFRoZXNlIGxvY2tzIGFyZQorCQkgKiBlbmNsb3NlZCBieSBzY2FuX211dGV4LgorCQkgKi8KKwkJc3Bpbl9sb2NrX2lycXNhdmVfbmVzdGVkKCZvYmplY3QtPmxvY2ssIGZsYWdzLAorCQkJCQkgU0lOR0xFX0RFUFRIX05FU1RJTkcpOworCQlpZiAoIWNvbG9yX3doaXRlKG9iamVjdCkpIHsKKwkJCS8qIG5vbi1vcnBoYW4sIGlnbm9yZWQgb3IgbmV3ICovCisJCQlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZvYmplY3QtPmxvY2ssIGZsYWdzKTsKKwkJCXB1dF9vYmplY3Qob2JqZWN0KTsKKwkJCWNvbnRpbnVlOworCQl9CisKKwkJLyoKKwkJICogSW5jcmVhc2UgdGhlIG9iamVjdCdzIHJlZmVyZW5jZSBjb3VudCAobnVtYmVyIG9mIHBvaW50ZXJzCisJCSAqIHRvIHRoZSBtZW1vcnkgYmxvY2spLiBJZiB0aGlzIGNvdW50IHJlYWNoZXMgdGhlIHJlcXVpcmVkCisJCSAqIG1pbmltdW0sIHRoZSBvYmplY3QncyBjb2xvciB3aWxsIGJlY29tZSBncmF5IGFuZCBpdCB3aWxsIGJlCisJCSAqIGFkZGVkIHRvIHRoZSBncmF5X2xpc3QuCisJCSAqLworCQlvYmplY3QtPmNvdW50Kys7CisJCWlmIChjb2xvcl9ncmF5KG9iamVjdCkpCisJCQlsaXN0X2FkZF90YWlsKCZvYmplY3QtPmdyYXlfbGlzdCwgJmdyYXlfbGlzdCk7CisJCWVsc2UKKwkJCXB1dF9vYmplY3Qob2JqZWN0KTsKKwkJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmb2JqZWN0LT5sb2NrLCBmbGFncyk7CisJfQorfQorCisvKgorICogU2NhbiBhIG1lbW9yeSBibG9jayBjb3JyZXNwb25kaW5nIHRvIGEga21lbWxlYWtfb2JqZWN0LiBBIGNvbmRpdGlvbiBpcworICogdGhhdCBvYmplY3QtPnVzZV9jb3VudCA+PSAxLgorICovCitzdGF0aWMgdm9pZCBzY2FuX29iamVjdChzdHJ1Y3Qga21lbWxlYWtfb2JqZWN0ICpvYmplY3QpCit7CisJc3RydWN0IGttZW1sZWFrX3NjYW5fYXJlYSAqYXJlYTsKKwlzdHJ1Y3QgaGxpc3Rfbm9kZSAqZWxlbTsKKwl1bnNpZ25lZCBsb25nIGZsYWdzOworCisJLyoKKwkgKiBPbmNlIHRoZSBvYmplY3QtPmxvY2sgaXMgYXF1aXJlZCwgdGhlIGNvcnJlc3BvbmRpbmcgbWVtb3J5IGJsb2NrCisJICogY2Fubm90IGJlIGZyZWVkICh0aGUgc2FtZSBsb2NrIGlzIGFxdWlyZWQgaW4gZGVsZXRlX29iamVjdCkuCisJICovCisJc3Bpbl9sb2NrX2lycXNhdmUoJm9iamVjdC0+bG9jaywgZmxhZ3MpOworCWlmIChvYmplY3QtPmZsYWdzICYgT0JKRUNUX05PX1NDQU4pCisJCWdvdG8gb3V0OworCWlmICghKG9iamVjdC0+ZmxhZ3MgJiBPQkpFQ1RfQUxMT0NBVEVEKSkKKwkJLyogYWxyZWFkeSBmcmVlZCBvYmplY3QgKi8KKwkJZ290byBvdXQ7CisJaWYgKGhsaXN0X2VtcHR5KCZvYmplY3QtPmFyZWFfbGlzdCkpCisJCXNjYW5fYmxvY2soKHZvaWQgKilvYmplY3QtPnBvaW50ZXIsCisJCQkgICAodm9pZCAqKShvYmplY3QtPnBvaW50ZXIgKyBvYmplY3QtPnNpemUpLCBvYmplY3QpOworCWVsc2UKKwkJaGxpc3RfZm9yX2VhY2hfZW50cnkoYXJlYSwgZWxlbSwgJm9iamVjdC0+YXJlYV9saXN0LCBub2RlKQorCQkJc2Nhbl9ibG9jaygodm9pZCAqKShvYmplY3QtPnBvaW50ZXIgKyBhcmVhLT5vZmZzZXQpLAorCQkJCSAgICh2b2lkICopKG9iamVjdC0+cG9pbnRlciArIGFyZWEtPm9mZnNldAorCQkJCQkgICAgKyBhcmVhLT5sZW5ndGgpLCBvYmplY3QpOworb3V0OgorCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJm9iamVjdC0+bG9jaywgZmxhZ3MpOworfQorCisvKgorICogU2NhbiBkYXRhIHNlY3Rpb25zIGFuZCBhbGwgdGhlIHJlZmVyZW5jZWQgbWVtb3J5IGJsb2NrcyBhbGxvY2F0ZWQgdmlhIHRoZQorICoga2VybmVsJ3Mgc3RhbmRhcmQgYWxsb2NhdG9ycy4gVGhpcyBmdW5jdGlvbiBtdXN0IGJlIGNhbGxlZCB3aXRoIHRoZQorICogc2Nhbl9tdXRleCBoZWxkLgorICovCitzdGF0aWMgdm9pZCBrbWVtbGVha19zY2FuKHZvaWQpCit7CisJdW5zaWduZWQgbG9uZyBmbGFnczsKKwlzdHJ1Y3Qga21lbWxlYWtfb2JqZWN0ICpvYmplY3QsICp0bXA7CisJc3RydWN0IHRhc2tfc3RydWN0ICp0YXNrOworCWludCBpOworCisJLyogcHJlcGFyZSB0aGUga21lbWxlYWtfb2JqZWN0J3MgKi8KKwlyY3VfcmVhZF9sb2NrKCk7CisJbGlzdF9mb3JfZWFjaF9lbnRyeV9yY3Uob2JqZWN0LCAmb2JqZWN0X2xpc3QsIG9iamVjdF9saXN0KSB7CisJCXNwaW5fbG9ja19pcnFzYXZlKCZvYmplY3QtPmxvY2ssIGZsYWdzKTsKKyNpZmRlZiBERUJVRworCQkvKgorCQkgKiBXaXRoIGEgZmV3IGV4Y2VwdGlvbnMgdGhlcmUgc2hvdWxkIGJlIGEgbWF4aW11bSBvZgorCQkgKiAxIHJlZmVyZW5jZSB0byBhbnkgb2JqZWN0IGF0IHRoaXMgcG9pbnQuCisJCSAqLworCQlpZiAoYXRvbWljX3JlYWQoJm9iamVjdC0+dXNlX2NvdW50KSA+IDEpIHsKKwkJCXByX2RlYnVnKCJrbWVtbGVhazogb2JqZWN0LT51c2VfY291bnQgPSAlZFxuIiwKKwkJCQkgYXRvbWljX3JlYWQoJm9iamVjdC0+dXNlX2NvdW50KSk7CisJCQlkdW1wX29iamVjdF9pbmZvKG9iamVjdCk7CisJCX0KKyNlbmRpZgorCQkvKiByZXNldCB0aGUgcmVmZXJlbmNlIGNvdW50ICh3aGl0ZW4gdGhlIG9iamVjdCkgKi8KKwkJb2JqZWN0LT5jb3VudCA9IDA7CisJCWlmIChjb2xvcl9ncmF5KG9iamVjdCkgJiYgZ2V0X29iamVjdChvYmplY3QpKQorCQkJbGlzdF9hZGRfdGFpbCgmb2JqZWN0LT5ncmF5X2xpc3QsICZncmF5X2xpc3QpOworCisJCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJm9iamVjdC0+bG9jaywgZmxhZ3MpOworCX0KKwlyY3VfcmVhZF91bmxvY2soKTsKKworCS8qIGRhdGEvYnNzIHNjYW5uaW5nICovCisJc2Nhbl9ibG9jayhfc2RhdGEsIF9lZGF0YSwgTlVMTCk7CisJc2Nhbl9ibG9jayhfX2Jzc19zdGFydCwgX19ic3Nfc3RvcCwgTlVMTCk7CisKKyNpZmRlZiBDT05GSUdfU01QCisJLyogcGVyLWNwdSBzZWN0aW9ucyBzY2FubmluZyAqLworCWZvcl9lYWNoX3Bvc3NpYmxlX2NwdShpKQorCQlzY2FuX2Jsb2NrKF9fcGVyX2NwdV9zdGFydCArIHBlcl9jcHVfb2Zmc2V0KGkpLAorCQkJICAgX19wZXJfY3B1X2VuZCArIHBlcl9jcHVfb2Zmc2V0KGkpLCBOVUxMKTsKKyNlbmRpZgorCisJLyoKKwkgKiBTdHJ1Y3QgcGFnZSBzY2FubmluZyBmb3IgZWFjaCBub2RlLiBUaGUgY29kZSBiZWxvdyBpcyBub3QgeWV0IHNhZmUKKwkgKiB3aXRoIE1FTU9SWV9IT1RQTFVHLgorCSAqLworCWZvcl9lYWNoX29ubGluZV9ub2RlKGkpIHsKKwkJcGdfZGF0YV90ICpwZ2RhdCA9IE5PREVfREFUQShpKTsKKwkJdW5zaWduZWQgbG9uZyBzdGFydF9wZm4gPSBwZ2RhdC0+bm9kZV9zdGFydF9wZm47CisJCXVuc2lnbmVkIGxvbmcgZW5kX3BmbiA9IHN0YXJ0X3BmbiArIHBnZGF0LT5ub2RlX3NwYW5uZWRfcGFnZXM7CisJCXVuc2lnbmVkIGxvbmcgcGZuOworCisJCWZvciAocGZuID0gc3RhcnRfcGZuOyBwZm4gPCBlbmRfcGZuOyBwZm4rKykgeworCQkJc3RydWN0IHBhZ2UgKnBhZ2U7CisKKwkJCWlmICghcGZuX3ZhbGlkKHBmbikpCisJCQkJY29udGludWU7CisJCQlwYWdlID0gcGZuX3RvX3BhZ2UocGZuKTsKKwkJCS8qIG9ubHkgc2NhbiBpZiBwYWdlIGlzIGluIHVzZSAqLworCQkJaWYgKHBhZ2VfY291bnQocGFnZSkgPT0gMCkKKwkJCQljb250aW51ZTsKKwkJCXNjYW5fYmxvY2socGFnZSwgcGFnZSArIDEsIE5VTEwpOworCQl9CisJfQorCisJLyoKKwkgKiBTY2FubmluZyB0aGUgdGFzayBzdGFja3MgbWF5IGludHJvZHVjZSBmYWxzZSBuZWdhdGl2ZXMgYW5kIGl0IGlzCisJICogbm90IGVuYWJsZWQgYnkgZGVmYXVsdC4KKwkgKi8KKwlpZiAoa21lbWxlYWtfc3RhY2tfc2NhbikgeworCQlyZWFkX2xvY2soJnRhc2tsaXN0X2xvY2spOworCQlmb3JfZWFjaF9wcm9jZXNzKHRhc2spCisJCQlzY2FuX2Jsb2NrKHRhc2tfc3RhY2tfcGFnZSh0YXNrKSwKKwkJCQkgICB0YXNrX3N0YWNrX3BhZ2UodGFzaykgKyBUSFJFQURfU0laRSwgTlVMTCk7CisJCXJlYWRfdW5sb2NrKCZ0YXNrbGlzdF9sb2NrKTsKKwl9CisKKwkvKgorCSAqIFNjYW4gdGhlIG9iamVjdHMgYWxyZWFkeSByZWZlcmVuY2VkIGZyb20gdGhlIHNlY3Rpb25zIHNjYW5uZWQKKwkgKiBhYm92ZS4gTW9yZSBvYmplY3RzIHdpbGwgYmUgcmVmZXJlbmNlZCBhbmQsIGlmIHRoZXJlIGFyZSBubyBtZW1vcnkKKwkgKiBsZWFrcywgYWxsIHRoZSBvYmplY3RzIHdpbGwgYmUgc2Nhbm5lZC4gVGhlIGxpc3QgdHJhdmVyc2FsIGlzIHNhZmUKKwkgKiBmb3IgYm90aCB0YWlsIGFkZGl0aW9ucyBhbmQgcmVtb3ZhbHMgZnJvbSBpbnNpZGUgdGhlIGxvb3AuIFRoZQorCSAqIGttZW1sZWFrIG9iamVjdHMgY2Fubm90IGJlIGZyZWVkIGZyb20gb3V0c2lkZSB0aGUgbG9vcCBiZWNhdXNlIHRoZWlyCisJICogdXNlX2NvdW50IHdhcyBpbmNyZWFzZWQuCisJICovCisJb2JqZWN0ID0gbGlzdF9lbnRyeShncmF5X2xpc3QubmV4dCwgdHlwZW9mKCpvYmplY3QpLCBncmF5X2xpc3QpOworCXdoaWxlICgmb2JqZWN0LT5ncmF5X2xpc3QgIT0gJmdyYXlfbGlzdCkgeworCQlzY2FuX3lpZWxkKCk7CisKKwkJLyogbWF5IGFkZCBuZXcgb2JqZWN0cyB0byB0aGUgbGlzdCAqLworCQlpZiAoIXNjYW5fc2hvdWxkX3N0b3AoKSkKKwkJCXNjYW5fb2JqZWN0KG9iamVjdCk7CisKKwkJdG1wID0gbGlzdF9lbnRyeShvYmplY3QtPmdyYXlfbGlzdC5uZXh0LCB0eXBlb2YoKm9iamVjdCksCisJCQkJIGdyYXlfbGlzdCk7CisKKwkJLyogcmVtb3ZlIHRoZSBvYmplY3QgZnJvbSB0aGUgbGlzdCBhbmQgcmVsZWFzZSBpdCAqLworCQlsaXN0X2RlbCgmb2JqZWN0LT5ncmF5X2xpc3QpOworCQlwdXRfb2JqZWN0KG9iamVjdCk7CisKKwkJb2JqZWN0ID0gdG1wOworCX0KKwlXQVJOX09OKCFsaXN0X2VtcHR5KCZncmF5X2xpc3QpKTsKK30KKworLyoKKyAqIFRocmVhZCBmdW5jdGlvbiBwZXJmb3JtaW5nIGF1dG9tYXRpYyBtZW1vcnkgc2Nhbm5pbmcuIFVucmVmZXJlbmNlZCBvYmplY3RzCisgKiBhdCB0aGUgZW5kIG9mIGEgbWVtb3J5IHNjYW4gYXJlIHJlcG9ydGVkIGJ1dCBvbmx5IHRoZSBmaXJzdCB0aW1lLgorICovCitzdGF0aWMgaW50IGttZW1sZWFrX3NjYW5fdGhyZWFkKHZvaWQgKmFyZykKK3sKKwlzdGF0aWMgaW50IGZpcnN0X3J1biA9IDE7CisKKwlwcl9pbmZvKCJrbWVtbGVhazogQXV0b21hdGljIG1lbW9yeSBzY2FubmluZyB0aHJlYWQgc3RhcnRlZFxuIik7CisKKwkvKgorCSAqIFdhaXQgYmVmb3JlIHRoZSBmaXJzdCBzY2FuIHRvIGFsbG93IHRoZSBzeXN0ZW0gdG8gZnVsbHkgaW5pdGlhbGl6ZS4KKwkgKi8KKwlpZiAoZmlyc3RfcnVuKSB7CisJCWZpcnN0X3J1biA9IDA7CisJCXNzbGVlcChTRUNTX0ZJUlNUX1NDQU4pOworCX0KKworCXdoaWxlICgha3RocmVhZF9zaG91bGRfc3RvcCgpKSB7CisJCXN0cnVjdCBrbWVtbGVha19vYmplY3QgKm9iamVjdDsKKwkJc2lnbmVkIGxvbmcgdGltZW91dCA9IGppZmZpZXNfc2Nhbl93YWl0OworCisJCW11dGV4X2xvY2soJnNjYW5fbXV0ZXgpOworCisJCWttZW1sZWFrX3NjYW4oKTsKKwkJcmVwb3J0ZWRfbGVha3MgPSAwOworCisJCXJjdV9yZWFkX2xvY2soKTsKKwkJbGlzdF9mb3JfZWFjaF9lbnRyeV9yY3Uob2JqZWN0LCAmb2JqZWN0X2xpc3QsIG9iamVjdF9saXN0KSB7CisJCQl1bnNpZ25lZCBsb25nIGZsYWdzOworCisJCQlpZiAocmVwb3J0ZWRfbGVha3MgPj0gUkVQT1JUU19OUikKKwkJCQlicmVhazsKKwkJCXNwaW5fbG9ja19pcnFzYXZlKCZvYmplY3QtPmxvY2ssIGZsYWdzKTsKKwkJCWlmICghKG9iamVjdC0+ZmxhZ3MgJiBPQkpFQ1RfUkVQT1JURUQpICYmCisJCQkgICAgdW5yZWZlcmVuY2VkX29iamVjdChvYmplY3QpKSB7CisJCQkJcHJpbnRfdW5yZWZlcmVuY2VkKE5VTEwsIG9iamVjdCk7CisJCQkJb2JqZWN0LT5mbGFncyB8PSBPQkpFQ1RfUkVQT1JURUQ7CisJCQkJcmVwb3J0ZWRfbGVha3MrKzsKKwkJCX0gZWxzZSBpZiAoKG9iamVjdC0+ZmxhZ3MgJiBPQkpFQ1RfUkVQT1JURUQpICYmCisJCQkJICAgcmVmZXJlbmNlZF9vYmplY3Qob2JqZWN0KSkgeworCQkJCXByaW50X3JlZmVyZW5jZWQob2JqZWN0KTsKKwkJCQlvYmplY3QtPmZsYWdzICY9IH5PQkpFQ1RfUkVQT1JURUQ7CisJCQl9CisJCQlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZvYmplY3QtPmxvY2ssIGZsYWdzKTsKKwkJfQorCQlyY3VfcmVhZF91bmxvY2soKTsKKworCQltdXRleF91bmxvY2soJnNjYW5fbXV0ZXgpOworCQkvKiB3YWl0IGJlZm9yZSB0aGUgbmV4dCBzY2FuICovCisJCXdoaWxlICh0aW1lb3V0ICYmICFrdGhyZWFkX3Nob3VsZF9zdG9wKCkpCisJCQl0aW1lb3V0ID0gc2NoZWR1bGVfdGltZW91dF9pbnRlcnJ1cHRpYmxlKHRpbWVvdXQpOworCX0KKworCXByX2luZm8oImttZW1sZWFrOiBBdXRvbWF0aWMgbWVtb3J5IHNjYW5uaW5nIHRocmVhZCBlbmRlZFxuIik7CisKKwlyZXR1cm4gMDsKK30KKworLyoKKyAqIFN0YXJ0IHRoZSBhdXRvbWF0aWMgbWVtb3J5IHNjYW5uaW5nIHRocmVhZC4gVGhpcyBmdW5jdGlvbiBtdXN0IGJlIGNhbGxlZAorICogd2l0aCB0aGUga21lbWxlYWtfbXV0ZXggaGVsZC4KKyAqLwordm9pZCBzdGFydF9zY2FuX3RocmVhZCh2b2lkKQoreworCWlmIChzY2FuX3RocmVhZCkKKwkJcmV0dXJuOworCXNjYW5fdGhyZWFkID0ga3RocmVhZF9ydW4oa21lbWxlYWtfc2Nhbl90aHJlYWQsIE5VTEwsICJrbWVtbGVhayIpOworCWlmIChJU19FUlIoc2Nhbl90aHJlYWQpKSB7CisJCXByX3dhcm5pbmcoImttZW1sZWFrOiBGYWlsZWQgdG8gY3JlYXRlIHRoZSBzY2FuIHRocmVhZFxuIik7CisJCXNjYW5fdGhyZWFkID0gTlVMTDsKKwl9Cit9CisKKy8qCisgKiBTdG9wIHRoZSBhdXRvbWF0aWMgbWVtb3J5IHNjYW5uaW5nIHRocmVhZC4gVGhpcyBmdW5jdGlvbiBtdXN0IGJlIGNhbGxlZAorICogd2l0aCB0aGUga21lbWxlYWtfbXV0ZXggaGVsZC4KKyAqLwordm9pZCBzdG9wX3NjYW5fdGhyZWFkKHZvaWQpCit7CisJaWYgKHNjYW5fdGhyZWFkKSB7CisJCWt0aHJlYWRfc3RvcChzY2FuX3RocmVhZCk7CisJCXNjYW5fdGhyZWFkID0gTlVMTDsKKwl9Cit9CisKKy8qCisgKiBJdGVyYXRlIG92ZXIgdGhlIG9iamVjdF9saXN0IGFuZCByZXR1cm4gdGhlIGZpcnN0IHZhbGlkIG9iamVjdCBhdCBvciBhZnRlcgorICogdGhlIHJlcXVpcmVkIHBvc2l0aW9uIHdpdGggaXRzIHVzZV9jb3VudCBpbmNyZW1lbnRlZC4gVGhlIGZ1bmN0aW9uIHRyaWdnZXJzCisgKiBhIG1lbW9yeSBzY2FubmluZyB3aGVuIHRoZSBwb3MgYXJndW1lbnQgcG9pbnRzIHRvIHRoZSBmaXJzdCBwb3NpdGlvbi4KKyAqLworc3RhdGljIHZvaWQgKmttZW1sZWFrX3NlcV9zdGFydChzdHJ1Y3Qgc2VxX2ZpbGUgKnNlcSwgbG9mZl90ICpwb3MpCit7CisJc3RydWN0IGttZW1sZWFrX29iamVjdCAqb2JqZWN0OworCWxvZmZfdCBuID0gKnBvczsKKworCWlmICghbikgeworCQlrbWVtbGVha19zY2FuKCk7CisJCXJlcG9ydGVkX2xlYWtzID0gMDsKKwl9CisJaWYgKHJlcG9ydGVkX2xlYWtzID49IFJFUE9SVFNfTlIpCisJCXJldHVybiBOVUxMOworCisJcmN1X3JlYWRfbG9jaygpOworCWxpc3RfZm9yX2VhY2hfZW50cnlfcmN1KG9iamVjdCwgJm9iamVjdF9saXN0LCBvYmplY3RfbGlzdCkgeworCQlpZiAobi0tID4gMCkKKwkJCWNvbnRpbnVlOworCQlpZiAoZ2V0X29iamVjdChvYmplY3QpKQorCQkJZ290byBvdXQ7CisJfQorCW9iamVjdCA9IE5VTEw7CitvdXQ6CisJcmN1X3JlYWRfdW5sb2NrKCk7CisJcmV0dXJuIG9iamVjdDsKK30KKworLyoKKyAqIFJldHVybiB0aGUgbmV4dCBvYmplY3QgaW4gdGhlIG9iamVjdF9saXN0LiBUaGUgZnVuY3Rpb24gZGVjcmVtZW50cyB0aGUKKyAqIHVzZV9jb3VudCBvZiB0aGUgcHJldmlvdXMgb2JqZWN0IGFuZCBpbmNyZWFzZXMgdGhhdCBvZiB0aGUgbmV4dCBvbmUuCisgKi8KK3N0YXRpYyB2b2lkICprbWVtbGVha19zZXFfbmV4dChzdHJ1Y3Qgc2VxX2ZpbGUgKnNlcSwgdm9pZCAqdiwgbG9mZl90ICpwb3MpCit7CisJc3RydWN0IGttZW1sZWFrX29iamVjdCAqcHJldl9vYmogPSB2OworCXN0cnVjdCBrbWVtbGVha19vYmplY3QgKm5leHRfb2JqID0gTlVMTDsKKwlzdHJ1Y3QgbGlzdF9oZWFkICpuID0gJnByZXZfb2JqLT5vYmplY3RfbGlzdDsKKworCSsrKCpwb3MpOworCWlmIChyZXBvcnRlZF9sZWFrcyA+PSBSRVBPUlRTX05SKQorCQlnb3RvIG91dDsKKworCXJjdV9yZWFkX2xvY2soKTsKKwlsaXN0X2Zvcl9lYWNoX2NvbnRpbnVlX3JjdShuLCAmb2JqZWN0X2xpc3QpIHsKKwkJbmV4dF9vYmogPSBsaXN0X2VudHJ5KG4sIHN0cnVjdCBrbWVtbGVha19vYmplY3QsIG9iamVjdF9saXN0KTsKKwkJaWYgKGdldF9vYmplY3QobmV4dF9vYmopKQorCQkJYnJlYWs7CisJfQorCXJjdV9yZWFkX3VubG9jaygpOworb3V0OgorCXB1dF9vYmplY3QocHJldl9vYmopOworCXJldHVybiBuZXh0X29iajsKK30KKworLyoKKyAqIERlY3JlbWVudCB0aGUgdXNlX2NvdW50IG9mIHRoZSBsYXN0IG9iamVjdCByZXF1aXJlZCwgaWYgYW55LgorICovCitzdGF0aWMgdm9pZCBrbWVtbGVha19zZXFfc3RvcChzdHJ1Y3Qgc2VxX2ZpbGUgKnNlcSwgdm9pZCAqdikKK3sKKwlpZiAodikKKwkJcHV0X29iamVjdCh2KTsKK30KKworLyoKKyAqIFByaW50IHRoZSBpbmZvcm1hdGlvbiBmb3IgYW4gdW5yZWZlcmVuY2VkIG9iamVjdCB0byB0aGUgc2VxIGZpbGUuCisgKi8KK3N0YXRpYyBpbnQga21lbWxlYWtfc2VxX3Nob3coc3RydWN0IHNlcV9maWxlICpzZXEsIHZvaWQgKnYpCit7CisJc3RydWN0IGttZW1sZWFrX29iamVjdCAqb2JqZWN0ID0gdjsKKwl1bnNpZ25lZCBsb25nIGZsYWdzOworCisJc3Bpbl9sb2NrX2lycXNhdmUoJm9iamVjdC0+bG9jaywgZmxhZ3MpOworCWlmICghdW5yZWZlcmVuY2VkX29iamVjdChvYmplY3QpKQorCQlnb3RvIG91dDsKKwlwcmludF91bnJlZmVyZW5jZWQoc2VxLCBvYmplY3QpOworCXJlcG9ydGVkX2xlYWtzKys7CitvdXQ6CisJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmb2JqZWN0LT5sb2NrLCBmbGFncyk7CisJcmV0dXJuIDA7Cit9CisKK3N0YXRpYyBjb25zdCBzdHJ1Y3Qgc2VxX29wZXJhdGlvbnMga21lbWxlYWtfc2VxX29wcyA9IHsKKwkuc3RhcnQgPSBrbWVtbGVha19zZXFfc3RhcnQsCisJLm5leHQgID0ga21lbWxlYWtfc2VxX25leHQsCisJLnN0b3AgID0ga21lbWxlYWtfc2VxX3N0b3AsCisJLnNob3cgID0ga21lbWxlYWtfc2VxX3Nob3csCit9OworCitzdGF0aWMgaW50IGttZW1sZWFrX29wZW4oc3RydWN0IGlub2RlICppbm9kZSwgc3RydWN0IGZpbGUgKmZpbGUpCit7CisJaW50IHJldCA9IDA7CisKKwlpZiAoIWF0b21pY19yZWFkKCZrbWVtbGVha19lbmFibGVkKSkKKwkJcmV0dXJuIC1FQlVTWTsKKworCXJldCA9IG11dGV4X2xvY2tfaW50ZXJydXB0aWJsZSgma21lbWxlYWtfbXV0ZXgpOworCWlmIChyZXQgPCAwKQorCQlnb3RvIG91dDsKKwlpZiAoZmlsZS0+Zl9tb2RlICYgRk1PREVfUkVBRCkgeworCQlyZXQgPSBtdXRleF9sb2NrX2ludGVycnVwdGlibGUoJnNjYW5fbXV0ZXgpOworCQlpZiAocmV0IDwgMCkKKwkJCWdvdG8ga21lbWxlYWtfdW5sb2NrOworCQlyZXQgPSBzZXFfb3BlbihmaWxlLCAma21lbWxlYWtfc2VxX29wcyk7CisJCWlmIChyZXQgPCAwKQorCQkJZ290byBzY2FuX3VubG9jazsKKwl9CisJcmV0dXJuIHJldDsKKworc2Nhbl91bmxvY2s6CisJbXV0ZXhfdW5sb2NrKCZzY2FuX211dGV4KTsKK2ttZW1sZWFrX3VubG9jazoKKwltdXRleF91bmxvY2soJmttZW1sZWFrX211dGV4KTsKK291dDoKKwlyZXR1cm4gcmV0OworfQorCitzdGF0aWMgaW50IGttZW1sZWFrX3JlbGVhc2Uoc3RydWN0IGlub2RlICppbm9kZSwgc3RydWN0IGZpbGUgKmZpbGUpCit7CisJaW50IHJldCA9IDA7CisKKwlpZiAoZmlsZS0+Zl9tb2RlICYgRk1PREVfUkVBRCkgeworCQlzZXFfcmVsZWFzZShpbm9kZSwgZmlsZSk7CisJCW11dGV4X3VubG9jaygmc2Nhbl9tdXRleCk7CisJfQorCW11dGV4X3VubG9jaygma21lbWxlYWtfbXV0ZXgpOworCisJcmV0dXJuIHJldDsKK30KKworLyoKKyAqIEZpbGUgd3JpdGUgb3BlcmF0aW9uIHRvIGNvbmZpZ3VyZSBrbWVtbGVhayBhdCBydW4tdGltZS4gVGhlIGZvbGxvd2luZworICogY29tbWFuZHMgY2FuIGJlIHdyaXR0ZW4gdG8gdGhlIC9zeXMva2VybmVsL2RlYnVnL2ttZW1sZWFrIGZpbGU6CisgKiAgIG9mZgktIGRpc2FibGUga21lbWxlYWsgKGlycmV2ZXJzaWJsZSkKKyAqICAgc3RhY2s9b24JLSBlbmFibGUgdGhlIHRhc2sgc3RhY2tzIHNjYW5uaW5nCisgKiAgIHN0YWNrPW9mZgktIGRpc2FibGUgdGhlIHRhc2tzIHN0YWNrcyBzY2FubmluZworICogICBzY2FuPW9uCS0gc3RhcnQgdGhlIGF1dG9tYXRpYyBtZW1vcnkgc2Nhbm5pbmcgdGhyZWFkCisgKiAgIHNjYW49b2ZmCS0gc3RvcCB0aGUgYXV0b21hdGljIG1lbW9yeSBzY2FubmluZyB0aHJlYWQKKyAqICAgc2Nhbj0uLi4JLSBzZXQgdGhlIGF1dG9tYXRpYyBtZW1vcnkgc2Nhbm5pbmcgcGVyaW9kIGluIHNlY29uZHMgKDAgdG8KKyAqCQkgIGRpc2FibGUgaXQpCisgKi8KK3N0YXRpYyBzc2l6ZV90IGttZW1sZWFrX3dyaXRlKHN0cnVjdCBmaWxlICpmaWxlLCBjb25zdCBjaGFyIF9fdXNlciAqdXNlcl9idWYsCisJCQkgICAgICBzaXplX3Qgc2l6ZSwgbG9mZl90ICpwcG9zKQoreworCWNoYXIgYnVmWzY0XTsKKwlpbnQgYnVmX3NpemU7CisKKwlpZiAoIWF0b21pY19yZWFkKCZrbWVtbGVha19lbmFibGVkKSkKKwkJcmV0dXJuIC1FQlVTWTsKKworCWJ1Zl9zaXplID0gbWluKHNpemUsIChzaXplb2YoYnVmKSAtIDEpKTsKKwlpZiAoc3RybmNweV9mcm9tX3VzZXIoYnVmLCB1c2VyX2J1ZiwgYnVmX3NpemUpIDwgMCkKKwkJcmV0dXJuIC1FRkFVTFQ7CisJYnVmW2J1Zl9zaXplXSA9IDA7CisKKwlpZiAoc3RybmNtcChidWYsICJvZmYiLCAzKSA9PSAwKQorCQlrbWVtbGVha19kaXNhYmxlKCk7CisJZWxzZSBpZiAoc3RybmNtcChidWYsICJzdGFjaz1vbiIsIDgpID09IDApCisJCWttZW1sZWFrX3N0YWNrX3NjYW4gPSAxOworCWVsc2UgaWYgKHN0cm5jbXAoYnVmLCAic3RhY2s9b2ZmIiwgOSkgPT0gMCkKKwkJa21lbWxlYWtfc3RhY2tfc2NhbiA9IDA7CisJZWxzZSBpZiAoc3RybmNtcChidWYsICJzY2FuPW9uIiwgNykgPT0gMCkKKwkJc3RhcnRfc2Nhbl90aHJlYWQoKTsKKwllbHNlIGlmIChzdHJuY21wKGJ1ZiwgInNjYW49b2ZmIiwgOCkgPT0gMCkKKwkJc3RvcF9zY2FuX3RocmVhZCgpOworCWVsc2UgaWYgKHN0cm5jbXAoYnVmLCAic2Nhbj0iLCA1KSA9PSAwKSB7CisJCXVuc2lnbmVkIGxvbmcgc2VjczsKKwkJaW50IGVycjsKKworCQllcnIgPSBzdHJpY3Rfc3RydG91bChidWYgKyA1LCAwLCAmc2Vjcyk7CisJCWlmIChlcnIgPCAwKQorCQkJcmV0dXJuIGVycjsKKwkJc3RvcF9zY2FuX3RocmVhZCgpOworCQlpZiAoc2VjcykgeworCQkJamlmZmllc19zY2FuX3dhaXQgPSBtc2Vjc190b19qaWZmaWVzKHNlY3MgKiAxMDAwKTsKKwkJCXN0YXJ0X3NjYW5fdGhyZWFkKCk7CisJCX0KKwl9IGVsc2UKKwkJcmV0dXJuIC1FSU5WQUw7CisKKwkvKiBpZ25vcmUgdGhlIHJlc3Qgb2YgdGhlIGJ1ZmZlciwgb25seSBvbmUgY29tbWFuZCBhdCBhIHRpbWUgKi8KKwkqcHBvcyArPSBzaXplOworCXJldHVybiBzaXplOworfQorCitzdGF0aWMgY29uc3Qgc3RydWN0IGZpbGVfb3BlcmF0aW9ucyBrbWVtbGVha19mb3BzID0geworCS5vd25lcgkJPSBUSElTX01PRFVMRSwKKwkub3BlbgkJPSBrbWVtbGVha19vcGVuLAorCS5yZWFkCQk9IHNlcV9yZWFkLAorCS53cml0ZQkJPSBrbWVtbGVha193cml0ZSwKKwkubGxzZWVrCQk9IHNlcV9sc2VlaywKKwkucmVsZWFzZQk9IGttZW1sZWFrX3JlbGVhc2UsCit9OworCisvKgorICogUGVyZm9ybSB0aGUgZnJlZWluZyBvZiB0aGUga21lbWxlYWsgaW50ZXJuYWwgb2JqZWN0cyBhZnRlciB3YWl0aW5nIGZvciBhbnkKKyAqIGN1cnJlbnQgbWVtb3J5IHNjYW4gdG8gY29tcGxldGUuCisgKi8KK3N0YXRpYyBpbnQga21lbWxlYWtfY2xlYW51cF90aHJlYWQodm9pZCAqYXJnKQoreworCXN0cnVjdCBrbWVtbGVha19vYmplY3QgKm9iamVjdDsKKworCW11dGV4X2xvY2soJmttZW1sZWFrX211dGV4KTsKKwlzdG9wX3NjYW5fdGhyZWFkKCk7CisJbXV0ZXhfdW5sb2NrKCZrbWVtbGVha19tdXRleCk7CisKKwltdXRleF9sb2NrKCZzY2FuX211dGV4KTsKKwlyY3VfcmVhZF9sb2NrKCk7CisJbGlzdF9mb3JfZWFjaF9lbnRyeV9yY3Uob2JqZWN0LCAmb2JqZWN0X2xpc3QsIG9iamVjdF9saXN0KQorCQlkZWxldGVfb2JqZWN0KG9iamVjdC0+cG9pbnRlcik7CisJcmN1X3JlYWRfdW5sb2NrKCk7CisJbXV0ZXhfdW5sb2NrKCZzY2FuX211dGV4KTsKKworCXJldHVybiAwOworfQorCisvKgorICogU3RhcnQgdGhlIGNsZWFuLXVwIHRocmVhZC4KKyAqLworc3RhdGljIHZvaWQga21lbWxlYWtfY2xlYW51cCh2b2lkKQoreworCXN0cnVjdCB0YXNrX3N0cnVjdCAqY2xlYW51cF90aHJlYWQ7CisKKwljbGVhbnVwX3RocmVhZCA9IGt0aHJlYWRfcnVuKGttZW1sZWFrX2NsZWFudXBfdGhyZWFkLCBOVUxMLAorCQkJCSAgICAgImttZW1sZWFrLWNsZWFuIik7CisJaWYgKElTX0VSUihjbGVhbnVwX3RocmVhZCkpCisJCXByX3dhcm5pbmcoImttZW1sZWFrOiBGYWlsZWQgdG8gY3JlYXRlIHRoZSBjbGVhbi11cCB0aHJlYWRcbiIpOworfQorCisvKgorICogRGlzYWJsZSBrbWVtbGVhay4gTm8gbWVtb3J5IGFsbG9jYXRpb24vZnJlZWluZyB3aWxsIGJlIHRyYWNlZCBvbmNlIHRoaXMKKyAqIGZ1bmN0aW9uIGlzIGNhbGxlZC4gRGlzYWJsaW5nIGttZW1sZWFrIGlzIGFuIGlycmV2ZXJzaWJsZSBvcGVyYXRpb24uCisgKi8KK3N0YXRpYyB2b2lkIGttZW1sZWFrX2Rpc2FibGUodm9pZCkKK3sKKwkvKiBhdG9taWNhbGx5IGNoZWNrIHdoZXRoZXIgaXQgd2FzIGFscmVhZHkgaW52b2tlZCAqLworCWlmIChhdG9taWNfY21weGNoZygma21lbWxlYWtfZXJyb3IsIDAsIDEpKQorCQlyZXR1cm47CisKKwkvKiBzdG9wIGFueSBtZW1vcnkgb3BlcmF0aW9uIHRyYWNpbmcgKi8KKwlhdG9taWNfc2V0KCZrbWVtbGVha19lYXJseV9sb2csIDApOworCWF0b21pY19zZXQoJmttZW1sZWFrX2VuYWJsZWQsIDApOworCisJLyogY2hlY2sgd2hldGhlciBpdCBpcyB0b28gZWFybHkgZm9yIGEga2VybmVsIHRocmVhZCAqLworCWlmIChhdG9taWNfcmVhZCgma21lbWxlYWtfaW5pdGlhbGl6ZWQpKQorCQlrbWVtbGVha19jbGVhbnVwKCk7CisKKwlwcl9pbmZvKCJLZXJuZWwgbWVtb3J5IGxlYWsgZGV0ZWN0b3IgZGlzYWJsZWRcbiIpOworfQorCisvKgorICogQWxsb3cgYm9vdC10aW1lIGttZW1sZWFrIGRpc2FibGluZyAoZW5hYmxlZCBieSBkZWZhdWx0KS4KKyAqLworc3RhdGljIGludCBrbWVtbGVha19ib290X2NvbmZpZyhjaGFyICpzdHIpCit7CisJaWYgKCFzdHIpCisJCXJldHVybiAtRUlOVkFMOworCWlmIChzdHJjbXAoc3RyLCAib2ZmIikgPT0gMCkKKwkJa21lbWxlYWtfZGlzYWJsZSgpOworCWVsc2UgaWYgKHN0cmNtcChzdHIsICJvbiIpICE9IDApCisJCXJldHVybiAtRUlOVkFMOworCXJldHVybiAwOworfQorZWFybHlfcGFyYW0oImttZW1sZWFrIiwga21lbWxlYWtfYm9vdF9jb25maWcpOworCisvKgorICogS2ttZW1sZWFrIGluaXRpYWxpemF0aW9uLgorICovCit2b2lkIF9faW5pdCBrbWVtbGVha19pbml0KHZvaWQpCit7CisJaW50IGk7CisJdW5zaWduZWQgbG9uZyBmbGFnczsKKworCWppZmZpZXNfc2Nhbl95aWVsZCA9IG1zZWNzX3RvX2ppZmZpZXMoTVNFQ1NfU0NBTl9ZSUVMRCk7CisJamlmZmllc19taW5fYWdlID0gbXNlY3NfdG9famlmZmllcyhNU0VDU19NSU5fQUdFKTsKKwlqaWZmaWVzX3NjYW5fd2FpdCA9IG1zZWNzX3RvX2ppZmZpZXMoU0VDU19TQ0FOX1dBSVQgKiAxMDAwKTsKKworCW9iamVjdF9jYWNoZSA9IEtNRU1fQ0FDSEUoa21lbWxlYWtfb2JqZWN0LCBTTEFCX05PTEVBS1RSQUNFKTsKKwlzY2FuX2FyZWFfY2FjaGUgPSBLTUVNX0NBQ0hFKGttZW1sZWFrX3NjYW5fYXJlYSwgU0xBQl9OT0xFQUtUUkFDRSk7CisJSU5JVF9QUklPX1RSRUVfUk9PVCgmb2JqZWN0X3RyZWVfcm9vdCk7CisKKwkvKiB0aGUga2VybmVsIGlzIHN0aWxsIGluIFVQIG1vZGUsIHNvIGRpc2FibGluZyB0aGUgSVJRcyBpcyBlbm91Z2ggKi8KKwlsb2NhbF9pcnFfc2F2ZShmbGFncyk7CisJaWYgKCFhdG9taWNfcmVhZCgma21lbWxlYWtfZXJyb3IpKSB7CisJCWF0b21pY19zZXQoJmttZW1sZWFrX2VuYWJsZWQsIDEpOworCQlhdG9taWNfc2V0KCZrbWVtbGVha19lYXJseV9sb2csIDApOworCX0KKwlsb2NhbF9pcnFfcmVzdG9yZShmbGFncyk7CisKKwkvKgorCSAqIFRoaXMgaXMgdGhlIHBvaW50IHdoZXJlIHRyYWNraW5nIGFsbG9jYXRpb25zIGlzIHNhZmUuIEF1dG9tYXRpYworCSAqIHNjYW5uaW5nIGlzIHN0YXJ0ZWQgZHVyaW5nIHRoZSBsYXRlIGluaXRjYWxsLiBBZGQgdGhlIGVhcmx5IGxvZ2dlZAorCSAqIGNhbGxiYWNrcyB0byB0aGUga21lbWxlYWsgaW5mcmFzdHJ1Y3R1cmUuCisJICovCisJZm9yIChpID0gMDsgaSA8IGNydF9lYXJseV9sb2c7IGkrKykgeworCQlzdHJ1Y3QgZWFybHlfbG9nICpsb2cgPSAmZWFybHlfbG9nW2ldOworCisJCXN3aXRjaCAobG9nLT5vcF90eXBlKSB7CisJCWNhc2UgS01FTUxFQUtfQUxMT0M6CisJCQlrbWVtbGVha19hbGxvYyhsb2ctPnB0ciwgbG9nLT5zaXplLCBsb2ctPm1pbl9jb3VudCwKKwkJCQkgICAgICAgR0ZQX0tFUk5FTCk7CisJCQlicmVhazsKKwkJY2FzZSBLTUVNTEVBS19GUkVFOgorCQkJa21lbWxlYWtfZnJlZShsb2ctPnB0cik7CisJCQlicmVhazsKKwkJY2FzZSBLTUVNTEVBS19OT1RfTEVBSzoKKwkJCWttZW1sZWFrX25vdF9sZWFrKGxvZy0+cHRyKTsKKwkJCWJyZWFrOworCQljYXNlIEtNRU1MRUFLX0lHTk9SRToKKwkJCWttZW1sZWFrX2lnbm9yZShsb2ctPnB0cik7CisJCQlicmVhazsKKwkJY2FzZSBLTUVNTEVBS19TQ0FOX0FSRUE6CisJCQlrbWVtbGVha19zY2FuX2FyZWEobG9nLT5wdHIsIGxvZy0+b2Zmc2V0LCBsb2ctPmxlbmd0aCwKKwkJCQkJICAgR0ZQX0tFUk5FTCk7CisJCQlicmVhazsKKwkJY2FzZSBLTUVNTEVBS19OT19TQ0FOOgorCQkJa21lbWxlYWtfbm9fc2Nhbihsb2ctPnB0cik7CisJCQlicmVhazsKKwkJZGVmYXVsdDoKKwkJCVdBUk5fT04oMSk7CisJCX0KKwl9Cit9CisKKy8qCisgKiBMYXRlIGluaXRpYWxpemF0aW9uIGZ1bmN0aW9uLgorICovCitzdGF0aWMgaW50IF9faW5pdCBrbWVtbGVha19sYXRlX2luaXQodm9pZCkKK3sKKwlzdHJ1Y3QgZGVudHJ5ICpkZW50cnk7CisKKwlhdG9taWNfc2V0KCZrbWVtbGVha19pbml0aWFsaXplZCwgMSk7CisKKwlpZiAoYXRvbWljX3JlYWQoJmttZW1sZWFrX2Vycm9yKSkgeworCQkvKgorCQkgKiBTb21lIGVycm9yIG9jY3VyZWQgYW5kIGttZW1sZWFrIHdhcyBkaXNhYmxlZC4gVGhlcmUgaXMgYQorCQkgKiBzbWFsbCBjaGFuY2UgdGhhdCBrbWVtbGVha19kaXNhYmxlKCkgd2FzIGNhbGxlZCBpbW1lZGlhdGVseQorCQkgKiBhZnRlciBzZXR0aW5nIGttZW1sZWFrX2luaXRpYWxpemVkIGFuZCB3ZSBtYXkgZW5kIHVwIHdpdGgKKwkJICogdHdvIGNsZWFuLXVwIHRocmVhZHMgYnV0IHNlcmlhbGl6ZWQgYnkgc2Nhbl9tdXRleC4KKwkJICovCisJCWttZW1sZWFrX2NsZWFudXAoKTsKKwkJcmV0dXJuIC1FTk9NRU07CisJfQorCisJZGVudHJ5ID0gZGVidWdmc19jcmVhdGVfZmlsZSgia21lbWxlYWsiLCBTX0lSVUdPLCBOVUxMLCBOVUxMLAorCQkJCSAgICAgJmttZW1sZWFrX2ZvcHMpOworCWlmICghZGVudHJ5KQorCQlwcl93YXJuaW5nKCJrbWVtbGVhazogRmFpbGVkIHRvIGNyZWF0ZSB0aGUgZGVidWdmcyBrbWVtbGVhayAiCisJCQkgICAiZmlsZVxuIik7CisJbXV0ZXhfbG9jaygma21lbWxlYWtfbXV0ZXgpOworCXN0YXJ0X3NjYW5fdGhyZWFkKCk7CisJbXV0ZXhfdW5sb2NrKCZrbWVtbGVha19tdXRleCk7CisKKwlwcl9pbmZvKCJLZXJuZWwgbWVtb3J5IGxlYWsgZGV0ZWN0b3IgaW5pdGlhbGl6ZWRcbiIpOworCisJcmV0dXJuIDA7Cit9CitsYXRlX2luaXRjYWxsKGttZW1sZWFrX2xhdGVfaW5pdCk7CmRpZmYgLS1naXQgYS9tbS9tbWFwLmMgYi9tbS9tbWFwLmMKaW5kZXggMmI0M2ZhMS4uMzQ1NzliMiAxMDA2NDQKLS0tIGEvbW0vbW1hcC5jCisrKyBiL21tL21tYXAuYwpAQCAtMjgsNiArMjgsNyBAQAogI2luY2x1ZGUgPGxpbnV4L21lbXBvbGljeS5oPgogI2luY2x1ZGUgPGxpbnV4L3JtYXAuaD4KICNpbmNsdWRlIDxsaW51eC9tbXVfbm90aWZpZXIuaD4KKyNpbmNsdWRlIDxsaW51eC9wZXJmX2NvdW50ZXIuaD4KIAogI2luY2x1ZGUgPGFzbS91YWNjZXNzLmg+CiAjaW5jbHVkZSA8YXNtL2NhY2hlZmx1c2guaD4KQEAgLTEyMjIsNiArMTIyMyw4IEBACiAJaWYgKGNvcnJlY3Rfd2NvdW50KQogCQlhdG9taWNfaW5jKCZpbm9kZS0+aV93cml0ZWNvdW50KTsKIG91dDoKKwlwZXJmX2NvdW50ZXJfbW1hcCh2bWEpOworCiAJbW0tPnRvdGFsX3ZtICs9IGxlbiA+PiBQQUdFX1NISUZUOwogCXZtX3N0YXRfYWNjb3VudChtbSwgdm1fZmxhZ3MsIGZpbGUsIGxlbiA+PiBQQUdFX1NISUZUKTsKIAlpZiAodm1fZmxhZ3MgJiBWTV9MT0NLRUQpIHsKQEAgLTIzMDgsNiArMjMxMSw4IEBACiAKIAltbS0+dG90YWxfdm0gKz0gbGVuID4+IFBBR0VfU0hJRlQ7CiAKKwlwZXJmX2NvdW50ZXJfbW1hcCh2bWEpOworCiAJcmV0dXJuIDA7CiB9CiAKZGlmZiAtLWdpdCBhL21tL21wcm90ZWN0LmMgYi9tbS9tcHJvdGVjdC5jCmluZGV4IDI1ODE5N2IuLmQ4MDMxMWIgMTAwNjQ0Ci0tLSBhL21tL21wcm90ZWN0LmMKKysrIGIvbW0vbXByb3RlY3QuYwpAQCAtMjMsNiArMjMsNyBAQAogI2luY2x1ZGUgPGxpbnV4L3N3YXBvcHMuaD4KICNpbmNsdWRlIDxsaW51eC9tbXVfbm90aWZpZXIuaD4KICNpbmNsdWRlIDxsaW51eC9taWdyYXRlLmg+CisjaW5jbHVkZSA8bGludXgvcGVyZl9jb3VudGVyLmg+CiAjaW5jbHVkZSA8YXNtL3VhY2Nlc3MuaD4KICNpbmNsdWRlIDxhc20vcGd0YWJsZS5oPgogI2luY2x1ZGUgPGFzbS9jYWNoZWZsdXNoLmg+CkBAIC0yOTksNiArMzAwLDcgQEAKIAkJZXJyb3IgPSBtcHJvdGVjdF9maXh1cCh2bWEsICZwcmV2LCBuc3RhcnQsIHRtcCwgbmV3ZmxhZ3MpOwogCQlpZiAoZXJyb3IpCiAJCQlnb3RvIG91dDsKKwkJcGVyZl9jb3VudGVyX21tYXAodm1hKTsKIAkJbnN0YXJ0ID0gdG1wOwogCiAJCWlmIChuc3RhcnQgPCBwcmV2LT52bV9lbmQpCmRpZmYgLS1naXQgYS9tbS9wYWdlX2FsbG9jLmMgYi9tbS9wYWdlX2FsbG9jLmMKaW5kZXggNDc0YzdlOS4uMTdkNWY1MyAxMDA2NDQKLS0tIGEvbW0vcGFnZV9hbGxvYy5jCisrKyBiL21tL3BhZ2VfYWxsb2MuYwpAQCAtNDYsNiArNDYsNyBAQAogI2luY2x1ZGUgPGxpbnV4L3BhZ2UtaXNvbGF0aW9uLmg+CiAjaW5jbHVkZSA8bGludXgvcGFnZV9jZ3JvdXAuaD4KICNpbmNsdWRlIDxsaW51eC9kZWJ1Z29iamVjdHMuaD4KKyNpbmNsdWRlIDxsaW51eC9rbWVtbGVhay5oPgogCiAjaW5jbHVkZSA8YXNtL3RsYmZsdXNoLmg+CiAjaW5jbHVkZSA8YXNtL2RpdjY0Lmg+CkBAIC00NTQ2LDYgKzQ1NDcsMTYgQEAKIAlpZiAoX2hhc2hfbWFzaykKIAkJKl9oYXNoX21hc2sgPSAoMSA8PCBsb2cycXR5KSAtIDE7CiAKKwkvKgorCSAqIElmIGhhc2hkaXN0IGlzIHNldCwgdGhlIHRhYmxlIGFsbG9jYXRpb24gaXMgZG9uZSB3aXRoIF9fdm1hbGxvYygpCisJICogd2hpY2ggaW52b2tlcyB0aGUga21lbWxlYWtfYWxsb2MoKSBjYWxsYmFjay4gVGhpcyBmdW5jdGlvbiBtYXkgYWxzbworCSAqIGJlIGNhbGxlZCBiZWZvcmUgdGhlIHNsYWIgYW5kIGttZW1sZWFrIGFyZSBpbml0aWFsaXNlZCB3aGVuCisJICoga21lbWxlYWsgc2ltcGx5IGJ1ZmZlcnMgdGhlIHJlcXVlc3QgdG8gYmUgZXhlY3V0ZWQgbGF0ZXIKKwkgKiAoR0ZQX0FUT01JQyBmbGFnIGlnbm9yZWQgaW4gdGhpcyBjYXNlKS4KKwkgKi8KKwlpZiAoIWhhc2hkaXN0KQorCQlrbWVtbGVha19hbGxvYyh0YWJsZSwgc2l6ZSwgMSwgR0ZQX0FUT01JQyk7CisKIAlyZXR1cm4gdGFibGU7CiB9CiAKZGlmZiAtLWdpdCBhL21tL3BhZ2VfY2dyb3VwLmMgYi9tbS9wYWdlX2Nncm91cC5jCmluZGV4IDc5MTkwNWMuLjNkZDRhOTAgMTAwNjQ0Ci0tLSBhL21tL3BhZ2VfY2dyb3VwLmMKKysrIGIvbW0vcGFnZV9jZ3JvdXAuYwpAQCAtNDcsNiArNDcsOCBAQAogCXN0cnVjdCBwYWdlX2Nncm91cCAqYmFzZSwgKnBjOwogCXVuc2lnbmVkIGxvbmcgdGFibGVfc2l6ZTsKIAl1bnNpZ25lZCBsb25nIHN0YXJ0X3BmbiwgbnJfcGFnZXMsIGluZGV4OworCXN0cnVjdCBwYWdlICpwYWdlOworCXVuc2lnbmVkIGludCBvcmRlcjsKIAogCXN0YXJ0X3BmbiA9IE5PREVfREFUQShuaWQpLT5ub2RlX3N0YXJ0X3BmbjsKIAlucl9wYWdlcyA9IE5PREVfREFUQShuaWQpLT5ub2RlX3NwYW5uZWRfcGFnZXM7CkBAIC01NSwxMSArNTcsMTMgQEAKIAkJcmV0dXJuIDA7CiAKIAl0YWJsZV9zaXplID0gc2l6ZW9mKHN0cnVjdCBwYWdlX2Nncm91cCkgKiBucl9wYWdlczsKLQotCWJhc2UgPSBfX2FsbG9jX2Jvb3RtZW1fbm9kZV9ub3BhbmljKE5PREVfREFUQShuaWQpLAotCQkJdGFibGVfc2l6ZSwgUEFHRV9TSVpFLCBfX3BhKE1BWF9ETUFfQUREUkVTUykpOwotCWlmICghYmFzZSkKKwlvcmRlciA9IGdldF9vcmRlcih0YWJsZV9zaXplKTsKKwlwYWdlID0gYWxsb2NfcGFnZXNfbm9kZShuaWQsIEdGUF9OT1dBSVQgfCBfX0dGUF9aRVJPLCBvcmRlcik7CisJaWYgKCFwYWdlKQorCQlwYWdlID0gYWxsb2NfcGFnZXNfbm9kZSgtMSwgR0ZQX05PV0FJVCB8IF9fR0ZQX1pFUk8sIG9yZGVyKTsKKwlpZiAoIXBhZ2UpCiAJCXJldHVybiAtRU5PTUVNOworCWJhc2UgPSBwYWdlX2FkZHJlc3MocGFnZSk7CiAJZm9yIChpbmRleCA9IDA7IGluZGV4IDwgbnJfcGFnZXM7IGluZGV4KyspIHsKIAkJcGMgPSBiYXNlICsgaW5kZXg7CiAJCV9faW5pdF9wYWdlX2Nncm91cChwYywgc3RhcnRfcGZuICsgaW5kZXgpOwpkaWZmIC0tZ2l0IGEvbW0vc2xhYi5jIGIvbW0vc2xhYi5jCmluZGV4IGY4NTgzMWQuLmY0NmI2NWQgMTAwNjQ0Ci0tLSBhL21tL3NsYWIuYworKysgYi9tbS9zbGFiLmMKQEAgLTEwNyw2ICsxMDcsNyBAQAogI2luY2x1ZGUJPGxpbnV4L3N0cmluZy5oPgogI2luY2x1ZGUJPGxpbnV4L3VhY2Nlc3MuaD4KICNpbmNsdWRlCTxsaW51eC9ub2RlbWFzay5oPgorI2luY2x1ZGUJPGxpbnV4L2ttZW1sZWFrLmg+CiAjaW5jbHVkZQk8bGludXgvbWVtcG9saWN5Lmg+CiAjaW5jbHVkZQk8bGludXgvbXV0ZXguaD4KICNpbmNsdWRlCTxsaW51eC9mYXVsdC1pbmplY3QuaD4KQEAgLTE3OCwxMyArMTc5LDEzIEBACiAJCQkgU0xBQl9TVE9SRV9VU0VSIHwgXAogCQkJIFNMQUJfUkVDTEFJTV9BQ0NPVU5UIHwgU0xBQl9QQU5JQyB8IFwKIAkJCSBTTEFCX0RFU1RST1lfQllfUkNVIHwgU0xBQl9NRU1fU1BSRUFEIHwgXAotCQkJIFNMQUJfREVCVUdfT0JKRUNUUykKKwkJCSBTTEFCX0RFQlVHX09CSkVDVFMgfCBTTEFCX05PTEVBS1RSQUNFKQogI2Vsc2UKICMgZGVmaW5lIENSRUFURV9NQVNLCShTTEFCX0hXQ0FDSEVfQUxJR04gfCBcCiAJCQkgU0xBQl9DQUNIRV9ETUEgfCBcCiAJCQkgU0xBQl9SRUNMQUlNX0FDQ09VTlQgfCBTTEFCX1BBTklDIHwgXAogCQkJIFNMQUJfREVTVFJPWV9CWV9SQ1UgfCBTTEFCX01FTV9TUFJFQUQgfCBcCi0JCQkgU0xBQl9ERUJVR19PQkpFQ1RTKQorCQkJIFNMQUJfREVCVUdfT0JKRUNUUyB8IFNMQUJfTk9MRUFLVFJBQ0UpCiAjZW5kaWYKIAogLyoKQEAgLTMxNSw3ICszMTYsNyBAQAogCQkJc3RydWN0IGttZW1fbGlzdDMgKmwzLCBpbnQgdG9mcmVlKTsKIHN0YXRpYyB2b2lkIGZyZWVfYmxvY2soc3RydWN0IGttZW1fY2FjaGUgKmNhY2hlcCwgdm9pZCAqKm9ianBwLCBpbnQgbGVuLAogCQkJaW50IG5vZGUpOwotc3RhdGljIGludCBlbmFibGVfY3B1Y2FjaGUoc3RydWN0IGttZW1fY2FjaGUgKmNhY2hlcCk7CitzdGF0aWMgaW50IGVuYWJsZV9jcHVjYWNoZShzdHJ1Y3Qga21lbV9jYWNoZSAqY2FjaGVwLCBnZnBfdCBnZnApOwogc3RhdGljIHZvaWQgY2FjaGVfcmVhcChzdHJ1Y3Qgd29ya19zdHJ1Y3QgKnVudXNlZCk7CiAKIC8qCkBAIC05NTgsMTIgKzk1OSwyMCBAQAogfQogCiBzdGF0aWMgc3RydWN0IGFycmF5X2NhY2hlICphbGxvY19hcnJheWNhY2hlKGludCBub2RlLCBpbnQgZW50cmllcywKLQkJCQkJICAgIGludCBiYXRjaGNvdW50KQorCQkJCQkgICAgaW50IGJhdGNoY291bnQsIGdmcF90IGdmcCkKIHsKIAlpbnQgbWVtc2l6ZSA9IHNpemVvZih2b2lkICopICogZW50cmllcyArIHNpemVvZihzdHJ1Y3QgYXJyYXlfY2FjaGUpOwogCXN0cnVjdCBhcnJheV9jYWNoZSAqbmMgPSBOVUxMOwogCi0JbmMgPSBrbWFsbG9jX25vZGUobWVtc2l6ZSwgR0ZQX0tFUk5FTCwgbm9kZSk7CisJbmMgPSBrbWFsbG9jX25vZGUobWVtc2l6ZSwgZ2ZwLCBub2RlKTsKKwkvKgorCSAqIFRoZSBhcnJheV9jYWNoZSBzdHJ1Y3R1cmVzIGNvbnRhaW4gcG9pbnRlcnMgdG8gZnJlZSBvYmplY3QuCisJICogSG93ZXZlciwgd2hlbiBzdWNoIG9iamVjdHMgYXJlIGFsbG9jYXRlZCBvciB0cmFuc2ZlcmVkIHRvIGFub3RoZXIKKwkgKiBjYWNoZSB0aGUgcG9pbnRlcnMgYXJlIG5vdCBjbGVhcmVkIGFuZCB0aGV5IGNvdWxkIGJlIGNvdW50ZWQgYXMKKwkgKiB2YWxpZCByZWZlcmVuY2VzIGR1cmluZyBhIGttZW1sZWFrIHNjYW4uIFRoZXJlZm9yZSwga21lbWxlYWsgbXVzdAorCSAqIG5vdCBzY2FuIHN1Y2ggb2JqZWN0cy4KKwkgKi8KKwlrbWVtbGVha19ub19zY2FuKG5jKTsKIAlpZiAobmMpIHsKIAkJbmMtPmF2YWlsID0gMDsKIAkJbmMtPmxpbWl0ID0gZW50cmllczsKQEAgLTEwMDMsNyArMTAxMiw3IEBACiAjZGVmaW5lIGRyYWluX2FsaWVuX2NhY2hlKGNhY2hlcCwgYWxpZW4pIGRvIHsgfSB3aGlsZSAoMCkKICNkZWZpbmUgcmVhcF9hbGllbihjYWNoZXAsIGwzKSBkbyB7IH0gd2hpbGUgKDApCiAKLXN0YXRpYyBpbmxpbmUgc3RydWN0IGFycmF5X2NhY2hlICoqYWxsb2NfYWxpZW5fY2FjaGUoaW50IG5vZGUsIGludCBsaW1pdCkKK3N0YXRpYyBpbmxpbmUgc3RydWN0IGFycmF5X2NhY2hlICoqYWxsb2NfYWxpZW5fY2FjaGUoaW50IG5vZGUsIGludCBsaW1pdCwgZ2ZwX3QgZ2ZwKQogewogCXJldHVybiAoc3RydWN0IGFycmF5X2NhY2hlICoqKUJBRF9BTElFTl9NQUdJQzsKIH0KQEAgLTEwMzQsNyArMTA0Myw3IEBACiBzdGF0aWMgdm9pZCAqX19fX2NhY2hlX2FsbG9jX25vZGUoc3RydWN0IGttZW1fY2FjaGUgKiwgZ2ZwX3QsIGludCk7CiBzdGF0aWMgdm9pZCAqYWx0ZXJuYXRlX25vZGVfYWxsb2Moc3RydWN0IGttZW1fY2FjaGUgKiwgZ2ZwX3QpOwogCi1zdGF0aWMgc3RydWN0IGFycmF5X2NhY2hlICoqYWxsb2NfYWxpZW5fY2FjaGUoaW50IG5vZGUsIGludCBsaW1pdCkKK3N0YXRpYyBzdHJ1Y3QgYXJyYXlfY2FjaGUgKiphbGxvY19hbGllbl9jYWNoZShpbnQgbm9kZSwgaW50IGxpbWl0LCBnZnBfdCBnZnApCiB7CiAJc3RydWN0IGFycmF5X2NhY2hlICoqYWNfcHRyOwogCWludCBtZW1zaXplID0gc2l6ZW9mKHZvaWQgKikgKiBucl9ub2RlX2lkczsKQEAgLTEwNDIsMTQgKzEwNTEsMTQgQEAKIAogCWlmIChsaW1pdCA+IDEpCiAJCWxpbWl0ID0gMTI7Ci0JYWNfcHRyID0ga21hbGxvY19ub2RlKG1lbXNpemUsIEdGUF9LRVJORUwsIG5vZGUpOworCWFjX3B0ciA9IGttYWxsb2Nfbm9kZShtZW1zaXplLCBnZnAsIG5vZGUpOwogCWlmIChhY19wdHIpIHsKIAkJZm9yX2VhY2hfbm9kZShpKSB7CiAJCQlpZiAoaSA9PSBub2RlIHx8ICFub2RlX29ubGluZShpKSkgewogCQkJCWFjX3B0cltpXSA9IE5VTEw7CiAJCQkJY29udGludWU7CiAJCQl9Ci0JCQlhY19wdHJbaV0gPSBhbGxvY19hcnJheWNhY2hlKG5vZGUsIGxpbWl0LCAweGJhYWRmMDBkKTsKKwkJCWFjX3B0cltpXSA9IGFsbG9jX2FycmF5Y2FjaGUobm9kZSwgbGltaXQsIDB4YmFhZGYwMGQsIGdmcCk7CiAJCQlpZiAoIWFjX3B0cltpXSkgewogCQkJCWZvciAoaS0tOyBpID49IDA7IGktLSkKIAkJCQkJa2ZyZWUoYWNfcHRyW2ldKTsKQEAgLTEyODIsMjAgKzEyOTEsMjAgQEAKIAkJc3RydWN0IGFycmF5X2NhY2hlICoqYWxpZW4gPSBOVUxMOwogCiAJCW5jID0gYWxsb2NfYXJyYXljYWNoZShub2RlLCBjYWNoZXAtPmxpbWl0LAotCQkJCQljYWNoZXAtPmJhdGNoY291bnQpOworCQkJCQljYWNoZXAtPmJhdGNoY291bnQsIEdGUF9LRVJORUwpOwogCQlpZiAoIW5jKQogCQkJZ290byBiYWQ7CiAJCWlmIChjYWNoZXAtPnNoYXJlZCkgewogCQkJc2hhcmVkID0gYWxsb2NfYXJyYXljYWNoZShub2RlLAogCQkJCWNhY2hlcC0+c2hhcmVkICogY2FjaGVwLT5iYXRjaGNvdW50LAotCQkJCTB4YmFhZGYwMGQpOworCQkJCTB4YmFhZGYwMGQsIEdGUF9LRVJORUwpOwogCQkJaWYgKCFzaGFyZWQpIHsKIAkJCQlrZnJlZShuYyk7CiAJCQkJZ290byBiYWQ7CiAJCQl9CiAJCX0KIAkJaWYgKHVzZV9hbGllbl9jYWNoZXMpIHsKLQkJCWFsaWVuID0gYWxsb2NfYWxpZW5fY2FjaGUobm9kZSwgY2FjaGVwLT5saW1pdCk7CisJCQlhbGllbiA9IGFsbG9jX2FsaWVuX2NhY2hlKG5vZGUsIGNhY2hlcC0+bGltaXQsIEdGUF9LRVJORUwpOwogCQkJaWYgKCFhbGllbikgewogCQkJCWtmcmVlKHNoYXJlZCk7CiAJCQkJa2ZyZWUobmMpOwpAQCAtMTM5OSwxMCArMTQwOCw5IEBACiB7CiAJc3RydWN0IGttZW1fbGlzdDMgKnB0cjsKIAotCXB0ciA9IGttYWxsb2Nfbm9kZShzaXplb2Yoc3RydWN0IGttZW1fbGlzdDMpLCBHRlBfS0VSTkVMLCBub2RlaWQpOworCXB0ciA9IGttYWxsb2Nfbm9kZShzaXplb2Yoc3RydWN0IGttZW1fbGlzdDMpLCBHRlBfTk9XQUlULCBub2RlaWQpOwogCUJVR19PTighcHRyKTsKIAotCWxvY2FsX2lycV9kaXNhYmxlKCk7CiAJbWVtY3B5KHB0ciwgbGlzdCwgc2l6ZW9mKHN0cnVjdCBrbWVtX2xpc3QzKSk7CiAJLyoKIAkgKiBEbyBub3QgYXNzdW1lIHRoYXQgc3BpbmxvY2tzIGNhbiBiZSBpbml0aWFsaXplZCB2aWEgbWVtY3B5OgpAQCAtMTQxMSw3ICsxNDE5LDYgQEAKIAogCU1BS0VfQUxMX0xJU1RTKGNhY2hlcCwgcHRyLCBub2RlaWQpOwogCWNhY2hlcC0+bm9kZWxpc3RzW25vZGVpZF0gPSBwdHI7Ci0JbG9jYWxfaXJxX2VuYWJsZSgpOwogfQogCiAvKgpAQCAtMTU3NSw5ICsxNTgyLDggQEAKIAl7CiAJCXN0cnVjdCBhcnJheV9jYWNoZSAqcHRyOwogCi0JCXB0ciA9IGttYWxsb2Moc2l6ZW9mKHN0cnVjdCBhcnJheWNhY2hlX2luaXQpLCBHRlBfS0VSTkVMKTsKKwkJcHRyID0ga21hbGxvYyhzaXplb2Yoc3RydWN0IGFycmF5Y2FjaGVfaW5pdCksIEdGUF9OT1dBSVQpOwogCi0JCWxvY2FsX2lycV9kaXNhYmxlKCk7CiAJCUJVR19PTihjcHVfY2FjaGVfZ2V0KCZjYWNoZV9jYWNoZSkgIT0gJmluaXRhcnJheV9jYWNoZS5jYWNoZSk7CiAJCW1lbWNweShwdHIsIGNwdV9jYWNoZV9nZXQoJmNhY2hlX2NhY2hlKSwKIAkJICAgICAgIHNpemVvZihzdHJ1Y3QgYXJyYXljYWNoZV9pbml0KSk7CkBAIC0xNTg3LDExICsxNTkzLDkgQEAKIAkJc3Bpbl9sb2NrX2luaXQoJnB0ci0+bG9jayk7CiAKIAkJY2FjaGVfY2FjaGUuYXJyYXlbc21wX3Byb2Nlc3Nvcl9pZCgpXSA9IHB0cjsKLQkJbG9jYWxfaXJxX2VuYWJsZSgpOwogCi0JCXB0ciA9IGttYWxsb2Moc2l6ZW9mKHN0cnVjdCBhcnJheWNhY2hlX2luaXQpLCBHRlBfS0VSTkVMKTsKKwkJcHRyID0ga21hbGxvYyhzaXplb2Yoc3RydWN0IGFycmF5Y2FjaGVfaW5pdCksIEdGUF9OT1dBSVQpOwogCi0JCWxvY2FsX2lycV9kaXNhYmxlKCk7CiAJCUJVR19PTihjcHVfY2FjaGVfZ2V0KG1hbGxvY19zaXplc1tJTkRFWF9BQ10uY3NfY2FjaGVwKQogCQkgICAgICAgIT0gJmluaXRhcnJheV9nZW5lcmljLmNhY2hlKTsKIAkJbWVtY3B5KHB0ciwgY3B1X2NhY2hlX2dldChtYWxsb2Nfc2l6ZXNbSU5ERVhfQUNdLmNzX2NhY2hlcCksCkBAIC0xNjAzLDcgKzE2MDcsNiBAQAogCiAJCW1hbGxvY19zaXplc1tJTkRFWF9BQ10uY3NfY2FjaGVwLT5hcnJheVtzbXBfcHJvY2Vzc29yX2lkKCldID0KIAkJICAgIHB0cjsKLQkJbG9jYWxfaXJxX2VuYWJsZSgpOwogCX0KIAkvKiA1KSBSZXBsYWNlIHRoZSBib290c3RyYXAga21lbV9saXN0MydzICovCiAJewpAQCAtMTYyNyw3ICsxNjMwLDcgQEAKIAkJc3RydWN0IGttZW1fY2FjaGUgKmNhY2hlcDsKIAkJbXV0ZXhfbG9jaygmY2FjaGVfY2hhaW5fbXV0ZXgpOwogCQlsaXN0X2Zvcl9lYWNoX2VudHJ5KGNhY2hlcCwgJmNhY2hlX2NoYWluLCBuZXh0KQotCQkJaWYgKGVuYWJsZV9jcHVjYWNoZShjYWNoZXApKQorCQkJaWYgKGVuYWJsZV9jcHVjYWNoZShjYWNoZXAsIEdGUF9OT1dBSVQpKQogCQkJCUJVRygpOwogCQltdXRleF91bmxvY2soJmNhY2hlX2NoYWluX211dGV4KTsKIAl9CkBAIC0yMDY0LDEwICsyMDY3LDEwIEBACiAJcmV0dXJuIGxlZnRfb3ZlcjsKIH0KIAotc3RhdGljIGludCBfX2luaXRfcmVmb2sgc2V0dXBfY3B1X2NhY2hlKHN0cnVjdCBrbWVtX2NhY2hlICpjYWNoZXApCitzdGF0aWMgaW50IF9faW5pdF9yZWZvayBzZXR1cF9jcHVfY2FjaGUoc3RydWN0IGttZW1fY2FjaGUgKmNhY2hlcCwgZ2ZwX3QgZ2ZwKQogewogCWlmIChnX2NwdWNhY2hlX3VwID09IEZVTEwpCi0JCXJldHVybiBlbmFibGVfY3B1Y2FjaGUoY2FjaGVwKTsKKwkJcmV0dXJuIGVuYWJsZV9jcHVjYWNoZShjYWNoZXAsIGdmcCk7CiAKIAlpZiAoZ19jcHVjYWNoZV91cCA9PSBOT05FKSB7CiAJCS8qCkBAIC0yMDg5LDcgKzIwOTIsNyBAQAogCQkJZ19jcHVjYWNoZV91cCA9IFBBUlRJQUxfQUM7CiAJfSBlbHNlIHsKIAkJY2FjaGVwLT5hcnJheVtzbXBfcHJvY2Vzc29yX2lkKCldID0KLQkJCWttYWxsb2Moc2l6ZW9mKHN0cnVjdCBhcnJheWNhY2hlX2luaXQpLCBHRlBfS0VSTkVMKTsKKwkJCWttYWxsb2Moc2l6ZW9mKHN0cnVjdCBhcnJheWNhY2hlX2luaXQpLCBnZnApOwogCiAJCWlmIChnX2NwdWNhY2hlX3VwID09IFBBUlRJQUxfQUMpIHsKIAkJCXNldF91cF9saXN0M3MoY2FjaGVwLCBTSVpFX0wzKTsKQEAgLTIxNTMsNiArMjE1Niw3IEBACiB7CiAJc2l6ZV90IGxlZnRfb3Zlciwgc2xhYl9zaXplLCByYWxpZ247CiAJc3RydWN0IGttZW1fY2FjaGUgKmNhY2hlcCA9IE5VTEwsICpwYzsKKwlnZnBfdCBnZnA7CiAKIAkvKgogCSAqIFNhbml0eSBjaGVja3MuLi4gdGhlc2UgYXJlIGFsbCBzZXJpb3VzIHVzYWdlIGJ1Z3MuCkBAIC0yMTY4LDggKzIxNzIsMTAgQEAKIAkgKiBXZSB1c2UgY2FjaGVfY2hhaW5fbXV0ZXggdG8gZW5zdXJlIGEgY29uc2lzdGVudCB2aWV3IG9mCiAJICogY3B1X29ubGluZV9tYXNrIGFzIHdlbGwuICBQbGVhc2Ugc2VlIGNwdXVwX2NhbGxiYWNrCiAJICovCi0JZ2V0X29ubGluZV9jcHVzKCk7Ci0JbXV0ZXhfbG9jaygmY2FjaGVfY2hhaW5fbXV0ZXgpOworCWlmIChzbGFiX2lzX2F2YWlsYWJsZSgpKSB7CisJCWdldF9vbmxpbmVfY3B1cygpOworCQltdXRleF9sb2NrKCZjYWNoZV9jaGFpbl9tdXRleCk7CisJfQogCiAJbGlzdF9mb3JfZWFjaF9lbnRyeShwYywgJmNhY2hlX2NoYWluLCBuZXh0KSB7CiAJCWNoYXIgdG1wOwpAQCAtMjI3OCw4ICsyMjg0LDEzIEBACiAJICovCiAJYWxpZ24gPSByYWxpZ247CiAKKwlpZiAoc2xhYl9pc19hdmFpbGFibGUoKSkKKwkJZ2ZwID0gR0ZQX0tFUk5FTDsKKwllbHNlCisJCWdmcCA9IEdGUF9OT1dBSVQ7CisKIAkvKiBHZXQgY2FjaGUncyBkZXNjcmlwdGlvbiBvYmouICovCi0JY2FjaGVwID0ga21lbV9jYWNoZV96YWxsb2MoJmNhY2hlX2NhY2hlLCBHRlBfS0VSTkVMKTsKKwljYWNoZXAgPSBrbWVtX2NhY2hlX3phbGxvYygmY2FjaGVfY2FjaGUsIGdmcCk7CiAJaWYgKCFjYWNoZXApCiAJCWdvdG8gb29wczsKIApAQCAtMjM4Miw3ICsyMzkzLDcgQEAKIAljYWNoZXAtPmN0b3IgPSBjdG9yOwogCWNhY2hlcC0+bmFtZSA9IG5hbWU7CiAKLQlpZiAoc2V0dXBfY3B1X2NhY2hlKGNhY2hlcCkpIHsKKwlpZiAoc2V0dXBfY3B1X2NhY2hlKGNhY2hlcCwgZ2ZwKSkgewogCQlfX2ttZW1fY2FjaGVfZGVzdHJveShjYWNoZXApOwogCQljYWNoZXAgPSBOVUxMOwogCQlnb3RvIG9vcHM7CkBAIC0yMzk0LDggKzI0MDUsMTAgQEAKIAlpZiAoIWNhY2hlcCAmJiAoZmxhZ3MgJiBTTEFCX1BBTklDKSkKIAkJcGFuaWMoImttZW1fY2FjaGVfY3JlYXRlKCk6IGZhaWxlZCB0byBjcmVhdGUgc2xhYiBgJXMnXG4iLAogCQkgICAgICBuYW1lKTsKLQltdXRleF91bmxvY2soJmNhY2hlX2NoYWluX211dGV4KTsKLQlwdXRfb25saW5lX2NwdXMoKTsKKwlpZiAoc2xhYl9pc19hdmFpbGFibGUoKSkgeworCQltdXRleF91bmxvY2soJmNhY2hlX2NoYWluX211dGV4KTsKKwkJcHV0X29ubGluZV9jcHVzKCk7CisJfQogCXJldHVybiBjYWNoZXA7CiB9CiBFWFBPUlRfU1lNQk9MKGttZW1fY2FjaGVfY3JlYXRlKTsKQEAgLTI2MjEsNiArMjYzNCwxNCBAQAogCQkvKiBTbGFiIG1hbmFnZW1lbnQgb2JqIGlzIG9mZi1zbGFiLiAqLwogCQlzbGFicCA9IGttZW1fY2FjaGVfYWxsb2Nfbm9kZShjYWNoZXAtPnNsYWJwX2NhY2hlLAogCQkJCQkgICAgICBsb2NhbF9mbGFncywgbm9kZWlkKTsKKwkJLyoKKwkJICogSWYgdGhlIGZpcnN0IG9iamVjdCBpbiB0aGUgc2xhYiBpcyBsZWFrZWQgKGl0J3MgYWxsb2NhdGVkCisJCSAqIGJ1dCBubyBvbmUgaGFzIGEgcmVmZXJlbmNlIHRvIGl0KSwgd2Ugd2FudCB0byBtYWtlIHN1cmUKKwkJICoga21lbWxlYWsgZG9lcyBub3QgdHJlYXQgdGhlIC0+c19tZW0gcG9pbnRlciBhcyBhIHJlZmVyZW5jZQorCQkgKiB0byB0aGUgb2JqZWN0LiBPdGhlcndpc2Ugd2Ugd2lsbCBub3QgcmVwb3J0IHRoZSBsZWFrLgorCQkgKi8KKwkJa21lbWxlYWtfc2Nhbl9hcmVhKHNsYWJwLCBvZmZzZXRvZihzdHJ1Y3Qgc2xhYiwgbGlzdCksCisJCQkJICAgc2l6ZW9mKHN0cnVjdCBsaXN0X2hlYWQpLCBsb2NhbF9mbGFncyk7CiAJCWlmICghc2xhYnApCiAJCQlyZXR1cm4gTlVMTDsKIAl9IGVsc2UgewpAQCAtMzE0MSw2ICszMTYyLDEyIEBACiAJCVNUQVRTX0lOQ19BTExPQ01JU1MoY2FjaGVwKTsKIAkJb2JqcCA9IGNhY2hlX2FsbG9jX3JlZmlsbChjYWNoZXAsIGZsYWdzKTsKIAl9CisJLyoKKwkgKiBUbyBhdm9pZCBhIGZhbHNlIG5lZ2F0aXZlLCBpZiBhbiBvYmplY3QgdGhhdCBpcyBpbiBvbmUgb2YgdGhlCisJICogcGVyLUNQVSBjYWNoZXMgaXMgbGVha2VkLCB3ZSBuZWVkIHRvIG1ha2Ugc3VyZSBrbWVtbGVhayBkb2Vzbid0CisJICogdHJlYXQgdGhlIGFycmF5IHBvaW50ZXJzIGFzIGEgcmVmZXJlbmNlIHRvIHRoZSBvYmplY3QuCisJICovCisJa21lbWxlYWtfZXJhc2UoJmFjLT5lbnRyeVthYy0+YXZhaWxdKTsKIAlyZXR1cm4gb2JqcDsKIH0KIApAQCAtMzM2MCw2ICszMzg3LDggQEAKICAgb3V0OgogCWxvY2FsX2lycV9yZXN0b3JlKHNhdmVfZmxhZ3MpOwogCXB0ciA9IGNhY2hlX2FsbG9jX2RlYnVnY2hlY2tfYWZ0ZXIoY2FjaGVwLCBmbGFncywgcHRyLCBjYWxsZXIpOworCWttZW1sZWFrX2FsbG9jX3JlY3Vyc2l2ZShwdHIsIG9ial9zaXplKGNhY2hlcCksIDEsIGNhY2hlcC0+ZmxhZ3MsCisJCQkJIGZsYWdzKTsKIAogCWlmICh1bmxpa2VseSgoZmxhZ3MgJiBfX0dGUF9aRVJPKSAmJiBwdHIpKQogCQltZW1zZXQocHRyLCAwLCBvYmpfc2l6ZShjYWNoZXApKTsKQEAgLTM0MTUsNiArMzQ0NCw4IEBACiAJb2JqcCA9IF9fZG9fY2FjaGVfYWxsb2MoY2FjaGVwLCBmbGFncyk7CiAJbG9jYWxfaXJxX3Jlc3RvcmUoc2F2ZV9mbGFncyk7CiAJb2JqcCA9IGNhY2hlX2FsbG9jX2RlYnVnY2hlY2tfYWZ0ZXIoY2FjaGVwLCBmbGFncywgb2JqcCwgY2FsbGVyKTsKKwlrbWVtbGVha19hbGxvY19yZWN1cnNpdmUob2JqcCwgb2JqX3NpemUoY2FjaGVwKSwgMSwgY2FjaGVwLT5mbGFncywKKwkJCQkgZmxhZ3MpOwogCXByZWZldGNodyhvYmpwKTsKIAogCWlmICh1bmxpa2VseSgoZmxhZ3MgJiBfX0dGUF9aRVJPKSAmJiBvYmpwKSkKQEAgLTM1MzAsNiArMzU2MSw3IEBACiAJc3RydWN0IGFycmF5X2NhY2hlICphYyA9IGNwdV9jYWNoZV9nZXQoY2FjaGVwKTsKIAogCWNoZWNrX2lycV9vZmYoKTsKKwlrbWVtbGVha19mcmVlX3JlY3Vyc2l2ZShvYmpwLCBjYWNoZXAtPmZsYWdzKTsKIAlvYmpwID0gY2FjaGVfZnJlZV9kZWJ1Z2NoZWNrKGNhY2hlcCwgb2JqcCwgX19idWlsdGluX3JldHVybl9hZGRyZXNzKDApKTsKIAogCS8qCkBAIC0zODAyLDcgKzM4MzQsNyBAQAogLyoKICAqIFRoaXMgaW5pdGlhbGl6ZXMga21lbV9saXN0MyBvciByZXNpemVzIHZhcmlvdXMgY2FjaGVzIGZvciBhbGwgbm9kZXMuCiAgKi8KLXN0YXRpYyBpbnQgYWxsb2Nfa21lbWxpc3Qoc3RydWN0IGttZW1fY2FjaGUgKmNhY2hlcCkKK3N0YXRpYyBpbnQgYWxsb2Nfa21lbWxpc3Qoc3RydWN0IGttZW1fY2FjaGUgKmNhY2hlcCwgZ2ZwX3QgZ2ZwKQogewogCWludCBub2RlOwogCXN0cnVjdCBrbWVtX2xpc3QzICpsMzsKQEAgLTM4MTIsNyArMzg0NCw3IEBACiAJZm9yX2VhY2hfb25saW5lX25vZGUobm9kZSkgewogCiAgICAgICAgICAgICAgICAgaWYgKHVzZV9hbGllbl9jYWNoZXMpIHsKLSAgICAgICAgICAgICAgICAgICAgICAgIG5ld19hbGllbiA9IGFsbG9jX2FsaWVuX2NhY2hlKG5vZGUsIGNhY2hlcC0+bGltaXQpOworICAgICAgICAgICAgICAgICAgICAgICAgbmV3X2FsaWVuID0gYWxsb2NfYWxpZW5fY2FjaGUobm9kZSwgY2FjaGVwLT5saW1pdCwgZ2ZwKTsKICAgICAgICAgICAgICAgICAgICAgICAgIGlmICghbmV3X2FsaWVuKQogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBnb3RvIGZhaWw7CiAgICAgICAgICAgICAgICAgfQpAQCAtMzgyMSw3ICszODUzLDcgQEAKIAkJaWYgKGNhY2hlcC0+c2hhcmVkKSB7CiAJCQluZXdfc2hhcmVkID0gYWxsb2NfYXJyYXljYWNoZShub2RlLAogCQkJCWNhY2hlcC0+c2hhcmVkKmNhY2hlcC0+YmF0Y2hjb3VudCwKLQkJCQkJMHhiYWFkZjAwZCk7CisJCQkJCTB4YmFhZGYwMGQsIGdmcCk7CiAJCQlpZiAoIW5ld19zaGFyZWQpIHsKIAkJCQlmcmVlX2FsaWVuX2NhY2hlKG5ld19hbGllbik7CiAJCQkJZ290byBmYWlsOwpAQCAtMzg1MCw3ICszODgyLDcgQEAKIAkJCWZyZWVfYWxpZW5fY2FjaGUobmV3X2FsaWVuKTsKIAkJCWNvbnRpbnVlOwogCQl9Ci0JCWwzID0ga21hbGxvY19ub2RlKHNpemVvZihzdHJ1Y3Qga21lbV9saXN0MyksIEdGUF9LRVJORUwsIG5vZGUpOworCQlsMyA9IGttYWxsb2Nfbm9kZShzaXplb2Yoc3RydWN0IGttZW1fbGlzdDMpLCBnZnAsIG5vZGUpOwogCQlpZiAoIWwzKSB7CiAJCQlmcmVlX2FsaWVuX2NhY2hlKG5ld19hbGllbik7CiAJCQlrZnJlZShuZXdfc2hhcmVkKTsKQEAgLTM5MDYsMTggKzM5MzgsMTggQEAKIAogLyogQWx3YXlzIGNhbGxlZCB3aXRoIHRoZSBjYWNoZV9jaGFpbl9tdXRleCBoZWxkICovCiBzdGF0aWMgaW50IGRvX3R1bmVfY3B1Y2FjaGUoc3RydWN0IGttZW1fY2FjaGUgKmNhY2hlcCwgaW50IGxpbWl0LAotCQkJCWludCBiYXRjaGNvdW50LCBpbnQgc2hhcmVkKQorCQkJCWludCBiYXRjaGNvdW50LCBpbnQgc2hhcmVkLCBnZnBfdCBnZnApCiB7CiAJc3RydWN0IGNjdXBkYXRlX3N0cnVjdCAqbmV3OwogCWludCBpOwogCi0JbmV3ID0ga3phbGxvYyhzaXplb2YoKm5ldyksIEdGUF9LRVJORUwpOworCW5ldyA9IGt6YWxsb2Moc2l6ZW9mKCpuZXcpLCBnZnApOwogCWlmICghbmV3KQogCQlyZXR1cm4gLUVOT01FTTsKIAogCWZvcl9lYWNoX29ubGluZV9jcHUoaSkgewogCQluZXctPm5ld1tpXSA9IGFsbG9jX2FycmF5Y2FjaGUoY3B1X3RvX25vZGUoaSksIGxpbWl0LAotCQkJCQkJYmF0Y2hjb3VudCk7CisJCQkJCQliYXRjaGNvdW50LCBnZnApOwogCQlpZiAoIW5ldy0+bmV3W2ldKSB7CiAJCQlmb3IgKGktLTsgaSA+PSAwOyBpLS0pCiAJCQkJa2ZyZWUobmV3LT5uZXdbaV0pOwpAQCAtMzk0NCwxMSArMzk3NiwxMSBAQAogCQlrZnJlZShjY29sZCk7CiAJfQogCWtmcmVlKG5ldyk7Ci0JcmV0dXJuIGFsbG9jX2ttZW1saXN0KGNhY2hlcCk7CisJcmV0dXJuIGFsbG9jX2ttZW1saXN0KGNhY2hlcCwgZ2ZwKTsKIH0KIAogLyogQ2FsbGVkIHdpdGggY2FjaGVfY2hhaW5fbXV0ZXggaGVsZCBhbHdheXMgKi8KLXN0YXRpYyBpbnQgZW5hYmxlX2NwdWNhY2hlKHN0cnVjdCBrbWVtX2NhY2hlICpjYWNoZXApCitzdGF0aWMgaW50IGVuYWJsZV9jcHVjYWNoZShzdHJ1Y3Qga21lbV9jYWNoZSAqY2FjaGVwLCBnZnBfdCBnZnApCiB7CiAJaW50IGVycjsKIAlpbnQgbGltaXQsIHNoYXJlZDsKQEAgLTM5OTQsNyArNDAyNiw3IEBACiAJaWYgKGxpbWl0ID4gMzIpCiAJCWxpbWl0ID0gMzI7CiAjZW5kaWYKLQllcnIgPSBkb190dW5lX2NwdWNhY2hlKGNhY2hlcCwgbGltaXQsIChsaW1pdCArIDEpIC8gMiwgc2hhcmVkKTsKKwllcnIgPSBkb190dW5lX2NwdWNhY2hlKGNhY2hlcCwgbGltaXQsIChsaW1pdCArIDEpIC8gMiwgc2hhcmVkLCBnZnApOwogCWlmIChlcnIpCiAJCXByaW50ayhLRVJOX0VSUiAiZW5hYmxlX2NwdWNhY2hlIGZhaWxlZCBmb3IgJXMsIGVycm9yICVkLlxuIiwKIAkJICAgICAgIGNhY2hlcC0+bmFtZSwgLWVycik7CkBAIC00MzAwLDcgKzQzMzIsOCBAQAogCQkJCXJlcyA9IDA7CiAJCQl9IGVsc2UgewogCQkJCXJlcyA9IGRvX3R1bmVfY3B1Y2FjaGUoY2FjaGVwLCBsaW1pdCwKLQkJCQkJCSAgICAgICBiYXRjaGNvdW50LCBzaGFyZWQpOworCQkJCQkJICAgICAgIGJhdGNoY291bnQsIHNoYXJlZCwKKwkJCQkJCSAgICAgICBHRlBfS0VSTkVMKTsKIAkJCX0KIAkJCWJyZWFrOwogCQl9CmRpZmYgLS1naXQgYS9tbS9zbG9iLmMgYi9tbS9zbG9iLmMKaW5kZXggOWIxNzM3Yi4uMTJmMjYxNCAxMDA2NDQKLS0tIGEvbW0vc2xvYi5jCisrKyBiL21tL3Nsb2IuYwpAQCAtNjcsNiArNjcsNyBAQAogI2luY2x1ZGUgPGxpbnV4L3JjdXBkYXRlLmg+CiAjaW5jbHVkZSA8bGludXgvbGlzdC5oPgogI2luY2x1ZGUgPGxpbnV4L2ttZW10cmFjZS5oPgorI2luY2x1ZGUgPGxpbnV4L2ttZW1sZWFrLmg+CiAjaW5jbHVkZSA8YXNtL2F0b21pYy5oPgogCiAvKgpAQCAtNTA5LDYgKzUxMCw3IEBACiAJCQkJICAgc2l6ZSwgUEFHRV9TSVpFIDw8IG9yZGVyLCBnZnAsIG5vZGUpOwogCX0KIAorCWttZW1sZWFrX2FsbG9jKHJldCwgc2l6ZSwgMSwgZ2ZwKTsKIAlyZXR1cm4gcmV0OwogfQogRVhQT1JUX1NZTUJPTChfX2ttYWxsb2Nfbm9kZSk7CkBAIC01MjEsNiArNTIzLDcgQEAKIAogCWlmICh1bmxpa2VseShaRVJPX09SX05VTExfUFRSKGJsb2NrKSkpCiAJCXJldHVybjsKKwlrbWVtbGVha19mcmVlKGJsb2NrKTsKIAogCXNwID0gc2xvYl9wYWdlKGJsb2NrKTsKIAlpZiAoaXNfc2xvYl9wYWdlKHNwKSkgewpAQCAtNTg0LDEyICs1ODcsMTQgQEAKIAl9IGVsc2UgaWYgKGZsYWdzICYgU0xBQl9QQU5JQykKIAkJcGFuaWMoIkNhbm5vdCBjcmVhdGUgc2xhYiBjYWNoZSAlc1xuIiwgbmFtZSk7CiAKKwlrbWVtbGVha19hbGxvYyhjLCBzaXplb2Yoc3RydWN0IGttZW1fY2FjaGUpLCAxLCBHRlBfS0VSTkVMKTsKIAlyZXR1cm4gYzsKIH0KIEVYUE9SVF9TWU1CT0woa21lbV9jYWNoZV9jcmVhdGUpOwogCiB2b2lkIGttZW1fY2FjaGVfZGVzdHJveShzdHJ1Y3Qga21lbV9jYWNoZSAqYykKIHsKKwlrbWVtbGVha19mcmVlKGMpOwogCXNsb2JfZnJlZShjLCBzaXplb2Yoc3RydWN0IGttZW1fY2FjaGUpKTsKIH0KIEVYUE9SVF9TWU1CT0woa21lbV9jYWNoZV9kZXN0cm95KTsKQEAgLTYxMyw2ICs2MTgsNyBAQAogCWlmIChjLT5jdG9yKQogCQljLT5jdG9yKGIpOwogCisJa21lbWxlYWtfYWxsb2NfcmVjdXJzaXZlKGIsIGMtPnNpemUsIDEsIGMtPmZsYWdzLCBmbGFncyk7CiAJcmV0dXJuIGI7CiB9CiBFWFBPUlRfU1lNQk9MKGttZW1fY2FjaGVfYWxsb2Nfbm9kZSk7CkBAIC02MzUsNiArNjQxLDcgQEAKIAogdm9pZCBrbWVtX2NhY2hlX2ZyZWUoc3RydWN0IGttZW1fY2FjaGUgKmMsIHZvaWQgKmIpCiB7CisJa21lbWxlYWtfZnJlZV9yZWN1cnNpdmUoYiwgYy0+ZmxhZ3MpOwogCWlmICh1bmxpa2VseShjLT5mbGFncyAmIFNMQUJfREVTVFJPWV9CWV9SQ1UpKSB7CiAJCXN0cnVjdCBzbG9iX3JjdSAqc2xvYl9yY3U7CiAJCXNsb2JfcmN1ID0gYiArIChjLT5zaXplIC0gc2l6ZW9mKHN0cnVjdCBzbG9iX3JjdSkpOwpkaWZmIC0tZ2l0IGEvbW0vc2x1Yi5jIGIvbW0vc2x1Yi5jCmluZGV4IDVlODA1YTYuLjM5NjRkM2MgMTAwNjQ0Ci0tLSBhL21tL3NsdWIuYworKysgYi9tbS9zbHViLmMKQEAgLTIwLDYgKzIwLDcgQEAKICNpbmNsdWRlIDxsaW51eC9rbWVtdHJhY2UuaD4KICNpbmNsdWRlIDxsaW51eC9jcHUuaD4KICNpbmNsdWRlIDxsaW51eC9jcHVzZXQuaD4KKyNpbmNsdWRlIDxsaW51eC9rbWVtbGVhay5oPgogI2luY2x1ZGUgPGxpbnV4L21lbXBvbGljeS5oPgogI2luY2x1ZGUgPGxpbnV4L2N0eXBlLmg+CiAjaW5jbHVkZSA8bGludXgvZGVidWdvYmplY3RzLmg+CkBAIC0xNDMsNyArMTQ0LDcgQEAKICAqIFNldCBvZiBmbGFncyB0aGF0IHdpbGwgcHJldmVudCBzbGFiIG1lcmdpbmcKICAqLwogI2RlZmluZSBTTFVCX05FVkVSX01FUkdFIChTTEFCX1JFRF9aT05FIHwgU0xBQl9QT0lTT04gfCBTTEFCX1NUT1JFX1VTRVIgfCBcCi0JCVNMQUJfVFJBQ0UgfCBTTEFCX0RFU1RST1lfQllfUkNVKQorCQlTTEFCX1RSQUNFIHwgU0xBQl9ERVNUUk9ZX0JZX1JDVSB8IFNMQUJfTk9MRUFLVFJBQ0UpCiAKICNkZWZpbmUgU0xVQl9NRVJHRV9TQU1FIChTTEFCX0RFQlVHX0ZSRUUgfCBTTEFCX1JFQ0xBSU1fQUNDT1VOVCB8IFwKIAkJU0xBQl9DQUNIRV9ETUEpCkBAIC0xNjE3LDYgKzE2MTgsNyBAQAogCWlmICh1bmxpa2VseSgoZ2ZwZmxhZ3MgJiBfX0dGUF9aRVJPKSAmJiBvYmplY3QpKQogCQltZW1zZXQob2JqZWN0LCAwLCBvYmpzaXplKTsKIAorCWttZW1sZWFrX2FsbG9jX3JlY3Vyc2l2ZShvYmplY3QsIG9ianNpemUsIDEsIHMtPmZsYWdzLCBnZnBmbGFncyk7CiAJcmV0dXJuIG9iamVjdDsKIH0KIApAQCAtMTc0Niw2ICsxNzQ4LDcgQEAKIAlzdHJ1Y3Qga21lbV9jYWNoZV9jcHUgKmM7CiAJdW5zaWduZWQgbG9uZyBmbGFnczsKIAorCWttZW1sZWFrX2ZyZWVfcmVjdXJzaXZlKHgsIHMtPmZsYWdzKTsKIAlsb2NhbF9pcnFfc2F2ZShmbGFncyk7CiAJYyA9IGdldF9jcHVfc2xhYihzLCBzbXBfcHJvY2Vzc29yX2lkKCkpOwogCWRlYnVnX2NoZWNrX25vX2xvY2tzX2ZyZWVkKG9iamVjdCwgYy0+b2Jqc2l6ZSk7CkBAIC0yNTU3LDEzICsyNTYwLDE2IEBACiAJaWYgKGdmcF9mbGFncyAmIFNMVUJfRE1BKQogCQlmbGFncyA9IFNMQUJfQ0FDSEVfRE1BOwogCi0JZG93bl93cml0ZSgmc2x1Yl9sb2NrKTsKKwkvKgorCSAqIFRoaXMgZnVuY3Rpb24gaXMgY2FsbGVkIHdpdGggSVJRcyBkaXNhYmxlZCBkdXJpbmcgZWFybHktYm9vdCBvbgorCSAqIHNpbmdsZSBDUFUgc28gdGhlcmUncyBubyBuZWVkIHRvIHRha2Ugc2x1Yl9sb2NrIGhlcmUuCisJICovCiAJaWYgKCFrbWVtX2NhY2hlX29wZW4ocywgZ2ZwX2ZsYWdzLCBuYW1lLCBzaXplLCBBUkNIX0tNQUxMT0NfTUlOQUxJR04sCiAJCQkJCQkJCWZsYWdzLCBOVUxMKSkKIAkJZ290byBwYW5pYzsKIAogCWxpc3RfYWRkKCZzLT5saXN0LCAmc2xhYl9jYWNoZXMpOwotCXVwX3dyaXRlKCZzbHViX2xvY2spOworCiAJaWYgKHN5c2ZzX3NsYWJfYWRkKHMpKQogCQlnb3RvIHBhbmljOwogCXJldHVybiBzOwpAQCAtMzAyMSw3ICszMDI3LDcgQEAKIAkgKiBrbWVtX2NhY2hlX29wZW4gZm9yIHNsYWJfc3RhdGUgPT0gRE9XTi4KIAkgKi8KIAljcmVhdGVfa21hbGxvY19jYWNoZSgma21hbGxvY19jYWNoZXNbMF0sICJrbWVtX2NhY2hlX25vZGUiLAotCQlzaXplb2Yoc3RydWN0IGttZW1fY2FjaGVfbm9kZSksIEdGUF9LRVJORUwpOworCQlzaXplb2Yoc3RydWN0IGttZW1fY2FjaGVfbm9kZSksIEdGUF9OT1dBSVQpOwogCWttYWxsb2NfY2FjaGVzWzBdLnJlZmNvdW50ID0gLTE7CiAJY2FjaGVzKys7CiAKQEAgLTMwMzQsMTYgKzMwNDAsMTYgQEAKIAkvKiBDYWNoZXMgdGhhdCBhcmUgbm90IG9mIHRoZSB0d28tdG8tdGhlLXBvd2VyLW9mIHNpemUgKi8KIAlpZiAoS01BTExPQ19NSU5fU0laRSA8PSA2NCkgewogCQljcmVhdGVfa21hbGxvY19jYWNoZSgma21hbGxvY19jYWNoZXNbMV0sCi0JCQkJImttYWxsb2MtOTYiLCA5NiwgR0ZQX0tFUk5FTCk7CisJCQkJImttYWxsb2MtOTYiLCA5NiwgR0ZQX05PV0FJVCk7CiAJCWNhY2hlcysrOwogCQljcmVhdGVfa21hbGxvY19jYWNoZSgma21hbGxvY19jYWNoZXNbMl0sCi0JCQkJImttYWxsb2MtMTkyIiwgMTkyLCBHRlBfS0VSTkVMKTsKKwkJCQkia21hbGxvYy0xOTIiLCAxOTIsIEdGUF9OT1dBSVQpOwogCQljYWNoZXMrKzsKIAl9CiAKIAlmb3IgKGkgPSBLTUFMTE9DX1NISUZUX0xPVzsgaSA8IFNMVUJfUEFHRV9TSElGVDsgaSsrKSB7CiAJCWNyZWF0ZV9rbWFsbG9jX2NhY2hlKCZrbWFsbG9jX2NhY2hlc1tpXSwKLQkJCSJrbWFsbG9jIiwgMSA8PCBpLCBHRlBfS0VSTkVMKTsKKwkJCSJrbWFsbG9jIiwgMSA8PCBpLCBHRlBfTk9XQUlUKTsKIAkJY2FjaGVzKys7CiAJfQogCkBAIC0zMDgwLDcgKzMwODYsNyBAQAogCS8qIFByb3ZpZGUgdGhlIGNvcnJlY3Qga21hbGxvYyBuYW1lcyBub3cgdGhhdCB0aGUgY2FjaGVzIGFyZSB1cCAqLwogCWZvciAoaSA9IEtNQUxMT0NfU0hJRlRfTE9XOyBpIDwgU0xVQl9QQUdFX1NISUZUOyBpKyspCiAJCWttYWxsb2NfY2FjaGVzW2ldLiBuYW1lID0KLQkJCWthc3ByaW50ZihHRlBfS0VSTkVMLCAia21hbGxvYy0lZCIsIDEgPDwgaSk7CisJCQlrYXNwcmludGYoR0ZQX05PV0FJVCwgImttYWxsb2MtJWQiLCAxIDw8IGkpOwogCiAjaWZkZWYgQ09ORklHX1NNUAogCXJlZ2lzdGVyX2NwdV9ub3RpZmllcigmc2xhYl9ub3RpZmllcik7CmRpZmYgLS1naXQgYS9tbS92bWFsbG9jLmMgYi9tbS92bWFsbG9jLmMKaW5kZXggMDgzNzE2ZS4uZjgxODlhNCAxMDA2NDQKLS0tIGEvbW0vdm1hbGxvYy5jCisrKyBiL21tL3ZtYWxsb2MuYwpAQCAtMjMsOCArMjMsOCBAQAogI2luY2x1ZGUgPGxpbnV4L3JidHJlZS5oPgogI2luY2x1ZGUgPGxpbnV4L3JhZGl4LXRyZWUuaD4KICNpbmNsdWRlIDxsaW51eC9yY3VwZGF0ZS5oPgotI2luY2x1ZGUgPGxpbnV4L2Jvb3RtZW0uaD4KICNpbmNsdWRlIDxsaW51eC9wZm4uaD4KKyNpbmNsdWRlIDxsaW51eC9rbWVtbGVhay5oPgogCiAjaW5jbHVkZSA8YXNtL2F0b21pYy5oPgogI2luY2x1ZGUgPGFzbS91YWNjZXNzLmg+CkBAIC0xMDMyLDcgKzEwMzIsNyBAQAogCiAJLyogSW1wb3J0IGV4aXN0aW5nIHZtbGlzdCBlbnRyaWVzLiAqLwogCWZvciAodG1wID0gdm1saXN0OyB0bXA7IHRtcCA9IHRtcC0+bmV4dCkgewotCQl2YSA9IGFsbG9jX2Jvb3RtZW0oc2l6ZW9mKHN0cnVjdCB2bWFwX2FyZWEpKTsKKwkJdmEgPSBremFsbG9jKHNpemVvZihzdHJ1Y3Qgdm1hcF9hcmVhKSwgR0ZQX05PV0FJVCk7CiAJCXZhLT5mbGFncyA9IHRtcC0+ZmxhZ3MgfCBWTV9WTV9BUkVBOwogCQl2YS0+dmFfc3RhcnQgPSAodW5zaWduZWQgbG9uZyl0bXAtPmFkZHI7CiAJCXZhLT52YV9lbmQgPSB2YS0+dmFfc3RhcnQgKyB0bXAtPnNpemU7CkBAIC0xMzI3LDYgKzEzMjcsOSBAQAogdm9pZCB2ZnJlZShjb25zdCB2b2lkICphZGRyKQogewogCUJVR19PTihpbl9pbnRlcnJ1cHQoKSk7CisKKwlrbWVtbGVha19mcmVlKGFkZHIpOworCiAJX192dW5tYXAoYWRkciwgMSk7CiB9CiBFWFBPUlRfU1lNQk9MKHZmcmVlKTsKQEAgLTE0MzksOCArMTQ0MiwxNyBAQAogCiB2b2lkICpfX3ZtYWxsb2NfYXJlYShzdHJ1Y3Qgdm1fc3RydWN0ICphcmVhLCBnZnBfdCBnZnBfbWFzaywgcGdwcm90X3QgcHJvdCkKIHsKLQlyZXR1cm4gX192bWFsbG9jX2FyZWFfbm9kZShhcmVhLCBnZnBfbWFzaywgcHJvdCwgLTEsCi0JCQkJCV9fYnVpbHRpbl9yZXR1cm5fYWRkcmVzcygwKSk7CisJdm9pZCAqYWRkciA9IF9fdm1hbGxvY19hcmVhX25vZGUoYXJlYSwgZ2ZwX21hc2ssIHByb3QsIC0xLAorCQkJCQkgX19idWlsdGluX3JldHVybl9hZGRyZXNzKDApKTsKKworCS8qCisJICogQSByZWZfY291bnQgPSAzIGlzIG5lZWRlZCBiZWNhdXNlIHRoZSB2bV9zdHJ1Y3QgYW5kIHZtYXBfYXJlYQorCSAqIHN0cnVjdHVyZXMgYWxsb2NhdGVkIGluIHRoZSBfX2dldF92bV9hcmVhX25vZGUoKSBmdW5jdGlvbiBjb250YWluCisJICogcmVmZXJlbmNlcyB0byB0aGUgdmlydHVhbCBhZGRyZXNzIG9mIHRoZSB2bWFsbG9jJ2VkIGJsb2NrLgorCSAqLworCWttZW1sZWFrX2FsbG9jKGFkZHIsIGFyZWEtPnNpemUgLSBQQUdFX1NJWkUsIDMsIGdmcF9tYXNrKTsKKworCXJldHVybiBhZGRyOwogfQogCiAvKioKQEAgLTE0NTksNiArMTQ3MSw4IEBACiAJCQkJCQlpbnQgbm9kZSwgdm9pZCAqY2FsbGVyKQogewogCXN0cnVjdCB2bV9zdHJ1Y3QgKmFyZWE7CisJdm9pZCAqYWRkcjsKKwl1bnNpZ25lZCBsb25nIHJlYWxfc2l6ZSA9IHNpemU7CiAKIAlzaXplID0gUEFHRV9BTElHTihzaXplKTsKIAlpZiAoIXNpemUgfHwgKHNpemUgPj4gUEFHRV9TSElGVCkgPiBudW1fcGh5c3BhZ2VzKQpAQCAtMTQ3MCw3ICsxNDg0LDE2IEBACiAJaWYgKCFhcmVhKQogCQlyZXR1cm4gTlVMTDsKIAotCXJldHVybiBfX3ZtYWxsb2NfYXJlYV9ub2RlKGFyZWEsIGdmcF9tYXNrLCBwcm90LCBub2RlLCBjYWxsZXIpOworCWFkZHIgPSBfX3ZtYWxsb2NfYXJlYV9ub2RlKGFyZWEsIGdmcF9tYXNrLCBwcm90LCBub2RlLCBjYWxsZXIpOworCisJLyoKKwkgKiBBIHJlZl9jb3VudCA9IDMgaXMgbmVlZGVkIGJlY2F1c2UgdGhlIHZtX3N0cnVjdCBhbmQgdm1hcF9hcmVhCisJICogc3RydWN0dXJlcyBhbGxvY2F0ZWQgaW4gdGhlIF9fZ2V0X3ZtX2FyZWFfbm9kZSgpIGZ1bmN0aW9uIGNvbnRhaW4KKwkgKiByZWZlcmVuY2VzIHRvIHRoZSB2aXJ0dWFsIGFkZHJlc3Mgb2YgdGhlIHZtYWxsb2MnZWQgYmxvY2suCisJICovCisJa21lbWxlYWtfYWxsb2MoYWRkciwgcmVhbF9zaXplLCAzLCBnZnBfbWFzayk7CisKKwlyZXR1cm4gYWRkcjsKIH0KIAogdm9pZCAqX192bWFsbG9jKHVuc2lnbmVkIGxvbmcgc2l6ZSwgZ2ZwX3QgZ2ZwX21hc2ssIHBncHJvdF90IHByb3QpCmRpZmYgLS1naXQgYS90b29scy9wZXJmLy5naXRpZ25vcmUgYi90b29scy9wZXJmLy5naXRpZ25vcmUKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uZDY5YTc1OQotLS0gL2Rldi9udWxsCisrKyBiL3Rvb2xzL3BlcmYvLmdpdGlnbm9yZQpAQCAtMCwwICsxLDE2IEBACitQRVJGLUJVSUxELU9QVElPTlMKK1BFUkYtQ0ZMQUdTCitQRVJGLUdVSS1WQVJTCitQRVJGLVZFUlNJT04tRklMRQorcGVyZgorcGVyZi1oZWxwCitwZXJmLXJlY29yZAorcGVyZi1yZXBvcnQKK3BlcmYtc3RhdAorcGVyZi10b3AKK3BlcmYqLjEKK3BlcmYqLnhtbAorY29tbW9uLWNtZHMuaAordGFncworVEFHUworY3Njb3BlKgpkaWZmIC0tZ2l0IGEvdG9vbHMvcGVyZi9Eb2N1bWVudGF0aW9uL01ha2VmaWxlIGIvdG9vbHMvcGVyZi9Eb2N1bWVudGF0aW9uL01ha2VmaWxlCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjU0NTcxOTIKLS0tIC9kZXYvbnVsbAorKysgYi90b29scy9wZXJmL0RvY3VtZW50YXRpb24vTWFrZWZpbGUKQEAgLTAsMCArMSwzMDAgQEAKK01BTjFfVFhUPSBcCisJJChmaWx0ZXItb3V0ICQoYWRkc3VmZml4IC50eHQsICQoQVJUSUNMRVMpICQoU1BfQVJUSUNMRVMpKSwgXAorCQkkKHdpbGRjYXJkIHBlcmYtKi50eHQpKSBcCisJcGVyZi50eHQKK01BTjVfVFhUPQorTUFON19UWFQ9CisKK01BTl9UWFQgPSAkKE1BTjFfVFhUKSAkKE1BTjVfVFhUKSAkKE1BTjdfVFhUKQorTUFOX1hNTD0kKHBhdHN1YnN0ICUudHh0LCUueG1sLCQoTUFOX1RYVCkpCitNQU5fSFRNTD0kKHBhdHN1YnN0ICUudHh0LCUuaHRtbCwkKE1BTl9UWFQpKQorCitET0NfSFRNTD0kKE1BTl9IVE1MKQorCitBUlRJQ0xFUyA9CisjIHdpdGggdGhlaXIgb3duIGZvcm1hdHRpbmcgcnVsZXMuCitTUF9BUlRJQ0xFUyA9CitBUElfRE9DUyA9ICQocGF0c3Vic3QgJS50eHQsJSwkKGZpbHRlci1vdXQgdGVjaG5pY2FsL2FwaS1pbmRleC1za2VsLnR4dCB0ZWNobmljYWwvYXBpLWluZGV4LnR4dCwgJCh3aWxkY2FyZCB0ZWNobmljYWwvYXBpLSoudHh0KSkpCitTUF9BUlRJQ0xFUyArPSAkKEFQSV9ET0NTKQorU1BfQVJUSUNMRVMgKz0gdGVjaG5pY2FsL2FwaS1pbmRleAorCitET0NfSFRNTCArPSAkKHBhdHN1YnN0ICUsJS5odG1sLCQoQVJUSUNMRVMpICQoU1BfQVJUSUNMRVMpKQorCitET0NfTUFOMT0kKHBhdHN1YnN0ICUudHh0LCUuMSwkKE1BTjFfVFhUKSkKK0RPQ19NQU41PSQocGF0c3Vic3QgJS50eHQsJS41LCQoTUFONV9UWFQpKQorRE9DX01BTjc9JChwYXRzdWJzdCAlLnR4dCwlLjcsJChNQU43X1RYVCkpCisKK3ByZWZpeD89JChIT01FKQorYmluZGlyPz0kKHByZWZpeCkvYmluCitodG1sZGlyPz0kKHByZWZpeCkvc2hhcmUvZG9jL3BlcmYtZG9jCitwZGZkaXI/PSQocHJlZml4KS9zaGFyZS9kb2MvcGVyZi1kb2MKK21hbmRpcj89JChwcmVmaXgpL3NoYXJlL21hbgorbWFuMWRpcj0kKG1hbmRpcikvbWFuMQorbWFuNWRpcj0kKG1hbmRpcikvbWFuNQorbWFuN2Rpcj0kKG1hbmRpcikvbWFuNworIyBERVNURElSPQorCitBU0NJSURPQz1hc2NpaWRvYworQVNDSUlET0NfRVhUUkEgPQorTUFOUEFHRV9YU0wgPSBtYW5wYWdlLW5vcm1hbC54c2wKK1hNTFRPX0VYVFJBID0KK0lOU1RBTEw/PWluc3RhbGwKK1JNID89IHJtIC1mCitET0NfUkVGID0gb3JpZ2luL21hbgorSFRNTF9SRUYgPSBvcmlnaW4vaHRtbAorCitpbmZvZGlyPz0kKHByZWZpeCkvc2hhcmUvaW5mbworTUFLRUlORk89bWFrZWluZm8KK0lOU1RBTExfSU5GTz1pbnN0YWxsLWluZm8KK0RPQ0JPT0syWF9URVhJPWRvY2Jvb2syeC10ZXhpCitEQkxBVEVYPWRibGF0ZXgKK2lmbmRlZiBQRVJMX1BBVEgKKwlQRVJMX1BBVEggPSAvdXNyL2Jpbi9wZXJsCitlbmRpZgorCistaW5jbHVkZSAuLi9jb25maWcubWFrLmF1dG9nZW4KKy1pbmNsdWRlIC4uL2NvbmZpZy5tYWsKKworIworIyBGb3IgYXNjaWlkb2MgLi4uCisjCS03LjEuMiwJbm8gZXh0cmEgc2V0dGluZ3MgYXJlIG5lZWRlZC4KKyMJOC4wLSwJc2V0IEFTQ0lJRE9DOC4KKyMKKworIworIyBGb3IgZG9jYm9vay14c2wgLi4uCisjCS0xLjY4LjEsCXNldCBBU0NJSURPQ19OT19ST0ZGPyAoYmFzZWQgb24gY2hhbmdlbG9nIGZyb20gMS43My4wKQorIwkxLjY5LjAsCQlubyBleHRyYSBzZXR0aW5ncyBhcmUgbmVlZGVkPworIwkxLjY5LjEtMS43MS4wLAlzZXQgRE9DQk9PS19TVVBQUkVTU19TUD8KKyMJMS43MS4xLAkJbm8gZXh0cmEgc2V0dGluZ3MgYXJlIG5lZWRlZD8KKyMJMS43Mi4wLAkJc2V0IERPQ0JPT0tfWFNMXzE3Mi4KKyMJMS43My4wLSwJc2V0IEFTQ0lJRE9DX05PX1JPRkYKKyMKKworIworIyBJZiB5b3UgaGFkIGJlZW4gdXNpbmcgRE9DQk9PS19YU0xfMTcyIGluIGFuIGF0dGVtcHQgdG8gZ2V0IHJpZAorIyBvZiAndGhlICIuZnQgQyIgcHJvYmxlbScgaW4geW91ciBnZW5lcmF0ZWQgbWFucGFnZXMsIGFuZCB5b3UKKyMgaW5zdGVhZCBlbmRlZCB1cCB3aXRoIHdlaXJkIGNoYXJhY3RlcnMgYXJvdW5kIGNhbGxvdXRzLCB0cnkKKyMgdXNpbmcgQVNDSUlET0NfTk9fUk9GRiBpbnN0ZWFkIChpdCB3b3JrcyBmaW5lIHdpdGggQVNDSUlET0M4KS4KKyMKKworaWZkZWYgQVNDSUlET0M4CitBU0NJSURPQ19FWFRSQSArPSAtYSBhc2NpaWRvYzdjb21wYXRpYmxlCitlbmRpZgoraWZkZWYgRE9DQk9PS19YU0xfMTcyCitBU0NJSURPQ19FWFRSQSArPSAtYSBwZXJmLWFzY2lpZG9jLW5vLXJvZmYKK01BTlBBR0VfWFNMID0gbWFucGFnZS0xLjcyLnhzbAorZWxzZQorCWlmZGVmIEFTQ0lJRE9DX05PX1JPRkYKKwkjIGRvY2Jvb2steHNsIGFmdGVyIDEuNzIgbmVlZHMgdGhlIHJlZ3VsYXIgWFNMLCBidXQgd2lsbCBub3QKKwkjIHBhc3MtdGhydSByYXcgcm9mZiBjb2RlcyBmcm9tIGFzY2lpZG9jLmNvbmYsIHNvIHR1cm4gdGhlbSBvZmYuCisJQVNDSUlET0NfRVhUUkEgKz0gLWEgcGVyZi1hc2NpaWRvYy1uby1yb2ZmCisJZW5kaWYKK2VuZGlmCitpZmRlZiBNQU5fQk9MRF9MSVRFUkFMCitYTUxUT19FWFRSQSArPSAtbSBtYW5wYWdlLWJvbGQtbGl0ZXJhbC54c2wKK2VuZGlmCitpZmRlZiBET0NCT09LX1NVUFBSRVNTX1NQCitYTUxUT19FWFRSQSArPSAtbSBtYW5wYWdlLXN1cHByZXNzLXNwLnhzbAorZW5kaWYKKworU0hFTExfUEFUSCA/PSAkKFNIRUxMKQorIyBTaGVsbCBxdW90ZTsKK1NIRUxMX1BBVEhfU1EgPSAkKHN1YnN0ICcsJ1wnJywkKFNIRUxMX1BBVEgpKQorCisjCisjIFBsZWFzZSBub3RlIHRoYXQgdGhlcmUgaXMgYSBtaW5vciBidWcgaW4gYXNjaWlkb2MuCisjIFRoZSB2ZXJzaW9uIGFmdGVyIDYuMC4zIF93aWxsXyBpbmNsdWRlIHRoZSBwYXRjaCBmb3VuZCBoZXJlOgorIyAgIGh0dHA6Ly9tYXJjLnRoZWFpbXNncm91cC5jb20vP2w9cGVyZiZtPTExMTU1ODc1NzIwMjI0MyZ3PTIKKyMKKyMgVW50aWwgdGhhdCB2ZXJzaW9uIGlzIHJlbGVhc2VkIHlvdSBtYXkgaGF2ZSB0byBhcHBseSB0aGUgcGF0Y2gKKyMgeW91cnNlbGYgLSB5ZXMsIGFsbCA2IGNoYXJhY3RlcnMgb2YgaXQhCisjCisKK1FVSUVUX1NVQkRJUjAgID0gKyQoTUFLRSkgLUMgIyBzcGFjZSB0byBzZXBhcmF0ZSAtQyBhbmQgc3ViZGlyCitRVUlFVF9TVUJESVIxICA9CisKK2lmbmVxICgkKGZpbmRzdHJpbmcgJChNQUtFRkxBR1MpLHcpLHcpCitQUklOVF9ESVIgPSAtLW5vLXByaW50LWRpcmVjdG9yeQorZWxzZSAjICJtYWtlIC13IgorTk9fU1VCRElSID0gOgorZW5kaWYKKworaWZuZXEgKCQoZmluZHN0cmluZyAkKE1BS0VGTEFHUykscykscykKK2lmbmRlZiBWCisJUVVJRVRfQVNDSUlET0MJPSBAZWNobyAnICAgJyBBU0NJSURPQyAkQDsKKwlRVUlFVF9YTUxUTwk9IEBlY2hvICcgICAnIFhNTFRPICRAOworCVFVSUVUX0RCMlRFWEkJPSBAZWNobyAnICAgJyBEQjJURVhJICRAOworCVFVSUVUX01BS0VJTkZPCT0gQGVjaG8gJyAgICcgTUFLRUlORk8gJEA7CisJUVVJRVRfREJMQVRFWAk9IEBlY2hvICcgICAnIERCTEFURVggJEA7CisJUVVJRVRfWFNMVFBST0MJPSBAZWNobyAnICAgJyBYU0xUUFJPQyAkQDsKKwlRVUlFVF9HRU4JPSBAZWNobyAnICAgJyBHRU4gJEA7CisJUVVJRVRfU1RERVJSCT0gMj4gL2Rldi9udWxsCisJUVVJRVRfU1VCRElSMAk9ICtAc3ViZGlyPQorCVFVSUVUX1NVQkRJUjEJPSA7JChOT19TVUJESVIpIGVjaG8gJyAgICcgU1VCRElSICQkc3ViZGlyOyBcCisJCQkgICQoTUFLRSkgJChQUklOVF9ESVIpIC1DICQkc3ViZGlyCisJZXhwb3J0IFYKK2VuZGlmCitlbmRpZgorCithbGw6IGh0bWwgbWFuCisKK2h0bWw6ICQoRE9DX0hUTUwpCisKKyQoRE9DX0hUTUwpICQoRE9DX01BTjEpICQoRE9DX01BTjUpICQoRE9DX01BTjcpOiBhc2NpaWRvYy5jb25mCisKK21hbjogbWFuMSBtYW41IG1hbjcKK21hbjE6ICQoRE9DX01BTjEpCittYW41OiAkKERPQ19NQU41KQorbWFuNzogJChET0NfTUFONykKKworaW5mbzogcGVyZi5pbmZvIHBlcmZtYW4uaW5mbworCitwZGY6IHVzZXItbWFudWFsLnBkZgorCitpbnN0YWxsOiBpbnN0YWxsLW1hbgorCitpbnN0YWxsLW1hbjogbWFuCisJJChJTlNUQUxMKSAtZCAtbSA3NTUgJChERVNURElSKSQobWFuMWRpcikKKyMJJChJTlNUQUxMKSAtZCAtbSA3NTUgJChERVNURElSKSQobWFuNWRpcikKKyMJJChJTlNUQUxMKSAtZCAtbSA3NTUgJChERVNURElSKSQobWFuN2RpcikKKwkkKElOU1RBTEwpIC1tIDY0NCAkKERPQ19NQU4xKSAkKERFU1RESVIpJChtYW4xZGlyKQorIwkkKElOU1RBTEwpIC1tIDY0NCAkKERPQ19NQU41KSAkKERFU1RESVIpJChtYW41ZGlyKQorIwkkKElOU1RBTEwpIC1tIDY0NCAkKERPQ19NQU43KSAkKERFU1RESVIpJChtYW43ZGlyKQorCitpbnN0YWxsLWluZm86IGluZm8KKwkkKElOU1RBTEwpIC1kIC1tIDc1NSAkKERFU1RESVIpJChpbmZvZGlyKQorCSQoSU5TVEFMTCkgLW0gNjQ0IHBlcmYuaW5mbyBwZXJmbWFuLmluZm8gJChERVNURElSKSQoaW5mb2RpcikKKwlpZiB0ZXN0IC1yICQoREVTVERJUikkKGluZm9kaXIpL2RpcjsgdGhlbiBcCisJICAkKElOU1RBTExfSU5GTykgLS1pbmZvLWRpcj0kKERFU1RESVIpJChpbmZvZGlyKSBwZXJmLmluZm8gO1wKKwkgICQoSU5TVEFMTF9JTkZPKSAtLWluZm8tZGlyPSQoREVTVERJUikkKGluZm9kaXIpIHBlcmZtYW4uaW5mbyA7XAorCWVsc2UgXAorCSAgZWNobyAiTm8gZGlyZWN0b3J5IGZvdW5kIGluICQoREVTVERJUikkKGluZm9kaXIpIiA+JjIgOyBcCisJZmkKKworaW5zdGFsbC1wZGY6IHBkZgorCSQoSU5TVEFMTCkgLWQgLW0gNzU1ICQoREVTVERJUikkKHBkZmRpcikKKwkkKElOU1RBTEwpIC1tIDY0NCB1c2VyLW1hbnVhbC5wZGYgJChERVNURElSKSQocGRmZGlyKQorCitpbnN0YWxsLWh0bWw6IGh0bWwKKwknJChTSEVMTF9QQVRIX1NRKScgLi9pbnN0YWxsLXdlYmRvYy5zaCAkKERFU1RESVIpJChodG1sZGlyKQorCisuLi9QRVJGLVZFUlNJT04tRklMRTogLkZPUkNFLVBFUkYtVkVSU0lPTi1GSUxFCisJJChRVUlFVF9TVUJESVIwKS4uLyAkKFFVSUVUX1NVQkRJUjEpIFBFUkYtVkVSU0lPTi1GSUxFCisKKy1pbmNsdWRlIC4uL1BFUkYtVkVSU0lPTi1GSUxFCisKKyMKKyMgRGV0ZXJtaW5lICJpbmNsdWRlOjoiIGZpbGUgcmVmZXJlbmNlcyBpbiBhc2NpaWRvYyBmaWxlcy4KKyMKK2RvYy5kZXAgOiAkKHdpbGRjYXJkICoudHh0KSBidWlsZC1kb2NkZXAucGVybAorCSQoUVVJRVRfR0VOKSQoUk0pICRAKyAkQCAmJiBcCisJJChQRVJMX1BBVEgpIC4vYnVpbGQtZG9jZGVwLnBlcmwgPiRAKyAkKFFVSUVUX1NUREVSUikgJiYgXAorCW12ICRAKyAkQAorCistaW5jbHVkZSBkb2MuZGVwCisKK2NtZHNfdHh0ID0gY21kcy1hbmNpbGxhcnlpbnRlcnJvZ2F0b3JzLnR4dCBcCisJY21kcy1hbmNpbGxhcnltYW5pcHVsYXRvcnMudHh0IFwKKwljbWRzLW1haW5wb3JjZWxhaW4udHh0IFwKKwljbWRzLXBsdW1iaW5naW50ZXJyb2dhdG9ycy50eHQgXAorCWNtZHMtcGx1bWJpbmdtYW5pcHVsYXRvcnMudHh0IFwKKwljbWRzLXN5bmNoaW5ncmVwb3NpdG9yaWVzLnR4dCBcCisJY21kcy1zeW5jaGVscGVycy50eHQgXAorCWNtZHMtcHVyZWhlbHBlcnMudHh0IFwKKwljbWRzLWZvcmVpZ25zY21pbnRlcmZhY2UudHh0CisKKyQoY21kc190eHQpOiBjbWQtbGlzdC5tYWRlCisKK2NtZC1saXN0Lm1hZGU6IGNtZC1saXN0LnBlcmwgLi4vY29tbWFuZC1saXN0LnR4dCAkKE1BTjFfVFhUKQorCSQoUVVJRVRfR0VOKSQoUk0pICRAICYmIFwKKwkkKFBFUkxfUEFUSCkgLi9jbWQtbGlzdC5wZXJsIC4uL2NvbW1hbmQtbGlzdC50eHQgJChRVUlFVF9TVERFUlIpICYmIFwKKwlkYXRlID4kQAorCitjbGVhbjoKKwkkKFJNKSAqLnhtbCAqLnhtbCsgKi5odG1sICouaHRtbCsgKi4xICouNSAqLjcKKwkkKFJNKSAqLnRleGkgKi50ZXhpKyAqLnRleGkrKyBwZXJmLmluZm8gcGVyZm1hbi5pbmZvCisJJChSTSkgaG93dG8taW5kZXgudHh0IGhvd3RvLyouaHRtbCBkb2MuZGVwCisJJChSTSkgdGVjaG5pY2FsL2FwaS0qLmh0bWwgdGVjaG5pY2FsL2FwaS1pbmRleC50eHQKKwkkKFJNKSAkKGNtZHNfdHh0KSAqLm1hZGUKKworJChNQU5fSFRNTCk6ICUuaHRtbCA6ICUudHh0CisJJChRVUlFVF9BU0NJSURPQykkKFJNKSAkQCsgJEAgJiYgXAorCSQoQVNDSUlET0MpIC1iIHhodG1sMTEgLWQgbWFucGFnZSAtZiBhc2NpaWRvYy5jb25mIFwKKwkJJChBU0NJSURPQ19FWFRSQSkgLWFwZXJmX3ZlcnNpb249JChQRVJGX1ZFUlNJT04pIC1vICRAKyAkPCAmJiBcCisJbXYgJEArICRACisKKyUuMSAlLjUgJS43IDogJS54bWwKKwkkKFFVSUVUX1hNTFRPKSQoUk0pICRAICYmIFwKKwl4bWx0byAtbSAkKE1BTlBBR0VfWFNMKSAkKFhNTFRPX0VYVFJBKSBtYW4gJDwKKworJS54bWwgOiAlLnR4dAorCSQoUVVJRVRfQVNDSUlET0MpJChSTSkgJEArICRAICYmIFwKKwkkKEFTQ0lJRE9DKSAtYiBkb2Nib29rIC1kIG1hbnBhZ2UgLWYgYXNjaWlkb2MuY29uZiBcCisJCSQoQVNDSUlET0NfRVhUUkEpIC1hcGVyZl92ZXJzaW9uPSQoUEVSRl9WRVJTSU9OKSAtbyAkQCsgJDwgJiYgXAorCW12ICRAKyAkQAorCitYU0xUID0gZG9jYm9vay54c2wKK1hTTFRPUFRTID0gLS14aW5jbHVkZSAtLXN0cmluZ3BhcmFtIGh0bWwuc3R5bGVzaGVldCBkb2Nib29rLXhzbC5jc3MKKwordXNlci1tYW51YWwuaHRtbDogdXNlci1tYW51YWwueG1sCisJJChRVUlFVF9YU0xUUFJPQyl4c2x0cHJvYyAkKFhTTFRPUFRTKSAtbyAkQCAkKFhTTFQpICQ8CisKK3BlcmYuaW5mbzogdXNlci1tYW51YWwudGV4aQorCSQoUVVJRVRfTUFLRUlORk8pJChNQUtFSU5GTykgLS1uby1zcGxpdCAtbyAkQCB1c2VyLW1hbnVhbC50ZXhpCisKK3VzZXItbWFudWFsLnRleGk6IHVzZXItbWFudWFsLnhtbAorCSQoUVVJRVRfREIyVEVYSSkkKFJNKSAkQCsgJEAgJiYgXAorCSQoRE9DQk9PSzJYX1RFWEkpIHVzZXItbWFudWFsLnhtbCAtLWVuY29kaW5nPVVURi04IC0tdG8tc3Rkb3V0ID4kQCsrICYmIFwKKwkkKFBFUkxfUEFUSCkgZml4LXRleGkucGVybCA8JEArKyA+JEArICYmIFwKKwlybSAkQCsrICYmIFwKKwltdiAkQCsgJEAKKwordXNlci1tYW51YWwucGRmOiB1c2VyLW1hbnVhbC54bWwKKwkkKFFVSUVUX0RCTEFURVgpJChSTSkgJEArICRAICYmIFwKKwkkKERCTEFURVgpIC1vICRAKyAtcCAvZXRjL2FzY2lpZG9jL2RibGF0ZXgvYXNjaWlkb2MtZGJsYXRleC54c2wgLXMgL2V0Yy9hc2NpaWRvYy9kYmxhdGV4L2FzY2lpZG9jLWRibGF0ZXguc3R5ICQ8ICYmIFwKKwltdiAkQCsgJEAKKworcGVyZm1hbi50ZXhpOiAkKE1BTl9YTUwpIGNhdC10ZXhpLnBlcmwKKwkkKFFVSUVUX0RCMlRFWEkpJChSTSkgJEArICRAICYmIFwKKwkoJChmb3JlYWNoIHhtbCwkKE1BTl9YTUwpLCQoRE9DQk9PSzJYX1RFWEkpIC0tZW5jb2Rpbmc9VVRGLTggXAorCQktLXRvLXN0ZG91dCAkKHhtbCkgJiYpIHRydWUpID4gJEArKyAmJiBcCisJJChQRVJMX1BBVEgpIGNhdC10ZXhpLnBlcmwgJEAgPCRAKysgPiRAKyAmJiBcCisJcm0gJEArKyAmJiBcCisJbXYgJEArICRACisKK3BlcmZtYW4uaW5mbzogcGVyZm1hbi50ZXhpCisJJChRVUlFVF9NQUtFSU5GTykkKE1BS0VJTkZPKSAtLW5vLXNwbGl0IC0tbm8tdmFsaWRhdGUgJCoudGV4aQorCiskKHBhdHN1YnN0ICUudHh0LCUudGV4aSwkKE1BTl9UWFQpKTogJS50ZXhpIDogJS54bWwKKwkkKFFVSUVUX0RCMlRFWEkpJChSTSkgJEArICRAICYmIFwKKwkkKERPQ0JPT0syWF9URVhJKSAtLXRvLXN0ZG91dCAkKi54bWwgPiRAKyAmJiBcCisJbXYgJEArICRACisKK2hvd3RvLWluZGV4LnR4dDogaG93dG8taW5kZXguc2ggJCh3aWxkY2FyZCBob3d0by8qLnR4dCkKKwkkKFFVSUVUX0dFTikkKFJNKSAkQCsgJEAgJiYgXAorCSckKFNIRUxMX1BBVEhfU1EpJyAuL2hvd3RvLWluZGV4LnNoICQod2lsZGNhcmQgaG93dG8vKi50eHQpID4kQCsgJiYgXAorCW12ICRAKyAkQAorCiskKHBhdHN1YnN0ICUsJS5odG1sLCQoQVJUSUNMRVMpKSA6ICUuaHRtbCA6ICUudHh0CisJJChRVUlFVF9BU0NJSURPQykkKEFTQ0lJRE9DKSAtYiB4aHRtbDExICQqLnR4dAorCitXRUJET0NfREVTVCA9IC9wdWIvc29mdHdhcmUvdG9vbHMvcGVyZi9kb2NzCisKKyQocGF0c3Vic3QgJS50eHQsJS5odG1sLCQod2lsZGNhcmQgaG93dG8vKi50eHQpKTogJS5odG1sIDogJS50eHQKKwkkKFFVSUVUX0FTQ0lJRE9DKSQoUk0pICRAKyAkQCAmJiBcCisJc2VkIC1lICcxLC9eJCQvZCcgJDwgfCAkKEFTQ0lJRE9DKSAtYiB4aHRtbDExIC0gPiRAKyAmJiBcCisJbXYgJEArICRACisKK2luc3RhbGwtd2ViZG9jIDogaHRtbAorCSckKFNIRUxMX1BBVEhfU1EpJyAuL2luc3RhbGwtd2ViZG9jLnNoICQoV0VCRE9DX0RFU1QpCisKK3F1aWNrLWluc3RhbGw6IHF1aWNrLWluc3RhbGwtbWFuCisKK3F1aWNrLWluc3RhbGwtbWFuOgorCSckKFNIRUxMX1BBVEhfU1EpJyAuL2luc3RhbGwtZG9jLXF1aWNrLnNoICQoRE9DX1JFRikgJChERVNURElSKSQobWFuZGlyKQorCitxdWljay1pbnN0YWxsLWh0bWw6CisJJyQoU0hFTExfUEFUSF9TUSknIC4vaW5zdGFsbC1kb2MtcXVpY2suc2ggJChIVE1MX1JFRikgJChERVNURElSKSQoaHRtbGRpcikKKworLlBIT05ZOiAuRk9SQ0UtUEVSRi1WRVJTSU9OLUZJTEUKZGlmZiAtLWdpdCBhL3Rvb2xzL3BlcmYvRG9jdW1lbnRhdGlvbi9hc2NpaWRvYy5jb25mIGIvdG9vbHMvcGVyZi9Eb2N1bWVudGF0aW9uL2FzY2lpZG9jLmNvbmYKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uMzU2YjIzYQotLS0gL2Rldi9udWxsCisrKyBiL3Rvb2xzL3BlcmYvRG9jdW1lbnRhdGlvbi9hc2NpaWRvYy5jb25mCkBAIC0wLDAgKzEsOTEgQEAKKyMjIGxpbmtwZXJmOiBtYWNybworIworIyBVc2FnZTogbGlua3BlcmY6Y29tbWFuZFttYW5wYWdlLXNlY3Rpb25dCisjCisjIE5vdGUsIHswfSBpcyB0aGUgbWFucGFnZSBzZWN0aW9uLCB3aGlsZSB7dGFyZ2V0fSBpcyB0aGUgY29tbWFuZC4KKyMKKyMgU2hvdyBQRVJGIGxpbmsgYXM6IDxjb21tYW5kPig8c2VjdGlvbj4pOyBpZiBzZWN0aW9uIGlzIGRlZmluZWQsIGVsc2UganVzdCBzaG93CisjIHRoZSBjb21tYW5kLgorCitbbWFjcm9zXQorKD9zdSlbXFxdPyg/UDxuYW1lPmxpbmtwZXJmKTooP1A8dGFyZ2V0PlxTKj8pXFsoP1A8YXR0cmxpc3Q+Lio/KVxdPQorCitbYXR0cmlidXRlc10KK2FzdGVyaXNrPSYjNDI7CitwbHVzPSYjNDM7CitjYXJldD0mIzk0Oworc3RhcnRzYj0mIzkxOworZW5kc2I9JiM5MzsKK3RpbGRlPSYjMTI2OworCitpZmRlZjo6YmFja2VuZC1kb2Nib29rW10KK1tsaW5rcGVyZi1pbmxpbmVtYWNyb10KK3swJXt0YXJnZXR9fQorezAjPGNpdGVyZWZlbnRyeT59Cit7MCM8cmVmZW50cnl0aXRsZT57dGFyZ2V0fTwvcmVmZW50cnl0aXRsZT48bWFudm9sbnVtPnswfTwvbWFudm9sbnVtPn0KK3swIzwvY2l0ZXJlZmVudHJ5Pn0KK2VuZGlmOjpiYWNrZW5kLWRvY2Jvb2tbXQorCitpZmRlZjo6YmFja2VuZC1kb2Nib29rW10KK2lmbmRlZjo6cGVyZi1hc2NpaWRvYy1uby1yb2ZmW10KKyMgInVuYnJlYWsiIGRvY2Jvb2steHNsIHYxLjY4IGZvciBtYW5wYWdlcy4gdjEuNjkgd29ya3Mgd2l0aCBvciB3aXRob3V0IHRoaXMuCisjIHYxLjcyIGJyZWFrcyB3aXRoIHRoaXMgYmVjYXVzZSBpdCByZXBsYWNlcyBkb3RzIG5vdCBpbiByb2ZmIHJlcXVlc3RzLgorW2xpc3RpbmdibG9ja10KKzxleGFtcGxlPjx0aXRsZT57dGl0bGV9PC90aXRsZT4KKzxsaXRlcmFsbGF5b3V0PgoraWZkZWY6OmRvY3R5cGUtbWFucGFnZVtdCismIzEwOy5mdCBDJiMxMDsKK2VuZGlmOjpkb2N0eXBlLW1hbnBhZ2VbXQorfAoraWZkZWY6OmRvY3R5cGUtbWFucGFnZVtdCismIzEwOy5mdCYjMTA7CitlbmRpZjo6ZG9jdHlwZS1tYW5wYWdlW10KKzwvbGl0ZXJhbGxheW91dD4KK3t0aXRsZSN9PC9leGFtcGxlPgorZW5kaWY6OnBlcmYtYXNjaWlkb2Mtbm8tcm9mZltdCisKK2lmZGVmOjpwZXJmLWFzY2lpZG9jLW5vLXJvZmZbXQoraWZkZWY6OmRvY3R5cGUtbWFucGFnZVtdCisjIFRoZSBmb2xsb3dpbmcgdHdvIHNtYWxsIHdvcmthcm91bmRzIGluc2VydCBhIHNpbXBsZSBwYXJhZ3JhcGggYWZ0ZXIgc2NyZWVuCitbbGlzdGluZ2Jsb2NrXQorPGV4YW1wbGU+PHRpdGxlPnt0aXRsZX08L3RpdGxlPgorPGxpdGVyYWxsYXlvdXQ+Cit8Cis8L2xpdGVyYWxsYXlvdXQ+PHNpbXBhcmE+PC9zaW1wYXJhPgore3RpdGxlI308L2V4YW1wbGU+CisKK1t2ZXJzZWJsb2NrXQorPGZvcm1hbHBhcmF7aWQ/IGlkPSJ7aWR9In0+PHRpdGxlPnt0aXRsZX08L3RpdGxlPjxwYXJhPgore3RpdGxlJX08bGl0ZXJhbGxheW91dHtpZD8gaWQ9IntpZH0ifT4KK3t0aXRsZSN9PGxpdGVyYWxsYXlvdXQ+Cit8Cis8L2xpdGVyYWxsYXlvdXQ+Cit7dGl0bGUjfTwvcGFyYT48L2Zvcm1hbHBhcmE+Cit7dGl0bGUlfTxzaW1wYXJhPjwvc2ltcGFyYT4KK2VuZGlmOjpkb2N0eXBlLW1hbnBhZ2VbXQorZW5kaWY6OnBlcmYtYXNjaWlkb2Mtbm8tcm9mZltdCitlbmRpZjo6YmFja2VuZC1kb2Nib29rW10KKworaWZkZWY6OmRvY3R5cGUtbWFucGFnZVtdCitpZmRlZjo6YmFja2VuZC1kb2Nib29rW10KK1toZWFkZXJdCit0ZW1wbGF0ZTo6W2hlYWRlci1kZWNsYXJhdGlvbnNdCis8cmVmZW50cnk+Cis8cmVmbWV0YT4KKzxyZWZlbnRyeXRpdGxlPnttYW50aXRsZX08L3JlZmVudHJ5dGl0bGU+Cis8bWFudm9sbnVtPnttYW52b2xudW19PC9tYW52b2xudW0+Cis8cmVmbWlzY2luZm8gY2xhc3M9InNvdXJjZSI+cGVyZjwvcmVmbWlzY2luZm8+Cis8cmVmbWlzY2luZm8gY2xhc3M9InZlcnNpb24iPntwZXJmX3ZlcnNpb259PC9yZWZtaXNjaW5mbz4KKzxyZWZtaXNjaW5mbyBjbGFzcz0ibWFudWFsIj5wZXJmIE1hbnVhbDwvcmVmbWlzY2luZm8+Cis8L3JlZm1ldGE+Cis8cmVmbmFtZWRpdj4KKyAgPHJlZm5hbWU+e21hbm5hbWV9PC9yZWZuYW1lPgorICA8cmVmcHVycG9zZT57bWFucHVycG9zZX08L3JlZnB1cnBvc2U+Cis8L3JlZm5hbWVkaXY+CitlbmRpZjo6YmFja2VuZC1kb2Nib29rW10KK2VuZGlmOjpkb2N0eXBlLW1hbnBhZ2VbXQorCitpZmRlZjo6YmFja2VuZC14aHRtbDExW10KK1tsaW5rcGVyZi1pbmxpbmVtYWNyb10KKzxhIGhyZWY9Int0YXJnZXR9Lmh0bWwiPnt0YXJnZXR9ezA/KHswfSl9PC9hPgorZW5kaWY6OmJhY2tlbmQteGh0bWwxMVtdCmRpZmYgLS1naXQgYS90b29scy9wZXJmL0RvY3VtZW50YXRpb24vbWFucGFnZS0xLjcyLnhzbCBiL3Rvb2xzL3BlcmYvRG9jdW1lbnRhdGlvbi9tYW5wYWdlLTEuNzIueHNsCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLmI0ZDMxNWMKLS0tIC9kZXYvbnVsbAorKysgYi90b29scy9wZXJmL0RvY3VtZW50YXRpb24vbWFucGFnZS0xLjcyLnhzbApAQCAtMCwwICsxLDE0IEBACis8IS0tIG1hbnBhZ2UtMS43Mi54c2w6CisgICAgIHNwZWNpYWwgc2V0dGluZ3MgZm9yIG1hbnBhZ2VzIHJlbmRlcmVkIGZyb20gYXNjaWlkb2MrZG9jYm9vaworICAgICBoYW5kbGVzIHBlY3VsaWFyaXRpZXMgaW4gZG9jYm9vay14c2wgMS43Mi4wIC0tPgorPHhzbDpzdHlsZXNoZWV0IHhtbG5zOnhzbD0iaHR0cDovL3d3dy53My5vcmcvMTk5OS9YU0wvVHJhbnNmb3JtIgorCQl2ZXJzaW9uPSIxLjAiPgorCis8eHNsOmltcG9ydCBocmVmPSJtYW5wYWdlLWJhc2UueHNsIi8+CisKKzwhLS0gdGhlc2UgYXJlIHRoZSBzcGVjaWFsIHZhbHVlcyBmb3IgdGhlIHJvZmYgY29udHJvbCBjaGFyYWN0ZXJzCisgICAgIG5lZWRlZCBmb3IgZG9jYm9vay14c2wgMS43Mi4wIC0tPgorPHhzbDpwYXJhbSBuYW1lPSJnaXQuZG9jYm9vay5iYWNrc2xhc2giPiYjeDI1OTM7PC94c2w6cGFyYW0+Cis8eHNsOnBhcmFtIG5hbWU9ImdpdC5kb2Nib29rLmRvdCIgICAgICA+JiN4MjMwMjs8L3hzbDpwYXJhbT4KKworPC94c2w6c3R5bGVzaGVldD4KZGlmZiAtLWdpdCBhL3Rvb2xzL3BlcmYvRG9jdW1lbnRhdGlvbi9tYW5wYWdlLWJhc2UueHNsIGIvdG9vbHMvcGVyZi9Eb2N1bWVudGF0aW9uL21hbnBhZ2UtYmFzZS54c2wKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uYTI2NGZhNjEKLS0tIC9kZXYvbnVsbAorKysgYi90b29scy9wZXJmL0RvY3VtZW50YXRpb24vbWFucGFnZS1iYXNlLnhzbApAQCAtMCwwICsxLDM1IEBACis8IS0tIG1hbnBhZ2UtYmFzZS54c2w6CisgICAgIHNwZWNpYWwgZm9ybWF0dGluZyBmb3IgbWFucGFnZXMgcmVuZGVyZWQgZnJvbSBhc2NpaWRvYytkb2Nib29rIC0tPgorPHhzbDpzdHlsZXNoZWV0IHhtbG5zOnhzbD0iaHR0cDovL3d3dy53My5vcmcvMTk5OS9YU0wvVHJhbnNmb3JtIgorCQl2ZXJzaW9uPSIxLjAiPgorCis8IS0tIHRoZXNlIHBhcmFtcyBzaWxlbmNlIHNvbWUgb3V0cHV0IGZyb20geG1sdG8gLS0+Cis8eHNsOnBhcmFtIG5hbWU9Im1hbi5vdXRwdXQucXVpZXRseSIgc2VsZWN0PSIxIi8+Cis8eHNsOnBhcmFtIG5hbWU9InJlZmVudHJ5Lm1ldGEuZ2V0LnF1aWV0bHkiIHNlbGVjdD0iMSIvPgorCis8IS0tIGNvbnZlcnQgYXNjaWlkb2MgY2FsbG91dHMgdG8gbWFuIHBhZ2UgZm9ybWF0OworICAgICBnaXQuZG9jYm9vay5iYWNrc2xhc2ggYW5kIGdpdC5kb2Nib29rLmRvdCBwYXJhbXMKKyAgICAgbXVzdCBiZSBzdXBwbGllZCBieSBhbm90aGVyIFhTTCBmaWxlIG9yIG90aGVyIG1lYW5zIC0tPgorPHhzbDp0ZW1wbGF0ZSBtYXRjaD0iY28iPgorCTx4c2w6dmFsdWUtb2Ygc2VsZWN0PSJjb25jYXQoCisJCQkgICAgICAkZ2l0LmRvY2Jvb2suYmFja3NsYXNoLCdmQignLAorCQkJICAgICAgc3Vic3RyaW5nLWFmdGVyKEBpZCwnLScpLCcpJywKKwkJCSAgICAgICRnaXQuZG9jYm9vay5iYWNrc2xhc2gsJ2ZSJykiLz4KKzwveHNsOnRlbXBsYXRlPgorPHhzbDp0ZW1wbGF0ZSBtYXRjaD0iY2FsbG91dGxpc3QiPgorCTx4c2w6dmFsdWUtb2Ygc2VsZWN0PSIkZ2l0LmRvY2Jvb2suZG90Ii8+CisJPHhzbDp0ZXh0PnNwJiMxMDs8L3hzbDp0ZXh0PgorCTx4c2w6YXBwbHktdGVtcGxhdGVzLz4KKwk8eHNsOnRleHQ+JiMxMDs8L3hzbDp0ZXh0PgorPC94c2w6dGVtcGxhdGU+Cis8eHNsOnRlbXBsYXRlIG1hdGNoPSJjYWxsb3V0Ij4KKwk8eHNsOnZhbHVlLW9mIHNlbGVjdD0iY29uY2F0KAorCQkJICAgICAgJGdpdC5kb2Nib29rLmJhY2tzbGFzaCwnZkInLAorCQkJICAgICAgc3Vic3RyaW5nLWFmdGVyKEBhcmVhcmVmcywnLScpLAorCQkJICAgICAgJy4gJywkZ2l0LmRvY2Jvb2suYmFja3NsYXNoLCdmUicpIi8+CisJPHhzbDphcHBseS10ZW1wbGF0ZXMvPgorCTx4c2w6dmFsdWUtb2Ygc2VsZWN0PSIkZ2l0LmRvY2Jvb2suZG90Ii8+CisJPHhzbDp0ZXh0PmJyJiMxMDs8L3hzbDp0ZXh0PgorPC94c2w6dGVtcGxhdGU+CisKKzwveHNsOnN0eWxlc2hlZXQ+CmRpZmYgLS1naXQgYS90b29scy9wZXJmL0RvY3VtZW50YXRpb24vbWFucGFnZS1ib2xkLWxpdGVyYWwueHNsIGIvdG9vbHMvcGVyZi9Eb2N1bWVudGF0aW9uL21hbnBhZ2UtYm9sZC1saXRlcmFsLnhzbApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi42MDhlYjVkCi0tLSAvZGV2L251bGwKKysrIGIvdG9vbHMvcGVyZi9Eb2N1bWVudGF0aW9uL21hbnBhZ2UtYm9sZC1saXRlcmFsLnhzbApAQCAtMCwwICsxLDE3IEBACis8IS0tIG1hbnBhZ2UtYm9sZC1saXRlcmFsLnhzbDoKKyAgICAgc3BlY2lhbCBmb3JtYXR0aW5nIGZvciBtYW5wYWdlcyByZW5kZXJlZCBmcm9tIGFzY2lpZG9jK2RvY2Jvb2sgLS0+Cis8eHNsOnN0eWxlc2hlZXQgeG1sbnM6eHNsPSJodHRwOi8vd3d3LnczLm9yZy8xOTk5L1hTTC9UcmFuc2Zvcm0iCisJCXZlcnNpb249IjEuMCI+CisKKzwhLS0gcmVuZGVyIGxpdGVyYWwgdGV4dCBhcyBib2xkIChpbnN0ZWFkIG9mIHBsYWluIG9yIG1vbm9zcGFjZSk7CisgICAgIHRoaXMgbWFrZXMgbGl0ZXJhbCB0ZXh0IGVhc2llciB0byBkaXN0aW5ndWlzaCBpbiBtYW5wYWdlcworICAgICB2aWV3ZWQgb24gYSB0dHkgLS0+Cis8eHNsOnRlbXBsYXRlIG1hdGNoPSJsaXRlcmFsIj4KKwk8eHNsOnZhbHVlLW9mIHNlbGVjdD0iJGdpdC5kb2Nib29rLmJhY2tzbGFzaCIvPgorCTx4c2w6dGV4dD5mQjwveHNsOnRleHQ+CisJPHhzbDphcHBseS10ZW1wbGF0ZXMvPgorCTx4c2w6dmFsdWUtb2Ygc2VsZWN0PSIkZ2l0LmRvY2Jvb2suYmFja3NsYXNoIi8+CisJPHhzbDp0ZXh0PmZSPC94c2w6dGV4dD4KKzwveHNsOnRlbXBsYXRlPgorCis8L3hzbDpzdHlsZXNoZWV0PgpkaWZmIC0tZ2l0IGEvdG9vbHMvcGVyZi9Eb2N1bWVudGF0aW9uL21hbnBhZ2Utbm9ybWFsLnhzbCBiL3Rvb2xzL3BlcmYvRG9jdW1lbnRhdGlvbi9tYW5wYWdlLW5vcm1hbC54c2wKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uYTQ4ZjViMQotLS0gL2Rldi9udWxsCisrKyBiL3Rvb2xzL3BlcmYvRG9jdW1lbnRhdGlvbi9tYW5wYWdlLW5vcm1hbC54c2wKQEAgLTAsMCArMSwxMyBAQAorPCEtLSBtYW5wYWdlLW5vcm1hbC54c2w6CisgICAgIHNwZWNpYWwgc2V0dGluZ3MgZm9yIG1hbnBhZ2VzIHJlbmRlcmVkIGZyb20gYXNjaWlkb2MrZG9jYm9vaworICAgICBoYW5kbGVzIGFueXRoaW5nIHdlIHdhbnQgdG8ga2VlcCBhd2F5IGZyb20gZG9jYm9vay14c2wgMS43Mi4wIC0tPgorPHhzbDpzdHlsZXNoZWV0IHhtbG5zOnhzbD0iaHR0cDovL3d3dy53My5vcmcvMTk5OS9YU0wvVHJhbnNmb3JtIgorCQl2ZXJzaW9uPSIxLjAiPgorCis8eHNsOmltcG9ydCBocmVmPSJtYW5wYWdlLWJhc2UueHNsIi8+CisKKzwhLS0gdGhlc2UgYXJlIHRoZSBub3JtYWwgdmFsdWVzIGZvciB0aGUgcm9mZiBjb250cm9sIGNoYXJhY3RlcnMgLS0+Cis8eHNsOnBhcmFtIG5hbWU9ImdpdC5kb2Nib29rLmJhY2tzbGFzaCI+XDwveHNsOnBhcmFtPgorPHhzbDpwYXJhbSBuYW1lPSJnaXQuZG9jYm9vay5kb3QiCT4uPC94c2w6cGFyYW0+CisKKzwveHNsOnN0eWxlc2hlZXQ+CmRpZmYgLS1naXQgYS90b29scy9wZXJmL0RvY3VtZW50YXRpb24vbWFucGFnZS1zdXBwcmVzcy1zcC54c2wgYi90b29scy9wZXJmL0RvY3VtZW50YXRpb24vbWFucGFnZS1zdXBwcmVzcy1zcC54c2wKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uYTYzYzc2MwotLS0gL2Rldi9udWxsCisrKyBiL3Rvb2xzL3BlcmYvRG9jdW1lbnRhdGlvbi9tYW5wYWdlLXN1cHByZXNzLXNwLnhzbApAQCAtMCwwICsxLDIxIEBACis8IS0tIG1hbnBhZ2Utc3VwcHJlc3Mtc3AueHNsOgorICAgICBzcGVjaWFsIHNldHRpbmdzIGZvciBtYW5wYWdlcyByZW5kZXJlZCBmcm9tIGFzY2lpZG9jK2RvY2Jvb2sKKyAgICAgaGFuZGxlcyBlcnJvbmVvdXMsIGlubGluZSAuc3AgaW4gbWFucGFnZSBvdXRwdXQgb2Ygc29tZQorICAgICB2ZXJzaW9ucyBvZiBkb2Nib29rLXhzbCAtLT4KKzx4c2w6c3R5bGVzaGVldCB4bWxuczp4c2w9Imh0dHA6Ly93d3cudzMub3JnLzE5OTkvWFNML1RyYW5zZm9ybSIKKwkJdmVyc2lvbj0iMS4wIj4KKworPCEtLSBhdHRlbXB0IHRvIHdvcmsgYXJvdW5kIHNwdXJpb3VzIC5zcCBhdCB0aGUgdGFpbCBvZiB0aGUgbGluZQorICAgICB0aGF0IHNvbWUgdmVyc2lvbnMgb2YgZG9jYm9vayBzdHlsZXNoZWV0cyBzZWVtIHRvIGFkZCAtLT4KKzx4c2w6dGVtcGxhdGUgbWF0Y2g9InNpbXBhcmEiPgorICA8eHNsOnZhcmlhYmxlIG5hbWU9ImNvbnRlbnQiPgorICAgIDx4c2w6YXBwbHktdGVtcGxhdGVzLz4KKyAgPC94c2w6dmFyaWFibGU+CisgIDx4c2w6dmFsdWUtb2Ygc2VsZWN0PSJub3JtYWxpemUtc3BhY2UoJGNvbnRlbnQpIi8+CisgIDx4c2w6aWYgdGVzdD0ibm90KGFuY2VzdG9yOjphdXRob3JibHVyYikgYW5kCisgICAgICAgICAgICAgICAgbm90KGFuY2VzdG9yOjpwZXJzb25ibHVyYikiPgorICAgIDx4c2w6dGV4dD4mIzEwOyYjMTA7PC94c2w6dGV4dD4KKyAgPC94c2w6aWY+Cis8L3hzbDp0ZW1wbGF0ZT4KKworPC94c2w6c3R5bGVzaGVldD4KZGlmZiAtLWdpdCBhL3Rvb2xzL3BlcmYvRG9jdW1lbnRhdGlvbi9wZXJmLWFubm90YXRlLnR4dCBiL3Rvb2xzL3BlcmYvRG9jdW1lbnRhdGlvbi9wZXJmLWFubm90YXRlLnR4dApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi5jOWRjYWRlCi0tLSAvZGV2L251bGwKKysrIGIvdG9vbHMvcGVyZi9Eb2N1bWVudGF0aW9uL3BlcmYtYW5ub3RhdGUudHh0CkBAIC0wLDAgKzEsMjkgQEAKK3BlcmYtYW5ub3RhdGUoMSkKKz09PT09PT09PT09PT09CisKK05BTUUKKy0tLS0KK3BlcmYtYW5ub3RhdGUgLSBSZWFkIHBlcmYuZGF0YSAoY3JlYXRlZCBieSBwZXJmIHJlY29yZCkgYW5kIGRpc3BsYXkgYW5ub3RhdGVkIGNvZGUKKworU1lOT1BTSVMKKy0tLS0tLS0tCitbdmVyc2VdCisncGVyZiBhbm5vdGF0ZScgWy1pIDxmaWxlPiB8IC0taW5wdXQ9ZmlsZV0gc3ltYm9sX25hbWUKKworREVTQ1JJUFRJT04KKy0tLS0tLS0tLS0tCitUaGlzIGNvbW1hbmQgcmVhZHMgdGhlIGlucHV0IGZpbGUgYW5kIGRpc3BsYXlzIGFuIGFubm90YXRlZCB2ZXJzaW9uIG9mIHRoZQorY29kZS4gSWYgdGhlIG9iamVjdCBmaWxlIGhhcyBkZWJ1ZyBzeW1ib2xzIHRoZW4gdGhlIHNvdXJjZSBjb2RlIHdpbGwgYmUKK2Rpc3BsYXllZCBhbG9uZ3NpZGUgYXNzZW1ibHkgY29kZS4KKworSWYgdGhlcmUgaXMgbm8gZGVidWcgaW5mbyBpbiB0aGUgb2JqZWN0LCB0aGVuIGFubm90YXRlZCBhc3NlbWJseSBpcyBkaXNwbGF5ZWQuCisKK09QVElPTlMKKy0tLS0tLS0KKy1pOjoKKy0taW5wdXQ9OjoKKyAgICAgICAgSW5wdXQgZmlsZSBuYW1lLiAoZGVmYXVsdDogcGVyZi5kYXRhKQorCitTRUUgQUxTTworLS0tLS0tLS0KK2xpbmtwZXJmOnBlcmYtcmVjb3JkWzFdCmRpZmYgLS1naXQgYS90b29scy9wZXJmL0RvY3VtZW50YXRpb24vcGVyZi1oZWxwLnR4dCBiL3Rvb2xzL3BlcmYvRG9jdW1lbnRhdGlvbi9wZXJmLWhlbHAudHh0Cm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjUxNDM5MTgKLS0tIC9kZXYvbnVsbAorKysgYi90b29scy9wZXJmL0RvY3VtZW50YXRpb24vcGVyZi1oZWxwLnR4dApAQCAtMCwwICsxLDM4IEBACitwZXJmLWhlbHAoMSkKKz09PT09PT09PT09PQorCitOQU1FCistLS0tCitwZXJmLWhlbHAgLSBkaXNwbGF5IGhlbHAgaW5mb3JtYXRpb24gYWJvdXQgcGVyZgorCitTWU5PUFNJUworLS0tLS0tLS0KKydwZXJmIGhlbHAnIFstYXwtLWFsbF0gW0NPTU1BTkRdCisKK0RFU0NSSVBUSU9OCistLS0tLS0tLS0tLQorCitXaXRoIG5vIG9wdGlvbnMgYW5kIG5vIENPTU1BTkQgZ2l2ZW4sIHRoZSBzeW5vcHNpcyBvZiB0aGUgJ3BlcmYnCitjb21tYW5kIGFuZCBhIGxpc3Qgb2YgdGhlIG1vc3QgY29tbW9ubHkgdXNlZCBwZXJmIGNvbW1hbmRzIGFyZSBwcmludGVkCitvbiB0aGUgc3RhbmRhcmQgb3V0cHV0LgorCitJZiB0aGUgb3B0aW9uICctLWFsbCcgb3IgJy1hJyBpcyBnaXZlbiwgdGhlbiBhbGwgYXZhaWxhYmxlIGNvbW1hbmRzIGFyZQorcHJpbnRlZCBvbiB0aGUgc3RhbmRhcmQgb3V0cHV0LgorCitJZiBhIHBlcmYgY29tbWFuZCBpcyBuYW1lZCwgYSBtYW51YWwgcGFnZSBmb3IgdGhhdCBjb21tYW5kIGlzIGJyb3VnaHQKK3VwLiBUaGUgJ21hbicgcHJvZ3JhbSBpcyB1c2VkIGJ5IGRlZmF1bHQgZm9yIHRoaXMgcHVycG9zZSwgYnV0IHRoaXMKK2NhbiBiZSBvdmVycmlkZGVuIGJ5IG90aGVyIG9wdGlvbnMgb3IgY29uZmlndXJhdGlvbiB2YXJpYWJsZXMuCisKK05vdGUgdGhhdCBgcGVyZiAtLWhlbHAgLi4uYCBpcyBpZGVudGljYWwgdG8gYHBlcmYgaGVscCAuLi5gIGJlY2F1c2UgdGhlCitmb3JtZXIgaXMgaW50ZXJuYWxseSBjb252ZXJ0ZWQgaW50byB0aGUgbGF0dGVyLgorCitPUFRJT05TCistLS0tLS0tCistYTo6CistLWFsbDo6CisJUHJpbnRzIGFsbCB0aGUgYXZhaWxhYmxlIGNvbW1hbmRzIG9uIHRoZSBzdGFuZGFyZCBvdXRwdXQuIFRoaXMKKwlvcHRpb24gc3VwZXJzZWRlcyBhbnkgb3RoZXIgb3B0aW9uLgorCitQRVJGCistLS0tCitQYXJ0IG9mIHRoZSBsaW5rcGVyZjpwZXJmWzFdIHN1aXRlCmRpZmYgLS1naXQgYS90b29scy9wZXJmL0RvY3VtZW50YXRpb24vcGVyZi1saXN0LnR4dCBiL3Rvb2xzL3BlcmYvRG9jdW1lbnRhdGlvbi9wZXJmLWxpc3QudHh0Cm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjgyOTBiOTQKLS0tIC9kZXYvbnVsbAorKysgYi90b29scy9wZXJmL0RvY3VtZW50YXRpb24vcGVyZi1saXN0LnR4dApAQCAtMCwwICsxLDI1IEBACitwZXJmLWxpc3QoMSkKKz09PT09PT09PT09PQorCitOQU1FCistLS0tCitwZXJmLWxpc3QgLSBMaXN0IGFsbCBzeW1ib2xpYyBldmVudCB0eXBlcworCitTWU5PUFNJUworLS0tLS0tLS0KK1t2ZXJzZV0KKydwZXJmIGxpc3QnCisKK0RFU0NSSVBUSU9OCistLS0tLS0tLS0tLQorVGhpcyBjb21tYW5kIGRpc3BsYXlzIHRoZSBzeW1ib2xpYyBldmVudCB0eXBlcyB3aGljaCBjYW4gYmUgc2VsZWN0ZWQgaW4gdGhlCit2YXJpb3VzIHBlcmYgY29tbWFuZHMgd2l0aCB0aGUgLWUgb3B0aW9uLgorCitPUFRJT05TCistLS0tLS0tCitOb25lCisKK1NFRSBBTFNPCistLS0tLS0tLQorbGlua3BlcmY6cGVyZi1zdGF0WzFdLCBsaW5rcGVyZjpwZXJmLXRvcFsxXSwKK2xpbmtwZXJmOnBlcmYtcmVjb3JkWzFdCmRpZmYgLS1naXQgYS90b29scy9wZXJmL0RvY3VtZW50YXRpb24vcGVyZi1yZWNvcmQudHh0IGIvdG9vbHMvcGVyZi9Eb2N1bWVudGF0aW9uL3BlcmYtcmVjb3JkLnR4dApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi4xZGJjMWVlCi0tLSAvZGV2L251bGwKKysrIGIvdG9vbHMvcGVyZi9Eb2N1bWVudGF0aW9uL3BlcmYtcmVjb3JkLnR4dApAQCAtMCwwICsxLDQyIEBACitwZXJmLXJlY29yZCgxKQorPT09PT09PT09PT09PT0KKworTkFNRQorLS0tLQorcGVyZi1yZWNvcmQgLSBSdW4gYSBjb21tYW5kIGFuZCByZWNvcmQgaXRzIHByb2ZpbGUgaW50byBwZXJmLmRhdGEKKworU1lOT1BTSVMKKy0tLS0tLS0tCitbdmVyc2VdCisncGVyZiByZWNvcmQnIFstZSA8RVZFTlQ+IHwgLS1ldmVudD1FVkVOVF0gWy1sXSBbLWFdIDxjb21tYW5kPgorJ3BlcmYgcmVjb3JkJyBbLWUgPEVWRU5UPiB8IC0tZXZlbnQ9RVZFTlRdIFstbF0gWy1hXSAtLSA8Y29tbWFuZD4gWzxvcHRpb25zPl0KKworREVTQ1JJUFRJT04KKy0tLS0tLS0tLS0tCitUaGlzIGNvbW1hbmQgcnVucyBhIGNvbW1hbmQgYW5kIGdhdGhlcnMgYSBwZXJmb3JtYW5jZSBjb3VudGVyIHByb2ZpbGUKK2Zyb20gaXQsIGludG8gcGVyZi5kYXRhIC0gd2l0aG91dCBkaXNwbGF5aW5nIGFueXRoaW5nLgorCitUaGlzIGZpbGUgY2FuIHRoZW4gYmUgaW5zcGVjdGVkIGxhdGVyIG9uLCB1c2luZyAncGVyZiByZXBvcnQnLgorCisKK09QVElPTlMKKy0tLS0tLS0KKzxjb21tYW5kPi4uLjo6CisJQW55IGNvbW1hbmQgeW91IGNhbiBzcGVjaWZ5IGluIGEgc2hlbGwuCisKKy1lOjoKKy0tZXZlbnQ9OjoKKwlTZWxlY3QgdGhlIFBNVSBldmVudC4gU2VsZWN0aW9uIGNhbiBiZSBhIHN5bWJvbGljIGV2ZW50IG5hbWUKKwkodXNlICdwZXJmIGxpc3QnIHRvIGxpc3QgYWxsIGV2ZW50cykgb3IgYSByYXcgUE1VCisJZXZlbnQgKGV2ZW50c2VsK3VtYXNrKSBpbiB0aGUgZm9ybSBvZiByTk5OIHdoZXJlIE5OTiBpcyBhCisJIGhleGFkZWNpbWFsIGV2ZW50IGRlc2NyaXB0b3IuCisKKy1hOjoKKyAgICAgICAgc3lzdGVtLXdpZGUgY29sbGVjdGlvbgorCistbDo6CisgICAgICAgIHNjYWxlIGNvdW50ZXIgdmFsdWVzCisKK1NFRSBBTFNPCistLS0tLS0tLQorbGlua3BlcmY6cGVyZi1zdGF0WzFdLCBsaW5rcGVyZjpwZXJmLWxpc3RbMV0KZGlmZiAtLWdpdCBhL3Rvb2xzL3BlcmYvRG9jdW1lbnRhdGlvbi9wZXJmLXJlcG9ydC50eHQgYi90b29scy9wZXJmL0RvY3VtZW50YXRpb24vcGVyZi1yZXBvcnQudHh0Cm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjUyZDNmYzYKLS0tIC9kZXYvbnVsbAorKysgYi90b29scy9wZXJmL0RvY3VtZW50YXRpb24vcGVyZi1yZXBvcnQudHh0CkBAIC0wLDAgKzEsMjYgQEAKK3BlcmYtcmVwb3J0KDEpCis9PT09PT09PT09PT09PQorCitOQU1FCistLS0tCitwZXJmLXJlcG9ydCAtIFJlYWQgcGVyZi5kYXRhIChjcmVhdGVkIGJ5IHBlcmYgcmVjb3JkKSBhbmQgZGlzcGxheSB0aGUgcHJvZmlsZQorCitTWU5PUFNJUworLS0tLS0tLS0KK1t2ZXJzZV0KKydwZXJmIHJlcG9ydCcgWy1pIDxmaWxlPiB8IC0taW5wdXQ9ZmlsZV0KKworREVTQ1JJUFRJT04KKy0tLS0tLS0tLS0tCitUaGlzIGNvbW1hbmQgZGlzcGxheXMgdGhlIHBlcmZvcm1hbmNlIGNvdW50ZXIgcHJvZmlsZSBpbmZvcm1hdGlvbiByZWNvcmRlZAordmlhIHBlcmYgcmVwb3J0LgorCitPUFRJT05TCistLS0tLS0tCistaTo6CistLWlucHV0PTo6CisgICAgICAgIElucHV0IGZpbGUgbmFtZS4gKGRlZmF1bHQ6IHBlcmYuZGF0YSkKKworU0VFIEFMU08KKy0tLS0tLS0tCitsaW5rcGVyZjpwZXJmLXN0YXRbMV0KZGlmZiAtLWdpdCBhL3Rvb2xzL3BlcmYvRG9jdW1lbnRhdGlvbi9wZXJmLXN0YXQudHh0IGIvdG9vbHMvcGVyZi9Eb2N1bWVudGF0aW9uL3BlcmYtc3RhdC50eHQKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uYzM2OGE3MgotLS0gL2Rldi9udWxsCisrKyBiL3Rvb2xzL3BlcmYvRG9jdW1lbnRhdGlvbi9wZXJmLXN0YXQudHh0CkBAIC0wLDAgKzEsNjYgQEAKK3BlcmYtc3RhdCgxKQorPT09PT09PT09PT09CisKK05BTUUKKy0tLS0KK3BlcmYtc3RhdCAtIFJ1biBhIGNvbW1hbmQgYW5kIGdhdGhlciBwZXJmb3JtYW5jZSBjb3VudGVyIHN0YXRpc3RpY3MKKworU1lOT1BTSVMKKy0tLS0tLS0tCitbdmVyc2VdCisncGVyZiBzdGF0JyBbLWUgPEVWRU5UPiB8IC0tZXZlbnQ9RVZFTlRdIFstbF0gWy1hXSA8Y29tbWFuZD4KKydwZXJmIHN0YXQnIFstZSA8RVZFTlQ+IHwgLS1ldmVudD1FVkVOVF0gWy1sXSBbLWFdIC0tIDxjb21tYW5kPiBbPG9wdGlvbnM+XQorCitERVNDUklQVElPTgorLS0tLS0tLS0tLS0KK1RoaXMgY29tbWFuZCBydW5zIGEgY29tbWFuZCBhbmQgZ2F0aGVycyBwZXJmb3JtYW5jZSBjb3VudGVyIHN0YXRpc3RpY3MKK2Zyb20gaXQuCisKKworT1BUSU9OUworLS0tLS0tLQorPGNvbW1hbmQ+Li4uOjoKKwlBbnkgY29tbWFuZCB5b3UgY2FuIHNwZWNpZnkgaW4gYSBzaGVsbC4KKworCistZTo6CistLWV2ZW50PTo6CisJU2VsZWN0IHRoZSBQTVUgZXZlbnQuIFNlbGVjdGlvbiBjYW4gYmUgYSBzeW1ib2xpYyBldmVudCBuYW1lCisJKHVzZSAncGVyZiBsaXN0JyB0byBsaXN0IGFsbCBldmVudHMpIG9yIGEgcmF3IFBNVQorCWV2ZW50IChldmVudHNlbCt1bWFzaykgaW4gdGhlIGZvcm0gb2Ygck5OTiB3aGVyZSBOTk4gaXMgYQorCSBoZXhhZGVjaW1hbCBldmVudCBkZXNjcmlwdG9yLgorCistaTo6CistLWluaGVyaXQ6OgorICAgICAgICBjaGlsZCB0YXNrcyBpbmhlcml0IGNvdW50ZXJzCistcDo6CistLXBpZD08cGlkPjo6CisgICAgICAgIHN0YXQgZXZlbnRzIG9uIGV4aXN0aW5nIHBpZAorCistYTo6CisgICAgICAgIHN5c3RlbS13aWRlIGNvbGxlY3Rpb24KKworLWw6OgorICAgICAgICBzY2FsZSBjb3VudGVyIHZhbHVlcworCitFWEFNUExFUworLS0tLS0tLS0KKworJCBwZXJmIHN0YXQgLS0gbWFrZSAtagorCisgUGVyZm9ybWFuY2UgY291bnRlciBzdGF0cyBmb3IgJ21ha2UgLWonOgorCisgICAgODExNy4zNzAyNTYgIHRhc2sgY2xvY2sgdGlja3MgICAgICMgICAgICAxMS4yODEgQ1BVIHV0aWxpemF0aW9uIGZhY3RvcgorICAgICAgICAgICAgNjc4ICBjb250ZXh0IHN3aXRjaGVzICAgICAjICAgICAgIDAuMDAwIE0vc2VjCisgICAgICAgICAgICAxMzMgIENQVSBtaWdyYXRpb25zICAgICAgICMgICAgICAgMC4wMDAgTS9zZWMKKyAgICAgICAgIDIzNTcyNCAgcGFnZWZhdWx0cyAgICAgICAgICAgIyAgICAgICAwLjAyOSBNL3NlYworICAgIDI0ODIxMTYyNTI2ICBDUFUgY3ljbGVzICAgICAgICAgICAjICAgIDMwNTcuNzg0IE0vc2VjCisgICAgMTg2ODczMDM0NTcgIGluc3RydWN0aW9ucyAgICAgICAgICMgICAgMjMwMi4xMzggTS9zZWMKKyAgICAgIDE3MjE1ODg5NSAgY2FjaGUgcmVmZXJlbmNlcyAgICAgIyAgICAgIDIxLjIwOSBNL3NlYworICAgICAgIDI3MDc1MjU5ICBjYWNoZSBtaXNzZXMgICAgICAgICAjICAgICAgIDMuMzM1IE0vc2VjCisKKyBXYWxsLWNsb2NrIHRpbWUgZWxhcHNlZDogICA3MTkuNTU0MzUyIG1zZWNzCisKK1NFRSBBTFNPCistLS0tLS0tLQorbGlua3BlcmY6cGVyZi10b3BbMV0sIGxpbmtwZXJmOnBlcmYtbGlzdFsxXQpkaWZmIC0tZ2l0IGEvdG9vbHMvcGVyZi9Eb2N1bWVudGF0aW9uL3BlcmYtdG9wLnR4dCBiL3Rvb2xzL3BlcmYvRG9jdW1lbnRhdGlvbi9wZXJmLXRvcC50eHQKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uNTM5ZDAxMgotLS0gL2Rldi9udWxsCisrKyBiL3Rvb2xzL3BlcmYvRG9jdW1lbnRhdGlvbi9wZXJmLXRvcC50eHQKQEAgLTAsMCArMSwzOSBAQAorcGVyZi10b3AoMSkKKz09PT09PT09PT09CisKK05BTUUKKy0tLS0KK3BlcmYtdG9wIC0gUnVuIGEgY29tbWFuZCBhbmQgcHJvZmlsZSBpdAorCitTWU5PUFNJUworLS0tLS0tLS0KK1t2ZXJzZV0KKydwZXJmIHRvcCcgWy1lIDxFVkVOVD4gfCAtLWV2ZW50PUVWRU5UXSBbLWxdIFstYV0gPGNvbW1hbmQ+CisKK0RFU0NSSVBUSU9OCistLS0tLS0tLS0tLQorVGhpcyBjb21tYW5kIHJ1bnMgYSBjb21tYW5kIGFuZCBnYXRoZXJzIGEgcGVyZm9ybWFuY2UgY291bnRlciBwcm9maWxlCitmcm9tIGl0LgorCisKK09QVElPTlMKKy0tLS0tLS0KKzxjb21tYW5kPi4uLjo6CisJQW55IGNvbW1hbmQgeW91IGNhbiBzcGVjaWZ5IGluIGEgc2hlbGwuCisKKy1lOjoKKy0tZXZlbnQ9OjoKKwlTZWxlY3QgdGhlIFBNVSBldmVudC4gU2VsZWN0aW9uIGNhbiBiZSBhIHN5bWJvbGljIGV2ZW50IG5hbWUKKwkodXNlICdwZXJmIGxpc3QnIHRvIGxpc3QgYWxsIGV2ZW50cykgb3IgYSByYXcgUE1VCisJZXZlbnQgKGV2ZW50c2VsK3VtYXNrKSBpbiB0aGUgZm9ybSBvZiByTk5OIHdoZXJlIE5OTiBpcyBhCisJIGhleGFkZWNpbWFsIGV2ZW50IGRlc2NyaXB0b3IuCisKKy1hOjoKKyAgICAgICAgc3lzdGVtLXdpZGUgY29sbGVjdGlvbgorCistbDo6CisgICAgICAgIHNjYWxlIGNvdW50ZXIgdmFsdWVzCisKK1NFRSBBTFNPCistLS0tLS0tLQorbGlua3BlcmY6cGVyZi1zdGF0WzFdLCBsaW5rcGVyZjpwZXJmLWxpc3RbMV0KZGlmZiAtLWdpdCBhL3Rvb2xzL3BlcmYvRG9jdW1lbnRhdGlvbi9wZXJmLnR4dCBiL3Rvb2xzL3BlcmYvRG9jdW1lbnRhdGlvbi9wZXJmLnR4dApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi42OWM4MzI1Ci0tLSAvZGV2L251bGwKKysrIGIvdG9vbHMvcGVyZi9Eb2N1bWVudGF0aW9uL3BlcmYudHh0CkBAIC0wLDAgKzEsMjQgQEAKK3BlcmYoMSkKKz09PT09PT0KKworTkFNRQorLS0tLQorcGVyZiAtIFBlcmZvcm1hbmNlIGFuYWx5c2lzIHRvb2xzIGZvciBMaW51eAorCitTWU5PUFNJUworLS0tLS0tLS0KK1t2ZXJzZV0KKydwZXJmJyBbLS12ZXJzaW9uXSBbLS1oZWxwXSBDT01NQU5EIFtBUkdTXQorCitERVNDUklQVElPTgorLS0tLS0tLS0tLS0KK1BlcmZvcm1hbmNlIGNvdW50ZXJzIGZvciBMaW51eCBhcmUgYXJlIGEgbmV3IGtlcm5lbC1iYXNlZCBzdWJzeXN0ZW0KK3RoYXQgcHJvdmlkZSBhIGZyYW1ld29yayBmb3IgYWxsIHRoaW5ncyBwZXJmb3JtYW5jZSBhbmFseXNpcy4gSXQKK2NvdmVycyBoYXJkd2FyZSBsZXZlbCAoQ1BVL1BNVSwgUGVyZm9ybWFuY2UgTW9uaXRvcmluZyBVbml0KSBmZWF0dXJlcworYW5kIHNvZnR3YXJlIGZlYXR1cmVzIChzb2Z0d2FyZSBjb3VudGVycywgdHJhY2Vwb2ludHMpIGFzIHdlbGwuCisKK1NFRSBBTFNPCistLS0tLS0tLQorbGlua3BlcmY6cGVyZi1zdGF0WzFdLCBsaW5rcGVyZjpwZXJmLXRvcFsxXSwKK2xpbmtwZXJmOnBlcmYtcmVjb3JkWzFdLCBsaW5rcGVyZjpwZXJmLXJlcG9ydFsxXSwKK2xpbmtwZXJmOnBlcmYtbGlzdFsxXQpkaWZmIC0tZ2l0IGEvdG9vbHMvcGVyZi9NYWtlZmlsZSBiL3Rvb2xzL3BlcmYvTWFrZWZpbGUKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uMGNiZDVkNgotLS0gL2Rldi9udWxsCisrKyBiL3Rvb2xzL3BlcmYvTWFrZWZpbGUKQEAgLTAsMCArMSw5MjkgQEAKKyMgVGhlIGRlZmF1bHQgdGFyZ2V0IG9mIHRoaXMgTWFrZWZpbGUgaXMuLi4KK2FsbDo6CisKKyMgRGVmaW5lIFY9MSB0byBoYXZlIGEgbW9yZSB2ZXJib3NlIGNvbXBpbGUuCisjCisjIERlZmluZSBTTlBSSU5URl9SRVRVUk5TX0JPR1VTIGlmIHlvdXIgYXJlIG9uIGEgc3lzdGVtIHdoaWNoIHNucHJpbnRmKCkKKyMgb3IgdnNucHJpbnRmKCkgcmV0dXJuIC0xIGluc3RlYWQgb2YgbnVtYmVyIG9mIGNoYXJhY3RlcnMgd2hpY2ggd291bGQKKyMgaGF2ZSBiZWVuIHdyaXR0ZW4gdG8gdGhlIGZpbmFsIHN0cmluZyBpZiBlbm91Z2ggc3BhY2UgaGFkIGJlZW4gYXZhaWxhYmxlLgorIworIyBEZWZpbmUgRlJFQURfUkVBRFNfRElSRUNUT1JJRVMgaWYgeW91ciBhcmUgb24gYSBzeXN0ZW0gd2hpY2ggc3VjY2VlZHMKKyMgd2hlbiBhdHRlbXB0aW5nIHRvIHJlYWQgZnJvbSBhbiBmb3BlbidlZCBkaXJlY3RvcnkuCisjCisjIERlZmluZSBOT19PUEVOU1NMIGVudmlyb25tZW50IHZhcmlhYmxlIGlmIHlvdSBkbyBub3QgaGF2ZSBPcGVuU1NMLgorIyBUaGlzIGFsc28gaW1wbGllcyBNT1pJTExBX1NIQTEuCisjCisjIERlZmluZSBDVVJMRElSPS9mb28vYmFyIGlmIHlvdXIgY3VybCBoZWFkZXIgYW5kIGxpYnJhcnkgZmlsZXMgYXJlIGluCisjIC9mb28vYmFyL2luY2x1ZGUgYW5kIC9mb28vYmFyL2xpYiBkaXJlY3Rvcmllcy4KKyMKKyMgRGVmaW5lIEVYUEFURElSPS9mb28vYmFyIGlmIHlvdXIgZXhwYXQgaGVhZGVyIGFuZCBsaWJyYXJ5IGZpbGVzIGFyZSBpbgorIyAvZm9vL2Jhci9pbmNsdWRlIGFuZCAvZm9vL2Jhci9saWIgZGlyZWN0b3JpZXMuCisjCisjIERlZmluZSBOT19EX0lOT19JTl9ESVJFTlQgaWYgeW91IGRvbid0IGhhdmUgZF9pbm8gaW4geW91ciBzdHJ1Y3QgZGlyZW50LgorIworIyBEZWZpbmUgTk9fRF9UWVBFX0lOX0RJUkVOVCBpZiB5b3VyIHBsYXRmb3JtIGRlZmluZXMgRFRfVU5LTk9XTiBidXQgbGFja3MKKyMgZF90eXBlIGluIHN0cnVjdCBkaXJlbnQgKGxhdGVzdCBDeWd3aW4gLS0gd2lsbCBiZSBmaXhlZCBzb29uaXNoKS4KKyMKKyMgRGVmaW5lIE5PX0M5OV9GT1JNQVQgaWYgeW91ciBmb3JtYXR0ZWQgSU8gZnVuY3Rpb25zIChwcmludGYvc2NhbmYgZXQuYWwuKQorIyBkbyBub3Qgc3VwcG9ydCB0aGUgJ3NpemUgc3BlY2lmaWVycycgaW50cm9kdWNlZCBieSBDOTksIG5hbWVseSBsbCwgaGgsCisjIGosIHosIHQuIChyZXByZXNlbnRpbmcgbG9uZyBsb25nIGludCwgY2hhciwgaW50bWF4X3QsIHNpemVfdCwgcHRyZGlmZl90KS4KKyMgc29tZSBDIGNvbXBpbGVycyBzdXBwb3J0ZWQgdGhlc2Ugc3BlY2lmaWVycyBwcmlvciB0byBDOTkgYXMgYW4gZXh0ZW5zaW9uLgorIworIyBEZWZpbmUgTk9fU1RSQ0FTRVNUUiBpZiB5b3UgZG9uJ3QgaGF2ZSBzdHJjYXNlc3RyLgorIworIyBEZWZpbmUgTk9fTUVNTUVNIGlmIHlvdSBkb24ndCBoYXZlIG1lbW1lbS4KKyMKKyMgRGVmaW5lIE5PX1NUUlRPVU1BWCBpZiB5b3UgZG9uJ3QgaGF2ZSBzdHJ0b3VtYXggaW4gdGhlIEMgbGlicmFyeS4KKyMgSWYgeW91ciBjb21waWxlciBhbHNvIGRvZXMgbm90IHN1cHBvcnQgbG9uZyBsb25nIG9yIGRvZXMgbm90IGhhdmUKKyMgc3RydG91bGwsIGRlZmluZSBOT19TVFJUT1VMTC4KKyMKKyMgRGVmaW5lIE5PX1NFVEVOViBpZiB5b3UgZG9uJ3QgaGF2ZSBzZXRlbnYgaW4gdGhlIEMgbGlicmFyeS4KKyMKKyMgRGVmaW5lIE5PX1VOU0VURU5WIGlmIHlvdSBkb24ndCBoYXZlIHVuc2V0ZW52IGluIHRoZSBDIGxpYnJhcnkuCisjCisjIERlZmluZSBOT19NS0RURU1QIGlmIHlvdSBkb24ndCBoYXZlIG1rZHRlbXAgaW4gdGhlIEMgbGlicmFyeS4KKyMKKyMgRGVmaW5lIE5PX1NZU19TRUxFQ1RfSCBpZiB5b3UgZG9uJ3QgaGF2ZSBzeXMvc2VsZWN0LmguCisjCisjIERlZmluZSBOT19TWU1MSU5LX0hFQUQgaWYgeW91IG5ldmVyIHdhbnQgLnBlcmYvSEVBRCB0byBiZSBhIHN5bWJvbGljIGxpbmsuCisjIEVuYWJsZSBpdCBvbiBXaW5kb3dzLiAgQnkgZGVmYXVsdCwgc3ltcmVmcyBhcmUgc3RpbGwgdXNlZC4KKyMKKyMgRGVmaW5lIE5PX1NWTl9URVNUUyBpZiB5b3Ugd2FudCB0byBza2lwIHRpbWUtY29uc3VtaW5nIFNWTiBpbnRlcm9wZXJhYmlsaXR5CisjIHRlc3RzLiAgVGhlc2UgdGVzdHMgdGFrZSB1cCBhIHNpZ25pZmljYW50IGFtb3VudCBvZiB0aGUgdG90YWwgdGVzdCB0aW1lCisjIGJ1dCBhcmUgbm90IG5lZWRlZCB1bmxlc3MgeW91IHBsYW4gdG8gdGFsayB0byBTVk4gcmVwb3MuCisjCisjIERlZmluZSBOT19GSU5LIGlmIHlvdSBhcmUgYnVpbGRpbmcgb24gRGFyd2luL01hYyBPUyBYLCBoYXZlIEZpbmsKKyMgaW5zdGFsbGVkIGluIC9zdywgYnV0IGRvbid0IHdhbnQgUEVSRiB0byBsaW5rIGFnYWluc3QgYW55IGxpYnJhcmllcworIyBpbnN0YWxsZWQgdGhlcmUuICBJZiBkZWZpbmVkIHlvdSBtYXkgc3BlY2lmeSB5b3VyIG93biAob3IgRmluaydzKQorIyBpbmNsdWRlIGRpcmVjdG9yaWVzIGFuZCBsaWJyYXJ5IGRpcmVjdG9yaWVzIGJ5IGRlZmluaW5nIENGTEFHUworIyBhbmQgTERGTEFHUyBhcHByb3ByaWF0ZWx5LgorIworIyBEZWZpbmUgTk9fREFSV0lOX1BPUlRTIGlmIHlvdSBhcmUgYnVpbGRpbmcgb24gRGFyd2luL01hYyBPUyBYLAorIyBoYXZlIERhcndpblBvcnRzIGluc3RhbGxlZCBpbiAvb3B0L2xvY2FsLCBidXQgZG9uJ3Qgd2FudCBQRVJGIHRvCisjIGxpbmsgYWdhaW5zdCBhbnkgbGlicmFyaWVzIGluc3RhbGxlZCB0aGVyZS4gIElmIGRlZmluZWQgeW91IG1heQorIyBzcGVjaWZ5IHlvdXIgb3duIChvciBEYXJ3aW5Qb3J0J3MpIGluY2x1ZGUgZGlyZWN0b3JpZXMgYW5kCisjIGxpYnJhcnkgZGlyZWN0b3JpZXMgYnkgZGVmaW5pbmcgQ0ZMQUdTIGFuZCBMREZMQUdTIGFwcHJvcHJpYXRlbHkuCisjCisjIERlZmluZSBQUENfU0hBMSBlbnZpcm9ubWVudCB2YXJpYWJsZSB3aGVuIHJ1bm5pbmcgbWFrZSB0byBtYWtlIHVzZSBvZgorIyBhIGJ1bmRsZWQgU0hBMSByb3V0aW5lIG9wdGltaXplZCBmb3IgUG93ZXJQQy4KKyMKKyMgRGVmaW5lIEFSTV9TSEExIGVudmlyb25tZW50IHZhcmlhYmxlIHdoZW4gcnVubmluZyBtYWtlIHRvIG1ha2UgdXNlIG9mCisjIGEgYnVuZGxlZCBTSEExIHJvdXRpbmUgb3B0aW1pemVkIGZvciBBUk0uCisjCisjIERlZmluZSBNT1pJTExBX1NIQTEgZW52aXJvbm1lbnQgdmFyaWFibGUgd2hlbiBydW5uaW5nIG1ha2UgdG8gbWFrZSB1c2Ugb2YKKyMgYSBidW5kbGVkIFNIQTEgcm91dGluZSBjb21pbmcgZnJvbSBNb3ppbGxhLiBJdCBpcyBHUEwnZCBhbmQgc2hvdWxkIGJlIGZhc3QKKyMgb24gbm9uLXg4NiBhcmNoaXRlY3R1cmVzIChlLmcuIFBvd2VyUEMpLCB3aGlsZSB0aGUgT3BlblNTTCB2ZXJzaW9uIChkZWZhdWx0CisjIGNob2ljZSkgaGFzIHZlcnkgZmFzdCB2ZXJzaW9uIG9wdGltaXplZCBmb3IgaTU4Ni4KKyMKKyMgRGVmaW5lIE5FRURTX1NTTF9XSVRIX0NSWVBUTyBpZiB5b3UgbmVlZCAtbGNyeXB0byB3aXRoIC1sc3NsIChEYXJ3aW4pLgorIworIyBEZWZpbmUgTkVFRFNfTElCSUNPTlYgaWYgbGlua2luZyB3aXRoIGxpYmMgaXMgbm90IGVub3VnaCAoRGFyd2luKS4KKyMKKyMgRGVmaW5lIE5FRURTX1NPQ0tFVCBpZiBsaW5raW5nIHdpdGggbGliYyBpcyBub3QgZW5vdWdoIChTdW5PUywKKyMgUGF0cmljayBNYXVyaXR6KS4KKyMKKyMgRGVmaW5lIE5PX01NQVAgaWYgeW91IHdhbnQgdG8gYXZvaWQgbW1hcC4KKyMKKyMgRGVmaW5lIE5PX1BUSFJFQURTIGlmIHlvdSBkbyBub3QgaGF2ZSBvciBkbyBub3Qgd2FudCB0byB1c2UgUHRocmVhZHMuCisjCisjIERlZmluZSBOT19QUkVBRCBpZiB5b3UgaGF2ZSBhIHByb2JsZW0gd2l0aCBwcmVhZCgpIHN5c3RlbSBjYWxsIChlLmcuCisjIGN5Z3dpbi5kbGwgYmVmb3JlIHYxLjUuMjIpLgorIworIyBEZWZpbmUgTk9fRkFTVF9XT1JLSU5HX0RJUkVDVE9SWSBpZiBhY2Nlc3Npbmcgb2JqZWN0cyBpbiBwYWNrIGZpbGVzIGlzCisjIGdlbmVyYWxseSBmYXN0ZXIgb24geW91ciBwbGF0Zm9ybSB0aGFuIGFjY2Vzc2luZyB0aGUgd29ya2luZyBkaXJlY3RvcnkuCisjCisjIERlZmluZSBOT19UUlVTVEFCTEVfRklMRU1PREUgaWYgeW91ciBmaWxlc3lzdGVtIG1heSBjbGFpbSB0byBzdXBwb3J0CisjIHRoZSBleGVjdXRhYmxlIG1vZGUgYml0LCBidXQgZG9lc24ndCByZWFsbHkgZG8gc28uCisjCisjIERlZmluZSBOT19JUFY2IGlmIHlvdSBsYWNrIElQdjYgc3VwcG9ydCBhbmQgZ2V0YWRkcmluZm8oKS4KKyMKKyMgRGVmaW5lIE5PX1NPQ0tBRERSX1NUT1JBR0UgaWYgeW91ciBwbGF0Zm9ybSBkb2VzIG5vdCBoYXZlIHN0cnVjdAorIyBzb2NrYWRkcl9zdG9yYWdlLgorIworIyBEZWZpbmUgTk9fSUNPTlYgaWYgeW91ciBsaWJjIGRvZXMgbm90IHByb3Blcmx5IHN1cHBvcnQgaWNvbnYuCisjCisjIERlZmluZSBPTERfSUNPTlYgaWYgeW91ciBsaWJyYXJ5IGhhcyBhbiBvbGQgaWNvbnYoKSwgd2hlcmUgdGhlIHNlY29uZAorIyAoaW5wdXQgYnVmZmVyIHBvaW50ZXIpIHBhcmFtZXRlciBpcyBkZWNsYXJlZCB3aXRoIHR5cGUgKGNvbnN0IGNoYXIgKiopLgorIworIyBEZWZpbmUgTk9fREVGTEFURV9CT1VORCBpZiB5b3VyIHpsaWIgZG9lcyBub3QgaGF2ZSBkZWZsYXRlQm91bmQuCisjCisjIERlZmluZSBOT19SX1RPX0dDQ19MSU5LRVIgaWYgeW91ciBnY2MgZG9lcyBub3QgbGlrZSAiLVIvcGF0aC9saWIiCisjIHRoYXQgdGVsbHMgcnVudGltZSBwYXRocyB0byBkeW5hbWljIGxpYnJhcmllczsKKyMgIi1XbCwtcnBhdGg9L3BhdGgvbGliIiBpcyB1c2VkIGluc3RlYWQuCisjCisjIERlZmluZSBVU0VfTlNFQyBiZWxvdyBpZiB5b3Ugd2FudCBwZXJmIHRvIGNhcmUgYWJvdXQgc3ViLXNlY29uZCBmaWxlIG10aW1lcworIyBhbmQgY3RpbWVzLiBOb3RlIHRoYXQgeW91IG5lZWQgcmVjZW50IGdsaWJjIChhdCBsZWFzdCAyLjIuNCkgZm9yIHRoaXMsIGFuZAorIyBpdCB3aWxsIEJSRUFLIFlPVVIgTE9DQUwgRElGRlMhIHNob3ctZGlmZiBhbmQgYW55dGhpbmcgdXNpbmcgaXQgd2lsbCBsaWtlbHkKKyMgcmFuZG9tbHkgYnJlYWsgdW5sZXNzIHlvdXIgdW5kZXJseWluZyBmaWxlc3lzdGVtIHN1cHBvcnRzIHRob3NlIHN1Yi1zZWNvbmQKKyMgdGltZXMgKG15IGV4dDMgZG9lc24ndCkuCisjCisjIERlZmluZSBVU0VfU1RfVElNRVNQRUMgaWYgeW91ciAic3RydWN0IHN0YXQiIHVzZXMgInN0X2N0aW1lc3BlYyIgaW5zdGVhZCBvZgorIyAic3RfY3RpbSIKKyMKKyMgRGVmaW5lIE5PX05TRUMgaWYgeW91ciAic3RydWN0IHN0YXQiIGRvZXMgbm90IGhhdmUgInN0X2N0aW0udHZfbnNlYyIKKyMgYXZhaWxhYmxlLiAgVGhpcyBhdXRvbWF0aWNhbGx5IHR1cm5zIFVTRV9OU0VDIG9mZi4KKyMKKyMgRGVmaW5lIFVTRV9TVERFViBiZWxvdyBpZiB5b3Ugd2FudCBwZXJmIHRvIGNhcmUgYWJvdXQgdGhlIHVuZGVybHlpbmcgZGV2aWNlCisjIGNoYW5nZSBiZWluZyBjb25zaWRlcmVkIGFuIGlub2RlIGNoYW5nZSBmcm9tIHRoZSB1cGRhdGUtaW5kZXggcGVyc3BlY3RpdmUuCisjCisjIERlZmluZSBOT19TVF9CTE9DS1NfSU5fU1RSVUNUX1NUQVQgaWYgeW91ciBwbGF0Zm9ybSBkb2VzIG5vdCBoYXZlIHN0X2Jsb2NrcworIyBmaWVsZCB0aGF0IGNvdW50cyB0aGUgb24tZGlzayBmb290cHJpbnQgaW4gNTEyLWJ5dGUgYmxvY2tzLgorIworIyBEZWZpbmUgQVNDSUlET0M4IGlmIHlvdSB3YW50IHRvIGZvcm1hdCBkb2N1bWVudGF0aW9uIHdpdGggQXNjaWlEb2MgOAorIworIyBEZWZpbmUgRE9DQk9PS19YU0xfMTcyIGlmIHlvdSB3YW50IHRvIGZvcm1hdCBtYW4gcGFnZXMgd2l0aCBEb2NCb29rIFhTTCB2MS43Mi4KKyMKKyMgRGVmaW5lIE5PX1BFUkxfTUFLRU1BS0VSIGlmIHlvdSBjYW5ub3QgdXNlIE1ha2VmaWxlcyBnZW5lcmF0ZWQgYnkgcGVybCdzCisjIE1ha2VNYWtlciAoZS5nLiB1c2luZyBBY3RpdmVTdGF0ZSB1bmRlciBDeWd3aW4pLgorIworIyBEZWZpbmUgTk9fUEVSTCBpZiB5b3UgZG8gbm90IHdhbnQgUGVybCBzY3JpcHRzIG9yIGxpYnJhcmllcyBhdCBhbGwuCisjCisjIERlZmluZSBJTlRFUk5BTF9RU09SVCB0byB1c2UgR2l0J3MgaW1wbGVtZW50YXRpb24gb2YgcXNvcnQoKSwgd2hpY2gKKyMgaXMgYSBzaW1wbGlmaWVkIHZlcnNpb24gb2YgdGhlIG1lcmdlIHNvcnQgdXNlZCBpbiBnbGliYy4gVGhpcyBpcworIyByZWNvbW1lbmRlZCBpZiBHaXQgdHJpZ2dlcnMgTyhuXjIpIGJlaGF2aW9yIGluIHlvdXIgcGxhdGZvcm0ncyBxc29ydCgpLgorIworIyBEZWZpbmUgTk9fRVhURVJOQUxfR1JFUCBpZiB5b3UgZG9uJ3Qgd2FudCAicGVyZiBncmVwIiB0byBldmVyIGNhbGwKKyMgeW91ciBleHRlcm5hbCBncmVwIChlLmcuLCBpZiB5b3VyIHN5c3RlbSBsYWNrcyBncmVwLCBpZiBpdHMgZ3JlcCBpcworIyBicm9rZW4sIG9yIHNwYXduaW5nIGV4dGVybmFsIHByb2Nlc3MgaXMgc2xvd2VyIHRoYW4gYnVpbHQtaW4gZ3JlcCBwZXJmIGhhcykuCisKK1BFUkYtVkVSU0lPTi1GSUxFOiAuRk9SQ0UtUEVSRi1WRVJTSU9OLUZJTEUKKwlAJChTSEVMTF9QQVRIKSB1dGlsL1BFUkYtVkVSU0lPTi1HRU4KKy1pbmNsdWRlIFBFUkYtVkVSU0lPTi1GSUxFCisKK3VuYW1lX1MgOj0gJChzaGVsbCBzaCAtYyAndW5hbWUgLXMgMj4vZGV2L251bGwgfHwgZWNobyBub3QnKQordW5hbWVfTSA6PSAkKHNoZWxsIHNoIC1jICd1bmFtZSAtbSAyPi9kZXYvbnVsbCB8fCBlY2hvIG5vdCcpCit1bmFtZV9PIDo9ICQoc2hlbGwgc2ggLWMgJ3VuYW1lIC1vIDI+L2Rldi9udWxsIHx8IGVjaG8gbm90JykKK3VuYW1lX1IgOj0gJChzaGVsbCBzaCAtYyAndW5hbWUgLXIgMj4vZGV2L251bGwgfHwgZWNobyBub3QnKQordW5hbWVfUCA6PSAkKHNoZWxsIHNoIC1jICd1bmFtZSAtcCAyPi9kZXYvbnVsbCB8fCBlY2hvIG5vdCcpCit1bmFtZV9WIDo9ICQoc2hlbGwgc2ggLWMgJ3VuYW1lIC12IDI+L2Rldi9udWxsIHx8IGVjaG8gbm90JykKKworIyBDRkxBR1MgYW5kIExERkxBR1MgYXJlIGZvciB0aGUgdXNlcnMgdG8gb3ZlcnJpZGUgZnJvbSB0aGUgY29tbWFuZCBsaW5lLgorCitDRkxBR1MgPSAtZ2dkYjMgLVdhbGwgLVdlcnJvciAtV3N0cmljdC1wcm90b3R5cGVzIC1XbWlzc2luZy1kZWNsYXJhdGlvbnMgLVdtaXNzaW5nLXByb3RvdHlwZXMgLXN0ZD1nbnU5OSAtV2RlY2xhcmF0aW9uLWFmdGVyLXN0YXRlbWVudCAtTzYKK0xERkxBR1MgPSAtbHB0aHJlYWQgLWxydCAtbGVsZgorQUxMX0NGTEFHUyA9ICQoQ0ZMQUdTKQorQUxMX0xERkxBR1MgPSAkKExERkxBR1MpCitTVFJJUCA/PSBzdHJpcAorCisjIEFtb25nIHRoZSB2YXJpYWJsZXMgYmVsb3csIHRoZXNlOgorIyAgIHBlcmZleGVjZGlyCisjICAgdGVtcGxhdGVfZGlyCisjICAgbWFuZGlyCisjICAgaW5mb2RpcgorIyAgIGh0bWxkaXIKKyMgICBFVENfUEVSRkNPTkZJRyAoYnV0IG5vdCBzeXNjb25mZGlyKQorIyBjYW4gYmUgc3BlY2lmaWVkIGFzIGEgcmVsYXRpdmUgcGF0aCBzb21lL3doZXJlL2Vsc2U7CisjIHRoaXMgaXMgaW50ZXJwcmV0ZWQgYXMgcmVsYXRpdmUgdG8gJChwcmVmaXgpIGFuZCAicGVyZiIgYXQKKyMgcnVudGltZSBmaWd1cmVzIG91dCB3aGVyZSB0aGV5IGFyZSBiYXNlZCBvbiB0aGUgcGF0aCB0byB0aGUgZXhlY3V0YWJsZS4KKyMgVGhpcyBjYW4gaGVscCBpbnN0YWxsaW5nIHRoZSBzdWl0ZSBpbiBhIHJlbG9jYXRhYmxlIHdheS4KKworcHJlZml4ID0gJChIT01FKQorYmluZGlyX3JlbGF0aXZlID0gYmluCitiaW5kaXIgPSAkKHByZWZpeCkvJChiaW5kaXJfcmVsYXRpdmUpCittYW5kaXIgPSBzaGFyZS9tYW4KK2luZm9kaXIgPSBzaGFyZS9pbmZvCitwZXJmZXhlY2RpciA9IGxpYmV4ZWMvcGVyZi1jb3JlCitzaGFyZWRpciA9ICQocHJlZml4KS9zaGFyZQordGVtcGxhdGVfZGlyID0gc2hhcmUvcGVyZi1jb3JlL3RlbXBsYXRlcworaHRtbGRpciA9IHNoYXJlL2RvYy9wZXJmLWRvYworaWZlcSAoJChwcmVmaXgpLC91c3IpCitzeXNjb25mZGlyID0gL2V0YworRVRDX1BFUkZDT05GSUcgPSAkKHN5c2NvbmZkaXIpL3BlcmZjb25maWcKK2Vsc2UKK3N5c2NvbmZkaXIgPSAkKHByZWZpeCkvZXRjCitFVENfUEVSRkNPTkZJRyA9IGV0Yy9wZXJmY29uZmlnCitlbmRpZgorbGliID0gbGliCisjIERFU1RESVI9CisKK2V4cG9ydCBwcmVmaXggYmluZGlyIHNoYXJlZGlyIHN5c2NvbmZkaXIKKworQ0MgPSBnY2MKK0FSID0gYXIKK1JNID0gcm0gLWYKK1RBUiA9IHRhcgorRklORCA9IGZpbmQKK0lOU1RBTEwgPSBpbnN0YWxsCitSUE1CVUlMRCA9IHJwbWJ1aWxkCitQVEhSRUFEX0xJQlMgPSAtbHB0aHJlYWQKKworIyBzcGFyc2UgaXMgYXJjaGl0ZWN0dXJlLW5ldXRyYWwsIHdoaWNoIG1lYW5zIHRoYXQgd2UgbmVlZCB0byB0ZWxsIGl0CisjIGV4cGxpY2l0bHkgd2hhdCBhcmNoaXRlY3R1cmUgdG8gY2hlY2sgZm9yLiBGaXggdGhpcyB1cCBmb3IgeW91cnMuLgorU1BBUlNFX0ZMQUdTID0gLURfX0JJR19FTkRJQU5fXyAtRF9fcG93ZXJwY19fCisKKworCisjIyMgLS0tIEVORCBDT05GSUdVUkFUSU9OIFNFQ1RJT04gLS0tCisKKyMgVGhvc2UgbXVzdCBub3QgYmUgR05VLXNwZWNpZmljOyB0aGV5IGFyZSBzaGFyZWQgd2l0aCBwZXJsLyB3aGljaCBtYXkKKyMgYmUgYnVpbHQgYnkgYSBkaWZmZXJlbnQgY29tcGlsZXIuIChOb3RlIHRoYXQgdGhpcyBpcyBhbiBhcnRpZmFjdCBub3cKKyMgYnV0IGl0IHN0aWxsIG1pZ2h0IGJlIG5pY2UgdG8ga2VlcCB0aGF0IGRpc3RpbmN0aW9uLikKK0JBU0lDX0NGTEFHUyA9CitCQVNJQ19MREZMQUdTID0KKworIyBHdWFyZCBhZ2FpbnN0IGVudmlyb25tZW50IHZhcmlhYmxlcworQlVJTFRJTl9PQkpTID0KK0JVSUxUX0lOUyA9CitDT01QQVRfQ0ZMQUdTID0KK0NPTVBBVF9PQkpTID0KK0xJQl9IID0KK0xJQl9PQkpTID0KK1NDUklQVF9QRVJMID0KK1NDUklQVF9TSCA9CitURVNUX1BST0dSQU1TID0KKworIworIyBObyBzY3JpcHRzIHJpZ2h0IG5vdzoKKyMKKworIyBTQ1JJUFRfU0ggKz0gcGVyZi1hbS5zaAorCisjCisjIE5vIFBlcmwgc2NyaXB0cyByaWdodCBub3c6CisjCisKKyMgU0NSSVBUX1BFUkwgKz0gcGVyZi1hZGQtLWludGVyYWN0aXZlLnBlcmwKKworU0NSSVBUUyA9ICQocGF0c3Vic3QgJS5zaCwlLCQoU0NSSVBUX1NIKSkgXAorCSAgJChwYXRzdWJzdCAlLnBlcmwsJSwkKFNDUklQVF9QRVJMKSkKKworIyBFbXB0eS4uLgorRVhUUkFfUFJPR1JBTVMgPQorCisjIC4uLiBhbmQgYWxsIHRoZSByZXN0IHRoYXQgY291bGQgYmUgbW92ZWQgb3V0IG9mIGJpbmRpciB0byBwZXJmZXhlY2RpcgorUFJPR1JBTVMgKz0gJChFWFRSQV9QUk9HUkFNUykKKworIworIyBTaW5nbGUgJ3BlcmYnIGJpbmFyeSByaWdodCBub3c6CisjCitQUk9HUkFNUyArPSBwZXJmCisKKyMgTGlzdCBidWlsdC1pbiBjb21tYW5kICRDIHdob3NlIGltcGxlbWVudGF0aW9uIGNtZF8kQygpIGlzIG5vdCBpbgorIyBidWlsdGluLSRDLm8gYnV0IGlzIGxpbmtlZCBpbiBhcyBwYXJ0IG9mIHNvbWUgb3RoZXIgY29tbWFuZC4KKyMKKyMgTm9uZSByaWdodCBub3c6CisjCisjIEJVSUxUX0lOUyArPSBwZXJmLWluaXQgJFgKKworIyB3aGF0ICdhbGwnIHdpbGwgYnVpbGQgYW5kICdpbnN0YWxsJyB3aWxsIGluc3RhbGwsIGluIHBlcmZleGVjZGlyCitBTExfUFJPR1JBTVMgPSAkKFBST0dSQU1TKSAkKFNDUklQVFMpCisKKyMgd2hhdCAnYWxsJyB3aWxsIGJ1aWxkIGJ1dCBub3QgaW5zdGFsbCBpbiBwZXJmZXhlY2RpcgorT1RIRVJfUFJPR1JBTVMgPSBwZXJmJFgKKworIyBTZXQgcGF0aHMgdG8gdG9vbHMgZWFybHkgc28gdGhhdCB0aGV5IGNhbiBiZSB1c2VkIGZvciB2ZXJzaW9uIHRlc3RzLgoraWZuZGVmIFNIRUxMX1BBVEgKKwlTSEVMTF9QQVRIID0gL2Jpbi9zaAorZW5kaWYKK2lmbmRlZiBQRVJMX1BBVEgKKwlQRVJMX1BBVEggPSAvdXNyL2Jpbi9wZXJsCitlbmRpZgorCitleHBvcnQgUEVSTF9QQVRICisKK0xJQl9GSUxFPWxpYnBlcmYuYQorCitMSUJfSCArPSAuLi8uLi9pbmNsdWRlL2xpbnV4L3BlcmZfY291bnRlci5oCitMSUJfSCArPSBwZXJmLmgKK0xJQl9IICs9IHV0aWwvbGlzdC5oCitMSUJfSCArPSB1dGlsL3JidHJlZS5oCitMSUJfSCArPSB1dGlsL2xldmVuc2h0ZWluLmgKK0xJQl9IICs9IHV0aWwvcGFyc2Utb3B0aW9ucy5oCitMSUJfSCArPSB1dGlsL3BhcnNlLWV2ZW50cy5oCitMSUJfSCArPSB1dGlsL3F1b3RlLmgKK0xJQl9IICs9IHV0aWwvdXRpbC5oCitMSUJfSCArPSB1dGlsL2hlbHAuaAorTElCX0ggKz0gdXRpbC9zdHJidWYuaAorTElCX0ggKz0gdXRpbC9zdHJpbmcuaAorTElCX0ggKz0gdXRpbC9ydW4tY29tbWFuZC5oCitMSUJfSCArPSB1dGlsL3NpZ2NoYWluLmgKK0xJQl9IICs9IHV0aWwvc3ltYm9sLmgKK0xJQl9IICs9IHV0aWwvY29sb3IuaAorCitMSUJfT0JKUyArPSB1dGlsL2Fic3BhdGgubworTElCX09CSlMgKz0gdXRpbC9hbGlhcy5vCitMSUJfT0JKUyArPSB1dGlsL2NvbmZpZy5vCitMSUJfT0JKUyArPSB1dGlsL2N0eXBlLm8KK0xJQl9PQkpTICs9IHV0aWwvZW52aXJvbm1lbnQubworTElCX09CSlMgKz0gdXRpbC9leGVjX2NtZC5vCitMSUJfT0JKUyArPSB1dGlsL2hlbHAubworTElCX09CSlMgKz0gdXRpbC9sZXZlbnNodGVpbi5vCitMSUJfT0JKUyArPSB1dGlsL3BhcnNlLW9wdGlvbnMubworTElCX09CSlMgKz0gdXRpbC9wYXJzZS1ldmVudHMubworTElCX09CSlMgKz0gdXRpbC9wYXRoLm8KK0xJQl9PQkpTICs9IHV0aWwvcmJ0cmVlLm8KK0xJQl9PQkpTICs9IHV0aWwvcnVuLWNvbW1hbmQubworTElCX09CSlMgKz0gdXRpbC9xdW90ZS5vCitMSUJfT0JKUyArPSB1dGlsL3N0cmJ1Zi5vCitMSUJfT0JKUyArPSB1dGlsL3N0cmluZy5vCitMSUJfT0JKUyArPSB1dGlsL3VzYWdlLm8KK0xJQl9PQkpTICs9IHV0aWwvd3JhcHBlci5vCitMSUJfT0JKUyArPSB1dGlsL3NpZ2NoYWluLm8KK0xJQl9PQkpTICs9IHV0aWwvc3ltYm9sLm8KK0xJQl9PQkpTICs9IHV0aWwvY29sb3IubworTElCX09CSlMgKz0gdXRpbC9wYWdlci5vCisKK0JVSUxUSU5fT0JKUyArPSBidWlsdGluLWFubm90YXRlLm8KK0JVSUxUSU5fT0JKUyArPSBidWlsdGluLWhlbHAubworQlVJTFRJTl9PQkpTICs9IGJ1aWx0aW4tbGlzdC5vCitCVUlMVElOX09CSlMgKz0gYnVpbHRpbi1yZWNvcmQubworQlVJTFRJTl9PQkpTICs9IGJ1aWx0aW4tcmVwb3J0Lm8KK0JVSUxUSU5fT0JKUyArPSBidWlsdGluLXN0YXQubworQlVJTFRJTl9PQkpTICs9IGJ1aWx0aW4tdG9wLm8KKworUEVSRkxJQlMgPSAkKExJQl9GSUxFKQorRVhUTElCUyA9CisKKyMKKyMgUGxhdGZvcm0gc3BlY2lmaWMgdHdlYWtzCisjCisKKyMgV2UgY2hvb3NlIHRvIGF2b2lkICJpZiAuLiBlbHNlIGlmIC4uIGVsc2UgLi4gZW5kaWYgZW5kaWYiCisjIGJlY2F1c2UgbWFpbnRhaW5pbmcgdGhlIG5lc3RpbmcgdG8gbWF0Y2ggaXMgYSBwYWluLiAgSWYKKyMgd2UgaGFkICJlbGlmIiB0aGluZ3Mgd291bGQgaGF2ZSBiZWVuIG11Y2ggbmljZXIuLi4KKworLWluY2x1ZGUgY29uZmlnLm1hay5hdXRvZ2VuCistaW5jbHVkZSBjb25maWcubWFrCisKK2lmZXEgKCQodW5hbWVfUyksRGFyd2luKQorCWlmbmRlZiBOT19GSU5LCisJCWlmZXEgKCQoc2hlbGwgdGVzdCAtZCAvc3cvbGliICYmIGVjaG8geSkseSkKKwkJCUJBU0lDX0NGTEFHUyArPSAtSS9zdy9pbmNsdWRlCisJCQlCQVNJQ19MREZMQUdTICs9IC1ML3N3L2xpYgorCQllbmRpZgorCWVuZGlmCisJaWZuZGVmIE5PX0RBUldJTl9QT1JUUworCQlpZmVxICgkKHNoZWxsIHRlc3QgLWQgL29wdC9sb2NhbC9saWIgJiYgZWNobyB5KSx5KQorCQkJQkFTSUNfQ0ZMQUdTICs9IC1JL29wdC9sb2NhbC9pbmNsdWRlCisJCQlCQVNJQ19MREZMQUdTICs9IC1ML29wdC9sb2NhbC9saWIKKwkJZW5kaWYKKwllbmRpZgorCVBUSFJFQURfTElCUyA9CitlbmRpZgorCitpZm5kZWYgQ0NfTERfRFlOUEFUSAorCWlmZGVmIE5PX1JfVE9fR0NDX0xJTktFUgorCQkjIFNvbWUgZ2NjIGRvZXMgbm90IGFjY2VwdCBhbmQgcGFzcyAtUiB0byB0aGUgbGlua2VyIHRvIHNwZWNpZnkKKwkJIyB0aGUgcnVudGltZSBkeW5hbWljIGxpYnJhcnkgcGF0aC4KKwkJQ0NfTERfRFlOUEFUSCA9IC1XbCwtcnBhdGgsCisJZWxzZQorCQlDQ19MRF9EWU5QQVRIID0gLVIKKwllbmRpZgorZW5kaWYKKworaWZkZWYgWkxJQl9QQVRICisJQkFTSUNfQ0ZMQUdTICs9IC1JJChaTElCX1BBVEgpL2luY2x1ZGUKKwlFWFRMSUJTICs9IC1MJChaTElCX1BBVEgpLyQobGliKSAkKENDX0xEX0RZTlBBVEgpJChaTElCX1BBVEgpLyQobGliKQorZW5kaWYKK0VYVExJQlMgKz0gLWx6CisKK2lmZGVmIE5FRURTX1NPQ0tFVAorCUVYVExJQlMgKz0gLWxzb2NrZXQKK2VuZGlmCitpZmRlZiBORUVEU19OU0wKKwlFWFRMSUJTICs9IC1sbnNsCitlbmRpZgoraWZkZWYgTk9fRF9UWVBFX0lOX0RJUkVOVAorCUJBU0lDX0NGTEFHUyArPSAtRE5PX0RfVFlQRV9JTl9ESVJFTlQKK2VuZGlmCitpZmRlZiBOT19EX0lOT19JTl9ESVJFTlQKKwlCQVNJQ19DRkxBR1MgKz0gLUROT19EX0lOT19JTl9ESVJFTlQKK2VuZGlmCitpZmRlZiBOT19TVF9CTE9DS1NfSU5fU1RSVUNUX1NUQVQKKwlCQVNJQ19DRkxBR1MgKz0gLUROT19TVF9CTE9DS1NfSU5fU1RSVUNUX1NUQVQKK2VuZGlmCitpZmRlZiBVU0VfTlNFQworCUJBU0lDX0NGTEFHUyArPSAtRFVTRV9OU0VDCitlbmRpZgoraWZkZWYgVVNFX1NUX1RJTUVTUEVDCisJQkFTSUNfQ0ZMQUdTICs9IC1EVVNFX1NUX1RJTUVTUEVDCitlbmRpZgoraWZkZWYgTk9fTlNFQworCUJBU0lDX0NGTEFHUyArPSAtRE5PX05TRUMKK2VuZGlmCitpZmRlZiBOT19DOTlfRk9STUFUCisJQkFTSUNfQ0ZMQUdTICs9IC1ETk9fQzk5X0ZPUk1BVAorZW5kaWYKK2lmZGVmIFNOUFJJTlRGX1JFVFVSTlNfQk9HVVMKKwlDT01QQVRfQ0ZMQUdTICs9IC1EU05QUklOVEZfUkVUVVJOU19CT0dVUworCUNPTVBBVF9PQkpTICs9IGNvbXBhdC9zbnByaW50Zi5vCitlbmRpZgoraWZkZWYgRlJFQURfUkVBRFNfRElSRUNUT1JJRVMKKwlDT01QQVRfQ0ZMQUdTICs9IC1ERlJFQURfUkVBRFNfRElSRUNUT1JJRVMKKwlDT01QQVRfT0JKUyArPSBjb21wYXQvZm9wZW4ubworZW5kaWYKK2lmZGVmIE5PX1NZTUxJTktfSEVBRAorCUJBU0lDX0NGTEFHUyArPSAtRE5PX1NZTUxJTktfSEVBRAorZW5kaWYKK2lmZGVmIE5PX1NUUkNBU0VTVFIKKwlDT01QQVRfQ0ZMQUdTICs9IC1ETk9fU1RSQ0FTRVNUUgorCUNPTVBBVF9PQkpTICs9IGNvbXBhdC9zdHJjYXNlc3RyLm8KK2VuZGlmCitpZmRlZiBOT19TVFJUT1VNQVgKKwlDT01QQVRfQ0ZMQUdTICs9IC1ETk9fU1RSVE9VTUFYCisJQ09NUEFUX09CSlMgKz0gY29tcGF0L3N0cnRvdW1heC5vCitlbmRpZgoraWZkZWYgTk9fU1RSVE9VTEwKKwlDT01QQVRfQ0ZMQUdTICs9IC1ETk9fU1RSVE9VTEwKK2VuZGlmCitpZmRlZiBOT19TRVRFTlYKKwlDT01QQVRfQ0ZMQUdTICs9IC1ETk9fU0VURU5WCisJQ09NUEFUX09CSlMgKz0gY29tcGF0L3NldGVudi5vCitlbmRpZgoraWZkZWYgTk9fTUtEVEVNUAorCUNPTVBBVF9DRkxBR1MgKz0gLUROT19NS0RURU1QCisJQ09NUEFUX09CSlMgKz0gY29tcGF0L21rZHRlbXAubworZW5kaWYKK2lmZGVmIE5PX1VOU0VURU5WCisJQ09NUEFUX0NGTEFHUyArPSAtRE5PX1VOU0VURU5WCisJQ09NUEFUX09CSlMgKz0gY29tcGF0L3Vuc2V0ZW52Lm8KK2VuZGlmCitpZmRlZiBOT19TWVNfU0VMRUNUX0gKKwlCQVNJQ19DRkxBR1MgKz0gLUROT19TWVNfU0VMRUNUX0gKK2VuZGlmCitpZmRlZiBOT19NTUFQCisJQ09NUEFUX0NGTEFHUyArPSAtRE5PX01NQVAKKwlDT01QQVRfT0JKUyArPSBjb21wYXQvbW1hcC5vCitlbHNlCisJaWZkZWYgVVNFX1dJTjMyX01NQVAKKwkJQ09NUEFUX0NGTEFHUyArPSAtRFVTRV9XSU4zMl9NTUFQCisJCUNPTVBBVF9PQkpTICs9IGNvbXBhdC93aW4zMm1tYXAubworCWVuZGlmCitlbmRpZgoraWZkZWYgTk9fUFJFQUQKKwlDT01QQVRfQ0ZMQUdTICs9IC1ETk9fUFJFQUQKKwlDT01QQVRfT0JKUyArPSBjb21wYXQvcHJlYWQubworZW5kaWYKK2lmZGVmIE5PX0ZBU1RfV09SS0lOR19ESVJFQ1RPUlkKKwlCQVNJQ19DRkxBR1MgKz0gLUROT19GQVNUX1dPUktJTkdfRElSRUNUT1JZCitlbmRpZgoraWZkZWYgTk9fVFJVU1RBQkxFX0ZJTEVNT0RFCisJQkFTSUNfQ0ZMQUdTICs9IC1ETk9fVFJVU1RBQkxFX0ZJTEVNT0RFCitlbmRpZgoraWZkZWYgTk9fSVBWNgorCUJBU0lDX0NGTEFHUyArPSAtRE5PX0lQVjYKK2VuZGlmCitpZmRlZiBOT19VSU5UTUFYX1QKKwlCQVNJQ19DRkxBR1MgKz0gLUR1aW50bWF4X3Q9dWludDMyX3QKK2VuZGlmCitpZmRlZiBOT19TT0NLQUREUl9TVE9SQUdFCitpZmRlZiBOT19JUFY2CisJQkFTSUNfQ0ZMQUdTICs9IC1Ec29ja2FkZHJfc3RvcmFnZT1zb2NrYWRkcl9pbgorZWxzZQorCUJBU0lDX0NGTEFHUyArPSAtRHNvY2thZGRyX3N0b3JhZ2U9c29ja2FkZHJfaW42CitlbmRpZgorZW5kaWYKK2lmZGVmIE5PX0lORVRfTlRPUAorCUxJQl9PQkpTICs9IGNvbXBhdC9pbmV0X250b3AubworZW5kaWYKK2lmZGVmIE5PX0lORVRfUFRPTgorCUxJQl9PQkpTICs9IGNvbXBhdC9pbmV0X3B0b24ubworZW5kaWYKKworaWZkZWYgTk9fSUNPTlYKKwlCQVNJQ19DRkxBR1MgKz0gLUROT19JQ09OVgorZW5kaWYKKworaWZkZWYgT0xEX0lDT05WCisJQkFTSUNfQ0ZMQUdTICs9IC1ET0xEX0lDT05WCitlbmRpZgorCitpZmRlZiBOT19ERUZMQVRFX0JPVU5ECisJQkFTSUNfQ0ZMQUdTICs9IC1ETk9fREVGTEFURV9CT1VORAorZW5kaWYKKworaWZkZWYgUFBDX1NIQTEKKwlTSEExX0hFQURFUiA9ICJwcGMvc2hhMS5oIgorCUxJQl9PQkpTICs9IHBwYy9zaGExLm8gcHBjL3NoYTFwcGMubworZWxzZQoraWZkZWYgQVJNX1NIQTEKKwlTSEExX0hFQURFUiA9ICJhcm0vc2hhMS5oIgorCUxJQl9PQkpTICs9IGFybS9zaGExLm8gYXJtL3NoYTFfYXJtLm8KK2Vsc2UKK2lmZGVmIE1PWklMTEFfU0hBMQorCVNIQTFfSEVBREVSID0gIm1vemlsbGEtc2hhMS9zaGExLmgiCisJTElCX09CSlMgKz0gbW96aWxsYS1zaGExL3NoYTEubworZWxzZQorCVNIQTFfSEVBREVSID0gPG9wZW5zc2wvc2hhLmg+CisJRVhUTElCUyArPSAkKExJQl80X0NSWVBUTykKK2VuZGlmCitlbmRpZgorZW5kaWYKK2lmZGVmIE5PX1BFUkxfTUFLRU1BS0VSCisJZXhwb3J0IE5PX1BFUkxfTUFLRU1BS0VSCitlbmRpZgoraWZkZWYgTk9fSFNUUkVSUk9SCisJQ09NUEFUX0NGTEFHUyArPSAtRE5PX0hTVFJFUlJPUgorCUNPTVBBVF9PQkpTICs9IGNvbXBhdC9oc3RyZXJyb3IubworZW5kaWYKK2lmZGVmIE5PX01FTU1FTQorCUNPTVBBVF9DRkxBR1MgKz0gLUROT19NRU1NRU0KKwlDT01QQVRfT0JKUyArPSBjb21wYXQvbWVtbWVtLm8KK2VuZGlmCitpZmRlZiBJTlRFUk5BTF9RU09SVAorCUNPTVBBVF9DRkxBR1MgKz0gLURJTlRFUk5BTF9RU09SVAorCUNPTVBBVF9PQkpTICs9IGNvbXBhdC9xc29ydC5vCitlbmRpZgoraWZkZWYgUlVOVElNRV9QUkVGSVgKKwlDT01QQVRfQ0ZMQUdTICs9IC1EUlVOVElNRV9QUkVGSVgKK2VuZGlmCisKK2lmZGVmIERJUl9IQVNfQlNEX0dST1VQX1NFTUFOVElDUworCUNPTVBBVF9DRkxBR1MgKz0gLURESVJfSEFTX0JTRF9HUk9VUF9TRU1BTlRJQ1MKK2VuZGlmCitpZmRlZiBOT19FWFRFUk5BTF9HUkVQCisJQkFTSUNfQ0ZMQUdTICs9IC1ETk9fRVhURVJOQUxfR1JFUAorZW5kaWYKKworaWZlcSAoJChQRVJMX1BBVEgpLCkKK05PX1BFUkw9Tm9UaGFua3MKK2VuZGlmCisKK1FVSUVUX1NVQkRJUjAgID0gKyQoTUFLRSkgLUMgIyBzcGFjZSB0byBzZXBhcmF0ZSAtQyBhbmQgc3ViZGlyCitRVUlFVF9TVUJESVIxICA9CisKK2lmbmVxICgkKGZpbmRzdHJpbmcgJChNQUtFRkxBR1MpLHcpLHcpCitQUklOVF9ESVIgPSAtLW5vLXByaW50LWRpcmVjdG9yeQorZWxzZSAjICJtYWtlIC13IgorTk9fU1VCRElSID0gOgorZW5kaWYKKworaWZuZXEgKCQoZmluZHN0cmluZyAkKE1BS0VGTEFHUykscykscykKK2lmbmRlZiBWCisJUVVJRVRfQ0MgICAgICAgPSBAZWNobyAnICAgJyBDQyAkQDsKKwlRVUlFVF9BUiAgICAgICA9IEBlY2hvICcgICAnIEFSICRAOworCVFVSUVUX0xJTksgICAgID0gQGVjaG8gJyAgICcgTElOSyAkQDsKKwlRVUlFVF9CVUlMVF9JTiA9IEBlY2hvICcgICAnIEJVSUxUSU4gJEA7CisJUVVJRVRfR0VOICAgICAgPSBAZWNobyAnICAgJyBHRU4gJEA7CisJUVVJRVRfU1VCRElSMCAgPSArQHN1YmRpcj0KKwlRVUlFVF9TVUJESVIxICA9IDskKE5PX1NVQkRJUikgZWNobyAnICAgJyBTVUJESVIgJCRzdWJkaXI7IFwKKwkJCSAkKE1BS0UpICQoUFJJTlRfRElSKSAtQyAkJHN1YmRpcgorCWV4cG9ydCBWCisJZXhwb3J0IFFVSUVUX0dFTgorCWV4cG9ydCBRVUlFVF9CVUlMVF9JTgorZW5kaWYKK2VuZGlmCisKK2lmZGVmIEFTQ0lJRE9DOAorCWV4cG9ydCBBU0NJSURPQzgKK2VuZGlmCisKKyMgU2hlbGwgcXVvdGUgKGRvIG5vdCB1c2UgJChjYWxsKSB0byBhY2NvbW1vZGF0ZSBhbmNpZW50IHNldHVwcyk7CisKK1NIQTFfSEVBREVSX1NRID0gJChzdWJzdCAnLCdcJycsJChTSEExX0hFQURFUikpCitFVENfUEVSRkNPTkZJR19TUSA9ICQoc3Vic3QgJywnXCcnLCQoRVRDX1BFUkZDT05GSUcpKQorCitERVNURElSX1NRID0gJChzdWJzdCAnLCdcJycsJChERVNURElSKSkKK2JpbmRpcl9TUSA9ICQoc3Vic3QgJywnXCcnLCQoYmluZGlyKSkKK2JpbmRpcl9yZWxhdGl2ZV9TUSA9ICQoc3Vic3QgJywnXCcnLCQoYmluZGlyX3JlbGF0aXZlKSkKK21hbmRpcl9TUSA9ICQoc3Vic3QgJywnXCcnLCQobWFuZGlyKSkKK2luZm9kaXJfU1EgPSAkKHN1YnN0ICcsJ1wnJywkKGluZm9kaXIpKQorcGVyZmV4ZWNkaXJfU1EgPSAkKHN1YnN0ICcsJ1wnJywkKHBlcmZleGVjZGlyKSkKK3RlbXBsYXRlX2Rpcl9TUSA9ICQoc3Vic3QgJywnXCcnLCQodGVtcGxhdGVfZGlyKSkKK2h0bWxkaXJfU1EgPSAkKHN1YnN0ICcsJ1wnJywkKGh0bWxkaXIpKQorcHJlZml4X1NRID0gJChzdWJzdCAnLCdcJycsJChwcmVmaXgpKQorCitTSEVMTF9QQVRIX1NRID0gJChzdWJzdCAnLCdcJycsJChTSEVMTF9QQVRIKSkKK1BFUkxfUEFUSF9TUSA9ICQoc3Vic3QgJywnXCcnLCQoUEVSTF9QQVRIKSkKKworTElCUyA9ICQoUEVSRkxJQlMpICQoRVhUTElCUykKKworQkFTSUNfQ0ZMQUdTICs9IC1EU0hBMV9IRUFERVI9JyQoU0hBMV9IRUFERVJfU1EpJyBcCisJJChDT01QQVRfQ0ZMQUdTKQorTElCX09CSlMgKz0gJChDT01QQVRfT0JKUykKKworQUxMX0NGTEFHUyArPSAkKEJBU0lDX0NGTEFHUykKK0FMTF9MREZMQUdTICs9ICQoQkFTSUNfTERGTEFHUykKKworZXhwb3J0IFRBUiBJTlNUQUxMIERFU1RESVIgU0hFTExfUEFUSAorCisKKyMjIyBCdWlsZCBydWxlcworCitTSEVMTCA9ICQoU0hFTExfUEFUSCkKKworYWxsOjogc2hlbGxfY29tcGF0aWJpbGl0eV90ZXN0ICQoQUxMX1BST0dSQU1TKSAkKEJVSUxUX0lOUykgJChPVEhFUl9QUk9HUkFNUykgUEVSRi1CVUlMRC1PUFRJT05TCitpZm5lcSAoLCRYKQorCSQoZm9yZWFjaCBwLCQocGF0c3Vic3QgJSRYLCUsJChmaWx0ZXIgJSRYLCQoQUxMX1BST0dSQU1TKSAkKEJVSUxUX0lOUykgcGVyZiRYKSksIHRlc3QgJyRwJyAtZWYgJyRwJFgnIHx8ICQoUk0pICckcCc7KQorZW5kaWYKKworYWxsOjoKKworcGxlYXNlX3NldF9TSEVMTF9QQVRIX3RvX2FfbW9yZV9tb2Rlcm5fc2hlbGw6CisJQCQkKDopCisKK3NoZWxsX2NvbXBhdGliaWxpdHlfdGVzdDogcGxlYXNlX3NldF9TSEVMTF9QQVRIX3RvX2FfbW9yZV9tb2Rlcm5fc2hlbGwKKworc3RyaXA6ICQoUFJPR1JBTVMpIHBlcmYkWAorCSQoU1RSSVApICQoU1RSSVBfT1BUUykgJChQUk9HUkFNUykgcGVyZiRYCisKK3BlcmYubzogcGVyZi5jIGNvbW1vbi1jbWRzLmggUEVSRi1DRkxBR1MKKwkkKFFVSUVUX0NDKSQoQ0MpIC1EUEVSRl9WRVJTSU9OPSciJChQRVJGX1ZFUlNJT04pIicgXAorCQknLURQRVJGX0hUTUxfUEFUSD0iJChodG1sZGlyX1NRKSInIFwKKwkJJChBTExfQ0ZMQUdTKSAtYyAkKGZpbHRlciAlLmMsJF4pCisKK3BlcmYkWDogcGVyZi5vICQoQlVJTFRJTl9PQkpTKSAkKFBFUkZMSUJTKQorCSQoUVVJRVRfTElOSykkKENDKSAkKEFMTF9DRkxBR1MpIC1vICRAIHBlcmYubyBcCisJCSQoQlVJTFRJTl9PQkpTKSAkKEFMTF9MREZMQUdTKSAkKExJQlMpCisKK2J1aWx0aW4taGVscC5vOiBidWlsdGluLWhlbHAuYyBjb21tb24tY21kcy5oIFBFUkYtQ0ZMQUdTCisJJChRVUlFVF9DQykkKENDKSAtbyAkKi5vIC1jICQoQUxMX0NGTEFHUykgXAorCQknLURQRVJGX0hUTUxfUEFUSD0iJChodG1sZGlyX1NRKSInIFwKKwkJJy1EUEVSRl9NQU5fUEFUSD0iJChtYW5kaXJfU1EpIicgXAorCQknLURQRVJGX0lORk9fUEFUSD0iJChpbmZvZGlyX1NRKSInICQ8CisKKyQoQlVJTFRfSU5TKTogcGVyZiRYCisJJChRVUlFVF9CVUlMVF9JTikkKFJNKSAkQCAmJiBcCisJbG4gcGVyZiRYICRAIDI+L2Rldi9udWxsIHx8IFwKKwlsbiAtcyBwZXJmJFggJEAgMj4vZGV2L251bGwgfHwgXAorCWNwIHBlcmYkWCAkQAorCitjb21tb24tY21kcy5oOiB1dGlsL2dlbmVyYXRlLWNtZGxpc3Quc2ggY29tbWFuZC1saXN0LnR4dAorCitjb21tb24tY21kcy5oOiAkKHdpbGRjYXJkIERvY3VtZW50YXRpb24vcGVyZi0qLnR4dCkKKwkkKFFVSUVUX0dFTil1dGlsL2dlbmVyYXRlLWNtZGxpc3Quc2ggPiAkQCsgJiYgbXYgJEArICRACisKKyQocGF0c3Vic3QgJS5zaCwlLCQoU0NSSVBUX1NIKSkgOiAlIDogJS5zaAorCSQoUVVJRVRfR0VOKSQoUk0pICRAICRAKyAmJiBcCisJc2VkIC1lICcxc3wjIS4qL3NofCMhJChTSEVMTF9QQVRIX1NRKXwnIFwKKwkgICAgLWUgJ3N8QFNIRUxMX1BBVEhAfCQoU0hFTExfUEFUSF9TUSl8JyBcCisJICAgIC1lICdzfEBAUEVSTEBAfCQoUEVSTF9QQVRIX1NRKXxnJyBcCisJICAgIC1lICdzL0BAUEVSRl9WRVJTSU9OQEAvJChQRVJGX1ZFUlNJT04pL2cnIFwKKwkgICAgLWUgJ3MvQEBOT19DVVJMQEAvJChOT19DVVJMKS9nJyBcCisJICAgICRALnNoID4kQCsgJiYgXAorCWNobW9kICt4ICRAKyAmJiBcCisJbXYgJEArICRACisKK2NvbmZpZ3VyZTogY29uZmlndXJlLmFjCisJJChRVUlFVF9HRU4pJChSTSkgJEAgJDwrICYmIFwKKwlzZWQgLWUgJ3MvQEBQRVJGX1ZFUlNJT05AQC8kKFBFUkZfVkVSU0lPTikvZycgXAorCSAgICAkPCA+ICQ8KyAmJiBcCisJYXV0b2NvbmYgLW8gJEAgJDwrICYmIFwKKwkkKFJNKSAkPCsKKworIyBUaGVzZSBjYW4gcmVjb3JkIFBFUkZfVkVSU0lPTgorcGVyZi5vIHBlcmYuc3BlYyBcCisJJChwYXRzdWJzdCAlLnNoLCUsJChTQ1JJUFRfU0gpKSBcCisJJChwYXRzdWJzdCAlLnBlcmwsJSwkKFNDUklQVF9QRVJMKSkgXAorCTogUEVSRi1WRVJTSU9OLUZJTEUKKworJS5vOiAlLmMgUEVSRi1DRkxBR1MKKwkkKFFVSUVUX0NDKSQoQ0MpIC1vICQqLm8gLWMgJChBTExfQ0ZMQUdTKSAkPAorJS5zOiAlLmMgUEVSRi1DRkxBR1MKKwkkKFFVSUVUX0NDKSQoQ0MpIC1TICQoQUxMX0NGTEFHUykgJDwKKyUubzogJS5TCisJJChRVUlFVF9DQykkKENDKSAtbyAkKi5vIC1jICQoQUxMX0NGTEFHUykgJDwKKwordXRpbC9leGVjX2NtZC5vOiB1dGlsL2V4ZWNfY21kLmMgUEVSRi1DRkxBR1MKKwkkKFFVSUVUX0NDKSQoQ0MpIC1vICQqLm8gLWMgJChBTExfQ0ZMQUdTKSBcCisJCSctRFBFUkZfRVhFQ19QQVRIPSIkKHBlcmZleGVjZGlyX1NRKSInIFwKKwkJJy1EQklORElSPSIkKGJpbmRpcl9yZWxhdGl2ZV9TUSkiJyBcCisJCSctRFBSRUZJWD0iJChwcmVmaXhfU1EpIicgXAorCQkkPAorCitidWlsdGluLWluaXQtZGIubzogYnVpbHRpbi1pbml0LWRiLmMgUEVSRi1DRkxBR1MKKwkkKFFVSUVUX0NDKSQoQ0MpIC1vICQqLm8gLWMgJChBTExfQ0ZMQUdTKSAtRERFRkFVTFRfUEVSRl9URU1QTEFURV9ESVI9JyIkKHRlbXBsYXRlX2Rpcl9TUSkiJyAkPAorCit1dGlsL2NvbmZpZy5vOiB1dGlsL2NvbmZpZy5jIFBFUkYtQ0ZMQUdTCisJJChRVUlFVF9DQykkKENDKSAtbyAkKi5vIC1jICQoQUxMX0NGTEFHUykgLURFVENfUEVSRkNPTkZJRz0nIiQoRVRDX1BFUkZDT05GSUdfU1EpIicgJDwKKworcGVyZi0lJFg6ICUubyAkKFBFUkZMSUJTKQorCSQoUVVJRVRfTElOSykkKENDKSAkKEFMTF9DRkxBR1MpIC1vICRAICQoQUxMX0xERkxBR1MpICQoZmlsdGVyICUubywkXikgJChMSUJTKQorCiskKExJQl9PQkpTKSAkKEJVSUxUSU5fT0JKUyk6ICQoTElCX0gpCiskKHBhdHN1YnN0IHBlcmYtJSRYLCUubywkKFBST0dSQU1TKSk6ICQoTElCX0gpICQod2lsZGNhcmQgKi8qLmgpCitidWlsdGluLXJldmVydC5vIHd0LXN0YXR1cy5vOiB3dC1zdGF0dXMuaAorCiskKExJQl9GSUxFKTogJChMSUJfT0JKUykKKwkkKFFVSUVUX0FSKSQoUk0pICRAICYmICQoQVIpIHJjcyAkQCAkKExJQl9PQkpTKQorCitkb2M6CisJJChNQUtFKSAtQyBEb2N1bWVudGF0aW9uIGFsbAorCittYW46CisJJChNQUtFKSAtQyBEb2N1bWVudGF0aW9uIG1hbgorCitodG1sOgorCSQoTUFLRSkgLUMgRG9jdW1lbnRhdGlvbiBodG1sCisKK2luZm86CisJJChNQUtFKSAtQyBEb2N1bWVudGF0aW9uIGluZm8KKworcGRmOgorCSQoTUFLRSkgLUMgRG9jdW1lbnRhdGlvbiBwZGYKKworVEFHUzoKKwkkKFJNKSBUQUdTCisJJChGSU5EKSAuIC1uYW1lICcqLltoY1NdJyAtcHJpbnQgfCB4YXJncyBldGFncyAtYQorCit0YWdzOgorCSQoUk0pIHRhZ3MKKwkkKEZJTkQpIC4gLW5hbWUgJyouW2hjU10nIC1wcmludCB8IHhhcmdzIGN0YWdzIC1hCisKK2NzY29wZToKKwkkKFJNKSBjc2NvcGUqCisJJChGSU5EKSAuIC1uYW1lICcqLltoY1NdJyAtcHJpbnQgfCB4YXJncyBjc2NvcGUgLWIKKworIyMjIERldGVjdCBwcmVmaXggY2hhbmdlcworVFJBQ0tfQ0ZMQUdTID0gJChzdWJzdCAnLCdcJycsJChBTExfQ0ZMQUdTKSk6XAorICAgICAgICAgICAgICQoYmluZGlyX1NRKTokKHBlcmZleGVjZGlyX1NRKTokKHRlbXBsYXRlX2Rpcl9TUSk6JChwcmVmaXhfU1EpCisKK1BFUkYtQ0ZMQUdTOiAuRk9SQ0UtUEVSRi1DRkxBR1MKKwlARkxBR1M9JyQoVFJBQ0tfQ0ZMQUdTKSc7IFwKKwkgICAgaWYgdGVzdCB4IiQkRkxBR1MiICE9IHgiYGNhdCBQRVJGLUNGTEFHUyAyPi9kZXYvbnVsbGAiIDsgdGhlbiBcCisJCWVjaG8gMT4mMiAiICAgICogbmV3IGJ1aWxkIGZsYWdzIG9yIHByZWZpeCI7IFwKKwkJZWNobyAiJCRGTEFHUyIgPlBFUkYtQ0ZMQUdTOyBcCisgICAgICAgICAgICBmaQorCisjIFdlIG5lZWQgdG8gYXBwbHkgc3EgdHdpY2UsIG9uY2UgdG8gcHJvdGVjdCBmcm9tIHRoZSBzaGVsbAorIyB0aGF0IHJ1bnMgUEVSRi1CVUlMRC1PUFRJT05TLCBhbmQgdGhlbiBhZ2FpbiB0byBwcm90ZWN0IGl0CisjIGFuZCB0aGUgZmlyc3QgbGV2ZWwgcXVvdGluZyBmcm9tIHRoZSBzaGVsbCB0aGF0IHJ1bnMgImVjaG8iLgorUEVSRi1CVUlMRC1PUFRJT05TOiAuRk9SQ0UtUEVSRi1CVUlMRC1PUFRJT05TCisJQGVjaG8gU0hFTExfUEFUSD1cJyckKHN1YnN0ICcsJ1wnJywkKFNIRUxMX1BBVEhfU1EpKSdcJyA+JEAKKwlAZWNobyBUQVI9XCcnJChzdWJzdCAnLCdcJycsJChzdWJzdCAnLCdcJycsJChUQVIpKSknXCcgPj4kQAorCUBlY2hvIE5PX0NVUkw9XCcnJChzdWJzdCAnLCdcJycsJChzdWJzdCAnLCdcJycsJChOT19DVVJMKSkpJ1wnID4+JEAKKwlAZWNobyBOT19QRVJMPVwnJyQoc3Vic3QgJywnXCcnLCQoc3Vic3QgJywnXCcnLCQoTk9fUEVSTCkpKSdcJyA+PiRACisKKyMjIyBUZXN0aW5nIHJ1bGVzCisKKyMKKyMgTm9uZSByaWdodCBub3c6CisjCisjIFRFU1RfUFJPR1JBTVMgKz0gdGVzdC1zb21ldGhpbmckWAorCithbGw6OiAkKFRFU1RfUFJPR1JBTVMpCisKKyMgR05VIG1ha2Ugc3VwcG9ydHMgZXhwb3J0aW5nIGFsbCB2YXJpYWJsZXMgYnkgImV4cG9ydCIgd2l0aG91dCBwYXJhbWV0ZXJzLgorIyBIb3dldmVyLCB0aGUgZW52aXJvbm1lbnQgZ2V0cyBxdWl0ZSBiaWcsIGFuZCBzb21lIHByb2dyYW1zIGhhdmUgcHJvYmxlbXMKKyMgd2l0aCB0aGF0LgorCitleHBvcnQgTk9fU1ZOX1RFU1RTCisKK2NoZWNrOiBjb21tb24tY21kcy5oCisJaWYgc3BhcnNlOyBcCisJdGhlbiBcCisJCWZvciBpIGluICouYyAqLyouYzsgXAorCQlkbyBcCisJCQlzcGFyc2UgJChBTExfQ0ZMQUdTKSAkKFNQQVJTRV9GTEFHUykgJCRpIHx8IGV4aXQ7IFwKKwkJZG9uZTsgXAorCWVsc2UgXAorCQllY2hvIDI+JjEgIkRpZCB5b3UgbWVhbiAnbWFrZSB0ZXN0Jz8iOyBcCisJCWV4aXQgMTsgXAorCWZpCisKK3JlbW92ZS1kYXNoZXM6CisJLi9maXh1cC1idWlsdGlucyAkKEJVSUxUX0lOUykgJChQUk9HUkFNUykgJChTQ1JJUFRTKQorCisjIyMgSW5zdGFsbGF0aW9uIHJ1bGVzCisKK2lmbmVxICgkKGZpbHRlciAvJSwkKGZpcnN0d29yZCAkKHRlbXBsYXRlX2RpcikpKSwpCit0ZW1wbGF0ZV9pbnN0ZGlyID0gJCh0ZW1wbGF0ZV9kaXIpCitlbHNlCit0ZW1wbGF0ZV9pbnN0ZGlyID0gJChwcmVmaXgpLyQodGVtcGxhdGVfZGlyKQorZW5kaWYKK2V4cG9ydCB0ZW1wbGF0ZV9pbnN0ZGlyCisKK2lmbmVxICgkKGZpbHRlciAvJSwkKGZpcnN0d29yZCAkKHBlcmZleGVjZGlyKSkpLCkKK3BlcmZleGVjX2luc3RkaXIgPSAkKHBlcmZleGVjZGlyKQorZWxzZQorcGVyZmV4ZWNfaW5zdGRpciA9ICQocHJlZml4KS8kKHBlcmZleGVjZGlyKQorZW5kaWYKK3BlcmZleGVjX2luc3RkaXJfU1EgPSAkKHN1YnN0ICcsJ1wnJywkKHBlcmZleGVjX2luc3RkaXIpKQorZXhwb3J0IHBlcmZleGVjX2luc3RkaXIKKworaW5zdGFsbDogYWxsCisJJChJTlNUQUxMKSAtZCAtbSA3NTUgJyQoREVTVERJUl9TUSkkKGJpbmRpcl9TUSknCisJJChJTlNUQUxMKSBwZXJmJFggJyQoREVTVERJUl9TUSkkKGJpbmRpcl9TUSknCitpZmRlZiBCVUlMVF9JTlMKKwkkKElOU1RBTEwpIC1kIC1tIDc1NSAnJChERVNURElSX1NRKSQocGVyZmV4ZWNfaW5zdGRpcl9TUSknCisJJChJTlNUQUxMKSAkKEJVSUxUX0lOUykgJyQoREVTVERJUl9TUSkkKHBlcmZleGVjX2luc3RkaXJfU1EpJworaWZuZXEgKCwkWCkKKwkkKGZvcmVhY2ggcCwkKHBhdHN1YnN0ICUkWCwlLCQoZmlsdGVyICUkWCwkKEFMTF9QUk9HUkFNUykgJChCVUlMVF9JTlMpIHBlcmYkWCkpLCAkKFJNKSAnJChERVNURElSX1NRKSQocGVyZmV4ZWNfaW5zdGRpcl9TUSkvJHAnOykKK2VuZGlmCitlbmRpZgorCitpbnN0YWxsLWRvYzoKKwkkKE1BS0UpIC1DIERvY3VtZW50YXRpb24gaW5zdGFsbAorCitpbnN0YWxsLW1hbjoKKwkkKE1BS0UpIC1DIERvY3VtZW50YXRpb24gaW5zdGFsbC1tYW4KKworaW5zdGFsbC1odG1sOgorCSQoTUFLRSkgLUMgRG9jdW1lbnRhdGlvbiBpbnN0YWxsLWh0bWwKKworaW5zdGFsbC1pbmZvOgorCSQoTUFLRSkgLUMgRG9jdW1lbnRhdGlvbiBpbnN0YWxsLWluZm8KKworaW5zdGFsbC1wZGY6CisJJChNQUtFKSAtQyBEb2N1bWVudGF0aW9uIGluc3RhbGwtcGRmCisKK3F1aWNrLWluc3RhbGwtZG9jOgorCSQoTUFLRSkgLUMgRG9jdW1lbnRhdGlvbiBxdWljay1pbnN0YWxsCisKK3F1aWNrLWluc3RhbGwtbWFuOgorCSQoTUFLRSkgLUMgRG9jdW1lbnRhdGlvbiBxdWljay1pbnN0YWxsLW1hbgorCitxdWljay1pbnN0YWxsLWh0bWw6CisJJChNQUtFKSAtQyBEb2N1bWVudGF0aW9uIHF1aWNrLWluc3RhbGwtaHRtbAorCisKKyMjIyBNYWludGFpbmVyJ3MgZGlzdCBydWxlcworIworIyBOb25lIHJpZ2h0IG5vdworIworIworIyBwZXJmLnNwZWM6IHBlcmYuc3BlYy5pbgorIwlzZWQgLWUgJ3MvQEBWRVJTSU9OQEAvJChQRVJGX1ZFUlNJT04pL2cnIDwgJDwgPiAkQCsKKyMJbXYgJEArICRACisjCisjIFBFUkZfVEFSTkFNRT1wZXJmLSQoUEVSRl9WRVJTSU9OKQorIyBkaXN0OiBwZXJmLnNwZWMgcGVyZi1hcmNoaXZlJChYKSBjb25maWd1cmUKKyMJLi9wZXJmLWFyY2hpdmUgLS1mb3JtYXQ9dGFyIFwKKyMJCS0tcHJlZml4PSQoUEVSRl9UQVJOQU1FKS8gSEVBRF57dHJlZX0gPiAkKFBFUkZfVEFSTkFNRSkudGFyCisjCUBta2RpciAtcCAkKFBFUkZfVEFSTkFNRSkKKyMJQGNwIHBlcmYuc3BlYyBjb25maWd1cmUgJChQRVJGX1RBUk5BTUUpCisjCUBlY2hvICQoUEVSRl9WRVJTSU9OKSA+ICQoUEVSRl9UQVJOQU1FKS92ZXJzaW9uCisjCSQoVEFSKSByZiAkKFBFUkZfVEFSTkFNRSkudGFyIFwKKyMJCSQoUEVSRl9UQVJOQU1FKS9wZXJmLnNwZWMgXAorIwkJJChQRVJGX1RBUk5BTUUpL2NvbmZpZ3VyZSBcCisjCQkkKFBFUkZfVEFSTkFNRSkvdmVyc2lvbgorIwlAJChSTSkgLXIgJChQRVJGX1RBUk5BTUUpCisjCWd6aXAgLWYgLTkgJChQRVJGX1RBUk5BTUUpLnRhcgorIworIyBodG1sZG9jcyA9IHBlcmYtaHRtbGRvY3MtJChQRVJGX1ZFUlNJT04pCisjIG1hbnBhZ2VzID0gcGVyZi1tYW5wYWdlcy0kKFBFUkZfVkVSU0lPTikKKyMgZGlzdC1kb2M6CisjCSQoUk0pIC1yIC5kb2MtdG1wLWRpcgorIwlta2RpciAuZG9jLXRtcC1kaXIKKyMJJChNQUtFKSAtQyBEb2N1bWVudGF0aW9uIFdFQkRPQ19ERVNUPS4uLy5kb2MtdG1wLWRpciBpbnN0YWxsLXdlYmRvYworIwljZCAuZG9jLXRtcC1kaXIgJiYgJChUQVIpIGNmIC4uLyQoaHRtbGRvY3MpLnRhciAuCisjCWd6aXAgLW4gLTkgLWYgJChodG1sZG9jcykudGFyCisjCToKKyMJJChSTSkgLXIgLmRvYy10bXAtZGlyCisjCW1rZGlyIC1wIC5kb2MtdG1wLWRpci9tYW4xIC5kb2MtdG1wLWRpci9tYW41IC5kb2MtdG1wLWRpci9tYW43CisjCSQoTUFLRSkgLUMgRG9jdW1lbnRhdGlvbiBERVNURElSPS4vIFwKKyMJCW1hbjFkaXI9Li4vLmRvYy10bXAtZGlyL21hbjEgXAorIwkJbWFuNWRpcj0uLi8uZG9jLXRtcC1kaXIvbWFuNSBcCisjCQltYW43ZGlyPS4uLy5kb2MtdG1wLWRpci9tYW43IFwKKyMJCWluc3RhbGwKKyMJY2QgLmRvYy10bXAtZGlyICYmICQoVEFSKSBjZiAuLi8kKG1hbnBhZ2VzKS50YXIgLgorIwlnemlwIC1uIC05IC1mICQobWFucGFnZXMpLnRhcgorIwkkKFJNKSAtciAuZG9jLXRtcC1kaXIKKyMKKyMgcnBtOiBkaXN0CisjCSQoUlBNQlVJTEQpIC10YSAkKFBFUkZfVEFSTkFNRSkudGFyLmd6CisKKyMjIyBDbGVhbmluZyBydWxlcworCitkaXN0Y2xlYW46IGNsZWFuCisjCSQoUk0pIGNvbmZpZ3VyZQorCitjbGVhbjoKKwkkKFJNKSAqLm8gKi8qLm8gJChMSUJfRklMRSkKKwkkKFJNKSAkKEFMTF9QUk9HUkFNUykgJChCVUlMVF9JTlMpIHBlcmYkWAorCSQoUk0pICQoVEVTVF9QUk9HUkFNUykKKwkkKFJNKSAqLnNwZWMgKi5weWMgKi5weW8gKi8qLnB5YyAqLyoucHlvIGNvbW1vbi1jbWRzLmggVEFHUyB0YWdzIGNzY29wZSoKKwkkKFJNKSAtciBhdXRvbTR0ZS5jYWNoZQorCSQoUk0pIGNvbmZpZy5sb2cgY29uZmlnLm1hay5hdXRvZ2VuIGNvbmZpZy5tYWsuYXBwZW5kIGNvbmZpZy5zdGF0dXMgY29uZmlnLmNhY2hlCisJJChSTSkgLXIgJChQRVJGX1RBUk5BTUUpIC5kb2MtdG1wLWRpcgorCSQoUk0pICQoUEVSRl9UQVJOQU1FKS50YXIuZ3ogcGVyZi1jb3JlXyQoUEVSRl9WRVJTSU9OKS0qLnRhci5negorCSQoUk0pICQoaHRtbGRvY3MpLnRhci5neiAkKG1hbnBhZ2VzKS50YXIuZ3oKKwkkKE1BS0UpIC1DIERvY3VtZW50YXRpb24vIGNsZWFuCisJJChSTSkgUEVSRi1WRVJTSU9OLUZJTEUgUEVSRi1DRkxBR1MgUEVSRi1CVUlMRC1PUFRJT05TCisKKy5QSE9OWTogYWxsIGluc3RhbGwgY2xlYW4gc3RyaXAKKy5QSE9OWTogc2hlbGxfY29tcGF0aWJpbGl0eV90ZXN0IHBsZWFzZV9zZXRfU0hFTExfUEFUSF90b19hX21vcmVfbW9kZXJuX3NoZWxsCisuUEhPTlk6IC5GT1JDRS1QRVJGLVZFUlNJT04tRklMRSBUQUdTIHRhZ3MgY3Njb3BlIC5GT1JDRS1QRVJGLUNGTEFHUworLlBIT05ZOiAuRk9SQ0UtUEVSRi1CVUlMRC1PUFRJT05TCisKKyMjIyBNYWtlIHN1cmUgYnVpbHQtaW5zIGRvIG5vdCBoYXZlIGR1cHMgYW5kIGxpc3RlZCBpbiBwZXJmLmMKKyMKK2NoZWNrLWJ1aWx0aW5zOjoKKwkuL2NoZWNrLWJ1aWx0aW5zLnNoCisKKyMjIyBUZXN0IHN1aXRlIGNvdmVyYWdlIHRlc3RpbmcKKyMKKyMgTm9uZSByaWdodCBub3cKKyMKKyMgLlBIT05ZOiBjb3ZlcmFnZSBjb3ZlcmFnZS1jbGVhbiBjb3ZlcmFnZS1idWlsZCBjb3ZlcmFnZS1yZXBvcnQKKyMKKyMgY292ZXJhZ2U6CisjCSQoTUFLRSkgY292ZXJhZ2UtYnVpbGQKKyMJJChNQUtFKSBjb3ZlcmFnZS1yZXBvcnQKKyMKKyMgY292ZXJhZ2UtY2xlYW46CisjCXJtIC1mICouZ2NkYSAqLmdjbm8KKyMKKyMgQ09WRVJBR0VfQ0ZMQUdTID0gJChDRkxBR1MpIC1PMCAtZnRlc3QtY292ZXJhZ2UgLWZwcm9maWxlLWFyY3MKKyMgQ09WRVJBR0VfTERGTEFHUyA9ICQoQ0ZMQUdTKSAgLU8wIC1sZ2NvdgorIworIyBjb3ZlcmFnZS1idWlsZDogY292ZXJhZ2UtY2xlYW4KKyMJJChNQUtFKSBDRkxBR1M9IiQoQ09WRVJBR0VfQ0ZMQUdTKSIgTERGTEFHUz0iJChDT1ZFUkFHRV9MREZMQUdTKSIgYWxsCisjCSQoTUFLRSkgQ0ZMQUdTPSIkKENPVkVSQUdFX0NGTEFHUykiIExERkxBR1M9IiQoQ09WRVJBR0VfTERGTEFHUykiIFwKKyMJCS1qMSB0ZXN0CisjCisjIGNvdmVyYWdlLXJlcG9ydDoKKyMJZ2NvdiAtYiAqLmMgKi8qLmMKKyMJZ3JlcCAnXmZ1bmN0aW9uLipjYWxsZWQgMCAnICouYy5nY292ICovKi5jLmdjb3YgXAorIwkJfCBzZWQgLWUgJ3MvXChbXjpdKlwpXC5nY292OiAqZnVuY3Rpb24gXChbXiBdKlwpIGNhbGxlZC4qL1wxOiBcMi8nIFwKKyMJCXwgdGVlIGNvdmVyYWdlLXVudGVzdGVkLWZ1bmN0aW9ucwpkaWZmIC0tZ2l0IGEvdG9vbHMvcGVyZi9idWlsdGluLWFubm90YXRlLmMgYi90b29scy9wZXJmL2J1aWx0aW4tYW5ub3RhdGUuYwpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi5iMWVkNWY3Ci0tLSAvZGV2L251bGwKKysrIGIvdG9vbHMvcGVyZi9idWlsdGluLWFubm90YXRlLmMKQEAgLTAsMCArMSwxMzU2IEBACisvKgorICogYnVpbHRpbi1hbm5vdGF0ZS5jCisgKgorICogQnVpbHRpbiBhbm5vdGF0ZSBjb21tYW5kOiBBbmFseXplIHRoZSBwZXJmLmRhdGEgaW5wdXQgZmlsZSwKKyAqIGxvb2sgdXAgYW5kIHJlYWQgRFNPcyBhbmQgc3ltYm9sIGluZm9ybWF0aW9uIGFuZCBkaXNwbGF5CisgKiBhIGhpc3RvZ3JhbSBvZiByZXN1bHRzLCBhbG9uZyB2YXJpb3VzIHNvcnRpbmcga2V5cy4KKyAqLworI2luY2x1ZGUgImJ1aWx0aW4uaCIKKworI2luY2x1ZGUgInV0aWwvdXRpbC5oIgorCisjaW5jbHVkZSAidXRpbC9jb2xvci5oIgorI2luY2x1ZGUgInV0aWwvbGlzdC5oIgorI2luY2x1ZGUgInV0aWwvY2FjaGUuaCIKKyNpbmNsdWRlICJ1dGlsL3JidHJlZS5oIgorI2luY2x1ZGUgInV0aWwvc3ltYm9sLmgiCisjaW5jbHVkZSAidXRpbC9zdHJpbmcuaCIKKworI2luY2x1ZGUgInBlcmYuaCIKKworI2luY2x1ZGUgInV0aWwvcGFyc2Utb3B0aW9ucy5oIgorI2luY2x1ZGUgInV0aWwvcGFyc2UtZXZlbnRzLmgiCisKKyNkZWZpbmUgU0hPV19LRVJORUwJMQorI2RlZmluZSBTSE9XX1VTRVIJMgorI2RlZmluZSBTSE9XX0hWCQk0CisKK3N0YXRpYyBjaGFyCQljb25zdCAqaW5wdXRfbmFtZSA9ICJwZXJmLmRhdGEiOworc3RhdGljIGNoYXIJCSp2bWxpbnV4ID0gInZtbGludXgiOworCitzdGF0aWMgY2hhcgkJZGVmYXVsdF9zb3J0X29yZGVyW10gPSAiY29tbSxzeW1ib2wiOworc3RhdGljIGNoYXIJCSpzb3J0X29yZGVyID0gZGVmYXVsdF9zb3J0X29yZGVyOworCitzdGF0aWMgaW50CQlpbnB1dDsKK3N0YXRpYyBpbnQJCXNob3dfbWFzayA9IFNIT1dfS0VSTkVMIHwgU0hPV19VU0VSIHwgU0hPV19IVjsKKworc3RhdGljIGludAkJZHVtcF90cmFjZSA9IDA7CisjZGVmaW5lIGRwcmludGYoeC4uLikJZG8geyBpZiAoZHVtcF90cmFjZSkgcHJpbnRmKHgpOyB9IHdoaWxlICgwKQorCitzdGF0aWMgaW50CQl2ZXJib3NlOworCitzdGF0aWMgdW5zaWduZWQgbG9uZwlwYWdlX3NpemU7CitzdGF0aWMgdW5zaWduZWQgbG9uZwltbWFwX3dpbmRvdyA9IDMyOworCitzdHJ1Y3QgaXBfZXZlbnQgeworCXN0cnVjdCBwZXJmX2V2ZW50X2hlYWRlciBoZWFkZXI7CisJX191NjQgaXA7CisJX191MzIgcGlkLCB0aWQ7Cit9OworCitzdHJ1Y3QgbW1hcF9ldmVudCB7CisJc3RydWN0IHBlcmZfZXZlbnRfaGVhZGVyIGhlYWRlcjsKKwlfX3UzMiBwaWQsIHRpZDsKKwlfX3U2NCBzdGFydDsKKwlfX3U2NCBsZW47CisJX191NjQgcGdvZmY7CisJY2hhciBmaWxlbmFtZVtQQVRIX01BWF07Cit9OworCitzdHJ1Y3QgY29tbV9ldmVudCB7CisJc3RydWN0IHBlcmZfZXZlbnRfaGVhZGVyIGhlYWRlcjsKKwlfX3UzMiBwaWQsIHRpZDsKKwljaGFyIGNvbW1bMTZdOworfTsKKworc3RydWN0IGZvcmtfZXZlbnQgeworCXN0cnVjdCBwZXJmX2V2ZW50X2hlYWRlciBoZWFkZXI7CisJX191MzIgcGlkLCBwcGlkOworfTsKKworc3RydWN0IHBlcmlvZF9ldmVudCB7CisJc3RydWN0IHBlcmZfZXZlbnRfaGVhZGVyIGhlYWRlcjsKKwlfX3U2NCB0aW1lOworCV9fdTY0IGlkOworCV9fdTY0IHNhbXBsZV9wZXJpb2Q7Cit9OworCit0eXBlZGVmIHVuaW9uIGV2ZW50X3VuaW9uIHsKKwlzdHJ1Y3QgcGVyZl9ldmVudF9oZWFkZXIJaGVhZGVyOworCXN0cnVjdCBpcF9ldmVudAkJCWlwOworCXN0cnVjdCBtbWFwX2V2ZW50CQltbWFwOworCXN0cnVjdCBjb21tX2V2ZW50CQljb21tOworCXN0cnVjdCBmb3JrX2V2ZW50CQlmb3JrOworCXN0cnVjdCBwZXJpb2RfZXZlbnQJCXBlcmlvZDsKK30gZXZlbnRfdDsKKworc3RhdGljIExJU1RfSEVBRChkc29zKTsKK3N0YXRpYyBzdHJ1Y3QgZHNvICprZXJuZWxfZHNvOworc3RhdGljIHN0cnVjdCBkc28gKnZkc287CisKKworc3RhdGljIHZvaWQgZHNvc19fYWRkKHN0cnVjdCBkc28gKmRzbykKK3sKKwlsaXN0X2FkZF90YWlsKCZkc28tPm5vZGUsICZkc29zKTsKK30KKworc3RhdGljIHN0cnVjdCBkc28gKmRzb3NfX2ZpbmQoY29uc3QgY2hhciAqbmFtZSkKK3sKKwlzdHJ1Y3QgZHNvICpwb3M7CisKKwlsaXN0X2Zvcl9lYWNoX2VudHJ5KHBvcywgJmRzb3MsIG5vZGUpCisJCWlmIChzdHJjbXAocG9zLT5uYW1lLCBuYW1lKSA9PSAwKQorCQkJcmV0dXJuIHBvczsKKwlyZXR1cm4gTlVMTDsKK30KKworc3RhdGljIHN0cnVjdCBkc28gKmRzb3NfX2ZpbmRuZXcoY29uc3QgY2hhciAqbmFtZSkKK3sKKwlzdHJ1Y3QgZHNvICpkc28gPSBkc29zX19maW5kKG5hbWUpOworCWludCBucjsKKworCWlmIChkc28pCisJCXJldHVybiBkc287CisKKwlkc28gPSBkc29fX25ldyhuYW1lLCAwKTsKKwlpZiAoIWRzbykKKwkJZ290byBvdXRfZGVsZXRlX2RzbzsKKworCW5yID0gZHNvX19sb2FkKGRzbywgTlVMTCwgdmVyYm9zZSk7CisJaWYgKG5yIDwgMCkgeworCQlpZiAodmVyYm9zZSkKKwkJCWZwcmludGYoc3RkZXJyLCAiRmFpbGVkIHRvIG9wZW46ICVzXG4iLCBuYW1lKTsKKwkJZ290byBvdXRfZGVsZXRlX2RzbzsKKwl9CisJaWYgKCFuciAmJiB2ZXJib3NlKSB7CisJCWZwcmludGYoc3RkZXJyLAorCQkiTm8gc3ltYm9scyBmb3VuZCBpbjogJXMsIG1heWJlIGluc3RhbGwgYSBkZWJ1ZyBwYWNrYWdlP1xuIiwKKwkJCQluYW1lKTsKKwl9CisKKwlkc29zX19hZGQoZHNvKTsKKworCXJldHVybiBkc287CisKK291dF9kZWxldGVfZHNvOgorCWRzb19fZGVsZXRlKGRzbyk7CisJcmV0dXJuIE5VTEw7Cit9CisKK3N0YXRpYyB2b2lkIGRzb3NfX2ZwcmludGYoRklMRSAqZnApCit7CisJc3RydWN0IGRzbyAqcG9zOworCisJbGlzdF9mb3JfZWFjaF9lbnRyeShwb3MsICZkc29zLCBub2RlKQorCQlkc29fX2ZwcmludGYocG9zLCBmcCk7Cit9CisKK3N0YXRpYyBzdHJ1Y3Qgc3ltYm9sICp2ZHNvX19maW5kX3N5bWJvbChzdHJ1Y3QgZHNvICpkc28sIF9fdTY0IGlwKQoreworCXJldHVybiBkc29fX2ZpbmRfc3ltYm9sKGtlcm5lbF9kc28sIGlwKTsKK30KKworc3RhdGljIGludCBsb2FkX2tlcm5lbCh2b2lkKQoreworCWludCBlcnI7CisKKwlrZXJuZWxfZHNvID0gZHNvX19uZXcoIltrZXJuZWxdIiwgMCk7CisJaWYgKCFrZXJuZWxfZHNvKQorCQlyZXR1cm4gLTE7CisKKwllcnIgPSBkc29fX2xvYWRfa2VybmVsKGtlcm5lbF9kc28sIHZtbGludXgsIE5VTEwsIHZlcmJvc2UpOworCWlmIChlcnIpIHsKKwkJZHNvX19kZWxldGUoa2VybmVsX2Rzbyk7CisJCWtlcm5lbF9kc28gPSBOVUxMOworCX0gZWxzZQorCQlkc29zX19hZGQoa2VybmVsX2Rzbyk7CisKKwl2ZHNvID0gZHNvX19uZXcoIlt2ZHNvXSIsIDApOworCWlmICghdmRzbykKKwkJcmV0dXJuIC0xOworCisJdmRzby0+ZmluZF9zeW1ib2wgPSB2ZHNvX19maW5kX3N5bWJvbDsKKworCWRzb3NfX2FkZCh2ZHNvKTsKKworCXJldHVybiBlcnI7Cit9CisKK3N0cnVjdCBtYXAgeworCXN0cnVjdCBsaXN0X2hlYWQgbm9kZTsKKwlfX3U2NAkgc3RhcnQ7CisJX191NjQJIGVuZDsKKwlfX3U2NAkgcGdvZmY7CisJX191NjQJICgqbWFwX2lwKShzdHJ1Y3QgbWFwICosIF9fdTY0KTsKKwlzdHJ1Y3QgZHNvCSAqZHNvOworfTsKKworc3RhdGljIF9fdTY0IG1hcF9fbWFwX2lwKHN0cnVjdCBtYXAgKm1hcCwgX191NjQgaXApCit7CisJcmV0dXJuIGlwIC0gbWFwLT5zdGFydCArIG1hcC0+cGdvZmY7Cit9CisKK3N0YXRpYyBfX3U2NCB2ZHNvX19tYXBfaXAoc3RydWN0IG1hcCAqbWFwLCBfX3U2NCBpcCkKK3sKKwlyZXR1cm4gaXA7Cit9CisKK3N0YXRpYyBzdHJ1Y3QgbWFwICptYXBfX25ldyhzdHJ1Y3QgbW1hcF9ldmVudCAqZXZlbnQpCit7CisJc3RydWN0IG1hcCAqc2VsZiA9IG1hbGxvYyhzaXplb2YoKnNlbGYpKTsKKworCWlmIChzZWxmICE9IE5VTEwpIHsKKwkJY29uc3QgY2hhciAqZmlsZW5hbWUgPSBldmVudC0+ZmlsZW5hbWU7CisKKwkJc2VsZi0+c3RhcnQgPSBldmVudC0+c3RhcnQ7CisJCXNlbGYtPmVuZCAgID0gZXZlbnQtPnN0YXJ0ICsgZXZlbnQtPmxlbjsKKwkJc2VsZi0+cGdvZmYgPSBldmVudC0+cGdvZmY7CisKKwkJc2VsZi0+ZHNvID0gZHNvc19fZmluZG5ldyhmaWxlbmFtZSk7CisJCWlmIChzZWxmLT5kc28gPT0gTlVMTCkKKwkJCWdvdG8gb3V0X2RlbGV0ZTsKKworCQlpZiAoc2VsZi0+ZHNvID09IHZkc28pCisJCQlzZWxmLT5tYXBfaXAgPSB2ZHNvX19tYXBfaXA7CisJCWVsc2UKKwkJCXNlbGYtPm1hcF9pcCA9IG1hcF9fbWFwX2lwOworCX0KKwlyZXR1cm4gc2VsZjsKK291dF9kZWxldGU6CisJZnJlZShzZWxmKTsKKwlyZXR1cm4gTlVMTDsKK30KKworc3RhdGljIHN0cnVjdCBtYXAgKm1hcF9fY2xvbmUoc3RydWN0IG1hcCAqc2VsZikKK3sKKwlzdHJ1Y3QgbWFwICptYXAgPSBtYWxsb2Moc2l6ZW9mKCpzZWxmKSk7CisKKwlpZiAoIW1hcCkKKwkJcmV0dXJuIE5VTEw7CisKKwltZW1jcHkobWFwLCBzZWxmLCBzaXplb2YoKnNlbGYpKTsKKworCXJldHVybiBtYXA7Cit9CisKK3N0YXRpYyBpbnQgbWFwX19vdmVybGFwKHN0cnVjdCBtYXAgKmwsIHN0cnVjdCBtYXAgKnIpCit7CisJaWYgKGwtPnN0YXJ0ID4gci0+c3RhcnQpIHsKKwkJc3RydWN0IG1hcCAqdCA9IGw7CisJCWwgPSByOworCQlyID0gdDsKKwl9CisKKwlpZiAobC0+ZW5kID4gci0+c3RhcnQpCisJCXJldHVybiAxOworCisJcmV0dXJuIDA7Cit9CisKK3N0YXRpYyBzaXplX3QgbWFwX19mcHJpbnRmKHN0cnVjdCBtYXAgKnNlbGYsIEZJTEUgKmZwKQoreworCXJldHVybiBmcHJpbnRmKGZwLCAiICVMeC0lTHggJUx4ICVzXG4iLAorCQkgICAgICAgc2VsZi0+c3RhcnQsIHNlbGYtPmVuZCwgc2VsZi0+cGdvZmYsIHNlbGYtPmRzby0+bmFtZSk7Cit9CisKKworc3RydWN0IHRocmVhZCB7CisJc3RydWN0IHJiX25vZGUJIHJiX25vZGU7CisJc3RydWN0IGxpc3RfaGVhZCBtYXBzOworCXBpZF90CQkgcGlkOworCWNoYXIJCSAqY29tbTsKK307CisKK3N0YXRpYyBzdHJ1Y3QgdGhyZWFkICp0aHJlYWRfX25ldyhwaWRfdCBwaWQpCit7CisJc3RydWN0IHRocmVhZCAqc2VsZiA9IG1hbGxvYyhzaXplb2YoKnNlbGYpKTsKKworCWlmIChzZWxmICE9IE5VTEwpIHsKKwkJc2VsZi0+cGlkID0gcGlkOworCQlzZWxmLT5jb21tID0gbWFsbG9jKDMyKTsKKwkJaWYgKHNlbGYtPmNvbW0pCisJCQlzbnByaW50ZihzZWxmLT5jb21tLCAzMiwgIjolZCIsIHNlbGYtPnBpZCk7CisJCUlOSVRfTElTVF9IRUFEKCZzZWxmLT5tYXBzKTsKKwl9CisKKwlyZXR1cm4gc2VsZjsKK30KKworc3RhdGljIGludCB0aHJlYWRfX3NldF9jb21tKHN0cnVjdCB0aHJlYWQgKnNlbGYsIGNvbnN0IGNoYXIgKmNvbW0pCit7CisJaWYgKHNlbGYtPmNvbW0pCisJCWZyZWUoc2VsZi0+Y29tbSk7CisJc2VsZi0+Y29tbSA9IHN0cmR1cChjb21tKTsKKwlyZXR1cm4gc2VsZi0+Y29tbSA/IDAgOiAtRU5PTUVNOworfQorCitzdGF0aWMgc2l6ZV90IHRocmVhZF9fZnByaW50ZihzdHJ1Y3QgdGhyZWFkICpzZWxmLCBGSUxFICpmcCkKK3sKKwlzdHJ1Y3QgbWFwICpwb3M7CisJc2l6ZV90IHJldCA9IGZwcmludGYoZnAsICJUaHJlYWQgJWQgJXNcbiIsIHNlbGYtPnBpZCwgc2VsZi0+Y29tbSk7CisKKwlsaXN0X2Zvcl9lYWNoX2VudHJ5KHBvcywgJnNlbGYtPm1hcHMsIG5vZGUpCisJCXJldCArPSBtYXBfX2ZwcmludGYocG9zLCBmcCk7CisKKwlyZXR1cm4gcmV0OworfQorCisKK3N0YXRpYyBzdHJ1Y3QgcmJfcm9vdCB0aHJlYWRzOworc3RhdGljIHN0cnVjdCB0aHJlYWQgKmxhc3RfbWF0Y2g7CisKK3N0YXRpYyBzdHJ1Y3QgdGhyZWFkICp0aHJlYWRzX19maW5kbmV3KHBpZF90IHBpZCkKK3sKKwlzdHJ1Y3QgcmJfbm9kZSAqKnAgPSAmdGhyZWFkcy5yYl9ub2RlOworCXN0cnVjdCByYl9ub2RlICpwYXJlbnQgPSBOVUxMOworCXN0cnVjdCB0aHJlYWQgKnRoOworCisJLyoKKwkgKiBGb250LWVuZCBjYWNoZSAtIFBJRCBsb29rdXBzIGNvbWUgaW4gYmxvY2tzLAorCSAqIHNvIG1vc3Qgb2YgdGhlIHRpbWUgd2UgZG9udCBoYXZlIHRvIGxvb2sgdXAKKwkgKiB0aGUgZnVsbCByYnRyZWU6CisJICovCisJaWYgKGxhc3RfbWF0Y2ggJiYgbGFzdF9tYXRjaC0+cGlkID09IHBpZCkKKwkJcmV0dXJuIGxhc3RfbWF0Y2g7CisKKwl3aGlsZSAoKnAgIT0gTlVMTCkgeworCQlwYXJlbnQgPSAqcDsKKwkJdGggPSByYl9lbnRyeShwYXJlbnQsIHN0cnVjdCB0aHJlYWQsIHJiX25vZGUpOworCisJCWlmICh0aC0+cGlkID09IHBpZCkgeworCQkJbGFzdF9tYXRjaCA9IHRoOworCQkJcmV0dXJuIHRoOworCQl9CisKKwkJaWYgKHBpZCA8IHRoLT5waWQpCisJCQlwID0gJigqcCktPnJiX2xlZnQ7CisJCWVsc2UKKwkJCXAgPSAmKCpwKS0+cmJfcmlnaHQ7CisJfQorCisJdGggPSB0aHJlYWRfX25ldyhwaWQpOworCWlmICh0aCAhPSBOVUxMKSB7CisJCXJiX2xpbmtfbm9kZSgmdGgtPnJiX25vZGUsIHBhcmVudCwgcCk7CisJCXJiX2luc2VydF9jb2xvcigmdGgtPnJiX25vZGUsICZ0aHJlYWRzKTsKKwkJbGFzdF9tYXRjaCA9IHRoOworCX0KKworCXJldHVybiB0aDsKK30KKworc3RhdGljIHZvaWQgdGhyZWFkX19pbnNlcnRfbWFwKHN0cnVjdCB0aHJlYWQgKnNlbGYsIHN0cnVjdCBtYXAgKm1hcCkKK3sKKwlzdHJ1Y3QgbWFwICpwb3MsICp0bXA7CisKKwlsaXN0X2Zvcl9lYWNoX2VudHJ5X3NhZmUocG9zLCB0bXAsICZzZWxmLT5tYXBzLCBub2RlKSB7CisJCWlmIChtYXBfX292ZXJsYXAocG9zLCBtYXApKSB7CisJCQlsaXN0X2RlbF9pbml0KCZwb3MtPm5vZGUpOworCQkJLyogWFhYIGxlYWtzIGRzb3MgKi8KKwkJCWZyZWUocG9zKTsKKwkJfQorCX0KKworCWxpc3RfYWRkX3RhaWwoJm1hcC0+bm9kZSwgJnNlbGYtPm1hcHMpOworfQorCitzdGF0aWMgaW50IHRocmVhZF9fZm9yayhzdHJ1Y3QgdGhyZWFkICpzZWxmLCBzdHJ1Y3QgdGhyZWFkICpwYXJlbnQpCit7CisJc3RydWN0IG1hcCAqbWFwOworCisJaWYgKHNlbGYtPmNvbW0pCisJCWZyZWUoc2VsZi0+Y29tbSk7CisJc2VsZi0+Y29tbSA9IHN0cmR1cChwYXJlbnQtPmNvbW0pOworCWlmICghc2VsZi0+Y29tbSkKKwkJcmV0dXJuIC1FTk9NRU07CisKKwlsaXN0X2Zvcl9lYWNoX2VudHJ5KG1hcCwgJnBhcmVudC0+bWFwcywgbm9kZSkgeworCQlzdHJ1Y3QgbWFwICpuZXcgPSBtYXBfX2Nsb25lKG1hcCk7CisJCWlmICghbmV3KQorCQkJcmV0dXJuIC1FTk9NRU07CisJCXRocmVhZF9faW5zZXJ0X21hcChzZWxmLCBuZXcpOworCX0KKworCXJldHVybiAwOworfQorCitzdGF0aWMgc3RydWN0IG1hcCAqdGhyZWFkX19maW5kX21hcChzdHJ1Y3QgdGhyZWFkICpzZWxmLCBfX3U2NCBpcCkKK3sKKwlzdHJ1Y3QgbWFwICpwb3M7CisKKwlpZiAoc2VsZiA9PSBOVUxMKQorCQlyZXR1cm4gTlVMTDsKKworCWxpc3RfZm9yX2VhY2hfZW50cnkocG9zLCAmc2VsZi0+bWFwcywgbm9kZSkKKwkJaWYgKGlwID49IHBvcy0+c3RhcnQgJiYgaXAgPD0gcG9zLT5lbmQpCisJCQlyZXR1cm4gcG9zOworCisJcmV0dXJuIE5VTEw7Cit9CisKK3N0YXRpYyBzaXplX3QgdGhyZWFkc19fZnByaW50ZihGSUxFICpmcCkKK3sKKwlzaXplX3QgcmV0ID0gMDsKKwlzdHJ1Y3QgcmJfbm9kZSAqbmQ7CisKKwlmb3IgKG5kID0gcmJfZmlyc3QoJnRocmVhZHMpOyBuZDsgbmQgPSByYl9uZXh0KG5kKSkgeworCQlzdHJ1Y3QgdGhyZWFkICpwb3MgPSByYl9lbnRyeShuZCwgc3RydWN0IHRocmVhZCwgcmJfbm9kZSk7CisKKwkJcmV0ICs9IHRocmVhZF9fZnByaW50Zihwb3MsIGZwKTsKKwl9CisKKwlyZXR1cm4gcmV0OworfQorCisvKgorICogaGlzdG9ncmFtLCBzb3J0ZWQgb24gaXRlbSwgY29sbGVjdHMgY291bnRzCisgKi8KKworc3RhdGljIHN0cnVjdCByYl9yb290IGhpc3Q7CisKK3N0cnVjdCBoaXN0X2VudHJ5IHsKKwlzdHJ1Y3QgcmJfbm9kZQkgcmJfbm9kZTsKKworCXN0cnVjdCB0aHJlYWQJICp0aHJlYWQ7CisJc3RydWN0IG1hcAkgKm1hcDsKKwlzdHJ1Y3QgZHNvCSAqZHNvOworCXN0cnVjdCBzeW1ib2wJICpzeW07CisJX191NjQJIGlwOworCWNoYXIJCSBsZXZlbDsKKworCXVpbnQzMl90CSBjb3VudDsKK307CisKKy8qCisgKiBjb25maWd1cmFibGUgc29ydGluZyBiaXRzCisgKi8KKworc3RydWN0IHNvcnRfZW50cnkgeworCXN0cnVjdCBsaXN0X2hlYWQgbGlzdDsKKworCWNoYXIgKmhlYWRlcjsKKworCWludDY0X3QgKCpjbXApKHN0cnVjdCBoaXN0X2VudHJ5ICosIHN0cnVjdCBoaXN0X2VudHJ5ICopOworCWludDY0X3QgKCpjb2xsYXBzZSkoc3RydWN0IGhpc3RfZW50cnkgKiwgc3RydWN0IGhpc3RfZW50cnkgKik7CisJc2l6ZV90CSgqcHJpbnQpKEZJTEUgKmZwLCBzdHJ1Y3QgaGlzdF9lbnRyeSAqKTsKK307CisKKy8qIC0tc29ydCBwaWQgKi8KKworc3RhdGljIGludDY0X3QKK3NvcnRfX3RocmVhZF9jbXAoc3RydWN0IGhpc3RfZW50cnkgKmxlZnQsIHN0cnVjdCBoaXN0X2VudHJ5ICpyaWdodCkKK3sKKwlyZXR1cm4gcmlnaHQtPnRocmVhZC0+cGlkIC0gbGVmdC0+dGhyZWFkLT5waWQ7Cit9CisKK3N0YXRpYyBzaXplX3QKK3NvcnRfX3RocmVhZF9wcmludChGSUxFICpmcCwgc3RydWN0IGhpc3RfZW50cnkgKnNlbGYpCit7CisJcmV0dXJuIGZwcmludGYoZnAsICIlMTZzOiU1ZCIsIHNlbGYtPnRocmVhZC0+Y29tbSA/OiAiIiwgc2VsZi0+dGhyZWFkLT5waWQpOworfQorCitzdGF0aWMgc3RydWN0IHNvcnRfZW50cnkgc29ydF90aHJlYWQgPSB7CisJLmhlYWRlciA9ICIgICAgICAgICBDb21tYW5kOiAgUGlkIiwKKwkuY21wCT0gc29ydF9fdGhyZWFkX2NtcCwKKwkucHJpbnQJPSBzb3J0X190aHJlYWRfcHJpbnQsCit9OworCisvKiAtLXNvcnQgY29tbSAqLworCitzdGF0aWMgaW50NjRfdAorc29ydF9fY29tbV9jbXAoc3RydWN0IGhpc3RfZW50cnkgKmxlZnQsIHN0cnVjdCBoaXN0X2VudHJ5ICpyaWdodCkKK3sKKwlyZXR1cm4gcmlnaHQtPnRocmVhZC0+cGlkIC0gbGVmdC0+dGhyZWFkLT5waWQ7Cit9CisKK3N0YXRpYyBpbnQ2NF90Citzb3J0X19jb21tX2NvbGxhcHNlKHN0cnVjdCBoaXN0X2VudHJ5ICpsZWZ0LCBzdHJ1Y3QgaGlzdF9lbnRyeSAqcmlnaHQpCit7CisJY2hhciAqY29tbV9sID0gbGVmdC0+dGhyZWFkLT5jb21tOworCWNoYXIgKmNvbW1fciA9IHJpZ2h0LT50aHJlYWQtPmNvbW07CisKKwlpZiAoIWNvbW1fbCB8fCAhY29tbV9yKSB7CisJCWlmICghY29tbV9sICYmICFjb21tX3IpCisJCQlyZXR1cm4gMDsKKwkJZWxzZSBpZiAoIWNvbW1fbCkKKwkJCXJldHVybiAtMTsKKwkJZWxzZQorCQkJcmV0dXJuIDE7CisJfQorCisJcmV0dXJuIHN0cmNtcChjb21tX2wsIGNvbW1fcik7Cit9CisKK3N0YXRpYyBzaXplX3QKK3NvcnRfX2NvbW1fcHJpbnQoRklMRSAqZnAsIHN0cnVjdCBoaXN0X2VudHJ5ICpzZWxmKQoreworCXJldHVybiBmcHJpbnRmKGZwLCAiJTE2cyIsIHNlbGYtPnRocmVhZC0+Y29tbSk7Cit9CisKK3N0YXRpYyBzdHJ1Y3Qgc29ydF9lbnRyeSBzb3J0X2NvbW0gPSB7CisJLmhlYWRlcgkJPSAiICAgICAgICAgQ29tbWFuZCIsCisJLmNtcAkJPSBzb3J0X19jb21tX2NtcCwKKwkuY29sbGFwc2UJPSBzb3J0X19jb21tX2NvbGxhcHNlLAorCS5wcmludAkJPSBzb3J0X19jb21tX3ByaW50LAorfTsKKworLyogLS1zb3J0IGRzbyAqLworCitzdGF0aWMgaW50NjRfdAorc29ydF9fZHNvX2NtcChzdHJ1Y3QgaGlzdF9lbnRyeSAqbGVmdCwgc3RydWN0IGhpc3RfZW50cnkgKnJpZ2h0KQoreworCXN0cnVjdCBkc28gKmRzb19sID0gbGVmdC0+ZHNvOworCXN0cnVjdCBkc28gKmRzb19yID0gcmlnaHQtPmRzbzsKKworCWlmICghZHNvX2wgfHwgIWRzb19yKSB7CisJCWlmICghZHNvX2wgJiYgIWRzb19yKQorCQkJcmV0dXJuIDA7CisJCWVsc2UgaWYgKCFkc29fbCkKKwkJCXJldHVybiAtMTsKKwkJZWxzZQorCQkJcmV0dXJuIDE7CisJfQorCisJcmV0dXJuIHN0cmNtcChkc29fbC0+bmFtZSwgZHNvX3ItPm5hbWUpOworfQorCitzdGF0aWMgc2l6ZV90Citzb3J0X19kc29fcHJpbnQoRklMRSAqZnAsIHN0cnVjdCBoaXN0X2VudHJ5ICpzZWxmKQoreworCWlmIChzZWxmLT5kc28pCisJCXJldHVybiBmcHJpbnRmKGZwLCAiJS0yNXMiLCBzZWxmLT5kc28tPm5hbWUpOworCisJcmV0dXJuIGZwcmludGYoZnAsICIlMDE2bGx4ICAgICAgICAgIiwgKF9fdTY0KXNlbGYtPmlwKTsKK30KKworc3RhdGljIHN0cnVjdCBzb3J0X2VudHJ5IHNvcnRfZHNvID0geworCS5oZWFkZXIgPSAiU2hhcmVkIE9iamVjdCAgICAgICAgICAgICIsCisJLmNtcAk9IHNvcnRfX2Rzb19jbXAsCisJLnByaW50CT0gc29ydF9fZHNvX3ByaW50LAorfTsKKworLyogLS1zb3J0IHN5bWJvbCAqLworCitzdGF0aWMgaW50NjRfdAorc29ydF9fc3ltX2NtcChzdHJ1Y3QgaGlzdF9lbnRyeSAqbGVmdCwgc3RydWN0IGhpc3RfZW50cnkgKnJpZ2h0KQoreworCV9fdTY0IGlwX2wsIGlwX3I7CisKKwlpZiAobGVmdC0+c3ltID09IHJpZ2h0LT5zeW0pCisJCXJldHVybiAwOworCisJaXBfbCA9IGxlZnQtPnN5bSA/IGxlZnQtPnN5bS0+c3RhcnQgOiBsZWZ0LT5pcDsKKwlpcF9yID0gcmlnaHQtPnN5bSA/IHJpZ2h0LT5zeW0tPnN0YXJ0IDogcmlnaHQtPmlwOworCisJcmV0dXJuIChpbnQ2NF90KShpcF9yIC0gaXBfbCk7Cit9CisKK3N0YXRpYyBzaXplX3QKK3NvcnRfX3N5bV9wcmludChGSUxFICpmcCwgc3RydWN0IGhpc3RfZW50cnkgKnNlbGYpCit7CisJc2l6ZV90IHJldCA9IDA7CisKKwlpZiAodmVyYm9zZSkKKwkJcmV0ICs9IGZwcmludGYoZnAsICIlIzAxOGxseCAgIiwgKF9fdTY0KXNlbGYtPmlwKTsKKworCWlmIChzZWxmLT5zeW0pIHsKKwkJcmV0ICs9IGZwcmludGYoZnAsICJbJWNdICVzIiwKKwkJCXNlbGYtPmRzbyA9PSBrZXJuZWxfZHNvID8gJ2snIDogJy4nLCBzZWxmLT5zeW0tPm5hbWUpOworCX0gZWxzZSB7CisJCXJldCArPSBmcHJpbnRmKGZwLCAiJSMwMTZsbHgiLCAoX191NjQpc2VsZi0+aXApOworCX0KKworCXJldHVybiByZXQ7Cit9CisKK3N0YXRpYyBzdHJ1Y3Qgc29ydF9lbnRyeSBzb3J0X3N5bSA9IHsKKwkuaGVhZGVyID0gIlN5bWJvbCIsCisJLmNtcAk9IHNvcnRfX3N5bV9jbXAsCisJLnByaW50CT0gc29ydF9fc3ltX3ByaW50LAorfTsKKworc3RhdGljIGludCBzb3J0X19uZWVkX2NvbGxhcHNlID0gMDsKKworc3RydWN0IHNvcnRfZGltZW5zaW9uIHsKKwljaGFyCQkJKm5hbWU7CisJc3RydWN0IHNvcnRfZW50cnkJKmVudHJ5OworCWludAkJCXRha2VuOworfTsKKworc3RhdGljIHN0cnVjdCBzb3J0X2RpbWVuc2lvbiBzb3J0X2RpbWVuc2lvbnNbXSA9IHsKKwl7IC5uYW1lID0gInBpZCIsCS5lbnRyeSA9ICZzb3J0X3RocmVhZCwJfSwKKwl7IC5uYW1lID0gImNvbW0iLAkuZW50cnkgPSAmc29ydF9jb21tLAl9LAorCXsgLm5hbWUgPSAiZHNvIiwJLmVudHJ5ID0gJnNvcnRfZHNvLAl9LAorCXsgLm5hbWUgPSAic3ltYm9sIiwJLmVudHJ5ID0gJnNvcnRfc3ltLAl9LAorfTsKKworc3RhdGljIExJU1RfSEVBRChoaXN0X2VudHJ5X19zb3J0X2xpc3QpOworCitzdGF0aWMgaW50IHNvcnRfZGltZW5zaW9uX19hZGQoY2hhciAqdG9rKQoreworCWludCBpOworCisJZm9yIChpID0gMDsgaSA8IEFSUkFZX1NJWkUoc29ydF9kaW1lbnNpb25zKTsgaSsrKSB7CisJCXN0cnVjdCBzb3J0X2RpbWVuc2lvbiAqc2QgPSAmc29ydF9kaW1lbnNpb25zW2ldOworCisJCWlmIChzZC0+dGFrZW4pCisJCQljb250aW51ZTsKKworCQlpZiAoc3RybmNhc2VjbXAodG9rLCBzZC0+bmFtZSwgc3RybGVuKHRvaykpKQorCQkJY29udGludWU7CisKKwkJaWYgKHNkLT5lbnRyeS0+Y29sbGFwc2UpCisJCQlzb3J0X19uZWVkX2NvbGxhcHNlID0gMTsKKworCQlsaXN0X2FkZF90YWlsKCZzZC0+ZW50cnktPmxpc3QsICZoaXN0X2VudHJ5X19zb3J0X2xpc3QpOworCQlzZC0+dGFrZW4gPSAxOworCisJCXJldHVybiAwOworCX0KKworCXJldHVybiAtRVNSQ0g7Cit9CisKK3N0YXRpYyBpbnQ2NF90CitoaXN0X2VudHJ5X19jbXAoc3RydWN0IGhpc3RfZW50cnkgKmxlZnQsIHN0cnVjdCBoaXN0X2VudHJ5ICpyaWdodCkKK3sKKwlzdHJ1Y3Qgc29ydF9lbnRyeSAqc2U7CisJaW50NjRfdCBjbXAgPSAwOworCisJbGlzdF9mb3JfZWFjaF9lbnRyeShzZSwgJmhpc3RfZW50cnlfX3NvcnRfbGlzdCwgbGlzdCkgeworCQljbXAgPSBzZS0+Y21wKGxlZnQsIHJpZ2h0KTsKKwkJaWYgKGNtcCkKKwkJCWJyZWFrOworCX0KKworCXJldHVybiBjbXA7Cit9CisKK3N0YXRpYyBpbnQ2NF90CitoaXN0X2VudHJ5X19jb2xsYXBzZShzdHJ1Y3QgaGlzdF9lbnRyeSAqbGVmdCwgc3RydWN0IGhpc3RfZW50cnkgKnJpZ2h0KQoreworCXN0cnVjdCBzb3J0X2VudHJ5ICpzZTsKKwlpbnQ2NF90IGNtcCA9IDA7CisKKwlsaXN0X2Zvcl9lYWNoX2VudHJ5KHNlLCAmaGlzdF9lbnRyeV9fc29ydF9saXN0LCBsaXN0KSB7CisJCWludDY0X3QgKCpmKShzdHJ1Y3QgaGlzdF9lbnRyeSAqLCBzdHJ1Y3QgaGlzdF9lbnRyeSAqKTsKKworCQlmID0gc2UtPmNvbGxhcHNlID86IHNlLT5jbXA7CisKKwkJY21wID0gZihsZWZ0LCByaWdodCk7CisJCWlmIChjbXApCisJCQlicmVhazsKKwl9CisKKwlyZXR1cm4gY21wOworfQorCisvKgorICogY29sbGVjdCBoaXN0b2dyYW0gY291bnRzCisgKi8KK3N0YXRpYyB2b2lkIGhpc3RfaGl0KHN0cnVjdCBoaXN0X2VudHJ5ICpoZSwgX191NjQgaXApCit7CisJdW5zaWduZWQgaW50IHN5bV9zaXplLCBvZmZzZXQ7CisJc3RydWN0IHN5bWJvbCAqc3ltID0gaGUtPnN5bTsKKworCWhlLT5jb3VudCsrOworCisJaWYgKCFzeW0gfHwgIXN5bS0+aGlzdCkKKwkJcmV0dXJuOworCisJc3ltX3NpemUgPSBzeW0tPmVuZCAtIHN5bS0+c3RhcnQ7CisJb2Zmc2V0ID0gaXAgLSBzeW0tPnN0YXJ0OworCisJaWYgKG9mZnNldCA+PSBzeW1fc2l6ZSkKKwkJcmV0dXJuOworCisJc3ltLT5oaXN0X3N1bSsrOworCXN5bS0+aGlzdFtvZmZzZXRdKys7CisKKwlpZiAodmVyYm9zZSA+PSAzKQorCQlwcmludGYoIiVwICVzOiBjb3VudCsrIFtpcDogJXAsICUwOEx4XSA9PiAlTGRcbiIsCisJCQkodm9pZCAqKSh1bnNpZ25lZCBsb25nKWhlLT5zeW0tPnN0YXJ0LAorCQkJaGUtPnN5bS0+bmFtZSwKKwkJCSh2b2lkICopKHVuc2lnbmVkIGxvbmcpaXAsIGlwIC0gaGUtPnN5bS0+c3RhcnQsCisJCQlzeW0tPmhpc3Rbb2Zmc2V0XSk7Cit9CisKK3N0YXRpYyBpbnQKK2hpc3RfZW50cnlfX2FkZChzdHJ1Y3QgdGhyZWFkICp0aHJlYWQsIHN0cnVjdCBtYXAgKm1hcCwgc3RydWN0IGRzbyAqZHNvLAorCQlzdHJ1Y3Qgc3ltYm9sICpzeW0sIF9fdTY0IGlwLCBjaGFyIGxldmVsKQoreworCXN0cnVjdCByYl9ub2RlICoqcCA9ICZoaXN0LnJiX25vZGU7CisJc3RydWN0IHJiX25vZGUgKnBhcmVudCA9IE5VTEw7CisJc3RydWN0IGhpc3RfZW50cnkgKmhlOworCXN0cnVjdCBoaXN0X2VudHJ5IGVudHJ5ID0geworCQkudGhyZWFkCT0gdGhyZWFkLAorCQkubWFwCT0gbWFwLAorCQkuZHNvCT0gZHNvLAorCQkuc3ltCT0gc3ltLAorCQkuaXAJPSBpcCwKKwkJLmxldmVsCT0gbGV2ZWwsCisJCS5jb3VudAk9IDEsCisJfTsKKwlpbnQgY21wOworCisJd2hpbGUgKCpwICE9IE5VTEwpIHsKKwkJcGFyZW50ID0gKnA7CisJCWhlID0gcmJfZW50cnkocGFyZW50LCBzdHJ1Y3QgaGlzdF9lbnRyeSwgcmJfbm9kZSk7CisKKwkJY21wID0gaGlzdF9lbnRyeV9fY21wKCZlbnRyeSwgaGUpOworCisJCWlmICghY21wKSB7CisJCQloaXN0X2hpdChoZSwgaXApOworCisJCQlyZXR1cm4gMDsKKwkJfQorCisJCWlmIChjbXAgPCAwKQorCQkJcCA9ICYoKnApLT5yYl9sZWZ0OworCQllbHNlCisJCQlwID0gJigqcCktPnJiX3JpZ2h0OworCX0KKworCWhlID0gbWFsbG9jKHNpemVvZigqaGUpKTsKKwlpZiAoIWhlKQorCQlyZXR1cm4gLUVOT01FTTsKKwkqaGUgPSBlbnRyeTsKKwlyYl9saW5rX25vZGUoJmhlLT5yYl9ub2RlLCBwYXJlbnQsIHApOworCXJiX2luc2VydF9jb2xvcigmaGUtPnJiX25vZGUsICZoaXN0KTsKKworCXJldHVybiAwOworfQorCitzdGF0aWMgdm9pZCBoaXN0X2VudHJ5X19mcmVlKHN0cnVjdCBoaXN0X2VudHJ5ICpoZSkKK3sKKwlmcmVlKGhlKTsKK30KKworLyoKKyAqIGNvbGxhcHNlIHRoZSBoaXN0b2dyYW0KKyAqLworCitzdGF0aWMgc3RydWN0IHJiX3Jvb3QgY29sbGFwc2VfaGlzdHM7CisKK3N0YXRpYyB2b2lkIGNvbGxhcHNlX19pbnNlcnRfZW50cnkoc3RydWN0IGhpc3RfZW50cnkgKmhlKQoreworCXN0cnVjdCByYl9ub2RlICoqcCA9ICZjb2xsYXBzZV9oaXN0cy5yYl9ub2RlOworCXN0cnVjdCByYl9ub2RlICpwYXJlbnQgPSBOVUxMOworCXN0cnVjdCBoaXN0X2VudHJ5ICppdGVyOworCWludDY0X3QgY21wOworCisJd2hpbGUgKCpwICE9IE5VTEwpIHsKKwkJcGFyZW50ID0gKnA7CisJCWl0ZXIgPSByYl9lbnRyeShwYXJlbnQsIHN0cnVjdCBoaXN0X2VudHJ5LCByYl9ub2RlKTsKKworCQljbXAgPSBoaXN0X2VudHJ5X19jb2xsYXBzZShpdGVyLCBoZSk7CisKKwkJaWYgKCFjbXApIHsKKwkJCWl0ZXItPmNvdW50ICs9IGhlLT5jb3VudDsKKwkJCWhpc3RfZW50cnlfX2ZyZWUoaGUpOworCQkJcmV0dXJuOworCQl9CisKKwkJaWYgKGNtcCA8IDApCisJCQlwID0gJigqcCktPnJiX2xlZnQ7CisJCWVsc2UKKwkJCXAgPSAmKCpwKS0+cmJfcmlnaHQ7CisJfQorCisJcmJfbGlua19ub2RlKCZoZS0+cmJfbm9kZSwgcGFyZW50LCBwKTsKKwlyYl9pbnNlcnRfY29sb3IoJmhlLT5yYl9ub2RlLCAmY29sbGFwc2VfaGlzdHMpOworfQorCitzdGF0aWMgdm9pZCBjb2xsYXBzZV9fcmVzb3J0KHZvaWQpCit7CisJc3RydWN0IHJiX25vZGUgKm5leHQ7CisJc3RydWN0IGhpc3RfZW50cnkgKm47CisKKwlpZiAoIXNvcnRfX25lZWRfY29sbGFwc2UpCisJCXJldHVybjsKKworCW5leHQgPSByYl9maXJzdCgmaGlzdCk7CisJd2hpbGUgKG5leHQpIHsKKwkJbiA9IHJiX2VudHJ5KG5leHQsIHN0cnVjdCBoaXN0X2VudHJ5LCByYl9ub2RlKTsKKwkJbmV4dCA9IHJiX25leHQoJm4tPnJiX25vZGUpOworCisJCXJiX2VyYXNlKCZuLT5yYl9ub2RlLCAmaGlzdCk7CisJCWNvbGxhcHNlX19pbnNlcnRfZW50cnkobik7CisJfQorfQorCisvKgorICogcmV2ZXJzZSB0aGUgbWFwLCBzb3J0IG9uIGNvdW50LgorICovCisKK3N0YXRpYyBzdHJ1Y3QgcmJfcm9vdCBvdXRwdXRfaGlzdHM7CisKK3N0YXRpYyB2b2lkIG91dHB1dF9faW5zZXJ0X2VudHJ5KHN0cnVjdCBoaXN0X2VudHJ5ICpoZSkKK3sKKwlzdHJ1Y3QgcmJfbm9kZSAqKnAgPSAmb3V0cHV0X2hpc3RzLnJiX25vZGU7CisJc3RydWN0IHJiX25vZGUgKnBhcmVudCA9IE5VTEw7CisJc3RydWN0IGhpc3RfZW50cnkgKml0ZXI7CisKKwl3aGlsZSAoKnAgIT0gTlVMTCkgeworCQlwYXJlbnQgPSAqcDsKKwkJaXRlciA9IHJiX2VudHJ5KHBhcmVudCwgc3RydWN0IGhpc3RfZW50cnksIHJiX25vZGUpOworCisJCWlmIChoZS0+Y291bnQgPiBpdGVyLT5jb3VudCkKKwkJCXAgPSAmKCpwKS0+cmJfbGVmdDsKKwkJZWxzZQorCQkJcCA9ICYoKnApLT5yYl9yaWdodDsKKwl9CisKKwlyYl9saW5rX25vZGUoJmhlLT5yYl9ub2RlLCBwYXJlbnQsIHApOworCXJiX2luc2VydF9jb2xvcigmaGUtPnJiX25vZGUsICZvdXRwdXRfaGlzdHMpOworfQorCitzdGF0aWMgdm9pZCBvdXRwdXRfX3Jlc29ydCh2b2lkKQoreworCXN0cnVjdCByYl9ub2RlICpuZXh0OworCXN0cnVjdCBoaXN0X2VudHJ5ICpuOworCXN0cnVjdCByYl9yb290ICp0cmVlID0gJmhpc3Q7CisKKwlpZiAoc29ydF9fbmVlZF9jb2xsYXBzZSkKKwkJdHJlZSA9ICZjb2xsYXBzZV9oaXN0czsKKworCW5leHQgPSByYl9maXJzdCh0cmVlKTsKKworCXdoaWxlIChuZXh0KSB7CisJCW4gPSByYl9lbnRyeShuZXh0LCBzdHJ1Y3QgaGlzdF9lbnRyeSwgcmJfbm9kZSk7CisJCW5leHQgPSByYl9uZXh0KCZuLT5yYl9ub2RlKTsKKworCQlyYl9lcmFzZSgmbi0+cmJfbm9kZSwgdHJlZSk7CisJCW91dHB1dF9faW5zZXJ0X2VudHJ5KG4pOworCX0KK30KKworc3RhdGljIHZvaWQgcmVnaXN0ZXJfaWRsZV90aHJlYWQodm9pZCkKK3sKKwlzdHJ1Y3QgdGhyZWFkICp0aHJlYWQgPSB0aHJlYWRzX19maW5kbmV3KDApOworCisJaWYgKHRocmVhZCA9PSBOVUxMIHx8CisJCQl0aHJlYWRfX3NldF9jb21tKHRocmVhZCwgIltpZGxlXSIpKSB7CisJCWZwcmludGYoc3RkZXJyLCAicHJvYmxlbSBpbnNlcnRpbmcgaWRsZSB0YXNrLlxuIik7CisJCWV4aXQoLTEpOworCX0KK30KKworc3RhdGljIHVuc2lnbmVkIGxvbmcgdG90YWwgPSAwLAorCQkgICAgIHRvdGFsX21tYXAgPSAwLAorCQkgICAgIHRvdGFsX2NvbW0gPSAwLAorCQkgICAgIHRvdGFsX2ZvcmsgPSAwLAorCQkgICAgIHRvdGFsX3Vua25vd24gPSAwOworCitzdGF0aWMgaW50Citwcm9jZXNzX292ZXJmbG93X2V2ZW50KGV2ZW50X3QgKmV2ZW50LCB1bnNpZ25lZCBsb25nIG9mZnNldCwgdW5zaWduZWQgbG9uZyBoZWFkKQoreworCWNoYXIgbGV2ZWw7CisJaW50IHNob3cgPSAwOworCXN0cnVjdCBkc28gKmRzbyA9IE5VTEw7CisJc3RydWN0IHRocmVhZCAqdGhyZWFkID0gdGhyZWFkc19fZmluZG5ldyhldmVudC0+aXAucGlkKTsKKwlfX3U2NCBpcCA9IGV2ZW50LT5pcC5pcDsKKwlzdHJ1Y3QgbWFwICptYXAgPSBOVUxMOworCisJZHByaW50ZigiJXAgWyVwXTogUEVSRl9FVkVOVCAoSVAsICVkKTogJWQ6ICVwXG4iLAorCQkodm9pZCAqKShvZmZzZXQgKyBoZWFkKSwKKwkJKHZvaWQgKikobG9uZykoZXZlbnQtPmhlYWRlci5zaXplKSwKKwkJZXZlbnQtPmhlYWRlci5taXNjLAorCQlldmVudC0+aXAucGlkLAorCQkodm9pZCAqKShsb25nKWlwKTsKKworCWRwcmludGYoIiAuLi4gdGhyZWFkOiAlczolZFxuIiwgdGhyZWFkLT5jb21tLCB0aHJlYWQtPnBpZCk7CisKKwlpZiAodGhyZWFkID09IE5VTEwpIHsKKwkJZnByaW50ZihzdGRlcnIsICJwcm9ibGVtIHByb2Nlc3NpbmcgJWQgZXZlbnQsIHNraXBwaW5nIGl0LlxuIiwKKwkJCWV2ZW50LT5oZWFkZXIudHlwZSk7CisJCXJldHVybiAtMTsKKwl9CisKKwlpZiAoZXZlbnQtPmhlYWRlci5taXNjICYgUEVSRl9FVkVOVF9NSVNDX0tFUk5FTCkgeworCQlzaG93ID0gU0hPV19LRVJORUw7CisJCWxldmVsID0gJ2snOworCisJCWRzbyA9IGtlcm5lbF9kc287CisKKwkJZHByaW50ZigiIC4uLi4uLiBkc286ICVzXG4iLCBkc28tPm5hbWUpOworCisJfSBlbHNlIGlmIChldmVudC0+aGVhZGVyLm1pc2MgJiBQRVJGX0VWRU5UX01JU0NfVVNFUikgeworCisJCXNob3cgPSBTSE9XX1VTRVI7CisJCWxldmVsID0gJy4nOworCisJCW1hcCA9IHRocmVhZF9fZmluZF9tYXAodGhyZWFkLCBpcCk7CisJCWlmIChtYXAgIT0gTlVMTCkgeworCQkJaXAgPSBtYXAtPm1hcF9pcChtYXAsIGlwKTsKKwkJCWRzbyA9IG1hcC0+ZHNvOworCQl9IGVsc2UgeworCQkJLyoKKwkJCSAqIElmIHRoaXMgaXMgb3V0c2lkZSBvZiBhbGwga25vd24gbWFwcywKKwkJCSAqIGFuZCBpcyBhIG5lZ2F0aXZlIGFkZHJlc3MsIHRyeSB0byBsb29rIGl0CisJCQkgKiB1cCBpbiB0aGUga2VybmVsIGRzbywgYXMgaXQgbWlnaHQgYmUgYQorCQkJICogdnN5c2NhbGwgKHdoaWNoIGV4ZWN1dGVzIGluIHVzZXItbW9kZSk6CisJCQkgKi8KKwkJCWlmICgobG9uZyBsb25nKWlwIDwgMCkKKwkJCQlkc28gPSBrZXJuZWxfZHNvOworCQl9CisJCWRwcmludGYoIiAuLi4uLi4gZHNvOiAlc1xuIiwgZHNvID8gZHNvLT5uYW1lIDogIjxub3QgZm91bmQ+Iik7CisKKwl9IGVsc2UgeworCQlzaG93ID0gU0hPV19IVjsKKwkJbGV2ZWwgPSAnSCc7CisJCWRwcmludGYoIiAuLi4uLi4gZHNvOiBbaHlwZXJ2aXNvcl1cbiIpOworCX0KKworCWlmIChzaG93ICYgc2hvd19tYXNrKSB7CisJCXN0cnVjdCBzeW1ib2wgKnN5bSA9IE5VTEw7CisKKwkJaWYgKGRzbykKKwkJCXN5bSA9IGRzby0+ZmluZF9zeW1ib2woZHNvLCBpcCk7CisKKwkJaWYgKGhpc3RfZW50cnlfX2FkZCh0aHJlYWQsIG1hcCwgZHNvLCBzeW0sIGlwLCBsZXZlbCkpIHsKKwkJCWZwcmludGYoc3RkZXJyLAorCQkicHJvYmxlbSBpbmNyZW1lbnRpbmcgc3ltYm9sIGNvdW50LCBza2lwcGluZyBldmVudFxuIik7CisJCQlyZXR1cm4gLTE7CisJCX0KKwl9CisJdG90YWwrKzsKKworCXJldHVybiAwOworfQorCitzdGF0aWMgaW50Citwcm9jZXNzX21tYXBfZXZlbnQoZXZlbnRfdCAqZXZlbnQsIHVuc2lnbmVkIGxvbmcgb2Zmc2V0LCB1bnNpZ25lZCBsb25nIGhlYWQpCit7CisJc3RydWN0IHRocmVhZCAqdGhyZWFkID0gdGhyZWFkc19fZmluZG5ldyhldmVudC0+bW1hcC5waWQpOworCXN0cnVjdCBtYXAgKm1hcCA9IG1hcF9fbmV3KCZldmVudC0+bW1hcCk7CisKKwlkcHJpbnRmKCIlcCBbJXBdOiBQRVJGX0VWRU5UX01NQVAgJWQ6IFslcCglcCkgQCAlcF06ICVzXG4iLAorCQkodm9pZCAqKShvZmZzZXQgKyBoZWFkKSwKKwkJKHZvaWQgKikobG9uZykoZXZlbnQtPmhlYWRlci5zaXplKSwKKwkJZXZlbnQtPm1tYXAucGlkLAorCQkodm9pZCAqKShsb25nKWV2ZW50LT5tbWFwLnN0YXJ0LAorCQkodm9pZCAqKShsb25nKWV2ZW50LT5tbWFwLmxlbiwKKwkJKHZvaWQgKikobG9uZylldmVudC0+bW1hcC5wZ29mZiwKKwkJZXZlbnQtPm1tYXAuZmlsZW5hbWUpOworCisJaWYgKHRocmVhZCA9PSBOVUxMIHx8IG1hcCA9PSBOVUxMKSB7CisJCWRwcmludGYoInByb2JsZW0gcHJvY2Vzc2luZyBQRVJGX0VWRU5UX01NQVAsIHNraXBwaW5nIGV2ZW50LlxuIik7CisJCXJldHVybiAwOworCX0KKworCXRocmVhZF9faW5zZXJ0X21hcCh0aHJlYWQsIG1hcCk7CisJdG90YWxfbW1hcCsrOworCisJcmV0dXJuIDA7Cit9CisKK3N0YXRpYyBpbnQKK3Byb2Nlc3NfY29tbV9ldmVudChldmVudF90ICpldmVudCwgdW5zaWduZWQgbG9uZyBvZmZzZXQsIHVuc2lnbmVkIGxvbmcgaGVhZCkKK3sKKwlzdHJ1Y3QgdGhyZWFkICp0aHJlYWQgPSB0aHJlYWRzX19maW5kbmV3KGV2ZW50LT5jb21tLnBpZCk7CisKKwlkcHJpbnRmKCIlcCBbJXBdOiBQRVJGX0VWRU5UX0NPTU06ICVzOiVkXG4iLAorCQkodm9pZCAqKShvZmZzZXQgKyBoZWFkKSwKKwkJKHZvaWQgKikobG9uZykoZXZlbnQtPmhlYWRlci5zaXplKSwKKwkJZXZlbnQtPmNvbW0uY29tbSwgZXZlbnQtPmNvbW0ucGlkKTsKKworCWlmICh0aHJlYWQgPT0gTlVMTCB8fAorCSAgICB0aHJlYWRfX3NldF9jb21tKHRocmVhZCwgZXZlbnQtPmNvbW0uY29tbSkpIHsKKwkJZHByaW50ZigicHJvYmxlbSBwcm9jZXNzaW5nIFBFUkZfRVZFTlRfQ09NTSwgc2tpcHBpbmcgZXZlbnQuXG4iKTsKKwkJcmV0dXJuIC0xOworCX0KKwl0b3RhbF9jb21tKys7CisKKwlyZXR1cm4gMDsKK30KKworc3RhdGljIGludAorcHJvY2Vzc19mb3JrX2V2ZW50KGV2ZW50X3QgKmV2ZW50LCB1bnNpZ25lZCBsb25nIG9mZnNldCwgdW5zaWduZWQgbG9uZyBoZWFkKQoreworCXN0cnVjdCB0aHJlYWQgKnRocmVhZCA9IHRocmVhZHNfX2ZpbmRuZXcoZXZlbnQtPmZvcmsucGlkKTsKKwlzdHJ1Y3QgdGhyZWFkICpwYXJlbnQgPSB0aHJlYWRzX19maW5kbmV3KGV2ZW50LT5mb3JrLnBwaWQpOworCisJZHByaW50ZigiJXAgWyVwXTogUEVSRl9FVkVOVF9GT1JLOiAlZDolZFxuIiwKKwkJKHZvaWQgKikob2Zmc2V0ICsgaGVhZCksCisJCSh2b2lkICopKGxvbmcpKGV2ZW50LT5oZWFkZXIuc2l6ZSksCisJCWV2ZW50LT5mb3JrLnBpZCwgZXZlbnQtPmZvcmsucHBpZCk7CisKKwlpZiAoIXRocmVhZCB8fCAhcGFyZW50IHx8IHRocmVhZF9fZm9yayh0aHJlYWQsIHBhcmVudCkpIHsKKwkJZHByaW50ZigicHJvYmxlbSBwcm9jZXNzaW5nIFBFUkZfRVZFTlRfRk9SSywgc2tpcHBpbmcgZXZlbnQuXG4iKTsKKwkJcmV0dXJuIC0xOworCX0KKwl0b3RhbF9mb3JrKys7CisKKwlyZXR1cm4gMDsKK30KKworc3RhdGljIGludAorcHJvY2Vzc19wZXJpb2RfZXZlbnQoZXZlbnRfdCAqZXZlbnQsIHVuc2lnbmVkIGxvbmcgb2Zmc2V0LCB1bnNpZ25lZCBsb25nIGhlYWQpCit7CisJZHByaW50ZigiJXAgWyVwXTogUEVSRl9FVkVOVF9QRVJJT0Q6IHRpbWU6JUxkLCBpZDolTGQ6IHBlcmlvZDolTGRcbiIsCisJCSh2b2lkICopKG9mZnNldCArIGhlYWQpLAorCQkodm9pZCAqKShsb25nKShldmVudC0+aGVhZGVyLnNpemUpLAorCQlldmVudC0+cGVyaW9kLnRpbWUsCisJCWV2ZW50LT5wZXJpb2QuaWQsCisJCWV2ZW50LT5wZXJpb2Quc2FtcGxlX3BlcmlvZCk7CisKKwlyZXR1cm4gMDsKK30KKworc3RhdGljIGludAorcHJvY2Vzc19ldmVudChldmVudF90ICpldmVudCwgdW5zaWduZWQgbG9uZyBvZmZzZXQsIHVuc2lnbmVkIGxvbmcgaGVhZCkKK3sKKwlpZiAoZXZlbnQtPmhlYWRlci5taXNjICYgUEVSRl9FVkVOVF9NSVNDX09WRVJGTE9XKQorCQlyZXR1cm4gcHJvY2Vzc19vdmVyZmxvd19ldmVudChldmVudCwgb2Zmc2V0LCBoZWFkKTsKKworCXN3aXRjaCAoZXZlbnQtPmhlYWRlci50eXBlKSB7CisJY2FzZSBQRVJGX0VWRU5UX01NQVA6CisJCXJldHVybiBwcm9jZXNzX21tYXBfZXZlbnQoZXZlbnQsIG9mZnNldCwgaGVhZCk7CisKKwljYXNlIFBFUkZfRVZFTlRfQ09NTToKKwkJcmV0dXJuIHByb2Nlc3NfY29tbV9ldmVudChldmVudCwgb2Zmc2V0LCBoZWFkKTsKKworCWNhc2UgUEVSRl9FVkVOVF9GT1JLOgorCQlyZXR1cm4gcHJvY2Vzc19mb3JrX2V2ZW50KGV2ZW50LCBvZmZzZXQsIGhlYWQpOworCisJY2FzZSBQRVJGX0VWRU5UX1BFUklPRDoKKwkJcmV0dXJuIHByb2Nlc3NfcGVyaW9kX2V2ZW50KGV2ZW50LCBvZmZzZXQsIGhlYWQpOworCS8qCisJICogV2UgZG9udCBwcm9jZXNzIHRoZW0gcmlnaHQgbm93IGJ1dCB0aGV5IGFyZSBmaW5lOgorCSAqLworCisJY2FzZSBQRVJGX0VWRU5UX1RIUk9UVExFOgorCWNhc2UgUEVSRl9FVkVOVF9VTlRIUk9UVExFOgorCQlyZXR1cm4gMDsKKworCWRlZmF1bHQ6CisJCXJldHVybiAtMTsKKwl9CisKKwlyZXR1cm4gMDsKK30KKworc3RhdGljIGludAorcGFyc2VfbGluZShGSUxFICpmaWxlLCBzdHJ1Y3Qgc3ltYm9sICpzeW0sIF9fdTY0IHN0YXJ0LCBfX3U2NCBsZW4pCit7CisJY2hhciAqbGluZSA9IE5VTEwsICp0bXAsICp0bXAyOworCXVuc2lnbmVkIGludCBvZmZzZXQ7CisJc2l6ZV90IGxpbmVfbGVuOworCV9fdTY0IGxpbmVfaXA7CisJaW50IHJldDsKKwljaGFyICpjOworCisJaWYgKGdldGxpbmUoJmxpbmUsICZsaW5lX2xlbiwgZmlsZSkgPCAwKQorCQlyZXR1cm4gLTE7CisJaWYgKCFsaW5lKQorCQlyZXR1cm4gLTE7CisKKwljID0gc3RyY2hyKGxpbmUsICdcbicpOworCWlmIChjKQorCQkqYyA9IDA7CisKKwlsaW5lX2lwID0gLTE7CisJb2Zmc2V0ID0gMDsKKwlyZXQgPSAtMjsKKworCS8qCisJICogU3RyaXAgbGVhZGluZyBzcGFjZXM6CisJICovCisJdG1wID0gbGluZTsKKwl3aGlsZSAoKnRtcCkgeworCQlpZiAoKnRtcCAhPSAnICcpCisJCQlicmVhazsKKwkJdG1wKys7CisJfQorCisJaWYgKCp0bXApIHsKKwkJLyoKKwkJICogUGFyc2UgaGV4YSBhZGRyZXNzZXMgZm9sbG93ZWQgYnkgJzonCisJCSAqLworCQlsaW5lX2lwID0gc3RydG91bGwodG1wLCAmdG1wMiwgMTYpOworCQlpZiAoKnRtcDIgIT0gJzonKQorCQkJbGluZV9pcCA9IC0xOworCX0KKworCWlmIChsaW5lX2lwICE9IC0xKSB7CisJCXVuc2lnbmVkIGludCBoaXRzID0gMDsKKwkJZG91YmxlIHBlcmNlbnQgPSAwLjA7CisJCWNoYXIgKmNvbG9yID0gUEVSRl9DT0xPUl9OT1JNQUw7CisKKwkJb2Zmc2V0ID0gbGluZV9pcCAtIHN0YXJ0OworCQlpZiAob2Zmc2V0IDwgbGVuKQorCQkJaGl0cyA9IHN5bS0+aGlzdFtvZmZzZXRdOworCisJCWlmIChzeW0tPmhpc3Rfc3VtKQorCQkJcGVyY2VudCA9IDEwMC4wICogaGl0cyAvIHN5bS0+aGlzdF9zdW07CisKKwkJLyoKKwkJICogV2UgY29sb3IgaGlnaC1vdmVyaGVhZCBlbnRyaWVzIGluIHJlZCwgbWlkLW92ZXJoZWFkCisJCSAqIGVudHJpZXMgaW4gZ3JlZW4gLSBhbmQga2VlcCB0aGUgbG93IG92ZXJoZWFkIHBsYWNlcworCQkgKiBub3JtYWw6CisJCSAqLworCQlpZiAocGVyY2VudCA+PSA1LjApCisJCQljb2xvciA9IFBFUkZfQ09MT1JfUkVEOworCQllbHNlIHsKKwkJCWlmIChwZXJjZW50ID4gMC41KQorCQkJCWNvbG9yID0gUEVSRl9DT0xPUl9HUkVFTjsKKwkJfQorCisJCWNvbG9yX2ZwcmludGYoc3Rkb3V0LCBjb2xvciwgIiAlNy4yZiIsIHBlcmNlbnQpOworCQlwcmludGYoIiA6CSIpOworCQljb2xvcl9mcHJpbnRmKHN0ZG91dCwgUEVSRl9DT0xPUl9CTFVFLCAiJXNcbiIsIGxpbmUpOworCX0gZWxzZSB7CisJCWlmICghKmxpbmUpCisJCQlwcmludGYoIiAgICAgICAgIDpcbiIpOworCQllbHNlCisJCQlwcmludGYoIiAgICAgICAgIDoJJXNcbiIsIGxpbmUpOworCX0KKworCXJldHVybiAwOworfQorCitzdGF0aWMgdm9pZCBhbm5vdGF0ZV9zeW0oc3RydWN0IGRzbyAqZHNvLCBzdHJ1Y3Qgc3ltYm9sICpzeW0pCit7CisJY2hhciAqZmlsZW5hbWUgPSBkc28tPm5hbWU7CisJX191NjQgc3RhcnQsIGVuZCwgbGVuOworCWNoYXIgY29tbWFuZFtQQVRIX01BWCoyXTsKKwlGSUxFICpmaWxlOworCisJaWYgKCFmaWxlbmFtZSkKKwkJcmV0dXJuOworCWlmIChkc28gPT0ga2VybmVsX2RzbykKKwkJZmlsZW5hbWUgPSB2bWxpbnV4OworCisJcHJpbnRmKCJcbi0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLVxuIik7CisJcHJpbnRmKCIgUGVyY2VudCB8CVNvdXJjZSBjb2RlICYgRGlzYXNzZW1ibHkgb2YgJXNcbiIsIGZpbGVuYW1lKTsKKwlwcmludGYoIi0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLVxuIik7CisKKwlpZiAodmVyYm9zZSA+PSAyKQorCQlwcmludGYoImFubm90YXRpbmcgWyVwXSAlMzBzIDogWyVwXSAlMzBzXG4iLCBkc28sIGRzby0+bmFtZSwgc3ltLCBzeW0tPm5hbWUpOworCisJc3RhcnQgPSBzeW0tPm9ial9zdGFydDsKKwlpZiAoIXN0YXJ0KQorCQlzdGFydCA9IHN5bS0+c3RhcnQ7CisKKwllbmQgPSBzdGFydCArIHN5bS0+ZW5kIC0gc3ltLT5zdGFydCArIDE7CisJbGVuID0gc3ltLT5lbmQgLSBzeW0tPnN0YXJ0OworCisJc3ByaW50Zihjb21tYW5kLCAib2JqZHVtcCAtLXN0YXJ0LWFkZHJlc3M9MHglMDE2THggLS1zdG9wLWFkZHJlc3M9MHglMDE2THggLWRTICVzIiwgKF9fdTY0KXN0YXJ0LCAoX191NjQpZW5kLCBmaWxlbmFtZSk7CisKKwlpZiAodmVyYm9zZSA+PSAzKQorCQlwcmludGYoImRvaW5nOiAlc1xuIiwgY29tbWFuZCk7CisKKwlmaWxlID0gcG9wZW4oY29tbWFuZCwgInIiKTsKKwlpZiAoIWZpbGUpCisJCXJldHVybjsKKworCXdoaWxlICghZmVvZihmaWxlKSkgeworCQlpZiAocGFyc2VfbGluZShmaWxlLCBzeW0sIHN0YXJ0LCBsZW4pIDwgMCkKKwkJCWJyZWFrOworCX0KKworCXBjbG9zZShmaWxlKTsKK30KKworc3RhdGljIHZvaWQgZmluZF9hbm5vdGF0aW9ucyh2b2lkKQoreworCXN0cnVjdCByYl9ub2RlICpuZDsKKwlzdHJ1Y3QgZHNvICpkc287CisJaW50IGNvdW50ID0gMDsKKworCWxpc3RfZm9yX2VhY2hfZW50cnkoZHNvLCAmZHNvcywgbm9kZSkgeworCisJCWZvciAobmQgPSByYl9maXJzdCgmZHNvLT5zeW1zKTsgbmQ7IG5kID0gcmJfbmV4dChuZCkpIHsKKwkJCXN0cnVjdCBzeW1ib2wgKnN5bSA9IHJiX2VudHJ5KG5kLCBzdHJ1Y3Qgc3ltYm9sLCByYl9ub2RlKTsKKworCQkJaWYgKHN5bS0+aGlzdCkgeworCQkJCWFubm90YXRlX3N5bShkc28sIHN5bSk7CisJCQkJY291bnQrKzsKKwkJCX0KKwkJfQorCX0KKworCWlmICghY291bnQpCisJCXByaW50ZigiIEVycm9yOiBzeW1ib2wgJyVzJyBub3QgcHJlc2VudCBhbW9uZ3N0IHRoZSBzYW1wbGVzLlxuIiwgc3ltX2hpc3RfZmlsdGVyKTsKK30KKworc3RhdGljIGludCBfX2NtZF9hbm5vdGF0ZSh2b2lkKQoreworCWludCByZXQsIHJjID0gRVhJVF9GQUlMVVJFOworCXVuc2lnbmVkIGxvbmcgb2Zmc2V0ID0gMDsKKwl1bnNpZ25lZCBsb25nIGhlYWQgPSAwOworCXN0cnVjdCBzdGF0IHN0YXQ7CisJZXZlbnRfdCAqZXZlbnQ7CisJdWludDMyX3Qgc2l6ZTsKKwljaGFyICpidWY7CisKKwlyZWdpc3Rlcl9pZGxlX3RocmVhZCgpOworCisJaW5wdXQgPSBvcGVuKGlucHV0X25hbWUsIE9fUkRPTkxZKTsKKwlpZiAoaW5wdXQgPCAwKSB7CisJCXBlcnJvcigiZmFpbGVkIHRvIG9wZW4gZmlsZSIpOworCQlleGl0KC0xKTsKKwl9CisKKwlyZXQgPSBmc3RhdChpbnB1dCwgJnN0YXQpOworCWlmIChyZXQgPCAwKSB7CisJCXBlcnJvcigiZmFpbGVkIHRvIHN0YXQgZmlsZSIpOworCQlleGl0KC0xKTsKKwl9CisKKwlpZiAoIXN0YXQuc3Rfc2l6ZSkgeworCQlmcHJpbnRmKHN0ZGVyciwgInplcm8tc2l6ZWQgZmlsZSwgbm90aGluZyB0byBkbyFcbiIpOworCQlleGl0KDApOworCX0KKworCWlmIChsb2FkX2tlcm5lbCgpIDwgMCkgeworCQlwZXJyb3IoImZhaWxlZCB0byBsb2FkIGtlcm5lbCBzeW1ib2xzIik7CisJCXJldHVybiBFWElUX0ZBSUxVUkU7CisJfQorCityZW1hcDoKKwlidWYgPSAoY2hhciAqKW1tYXAoTlVMTCwgcGFnZV9zaXplICogbW1hcF93aW5kb3csIFBST1RfUkVBRCwKKwkJCSAgIE1BUF9TSEFSRUQsIGlucHV0LCBvZmZzZXQpOworCWlmIChidWYgPT0gTUFQX0ZBSUxFRCkgeworCQlwZXJyb3IoImZhaWxlZCB0byBtbWFwIGZpbGUiKTsKKwkJZXhpdCgtMSk7CisJfQorCittb3JlOgorCWV2ZW50ID0gKGV2ZW50X3QgKikoYnVmICsgaGVhZCk7CisKKwlzaXplID0gZXZlbnQtPmhlYWRlci5zaXplOworCWlmICghc2l6ZSkKKwkJc2l6ZSA9IDg7CisKKwlpZiAoaGVhZCArIGV2ZW50LT5oZWFkZXIuc2l6ZSA+PSBwYWdlX3NpemUgKiBtbWFwX3dpbmRvdykgeworCQl1bnNpZ25lZCBsb25nIHNoaWZ0ID0gcGFnZV9zaXplICogKGhlYWQgLyBwYWdlX3NpemUpOworCQlpbnQgcmV0OworCisJCXJldCA9IG11bm1hcChidWYsIHBhZ2Vfc2l6ZSAqIG1tYXBfd2luZG93KTsKKwkJYXNzZXJ0KHJldCA9PSAwKTsKKworCQlvZmZzZXQgKz0gc2hpZnQ7CisJCWhlYWQgLT0gc2hpZnQ7CisJCWdvdG8gcmVtYXA7CisJfQorCisJc2l6ZSA9IGV2ZW50LT5oZWFkZXIuc2l6ZTsKKworCWRwcmludGYoIiVwIFslcF06IGV2ZW50OiAlZFxuIiwKKwkJCSh2b2lkICopKG9mZnNldCArIGhlYWQpLAorCQkJKHZvaWQgKikobG9uZylldmVudC0+aGVhZGVyLnNpemUsCisJCQlldmVudC0+aGVhZGVyLnR5cGUpOworCisJaWYgKCFzaXplIHx8IHByb2Nlc3NfZXZlbnQoZXZlbnQsIG9mZnNldCwgaGVhZCkgPCAwKSB7CisKKwkJZHByaW50ZigiJXAgWyVwXTogc2tpcHBpbmcgdW5rbm93biBoZWFkZXIgdHlwZTogJWRcbiIsCisJCQkodm9pZCAqKShvZmZzZXQgKyBoZWFkKSwKKwkJCSh2b2lkICopKGxvbmcpKGV2ZW50LT5oZWFkZXIuc2l6ZSksCisJCQlldmVudC0+aGVhZGVyLnR5cGUpOworCisJCXRvdGFsX3Vua25vd24rKzsKKworCQkvKgorCQkgKiBhc3N1bWUgd2UgbG9zdCB0cmFjayBvZiB0aGUgc3RyZWFtLCBjaGVjayBhbGlnbm1lbnQsIGFuZAorCQkgKiBpbmNyZW1lbnQgYSBzaW5nbGUgdTY0IGluIHRoZSBob3BlIHRvIGNhdGNoIG9uIGFnYWluICdzb29uJy4KKwkJICovCisKKwkJaWYgKHVubGlrZWx5KGhlYWQgJiA3KSkKKwkJCWhlYWQgJj0gfjdVTEw7CisKKwkJc2l6ZSA9IDg7CisJfQorCisJaGVhZCArPSBzaXplOworCisJaWYgKG9mZnNldCArIGhlYWQgPCBzdGF0LnN0X3NpemUpCisJCWdvdG8gbW9yZTsKKworCXJjID0gRVhJVF9TVUNDRVNTOworCWNsb3NlKGlucHV0KTsKKworCWRwcmludGYoIiAgICAgIElQIGV2ZW50czogJTEwbGRcbiIsIHRvdGFsKTsKKwlkcHJpbnRmKCIgICAgbW1hcCBldmVudHM6ICUxMGxkXG4iLCB0b3RhbF9tbWFwKTsKKwlkcHJpbnRmKCIgICAgY29tbSBldmVudHM6ICUxMGxkXG4iLCB0b3RhbF9jb21tKTsKKwlkcHJpbnRmKCIgICAgZm9yayBldmVudHM6ICUxMGxkXG4iLCB0b3RhbF9mb3JrKTsKKwlkcHJpbnRmKCIgdW5rbm93biBldmVudHM6ICUxMGxkXG4iLCB0b3RhbF91bmtub3duKTsKKworCWlmIChkdW1wX3RyYWNlKQorCQlyZXR1cm4gMDsKKworCWlmICh2ZXJib3NlID49IDMpCisJCXRocmVhZHNfX2ZwcmludGYoc3Rkb3V0KTsKKworCWlmICh2ZXJib3NlID49IDIpCisJCWRzb3NfX2ZwcmludGYoc3Rkb3V0KTsKKworCWNvbGxhcHNlX19yZXNvcnQoKTsKKwlvdXRwdXRfX3Jlc29ydCgpOworCisJZmluZF9hbm5vdGF0aW9ucygpOworCisJcmV0dXJuIHJjOworfQorCitzdGF0aWMgY29uc3QgY2hhciAqIGNvbnN0IGFubm90YXRlX3VzYWdlW10gPSB7CisJInBlcmYgYW5ub3RhdGUgWzxvcHRpb25zPl0gPGNvbW1hbmQ+IiwKKwlOVUxMCit9OworCitzdGF0aWMgY29uc3Qgc3RydWN0IG9wdGlvbiBvcHRpb25zW10gPSB7CisJT1BUX1NUUklORygnaScsICJpbnB1dCIsICZpbnB1dF9uYW1lLCAiZmlsZSIsCisJCSAgICAiaW5wdXQgZmlsZSBuYW1lIiksCisJT1BUX1NUUklORygncycsICJzeW1ib2wiLCAmc3ltX2hpc3RfZmlsdGVyLCAic3ltYm9sIiwKKwkJICAgICJzeW1ib2wgdG8gYW5ub3RhdGUiKSwKKwlPUFRfQk9PTEVBTigndicsICJ2ZXJib3NlIiwgJnZlcmJvc2UsCisJCSAgICAiYmUgbW9yZSB2ZXJib3NlIChzaG93IHN5bWJvbCBhZGRyZXNzLCBldGMpIiksCisJT1BUX0JPT0xFQU4oJ0QnLCAiZHVtcC1yYXctdHJhY2UiLCAmZHVtcF90cmFjZSwKKwkJICAgICJkdW1wIHJhdyB0cmFjZSBpbiBBU0NJSSIpLAorCU9QVF9TVFJJTkcoJ2snLCAidm1saW51eCIsICZ2bWxpbnV4LCAiZmlsZSIsICJ2bWxpbnV4IHBhdGhuYW1lIiksCisJT1BUX0VORCgpCit9OworCitzdGF0aWMgdm9pZCBzZXR1cF9zb3J0aW5nKHZvaWQpCit7CisJY2hhciAqdG1wLCAqdG9rLCAqc3RyID0gc3RyZHVwKHNvcnRfb3JkZXIpOworCisJZm9yICh0b2sgPSBzdHJ0b2tfcihzdHIsICIsICIsICZ0bXApOworCQkJdG9rOyB0b2sgPSBzdHJ0b2tfcihOVUxMLCAiLCAiLCAmdG1wKSkgeworCQlpZiAoc29ydF9kaW1lbnNpb25fX2FkZCh0b2spIDwgMCkgeworCQkJZXJyb3IoIlVua25vd24gLS1zb3J0IGtleTogYCVzJyIsIHRvayk7CisJCQl1c2FnZV93aXRoX29wdGlvbnMoYW5ub3RhdGVfdXNhZ2UsIG9wdGlvbnMpOworCQl9CisJfQorCisJZnJlZShzdHIpOworfQorCitpbnQgY21kX2Fubm90YXRlKGludCBhcmdjLCBjb25zdCBjaGFyICoqYXJndiwgY29uc3QgY2hhciAqcHJlZml4KQoreworCXN5bWJvbF9faW5pdCgpOworCisJcGFnZV9zaXplID0gZ2V0cGFnZXNpemUoKTsKKworCWFyZ2MgPSBwYXJzZV9vcHRpb25zKGFyZ2MsIGFyZ3YsIG9wdGlvbnMsIGFubm90YXRlX3VzYWdlLCAwKTsKKworCXNldHVwX3NvcnRpbmcoKTsKKworCWlmIChhcmdjKSB7CisJCS8qCisJCSAqIFNwZWNpYWwgY2FzZTogaWYgdGhlcmUncyBhbiBhcmd1bWVudCBsZWZ0IHRoZW4gYXNzdW1lIHRoYQorCQkgKiBpdCdzIGEgc3ltYm9sIGZpbHRlcjoKKwkJICovCisJCWlmIChhcmdjID4gMSkKKwkJCXVzYWdlX3dpdGhfb3B0aW9ucyhhbm5vdGF0ZV91c2FnZSwgb3B0aW9ucyk7CisKKwkJc3ltX2hpc3RfZmlsdGVyID0gYXJndlswXTsKKwl9CisKKwlpZiAoIXN5bV9oaXN0X2ZpbHRlcikKKwkJdXNhZ2Vfd2l0aF9vcHRpb25zKGFubm90YXRlX3VzYWdlLCBvcHRpb25zKTsKKworCXNldHVwX3BhZ2VyKCk7CisKKwlyZXR1cm4gX19jbWRfYW5ub3RhdGUoKTsKK30KZGlmZiAtLWdpdCBhL3Rvb2xzL3BlcmYvYnVpbHRpbi1oZWxwLmMgYi90b29scy9wZXJmL2J1aWx0aW4taGVscC5jCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjBmMzJkYzMKLS0tIC9kZXYvbnVsbAorKysgYi90b29scy9wZXJmL2J1aWx0aW4taGVscC5jCkBAIC0wLDAgKzEsNDYxIEBACisvKgorICogYnVpbHRpbi1oZWxwLmMKKyAqCisgKiBCdWlsdGluIGhlbHAgY29tbWFuZAorICovCisjaW5jbHVkZSAidXRpbC9jYWNoZS5oIgorI2luY2x1ZGUgImJ1aWx0aW4uaCIKKyNpbmNsdWRlICJ1dGlsL2V4ZWNfY21kLmgiCisjaW5jbHVkZSAiY29tbW9uLWNtZHMuaCIKKyNpbmNsdWRlICJ1dGlsL3BhcnNlLW9wdGlvbnMuaCIKKyNpbmNsdWRlICJ1dGlsL3J1bi1jb21tYW5kLmgiCisjaW5jbHVkZSAidXRpbC9oZWxwLmgiCisKK3N0YXRpYyBzdHJ1Y3QgbWFuX3ZpZXdlcl9saXN0IHsKKwlzdHJ1Y3QgbWFuX3ZpZXdlcl9saXN0ICpuZXh0OworCWNoYXIgbmFtZVtGTEVYX0FSUkFZXTsKK30gKm1hbl92aWV3ZXJfbGlzdDsKKworc3RhdGljIHN0cnVjdCBtYW5fdmlld2VyX2luZm9fbGlzdCB7CisJc3RydWN0IG1hbl92aWV3ZXJfaW5mb19saXN0ICpuZXh0OworCWNvbnN0IGNoYXIgKmluZm87CisJY2hhciBuYW1lW0ZMRVhfQVJSQVldOworfSAqbWFuX3ZpZXdlcl9pbmZvX2xpc3Q7CisKK2VudW0gaGVscF9mb3JtYXQgeworCUhFTFBfRk9STUFUX01BTiwKKwlIRUxQX0ZPUk1BVF9JTkZPLAorCUhFTFBfRk9STUFUX1dFQiwKK307CisKK3N0YXRpYyBpbnQgc2hvd19hbGwgPSAwOworc3RhdGljIGVudW0gaGVscF9mb3JtYXQgaGVscF9mb3JtYXQgPSBIRUxQX0ZPUk1BVF9NQU47CitzdGF0aWMgc3RydWN0IG9wdGlvbiBidWlsdGluX2hlbHBfb3B0aW9uc1tdID0geworCU9QVF9CT09MRUFOKCdhJywgImFsbCIsICZzaG93X2FsbCwgInByaW50IGFsbCBhdmFpbGFibGUgY29tbWFuZHMiKSwKKwlPUFRfU0VUX0lOVCgnbScsICJtYW4iLCAmaGVscF9mb3JtYXQsICJzaG93IG1hbiBwYWdlIiwgSEVMUF9GT1JNQVRfTUFOKSwKKwlPUFRfU0VUX0lOVCgndycsICJ3ZWIiLCAmaGVscF9mb3JtYXQsICJzaG93IG1hbnVhbCBpbiB3ZWIgYnJvd3NlciIsCisJCQlIRUxQX0ZPUk1BVF9XRUIpLAorCU9QVF9TRVRfSU5UKCdpJywgImluZm8iLCAmaGVscF9mb3JtYXQsICJzaG93IGluZm8gcGFnZSIsCisJCQlIRUxQX0ZPUk1BVF9JTkZPKSwKKwlPUFRfRU5EKCksCit9OworCitzdGF0aWMgY29uc3QgY2hhciAqIGNvbnN0IGJ1aWx0aW5faGVscF91c2FnZVtdID0geworCSJwZXJmIGhlbHAgWy0tYWxsXSBbLS1tYW58LS13ZWJ8LS1pbmZvXSBbY29tbWFuZF0iLAorCU5VTEwKK307CisKK3N0YXRpYyBlbnVtIGhlbHBfZm9ybWF0IHBhcnNlX2hlbHBfZm9ybWF0KGNvbnN0IGNoYXIgKmZvcm1hdCkKK3sKKwlpZiAoIXN0cmNtcChmb3JtYXQsICJtYW4iKSkKKwkJcmV0dXJuIEhFTFBfRk9STUFUX01BTjsKKwlpZiAoIXN0cmNtcChmb3JtYXQsICJpbmZvIikpCisJCXJldHVybiBIRUxQX0ZPUk1BVF9JTkZPOworCWlmICghc3RyY21wKGZvcm1hdCwgIndlYiIpIHx8ICFzdHJjbXAoZm9ybWF0LCAiaHRtbCIpKQorCQlyZXR1cm4gSEVMUF9GT1JNQVRfV0VCOworCWRpZSgidW5yZWNvZ25pemVkIGhlbHAgZm9ybWF0ICclcyciLCBmb3JtYXQpOworfQorCitzdGF0aWMgY29uc3QgY2hhciAqZ2V0X21hbl92aWV3ZXJfaW5mbyhjb25zdCBjaGFyICpuYW1lKQoreworCXN0cnVjdCBtYW5fdmlld2VyX2luZm9fbGlzdCAqdmlld2VyOworCisJZm9yICh2aWV3ZXIgPSBtYW5fdmlld2VyX2luZm9fbGlzdDsgdmlld2VyOyB2aWV3ZXIgPSB2aWV3ZXItPm5leHQpCisJeworCQlpZiAoIXN0cmNhc2VjbXAobmFtZSwgdmlld2VyLT5uYW1lKSkKKwkJCXJldHVybiB2aWV3ZXItPmluZm87CisJfQorCXJldHVybiBOVUxMOworfQorCitzdGF0aWMgaW50IGNoZWNrX2VtYWNzY2xpZW50X3ZlcnNpb24odm9pZCkKK3sKKwlzdHJ1Y3Qgc3RyYnVmIGJ1ZmZlciA9IFNUUkJVRl9JTklUOworCXN0cnVjdCBjaGlsZF9wcm9jZXNzIGVjX3Byb2Nlc3M7CisJY29uc3QgY2hhciAqYXJndl9lY1tdID0geyAiZW1hY3NjbGllbnQiLCAiLS12ZXJzaW9uIiwgTlVMTCB9OworCWludCB2ZXJzaW9uOworCisJLyogZW1hY3NjbGllbnQgcHJpbnRzIGl0cyB2ZXJzaW9uIG51bWJlciBvbiBzdGRlcnIgKi8KKwltZW1zZXQoJmVjX3Byb2Nlc3MsIDAsIHNpemVvZihlY19wcm9jZXNzKSk7CisJZWNfcHJvY2Vzcy5hcmd2ID0gYXJndl9lYzsKKwllY19wcm9jZXNzLmVyciA9IC0xOworCWVjX3Byb2Nlc3Muc3Rkb3V0X3RvX3N0ZGVyciA9IDE7CisJaWYgKHN0YXJ0X2NvbW1hbmQoJmVjX3Byb2Nlc3MpKSB7CisJCWZwcmludGYoc3RkZXJyLCAiRmFpbGVkIHRvIHN0YXJ0IGVtYWNzY2xpZW50LlxuIik7CisJCXJldHVybiAtMTsKKwl9CisJc3RyYnVmX3JlYWQoJmJ1ZmZlciwgZWNfcHJvY2Vzcy5lcnIsIDIwKTsKKwljbG9zZShlY19wcm9jZXNzLmVycik7CisKKwkvKgorCSAqIERvbid0IGJvdGhlciBjaGVja2luZyByZXR1cm4gdmFsdWUsIGJlY2F1c2UgImVtYWNzY2xpZW50IC0tdmVyc2lvbiIKKwkgKiBzZWVtcyB0byBhbHdheXMgZXhpdHMgd2l0aCBjb2RlIDEuCisJICovCisJZmluaXNoX2NvbW1hbmQoJmVjX3Byb2Nlc3MpOworCisJaWYgKHByZWZpeGNtcChidWZmZXIuYnVmLCAiZW1hY3NjbGllbnQiKSkgeworCQlmcHJpbnRmKHN0ZGVyciwgIkZhaWxlZCB0byBwYXJzZSBlbWFjc2NsaWVudCB2ZXJzaW9uLlxuIik7CisJCXN0cmJ1Zl9yZWxlYXNlKCZidWZmZXIpOworCQlyZXR1cm4gLTE7CisJfQorCisJc3RyYnVmX3JlbW92ZSgmYnVmZmVyLCAwLCBzdHJsZW4oImVtYWNzY2xpZW50IikpOworCXZlcnNpb24gPSBhdG9pKGJ1ZmZlci5idWYpOworCisJaWYgKHZlcnNpb24gPCAyMikgeworCQlmcHJpbnRmKHN0ZGVyciwKKwkJCSJlbWFjc2NsaWVudCB2ZXJzaW9uICclZCcgdG9vIG9sZCAoPCAyMikuXG4iLAorCQkJdmVyc2lvbik7CisJCXN0cmJ1Zl9yZWxlYXNlKCZidWZmZXIpOworCQlyZXR1cm4gLTE7CisJfQorCisJc3RyYnVmX3JlbGVhc2UoJmJ1ZmZlcik7CisJcmV0dXJuIDA7Cit9CisKK3N0YXRpYyB2b2lkIGV4ZWNfd29tYW5fZW1hY3MoY29uc3QgY2hhciogcGF0aCwgY29uc3QgY2hhciAqcGFnZSkKK3sKKwlpZiAoIWNoZWNrX2VtYWNzY2xpZW50X3ZlcnNpb24oKSkgeworCQkvKiBUaGlzIHdvcmtzIG9ubHkgd2l0aCBlbWFjc2NsaWVudCB2ZXJzaW9uID49IDIyLiAqLworCQlzdHJ1Y3Qgc3RyYnVmIG1hbl9wYWdlID0gU1RSQlVGX0lOSVQ7CisKKwkJaWYgKCFwYXRoKQorCQkJcGF0aCA9ICJlbWFjc2NsaWVudCI7CisJCXN0cmJ1Zl9hZGRmKCZtYW5fcGFnZSwgIih3b21hbiBcIiVzXCIpIiwgcGFnZSk7CisJCWV4ZWNscChwYXRoLCAiZW1hY3NjbGllbnQiLCAiLWUiLCBtYW5fcGFnZS5idWYsIE5VTEwpOworCQl3YXJuaW5nKCJmYWlsZWQgdG8gZXhlYyAnJXMnOiAlcyIsIHBhdGgsIHN0cmVycm9yKGVycm5vKSk7CisJfQorfQorCitzdGF0aWMgdm9pZCBleGVjX21hbl9rb25xdWVyb3IoY29uc3QgY2hhciogcGF0aCwgY29uc3QgY2hhciAqcGFnZSkKK3sKKwljb25zdCBjaGFyICpkaXNwbGF5ID0gZ2V0ZW52KCJESVNQTEFZIik7CisJaWYgKGRpc3BsYXkgJiYgKmRpc3BsYXkpIHsKKwkJc3RydWN0IHN0cmJ1ZiBtYW5fcGFnZSA9IFNUUkJVRl9JTklUOworCQljb25zdCBjaGFyICpmaWxlbmFtZSA9ICJrZm1jbGllbnQiOworCisJCS8qIEl0J3Mgc2ltcGxlciB0byBsYXVuY2gga29ucXVlcm9yIHVzaW5nIGtmbWNsaWVudC4gKi8KKwkJaWYgKHBhdGgpIHsKKwkJCWNvbnN0IGNoYXIgKmZpbGUgPSBzdHJyY2hyKHBhdGgsICcvJyk7CisJCQlpZiAoZmlsZSAmJiAhc3RyY21wKGZpbGUgKyAxLCAia29ucXVlcm9yIikpIHsKKwkJCQljaGFyICpuZXcgPSBzdHJkdXAocGF0aCk7CisJCQkJY2hhciAqZGVzdCA9IHN0cnJjaHIobmV3LCAnLycpOworCisJCQkJLyogc3RybGVuKCJrb25xdWVyb3IiKSA9PSBzdHJsZW4oImtmbWNsaWVudCIpICovCisJCQkJc3RyY3B5KGRlc3QgKyAxLCAia2ZtY2xpZW50Iik7CisJCQkJcGF0aCA9IG5ldzsKKwkJCX0KKwkJCWlmIChmaWxlKQorCQkJCWZpbGVuYW1lID0gZmlsZTsKKwkJfSBlbHNlCisJCQlwYXRoID0gImtmbWNsaWVudCI7CisJCXN0cmJ1Zl9hZGRmKCZtYW5fcGFnZSwgIm1hbjolcygxKSIsIHBhZ2UpOworCQlleGVjbHAocGF0aCwgZmlsZW5hbWUsICJuZXdUYWIiLCBtYW5fcGFnZS5idWYsIE5VTEwpOworCQl3YXJuaW5nKCJmYWlsZWQgdG8gZXhlYyAnJXMnOiAlcyIsIHBhdGgsIHN0cmVycm9yKGVycm5vKSk7CisJfQorfQorCitzdGF0aWMgdm9pZCBleGVjX21hbl9tYW4oY29uc3QgY2hhciogcGF0aCwgY29uc3QgY2hhciAqcGFnZSkKK3sKKwlpZiAoIXBhdGgpCisJCXBhdGggPSAibWFuIjsKKwlleGVjbHAocGF0aCwgIm1hbiIsIHBhZ2UsIE5VTEwpOworCXdhcm5pbmcoImZhaWxlZCB0byBleGVjICclcyc6ICVzIiwgcGF0aCwgc3RyZXJyb3IoZXJybm8pKTsKK30KKworc3RhdGljIHZvaWQgZXhlY19tYW5fY21kKGNvbnN0IGNoYXIgKmNtZCwgY29uc3QgY2hhciAqcGFnZSkKK3sKKwlzdHJ1Y3Qgc3RyYnVmIHNoZWxsX2NtZCA9IFNUUkJVRl9JTklUOworCXN0cmJ1Zl9hZGRmKCZzaGVsbF9jbWQsICIlcyAlcyIsIGNtZCwgcGFnZSk7CisJZXhlY2woIi9iaW4vc2giLCAic2giLCAiLWMiLCBzaGVsbF9jbWQuYnVmLCBOVUxMKTsKKwl3YXJuaW5nKCJmYWlsZWQgdG8gZXhlYyAnJXMnOiAlcyIsIGNtZCwgc3RyZXJyb3IoZXJybm8pKTsKK30KKworc3RhdGljIHZvaWQgYWRkX21hbl92aWV3ZXIoY29uc3QgY2hhciAqbmFtZSkKK3sKKwlzdHJ1Y3QgbWFuX3ZpZXdlcl9saXN0ICoqcCA9ICZtYW5fdmlld2VyX2xpc3Q7CisJc2l6ZV90IGxlbiA9IHN0cmxlbihuYW1lKTsKKworCXdoaWxlICgqcCkKKwkJcCA9ICYoKCpwKS0+bmV4dCk7CisJKnAgPSBjYWxsb2MoMSwgKHNpemVvZigqKnApICsgbGVuICsgMSkpOworCXN0cm5jcHkoKCpwKS0+bmFtZSwgbmFtZSwgbGVuKTsKK30KKworc3RhdGljIGludCBzdXBwb3J0ZWRfbWFuX3ZpZXdlcihjb25zdCBjaGFyICpuYW1lLCBzaXplX3QgbGVuKQoreworCXJldHVybiAoIXN0cm5jYXNlY21wKCJtYW4iLCBuYW1lLCBsZW4pIHx8CisJCSFzdHJuY2FzZWNtcCgid29tYW4iLCBuYW1lLCBsZW4pIHx8CisJCSFzdHJuY2FzZWNtcCgia29ucXVlcm9yIiwgbmFtZSwgbGVuKSk7Cit9CisKK3N0YXRpYyB2b2lkIGRvX2FkZF9tYW5fdmlld2VyX2luZm8oY29uc3QgY2hhciAqbmFtZSwKKwkJCQkgICBzaXplX3QgbGVuLAorCQkJCSAgIGNvbnN0IGNoYXIgKnZhbHVlKQoreworCXN0cnVjdCBtYW5fdmlld2VyX2luZm9fbGlzdCAqbmV3ID0gY2FsbG9jKDEsIHNpemVvZigqbmV3KSArIGxlbiArIDEpOworCisJc3RybmNweShuZXctPm5hbWUsIG5hbWUsIGxlbik7CisJbmV3LT5pbmZvID0gc3RyZHVwKHZhbHVlKTsKKwluZXctPm5leHQgPSBtYW5fdmlld2VyX2luZm9fbGlzdDsKKwltYW5fdmlld2VyX2luZm9fbGlzdCA9IG5ldzsKK30KKworc3RhdGljIGludCBhZGRfbWFuX3ZpZXdlcl9wYXRoKGNvbnN0IGNoYXIgKm5hbWUsCisJCQkgICAgICAgc2l6ZV90IGxlbiwKKwkJCSAgICAgICBjb25zdCBjaGFyICp2YWx1ZSkKK3sKKwlpZiAoc3VwcG9ydGVkX21hbl92aWV3ZXIobmFtZSwgbGVuKSkKKwkJZG9fYWRkX21hbl92aWV3ZXJfaW5mbyhuYW1lLCBsZW4sIHZhbHVlKTsKKwllbHNlCisJCXdhcm5pbmcoIiclcyc6IHBhdGggZm9yIHVuc3VwcG9ydGVkIG1hbiB2aWV3ZXIuXG4iCisJCQkiUGxlYXNlIGNvbnNpZGVyIHVzaW5nICdtYW4uPHRvb2w+LmNtZCcgaW5zdGVhZC4iLAorCQkJbmFtZSk7CisKKwlyZXR1cm4gMDsKK30KKworc3RhdGljIGludCBhZGRfbWFuX3ZpZXdlcl9jbWQoY29uc3QgY2hhciAqbmFtZSwKKwkJCSAgICAgIHNpemVfdCBsZW4sCisJCQkgICAgICBjb25zdCBjaGFyICp2YWx1ZSkKK3sKKwlpZiAoc3VwcG9ydGVkX21hbl92aWV3ZXIobmFtZSwgbGVuKSkKKwkJd2FybmluZygiJyVzJzogY21kIGZvciBzdXBwb3J0ZWQgbWFuIHZpZXdlci5cbiIKKwkJCSJQbGVhc2UgY29uc2lkZXIgdXNpbmcgJ21hbi48dG9vbD4ucGF0aCcgaW5zdGVhZC4iLAorCQkJbmFtZSk7CisJZWxzZQorCQlkb19hZGRfbWFuX3ZpZXdlcl9pbmZvKG5hbWUsIGxlbiwgdmFsdWUpOworCisJcmV0dXJuIDA7Cit9CisKK3N0YXRpYyBpbnQgYWRkX21hbl92aWV3ZXJfaW5mbyhjb25zdCBjaGFyICp2YXIsIGNvbnN0IGNoYXIgKnZhbHVlKQoreworCWNvbnN0IGNoYXIgKm5hbWUgPSB2YXIgKyA0OworCWNvbnN0IGNoYXIgKnN1YmtleSA9IHN0cnJjaHIobmFtZSwgJy4nKTsKKworCWlmICghc3Via2V5KQorCQlyZXR1cm4gZXJyb3IoIkNvbmZpZyB3aXRoIG5vIGtleSBmb3IgbWFuIHZpZXdlcjogJXMiLCBuYW1lKTsKKworCWlmICghc3RyY21wKHN1YmtleSwgIi5wYXRoIikpIHsKKwkJaWYgKCF2YWx1ZSkKKwkJCXJldHVybiBjb25maWdfZXJyb3Jfbm9uYm9vbCh2YXIpOworCQlyZXR1cm4gYWRkX21hbl92aWV3ZXJfcGF0aChuYW1lLCBzdWJrZXkgLSBuYW1lLCB2YWx1ZSk7CisJfQorCWlmICghc3RyY21wKHN1YmtleSwgIi5jbWQiKSkgeworCQlpZiAoIXZhbHVlKQorCQkJcmV0dXJuIGNvbmZpZ19lcnJvcl9ub25ib29sKHZhcik7CisJCXJldHVybiBhZGRfbWFuX3ZpZXdlcl9jbWQobmFtZSwgc3Via2V5IC0gbmFtZSwgdmFsdWUpOworCX0KKworCXdhcm5pbmcoIiclcyc6IHVuc3VwcG9ydGVkIG1hbiB2aWV3ZXIgc3ViIGtleS4iLCBzdWJrZXkpOworCXJldHVybiAwOworfQorCitzdGF0aWMgaW50IHBlcmZfaGVscF9jb25maWcoY29uc3QgY2hhciAqdmFyLCBjb25zdCBjaGFyICp2YWx1ZSwgdm9pZCAqY2IpCit7CisJaWYgKCFzdHJjbXAodmFyLCAiaGVscC5mb3JtYXQiKSkgeworCQlpZiAoIXZhbHVlKQorCQkJcmV0dXJuIGNvbmZpZ19lcnJvcl9ub25ib29sKHZhcik7CisJCWhlbHBfZm9ybWF0ID0gcGFyc2VfaGVscF9mb3JtYXQodmFsdWUpOworCQlyZXR1cm4gMDsKKwl9CisJaWYgKCFzdHJjbXAodmFyLCAibWFuLnZpZXdlciIpKSB7CisJCWlmICghdmFsdWUpCisJCQlyZXR1cm4gY29uZmlnX2Vycm9yX25vbmJvb2wodmFyKTsKKwkJYWRkX21hbl92aWV3ZXIodmFsdWUpOworCQlyZXR1cm4gMDsKKwl9CisJaWYgKCFwcmVmaXhjbXAodmFyLCAibWFuLiIpKQorCQlyZXR1cm4gYWRkX21hbl92aWV3ZXJfaW5mbyh2YXIsIHZhbHVlKTsKKworCXJldHVybiBwZXJmX2RlZmF1bHRfY29uZmlnKHZhciwgdmFsdWUsIGNiKTsKK30KKworc3RhdGljIHN0cnVjdCBjbWRuYW1lcyBtYWluX2NtZHMsIG90aGVyX2NtZHM7CisKK3ZvaWQgbGlzdF9jb21tb25fY21kc19oZWxwKHZvaWQpCit7CisJaW50IGksIGxvbmdlc3QgPSAwOworCisJZm9yIChpID0gMDsgaSA8IEFSUkFZX1NJWkUoY29tbW9uX2NtZHMpOyBpKyspIHsKKwkJaWYgKGxvbmdlc3QgPCBzdHJsZW4oY29tbW9uX2NtZHNbaV0ubmFtZSkpCisJCQlsb25nZXN0ID0gc3RybGVuKGNvbW1vbl9jbWRzW2ldLm5hbWUpOworCX0KKworCXB1dHMoIiBUaGUgbW9zdCBjb21tb25seSB1c2VkIHBlcmYgY29tbWFuZHMgYXJlOiIpOworCWZvciAoaSA9IDA7IGkgPCBBUlJBWV9TSVpFKGNvbW1vbl9jbWRzKTsgaSsrKSB7CisJCXByaW50ZigiICAgJXMgICAiLCBjb21tb25fY21kc1tpXS5uYW1lKTsKKwkJbXB1dF9jaGFyKCcgJywgbG9uZ2VzdCAtIHN0cmxlbihjb21tb25fY21kc1tpXS5uYW1lKSk7CisJCXB1dHMoY29tbW9uX2NtZHNbaV0uaGVscCk7CisJfQorfQorCitzdGF0aWMgaW50IGlzX3BlcmZfY29tbWFuZChjb25zdCBjaGFyICpzKQoreworCXJldHVybiBpc19pbl9jbWRsaXN0KCZtYWluX2NtZHMsIHMpIHx8CisJCWlzX2luX2NtZGxpc3QoJm90aGVyX2NtZHMsIHMpOworfQorCitzdGF0aWMgY29uc3QgY2hhciAqcHJlcGVuZChjb25zdCBjaGFyICpwcmVmaXgsIGNvbnN0IGNoYXIgKmNtZCkKK3sKKwlzaXplX3QgcHJlX2xlbiA9IHN0cmxlbihwcmVmaXgpOworCXNpemVfdCBjbWRfbGVuID0gc3RybGVuKGNtZCk7CisJY2hhciAqcCA9IG1hbGxvYyhwcmVfbGVuICsgY21kX2xlbiArIDEpOworCW1lbWNweShwLCBwcmVmaXgsIHByZV9sZW4pOworCXN0cmNweShwICsgcHJlX2xlbiwgY21kKTsKKwlyZXR1cm4gcDsKK30KKworc3RhdGljIGNvbnN0IGNoYXIgKmNtZF90b19wYWdlKGNvbnN0IGNoYXIgKnBlcmZfY21kKQoreworCWlmICghcGVyZl9jbWQpCisJCXJldHVybiAicGVyZiI7CisJZWxzZSBpZiAoIXByZWZpeGNtcChwZXJmX2NtZCwgInBlcmYiKSkKKwkJcmV0dXJuIHBlcmZfY21kOworCWVsc2UgaWYgKGlzX3BlcmZfY29tbWFuZChwZXJmX2NtZCkpCisJCXJldHVybiBwcmVwZW5kKCJwZXJmLSIsIHBlcmZfY21kKTsKKwllbHNlCisJCXJldHVybiBwcmVwZW5kKCJwZXJmLSIsIHBlcmZfY21kKTsKK30KKworc3RhdGljIHZvaWQgc2V0dXBfbWFuX3BhdGgodm9pZCkKK3sKKwlzdHJ1Y3Qgc3RyYnVmIG5ld19wYXRoID0gU1RSQlVGX0lOSVQ7CisJY29uc3QgY2hhciAqb2xkX3BhdGggPSBnZXRlbnYoIk1BTlBBVEgiKTsKKworCS8qIFdlIHNob3VsZCBhbHdheXMgcHV0ICc6JyBhZnRlciBvdXIgcGF0aC4gSWYgdGhlcmUgaXMgbm8KKwkgKiBvbGRfcGF0aCwgdGhlICc6JyBhdCB0aGUgZW5kIHdpbGwgbGV0ICdtYW4nIHRvIHRyeQorCSAqIHN5c3RlbS13aWRlIHBhdGhzIGFmdGVyIG91cnMgdG8gZmluZCB0aGUgbWFudWFsIHBhZ2UuIElmCisJICogdGhlcmUgaXMgb2xkX3BhdGgsIHdlIG5lZWQgJzonIGFzIGRlbGltaXRlci4gKi8KKwlzdHJidWZfYWRkc3RyKCZuZXdfcGF0aCwgc3lzdGVtX3BhdGgoUEVSRl9NQU5fUEFUSCkpOworCXN0cmJ1Zl9hZGRjaCgmbmV3X3BhdGgsICc6Jyk7CisJaWYgKG9sZF9wYXRoKQorCQlzdHJidWZfYWRkc3RyKCZuZXdfcGF0aCwgb2xkX3BhdGgpOworCisJc2V0ZW52KCJNQU5QQVRIIiwgbmV3X3BhdGguYnVmLCAxKTsKKworCXN0cmJ1Zl9yZWxlYXNlKCZuZXdfcGF0aCk7Cit9CisKK3N0YXRpYyB2b2lkIGV4ZWNfdmlld2VyKGNvbnN0IGNoYXIgKm5hbWUsIGNvbnN0IGNoYXIgKnBhZ2UpCit7CisJY29uc3QgY2hhciAqaW5mbyA9IGdldF9tYW5fdmlld2VyX2luZm8obmFtZSk7CisKKwlpZiAoIXN0cmNhc2VjbXAobmFtZSwgIm1hbiIpKQorCQlleGVjX21hbl9tYW4oaW5mbywgcGFnZSk7CisJZWxzZSBpZiAoIXN0cmNhc2VjbXAobmFtZSwgIndvbWFuIikpCisJCWV4ZWNfd29tYW5fZW1hY3MoaW5mbywgcGFnZSk7CisJZWxzZSBpZiAoIXN0cmNhc2VjbXAobmFtZSwgImtvbnF1ZXJvciIpKQorCQlleGVjX21hbl9rb25xdWVyb3IoaW5mbywgcGFnZSk7CisJZWxzZSBpZiAoaW5mbykKKwkJZXhlY19tYW5fY21kKGluZm8sIHBhZ2UpOworCWVsc2UKKwkJd2FybmluZygiJyVzJzogdW5rbm93biBtYW4gdmlld2VyLiIsIG5hbWUpOworfQorCitzdGF0aWMgdm9pZCBzaG93X21hbl9wYWdlKGNvbnN0IGNoYXIgKnBlcmZfY21kKQoreworCXN0cnVjdCBtYW5fdmlld2VyX2xpc3QgKnZpZXdlcjsKKwljb25zdCBjaGFyICpwYWdlID0gY21kX3RvX3BhZ2UocGVyZl9jbWQpOworCWNvbnN0IGNoYXIgKmZhbGxiYWNrID0gZ2V0ZW52KCJQRVJGX01BTl9WSUVXRVIiKTsKKworCXNldHVwX21hbl9wYXRoKCk7CisJZm9yICh2aWV3ZXIgPSBtYW5fdmlld2VyX2xpc3Q7IHZpZXdlcjsgdmlld2VyID0gdmlld2VyLT5uZXh0KQorCXsKKwkJZXhlY192aWV3ZXIodmlld2VyLT5uYW1lLCBwYWdlKTsgLyogd2lsbCByZXR1cm4gd2hlbiB1bmFibGUgKi8KKwl9CisJaWYgKGZhbGxiYWNrKQorCQlleGVjX3ZpZXdlcihmYWxsYmFjaywgcGFnZSk7CisJZXhlY192aWV3ZXIoIm1hbiIsIHBhZ2UpOworCWRpZSgibm8gbWFuIHZpZXdlciBoYW5kbGVkIHRoZSByZXF1ZXN0Iik7Cit9CisKK3N0YXRpYyB2b2lkIHNob3dfaW5mb19wYWdlKGNvbnN0IGNoYXIgKnBlcmZfY21kKQoreworCWNvbnN0IGNoYXIgKnBhZ2UgPSBjbWRfdG9fcGFnZShwZXJmX2NtZCk7CisJc2V0ZW52KCJJTkZPUEFUSCIsIHN5c3RlbV9wYXRoKFBFUkZfSU5GT19QQVRIKSwgMSk7CisJZXhlY2xwKCJpbmZvIiwgImluZm8iLCAicGVyZm1hbiIsIHBhZ2UsIE5VTEwpOworfQorCitzdGF0aWMgdm9pZCBnZXRfaHRtbF9wYWdlX3BhdGgoc3RydWN0IHN0cmJ1ZiAqcGFnZV9wYXRoLCBjb25zdCBjaGFyICpwYWdlKQoreworCXN0cnVjdCBzdGF0IHN0OworCWNvbnN0IGNoYXIgKmh0bWxfcGF0aCA9IHN5c3RlbV9wYXRoKFBFUkZfSFRNTF9QQVRIKTsKKworCS8qIENoZWNrIHRoYXQgd2UgaGF2ZSBhIHBlcmYgZG9jdW1lbnRhdGlvbiBkaXJlY3RvcnkuICovCisJaWYgKHN0YXQobWtwYXRoKCIlcy9wZXJmLmh0bWwiLCBodG1sX3BhdGgpLCAmc3QpCisJICAgIHx8ICFTX0lTUkVHKHN0LnN0X21vZGUpKQorCQlkaWUoIiclcyc6IG5vdCBhIGRvY3VtZW50YXRpb24gZGlyZWN0b3J5LiIsIGh0bWxfcGF0aCk7CisKKwlzdHJidWZfaW5pdChwYWdlX3BhdGgsIDApOworCXN0cmJ1Zl9hZGRmKHBhZ2VfcGF0aCwgIiVzLyVzLmh0bWwiLCBodG1sX3BhdGgsIHBhZ2UpOworfQorCisvKgorICogSWYgb3Blbl9odG1sIGlzIG5vdCBkZWZpbmVkIGluIGEgcGxhdGZvcm0tc3BlY2lmaWMgd2F5IChzZWUgZm9yCisgKiBleGFtcGxlIGNvbXBhdC9taW5ndy5oKSwgd2UgdXNlIHRoZSBzY3JpcHQgd2ViLS1icm93c2UgdG8gZGlzcGxheQorICogSFRNTC4KKyAqLworI2lmbmRlZiBvcGVuX2h0bWwKK3N0YXRpYyB2b2lkIG9wZW5faHRtbChjb25zdCBjaGFyICpwYXRoKQoreworCWV4ZWNsX3BlcmZfY21kKCJ3ZWItLWJyb3dzZSIsICItYyIsICJoZWxwLmJyb3dzZXIiLCBwYXRoLCBOVUxMKTsKK30KKyNlbmRpZgorCitzdGF0aWMgdm9pZCBzaG93X2h0bWxfcGFnZShjb25zdCBjaGFyICpwZXJmX2NtZCkKK3sKKwljb25zdCBjaGFyICpwYWdlID0gY21kX3RvX3BhZ2UocGVyZl9jbWQpOworCXN0cnVjdCBzdHJidWYgcGFnZV9wYXRoOyAvKiBpdCBsZWFrcyBidXQgd2UgZXhlYyBiZWxsb3cgKi8KKworCWdldF9odG1sX3BhZ2VfcGF0aCgmcGFnZV9wYXRoLCBwYWdlKTsKKworCW9wZW5faHRtbChwYWdlX3BhdGguYnVmKTsKK30KKworaW50IGNtZF9oZWxwKGludCBhcmdjLCBjb25zdCBjaGFyICoqYXJndiwgY29uc3QgY2hhciAqcHJlZml4KQoreworCWNvbnN0IGNoYXIgKmFsaWFzOworCWxvYWRfY29tbWFuZF9saXN0KCJwZXJmLSIsICZtYWluX2NtZHMsICZvdGhlcl9jbWRzKTsKKworCXBlcmZfY29uZmlnKHBlcmZfaGVscF9jb25maWcsIE5VTEwpOworCisJYXJnYyA9IHBhcnNlX29wdGlvbnMoYXJnYywgYXJndiwgYnVpbHRpbl9oZWxwX29wdGlvbnMsCisJCQlidWlsdGluX2hlbHBfdXNhZ2UsIDApOworCisJaWYgKHNob3dfYWxsKSB7CisJCXByaW50ZigiXG4gdXNhZ2U6ICVzXG5cbiIsIHBlcmZfdXNhZ2Vfc3RyaW5nKTsKKwkJbGlzdF9jb21tYW5kcygicGVyZiBjb21tYW5kcyIsICZtYWluX2NtZHMsICZvdGhlcl9jbWRzKTsKKwkJcHJpbnRmKCIgJXNcblxuIiwgcGVyZl9tb3JlX2luZm9fc3RyaW5nKTsKKwkJcmV0dXJuIDA7CisJfQorCisJaWYgKCFhcmd2WzBdKSB7CisJCXByaW50ZigiXG4gdXNhZ2U6ICVzXG5cbiIsIHBlcmZfdXNhZ2Vfc3RyaW5nKTsKKwkJbGlzdF9jb21tb25fY21kc19oZWxwKCk7CisJCXByaW50ZigiXG4gJXNcblxuIiwgcGVyZl9tb3JlX2luZm9fc3RyaW5nKTsKKwkJcmV0dXJuIDA7CisJfQorCisJYWxpYXMgPSBhbGlhc19sb29rdXAoYXJndlswXSk7CisJaWYgKGFsaWFzICYmICFpc19wZXJmX2NvbW1hbmQoYXJndlswXSkpIHsKKwkJcHJpbnRmKCJgcGVyZiAlcycgaXMgYWxpYXNlZCB0byBgJXMnXG4iLCBhcmd2WzBdLCBhbGlhcyk7CisJCXJldHVybiAwOworCX0KKworCXN3aXRjaCAoaGVscF9mb3JtYXQpIHsKKwljYXNlIEhFTFBfRk9STUFUX01BTjoKKwkJc2hvd19tYW5fcGFnZShhcmd2WzBdKTsKKwkJYnJlYWs7CisJY2FzZSBIRUxQX0ZPUk1BVF9JTkZPOgorCQlzaG93X2luZm9fcGFnZShhcmd2WzBdKTsKKwkJYnJlYWs7CisJY2FzZSBIRUxQX0ZPUk1BVF9XRUI6CisJCXNob3dfaHRtbF9wYWdlKGFyZ3ZbMF0pOworCQlicmVhazsKKwl9CisKKwlyZXR1cm4gMDsKK30KZGlmZiAtLWdpdCBhL3Rvb2xzL3BlcmYvYnVpbHRpbi1saXN0LmMgYi90b29scy9wZXJmL2J1aWx0aW4tbGlzdC5jCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLmZlNjBlMzcKLS0tIC9kZXYvbnVsbAorKysgYi90b29scy9wZXJmL2J1aWx0aW4tbGlzdC5jCkBAIC0wLDAgKzEsMjAgQEAKKy8qCisgKiBidWlsdGluLWxpc3QuYworICoKKyAqIEJ1aWx0aW4gbGlzdCBjb21tYW5kOiBsaXN0IGFsbCBldmVudCB0eXBlcworICoKKyAqIENvcHlyaWdodCAoQykgMjAwOSwgVGhvbWFzIEdsZWl4bmVyIDx0Z2x4QGxpbnV0cm9uaXguZGU+CisgKiBDb3B5cmlnaHQgKEMpIDIwMDgtMjAwOSwgUmVkIEhhdCBJbmMsIEluZ28gTW9sbmFyIDxtaW5nb0ByZWRoYXQuY29tPgorICovCisjaW5jbHVkZSAiYnVpbHRpbi5oIgorCisjaW5jbHVkZSAicGVyZi5oIgorCisjaW5jbHVkZSAidXRpbC9wYXJzZS1vcHRpb25zLmgiCisjaW5jbHVkZSAidXRpbC9wYXJzZS1ldmVudHMuaCIKKworaW50IGNtZF9saXN0KGludCBhcmdjLCBjb25zdCBjaGFyICoqYXJndiwgY29uc3QgY2hhciAqcHJlZml4KQoreworCXByaW50X2V2ZW50cygpOworCXJldHVybiAwOworfQpkaWZmIC0tZ2l0IGEvdG9vbHMvcGVyZi9idWlsdGluLXJlY29yZC5jIGIvdG9vbHMvcGVyZi9idWlsdGluLXJlY29yZC5jCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjI5MjU5ZTcKLS0tIC9kZXYvbnVsbAorKysgYi90b29scy9wZXJmL2J1aWx0aW4tcmVjb3JkLmMKQEAgLTAsMCArMSw1ODIgQEAKKy8qCisgKiBidWlsdGluLXJlY29yZC5jCisgKgorICogQnVpbHRpbiByZWNvcmQgY29tbWFuZDogUmVjb3JkIHRoZSBwcm9maWxlIG9mIGEgd29ya2xvYWQKKyAqIChvciBhIENQVSwgb3IgYSBQSUQpIGludG8gdGhlIHBlcmYuZGF0YSBvdXRwdXQgZmlsZSAtIGZvcgorICogbGF0ZXIgYW5hbHlzaXMgdmlhIHBlcmYgcmVwb3J0LgorICovCisjaW5jbHVkZSAiYnVpbHRpbi5oIgorCisjaW5jbHVkZSAicGVyZi5oIgorCisjaW5jbHVkZSAidXRpbC91dGlsLmgiCisjaW5jbHVkZSAidXRpbC9wYXJzZS1vcHRpb25zLmgiCisjaW5jbHVkZSAidXRpbC9wYXJzZS1ldmVudHMuaCIKKyNpbmNsdWRlICJ1dGlsL3N0cmluZy5oIgorCisjaW5jbHVkZSA8dW5pc3RkLmg+CisjaW5jbHVkZSA8c2NoZWQuaD4KKworI2RlZmluZSBBTElHTih4LCBhKQkJX19BTElHTl9NQVNLKHgsICh0eXBlb2YoeCkpKGEpLTEpCisjZGVmaW5lIF9fQUxJR05fTUFTSyh4LCBtYXNrKQkoKCh4KSsobWFzaykpJn4obWFzaykpCisKK3N0YXRpYyBpbnQJCQlmZFtNQVhfTlJfQ1BVU11bTUFYX0NPVU5URVJTXTsKKworc3RhdGljIGxvbmcJCQlkZWZhdWx0X2ludGVydmFsCQk9IDEwMDAwMDsKKworc3RhdGljIGludAkJCW5yX2NwdXMJCQkJPSAwOworc3RhdGljIHVuc2lnbmVkIGludAkJcGFnZV9zaXplOworc3RhdGljIHVuc2lnbmVkIGludAkJbW1hcF9wYWdlcwkJCT0gMTI4Oworc3RhdGljIGludAkJCWZyZXEJCQkJPSAwOworc3RhdGljIGludAkJCW91dHB1dDsKK3N0YXRpYyBjb25zdCBjaGFyCQkqb3V0cHV0X25hbWUJCQk9ICJwZXJmLmRhdGEiOworc3RhdGljIGludAkJCWdyb3VwCQkJCT0gMDsKK3N0YXRpYyB1bnNpZ25lZCBpbnQJCXJlYWx0aW1lX3ByaW8JCQk9IDA7CitzdGF0aWMgaW50CQkJc3lzdGVtX3dpZGUJCQk9IDA7CitzdGF0aWMgcGlkX3QJCQl0YXJnZXRfcGlkCQkJPSAtMTsKK3N0YXRpYyBpbnQJCQlpbmhlcml0CQkJCT0gMTsKK3N0YXRpYyBpbnQJCQlmb3JjZQkJCQk9IDA7CitzdGF0aWMgaW50CQkJYXBwZW5kX2ZpbGUJCQk9IDA7CitzdGF0aWMgaW50CQkJdmVyYm9zZQkJCQk9IDA7CisKK3N0YXRpYyBsb25nCQkJc2FtcGxlczsKK3N0YXRpYyBzdHJ1Y3QgdGltZXZhbAkJbGFzdF9yZWFkOworc3RhdGljIHN0cnVjdCB0aW1ldmFsCQl0aGlzX3JlYWQ7CisKK3N0YXRpYyBfX3U2NAkJCWJ5dGVzX3dyaXR0ZW47CisKK3N0YXRpYyBzdHJ1Y3QgcG9sbGZkCQlldmVudF9hcnJheVtNQVhfTlJfQ1BVUyAqIE1BWF9DT1VOVEVSU107CisKK3N0YXRpYyBpbnQJCQlucl9wb2xsOworc3RhdGljIGludAkJCW5yX2NwdTsKKworc3RydWN0IG1tYXBfZXZlbnQgeworCXN0cnVjdCBwZXJmX2V2ZW50X2hlYWRlcgloZWFkZXI7CisJX191MzIJCQkJcGlkOworCV9fdTMyCQkJCXRpZDsKKwlfX3U2NAkJCQlzdGFydDsKKwlfX3U2NAkJCQlsZW47CisJX191NjQJCQkJcGdvZmY7CisJY2hhcgkJCQlmaWxlbmFtZVtQQVRIX01BWF07Cit9OworCitzdHJ1Y3QgY29tbV9ldmVudCB7CisJc3RydWN0IHBlcmZfZXZlbnRfaGVhZGVyCWhlYWRlcjsKKwlfX3UzMgkJCQlwaWQ7CisJX191MzIJCQkJdGlkOworCWNoYXIJCQkJY29tbVsxNl07Cit9OworCisKK3N0cnVjdCBtbWFwX2RhdGEgeworCWludAkJCWNvdW50ZXI7CisJdm9pZAkJCSpiYXNlOworCXVuc2lnbmVkIGludAkJbWFzazsKKwl1bnNpZ25lZCBpbnQJCXByZXY7Cit9OworCitzdGF0aWMgc3RydWN0IG1tYXBfZGF0YQkJbW1hcF9hcnJheVtNQVhfTlJfQ1BVU11bTUFYX0NPVU5URVJTXTsKKworc3RhdGljIHVuc2lnbmVkIGludCBtbWFwX3JlYWRfaGVhZChzdHJ1Y3QgbW1hcF9kYXRhICptZCkKK3sKKwlzdHJ1Y3QgcGVyZl9jb3VudGVyX21tYXBfcGFnZSAqcGMgPSBtZC0+YmFzZTsKKwlpbnQgaGVhZDsKKworCWhlYWQgPSBwYy0+ZGF0YV9oZWFkOworCXJtYigpOworCisJcmV0dXJuIGhlYWQ7Cit9CisKK3N0YXRpYyB2b2lkIG1tYXBfcmVhZChzdHJ1Y3QgbW1hcF9kYXRhICptZCkKK3sKKwl1bnNpZ25lZCBpbnQgaGVhZCA9IG1tYXBfcmVhZF9oZWFkKG1kKTsKKwl1bnNpZ25lZCBpbnQgb2xkID0gbWQtPnByZXY7CisJdW5zaWduZWQgY2hhciAqZGF0YSA9IG1kLT5iYXNlICsgcGFnZV9zaXplOworCXVuc2lnbmVkIGxvbmcgc2l6ZTsKKwl2b2lkICpidWY7CisJaW50IGRpZmY7CisKKwlnZXR0aW1lb2ZkYXkoJnRoaXNfcmVhZCwgTlVMTCk7CisKKwkvKgorCSAqIElmIHdlJ3JlIGZ1cnRoZXIgYmVoaW5kIHRoYW4gaGFsZiB0aGUgYnVmZmVyLCB0aGVyZSdzIGEgY2hhbmNlCisJICogdGhlIHdyaXRlciB3aWxsIGJpdGUgb3VyIHRhaWwgYW5kIG1lc3MgdXAgdGhlIHNhbXBsZXMgdW5kZXIgdXMuCisJICoKKwkgKiBJZiB3ZSBzb21laG93IGVuZGVkIHVwIGFoZWFkIG9mIHRoZSBoZWFkLCB3ZSBnb3QgbWVzc2VkIHVwLgorCSAqCisJICogSW4gZWl0aGVyIGNhc2UsIHRydW5jYXRlIGFuZCByZXN0YXJ0IGF0IGhlYWQuCisJICovCisJZGlmZiA9IGhlYWQgLSBvbGQ7CisJaWYgKGRpZmYgPiBtZC0+bWFzayAvIDIgfHwgZGlmZiA8IDApIHsKKwkJc3RydWN0IHRpbWV2YWwgaXY7CisJCXVuc2lnbmVkIGxvbmcgbXNlY3M7CisKKwkJdGltZXJzdWIoJnRoaXNfcmVhZCwgJmxhc3RfcmVhZCwgJml2KTsKKwkJbXNlY3MgPSBpdi50dl9zZWMqMTAwMCArIGl2LnR2X3VzZWMvMTAwMDsKKworCQlmcHJpbnRmKHN0ZGVyciwgIldBUk5JTkc6IGZhaWxlZCB0byBrZWVwIHVwIHdpdGggbW1hcCBkYXRhLiIKKwkJCQkiICBMYXN0IHJlYWQgJWx1IG1zZWNzIGFnby5cbiIsIG1zZWNzKTsKKworCQkvKgorCQkgKiBoZWFkIHBvaW50cyB0byBhIGtub3duIGdvb2QgZW50cnksIHN0YXJ0IHRoZXJlLgorCQkgKi8KKwkJb2xkID0gaGVhZDsKKwl9CisKKwlsYXN0X3JlYWQgPSB0aGlzX3JlYWQ7CisKKwlpZiAob2xkICE9IGhlYWQpCisJCXNhbXBsZXMrKzsKKworCXNpemUgPSBoZWFkIC0gb2xkOworCisJaWYgKChvbGQgJiBtZC0+bWFzaykgKyBzaXplICE9IChoZWFkICYgbWQtPm1hc2spKSB7CisJCWJ1ZiA9ICZkYXRhW29sZCAmIG1kLT5tYXNrXTsKKwkJc2l6ZSA9IG1kLT5tYXNrICsgMSAtIChvbGQgJiBtZC0+bWFzayk7CisJCW9sZCArPSBzaXplOworCisJCXdoaWxlIChzaXplKSB7CisJCQlpbnQgcmV0ID0gd3JpdGUob3V0cHV0LCBidWYsIHNpemUpOworCisJCQlpZiAocmV0IDwgMCkKKwkJCQlkaWUoImZhaWxlZCB0byB3cml0ZSIpOworCisJCQlzaXplIC09IHJldDsKKwkJCWJ1ZiArPSByZXQ7CisKKwkJCWJ5dGVzX3dyaXR0ZW4gKz0gcmV0OworCQl9CisJfQorCisJYnVmID0gJmRhdGFbb2xkICYgbWQtPm1hc2tdOworCXNpemUgPSBoZWFkIC0gb2xkOworCW9sZCArPSBzaXplOworCisJd2hpbGUgKHNpemUpIHsKKwkJaW50IHJldCA9IHdyaXRlKG91dHB1dCwgYnVmLCBzaXplKTsKKworCQlpZiAocmV0IDwgMCkKKwkJCWRpZSgiZmFpbGVkIHRvIHdyaXRlIik7CisKKwkJc2l6ZSAtPSByZXQ7CisJCWJ1ZiArPSByZXQ7CisKKwkJYnl0ZXNfd3JpdHRlbiArPSByZXQ7CisJfQorCisJbWQtPnByZXYgPSBvbGQ7Cit9CisKK3N0YXRpYyB2b2xhdGlsZSBpbnQgZG9uZSA9IDA7CitzdGF0aWMgdm9sYXRpbGUgaW50IHNpZ25yID0gLTE7CisKK3N0YXRpYyB2b2lkIHNpZ19oYW5kbGVyKGludCBzaWcpCit7CisJZG9uZSA9IDE7CisJc2lnbnIgPSBzaWc7Cit9CisKK3N0YXRpYyB2b2lkIHNpZ19hdGV4aXQodm9pZCkKK3sKKwlpZiAoc2lnbnIgPT0gLTEpCisJCXJldHVybjsKKworCXNpZ25hbChzaWduciwgU0lHX0RGTCk7CisJa2lsbChnZXRwaWQoKSwgc2lnbnIpOworfQorCitzdGF0aWMgdm9pZCBwaWRfc3ludGhlc2l6ZV9jb21tX2V2ZW50KHBpZF90IHBpZCwgaW50IGZ1bGwpCit7CisJc3RydWN0IGNvbW1fZXZlbnQgY29tbV9ldjsKKwljaGFyIGZpbGVuYW1lW1BBVEhfTUFYXTsKKwljaGFyIGJmW0JVRlNJWl07CisJaW50IGZkLCByZXQ7CisJc2l6ZV90IHNpemU7CisJY2hhciAqZmllbGQsICpzZXA7CisJRElSICp0YXNrczsKKwlzdHJ1Y3QgZGlyZW50IGRpcmVudCwgKm5leHQ7CisKKwlzbnByaW50ZihmaWxlbmFtZSwgc2l6ZW9mKGZpbGVuYW1lKSwgIi9wcm9jLyVkL3N0YXQiLCBwaWQpOworCisJZmQgPSBvcGVuKGZpbGVuYW1lLCBPX1JET05MWSk7CisJaWYgKGZkIDwgMCkgeworCQlmcHJpbnRmKHN0ZGVyciwgImNvdWxkbid0IG9wZW4gJXNcbiIsIGZpbGVuYW1lKTsKKwkJZXhpdChFWElUX0ZBSUxVUkUpOworCX0KKwlpZiAocmVhZChmZCwgYmYsIHNpemVvZihiZikpIDwgMCkgeworCQlmcHJpbnRmKHN0ZGVyciwgImNvdWxkbid0IHJlYWQgJXNcbiIsIGZpbGVuYW1lKTsKKwkJZXhpdChFWElUX0ZBSUxVUkUpOworCX0KKwljbG9zZShmZCk7CisKKwkvKiA5MDI3IChjYXQpIFIgNjc0NyA5MDI3IDY3NDcgMzQ4MTYgOTAyNyAuLi4gKi8KKwltZW1zZXQoJmNvbW1fZXYsIDAsIHNpemVvZihjb21tX2V2KSk7CisJZmllbGQgPSBzdHJjaHIoYmYsICcoJyk7CisJaWYgKGZpZWxkID09IE5VTEwpCisJCWdvdG8gb3V0X2ZhaWx1cmU7CisJc2VwID0gc3RyY2hyKCsrZmllbGQsICcpJyk7CisJaWYgKHNlcCA9PSBOVUxMKQorCQlnb3RvIG91dF9mYWlsdXJlOworCXNpemUgPSBzZXAgLSBmaWVsZDsKKwltZW1jcHkoY29tbV9ldi5jb21tLCBmaWVsZCwgc2l6ZSsrKTsKKworCWNvbW1fZXYucGlkID0gcGlkOworCWNvbW1fZXYuaGVhZGVyLnR5cGUgPSBQRVJGX0VWRU5UX0NPTU07CisJc2l6ZSA9IEFMSUdOKHNpemUsIHNpemVvZihfX3U2NCkpOworCWNvbW1fZXYuaGVhZGVyLnNpemUgPSBzaXplb2YoY29tbV9ldikgLSAoc2l6ZW9mKGNvbW1fZXYuY29tbSkgLSBzaXplKTsKKworCWlmICghZnVsbCkgeworCQljb21tX2V2LnRpZCA9IHBpZDsKKworCQlyZXQgPSB3cml0ZShvdXRwdXQsICZjb21tX2V2LCBjb21tX2V2LmhlYWRlci5zaXplKTsKKwkJaWYgKHJldCA8IDApIHsKKwkJCXBlcnJvcigiZmFpbGVkIHRvIHdyaXRlIik7CisJCQlleGl0KC0xKTsKKwkJfQorCQlyZXR1cm47CisJfQorCisJc25wcmludGYoZmlsZW5hbWUsIHNpemVvZihmaWxlbmFtZSksICIvcHJvYy8lZC90YXNrIiwgcGlkKTsKKworCXRhc2tzID0gb3BlbmRpcihmaWxlbmFtZSk7CisJd2hpbGUgKCFyZWFkZGlyX3IodGFza3MsICZkaXJlbnQsICZuZXh0KSAmJiBuZXh0KSB7CisJCWNoYXIgKmVuZDsKKwkJcGlkID0gc3RydG9sKGRpcmVudC5kX25hbWUsICZlbmQsIDEwKTsKKwkJaWYgKCplbmQpCisJCQljb250aW51ZTsKKworCQljb21tX2V2LnRpZCA9IHBpZDsKKworCQlyZXQgPSB3cml0ZShvdXRwdXQsICZjb21tX2V2LCBjb21tX2V2LmhlYWRlci5zaXplKTsKKwkJaWYgKHJldCA8IDApIHsKKwkJCXBlcnJvcigiZmFpbGVkIHRvIHdyaXRlIik7CisJCQlleGl0KC0xKTsKKwkJfQorCX0KKwljbG9zZWRpcih0YXNrcyk7CisJcmV0dXJuOworCitvdXRfZmFpbHVyZToKKwlmcHJpbnRmKHN0ZGVyciwgImNvdWxkbid0IGdldCBDT01NIGFuZCBwZ2lkLCBtYWxmb3JtZWQgJXNcbiIsCisJCWZpbGVuYW1lKTsKKwlleGl0KEVYSVRfRkFJTFVSRSk7Cit9CisKK3N0YXRpYyB2b2lkIHBpZF9zeW50aGVzaXplX21tYXBfc2FtcGxlcyhwaWRfdCBwaWQpCit7CisJY2hhciBmaWxlbmFtZVtQQVRIX01BWF07CisJRklMRSAqZnA7CisKKwlzbnByaW50ZihmaWxlbmFtZSwgc2l6ZW9mKGZpbGVuYW1lKSwgIi9wcm9jLyVkL21hcHMiLCBwaWQpOworCisJZnAgPSBmb3BlbihmaWxlbmFtZSwgInIiKTsKKwlpZiAoZnAgPT0gTlVMTCkgeworCQlmcHJpbnRmKHN0ZGVyciwgImNvdWxkbid0IG9wZW4gJXNcbiIsIGZpbGVuYW1lKTsKKwkJZXhpdChFWElUX0ZBSUxVUkUpOworCX0KKwl3aGlsZSAoMSkgeworCQljaGFyIGJmW0JVRlNJWl0sICpwYmYgPSBiZjsKKwkJc3RydWN0IG1tYXBfZXZlbnQgbW1hcF9ldiA9IHsKKwkJCS5oZWFkZXIudHlwZSA9IFBFUkZfRVZFTlRfTU1BUCwKKwkJfTsKKwkJaW50IG47CisJCXNpemVfdCBzaXplOworCQlpZiAoZmdldHMoYmYsIHNpemVvZihiZiksIGZwKSA9PSBOVUxMKQorCQkJYnJlYWs7CisKKwkJLyogMDA0MDAwMDAtMDA0MGMwMDAgci14cCAwMDAwMDAwMCBmZDowMSA0MTAzOCAgL2Jpbi9jYXQgKi8KKwkJbiA9IGhleDJ1NjQocGJmLCAmbW1hcF9ldi5zdGFydCk7CisJCWlmIChuIDwgMCkKKwkJCWNvbnRpbnVlOworCQlwYmYgKz0gbiArIDE7CisJCW4gPSBoZXgydTY0KHBiZiwgJm1tYXBfZXYubGVuKTsKKwkJaWYgKG4gPCAwKQorCQkJY29udGludWU7CisJCXBiZiArPSBuICsgMzsKKwkJaWYgKCpwYmYgPT0gJ3gnKSB7IC8qIHZtX2V4ZWMgKi8KKwkJCWNoYXIgKmV4ZWNuYW1lID0gc3RycmNocihiZiwgJyAnKTsKKworCQkJaWYgKGV4ZWNuYW1lID09IE5VTEwgfHwgZXhlY25hbWVbMV0gIT0gJy8nKQorCQkJCWNvbnRpbnVlOworCisJCQlleGVjbmFtZSArPSAxOworCQkJc2l6ZSA9IHN0cmxlbihleGVjbmFtZSk7CisJCQlleGVjbmFtZVtzaXplIC0gMV0gPSAnXDAnOyAvKiBSZW1vdmUgXG4gKi8KKwkJCW1lbWNweShtbWFwX2V2LmZpbGVuYW1lLCBleGVjbmFtZSwgc2l6ZSk7CisJCQlzaXplID0gQUxJR04oc2l6ZSwgc2l6ZW9mKF9fdTY0KSk7CisJCQltbWFwX2V2LmxlbiAtPSBtbWFwX2V2LnN0YXJ0OworCQkJbW1hcF9ldi5oZWFkZXIuc2l6ZSA9IChzaXplb2YobW1hcF9ldikgLQorCQkJCQkgICAgICAgKHNpemVvZihtbWFwX2V2LmZpbGVuYW1lKSAtIHNpemUpKTsKKwkJCW1tYXBfZXYucGlkID0gcGlkOworCQkJbW1hcF9ldi50aWQgPSBwaWQ7CisKKwkJCWlmICh3cml0ZShvdXRwdXQsICZtbWFwX2V2LCBtbWFwX2V2LmhlYWRlci5zaXplKSA8IDApIHsKKwkJCQlwZXJyb3IoImZhaWxlZCB0byB3cml0ZSIpOworCQkJCWV4aXQoLTEpOworCQkJfQorCQl9CisJfQorCisJZmNsb3NlKGZwKTsKK30KKworc3RhdGljIHZvaWQgc3ludGhlc2l6ZV9zYW1wbGVzKHZvaWQpCit7CisJRElSICpwcm9jOworCXN0cnVjdCBkaXJlbnQgZGlyZW50LCAqbmV4dDsKKworCXByb2MgPSBvcGVuZGlyKCIvcHJvYyIpOworCisJd2hpbGUgKCFyZWFkZGlyX3IocHJvYywgJmRpcmVudCwgJm5leHQpICYmIG5leHQpIHsKKwkJY2hhciAqZW5kOworCQlwaWRfdCBwaWQ7CisKKwkJcGlkID0gc3RydG9sKGRpcmVudC5kX25hbWUsICZlbmQsIDEwKTsKKwkJaWYgKCplbmQpIC8qIG9ubHkgaW50ZXJlc3RlZCBpbiBwcm9wZXIgbnVtZXJpY2FsIGRpcmVudHMgKi8KKwkJCWNvbnRpbnVlOworCisJCXBpZF9zeW50aGVzaXplX2NvbW1fZXZlbnQocGlkLCAxKTsKKwkJcGlkX3N5bnRoZXNpemVfbW1hcF9zYW1wbGVzKHBpZCk7CisJfQorCisJY2xvc2VkaXIocHJvYyk7Cit9CisKK3N0YXRpYyBpbnQgZ3JvdXBfZmQ7CisKK3N0YXRpYyB2b2lkIGNyZWF0ZV9jb3VudGVyKGludCBjb3VudGVyLCBpbnQgY3B1LCBwaWRfdCBwaWQpCit7CisJc3RydWN0IHBlcmZfY291bnRlcl9hdHRyICphdHRyID0gYXR0cnMgKyBjb3VudGVyOworCWludCB0cmFjayA9IDE7CisKKwlhdHRyLT5zYW1wbGVfdHlwZQk9IFBFUkZfU0FNUExFX0lQIHwgUEVSRl9TQU1QTEVfVElEOworCWlmIChmcmVxKSB7CisJCWF0dHItPnNhbXBsZV90eXBlCXw9IFBFUkZfU0FNUExFX1BFUklPRDsKKwkJYXR0ci0+ZnJlcQkJPSAxOworCQlhdHRyLT5zYW1wbGVfZnJlcQk9IGZyZXE7CisJfQorCWF0dHItPm1tYXAJCT0gdHJhY2s7CisJYXR0ci0+Y29tbQkJPSB0cmFjazsKKwlhdHRyLT5pbmhlcml0CQk9IChjcHUgPCAwKSAmJiBpbmhlcml0OworCWF0dHItPmRpc2FibGVkCQk9IDE7CisKKwl0cmFjayA9IDA7IC8qIG9ubHkgdGhlIGZpcnN0IGNvdW50ZXIgbmVlZHMgdGhlc2UgKi8KKwordHJ5X2FnYWluOgorCWZkW25yX2NwdV1bY291bnRlcl0gPSBzeXNfcGVyZl9jb3VudGVyX29wZW4oYXR0ciwgcGlkLCBjcHUsIGdyb3VwX2ZkLCAwKTsKKworCWlmIChmZFtucl9jcHVdW2NvdW50ZXJdIDwgMCkgeworCQlpbnQgZXJyID0gZXJybm87CisKKwkJaWYgKGVyciA9PSBFUEVSTSkKKwkJCWRpZSgiUGVybWlzc2lvbiBlcnJvciAtIGFyZSB5b3Ugcm9vdD9cbiIpOworCisJCS8qCisJCSAqIElmIGl0J3MgY3ljbGVzIHRoZW4gZmFsbCBiYWNrIHRvIGhydGltZXIKKwkJICogYmFzZWQgY3B1LWNsb2NrLXRpY2sgc3cgY291bnRlciwgd2hpY2gKKwkJICogaXMgYWx3YXlzIGF2YWlsYWJsZSBldmVuIGlmIG5vIFBNVSBzdXBwb3J0OgorCQkgKi8KKwkJaWYgKGF0dHItPnR5cGUgPT0gUEVSRl9UWVBFX0hBUkRXQVJFCisJCQkmJiBhdHRyLT5jb25maWcgPT0gUEVSRl9DT1VOVF9IV19DUFVfQ1lDTEVTKSB7CisKKwkJCWlmICh2ZXJib3NlKQorCQkJCXdhcm5pbmcoIiAuLi4gdHJ5aW5nIHRvIGZhbGwgYmFjayB0byBjcHUtY2xvY2stdGlja3NcbiIpOworCQkJYXR0ci0+dHlwZSA9IFBFUkZfVFlQRV9TT0ZUV0FSRTsKKwkJCWF0dHItPmNvbmZpZyA9IFBFUkZfQ09VTlRfU1dfQ1BVX0NMT0NLOworCQkJZ290byB0cnlfYWdhaW47CisJCX0KKwkJcHJpbnRmKCJcbiIpOworCQllcnJvcigicGVyZmNvdW50ZXIgc3lzY2FsbCByZXR1cm5lZCB3aXRoICVkICglcylcbiIsCisJCQlmZFtucl9jcHVdW2NvdW50ZXJdLCBzdHJlcnJvcihlcnIpKTsKKwkJZGllKCJObyBDT05GSUdfUEVSRl9DT1VOVEVSUz15IGtlcm5lbCBzdXBwb3J0IGNvbmZpZ3VyZWQ/XG4iKTsKKwkJZXhpdCgtMSk7CisJfQorCisJYXNzZXJ0KGZkW25yX2NwdV1bY291bnRlcl0gPj0gMCk7CisJZmNudGwoZmRbbnJfY3B1XVtjb3VudGVyXSwgRl9TRVRGTCwgT19OT05CTE9DSyk7CisKKwkvKgorCSAqIEZpcnN0IGNvdW50ZXIgYWN0cyBhcyB0aGUgZ3JvdXAgbGVhZGVyOgorCSAqLworCWlmIChncm91cCAmJiBncm91cF9mZCA9PSAtMSkKKwkJZ3JvdXBfZmQgPSBmZFtucl9jcHVdW2NvdW50ZXJdOworCisJZXZlbnRfYXJyYXlbbnJfcG9sbF0uZmQgPSBmZFtucl9jcHVdW2NvdW50ZXJdOworCWV2ZW50X2FycmF5W25yX3BvbGxdLmV2ZW50cyA9IFBPTExJTjsKKwlucl9wb2xsKys7CisKKwltbWFwX2FycmF5W25yX2NwdV1bY291bnRlcl0uY291bnRlciA9IGNvdW50ZXI7CisJbW1hcF9hcnJheVtucl9jcHVdW2NvdW50ZXJdLnByZXYgPSAwOworCW1tYXBfYXJyYXlbbnJfY3B1XVtjb3VudGVyXS5tYXNrID0gbW1hcF9wYWdlcypwYWdlX3NpemUgLSAxOworCW1tYXBfYXJyYXlbbnJfY3B1XVtjb3VudGVyXS5iYXNlID0gbW1hcChOVUxMLCAobW1hcF9wYWdlcysxKSpwYWdlX3NpemUsCisJCQlQUk9UX1JFQUQsIE1BUF9TSEFSRUQsIGZkW25yX2NwdV1bY291bnRlcl0sIDApOworCWlmIChtbWFwX2FycmF5W25yX2NwdV1bY291bnRlcl0uYmFzZSA9PSBNQVBfRkFJTEVEKSB7CisJCWVycm9yKCJmYWlsZWQgdG8gbW1hcCB3aXRoICVkICglcylcbiIsIGVycm5vLCBzdHJlcnJvcihlcnJubykpOworCQlleGl0KC0xKTsKKwl9CisKKwlpb2N0bChmZFtucl9jcHVdW2NvdW50ZXJdLCBQRVJGX0NPVU5URVJfSU9DX0VOQUJMRSk7Cit9CisKK3N0YXRpYyB2b2lkIG9wZW5fY291bnRlcnMoaW50IGNwdSwgcGlkX3QgcGlkKQoreworCWludCBjb3VudGVyOworCisJaWYgKHBpZCA+IDApIHsKKwkJcGlkX3N5bnRoZXNpemVfY29tbV9ldmVudChwaWQsIDApOworCQlwaWRfc3ludGhlc2l6ZV9tbWFwX3NhbXBsZXMocGlkKTsKKwl9CisKKwlncm91cF9mZCA9IC0xOworCWZvciAoY291bnRlciA9IDA7IGNvdW50ZXIgPCBucl9jb3VudGVyczsgY291bnRlcisrKQorCQljcmVhdGVfY291bnRlcihjb3VudGVyLCBjcHUsIHBpZCk7CisKKwlucl9jcHUrKzsKK30KKworc3RhdGljIGludCBfX2NtZF9yZWNvcmQoaW50IGFyZ2MsIGNvbnN0IGNoYXIgKiphcmd2KQoreworCWludCBpLCBjb3VudGVyOworCXN0cnVjdCBzdGF0IHN0OworCXBpZF90IHBpZDsKKwlpbnQgZmxhZ3M7CisJaW50IHJldDsKKworCXBhZ2Vfc2l6ZSA9IHN5c2NvbmYoX1NDX1BBR0VfU0laRSk7CisJbnJfY3B1cyA9IHN5c2NvbmYoX1NDX05QUk9DRVNTT1JTX09OTE4pOworCWFzc2VydChucl9jcHVzIDw9IE1BWF9OUl9DUFVTKTsKKwlhc3NlcnQobnJfY3B1cyA+PSAwKTsKKworCWlmICghc3RhdChvdXRwdXRfbmFtZSwgJnN0KSAmJiAhZm9yY2UgJiYgIWFwcGVuZF9maWxlKSB7CisJCWZwcmludGYoc3RkZXJyLCAiRXJyb3IsIG91dHB1dCBmaWxlICVzIGV4aXN0cywgdXNlIC1BIHRvIGFwcGVuZCBvciAtZiB0byBvdmVyd3JpdGUuXG4iLAorCQkJCW91dHB1dF9uYW1lKTsKKwkJZXhpdCgtMSk7CisJfQorCisJZmxhZ3MgPSBPX0NSRUFUfE9fUkRXUjsKKwlpZiAoYXBwZW5kX2ZpbGUpCisJCWZsYWdzIHw9IE9fQVBQRU5EOworCWVsc2UKKwkJZmxhZ3MgfD0gT19UUlVOQzsKKworCW91dHB1dCA9IG9wZW4ob3V0cHV0X25hbWUsIGZsYWdzLCBTX0lSVVNSfFNfSVdVU1IpOworCWlmIChvdXRwdXQgPCAwKSB7CisJCXBlcnJvcigiZmFpbGVkIHRvIGNyZWF0ZSBvdXRwdXQgZmlsZSIpOworCQlleGl0KC0xKTsKKwl9CisKKwlpZiAoIXN5c3RlbV93aWRlKSB7CisJCW9wZW5fY291bnRlcnMoLTEsIHRhcmdldF9waWQgIT0gLTEgPyB0YXJnZXRfcGlkIDogZ2V0cGlkKCkpOworCX0gZWxzZSBmb3IgKGkgPSAwOyBpIDwgbnJfY3B1czsgaSsrKQorCQlvcGVuX2NvdW50ZXJzKGksIHRhcmdldF9waWQpOworCisJYXRleGl0KHNpZ19hdGV4aXQpOworCXNpZ25hbChTSUdDSExELCBzaWdfaGFuZGxlcik7CisJc2lnbmFsKFNJR0lOVCwgc2lnX2hhbmRsZXIpOworCisJaWYgKHRhcmdldF9waWQgPT0gLTEgJiYgYXJnYykgeworCQlwaWQgPSBmb3JrKCk7CisJCWlmIChwaWQgPCAwKQorCQkJcGVycm9yKCJmYWlsZWQgdG8gZm9yayIpOworCisJCWlmICghcGlkKSB7CisJCQlpZiAoZXhlY3ZwKGFyZ3ZbMF0sIChjaGFyICoqKWFyZ3YpKSB7CisJCQkJcGVycm9yKGFyZ3ZbMF0pOworCQkJCWV4aXQoLTEpOworCQkJfQorCQl9CisJfQorCisJaWYgKHJlYWx0aW1lX3ByaW8pIHsKKwkJc3RydWN0IHNjaGVkX3BhcmFtIHBhcmFtOworCisJCXBhcmFtLnNjaGVkX3ByaW9yaXR5ID0gcmVhbHRpbWVfcHJpbzsKKwkJaWYgKHNjaGVkX3NldHNjaGVkdWxlcigwLCBTQ0hFRF9GSUZPLCAmcGFyYW0pKSB7CisJCQlwcmludGYoIkNvdWxkIG5vdCBzZXQgcmVhbHRpbWUgcHJpb3JpdHkuXG4iKTsKKwkJCWV4aXQoLTEpOworCQl9CisJfQorCisJaWYgKHN5c3RlbV93aWRlKQorCQlzeW50aGVzaXplX3NhbXBsZXMoKTsKKworCXdoaWxlICghZG9uZSkgeworCQlpbnQgaGl0cyA9IHNhbXBsZXM7CisKKwkJZm9yIChpID0gMDsgaSA8IG5yX2NwdTsgaSsrKSB7CisJCQlmb3IgKGNvdW50ZXIgPSAwOyBjb3VudGVyIDwgbnJfY291bnRlcnM7IGNvdW50ZXIrKykKKwkJCQltbWFwX3JlYWQoJm1tYXBfYXJyYXlbaV1bY291bnRlcl0pOworCQl9CisKKwkJaWYgKGhpdHMgPT0gc2FtcGxlcykKKwkJCXJldCA9IHBvbGwoZXZlbnRfYXJyYXksIG5yX3BvbGwsIDEwMCk7CisJfQorCisJLyoKKwkgKiBBcHByb3hpbWF0ZSBSSVAgZXZlbnQgc2l6ZTogMjQgYnl0ZXMuCisJICovCisJZnByaW50ZihzdGRlcnIsCisJCSJbIHBlcmYgcmVjb3JkOiBDYXB0dXJlZCBhbmQgd3JvdGUgJS4zZiBNQiAlcyAofiVsbGQgc2FtcGxlcykgXVxuIiwKKwkJKGRvdWJsZSlieXRlc193cml0dGVuIC8gMTAyNC4wIC8gMTAyNC4wLAorCQlvdXRwdXRfbmFtZSwKKwkJYnl0ZXNfd3JpdHRlbiAvIDI0KTsKKworCXJldHVybiAwOworfQorCitzdGF0aWMgY29uc3QgY2hhciAqIGNvbnN0IHJlY29yZF91c2FnZVtdID0geworCSJwZXJmIHJlY29yZCBbPG9wdGlvbnM+XSBbPGNvbW1hbmQ+XSIsCisJInBlcmYgcmVjb3JkIFs8b3B0aW9ucz5dIC0tIDxjb21tYW5kPiBbPG9wdGlvbnM+XSIsCisJTlVMTAorfTsKKworc3RhdGljIGNvbnN0IHN0cnVjdCBvcHRpb24gb3B0aW9uc1tdID0geworCU9QVF9DQUxMQkFDSygnZScsICJldmVudCIsIE5VTEwsICJldmVudCIsCisJCSAgICAgImV2ZW50IHNlbGVjdG9yLiB1c2UgJ3BlcmYgbGlzdCcgdG8gbGlzdCBhdmFpbGFibGUgZXZlbnRzIiwKKwkJICAgICBwYXJzZV9ldmVudHMpLAorCU9QVF9JTlRFR0VSKCdwJywgInBpZCIsICZ0YXJnZXRfcGlkLAorCQkgICAgInJlY29yZCBldmVudHMgb24gZXhpc3RpbmcgcGlkIiksCisJT1BUX0lOVEVHRVIoJ3InLCAicmVhbHRpbWUiLCAmcmVhbHRpbWVfcHJpbywKKwkJICAgICJjb2xsZWN0IGRhdGEgd2l0aCB0aGlzIFJUIFNDSEVEX0ZJRk8gcHJpb3JpdHkiKSwKKwlPUFRfQk9PTEVBTignYScsICJhbGwtY3B1cyIsICZzeXN0ZW1fd2lkZSwKKwkJCSAgICAic3lzdGVtLXdpZGUgY29sbGVjdGlvbiBmcm9tIGFsbCBDUFVzIiksCisJT1BUX0JPT0xFQU4oJ0EnLCAiYXBwZW5kIiwgJmFwcGVuZF9maWxlLAorCQkJICAgICJhcHBlbmQgdG8gdGhlIG91dHB1dCBmaWxlIHRvIGRvIGluY3JlbWVudGFsIHByb2ZpbGluZyIpLAorCU9QVF9CT09MRUFOKCdmJywgImZvcmNlIiwgJmZvcmNlLAorCQkJIm92ZXJ3cml0ZSBleGlzdGluZyBkYXRhIGZpbGUiKSwKKwlPUFRfTE9ORygnYycsICJjb3VudCIsICZkZWZhdWx0X2ludGVydmFsLAorCQkgICAgImV2ZW50IHBlcmlvZCB0byBzYW1wbGUiKSwKKwlPUFRfU1RSSU5HKCdvJywgIm91dHB1dCIsICZvdXRwdXRfbmFtZSwgImZpbGUiLAorCQkgICAgIm91dHB1dCBmaWxlIG5hbWUiKSwKKwlPUFRfQk9PTEVBTignaScsICJpbmhlcml0IiwgJmluaGVyaXQsCisJCSAgICAiY2hpbGQgdGFza3MgaW5oZXJpdCBjb3VudGVycyIpLAorCU9QVF9JTlRFR0VSKCdGJywgImZyZXEiLCAmZnJlcSwKKwkJICAgICJwcm9maWxlIGF0IHRoaXMgZnJlcXVlbmN5IiksCisJT1BUX0lOVEVHRVIoJ20nLCAibW1hcC1wYWdlcyIsICZtbWFwX3BhZ2VzLAorCQkgICAgIm51bWJlciBvZiBtbWFwIGRhdGEgcGFnZXMiKSwKKwlPUFRfQk9PTEVBTigndicsICJ2ZXJib3NlIiwgJnZlcmJvc2UsCisJCSAgICAiYmUgbW9yZSB2ZXJib3NlIChzaG93IGNvdW50ZXIgb3BlbiBlcnJvcnMsIGV0YykiKSwKKwlPUFRfRU5EKCkKK307CisKK2ludCBjbWRfcmVjb3JkKGludCBhcmdjLCBjb25zdCBjaGFyICoqYXJndiwgY29uc3QgY2hhciAqcHJlZml4KQoreworCWludCBjb3VudGVyOworCisJYXJnYyA9IHBhcnNlX29wdGlvbnMoYXJnYywgYXJndiwgb3B0aW9ucywgcmVjb3JkX3VzYWdlLCAwKTsKKwlpZiAoIWFyZ2MgJiYgdGFyZ2V0X3BpZCA9PSAtMSAmJiAhc3lzdGVtX3dpZGUpCisJCXVzYWdlX3dpdGhfb3B0aW9ucyhyZWNvcmRfdXNhZ2UsIG9wdGlvbnMpOworCisJaWYgKCFucl9jb3VudGVycykKKwkJbnJfY291bnRlcnMgPSAxOworCisJZm9yIChjb3VudGVyID0gMDsgY291bnRlciA8IG5yX2NvdW50ZXJzOyBjb3VudGVyKyspIHsKKwkJaWYgKGF0dHJzW2NvdW50ZXJdLnNhbXBsZV9wZXJpb2QpCisJCQljb250aW51ZTsKKworCQlhdHRyc1tjb3VudGVyXS5zYW1wbGVfcGVyaW9kID0gZGVmYXVsdF9pbnRlcnZhbDsKKwl9CisKKwlyZXR1cm4gX19jbWRfcmVjb3JkKGFyZ2MsIGFyZ3YpOworfQpkaWZmIC0tZ2l0IGEvdG9vbHMvcGVyZi9idWlsdGluLXJlcG9ydC5jIGIvdG9vbHMvcGVyZi9idWlsdGluLXJlcG9ydC5jCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjgyZmE5M2IKLS0tIC9kZXYvbnVsbAorKysgYi90b29scy9wZXJmL2J1aWx0aW4tcmVwb3J0LmMKQEAgLTAsMCArMSwxMzE2IEBACisvKgorICogYnVpbHRpbi1yZXBvcnQuYworICoKKyAqIEJ1aWx0aW4gcmVwb3J0IGNvbW1hbmQ6IEFuYWx5emUgdGhlIHBlcmYuZGF0YSBpbnB1dCBmaWxlLAorICogbG9vayB1cCBhbmQgcmVhZCBEU09zIGFuZCBzeW1ib2wgaW5mb3JtYXRpb24gYW5kIGRpc3BsYXkKKyAqIGEgaGlzdG9ncmFtIG9mIHJlc3VsdHMsIGFsb25nIHZhcmlvdXMgc29ydGluZyBrZXlzLgorICovCisjaW5jbHVkZSAiYnVpbHRpbi5oIgorCisjaW5jbHVkZSAidXRpbC91dGlsLmgiCisKKyNpbmNsdWRlICJ1dGlsL2NvbG9yLmgiCisjaW5jbHVkZSAidXRpbC9saXN0LmgiCisjaW5jbHVkZSAidXRpbC9jYWNoZS5oIgorI2luY2x1ZGUgInV0aWwvcmJ0cmVlLmgiCisjaW5jbHVkZSAidXRpbC9zeW1ib2wuaCIKKyNpbmNsdWRlICJ1dGlsL3N0cmluZy5oIgorCisjaW5jbHVkZSAicGVyZi5oIgorCisjaW5jbHVkZSAidXRpbC9wYXJzZS1vcHRpb25zLmgiCisjaW5jbHVkZSAidXRpbC9wYXJzZS1ldmVudHMuaCIKKworI2RlZmluZSBTSE9XX0tFUk5FTAkxCisjZGVmaW5lIFNIT1dfVVNFUgkyCisjZGVmaW5lIFNIT1dfSFYJCTQKKworc3RhdGljIGNoYXIJCWNvbnN0ICppbnB1dF9uYW1lID0gInBlcmYuZGF0YSI7CitzdGF0aWMgY2hhcgkJKnZtbGludXggPSBOVUxMOworCitzdGF0aWMgY2hhcgkJZGVmYXVsdF9zb3J0X29yZGVyW10gPSAiY29tbSxkc28iOworc3RhdGljIGNoYXIJCSpzb3J0X29yZGVyID0gZGVmYXVsdF9zb3J0X29yZGVyOworCitzdGF0aWMgaW50CQlpbnB1dDsKK3N0YXRpYyBpbnQJCXNob3dfbWFzayA9IFNIT1dfS0VSTkVMIHwgU0hPV19VU0VSIHwgU0hPV19IVjsKKworc3RhdGljIGludAkJZHVtcF90cmFjZSA9IDA7CisjZGVmaW5lIGRwcmludGYoeC4uLikJZG8geyBpZiAoZHVtcF90cmFjZSkgcHJpbnRmKHgpOyB9IHdoaWxlICgwKQorCitzdGF0aWMgaW50CQl2ZXJib3NlOworc3RhdGljIGludAkJZnVsbF9wYXRoczsKKworc3RhdGljIHVuc2lnbmVkIGxvbmcJcGFnZV9zaXplOworc3RhdGljIHVuc2lnbmVkIGxvbmcJbW1hcF93aW5kb3cgPSAzMjsKKworc3RydWN0IGlwX2V2ZW50IHsKKwlzdHJ1Y3QgcGVyZl9ldmVudF9oZWFkZXIgaGVhZGVyOworCV9fdTY0IGlwOworCV9fdTMyIHBpZCwgdGlkOworCV9fdTY0IHBlcmlvZDsKK307CisKK3N0cnVjdCBtbWFwX2V2ZW50IHsKKwlzdHJ1Y3QgcGVyZl9ldmVudF9oZWFkZXIgaGVhZGVyOworCV9fdTMyIHBpZCwgdGlkOworCV9fdTY0IHN0YXJ0OworCV9fdTY0IGxlbjsKKwlfX3U2NCBwZ29mZjsKKwljaGFyIGZpbGVuYW1lW1BBVEhfTUFYXTsKK307CisKK3N0cnVjdCBjb21tX2V2ZW50IHsKKwlzdHJ1Y3QgcGVyZl9ldmVudF9oZWFkZXIgaGVhZGVyOworCV9fdTMyIHBpZCwgdGlkOworCWNoYXIgY29tbVsxNl07Cit9OworCitzdHJ1Y3QgZm9ya19ldmVudCB7CisJc3RydWN0IHBlcmZfZXZlbnRfaGVhZGVyIGhlYWRlcjsKKwlfX3UzMiBwaWQsIHBwaWQ7Cit9OworCitzdHJ1Y3QgcGVyaW9kX2V2ZW50IHsKKwlzdHJ1Y3QgcGVyZl9ldmVudF9oZWFkZXIgaGVhZGVyOworCV9fdTY0IHRpbWU7CisJX191NjQgaWQ7CisJX191NjQgc2FtcGxlX3BlcmlvZDsKK307CisKK3R5cGVkZWYgdW5pb24gZXZlbnRfdW5pb24geworCXN0cnVjdCBwZXJmX2V2ZW50X2hlYWRlcgloZWFkZXI7CisJc3RydWN0IGlwX2V2ZW50CQkJaXA7CisJc3RydWN0IG1tYXBfZXZlbnQJCW1tYXA7CisJc3RydWN0IGNvbW1fZXZlbnQJCWNvbW07CisJc3RydWN0IGZvcmtfZXZlbnQJCWZvcms7CisJc3RydWN0IHBlcmlvZF9ldmVudAkJcGVyaW9kOworfSBldmVudF90OworCitzdGF0aWMgTElTVF9IRUFEKGRzb3MpOworc3RhdGljIHN0cnVjdCBkc28gKmtlcm5lbF9kc287CitzdGF0aWMgc3RydWN0IGRzbyAqdmRzbzsKKworc3RhdGljIHZvaWQgZHNvc19fYWRkKHN0cnVjdCBkc28gKmRzbykKK3sKKwlsaXN0X2FkZF90YWlsKCZkc28tPm5vZGUsICZkc29zKTsKK30KKworc3RhdGljIHN0cnVjdCBkc28gKmRzb3NfX2ZpbmQoY29uc3QgY2hhciAqbmFtZSkKK3sKKwlzdHJ1Y3QgZHNvICpwb3M7CisKKwlsaXN0X2Zvcl9lYWNoX2VudHJ5KHBvcywgJmRzb3MsIG5vZGUpCisJCWlmIChzdHJjbXAocG9zLT5uYW1lLCBuYW1lKSA9PSAwKQorCQkJcmV0dXJuIHBvczsKKwlyZXR1cm4gTlVMTDsKK30KKworc3RhdGljIHN0cnVjdCBkc28gKmRzb3NfX2ZpbmRuZXcoY29uc3QgY2hhciAqbmFtZSkKK3sKKwlzdHJ1Y3QgZHNvICpkc28gPSBkc29zX19maW5kKG5hbWUpOworCWludCBucjsKKworCWlmIChkc28pCisJCXJldHVybiBkc287CisKKwlkc28gPSBkc29fX25ldyhuYW1lLCAwKTsKKwlpZiAoIWRzbykKKwkJZ290byBvdXRfZGVsZXRlX2RzbzsKKworCW5yID0gZHNvX19sb2FkKGRzbywgTlVMTCwgdmVyYm9zZSk7CisJaWYgKG5yIDwgMCkgeworCQlpZiAodmVyYm9zZSkKKwkJCWZwcmludGYoc3RkZXJyLCAiRmFpbGVkIHRvIG9wZW46ICVzXG4iLCBuYW1lKTsKKwkJZ290byBvdXRfZGVsZXRlX2RzbzsKKwl9CisJaWYgKCFuciAmJiB2ZXJib3NlKSB7CisJCWZwcmludGYoc3RkZXJyLAorCQkiTm8gc3ltYm9scyBmb3VuZCBpbjogJXMsIG1heWJlIGluc3RhbGwgYSBkZWJ1ZyBwYWNrYWdlP1xuIiwKKwkJCQluYW1lKTsKKwl9CisKKwlkc29zX19hZGQoZHNvKTsKKworCXJldHVybiBkc287CisKK291dF9kZWxldGVfZHNvOgorCWRzb19fZGVsZXRlKGRzbyk7CisJcmV0dXJuIE5VTEw7Cit9CisKK3N0YXRpYyB2b2lkIGRzb3NfX2ZwcmludGYoRklMRSAqZnApCit7CisJc3RydWN0IGRzbyAqcG9zOworCisJbGlzdF9mb3JfZWFjaF9lbnRyeShwb3MsICZkc29zLCBub2RlKQorCQlkc29fX2ZwcmludGYocG9zLCBmcCk7Cit9CisKK3N0YXRpYyBzdHJ1Y3Qgc3ltYm9sICp2ZHNvX19maW5kX3N5bWJvbChzdHJ1Y3QgZHNvICpkc28sIF9fdTY0IGlwKQoreworCXJldHVybiBkc29fX2ZpbmRfc3ltYm9sKGtlcm5lbF9kc28sIGlwKTsKK30KKworc3RhdGljIGludCBsb2FkX2tlcm5lbCh2b2lkKQoreworCWludCBlcnI7CisKKwlrZXJuZWxfZHNvID0gZHNvX19uZXcoIltrZXJuZWxdIiwgMCk7CisJaWYgKCFrZXJuZWxfZHNvKQorCQlyZXR1cm4gLTE7CisKKwllcnIgPSBkc29fX2xvYWRfa2VybmVsKGtlcm5lbF9kc28sIHZtbGludXgsIE5VTEwsIHZlcmJvc2UpOworCWlmIChlcnIpIHsKKwkJZHNvX19kZWxldGUoa2VybmVsX2Rzbyk7CisJCWtlcm5lbF9kc28gPSBOVUxMOworCX0gZWxzZQorCQlkc29zX19hZGQoa2VybmVsX2Rzbyk7CisKKwl2ZHNvID0gZHNvX19uZXcoIlt2ZHNvXSIsIDApOworCWlmICghdmRzbykKKwkJcmV0dXJuIC0xOworCisJdmRzby0+ZmluZF9zeW1ib2wgPSB2ZHNvX19maW5kX3N5bWJvbDsKKworCWRzb3NfX2FkZCh2ZHNvKTsKKworCXJldHVybiBlcnI7Cit9CisKK3N0YXRpYyBjaGFyIF9fY3dkW1BBVEhfTUFYXTsKK3N0YXRpYyBjaGFyICpjd2QgPSBfX2N3ZDsKK3N0YXRpYyBpbnQgY3dkbGVuOworCitzdGF0aWMgaW50IHN0cmNvbW1vbihjb25zdCBjaGFyICpwYXRobmFtZSkKK3sKKwlpbnQgbiA9IDA7CisKKwl3aGlsZSAocGF0aG5hbWVbbl0gPT0gY3dkW25dICYmIG4gPCBjd2RsZW4pCisJCSsrbjsKKworCXJldHVybiBuOworfQorCitzdHJ1Y3QgbWFwIHsKKwlzdHJ1Y3QgbGlzdF9oZWFkIG5vZGU7CisJX191NjQJIHN0YXJ0OworCV9fdTY0CSBlbmQ7CisJX191NjQJIHBnb2ZmOworCV9fdTY0CSAoKm1hcF9pcCkoc3RydWN0IG1hcCAqLCBfX3U2NCk7CisJc3RydWN0IGRzbwkgKmRzbzsKK307CisKK3N0YXRpYyBfX3U2NCBtYXBfX21hcF9pcChzdHJ1Y3QgbWFwICptYXAsIF9fdTY0IGlwKQoreworCXJldHVybiBpcCAtIG1hcC0+c3RhcnQgKyBtYXAtPnBnb2ZmOworfQorCitzdGF0aWMgX191NjQgdmRzb19fbWFwX2lwKHN0cnVjdCBtYXAgKm1hcCwgX191NjQgaXApCit7CisJcmV0dXJuIGlwOworfQorCitzdGF0aWMgaW5saW5lIGludCBpc19hbm9uX21lbW9yeShjb25zdCBjaGFyICpmaWxlbmFtZSkKK3sKKyAgICAgcmV0dXJuIHN0cmNtcChmaWxlbmFtZSwgIi8vYW5vbiIpID09IDA7Cit9CisKK3N0YXRpYyBzdHJ1Y3QgbWFwICptYXBfX25ldyhzdHJ1Y3QgbW1hcF9ldmVudCAqZXZlbnQpCit7CisJc3RydWN0IG1hcCAqc2VsZiA9IG1hbGxvYyhzaXplb2YoKnNlbGYpKTsKKworCWlmIChzZWxmICE9IE5VTEwpIHsKKwkJY29uc3QgY2hhciAqZmlsZW5hbWUgPSBldmVudC0+ZmlsZW5hbWU7CisJCWNoYXIgbmV3ZmlsZW5hbWVbUEFUSF9NQVhdOworCQlpbnQgYW5vbjsKKworCQlpZiAoY3dkKSB7CisJCQlpbnQgbiA9IHN0cmNvbW1vbihmaWxlbmFtZSk7CisKKwkJCWlmIChuID09IGN3ZGxlbikgeworCQkJCXNucHJpbnRmKG5ld2ZpbGVuYW1lLCBzaXplb2YobmV3ZmlsZW5hbWUpLAorCQkJCQkgIi4lcyIsIGZpbGVuYW1lICsgbik7CisJCQkJZmlsZW5hbWUgPSBuZXdmaWxlbmFtZTsKKwkJCX0KKwkJfQorCisJCWFub24gPSBpc19hbm9uX21lbW9yeShmaWxlbmFtZSk7CisKKwkJaWYgKGFub24pIHsKKwkJCXNucHJpbnRmKG5ld2ZpbGVuYW1lLCBzaXplb2YobmV3ZmlsZW5hbWUpLCAiL3RtcC9wZXJmLSVkLm1hcCIsIGV2ZW50LT5waWQpOworCQkJZmlsZW5hbWUgPSBuZXdmaWxlbmFtZTsKKwkJfQorCisJCXNlbGYtPnN0YXJ0ID0gZXZlbnQtPnN0YXJ0OworCQlzZWxmLT5lbmQgICA9IGV2ZW50LT5zdGFydCArIGV2ZW50LT5sZW47CisJCXNlbGYtPnBnb2ZmID0gZXZlbnQtPnBnb2ZmOworCisJCXNlbGYtPmRzbyA9IGRzb3NfX2ZpbmRuZXcoZmlsZW5hbWUpOworCQlpZiAoc2VsZi0+ZHNvID09IE5VTEwpCisJCQlnb3RvIG91dF9kZWxldGU7CisKKwkJaWYgKHNlbGYtPmRzbyA9PSB2ZHNvIHx8IGFub24pCisJCQlzZWxmLT5tYXBfaXAgPSB2ZHNvX19tYXBfaXA7CisJCWVsc2UKKwkJCXNlbGYtPm1hcF9pcCA9IG1hcF9fbWFwX2lwOworCX0KKwlyZXR1cm4gc2VsZjsKK291dF9kZWxldGU6CisJZnJlZShzZWxmKTsKKwlyZXR1cm4gTlVMTDsKK30KKworc3RhdGljIHN0cnVjdCBtYXAgKm1hcF9fY2xvbmUoc3RydWN0IG1hcCAqc2VsZikKK3sKKwlzdHJ1Y3QgbWFwICptYXAgPSBtYWxsb2Moc2l6ZW9mKCpzZWxmKSk7CisKKwlpZiAoIW1hcCkKKwkJcmV0dXJuIE5VTEw7CisKKwltZW1jcHkobWFwLCBzZWxmLCBzaXplb2YoKnNlbGYpKTsKKworCXJldHVybiBtYXA7Cit9CisKK3N0YXRpYyBpbnQgbWFwX19vdmVybGFwKHN0cnVjdCBtYXAgKmwsIHN0cnVjdCBtYXAgKnIpCit7CisJaWYgKGwtPnN0YXJ0ID4gci0+c3RhcnQpIHsKKwkJc3RydWN0IG1hcCAqdCA9IGw7CisJCWwgPSByOworCQlyID0gdDsKKwl9CisKKwlpZiAobC0+ZW5kID4gci0+c3RhcnQpCisJCXJldHVybiAxOworCisJcmV0dXJuIDA7Cit9CisKK3N0YXRpYyBzaXplX3QgbWFwX19mcHJpbnRmKHN0cnVjdCBtYXAgKnNlbGYsIEZJTEUgKmZwKQoreworCXJldHVybiBmcHJpbnRmKGZwLCAiICVMeC0lTHggJUx4ICVzXG4iLAorCQkgICAgICAgc2VsZi0+c3RhcnQsIHNlbGYtPmVuZCwgc2VsZi0+cGdvZmYsIHNlbGYtPmRzby0+bmFtZSk7Cit9CisKKworc3RydWN0IHRocmVhZCB7CisJc3RydWN0IHJiX25vZGUJIHJiX25vZGU7CisJc3RydWN0IGxpc3RfaGVhZCBtYXBzOworCXBpZF90CQkgcGlkOworCWNoYXIJCSAqY29tbTsKK307CisKK3N0YXRpYyBzdHJ1Y3QgdGhyZWFkICp0aHJlYWRfX25ldyhwaWRfdCBwaWQpCit7CisJc3RydWN0IHRocmVhZCAqc2VsZiA9IG1hbGxvYyhzaXplb2YoKnNlbGYpKTsKKworCWlmIChzZWxmICE9IE5VTEwpIHsKKwkJc2VsZi0+cGlkID0gcGlkOworCQlzZWxmLT5jb21tID0gbWFsbG9jKDMyKTsKKwkJaWYgKHNlbGYtPmNvbW0pCisJCQlzbnByaW50ZihzZWxmLT5jb21tLCAzMiwgIjolZCIsIHNlbGYtPnBpZCk7CisJCUlOSVRfTElTVF9IRUFEKCZzZWxmLT5tYXBzKTsKKwl9CisKKwlyZXR1cm4gc2VsZjsKK30KKworc3RhdGljIGludCB0aHJlYWRfX3NldF9jb21tKHN0cnVjdCB0aHJlYWQgKnNlbGYsIGNvbnN0IGNoYXIgKmNvbW0pCit7CisJaWYgKHNlbGYtPmNvbW0pCisJCWZyZWUoc2VsZi0+Y29tbSk7CisJc2VsZi0+Y29tbSA9IHN0cmR1cChjb21tKTsKKwlyZXR1cm4gc2VsZi0+Y29tbSA/IDAgOiAtRU5PTUVNOworfQorCitzdGF0aWMgc2l6ZV90IHRocmVhZF9fZnByaW50ZihzdHJ1Y3QgdGhyZWFkICpzZWxmLCBGSUxFICpmcCkKK3sKKwlzdHJ1Y3QgbWFwICpwb3M7CisJc2l6ZV90IHJldCA9IGZwcmludGYoZnAsICJUaHJlYWQgJWQgJXNcbiIsIHNlbGYtPnBpZCwgc2VsZi0+Y29tbSk7CisKKwlsaXN0X2Zvcl9lYWNoX2VudHJ5KHBvcywgJnNlbGYtPm1hcHMsIG5vZGUpCisJCXJldCArPSBtYXBfX2ZwcmludGYocG9zLCBmcCk7CisKKwlyZXR1cm4gcmV0OworfQorCisKK3N0YXRpYyBzdHJ1Y3QgcmJfcm9vdCB0aHJlYWRzOworc3RhdGljIHN0cnVjdCB0aHJlYWQgKmxhc3RfbWF0Y2g7CisKK3N0YXRpYyBzdHJ1Y3QgdGhyZWFkICp0aHJlYWRzX19maW5kbmV3KHBpZF90IHBpZCkKK3sKKwlzdHJ1Y3QgcmJfbm9kZSAqKnAgPSAmdGhyZWFkcy5yYl9ub2RlOworCXN0cnVjdCByYl9ub2RlICpwYXJlbnQgPSBOVUxMOworCXN0cnVjdCB0aHJlYWQgKnRoOworCisJLyoKKwkgKiBGb250LWVuZCBjYWNoZSAtIFBJRCBsb29rdXBzIGNvbWUgaW4gYmxvY2tzLAorCSAqIHNvIG1vc3Qgb2YgdGhlIHRpbWUgd2UgZG9udCBoYXZlIHRvIGxvb2sgdXAKKwkgKiB0aGUgZnVsbCByYnRyZWU6CisJICovCisJaWYgKGxhc3RfbWF0Y2ggJiYgbGFzdF9tYXRjaC0+cGlkID09IHBpZCkKKwkJcmV0dXJuIGxhc3RfbWF0Y2g7CisKKwl3aGlsZSAoKnAgIT0gTlVMTCkgeworCQlwYXJlbnQgPSAqcDsKKwkJdGggPSByYl9lbnRyeShwYXJlbnQsIHN0cnVjdCB0aHJlYWQsIHJiX25vZGUpOworCisJCWlmICh0aC0+cGlkID09IHBpZCkgeworCQkJbGFzdF9tYXRjaCA9IHRoOworCQkJcmV0dXJuIHRoOworCQl9CisKKwkJaWYgKHBpZCA8IHRoLT5waWQpCisJCQlwID0gJigqcCktPnJiX2xlZnQ7CisJCWVsc2UKKwkJCXAgPSAmKCpwKS0+cmJfcmlnaHQ7CisJfQorCisJdGggPSB0aHJlYWRfX25ldyhwaWQpOworCWlmICh0aCAhPSBOVUxMKSB7CisJCXJiX2xpbmtfbm9kZSgmdGgtPnJiX25vZGUsIHBhcmVudCwgcCk7CisJCXJiX2luc2VydF9jb2xvcigmdGgtPnJiX25vZGUsICZ0aHJlYWRzKTsKKwkJbGFzdF9tYXRjaCA9IHRoOworCX0KKworCXJldHVybiB0aDsKK30KKworc3RhdGljIHZvaWQgdGhyZWFkX19pbnNlcnRfbWFwKHN0cnVjdCB0aHJlYWQgKnNlbGYsIHN0cnVjdCBtYXAgKm1hcCkKK3sKKwlzdHJ1Y3QgbWFwICpwb3MsICp0bXA7CisKKwlsaXN0X2Zvcl9lYWNoX2VudHJ5X3NhZmUocG9zLCB0bXAsICZzZWxmLT5tYXBzLCBub2RlKSB7CisJCWlmIChtYXBfX292ZXJsYXAocG9zLCBtYXApKSB7CisJCQlsaXN0X2RlbF9pbml0KCZwb3MtPm5vZGUpOworCQkJLyogWFhYIGxlYWtzIGRzb3MgKi8KKwkJCWZyZWUocG9zKTsKKwkJfQorCX0KKworCWxpc3RfYWRkX3RhaWwoJm1hcC0+bm9kZSwgJnNlbGYtPm1hcHMpOworfQorCitzdGF0aWMgaW50IHRocmVhZF9fZm9yayhzdHJ1Y3QgdGhyZWFkICpzZWxmLCBzdHJ1Y3QgdGhyZWFkICpwYXJlbnQpCit7CisJc3RydWN0IG1hcCAqbWFwOworCisJaWYgKHNlbGYtPmNvbW0pCisJCWZyZWUoc2VsZi0+Y29tbSk7CisJc2VsZi0+Y29tbSA9IHN0cmR1cChwYXJlbnQtPmNvbW0pOworCWlmICghc2VsZi0+Y29tbSkKKwkJcmV0dXJuIC1FTk9NRU07CisKKwlsaXN0X2Zvcl9lYWNoX2VudHJ5KG1hcCwgJnBhcmVudC0+bWFwcywgbm9kZSkgeworCQlzdHJ1Y3QgbWFwICpuZXcgPSBtYXBfX2Nsb25lKG1hcCk7CisJCWlmICghbmV3KQorCQkJcmV0dXJuIC1FTk9NRU07CisJCXRocmVhZF9faW5zZXJ0X21hcChzZWxmLCBuZXcpOworCX0KKworCXJldHVybiAwOworfQorCitzdGF0aWMgc3RydWN0IG1hcCAqdGhyZWFkX19maW5kX21hcChzdHJ1Y3QgdGhyZWFkICpzZWxmLCBfX3U2NCBpcCkKK3sKKwlzdHJ1Y3QgbWFwICpwb3M7CisKKwlpZiAoc2VsZiA9PSBOVUxMKQorCQlyZXR1cm4gTlVMTDsKKworCWxpc3RfZm9yX2VhY2hfZW50cnkocG9zLCAmc2VsZi0+bWFwcywgbm9kZSkKKwkJaWYgKGlwID49IHBvcy0+c3RhcnQgJiYgaXAgPD0gcG9zLT5lbmQpCisJCQlyZXR1cm4gcG9zOworCisJcmV0dXJuIE5VTEw7Cit9CisKK3N0YXRpYyBzaXplX3QgdGhyZWFkc19fZnByaW50ZihGSUxFICpmcCkKK3sKKwlzaXplX3QgcmV0ID0gMDsKKwlzdHJ1Y3QgcmJfbm9kZSAqbmQ7CisKKwlmb3IgKG5kID0gcmJfZmlyc3QoJnRocmVhZHMpOyBuZDsgbmQgPSByYl9uZXh0KG5kKSkgeworCQlzdHJ1Y3QgdGhyZWFkICpwb3MgPSByYl9lbnRyeShuZCwgc3RydWN0IHRocmVhZCwgcmJfbm9kZSk7CisKKwkJcmV0ICs9IHRocmVhZF9fZnByaW50Zihwb3MsIGZwKTsKKwl9CisKKwlyZXR1cm4gcmV0OworfQorCisvKgorICogaGlzdG9ncmFtLCBzb3J0ZWQgb24gaXRlbSwgY29sbGVjdHMgY291bnRzCisgKi8KKworc3RhdGljIHN0cnVjdCByYl9yb290IGhpc3Q7CisKK3N0cnVjdCBoaXN0X2VudHJ5IHsKKwlzdHJ1Y3QgcmJfbm9kZQkgcmJfbm9kZTsKKworCXN0cnVjdCB0aHJlYWQJICp0aHJlYWQ7CisJc3RydWN0IG1hcAkgKm1hcDsKKwlzdHJ1Y3QgZHNvCSAqZHNvOworCXN0cnVjdCBzeW1ib2wJICpzeW07CisJX191NjQJCSBpcDsKKwljaGFyCQkgbGV2ZWw7CisKKwlfX3U2NAkJIGNvdW50OworfTsKKworLyoKKyAqIGNvbmZpZ3VyYWJsZSBzb3J0aW5nIGJpdHMKKyAqLworCitzdHJ1Y3Qgc29ydF9lbnRyeSB7CisJc3RydWN0IGxpc3RfaGVhZCBsaXN0OworCisJY2hhciAqaGVhZGVyOworCisJaW50NjRfdCAoKmNtcCkoc3RydWN0IGhpc3RfZW50cnkgKiwgc3RydWN0IGhpc3RfZW50cnkgKik7CisJaW50NjRfdCAoKmNvbGxhcHNlKShzdHJ1Y3QgaGlzdF9lbnRyeSAqLCBzdHJ1Y3QgaGlzdF9lbnRyeSAqKTsKKwlzaXplX3QJKCpwcmludCkoRklMRSAqZnAsIHN0cnVjdCBoaXN0X2VudHJ5ICopOworfTsKKworLyogLS1zb3J0IHBpZCAqLworCitzdGF0aWMgaW50NjRfdAorc29ydF9fdGhyZWFkX2NtcChzdHJ1Y3QgaGlzdF9lbnRyeSAqbGVmdCwgc3RydWN0IGhpc3RfZW50cnkgKnJpZ2h0KQoreworCXJldHVybiByaWdodC0+dGhyZWFkLT5waWQgLSBsZWZ0LT50aHJlYWQtPnBpZDsKK30KKworc3RhdGljIHNpemVfdAorc29ydF9fdGhyZWFkX3ByaW50KEZJTEUgKmZwLCBzdHJ1Y3QgaGlzdF9lbnRyeSAqc2VsZikKK3sKKwlyZXR1cm4gZnByaW50ZihmcCwgIiUxNnM6JTVkIiwgc2VsZi0+dGhyZWFkLT5jb21tID86ICIiLCBzZWxmLT50aHJlYWQtPnBpZCk7Cit9CisKK3N0YXRpYyBzdHJ1Y3Qgc29ydF9lbnRyeSBzb3J0X3RocmVhZCA9IHsKKwkuaGVhZGVyID0gIiAgICAgICAgIENvbW1hbmQ6ICBQaWQiLAorCS5jbXAJPSBzb3J0X190aHJlYWRfY21wLAorCS5wcmludAk9IHNvcnRfX3RocmVhZF9wcmludCwKK307CisKKy8qIC0tc29ydCBjb21tICovCisKK3N0YXRpYyBpbnQ2NF90Citzb3J0X19jb21tX2NtcChzdHJ1Y3QgaGlzdF9lbnRyeSAqbGVmdCwgc3RydWN0IGhpc3RfZW50cnkgKnJpZ2h0KQoreworCXJldHVybiByaWdodC0+dGhyZWFkLT5waWQgLSBsZWZ0LT50aHJlYWQtPnBpZDsKK30KKworc3RhdGljIGludDY0X3QKK3NvcnRfX2NvbW1fY29sbGFwc2Uoc3RydWN0IGhpc3RfZW50cnkgKmxlZnQsIHN0cnVjdCBoaXN0X2VudHJ5ICpyaWdodCkKK3sKKwljaGFyICpjb21tX2wgPSBsZWZ0LT50aHJlYWQtPmNvbW07CisJY2hhciAqY29tbV9yID0gcmlnaHQtPnRocmVhZC0+Y29tbTsKKworCWlmICghY29tbV9sIHx8ICFjb21tX3IpIHsKKwkJaWYgKCFjb21tX2wgJiYgIWNvbW1fcikKKwkJCXJldHVybiAwOworCQllbHNlIGlmICghY29tbV9sKQorCQkJcmV0dXJuIC0xOworCQllbHNlCisJCQlyZXR1cm4gMTsKKwl9CisKKwlyZXR1cm4gc3RyY21wKGNvbW1fbCwgY29tbV9yKTsKK30KKworc3RhdGljIHNpemVfdAorc29ydF9fY29tbV9wcmludChGSUxFICpmcCwgc3RydWN0IGhpc3RfZW50cnkgKnNlbGYpCit7CisJcmV0dXJuIGZwcmludGYoZnAsICIlMTZzIiwgc2VsZi0+dGhyZWFkLT5jb21tKTsKK30KKworc3RhdGljIHN0cnVjdCBzb3J0X2VudHJ5IHNvcnRfY29tbSA9IHsKKwkuaGVhZGVyCQk9ICIgICAgICAgICBDb21tYW5kIiwKKwkuY21wCQk9IHNvcnRfX2NvbW1fY21wLAorCS5jb2xsYXBzZQk9IHNvcnRfX2NvbW1fY29sbGFwc2UsCisJLnByaW50CQk9IHNvcnRfX2NvbW1fcHJpbnQsCit9OworCisvKiAtLXNvcnQgZHNvICovCisKK3N0YXRpYyBpbnQ2NF90Citzb3J0X19kc29fY21wKHN0cnVjdCBoaXN0X2VudHJ5ICpsZWZ0LCBzdHJ1Y3QgaGlzdF9lbnRyeSAqcmlnaHQpCit7CisJc3RydWN0IGRzbyAqZHNvX2wgPSBsZWZ0LT5kc287CisJc3RydWN0IGRzbyAqZHNvX3IgPSByaWdodC0+ZHNvOworCisJaWYgKCFkc29fbCB8fCAhZHNvX3IpIHsKKwkJaWYgKCFkc29fbCAmJiAhZHNvX3IpCisJCQlyZXR1cm4gMDsKKwkJZWxzZSBpZiAoIWRzb19sKQorCQkJcmV0dXJuIC0xOworCQllbHNlCisJCQlyZXR1cm4gMTsKKwl9CisKKwlyZXR1cm4gc3RyY21wKGRzb19sLT5uYW1lLCBkc29fci0+bmFtZSk7Cit9CisKK3N0YXRpYyBzaXplX3QKK3NvcnRfX2Rzb19wcmludChGSUxFICpmcCwgc3RydWN0IGhpc3RfZW50cnkgKnNlbGYpCit7CisJaWYgKHNlbGYtPmRzbykKKwkJcmV0dXJuIGZwcmludGYoZnAsICIlLTI1cyIsIHNlbGYtPmRzby0+bmFtZSk7CisKKwlyZXR1cm4gZnByaW50ZihmcCwgIiUwMTZsbHggICAgICAgICAiLCAoX191NjQpc2VsZi0+aXApOworfQorCitzdGF0aWMgc3RydWN0IHNvcnRfZW50cnkgc29ydF9kc28gPSB7CisJLmhlYWRlciA9ICJTaGFyZWQgT2JqZWN0ICAgICAgICAgICAgIiwKKwkuY21wCT0gc29ydF9fZHNvX2NtcCwKKwkucHJpbnQJPSBzb3J0X19kc29fcHJpbnQsCit9OworCisvKiAtLXNvcnQgc3ltYm9sICovCisKK3N0YXRpYyBpbnQ2NF90Citzb3J0X19zeW1fY21wKHN0cnVjdCBoaXN0X2VudHJ5ICpsZWZ0LCBzdHJ1Y3QgaGlzdF9lbnRyeSAqcmlnaHQpCit7CisJX191NjQgaXBfbCwgaXBfcjsKKworCWlmIChsZWZ0LT5zeW0gPT0gcmlnaHQtPnN5bSkKKwkJcmV0dXJuIDA7CisKKwlpcF9sID0gbGVmdC0+c3ltID8gbGVmdC0+c3ltLT5zdGFydCA6IGxlZnQtPmlwOworCWlwX3IgPSByaWdodC0+c3ltID8gcmlnaHQtPnN5bS0+c3RhcnQgOiByaWdodC0+aXA7CisKKwlyZXR1cm4gKGludDY0X3QpKGlwX3IgLSBpcF9sKTsKK30KKworc3RhdGljIHNpemVfdAorc29ydF9fc3ltX3ByaW50KEZJTEUgKmZwLCBzdHJ1Y3QgaGlzdF9lbnRyeSAqc2VsZikKK3sKKwlzaXplX3QgcmV0ID0gMDsKKworCWlmICh2ZXJib3NlKQorCQlyZXQgKz0gZnByaW50ZihmcCwgIiUjMDE4bGx4ICAiLCAoX191NjQpc2VsZi0+aXApOworCisJaWYgKHNlbGYtPnN5bSkgeworCQlyZXQgKz0gZnByaW50ZihmcCwgIlslY10gJXMiLAorCQkJc2VsZi0+ZHNvID09IGtlcm5lbF9kc28gPyAnaycgOiAnLicsIHNlbGYtPnN5bS0+bmFtZSk7CisJfSBlbHNlIHsKKwkJcmV0ICs9IGZwcmludGYoZnAsICIlIzAxNmxseCIsIChfX3U2NClzZWxmLT5pcCk7CisJfQorCisJcmV0dXJuIHJldDsKK30KKworc3RhdGljIHN0cnVjdCBzb3J0X2VudHJ5IHNvcnRfc3ltID0geworCS5oZWFkZXIgPSAiU3ltYm9sIiwKKwkuY21wCT0gc29ydF9fc3ltX2NtcCwKKwkucHJpbnQJPSBzb3J0X19zeW1fcHJpbnQsCit9OworCitzdGF0aWMgaW50IHNvcnRfX25lZWRfY29sbGFwc2UgPSAwOworCitzdHJ1Y3Qgc29ydF9kaW1lbnNpb24geworCWNoYXIJCQkqbmFtZTsKKwlzdHJ1Y3Qgc29ydF9lbnRyeQkqZW50cnk7CisJaW50CQkJdGFrZW47Cit9OworCitzdGF0aWMgc3RydWN0IHNvcnRfZGltZW5zaW9uIHNvcnRfZGltZW5zaW9uc1tdID0geworCXsgLm5hbWUgPSAicGlkIiwJLmVudHJ5ID0gJnNvcnRfdGhyZWFkLAl9LAorCXsgLm5hbWUgPSAiY29tbSIsCS5lbnRyeSA9ICZzb3J0X2NvbW0sCX0sCisJeyAubmFtZSA9ICJkc28iLAkuZW50cnkgPSAmc29ydF9kc28sCX0sCisJeyAubmFtZSA9ICJzeW1ib2wiLAkuZW50cnkgPSAmc29ydF9zeW0sCX0sCit9OworCitzdGF0aWMgTElTVF9IRUFEKGhpc3RfZW50cnlfX3NvcnRfbGlzdCk7CisKK3N0YXRpYyBpbnQgc29ydF9kaW1lbnNpb25fX2FkZChjaGFyICp0b2spCit7CisJaW50IGk7CisKKwlmb3IgKGkgPSAwOyBpIDwgQVJSQVlfU0laRShzb3J0X2RpbWVuc2lvbnMpOyBpKyspIHsKKwkJc3RydWN0IHNvcnRfZGltZW5zaW9uICpzZCA9ICZzb3J0X2RpbWVuc2lvbnNbaV07CisKKwkJaWYgKHNkLT50YWtlbikKKwkJCWNvbnRpbnVlOworCisJCWlmIChzdHJuY2FzZWNtcCh0b2ssIHNkLT5uYW1lLCBzdHJsZW4odG9rKSkpCisJCQljb250aW51ZTsKKworCQlpZiAoc2QtPmVudHJ5LT5jb2xsYXBzZSkKKwkJCXNvcnRfX25lZWRfY29sbGFwc2UgPSAxOworCisJCWxpc3RfYWRkX3RhaWwoJnNkLT5lbnRyeS0+bGlzdCwgJmhpc3RfZW50cnlfX3NvcnRfbGlzdCk7CisJCXNkLT50YWtlbiA9IDE7CisKKwkJcmV0dXJuIDA7CisJfQorCisJcmV0dXJuIC1FU1JDSDsKK30KKworc3RhdGljIGludDY0X3QKK2hpc3RfZW50cnlfX2NtcChzdHJ1Y3QgaGlzdF9lbnRyeSAqbGVmdCwgc3RydWN0IGhpc3RfZW50cnkgKnJpZ2h0KQoreworCXN0cnVjdCBzb3J0X2VudHJ5ICpzZTsKKwlpbnQ2NF90IGNtcCA9IDA7CisKKwlsaXN0X2Zvcl9lYWNoX2VudHJ5KHNlLCAmaGlzdF9lbnRyeV9fc29ydF9saXN0LCBsaXN0KSB7CisJCWNtcCA9IHNlLT5jbXAobGVmdCwgcmlnaHQpOworCQlpZiAoY21wKQorCQkJYnJlYWs7CisJfQorCisJcmV0dXJuIGNtcDsKK30KKworc3RhdGljIGludDY0X3QKK2hpc3RfZW50cnlfX2NvbGxhcHNlKHN0cnVjdCBoaXN0X2VudHJ5ICpsZWZ0LCBzdHJ1Y3QgaGlzdF9lbnRyeSAqcmlnaHQpCit7CisJc3RydWN0IHNvcnRfZW50cnkgKnNlOworCWludDY0X3QgY21wID0gMDsKKworCWxpc3RfZm9yX2VhY2hfZW50cnkoc2UsICZoaXN0X2VudHJ5X19zb3J0X2xpc3QsIGxpc3QpIHsKKwkJaW50NjRfdCAoKmYpKHN0cnVjdCBoaXN0X2VudHJ5ICosIHN0cnVjdCBoaXN0X2VudHJ5ICopOworCisJCWYgPSBzZS0+Y29sbGFwc2UgPzogc2UtPmNtcDsKKworCQljbXAgPSBmKGxlZnQsIHJpZ2h0KTsKKwkJaWYgKGNtcCkKKwkJCWJyZWFrOworCX0KKworCXJldHVybiBjbXA7Cit9CisKK3N0YXRpYyBzaXplX3QKK2hpc3RfZW50cnlfX2ZwcmludGYoRklMRSAqZnAsIHN0cnVjdCBoaXN0X2VudHJ5ICpzZWxmLCBfX3U2NCB0b3RhbF9zYW1wbGVzKQoreworCXN0cnVjdCBzb3J0X2VudHJ5ICpzZTsKKwlzaXplX3QgcmV0OworCisJaWYgKHRvdGFsX3NhbXBsZXMpIHsKKwkJZG91YmxlIHBlcmNlbnQgPSBzZWxmLT5jb3VudCAqIDEwMC4wIC8gdG90YWxfc2FtcGxlczsKKwkJY2hhciAqY29sb3IgPSBQRVJGX0NPTE9SX05PUk1BTDsKKworCQkvKgorCQkgKiBXZSBjb2xvciBoaWdoLW92ZXJoZWFkIGVudHJpZXMgaW4gcmVkLCBtaWQtb3ZlcmhlYWQKKwkJICogZW50cmllcyBpbiBncmVlbiAtIGFuZCBrZWVwIHRoZSBsb3cgb3ZlcmhlYWQgcGxhY2VzCisJCSAqIG5vcm1hbDoKKwkJICovCisJCWlmIChwZXJjZW50ID49IDUuMCkgeworCQkJY29sb3IgPSBQRVJGX0NPTE9SX1JFRDsKKwkJfSBlbHNlIHsKKwkJCWlmIChwZXJjZW50ID49IDAuNSkKKwkJCQljb2xvciA9IFBFUkZfQ09MT1JfR1JFRU47CisJCX0KKworCQlyZXQgPSBjb2xvcl9mcHJpbnRmKGZwLCBjb2xvciwgIiAgICU2LjJmJSUiLAorCQkJCShzZWxmLT5jb3VudCAqIDEwMC4wKSAvIHRvdGFsX3NhbXBsZXMpOworCX0gZWxzZQorCQlyZXQgPSBmcHJpbnRmKGZwLCAiJTEyTGQgIiwgc2VsZi0+Y291bnQpOworCisJbGlzdF9mb3JfZWFjaF9lbnRyeShzZSwgJmhpc3RfZW50cnlfX3NvcnRfbGlzdCwgbGlzdCkgeworCQlmcHJpbnRmKGZwLCAiICAiKTsKKwkJcmV0ICs9IHNlLT5wcmludChmcCwgc2VsZik7CisJfQorCisJcmV0ICs9IGZwcmludGYoZnAsICJcbiIpOworCisJcmV0dXJuIHJldDsKK30KKworLyoKKyAqIGNvbGxlY3QgaGlzdG9ncmFtIGNvdW50cworICovCisKK3N0YXRpYyBpbnQKK2hpc3RfZW50cnlfX2FkZChzdHJ1Y3QgdGhyZWFkICp0aHJlYWQsIHN0cnVjdCBtYXAgKm1hcCwgc3RydWN0IGRzbyAqZHNvLAorCQlzdHJ1Y3Qgc3ltYm9sICpzeW0sIF9fdTY0IGlwLCBjaGFyIGxldmVsLCBfX3U2NCBjb3VudCkKK3sKKwlzdHJ1Y3QgcmJfbm9kZSAqKnAgPSAmaGlzdC5yYl9ub2RlOworCXN0cnVjdCByYl9ub2RlICpwYXJlbnQgPSBOVUxMOworCXN0cnVjdCBoaXN0X2VudHJ5ICpoZTsKKwlzdHJ1Y3QgaGlzdF9lbnRyeSBlbnRyeSA9IHsKKwkJLnRocmVhZAk9IHRocmVhZCwKKwkJLm1hcAk9IG1hcCwKKwkJLmRzbwk9IGRzbywKKwkJLnN5bQk9IHN5bSwKKwkJLmlwCT0gaXAsCisJCS5sZXZlbAk9IGxldmVsLAorCQkuY291bnQJPSBjb3VudCwKKwl9OworCWludCBjbXA7CisKKwl3aGlsZSAoKnAgIT0gTlVMTCkgeworCQlwYXJlbnQgPSAqcDsKKwkJaGUgPSByYl9lbnRyeShwYXJlbnQsIHN0cnVjdCBoaXN0X2VudHJ5LCByYl9ub2RlKTsKKworCQljbXAgPSBoaXN0X2VudHJ5X19jbXAoJmVudHJ5LCBoZSk7CisKKwkJaWYgKCFjbXApIHsKKwkJCWhlLT5jb3VudCArPSBjb3VudDsKKwkJCXJldHVybiAwOworCQl9CisKKwkJaWYgKGNtcCA8IDApCisJCQlwID0gJigqcCktPnJiX2xlZnQ7CisJCWVsc2UKKwkJCXAgPSAmKCpwKS0+cmJfcmlnaHQ7CisJfQorCisJaGUgPSBtYWxsb2Moc2l6ZW9mKCpoZSkpOworCWlmICghaGUpCisJCXJldHVybiAtRU5PTUVNOworCSpoZSA9IGVudHJ5OworCXJiX2xpbmtfbm9kZSgmaGUtPnJiX25vZGUsIHBhcmVudCwgcCk7CisJcmJfaW5zZXJ0X2NvbG9yKCZoZS0+cmJfbm9kZSwgJmhpc3QpOworCisJcmV0dXJuIDA7Cit9CisKK3N0YXRpYyB2b2lkIGhpc3RfZW50cnlfX2ZyZWUoc3RydWN0IGhpc3RfZW50cnkgKmhlKQoreworCWZyZWUoaGUpOworfQorCisvKgorICogY29sbGFwc2UgdGhlIGhpc3RvZ3JhbQorICovCisKK3N0YXRpYyBzdHJ1Y3QgcmJfcm9vdCBjb2xsYXBzZV9oaXN0czsKKworc3RhdGljIHZvaWQgY29sbGFwc2VfX2luc2VydF9lbnRyeShzdHJ1Y3QgaGlzdF9lbnRyeSAqaGUpCit7CisJc3RydWN0IHJiX25vZGUgKipwID0gJmNvbGxhcHNlX2hpc3RzLnJiX25vZGU7CisJc3RydWN0IHJiX25vZGUgKnBhcmVudCA9IE5VTEw7CisJc3RydWN0IGhpc3RfZW50cnkgKml0ZXI7CisJaW50NjRfdCBjbXA7CisKKwl3aGlsZSAoKnAgIT0gTlVMTCkgeworCQlwYXJlbnQgPSAqcDsKKwkJaXRlciA9IHJiX2VudHJ5KHBhcmVudCwgc3RydWN0IGhpc3RfZW50cnksIHJiX25vZGUpOworCisJCWNtcCA9IGhpc3RfZW50cnlfX2NvbGxhcHNlKGl0ZXIsIGhlKTsKKworCQlpZiAoIWNtcCkgeworCQkJaXRlci0+Y291bnQgKz0gaGUtPmNvdW50OworCQkJaGlzdF9lbnRyeV9fZnJlZShoZSk7CisJCQlyZXR1cm47CisJCX0KKworCQlpZiAoY21wIDwgMCkKKwkJCXAgPSAmKCpwKS0+cmJfbGVmdDsKKwkJZWxzZQorCQkJcCA9ICYoKnApLT5yYl9yaWdodDsKKwl9CisKKwlyYl9saW5rX25vZGUoJmhlLT5yYl9ub2RlLCBwYXJlbnQsIHApOworCXJiX2luc2VydF9jb2xvcigmaGUtPnJiX25vZGUsICZjb2xsYXBzZV9oaXN0cyk7Cit9CisKK3N0YXRpYyB2b2lkIGNvbGxhcHNlX19yZXNvcnQodm9pZCkKK3sKKwlzdHJ1Y3QgcmJfbm9kZSAqbmV4dDsKKwlzdHJ1Y3QgaGlzdF9lbnRyeSAqbjsKKworCWlmICghc29ydF9fbmVlZF9jb2xsYXBzZSkKKwkJcmV0dXJuOworCisJbmV4dCA9IHJiX2ZpcnN0KCZoaXN0KTsKKwl3aGlsZSAobmV4dCkgeworCQluID0gcmJfZW50cnkobmV4dCwgc3RydWN0IGhpc3RfZW50cnksIHJiX25vZGUpOworCQluZXh0ID0gcmJfbmV4dCgmbi0+cmJfbm9kZSk7CisKKwkJcmJfZXJhc2UoJm4tPnJiX25vZGUsICZoaXN0KTsKKwkJY29sbGFwc2VfX2luc2VydF9lbnRyeShuKTsKKwl9Cit9CisKKy8qCisgKiByZXZlcnNlIHRoZSBtYXAsIHNvcnQgb24gY291bnQuCisgKi8KKworc3RhdGljIHN0cnVjdCByYl9yb290IG91dHB1dF9oaXN0czsKKworc3RhdGljIHZvaWQgb3V0cHV0X19pbnNlcnRfZW50cnkoc3RydWN0IGhpc3RfZW50cnkgKmhlKQoreworCXN0cnVjdCByYl9ub2RlICoqcCA9ICZvdXRwdXRfaGlzdHMucmJfbm9kZTsKKwlzdHJ1Y3QgcmJfbm9kZSAqcGFyZW50ID0gTlVMTDsKKwlzdHJ1Y3QgaGlzdF9lbnRyeSAqaXRlcjsKKworCXdoaWxlICgqcCAhPSBOVUxMKSB7CisJCXBhcmVudCA9ICpwOworCQlpdGVyID0gcmJfZW50cnkocGFyZW50LCBzdHJ1Y3QgaGlzdF9lbnRyeSwgcmJfbm9kZSk7CisKKwkJaWYgKGhlLT5jb3VudCA+IGl0ZXItPmNvdW50KQorCQkJcCA9ICYoKnApLT5yYl9sZWZ0OworCQllbHNlCisJCQlwID0gJigqcCktPnJiX3JpZ2h0OworCX0KKworCXJiX2xpbmtfbm9kZSgmaGUtPnJiX25vZGUsIHBhcmVudCwgcCk7CisJcmJfaW5zZXJ0X2NvbG9yKCZoZS0+cmJfbm9kZSwgJm91dHB1dF9oaXN0cyk7Cit9CisKK3N0YXRpYyB2b2lkIG91dHB1dF9fcmVzb3J0KHZvaWQpCit7CisJc3RydWN0IHJiX25vZGUgKm5leHQ7CisJc3RydWN0IGhpc3RfZW50cnkgKm47CisJc3RydWN0IHJiX3Jvb3QgKnRyZWUgPSAmaGlzdDsKKworCWlmIChzb3J0X19uZWVkX2NvbGxhcHNlKQorCQl0cmVlID0gJmNvbGxhcHNlX2hpc3RzOworCisJbmV4dCA9IHJiX2ZpcnN0KHRyZWUpOworCisJd2hpbGUgKG5leHQpIHsKKwkJbiA9IHJiX2VudHJ5KG5leHQsIHN0cnVjdCBoaXN0X2VudHJ5LCByYl9ub2RlKTsKKwkJbmV4dCA9IHJiX25leHQoJm4tPnJiX25vZGUpOworCisJCXJiX2VyYXNlKCZuLT5yYl9ub2RlLCB0cmVlKTsKKwkJb3V0cHV0X19pbnNlcnRfZW50cnkobik7CisJfQorfQorCitzdGF0aWMgc2l6ZV90IG91dHB1dF9fZnByaW50ZihGSUxFICpmcCwgX191NjQgdG90YWxfc2FtcGxlcykKK3sKKwlzdHJ1Y3QgaGlzdF9lbnRyeSAqcG9zOworCXN0cnVjdCBzb3J0X2VudHJ5ICpzZTsKKwlzdHJ1Y3QgcmJfbm9kZSAqbmQ7CisJc2l6ZV90IHJldCA9IDA7CisKKwlmcHJpbnRmKGZwLCAiXG4iKTsKKwlmcHJpbnRmKGZwLCAiI1xuIik7CisJZnByaW50ZihmcCwgIiMgKCVMZCBzYW1wbGVzKVxuIiwgKF9fdTY0KXRvdGFsX3NhbXBsZXMpOworCWZwcmludGYoZnAsICIjXG4iKTsKKworCWZwcmludGYoZnAsICIjIE92ZXJoZWFkIik7CisJbGlzdF9mb3JfZWFjaF9lbnRyeShzZSwgJmhpc3RfZW50cnlfX3NvcnRfbGlzdCwgbGlzdCkKKwkJZnByaW50ZihmcCwgIiAgJXMiLCBzZS0+aGVhZGVyKTsKKwlmcHJpbnRmKGZwLCAiXG4iKTsKKworCWZwcmludGYoZnAsICIjIC4uLi4uLi4uIik7CisJbGlzdF9mb3JfZWFjaF9lbnRyeShzZSwgJmhpc3RfZW50cnlfX3NvcnRfbGlzdCwgbGlzdCkgeworCQlpbnQgaTsKKworCQlmcHJpbnRmKGZwLCAiICAiKTsKKwkJZm9yIChpID0gMDsgaSA8IHN0cmxlbihzZS0+aGVhZGVyKTsgaSsrKQorCQkJZnByaW50ZihmcCwgIi4iKTsKKwl9CisJZnByaW50ZihmcCwgIlxuIik7CisKKwlmcHJpbnRmKGZwLCAiI1xuIik7CisKKwlmb3IgKG5kID0gcmJfZmlyc3QoJm91dHB1dF9oaXN0cyk7IG5kOyBuZCA9IHJiX25leHQobmQpKSB7CisJCXBvcyA9IHJiX2VudHJ5KG5kLCBzdHJ1Y3QgaGlzdF9lbnRyeSwgcmJfbm9kZSk7CisJCXJldCArPSBoaXN0X2VudHJ5X19mcHJpbnRmKGZwLCBwb3MsIHRvdGFsX3NhbXBsZXMpOworCX0KKworCWlmICghc3RyY21wKHNvcnRfb3JkZXIsIGRlZmF1bHRfc29ydF9vcmRlcikpIHsKKwkJZnByaW50ZihmcCwgIiNcbiIpOworCQlmcHJpbnRmKGZwLCAiIyAoRm9yIG1vcmUgZGV0YWlscywgdHJ5OiBwZXJmIHJlcG9ydCAtLXNvcnQgY29tbSxkc28sc3ltYm9sKVxuIik7CisJCWZwcmludGYoZnAsICIjXG4iKTsKKwl9CisJZnByaW50ZihmcCwgIlxuIik7CisKKwlyZXR1cm4gcmV0OworfQorCitzdGF0aWMgdm9pZCByZWdpc3Rlcl9pZGxlX3RocmVhZCh2b2lkKQoreworCXN0cnVjdCB0aHJlYWQgKnRocmVhZCA9IHRocmVhZHNfX2ZpbmRuZXcoMCk7CisKKwlpZiAodGhyZWFkID09IE5VTEwgfHwKKwkJCXRocmVhZF9fc2V0X2NvbW0odGhyZWFkLCAiW2lkbGVdIikpIHsKKwkJZnByaW50ZihzdGRlcnIsICJwcm9ibGVtIGluc2VydGluZyBpZGxlIHRhc2suXG4iKTsKKwkJZXhpdCgtMSk7CisJfQorfQorCitzdGF0aWMgdW5zaWduZWQgbG9uZyB0b3RhbCA9IDAsCisJCSAgICAgdG90YWxfbW1hcCA9IDAsCisJCSAgICAgdG90YWxfY29tbSA9IDAsCisJCSAgICAgdG90YWxfZm9yayA9IDAsCisJCSAgICAgdG90YWxfdW5rbm93biA9IDA7CisKK3N0YXRpYyBpbnQKK3Byb2Nlc3Nfb3ZlcmZsb3dfZXZlbnQoZXZlbnRfdCAqZXZlbnQsIHVuc2lnbmVkIGxvbmcgb2Zmc2V0LCB1bnNpZ25lZCBsb25nIGhlYWQpCit7CisJY2hhciBsZXZlbDsKKwlpbnQgc2hvdyA9IDA7CisJc3RydWN0IGRzbyAqZHNvID0gTlVMTDsKKwlzdHJ1Y3QgdGhyZWFkICp0aHJlYWQgPSB0aHJlYWRzX19maW5kbmV3KGV2ZW50LT5pcC5waWQpOworCV9fdTY0IGlwID0gZXZlbnQtPmlwLmlwOworCV9fdTY0IHBlcmlvZCA9IDE7CisJc3RydWN0IG1hcCAqbWFwID0gTlVMTDsKKworCWlmIChldmVudC0+aGVhZGVyLnR5cGUgJiBQRVJGX1NBTVBMRV9QRVJJT0QpCisJCXBlcmlvZCA9IGV2ZW50LT5pcC5wZXJpb2Q7CisKKwlkcHJpbnRmKCIlcCBbJXBdOiBQRVJGX0VWRU5UIChJUCwgJWQpOiAlZDogJXAgcGVyaW9kOiAlTGRcbiIsCisJCSh2b2lkICopKG9mZnNldCArIGhlYWQpLAorCQkodm9pZCAqKShsb25nKShldmVudC0+aGVhZGVyLnNpemUpLAorCQlldmVudC0+aGVhZGVyLm1pc2MsCisJCWV2ZW50LT5pcC5waWQsCisJCSh2b2lkICopKGxvbmcpaXAsCisJCShsb25nIGxvbmcpcGVyaW9kKTsKKworCWRwcmludGYoIiAuLi4gdGhyZWFkOiAlczolZFxuIiwgdGhyZWFkLT5jb21tLCB0aHJlYWQtPnBpZCk7CisKKwlpZiAodGhyZWFkID09IE5VTEwpIHsKKwkJZnByaW50ZihzdGRlcnIsICJwcm9ibGVtIHByb2Nlc3NpbmcgJWQgZXZlbnQsIHNraXBwaW5nIGl0LlxuIiwKKwkJCWV2ZW50LT5oZWFkZXIudHlwZSk7CisJCXJldHVybiAtMTsKKwl9CisKKwlpZiAoZXZlbnQtPmhlYWRlci5taXNjICYgUEVSRl9FVkVOVF9NSVNDX0tFUk5FTCkgeworCQlzaG93ID0gU0hPV19LRVJORUw7CisJCWxldmVsID0gJ2snOworCisJCWRzbyA9IGtlcm5lbF9kc287CisKKwkJZHByaW50ZigiIC4uLi4uLiBkc286ICVzXG4iLCBkc28tPm5hbWUpOworCisJfSBlbHNlIGlmIChldmVudC0+aGVhZGVyLm1pc2MgJiBQRVJGX0VWRU5UX01JU0NfVVNFUikgeworCisJCXNob3cgPSBTSE9XX1VTRVI7CisJCWxldmVsID0gJy4nOworCisJCW1hcCA9IHRocmVhZF9fZmluZF9tYXAodGhyZWFkLCBpcCk7CisJCWlmIChtYXAgIT0gTlVMTCkgeworCQkJaXAgPSBtYXAtPm1hcF9pcChtYXAsIGlwKTsKKwkJCWRzbyA9IG1hcC0+ZHNvOworCQl9IGVsc2UgeworCQkJLyoKKwkJCSAqIElmIHRoaXMgaXMgb3V0c2lkZSBvZiBhbGwga25vd24gbWFwcywKKwkJCSAqIGFuZCBpcyBhIG5lZ2F0aXZlIGFkZHJlc3MsIHRyeSB0byBsb29rIGl0CisJCQkgKiB1cCBpbiB0aGUga2VybmVsIGRzbywgYXMgaXQgbWlnaHQgYmUgYQorCQkJICogdnN5c2NhbGwgKHdoaWNoIGV4ZWN1dGVzIGluIHVzZXItbW9kZSk6CisJCQkgKi8KKwkJCWlmICgobG9uZyBsb25nKWlwIDwgMCkKKwkJCQlkc28gPSBrZXJuZWxfZHNvOworCQl9CisJCWRwcmludGYoIiAuLi4uLi4gZHNvOiAlc1xuIiwgZHNvID8gZHNvLT5uYW1lIDogIjxub3QgZm91bmQ+Iik7CisKKwl9IGVsc2UgeworCQlzaG93ID0gU0hPV19IVjsKKwkJbGV2ZWwgPSAnSCc7CisJCWRwcmludGYoIiAuLi4uLi4gZHNvOiBbaHlwZXJ2aXNvcl1cbiIpOworCX0KKworCWlmIChzaG93ICYgc2hvd19tYXNrKSB7CisJCXN0cnVjdCBzeW1ib2wgKnN5bSA9IE5VTEw7CisKKwkJaWYgKGRzbykKKwkJCXN5bSA9IGRzby0+ZmluZF9zeW1ib2woZHNvLCBpcCk7CisKKwkJaWYgKGhpc3RfZW50cnlfX2FkZCh0aHJlYWQsIG1hcCwgZHNvLCBzeW0sIGlwLCBsZXZlbCwgcGVyaW9kKSkgeworCQkJZnByaW50ZihzdGRlcnIsCisJCSJwcm9ibGVtIGluY3JlbWVudGluZyBzeW1ib2wgY291bnQsIHNraXBwaW5nIGV2ZW50XG4iKTsKKwkJCXJldHVybiAtMTsKKwkJfQorCX0KKwl0b3RhbCArPSBwZXJpb2Q7CisKKwlyZXR1cm4gMDsKK30KKworc3RhdGljIGludAorcHJvY2Vzc19tbWFwX2V2ZW50KGV2ZW50X3QgKmV2ZW50LCB1bnNpZ25lZCBsb25nIG9mZnNldCwgdW5zaWduZWQgbG9uZyBoZWFkKQoreworCXN0cnVjdCB0aHJlYWQgKnRocmVhZCA9IHRocmVhZHNfX2ZpbmRuZXcoZXZlbnQtPm1tYXAucGlkKTsKKwlzdHJ1Y3QgbWFwICptYXAgPSBtYXBfX25ldygmZXZlbnQtPm1tYXApOworCisJZHByaW50ZigiJXAgWyVwXTogUEVSRl9FVkVOVF9NTUFQICVkOiBbJXAoJXApIEAgJXBdOiAlc1xuIiwKKwkJKHZvaWQgKikob2Zmc2V0ICsgaGVhZCksCisJCSh2b2lkICopKGxvbmcpKGV2ZW50LT5oZWFkZXIuc2l6ZSksCisJCWV2ZW50LT5tbWFwLnBpZCwKKwkJKHZvaWQgKikobG9uZylldmVudC0+bW1hcC5zdGFydCwKKwkJKHZvaWQgKikobG9uZylldmVudC0+bW1hcC5sZW4sCisJCSh2b2lkICopKGxvbmcpZXZlbnQtPm1tYXAucGdvZmYsCisJCWV2ZW50LT5tbWFwLmZpbGVuYW1lKTsKKworCWlmICh0aHJlYWQgPT0gTlVMTCB8fCBtYXAgPT0gTlVMTCkgeworCQlkcHJpbnRmKCJwcm9ibGVtIHByb2Nlc3NpbmcgUEVSRl9FVkVOVF9NTUFQLCBza2lwcGluZyBldmVudC5cbiIpOworCQlyZXR1cm4gMDsKKwl9CisKKwl0aHJlYWRfX2luc2VydF9tYXAodGhyZWFkLCBtYXApOworCXRvdGFsX21tYXArKzsKKworCXJldHVybiAwOworfQorCitzdGF0aWMgaW50Citwcm9jZXNzX2NvbW1fZXZlbnQoZXZlbnRfdCAqZXZlbnQsIHVuc2lnbmVkIGxvbmcgb2Zmc2V0LCB1bnNpZ25lZCBsb25nIGhlYWQpCit7CisJc3RydWN0IHRocmVhZCAqdGhyZWFkID0gdGhyZWFkc19fZmluZG5ldyhldmVudC0+Y29tbS5waWQpOworCisJZHByaW50ZigiJXAgWyVwXTogUEVSRl9FVkVOVF9DT01NOiAlczolZFxuIiwKKwkJKHZvaWQgKikob2Zmc2V0ICsgaGVhZCksCisJCSh2b2lkICopKGxvbmcpKGV2ZW50LT5oZWFkZXIuc2l6ZSksCisJCWV2ZW50LT5jb21tLmNvbW0sIGV2ZW50LT5jb21tLnBpZCk7CisKKwlpZiAodGhyZWFkID09IE5VTEwgfHwKKwkgICAgdGhyZWFkX19zZXRfY29tbSh0aHJlYWQsIGV2ZW50LT5jb21tLmNvbW0pKSB7CisJCWRwcmludGYoInByb2JsZW0gcHJvY2Vzc2luZyBQRVJGX0VWRU5UX0NPTU0sIHNraXBwaW5nIGV2ZW50LlxuIik7CisJCXJldHVybiAtMTsKKwl9CisJdG90YWxfY29tbSsrOworCisJcmV0dXJuIDA7Cit9CisKK3N0YXRpYyBpbnQKK3Byb2Nlc3NfZm9ya19ldmVudChldmVudF90ICpldmVudCwgdW5zaWduZWQgbG9uZyBvZmZzZXQsIHVuc2lnbmVkIGxvbmcgaGVhZCkKK3sKKwlzdHJ1Y3QgdGhyZWFkICp0aHJlYWQgPSB0aHJlYWRzX19maW5kbmV3KGV2ZW50LT5mb3JrLnBpZCk7CisJc3RydWN0IHRocmVhZCAqcGFyZW50ID0gdGhyZWFkc19fZmluZG5ldyhldmVudC0+Zm9yay5wcGlkKTsKKworCWRwcmludGYoIiVwIFslcF06IFBFUkZfRVZFTlRfRk9SSzogJWQ6JWRcbiIsCisJCSh2b2lkICopKG9mZnNldCArIGhlYWQpLAorCQkodm9pZCAqKShsb25nKShldmVudC0+aGVhZGVyLnNpemUpLAorCQlldmVudC0+Zm9yay5waWQsIGV2ZW50LT5mb3JrLnBwaWQpOworCisJaWYgKCF0aHJlYWQgfHwgIXBhcmVudCB8fCB0aHJlYWRfX2ZvcmsodGhyZWFkLCBwYXJlbnQpKSB7CisJCWRwcmludGYoInByb2JsZW0gcHJvY2Vzc2luZyBQRVJGX0VWRU5UX0ZPUkssIHNraXBwaW5nIGV2ZW50LlxuIik7CisJCXJldHVybiAtMTsKKwl9CisJdG90YWxfZm9yaysrOworCisJcmV0dXJuIDA7Cit9CisKK3N0YXRpYyBpbnQKK3Byb2Nlc3NfcGVyaW9kX2V2ZW50KGV2ZW50X3QgKmV2ZW50LCB1bnNpZ25lZCBsb25nIG9mZnNldCwgdW5zaWduZWQgbG9uZyBoZWFkKQoreworCWRwcmludGYoIiVwIFslcF06IFBFUkZfRVZFTlRfUEVSSU9EOiB0aW1lOiVMZCwgaWQ6JUxkOiBwZXJpb2Q6JUxkXG4iLAorCQkodm9pZCAqKShvZmZzZXQgKyBoZWFkKSwKKwkJKHZvaWQgKikobG9uZykoZXZlbnQtPmhlYWRlci5zaXplKSwKKwkJZXZlbnQtPnBlcmlvZC50aW1lLAorCQlldmVudC0+cGVyaW9kLmlkLAorCQlldmVudC0+cGVyaW9kLnNhbXBsZV9wZXJpb2QpOworCisJcmV0dXJuIDA7Cit9CisKK3N0YXRpYyBpbnQKK3Byb2Nlc3NfZXZlbnQoZXZlbnRfdCAqZXZlbnQsIHVuc2lnbmVkIGxvbmcgb2Zmc2V0LCB1bnNpZ25lZCBsb25nIGhlYWQpCit7CisJaWYgKGV2ZW50LT5oZWFkZXIubWlzYyAmIFBFUkZfRVZFTlRfTUlTQ19PVkVSRkxPVykKKwkJcmV0dXJuIHByb2Nlc3Nfb3ZlcmZsb3dfZXZlbnQoZXZlbnQsIG9mZnNldCwgaGVhZCk7CisKKwlzd2l0Y2ggKGV2ZW50LT5oZWFkZXIudHlwZSkgeworCWNhc2UgUEVSRl9FVkVOVF9NTUFQOgorCQlyZXR1cm4gcHJvY2Vzc19tbWFwX2V2ZW50KGV2ZW50LCBvZmZzZXQsIGhlYWQpOworCisJY2FzZSBQRVJGX0VWRU5UX0NPTU06CisJCXJldHVybiBwcm9jZXNzX2NvbW1fZXZlbnQoZXZlbnQsIG9mZnNldCwgaGVhZCk7CisKKwljYXNlIFBFUkZfRVZFTlRfRk9SSzoKKwkJcmV0dXJuIHByb2Nlc3NfZm9ya19ldmVudChldmVudCwgb2Zmc2V0LCBoZWFkKTsKKworCWNhc2UgUEVSRl9FVkVOVF9QRVJJT0Q6CisJCXJldHVybiBwcm9jZXNzX3BlcmlvZF9ldmVudChldmVudCwgb2Zmc2V0LCBoZWFkKTsKKwkvKgorCSAqIFdlIGRvbnQgcHJvY2VzcyB0aGVtIHJpZ2h0IG5vdyBidXQgdGhleSBhcmUgZmluZToKKwkgKi8KKworCWNhc2UgUEVSRl9FVkVOVF9USFJPVFRMRToKKwljYXNlIFBFUkZfRVZFTlRfVU5USFJPVFRMRToKKwkJcmV0dXJuIDA7CisKKwlkZWZhdWx0OgorCQlyZXR1cm4gLTE7CisJfQorCisJcmV0dXJuIDA7Cit9CisKK3N0YXRpYyBpbnQgX19jbWRfcmVwb3J0KHZvaWQpCit7CisJaW50IHJldCwgcmMgPSBFWElUX0ZBSUxVUkU7CisJdW5zaWduZWQgbG9uZyBvZmZzZXQgPSAwOworCXVuc2lnbmVkIGxvbmcgaGVhZCA9IDA7CisJc3RydWN0IHN0YXQgc3RhdDsKKwlldmVudF90ICpldmVudDsKKwl1aW50MzJfdCBzaXplOworCWNoYXIgKmJ1ZjsKKworCXJlZ2lzdGVyX2lkbGVfdGhyZWFkKCk7CisKKwlpbnB1dCA9IG9wZW4oaW5wdXRfbmFtZSwgT19SRE9OTFkpOworCWlmIChpbnB1dCA8IDApIHsKKwkJZnByaW50ZihzdGRlcnIsICIgZmFpbGVkIHRvIG9wZW4gZmlsZTogJXMiLCBpbnB1dF9uYW1lKTsKKwkJaWYgKCFzdHJjbXAoaW5wdXRfbmFtZSwgInBlcmYuZGF0YSIpKQorCQkJZnByaW50ZihzdGRlcnIsICIgICh0cnkgJ3BlcmYgcmVjb3JkJyBmaXJzdCkiKTsKKwkJZnByaW50ZihzdGRlcnIsICJcbiIpOworCQlleGl0KC0xKTsKKwl9CisKKwlyZXQgPSBmc3RhdChpbnB1dCwgJnN0YXQpOworCWlmIChyZXQgPCAwKSB7CisJCXBlcnJvcigiZmFpbGVkIHRvIHN0YXQgZmlsZSIpOworCQlleGl0KC0xKTsKKwl9CisKKwlpZiAoIXN0YXQuc3Rfc2l6ZSkgeworCQlmcHJpbnRmKHN0ZGVyciwgInplcm8tc2l6ZWQgZmlsZSwgbm90aGluZyB0byBkbyFcbiIpOworCQlleGl0KDApOworCX0KKworCWlmIChsb2FkX2tlcm5lbCgpIDwgMCkgeworCQlwZXJyb3IoImZhaWxlZCB0byBsb2FkIGtlcm5lbCBzeW1ib2xzIik7CisJCXJldHVybiBFWElUX0ZBSUxVUkU7CisJfQorCisJaWYgKCFmdWxsX3BhdGhzKSB7CisJCWlmIChnZXRjd2QoX19jd2QsIHNpemVvZihfX2N3ZCkpID09IE5VTEwpIHsKKwkJCXBlcnJvcigiZmFpbGVkIHRvIGdldCB0aGUgY3VycmVudCBkaXJlY3RvcnkiKTsKKwkJCXJldHVybiBFWElUX0ZBSUxVUkU7CisJCX0KKwkJY3dkbGVuID0gc3RybGVuKGN3ZCk7CisJfSBlbHNlIHsKKwkJY3dkID0gTlVMTDsKKwkJY3dkbGVuID0gMDsKKwl9CityZW1hcDoKKwlidWYgPSAoY2hhciAqKW1tYXAoTlVMTCwgcGFnZV9zaXplICogbW1hcF93aW5kb3csIFBST1RfUkVBRCwKKwkJCSAgIE1BUF9TSEFSRUQsIGlucHV0LCBvZmZzZXQpOworCWlmIChidWYgPT0gTUFQX0ZBSUxFRCkgeworCQlwZXJyb3IoImZhaWxlZCB0byBtbWFwIGZpbGUiKTsKKwkJZXhpdCgtMSk7CisJfQorCittb3JlOgorCWV2ZW50ID0gKGV2ZW50X3QgKikoYnVmICsgaGVhZCk7CisKKwlzaXplID0gZXZlbnQtPmhlYWRlci5zaXplOworCWlmICghc2l6ZSkKKwkJc2l6ZSA9IDg7CisKKwlpZiAoaGVhZCArIGV2ZW50LT5oZWFkZXIuc2l6ZSA+PSBwYWdlX3NpemUgKiBtbWFwX3dpbmRvdykgeworCQl1bnNpZ25lZCBsb25nIHNoaWZ0ID0gcGFnZV9zaXplICogKGhlYWQgLyBwYWdlX3NpemUpOworCQlpbnQgcmV0OworCisJCXJldCA9IG11bm1hcChidWYsIHBhZ2Vfc2l6ZSAqIG1tYXBfd2luZG93KTsKKwkJYXNzZXJ0KHJldCA9PSAwKTsKKworCQlvZmZzZXQgKz0gc2hpZnQ7CisJCWhlYWQgLT0gc2hpZnQ7CisJCWdvdG8gcmVtYXA7CisJfQorCisJc2l6ZSA9IGV2ZW50LT5oZWFkZXIuc2l6ZTsKKworCWRwcmludGYoIiVwIFslcF06IGV2ZW50OiAlZFxuIiwKKwkJCSh2b2lkICopKG9mZnNldCArIGhlYWQpLAorCQkJKHZvaWQgKikobG9uZylldmVudC0+aGVhZGVyLnNpemUsCisJCQlldmVudC0+aGVhZGVyLnR5cGUpOworCisJaWYgKCFzaXplIHx8IHByb2Nlc3NfZXZlbnQoZXZlbnQsIG9mZnNldCwgaGVhZCkgPCAwKSB7CisKKwkJZHByaW50ZigiJXAgWyVwXTogc2tpcHBpbmcgdW5rbm93biBoZWFkZXIgdHlwZTogJWRcbiIsCisJCQkodm9pZCAqKShvZmZzZXQgKyBoZWFkKSwKKwkJCSh2b2lkICopKGxvbmcpKGV2ZW50LT5oZWFkZXIuc2l6ZSksCisJCQlldmVudC0+aGVhZGVyLnR5cGUpOworCisJCXRvdGFsX3Vua25vd24rKzsKKworCQkvKgorCQkgKiBhc3N1bWUgd2UgbG9zdCB0cmFjayBvZiB0aGUgc3RyZWFtLCBjaGVjayBhbGlnbm1lbnQsIGFuZAorCQkgKiBpbmNyZW1lbnQgYSBzaW5nbGUgdTY0IGluIHRoZSBob3BlIHRvIGNhdGNoIG9uIGFnYWluICdzb29uJy4KKwkJICovCisKKwkJaWYgKHVubGlrZWx5KGhlYWQgJiA3KSkKKwkJCWhlYWQgJj0gfjdVTEw7CisKKwkJc2l6ZSA9IDg7CisJfQorCisJaGVhZCArPSBzaXplOworCisJaWYgKG9mZnNldCArIGhlYWQgPCBzdGF0LnN0X3NpemUpCisJCWdvdG8gbW9yZTsKKworCXJjID0gRVhJVF9TVUNDRVNTOworCWNsb3NlKGlucHV0KTsKKworCWRwcmludGYoIiAgICAgIElQIGV2ZW50czogJTEwbGRcbiIsIHRvdGFsKTsKKwlkcHJpbnRmKCIgICAgbW1hcCBldmVudHM6ICUxMGxkXG4iLCB0b3RhbF9tbWFwKTsKKwlkcHJpbnRmKCIgICAgY29tbSBldmVudHM6ICUxMGxkXG4iLCB0b3RhbF9jb21tKTsKKwlkcHJpbnRmKCIgICAgZm9yayBldmVudHM6ICUxMGxkXG4iLCB0b3RhbF9mb3JrKTsKKwlkcHJpbnRmKCIgdW5rbm93biBldmVudHM6ICUxMGxkXG4iLCB0b3RhbF91bmtub3duKTsKKworCWlmIChkdW1wX3RyYWNlKQorCQlyZXR1cm4gMDsKKworCWlmICh2ZXJib3NlID49IDMpCisJCXRocmVhZHNfX2ZwcmludGYoc3Rkb3V0KTsKKworCWlmICh2ZXJib3NlID49IDIpCisJCWRzb3NfX2ZwcmludGYoc3Rkb3V0KTsKKworCWNvbGxhcHNlX19yZXNvcnQoKTsKKwlvdXRwdXRfX3Jlc29ydCgpOworCW91dHB1dF9fZnByaW50ZihzdGRvdXQsIHRvdGFsKTsKKworCXJldHVybiByYzsKK30KKworc3RhdGljIGNvbnN0IGNoYXIgKiBjb25zdCByZXBvcnRfdXNhZ2VbXSA9IHsKKwkicGVyZiByZXBvcnQgWzxvcHRpb25zPl0gPGNvbW1hbmQ+IiwKKwlOVUxMCit9OworCitzdGF0aWMgY29uc3Qgc3RydWN0IG9wdGlvbiBvcHRpb25zW10gPSB7CisJT1BUX1NUUklORygnaScsICJpbnB1dCIsICZpbnB1dF9uYW1lLCAiZmlsZSIsCisJCSAgICAiaW5wdXQgZmlsZSBuYW1lIiksCisJT1BUX0JPT0xFQU4oJ3YnLCAidmVyYm9zZSIsICZ2ZXJib3NlLAorCQkgICAgImJlIG1vcmUgdmVyYm9zZSAoc2hvdyBzeW1ib2wgYWRkcmVzcywgZXRjKSIpLAorCU9QVF9CT09MRUFOKCdEJywgImR1bXAtcmF3LXRyYWNlIiwgJmR1bXBfdHJhY2UsCisJCSAgICAiZHVtcCByYXcgdHJhY2UgaW4gQVNDSUkiKSwKKwlPUFRfU1RSSU5HKCdrJywgInZtbGludXgiLCAmdm1saW51eCwgImZpbGUiLCAidm1saW51eCBwYXRobmFtZSIpLAorCU9QVF9TVFJJTkcoJ3MnLCAic29ydCIsICZzb3J0X29yZGVyLCAia2V5WyxrZXkyLi4uXSIsCisJCSAgICJzb3J0IGJ5IGtleShzKTogcGlkLCBjb21tLCBkc28sIHN5bWJvbC4gRGVmYXVsdDogcGlkLHN5bWJvbCIpLAorCU9QVF9CT09MRUFOKCdQJywgImZ1bGwtcGF0aHMiLCAmZnVsbF9wYXRocywKKwkJICAgICJEb24ndCBzaG9ydGVuIHRoZSBwYXRobmFtZXMgdGFraW5nIGludG8gYWNjb3VudCB0aGUgY3dkIiksCisJT1BUX0VORCgpCit9OworCitzdGF0aWMgdm9pZCBzZXR1cF9zb3J0aW5nKHZvaWQpCit7CisJY2hhciAqdG1wLCAqdG9rLCAqc3RyID0gc3RyZHVwKHNvcnRfb3JkZXIpOworCisJZm9yICh0b2sgPSBzdHJ0b2tfcihzdHIsICIsICIsICZ0bXApOworCQkJdG9rOyB0b2sgPSBzdHJ0b2tfcihOVUxMLCAiLCAiLCAmdG1wKSkgeworCQlpZiAoc29ydF9kaW1lbnNpb25fX2FkZCh0b2spIDwgMCkgeworCQkJZXJyb3IoIlVua25vd24gLS1zb3J0IGtleTogYCVzJyIsIHRvayk7CisJCQl1c2FnZV93aXRoX29wdGlvbnMocmVwb3J0X3VzYWdlLCBvcHRpb25zKTsKKwkJfQorCX0KKworCWZyZWUoc3RyKTsKK30KKworaW50IGNtZF9yZXBvcnQoaW50IGFyZ2MsIGNvbnN0IGNoYXIgKiphcmd2LCBjb25zdCBjaGFyICpwcmVmaXgpCit7CisJc3ltYm9sX19pbml0KCk7CisKKwlwYWdlX3NpemUgPSBnZXRwYWdlc2l6ZSgpOworCisJYXJnYyA9IHBhcnNlX29wdGlvbnMoYXJnYywgYXJndiwgb3B0aW9ucywgcmVwb3J0X3VzYWdlLCAwKTsKKworCXNldHVwX3NvcnRpbmcoKTsKKworCS8qCisJICogQW55ICh1bnJlY29nbml6ZWQpIGFyZ3VtZW50cyBsZWZ0PworCSAqLworCWlmIChhcmdjKQorCQl1c2FnZV93aXRoX29wdGlvbnMocmVwb3J0X3VzYWdlLCBvcHRpb25zKTsKKworCXNldHVwX3BhZ2VyKCk7CisKKwlyZXR1cm4gX19jbWRfcmVwb3J0KCk7Cit9CmRpZmYgLS1naXQgYS90b29scy9wZXJmL2J1aWx0aW4tc3RhdC5jIGIvdG9vbHMvcGVyZi9idWlsdGluLXN0YXQuYwpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi5jNDNlNGE5Ci0tLSAvZGV2L251bGwKKysrIGIvdG9vbHMvcGVyZi9idWlsdGluLXN0YXQuYwpAQCAtMCwwICsxLDM2NyBAQAorLyoKKyAqIGJ1aWx0aW4tc3RhdC5jCisgKgorICogQnVpbHRpbiBzdGF0IGNvbW1hbmQ6IEdpdmUgYSBwcmVjaXNlIHBlcmZvcm1hbmNlIGNvdW50ZXJzIHN1bW1hcnkKKyAqIG92ZXJ2aWV3IGFib3V0IGFueSB3b3JrbG9hZCwgQ1BVIG9yIHNwZWNpZmljIFBJRC4KKyAqCisgKiBTYW1wbGUgb3V0cHV0OgorCisgICAkIHBlcmYgc3RhdCB+L2hhY2tiZW5jaCAxMAorICAgVGltZTogMC4xMDQKKworICAgIFBlcmZvcm1hbmNlIGNvdW50ZXIgc3RhdHMgZm9yICcvaG9tZS9taW5nby9oYWNrYmVuY2gnOgorCisgICAgICAgMTI1NS41Mzg2MTEgIHRhc2sgY2xvY2sgdGlja3MgICAgICMgICAgICAxMC4xNDMgQ1BVIHV0aWxpemF0aW9uIGZhY3RvcgorICAgICAgICAgICAgIDU0MDExICBjb250ZXh0IHN3aXRjaGVzICAgICAjICAgICAgIDAuMDQzIE0vc2VjCisgICAgICAgICAgICAgICAzODUgIENQVSBtaWdyYXRpb25zICAgICAgICMgICAgICAgMC4wMDAgTS9zZWMKKyAgICAgICAgICAgICAxNzc1NSAgcGFnZWZhdWx0cyAgICAgICAgICAgIyAgICAgICAwLjAxNCBNL3NlYworICAgICAgICAzODA4MzIzMTg1ICBDUFUgY3ljbGVzICAgICAgICAgICAjICAgIDMwMzMuMjE5IE0vc2VjCisgICAgICAgIDE1NzUxMTExOTAgIGluc3RydWN0aW9ucyAgICAgICAgICMgICAgMTI1NC41MzAgTS9zZWMKKyAgICAgICAgICAxNzM2Nzg5NSAgY2FjaGUgcmVmZXJlbmNlcyAgICAgIyAgICAgIDEzLjgzMyBNL3NlYworICAgICAgICAgICA3Njc0NDIxICBjYWNoZSBtaXNzZXMgICAgICAgICAjICAgICAgIDYuMTEyIE0vc2VjCisKKyAgICBXYWxsLWNsb2NrIHRpbWUgZWxhcHNlZDogICAxMjMuNzg2NjIwIG1zZWNzCisKKyAqCisgKiBDb3B5cmlnaHQgKEMpIDIwMDgsIFJlZCBIYXQgSW5jLCBJbmdvIE1vbG5hciA8bWluZ29AcmVkaGF0LmNvbT4KKyAqCisgKiBJbXByb3ZlbWVudHMgYW5kIGZpeGVzIGJ5OgorICoKKyAqICAgQXJqYW4gdmFuIGRlIFZlbiA8YXJqYW5AbGludXguaW50ZWwuY29tPgorICogICBZYW5taW4gWmhhbmcgPHlhbm1pbi56aGFuZ0BpbnRlbC5jb20+CisgKiAgIFd1IEZlbmdndWFuZyA8ZmVuZ2d1YW5nLnd1QGludGVsLmNvbT4KKyAqICAgTWlrZSBHYWxicmFpdGggPGVmYXVsdEBnbXguZGU+CisgKiAgIFBhdWwgTWFja2VycmFzIDxwYXVsdXNAc2FtYmEub3JnPgorICoKKyAqIFJlbGVhc2VkIHVuZGVyIHRoZSBHUEwgdjIuIChhbmQgb25seSB2Miwgbm90IGFueSBsYXRlciB2ZXJzaW9uKQorICovCisKKyNpbmNsdWRlICJwZXJmLmgiCisjaW5jbHVkZSAiYnVpbHRpbi5oIgorI2luY2x1ZGUgInV0aWwvdXRpbC5oIgorI2luY2x1ZGUgInV0aWwvcGFyc2Utb3B0aW9ucy5oIgorI2luY2x1ZGUgInV0aWwvcGFyc2UtZXZlbnRzLmgiCisKKyNpbmNsdWRlIDxzeXMvcHJjdGwuaD4KKworc3RhdGljIHN0cnVjdCBwZXJmX2NvdW50ZXJfYXR0ciBkZWZhdWx0X2F0dHJzW01BWF9DT1VOVEVSU10gPSB7CisKKyAgeyAudHlwZSA9IFBFUkZfVFlQRV9TT0ZUV0FSRSwgLmNvbmZpZyA9IFBFUkZfQ09VTlRfU1dfVEFTS19DTE9DSwl9LAorICB7IC50eXBlID0gUEVSRl9UWVBFX1NPRlRXQVJFLCAuY29uZmlnID0gUEVSRl9DT1VOVF9TV19DT05URVhUX1NXSVRDSEVTfSwKKyAgeyAudHlwZSA9IFBFUkZfVFlQRV9TT0ZUV0FSRSwgLmNvbmZpZyA9IFBFUkZfQ09VTlRfU1dfQ1BVX01JR1JBVElPTlMJfSwKKyAgeyAudHlwZSA9IFBFUkZfVFlQRV9TT0ZUV0FSRSwgLmNvbmZpZyA9IFBFUkZfQ09VTlRfU1dfUEFHRV9GQVVMVFMJfSwKKworICB7IC50eXBlID0gUEVSRl9UWVBFX0hBUkRXQVJFLCAuY29uZmlnID0gUEVSRl9DT1VOVF9IV19DUFVfQ1lDTEVTCX0sCisgIHsgLnR5cGUgPSBQRVJGX1RZUEVfSEFSRFdBUkUsIC5jb25maWcgPSBQRVJGX0NPVU5UX0hXX0lOU1RSVUNUSU9OUwl9LAorICB7IC50eXBlID0gUEVSRl9UWVBFX0hBUkRXQVJFLCAuY29uZmlnID0gUEVSRl9DT1VOVF9IV19DQUNIRV9SRUZFUkVOQ0VTfSwKKyAgeyAudHlwZSA9IFBFUkZfVFlQRV9IQVJEV0FSRSwgLmNvbmZpZyA9IFBFUkZfQ09VTlRfSFdfQ0FDSEVfTUlTU0VTCX0sCisKK307CisKK3N0YXRpYyBpbnQJCQlzeXN0ZW1fd2lkZQkJCT0gIDA7CitzdGF0aWMgaW50CQkJaW5oZXJpdAkJCQk9ICAxOworc3RhdGljIGludAkJCXZlcmJvc2UJCQkJPSAgMDsKKworc3RhdGljIGludAkJCWZkW01BWF9OUl9DUFVTXVtNQVhfQ09VTlRFUlNdOworCitzdGF0aWMgaW50CQkJdGFyZ2V0X3BpZAkJCT0gLTE7CitzdGF0aWMgaW50CQkJbnJfY3B1cwkJCQk9ICAwOworc3RhdGljIHVuc2lnbmVkIGludAkJcGFnZV9zaXplOworCitzdGF0aWMgaW50CQkJc2NhbGUJCQkJPSAgMTsKKworc3RhdGljIGNvbnN0IHVuc2lnbmVkIGludCBkZWZhdWx0X2NvdW50W10gPSB7CisJMTAwMDAwMCwKKwkxMDAwMDAwLAorCSAgMTAwMDAsCisJICAxMDAwMCwKKwkxMDAwMDAwLAorCSAgMTAwMDAsCit9OworCitzdGF0aWMgX191NjQJCQlldmVudF9yZXNbTUFYX0NPVU5URVJTXVszXTsKK3N0YXRpYyBfX3U2NAkJCWV2ZW50X3NjYWxlZFtNQVhfQ09VTlRFUlNdOworCitzdGF0aWMgX191NjQJCQlydW50aW1lX25zZWNzOworc3RhdGljIF9fdTY0CQkJd2FsbHRpbWVfbnNlY3M7CitzdGF0aWMgX191NjQJCQlydW50aW1lX2N5Y2xlczsKKworc3RhdGljIHZvaWQgY3JlYXRlX3BlcmZfc3RhdF9jb3VudGVyKGludCBjb3VudGVyKQoreworCXN0cnVjdCBwZXJmX2NvdW50ZXJfYXR0ciAqYXR0ciA9IGF0dHJzICsgY291bnRlcjsKKworCWlmIChzY2FsZSkKKwkJYXR0ci0+cmVhZF9mb3JtYXQgPSBQRVJGX0ZPUk1BVF9UT1RBTF9USU1FX0VOQUJMRUQgfAorCQkJCSAgICBQRVJGX0ZPUk1BVF9UT1RBTF9USU1FX1JVTk5JTkc7CisKKwlpZiAoc3lzdGVtX3dpZGUpIHsKKwkJaW50IGNwdTsKKwkJZm9yIChjcHUgPSAwOyBjcHUgPCBucl9jcHVzOyBjcHUgKyspIHsKKwkJCWZkW2NwdV1bY291bnRlcl0gPSBzeXNfcGVyZl9jb3VudGVyX29wZW4oYXR0ciwgLTEsIGNwdSwgLTEsIDApOworCQkJaWYgKGZkW2NwdV1bY291bnRlcl0gPCAwICYmIHZlcmJvc2UpIHsKKwkJCQlwcmludGYoIkVycm9yOiBjb3VudGVyICVkLCBzeXNfcGVyZl9jb3VudGVyX29wZW4oKSBzeXNjYWxsIHJldHVybmVkIHdpdGggJWQgKCVzKVxuIiwgY291bnRlciwgZmRbY3B1XVtjb3VudGVyXSwgc3RyZXJyb3IoZXJybm8pKTsKKwkJCX0KKwkJfQorCX0gZWxzZSB7CisJCWF0dHItPmluaGVyaXQJPSBpbmhlcml0OworCQlhdHRyLT5kaXNhYmxlZAk9IDE7CisKKwkJZmRbMF1bY291bnRlcl0gPSBzeXNfcGVyZl9jb3VudGVyX29wZW4oYXR0ciwgMCwgLTEsIC0xLCAwKTsKKwkJaWYgKGZkWzBdW2NvdW50ZXJdIDwgMCAmJiB2ZXJib3NlKSB7CisJCQlwcmludGYoIkVycm9yOiBjb3VudGVyICVkLCBzeXNfcGVyZl9jb3VudGVyX29wZW4oKSBzeXNjYWxsIHJldHVybmVkIHdpdGggJWQgKCVzKVxuIiwgY291bnRlciwgZmRbMF1bY291bnRlcl0sIHN0cmVycm9yKGVycm5vKSk7CisJCX0KKwl9Cit9CisKKy8qCisgKiBEb2VzIHRoZSBjb3VudGVyIGhhdmUgbnNlY3MgYXMgYSB1bml0PworICovCitzdGF0aWMgaW5saW5lIGludCBuc2VjX2NvdW50ZXIoaW50IGNvdW50ZXIpCit7CisJaWYgKGF0dHJzW2NvdW50ZXJdLnR5cGUgIT0gUEVSRl9UWVBFX1NPRlRXQVJFKQorCQlyZXR1cm4gMDsKKworCWlmIChhdHRyc1tjb3VudGVyXS5jb25maWcgPT0gUEVSRl9DT1VOVF9TV19DUFVfQ0xPQ0spCisJCXJldHVybiAxOworCisJaWYgKGF0dHJzW2NvdW50ZXJdLmNvbmZpZyA9PSBQRVJGX0NPVU5UX1NXX1RBU0tfQ0xPQ0spCisJCXJldHVybiAxOworCisJcmV0dXJuIDA7Cit9CisKKy8qCisgKiBSZWFkIG91dCB0aGUgcmVzdWx0cyBvZiBhIHNpbmdsZSBjb3VudGVyOgorICovCitzdGF0aWMgdm9pZCByZWFkX2NvdW50ZXIoaW50IGNvdW50ZXIpCit7CisJX191NjQgKmNvdW50LCBzaW5nbGVfY291bnRbM107CisJc3NpemVfdCByZXM7CisJaW50IGNwdSwgbnY7CisJaW50IHNjYWxlZDsKKworCWNvdW50ID0gZXZlbnRfcmVzW2NvdW50ZXJdOworCisJY291bnRbMF0gPSBjb3VudFsxXSA9IGNvdW50WzJdID0gMDsKKworCW52ID0gc2NhbGUgPyAzIDogMTsKKwlmb3IgKGNwdSA9IDA7IGNwdSA8IG5yX2NwdXM7IGNwdSArKykgeworCQlpZiAoZmRbY3B1XVtjb3VudGVyXSA8IDApCisJCQljb250aW51ZTsKKworCQlyZXMgPSByZWFkKGZkW2NwdV1bY291bnRlcl0sIHNpbmdsZV9jb3VudCwgbnYgKiBzaXplb2YoX191NjQpKTsKKwkJYXNzZXJ0KHJlcyA9PSBudiAqIHNpemVvZihfX3U2NCkpOworCisJCWNvdW50WzBdICs9IHNpbmdsZV9jb3VudFswXTsKKwkJaWYgKHNjYWxlKSB7CisJCQljb3VudFsxXSArPSBzaW5nbGVfY291bnRbMV07CisJCQljb3VudFsyXSArPSBzaW5nbGVfY291bnRbMl07CisJCX0KKwl9CisKKwlzY2FsZWQgPSAwOworCWlmIChzY2FsZSkgeworCQlpZiAoY291bnRbMl0gPT0gMCkgeworCQkJZXZlbnRfc2NhbGVkW2NvdW50ZXJdID0gLTE7CisJCQljb3VudFswXSA9IDA7CisJCQlyZXR1cm47CisJCX0KKworCQlpZiAoY291bnRbMl0gPCBjb3VudFsxXSkgeworCQkJZXZlbnRfc2NhbGVkW2NvdW50ZXJdID0gMTsKKwkJCWNvdW50WzBdID0gKHVuc2lnbmVkIGxvbmcgbG9uZykKKwkJCQkoKGRvdWJsZSljb3VudFswXSAqIGNvdW50WzFdIC8gY291bnRbMl0gKyAwLjUpOworCQl9CisJfQorCS8qCisJICogU2F2ZSB0aGUgZnVsbCBydW50aW1lIC0gdG8gYWxsb3cgbm9ybWFsaXphdGlvbiBkdXJpbmcgcHJpbnRvdXQ6CisJICovCisJaWYgKGF0dHJzW2NvdW50ZXJdLnR5cGUgPT0gUEVSRl9UWVBFX1NPRlRXQVJFICYmCisJCWF0dHJzW2NvdW50ZXJdLmNvbmZpZyA9PSBQRVJGX0NPVU5UX1NXX1RBU0tfQ0xPQ0spCisJCXJ1bnRpbWVfbnNlY3MgPSBjb3VudFswXTsKKwlpZiAoYXR0cnNbY291bnRlcl0udHlwZSA9PSBQRVJGX1RZUEVfSEFSRFdBUkUgJiYKKwkJYXR0cnNbY291bnRlcl0uY29uZmlnID09IFBFUkZfQ09VTlRfSFdfQ1BVX0NZQ0xFUykKKwkJcnVudGltZV9jeWNsZXMgPSBjb3VudFswXTsKK30KKworLyoKKyAqIFByaW50IG91dCB0aGUgcmVzdWx0cyBvZiBhIHNpbmdsZSBjb3VudGVyOgorICovCitzdGF0aWMgdm9pZCBwcmludF9jb3VudGVyKGludCBjb3VudGVyKQoreworCV9fdTY0ICpjb3VudDsKKwlpbnQgc2NhbGVkOworCisJY291bnQgPSBldmVudF9yZXNbY291bnRlcl07CisJc2NhbGVkID0gZXZlbnRfc2NhbGVkW2NvdW50ZXJdOworCisJaWYgKHNjYWxlZCA9PSAtMSkgeworCQlmcHJpbnRmKHN0ZGVyciwgIiAlMTRzICAlLTIwc1xuIiwKKwkJCSI8bm90IGNvdW50ZWQ+IiwgZXZlbnRfbmFtZShjb3VudGVyKSk7CisJCXJldHVybjsKKwl9CisKKwlpZiAobnNlY19jb3VudGVyKGNvdW50ZXIpKSB7CisJCWRvdWJsZSBtc2VjcyA9IChkb3VibGUpY291bnRbMF0gLyAxMDAwMDAwOworCisJCWZwcmludGYoc3RkZXJyLCAiICUxNC42ZiAgJS0yMHMiLAorCQkJbXNlY3MsIGV2ZW50X25hbWUoY291bnRlcikpOworCQlpZiAoYXR0cnNbY291bnRlcl0udHlwZSA9PSBQRVJGX1RZUEVfU09GVFdBUkUgJiYKKwkJCWF0dHJzW2NvdW50ZXJdLmNvbmZpZyA9PSBQRVJGX0NPVU5UX1NXX1RBU0tfQ0xPQ0spIHsKKworCQkJaWYgKHdhbGx0aW1lX25zZWNzKQorCQkJCWZwcmludGYoc3RkZXJyLCAiICMgJTExLjNmIENQVSB1dGlsaXphdGlvbiBmYWN0b3IiLAorCQkJCQkoZG91YmxlKWNvdW50WzBdIC8gKGRvdWJsZSl3YWxsdGltZV9uc2Vjcyk7CisJCX0KKwl9IGVsc2UgeworCQlmcHJpbnRmKHN0ZGVyciwgIiAlMTRMZCAgJS0yMHMiLAorCQkJY291bnRbMF0sIGV2ZW50X25hbWUoY291bnRlcikpOworCQlpZiAocnVudGltZV9uc2VjcykKKwkJCWZwcmludGYoc3RkZXJyLCAiICMgJTExLjNmIE0vc2VjIiwKKwkJCQkoZG91YmxlKWNvdW50WzBdL3J1bnRpbWVfbnNlY3MqMTAwMC4wKTsKKwkJaWYgKHJ1bnRpbWVfY3ljbGVzICYmCisJCQlhdHRyc1tjb3VudGVyXS50eXBlID09IFBFUkZfVFlQRV9IQVJEV0FSRSAmJgorCQkJCWF0dHJzW2NvdW50ZXJdLmNvbmZpZyA9PSBQRVJGX0NPVU5UX0hXX0lOU1RSVUNUSU9OUykgeworCisJCQlmcHJpbnRmKHN0ZGVyciwgIiAjICUxLjNmIHBlciBjeWNsZSIsCisJCQkJKGRvdWJsZSljb3VudFswXSAvIChkb3VibGUpcnVudGltZV9jeWNsZXMpOworCQl9CisJfQorCWlmIChzY2FsZWQpCisJCWZwcmludGYoc3RkZXJyLCAiICAoc2NhbGVkIGZyb20gJS4yZiUlKSIsCisJCQkoZG91YmxlKSBjb3VudFsyXSAvIGNvdW50WzFdICogMTAwKTsKKwlmcHJpbnRmKHN0ZGVyciwgIlxuIik7Cit9CisKK3N0YXRpYyBpbnQgZG9fcGVyZl9zdGF0KGludCBhcmdjLCBjb25zdCBjaGFyICoqYXJndikKK3sKKwl1bnNpZ25lZCBsb25nIGxvbmcgdDAsIHQxOworCWludCBjb3VudGVyOworCWludCBzdGF0dXM7CisJaW50IHBpZDsKKwlpbnQgaTsKKworCWlmICghc3lzdGVtX3dpZGUpCisJCW5yX2NwdXMgPSAxOworCisJZm9yIChjb3VudGVyID0gMDsgY291bnRlciA8IG5yX2NvdW50ZXJzOyBjb3VudGVyKyspCisJCWNyZWF0ZV9wZXJmX3N0YXRfY291bnRlcihjb3VudGVyKTsKKworCS8qCisJICogRW5hYmxlIGNvdW50ZXJzIGFuZCBleGVjIHRoZSBjb21tYW5kOgorCSAqLworCXQwID0gcmRjbG9jaygpOworCXByY3RsKFBSX1RBU0tfUEVSRl9DT1VOVEVSU19FTkFCTEUpOworCisJaWYgKChwaWQgPSBmb3JrKCkpIDwgMCkKKwkJcGVycm9yKCJmYWlsZWQgdG8gZm9yayIpOworCisJaWYgKCFwaWQpIHsKKwkJaWYgKGV4ZWN2cChhcmd2WzBdLCAoY2hhciAqKilhcmd2KSkgeworCQkJcGVycm9yKGFyZ3ZbMF0pOworCQkJZXhpdCgtMSk7CisJCX0KKwl9CisKKwl3aGlsZSAod2FpdCgmc3RhdHVzKSA+PSAwKQorCQk7CisKKwlwcmN0bChQUl9UQVNLX1BFUkZfQ09VTlRFUlNfRElTQUJMRSk7CisJdDEgPSByZGNsb2NrKCk7CisKKwl3YWxsdGltZV9uc2VjcyA9IHQxIC0gdDA7CisKKwlmZmx1c2goc3Rkb3V0KTsKKworCWZwcmludGYoc3RkZXJyLCAiXG4iKTsKKwlmcHJpbnRmKHN0ZGVyciwgIiBQZXJmb3JtYW5jZSBjb3VudGVyIHN0YXRzIGZvciBcJyVzIiwgYXJndlswXSk7CisKKwlmb3IgKGkgPSAxOyBpIDwgYXJnYzsgaSsrKQorCQlmcHJpbnRmKHN0ZGVyciwgIiAlcyIsIGFyZ3ZbaV0pOworCisJZnByaW50ZihzdGRlcnIsICJcJzpcbiIpOworCWZwcmludGYoc3RkZXJyLCAiXG4iKTsKKworCWZvciAoY291bnRlciA9IDA7IGNvdW50ZXIgPCBucl9jb3VudGVyczsgY291bnRlcisrKQorCQlyZWFkX2NvdW50ZXIoY291bnRlcik7CisKKwlmb3IgKGNvdW50ZXIgPSAwOyBjb3VudGVyIDwgbnJfY291bnRlcnM7IGNvdW50ZXIrKykKKwkJcHJpbnRfY291bnRlcihjb3VudGVyKTsKKworCisJZnByaW50ZihzdGRlcnIsICJcbiIpOworCWZwcmludGYoc3RkZXJyLCAiIFdhbGwtY2xvY2sgdGltZSBlbGFwc2VkOiAlMTIuNmYgbXNlY3NcbiIsCisJCQkoZG91YmxlKSh0MS10MCkvMWU2KTsKKwlmcHJpbnRmKHN0ZGVyciwgIlxuIik7CisKKwlyZXR1cm4gMDsKK30KKworc3RhdGljIHZvbGF0aWxlIGludCBzaWduciA9IC0xOworCitzdGF0aWMgdm9pZCBza2lwX3NpZ25hbChpbnQgc2lnbm8pCit7CisJc2lnbnIgPSBzaWdubzsKK30KKworc3RhdGljIHZvaWQgc2lnX2F0ZXhpdCh2b2lkKQoreworCWlmIChzaWduciA9PSAtMSkKKwkJcmV0dXJuOworCisJc2lnbmFsKHNpZ25yLCBTSUdfREZMKTsKKwlraWxsKGdldHBpZCgpLCBzaWducik7Cit9CisKK3N0YXRpYyBjb25zdCBjaGFyICogY29uc3Qgc3RhdF91c2FnZVtdID0geworCSJwZXJmIHN0YXQgWzxvcHRpb25zPl0gPGNvbW1hbmQ+IiwKKwlOVUxMCit9OworCitzdGF0aWMgY29uc3Qgc3RydWN0IG9wdGlvbiBvcHRpb25zW10gPSB7CisJT1BUX0NBTExCQUNLKCdlJywgImV2ZW50IiwgTlVMTCwgImV2ZW50IiwKKwkJICAgICAiZXZlbnQgc2VsZWN0b3IuIHVzZSAncGVyZiBsaXN0JyB0byBsaXN0IGF2YWlsYWJsZSBldmVudHMiLAorCQkgICAgIHBhcnNlX2V2ZW50cyksCisJT1BUX0JPT0xFQU4oJ2knLCAiaW5oZXJpdCIsICZpbmhlcml0LAorCQkgICAgImNoaWxkIHRhc2tzIGluaGVyaXQgY291bnRlcnMiKSwKKwlPUFRfSU5URUdFUigncCcsICJwaWQiLCAmdGFyZ2V0X3BpZCwKKwkJICAgICJzdGF0IGV2ZW50cyBvbiBleGlzdGluZyBwaWQiKSwKKwlPUFRfQk9PTEVBTignYScsICJhbGwtY3B1cyIsICZzeXN0ZW1fd2lkZSwKKwkJCSAgICAic3lzdGVtLXdpZGUgY29sbGVjdGlvbiBmcm9tIGFsbCBDUFVzIiksCisJT1BUX0JPT0xFQU4oJ1MnLCAic2NhbGUiLCAmc2NhbGUsCisJCQkgICAgInNjYWxlL25vcm1hbGl6ZSBjb3VudGVycyIpLAorCU9QVF9CT09MRUFOKCd2JywgInZlcmJvc2UiLCAmdmVyYm9zZSwKKwkJICAgICJiZSBtb3JlIHZlcmJvc2UgKHNob3cgY291bnRlciBvcGVuIGVycm9ycywgZXRjKSIpLAorCU9QVF9FTkQoKQorfTsKKworaW50IGNtZF9zdGF0KGludCBhcmdjLCBjb25zdCBjaGFyICoqYXJndiwgY29uc3QgY2hhciAqcHJlZml4KQoreworCXBhZ2Vfc2l6ZSA9IHN5c2NvbmYoX1NDX1BBR0VfU0laRSk7CisKKwltZW1jcHkoYXR0cnMsIGRlZmF1bHRfYXR0cnMsIHNpemVvZihhdHRycykpOworCisJYXJnYyA9IHBhcnNlX29wdGlvbnMoYXJnYywgYXJndiwgb3B0aW9ucywgc3RhdF91c2FnZSwgMCk7CisJaWYgKCFhcmdjKQorCQl1c2FnZV93aXRoX29wdGlvbnMoc3RhdF91c2FnZSwgb3B0aW9ucyk7CisKKwlpZiAoIW5yX2NvdW50ZXJzKQorCQlucl9jb3VudGVycyA9IDg7CisKKwlucl9jcHVzID0gc3lzY29uZihfU0NfTlBST0NFU1NPUlNfT05MTik7CisJYXNzZXJ0KG5yX2NwdXMgPD0gTUFYX05SX0NQVVMpOworCWFzc2VydChucl9jcHVzID49IDApOworCisJLyoKKwkgKiBXZSBkb250IHdhbnQgdG8gYmxvY2sgdGhlIHNpZ25hbHMgLSB0aGF0IHdvdWxkIGNhdXNlCisJICogY2hpbGQgdGFza3MgdG8gaW5oZXJpdCB0aGF0IGFuZCBDdHJsLUMgd291bGQgbm90IHdvcmsuCisJICogV2hhdCB3ZSB3YW50IGlzIGZvciBDdHJsLUMgdG8gd29yayBpbiB0aGUgZXhlYygpLWVkCisJICogdGFzaywgYnV0IGJlaW5nIGlnbm9yZWQgYnkgcGVyZiBzdGF0IGl0c2VsZjoKKwkgKi8KKwlhdGV4aXQoc2lnX2F0ZXhpdCk7CisJc2lnbmFsKFNJR0lOVCwgIHNraXBfc2lnbmFsKTsKKwlzaWduYWwoU0lHQUxSTSwgc2tpcF9zaWduYWwpOworCXNpZ25hbChTSUdBQlJULCBza2lwX3NpZ25hbCk7CisKKwlyZXR1cm4gZG9fcGVyZl9zdGF0KGFyZ2MsIGFyZ3YpOworfQpkaWZmIC0tZ2l0IGEvdG9vbHMvcGVyZi9idWlsdGluLXRvcC5jIGIvdG9vbHMvcGVyZi9idWlsdGluLXRvcC5jCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLmZlMzM4ZDNjCi0tLSAvZGV2L251bGwKKysrIGIvdG9vbHMvcGVyZi9idWlsdGluLXRvcC5jCkBAIC0wLDAgKzEsNzM2IEBACisvKgorICogYnVpbHRpbi10b3AuYworICoKKyAqIEJ1aWx0aW4gdG9wIGNvbW1hbmQ6IERpc3BsYXkgYSBjb250aW51b3VzbHkgdXBkYXRlZCBwcm9maWxlIG9mCisgKiBhbnkgd29ya2xvYWQsIENQVSBvciBzcGVjaWZpYyBQSUQuCisgKgorICogQ29weXJpZ2h0IChDKSAyMDA4LCBSZWQgSGF0IEluYywgSW5nbyBNb2xuYXIgPG1pbmdvQHJlZGhhdC5jb20+CisgKgorICogSW1wcm92ZW1lbnRzIGFuZCBmaXhlcyBieToKKyAqCisgKiAgIEFyamFuIHZhbiBkZSBWZW4gPGFyamFuQGxpbnV4LmludGVsLmNvbT4KKyAqICAgWWFubWluIFpoYW5nIDx5YW5taW4uemhhbmdAaW50ZWwuY29tPgorICogICBXdSBGZW5nZ3VhbmcgPGZlbmdndWFuZy53dUBpbnRlbC5jb20+CisgKiAgIE1pa2UgR2FsYnJhaXRoIDxlZmF1bHRAZ214LmRlPgorICogICBQYXVsIE1hY2tlcnJhcyA8cGF1bHVzQHNhbWJhLm9yZz4KKyAqCisgKiBSZWxlYXNlZCB1bmRlciB0aGUgR1BMIHYyLiAoYW5kIG9ubHkgdjIsIG5vdCBhbnkgbGF0ZXIgdmVyc2lvbikKKyAqLworI2luY2x1ZGUgImJ1aWx0aW4uaCIKKworI2luY2x1ZGUgInBlcmYuaCIKKworI2luY2x1ZGUgInV0aWwvc3ltYm9sLmgiCisjaW5jbHVkZSAidXRpbC9jb2xvci5oIgorI2luY2x1ZGUgInV0aWwvdXRpbC5oIgorI2luY2x1ZGUgInV0aWwvcmJ0cmVlLmgiCisjaW5jbHVkZSAidXRpbC9wYXJzZS1vcHRpb25zLmgiCisjaW5jbHVkZSAidXRpbC9wYXJzZS1ldmVudHMuaCIKKworI2luY2x1ZGUgPGFzc2VydC5oPgorI2luY2x1ZGUgPGZjbnRsLmg+CisKKyNpbmNsdWRlIDxzdGRpby5oPgorCisjaW5jbHVkZSA8ZXJybm8uaD4KKyNpbmNsdWRlIDx0aW1lLmg+CisjaW5jbHVkZSA8c2NoZWQuaD4KKyNpbmNsdWRlIDxwdGhyZWFkLmg+CisKKyNpbmNsdWRlIDxzeXMvc3lzY2FsbC5oPgorI2luY2x1ZGUgPHN5cy9pb2N0bC5oPgorI2luY2x1ZGUgPHN5cy9wb2xsLmg+CisjaW5jbHVkZSA8c3lzL3ByY3RsLmg+CisjaW5jbHVkZSA8c3lzL3dhaXQuaD4KKyNpbmNsdWRlIDxzeXMvdWlvLmg+CisjaW5jbHVkZSA8c3lzL21tYW4uaD4KKworI2luY2x1ZGUgPGxpbnV4L3VuaXN0ZC5oPgorI2luY2x1ZGUgPGxpbnV4L3R5cGVzLmg+CisKK3N0YXRpYyBpbnQJCQlmZFtNQVhfTlJfQ1BVU11bTUFYX0NPVU5URVJTXTsKKworc3RhdGljIGludAkJCXN5c3RlbV93aWRlCQkJPSAgMDsKKworc3RhdGljIGludAkJCWRlZmF1bHRfaW50ZXJ2YWwJCT0gMTAwMDAwOworCitzdGF0aWMgX191NjQJCQljb3VudF9maWx0ZXIJCQk9ICA1Oworc3RhdGljIGludAkJCXByaW50X2VudHJpZXMJCQk9IDE1OworCitzdGF0aWMgaW50CQkJdGFyZ2V0X3BpZAkJCT0gLTE7CitzdGF0aWMgaW50CQkJcHJvZmlsZV9jcHUJCQk9IC0xOworc3RhdGljIGludAkJCW5yX2NwdXMJCQkJPSAgMDsKK3N0YXRpYyB1bnNpZ25lZCBpbnQJCXJlYWx0aW1lX3ByaW8JCQk9ICAwOworc3RhdGljIGludAkJCWdyb3VwCQkJCT0gIDA7CitzdGF0aWMgdW5zaWduZWQgaW50CQlwYWdlX3NpemU7CitzdGF0aWMgdW5zaWduZWQgaW50CQltbWFwX3BhZ2VzCQkJPSAxNjsKK3N0YXRpYyBpbnQJCQlmcmVxCQkJCT0gIDA7CitzdGF0aWMgaW50CQkJdmVyYm9zZQkJCQk9ICAwOworCitzdGF0aWMgY2hhcgkJCSpzeW1fZmlsdGVyOworc3RhdGljIHVuc2lnbmVkIGxvbmcJCWZpbHRlcl9zdGFydDsKK3N0YXRpYyB1bnNpZ25lZCBsb25nCQlmaWx0ZXJfZW5kOworCitzdGF0aWMgaW50CQkJZGVsYXlfc2VjcwkJCT0gIDI7CitzdGF0aWMgaW50CQkJemVybzsKK3N0YXRpYyBpbnQJCQlkdW1wX3N5bXRhYjsKKworLyoKKyAqIFN5bWJvbHMKKyAqLworCitzdGF0aWMgX191NjQJCQltaW5faXA7CitzdGF0aWMgX191NjQJCQltYXhfaXAgPSAtMWxsOworCitzdHJ1Y3Qgc3ltX2VudHJ5IHsKKwlzdHJ1Y3QgcmJfbm9kZQkJcmJfbm9kZTsKKwlzdHJ1Y3QgbGlzdF9oZWFkCW5vZGU7CisJdW5zaWduZWQgbG9uZwkJY291bnRbTUFYX0NPVU5URVJTXTsKKwl1bnNpZ25lZCBsb25nCQlzbmFwX2NvdW50OworCWRvdWJsZQkJCXdlaWdodDsKKwlpbnQJCQlza2lwOworfTsKKworc3RydWN0IHN5bV9lbnRyeQkJKnN5bV9maWx0ZXJfZW50cnk7CisKK3N0cnVjdCBkc28JCQkqa2VybmVsX2RzbzsKKworLyoKKyAqIFN5bWJvbHMgd2lsbCBiZSBhZGRlZCBoZXJlIGluIHJlY29yZF9pcCBhbmQgd2lsbCBnZXQgb3V0CisgKiBhZnRlciBkZWNheWVkLgorICovCitzdGF0aWMgTElTVF9IRUFEKGFjdGl2ZV9zeW1ib2xzKTsKK3N0YXRpYyBwdGhyZWFkX211dGV4X3QgYWN0aXZlX3N5bWJvbHNfbG9jayA9IFBUSFJFQURfTVVURVhfSU5JVElBTElaRVI7CisKKy8qCisgKiBPcmRlcmluZyB3ZWlnaHQ6IGNvdW50LTEgKiBjb3VudC0yICogLi4uIC8gY291bnQtbgorICovCitzdGF0aWMgZG91YmxlIHN5bV93ZWlnaHQoY29uc3Qgc3RydWN0IHN5bV9lbnRyeSAqc3ltKQoreworCWRvdWJsZSB3ZWlnaHQgPSBzeW0tPnNuYXBfY291bnQ7CisJaW50IGNvdW50ZXI7CisKKwlmb3IgKGNvdW50ZXIgPSAxOyBjb3VudGVyIDwgbnJfY291bnRlcnMtMTsgY291bnRlcisrKQorCQl3ZWlnaHQgKj0gc3ltLT5jb3VudFtjb3VudGVyXTsKKworCXdlaWdodCAvPSAoc3ltLT5jb3VudFtjb3VudGVyXSArIDEpOworCisJcmV0dXJuIHdlaWdodDsKK30KKworc3RhdGljIGxvbmcJCQlzYW1wbGVzOworc3RhdGljIGxvbmcJCQl1c2Vyc3BhY2Vfc2FtcGxlczsKK3N0YXRpYyBjb25zdCBjaGFyCQlDT05TT0xFX0NMRUFSW10gPSAiG1tIG1sySiI7CisKK3N0YXRpYyB2b2lkIF9fbGlzdF9pbnNlcnRfYWN0aXZlX3N5bShzdHJ1Y3Qgc3ltX2VudHJ5ICpzeW1lKQoreworCWxpc3RfYWRkKCZzeW1lLT5ub2RlLCAmYWN0aXZlX3N5bWJvbHMpOworfQorCitzdGF0aWMgdm9pZCBsaXN0X3JlbW92ZV9hY3RpdmVfc3ltKHN0cnVjdCBzeW1fZW50cnkgKnN5bWUpCit7CisJcHRocmVhZF9tdXRleF9sb2NrKCZhY3RpdmVfc3ltYm9sc19sb2NrKTsKKwlsaXN0X2RlbF9pbml0KCZzeW1lLT5ub2RlKTsKKwlwdGhyZWFkX211dGV4X3VubG9jaygmYWN0aXZlX3N5bWJvbHNfbG9jayk7Cit9CisKK3N0YXRpYyB2b2lkIHJiX2luc2VydF9hY3RpdmVfc3ltKHN0cnVjdCByYl9yb290ICp0cmVlLCBzdHJ1Y3Qgc3ltX2VudHJ5ICpzZSkKK3sKKwlzdHJ1Y3QgcmJfbm9kZSAqKnAgPSAmdHJlZS0+cmJfbm9kZTsKKwlzdHJ1Y3QgcmJfbm9kZSAqcGFyZW50ID0gTlVMTDsKKwlzdHJ1Y3Qgc3ltX2VudHJ5ICppdGVyOworCisJd2hpbGUgKCpwICE9IE5VTEwpIHsKKwkJcGFyZW50ID0gKnA7CisJCWl0ZXIgPSByYl9lbnRyeShwYXJlbnQsIHN0cnVjdCBzeW1fZW50cnksIHJiX25vZGUpOworCisJCWlmIChzZS0+d2VpZ2h0ID4gaXRlci0+d2VpZ2h0KQorCQkJcCA9ICYoKnApLT5yYl9sZWZ0OworCQllbHNlCisJCQlwID0gJigqcCktPnJiX3JpZ2h0OworCX0KKworCXJiX2xpbmtfbm9kZSgmc2UtPnJiX25vZGUsIHBhcmVudCwgcCk7CisJcmJfaW5zZXJ0X2NvbG9yKCZzZS0+cmJfbm9kZSwgdHJlZSk7Cit9CisKK3N0YXRpYyB2b2lkIHByaW50X3N5bV90YWJsZSh2b2lkKQoreworCWludCBwcmludGVkID0gMCwgajsKKwlpbnQgY291bnRlcjsKKwlmbG9hdCBzYW1wbGVzX3Blcl9zZWMgPSBzYW1wbGVzL2RlbGF5X3NlY3M7CisJZmxvYXQga3NhbXBsZXNfcGVyX3NlYyA9IChzYW1wbGVzLXVzZXJzcGFjZV9zYW1wbGVzKS9kZWxheV9zZWNzOworCWZsb2F0IHN1bV9rc2FtcGxlcyA9IDAuMDsKKwlzdHJ1Y3Qgc3ltX2VudHJ5ICpzeW1lLCAqbjsKKwlzdHJ1Y3QgcmJfcm9vdCB0bXAgPSBSQl9ST09UOworCXN0cnVjdCByYl9ub2RlICpuZDsKKworCXNhbXBsZXMgPSB1c2Vyc3BhY2Vfc2FtcGxlcyA9IDA7CisKKwkvKiBTb3J0IHRoZSBhY3RpdmUgc3ltYm9scyAqLworCXB0aHJlYWRfbXV0ZXhfbG9jaygmYWN0aXZlX3N5bWJvbHNfbG9jayk7CisJc3ltZSA9IGxpc3RfZW50cnkoYWN0aXZlX3N5bWJvbHMubmV4dCwgc3RydWN0IHN5bV9lbnRyeSwgbm9kZSk7CisJcHRocmVhZF9tdXRleF91bmxvY2soJmFjdGl2ZV9zeW1ib2xzX2xvY2spOworCisJbGlzdF9mb3JfZWFjaF9lbnRyeV9zYWZlX2Zyb20oc3ltZSwgbiwgJmFjdGl2ZV9zeW1ib2xzLCBub2RlKSB7CisJCXN5bWUtPnNuYXBfY291bnQgPSBzeW1lLT5jb3VudFswXTsKKwkJaWYgKHN5bWUtPnNuYXBfY291bnQgIT0gMCkgeworCQkJc3ltZS0+d2VpZ2h0ID0gc3ltX3dlaWdodChzeW1lKTsKKwkJCXJiX2luc2VydF9hY3RpdmVfc3ltKCZ0bXAsIHN5bWUpOworCQkJc3VtX2tzYW1wbGVzICs9IHN5bWUtPnNuYXBfY291bnQ7CisKKwkJCWZvciAoaiA9IDA7IGogPCBucl9jb3VudGVyczsgaisrKQorCQkJCXN5bWUtPmNvdW50W2pdID0gemVybyA/IDAgOiBzeW1lLT5jb3VudFtqXSAqIDcgLyA4OworCQl9IGVsc2UKKwkJCWxpc3RfcmVtb3ZlX2FjdGl2ZV9zeW0oc3ltZSk7CisJfQorCisJcHV0cyhDT05TT0xFX0NMRUFSKTsKKworCXByaW50ZigKKyItLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS1cbiIpOworCXByaW50ZiggIiAgIFBlcmZUb3A6JTguMGYgaXJxcy9zZWMgIGtlcm5lbDolNC4xZiUlIFsiLAorCQlzYW1wbGVzX3Blcl9zZWMsCisJCTEwMC4wIC0gKDEwMC4wKigoc2FtcGxlc19wZXJfc2VjLWtzYW1wbGVzX3Blcl9zZWMpL3NhbXBsZXNfcGVyX3NlYykpKTsKKworCWlmIChucl9jb3VudGVycyA9PSAxKSB7CisJCXByaW50ZigiJUxkIiwgYXR0cnNbMF0uc2FtcGxlX3BlcmlvZCk7CisJCWlmIChmcmVxKQorCQkJcHJpbnRmKCJIeiAiKTsKKwkJZWxzZQorCQkJcHJpbnRmKCIgIik7CisJfQorCisJZm9yIChjb3VudGVyID0gMDsgY291bnRlciA8IG5yX2NvdW50ZXJzOyBjb3VudGVyKyspIHsKKwkJaWYgKGNvdW50ZXIpCisJCQlwcmludGYoIi8iKTsKKworCQlwcmludGYoIiVzIiwgZXZlbnRfbmFtZShjb3VudGVyKSk7CisJfQorCisJcHJpbnRmKCAiXSwgIik7CisKKwlpZiAodGFyZ2V0X3BpZCAhPSAtMSkKKwkJcHJpbnRmKCIgKHRhcmdldF9waWQ6ICVkIiwgdGFyZ2V0X3BpZCk7CisJZWxzZQorCQlwcmludGYoIiAoYWxsIik7CisKKwlpZiAocHJvZmlsZV9jcHUgIT0gLTEpCisJCXByaW50ZigiLCBjcHU6ICVkKVxuIiwgcHJvZmlsZV9jcHUpOworCWVsc2UgeworCQlpZiAodGFyZ2V0X3BpZCAhPSAtMSkKKwkJCXByaW50ZigiKVxuIik7CisJCWVsc2UKKwkJCXByaW50ZigiLCAlZCBDUFVzKVxuIiwgbnJfY3B1cyk7CisJfQorCisJcHJpbnRmKCItLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS1cblxuIik7CisKKwlpZiAobnJfY291bnRlcnMgPT0gMSkKKwkJcHJpbnRmKCIgICAgICAgICAgICAgc2FtcGxlcyAgICBwY250Iik7CisJZWxzZQorCQlwcmludGYoIiAgd2VpZ2h0ICAgICBzYW1wbGVzICAgIHBjbnQiKTsKKworCXByaW50ZigiICAgICAgICAgUklQICAgICAgICAgIGtlcm5lbCBmdW5jdGlvblxuIgorCSAgICAgICAJICAgICAgICIgIF9fX19fXyAgICAgX19fX19fXyAgIF9fX19fICAgX19fX19fX19fX19fX19fXyAgIF9fX19fX19fX19fX19fX1xuXG4iCisJKTsKKworCWZvciAobmQgPSByYl9maXJzdCgmdG1wKTsgbmQ7IG5kID0gcmJfbmV4dChuZCkpIHsKKwkJc3RydWN0IHN5bV9lbnRyeSAqc3ltZSA9IHJiX2VudHJ5KG5kLCBzdHJ1Y3Qgc3ltX2VudHJ5LCByYl9ub2RlKTsKKwkJc3RydWN0IHN5bWJvbCAqc3ltID0gKHN0cnVjdCBzeW1ib2wgKikoc3ltZSArIDEpOworCQljaGFyICpjb2xvciA9IFBFUkZfQ09MT1JfTk9STUFMOworCQlkb3VibGUgcGNudDsKKworCQlpZiAoKytwcmludGVkID4gcHJpbnRfZW50cmllcyB8fCBzeW1lLT5zbmFwX2NvdW50IDwgY291bnRfZmlsdGVyKQorCQkJY29udGludWU7CisKKwkJcGNudCA9IDEwMC4wIC0gKDEwMC4wICogKChzdW1fa3NhbXBsZXMgLSBzeW1lLT5zbmFwX2NvdW50KSAvCisJCQkJCSBzdW1fa3NhbXBsZXMpKTsKKworCQkvKgorCQkgKiBXZSBjb2xvciBoaWdoLW92ZXJoZWFkIGVudHJpZXMgaW4gcmVkLCBtaWQtb3ZlcmhlYWQKKwkJICogZW50cmllcyBpbiBncmVlbiAtIGFuZCBrZWVwIHRoZSBsb3cgb3ZlcmhlYWQgcGxhY2VzCisJCSAqIG5vcm1hbDoKKwkJICovCisJCWlmIChwY250ID49IDUuMCkgeworCQkJY29sb3IgPSBQRVJGX0NPTE9SX1JFRDsKKwkJfSBlbHNlIHsKKwkJCWlmIChwY250ID49IDAuNSkKKwkJCQljb2xvciA9IFBFUkZfQ09MT1JfR1JFRU47CisJCX0KKworCQlpZiAobnJfY291bnRlcnMgPT0gMSkKKwkJCXByaW50ZigiJTIwLjJmIC0gIiwgc3ltZS0+d2VpZ2h0KTsKKwkJZWxzZQorCQkJcHJpbnRmKCIlOS4xZiAlMTBsZCAtICIsIHN5bWUtPndlaWdodCwgc3ltZS0+c25hcF9jb3VudCk7CisKKwkJY29sb3JfZnByaW50ZihzdGRvdXQsIGNvbG9yLCAiJTQuMWYlJSIsIHBjbnQpOworCQlwcmludGYoIiAtICUwMTZsbHggOiAlc1xuIiwgc3ltLT5zdGFydCwgc3ltLT5uYW1lKTsKKwl9Cit9CisKK3N0YXRpYyB2b2lkICpkaXNwbGF5X3RocmVhZCh2b2lkICphcmcpCit7CisJc3RydWN0IHBvbGxmZCBzdGRpbl9wb2xsID0geyAuZmQgPSAwLCAuZXZlbnRzID0gUE9MTElOIH07CisJaW50IGRlbGF5X21zZWNzID0gZGVsYXlfc2VjcyAqIDEwMDA7CisKKwlwcmludGYoIlBlcmZUb3AgcmVmcmVzaCBwZXJpb2Q6ICVkIHNlY29uZHNcbiIsIGRlbGF5X3NlY3MpOworCisJZG8geworCQlwcmludF9zeW1fdGFibGUoKTsKKwl9IHdoaWxlICghcG9sbCgmc3RkaW5fcG9sbCwgMSwgZGVsYXlfbXNlY3MpID09IDEpOworCisJcHJpbnRmKCJrZXkgcHJlc3NlZCAtIGV4aXRpbmcuXG4iKTsKKwlleGl0KDApOworCisJcmV0dXJuIE5VTEw7Cit9CisKK3N0YXRpYyBpbnQgc3ltYm9sX2ZpbHRlcihzdHJ1Y3QgZHNvICpzZWxmLCBzdHJ1Y3Qgc3ltYm9sICpzeW0pCit7CisJc3RhdGljIGludCBmaWx0ZXJfbWF0Y2g7CisJc3RydWN0IHN5bV9lbnRyeSAqc3ltZTsKKwljb25zdCBjaGFyICpuYW1lID0gc3ltLT5uYW1lOworCisJaWYgKCFzdHJjbXAobmFtZSwgIl90ZXh0IikgfHwKKwkgICAgIXN0cmNtcChuYW1lLCAiX2V0ZXh0IikgfHwKKwkgICAgIXN0cmNtcChuYW1lLCAiX3Npbml0dGV4dCIpIHx8CisJICAgICFzdHJuY21wKCJpbml0X21vZHVsZSIsIG5hbWUsIDExKSB8fAorCSAgICAhc3RybmNtcCgiY2xlYW51cF9tb2R1bGUiLCBuYW1lLCAxNCkgfHwKKwkgICAgc3Ryc3RyKG5hbWUsICJfdGV4dF9zdGFydCIpIHx8CisJICAgIHN0cnN0cihuYW1lLCAiX3RleHRfZW5kIikpCisJCXJldHVybiAxOworCisJc3ltZSA9IGRzb19fc3ltX3ByaXYoc2VsZiwgc3ltKTsKKwkvKiBUYWcgc2FtcGxlcyB0byBiZSBza2lwcGVkLiAqLworCWlmICghc3RyY21wKCJkZWZhdWx0X2lkbGUiLCBuYW1lKSB8fAorCSAgICAhc3RyY21wKCJjcHVfaWRsZSIsIG5hbWUpIHx8CisJICAgICFzdHJjbXAoImVudGVyX2lkbGUiLCBuYW1lKSB8fAorCSAgICAhc3RyY21wKCJleGl0X2lkbGUiLCBuYW1lKSB8fAorCSAgICAhc3RyY21wKCJtd2FpdF9pZGxlIiwgbmFtZSkpCisJCXN5bWUtPnNraXAgPSAxOworCisJaWYgKGZpbHRlcl9tYXRjaCA9PSAxKSB7CisJCWZpbHRlcl9lbmQgPSBzeW0tPnN0YXJ0OworCQlmaWx0ZXJfbWF0Y2ggPSAtMTsKKwkJaWYgKGZpbHRlcl9lbmQgLSBmaWx0ZXJfc3RhcnQgPiAxMDAwMCkgeworCQkJZnByaW50ZihzdGRlcnIsCisJCQkJImhtLCB0b28gbGFyZ2UgZmlsdGVyIHN5bWJvbCA8JXM+IC0gc2tpcHBpbmcuXG4iLAorCQkJCXN5bV9maWx0ZXIpOworCQkJZnByaW50ZihzdGRlcnIsICJzeW1ib2wgZmlsdGVyIHN0YXJ0OiAlMDE2bHhcbiIsCisJCQkJZmlsdGVyX3N0YXJ0KTsKKwkJCWZwcmludGYoc3RkZXJyLCAiICAgICAgICAgICAgICAgIGVuZDogJTAxNmx4XG4iLAorCQkJCWZpbHRlcl9lbmQpOworCQkJZmlsdGVyX2VuZCA9IGZpbHRlcl9zdGFydCA9IDA7CisJCQlzeW1fZmlsdGVyID0gTlVMTDsKKwkJCXNsZWVwKDEpOworCQl9CisJfQorCisJaWYgKGZpbHRlcl9tYXRjaCA9PSAwICYmIHN5bV9maWx0ZXIgJiYgIXN0cmNtcChuYW1lLCBzeW1fZmlsdGVyKSkgeworCQlmaWx0ZXJfbWF0Y2ggPSAxOworCQlmaWx0ZXJfc3RhcnQgPSBzeW0tPnN0YXJ0OworCX0KKworCisJcmV0dXJuIDA7Cit9CisKK3N0YXRpYyBpbnQgcGFyc2Vfc3ltYm9scyh2b2lkKQoreworCXN0cnVjdCByYl9ub2RlICpub2RlOworCXN0cnVjdCBzeW1ib2wgICpzeW07CisKKwlrZXJuZWxfZHNvID0gZHNvX19uZXcoIltrZXJuZWxdIiwgc2l6ZW9mKHN0cnVjdCBzeW1fZW50cnkpKTsKKwlpZiAoa2VybmVsX2RzbyA9PSBOVUxMKQorCQlyZXR1cm4gLTE7CisKKwlpZiAoZHNvX19sb2FkX2tlcm5lbChrZXJuZWxfZHNvLCBOVUxMLCBzeW1ib2xfZmlsdGVyLCAxKSAhPSAwKQorCQlnb3RvIG91dF9kZWxldGVfZHNvOworCisJbm9kZSA9IHJiX2ZpcnN0KCZrZXJuZWxfZHNvLT5zeW1zKTsKKwlzeW0gPSByYl9lbnRyeShub2RlLCBzdHJ1Y3Qgc3ltYm9sLCByYl9ub2RlKTsKKwltaW5faXAgPSBzeW0tPnN0YXJ0OworCisJbm9kZSA9IHJiX2xhc3QoJmtlcm5lbF9kc28tPnN5bXMpOworCXN5bSA9IHJiX2VudHJ5KG5vZGUsIHN0cnVjdCBzeW1ib2wsIHJiX25vZGUpOworCW1heF9pcCA9IHN5bS0+ZW5kOworCisJaWYgKGR1bXBfc3ltdGFiKQorCQlkc29fX2ZwcmludGYoa2VybmVsX2Rzbywgc3RkZXJyKTsKKworCXJldHVybiAwOworCitvdXRfZGVsZXRlX2RzbzoKKwlkc29fX2RlbGV0ZShrZXJuZWxfZHNvKTsKKwlrZXJuZWxfZHNvID0gTlVMTDsKKwlyZXR1cm4gLTE7Cit9CisKKyNkZWZpbmUgVFJBQ0VfQ09VTlQgICAgIDMKKworLyoKKyAqIEJpbmFyeSBzZWFyY2ggaW4gdGhlIGhpc3RvZ3JhbSB0YWJsZSBhbmQgcmVjb3JkIHRoZSBoaXQ6CisgKi8KK3N0YXRpYyB2b2lkIHJlY29yZF9pcChfX3U2NCBpcCwgaW50IGNvdW50ZXIpCit7CisJc3RydWN0IHN5bWJvbCAqc3ltID0gZHNvX19maW5kX3N5bWJvbChrZXJuZWxfZHNvLCBpcCk7CisKKwlpZiAoc3ltICE9IE5VTEwpIHsKKwkJc3RydWN0IHN5bV9lbnRyeSAqc3ltZSA9IGRzb19fc3ltX3ByaXYoa2VybmVsX2Rzbywgc3ltKTsKKworCQlpZiAoIXN5bWUtPnNraXApIHsKKwkJCXN5bWUtPmNvdW50W2NvdW50ZXJdKys7CisJCQlwdGhyZWFkX211dGV4X2xvY2soJmFjdGl2ZV9zeW1ib2xzX2xvY2spOworCQkJaWYgKGxpc3RfZW1wdHkoJnN5bWUtPm5vZGUpIHx8ICFzeW1lLT5ub2RlLm5leHQpCisJCQkJX19saXN0X2luc2VydF9hY3RpdmVfc3ltKHN5bWUpOworCQkJcHRocmVhZF9tdXRleF91bmxvY2soJmFjdGl2ZV9zeW1ib2xzX2xvY2spOworCQkJcmV0dXJuOworCQl9CisJfQorCisJc2FtcGxlcy0tOworfQorCitzdGF0aWMgdm9pZCBwcm9jZXNzX2V2ZW50KF9fdTY0IGlwLCBpbnQgY291bnRlcikKK3sKKwlzYW1wbGVzKys7CisKKwlpZiAoaXAgPCBtaW5faXAgfHwgaXAgPiBtYXhfaXApIHsKKwkJdXNlcnNwYWNlX3NhbXBsZXMrKzsKKwkJcmV0dXJuOworCX0KKworCXJlY29yZF9pcChpcCwgY291bnRlcik7Cit9CisKK3N0cnVjdCBtbWFwX2RhdGEgeworCWludAkJCWNvdW50ZXI7CisJdm9pZAkJCSpiYXNlOworCXVuc2lnbmVkIGludAkJbWFzazsKKwl1bnNpZ25lZCBpbnQJCXByZXY7Cit9OworCitzdGF0aWMgdW5zaWduZWQgaW50IG1tYXBfcmVhZF9oZWFkKHN0cnVjdCBtbWFwX2RhdGEgKm1kKQoreworCXN0cnVjdCBwZXJmX2NvdW50ZXJfbW1hcF9wYWdlICpwYyA9IG1kLT5iYXNlOworCWludCBoZWFkOworCisJaGVhZCA9IHBjLT5kYXRhX2hlYWQ7CisJcm1iKCk7CisKKwlyZXR1cm4gaGVhZDsKK30KKworc3RydWN0IHRpbWV2YWwgbGFzdF9yZWFkLCB0aGlzX3JlYWQ7CisKK3N0YXRpYyB2b2lkIG1tYXBfcmVhZF9jb3VudGVyKHN0cnVjdCBtbWFwX2RhdGEgKm1kKQoreworCXVuc2lnbmVkIGludCBoZWFkID0gbW1hcF9yZWFkX2hlYWQobWQpOworCXVuc2lnbmVkIGludCBvbGQgPSBtZC0+cHJldjsKKwl1bnNpZ25lZCBjaGFyICpkYXRhID0gbWQtPmJhc2UgKyBwYWdlX3NpemU7CisJaW50IGRpZmY7CisKKwlnZXR0aW1lb2ZkYXkoJnRoaXNfcmVhZCwgTlVMTCk7CisKKwkvKgorCSAqIElmIHdlJ3JlIGZ1cnRoZXIgYmVoaW5kIHRoYW4gaGFsZiB0aGUgYnVmZmVyLCB0aGVyZSdzIGEgY2hhbmNlCisJICogdGhlIHdyaXRlciB3aWxsIGJpdGUgb3VyIHRhaWwgYW5kIG1lc3MgdXAgdGhlIHNhbXBsZXMgdW5kZXIgdXMuCisJICoKKwkgKiBJZiB3ZSBzb21laG93IGVuZGVkIHVwIGFoZWFkIG9mIHRoZSBoZWFkLCB3ZSBnb3QgbWVzc2VkIHVwLgorCSAqCisJICogSW4gZWl0aGVyIGNhc2UsIHRydW5jYXRlIGFuZCByZXN0YXJ0IGF0IGhlYWQuCisJICovCisJZGlmZiA9IGhlYWQgLSBvbGQ7CisJaWYgKGRpZmYgPiBtZC0+bWFzayAvIDIgfHwgZGlmZiA8IDApIHsKKwkJc3RydWN0IHRpbWV2YWwgaXY7CisJCXVuc2lnbmVkIGxvbmcgbXNlY3M7CisKKwkJdGltZXJzdWIoJnRoaXNfcmVhZCwgJmxhc3RfcmVhZCwgJml2KTsKKwkJbXNlY3MgPSBpdi50dl9zZWMqMTAwMCArIGl2LnR2X3VzZWMvMTAwMDsKKworCQlmcHJpbnRmKHN0ZGVyciwgIldBUk5JTkc6IGZhaWxlZCB0byBrZWVwIHVwIHdpdGggbW1hcCBkYXRhLiIKKwkJCQkiICBMYXN0IHJlYWQgJWx1IG1zZWNzIGFnby5cbiIsIG1zZWNzKTsKKworCQkvKgorCQkgKiBoZWFkIHBvaW50cyB0byBhIGtub3duIGdvb2QgZW50cnksIHN0YXJ0IHRoZXJlLgorCQkgKi8KKwkJb2xkID0gaGVhZDsKKwl9CisKKwlsYXN0X3JlYWQgPSB0aGlzX3JlYWQ7CisKKwlmb3IgKDsgb2xkICE9IGhlYWQ7KSB7CisJCXN0cnVjdCBpcF9ldmVudCB7CisJCQlzdHJ1Y3QgcGVyZl9ldmVudF9oZWFkZXIgaGVhZGVyOworCQkJX191NjQgaXA7CisJCQlfX3UzMiBwaWQsIHRhcmdldF9waWQ7CisJCX07CisJCXN0cnVjdCBtbWFwX2V2ZW50IHsKKwkJCXN0cnVjdCBwZXJmX2V2ZW50X2hlYWRlciBoZWFkZXI7CisJCQlfX3UzMiBwaWQsIHRhcmdldF9waWQ7CisJCQlfX3U2NCBzdGFydDsKKwkJCV9fdTY0IGxlbjsKKwkJCV9fdTY0IHBnb2ZmOworCQkJY2hhciBmaWxlbmFtZVtQQVRIX01BWF07CisJCX07CisKKwkJdHlwZWRlZiB1bmlvbiBldmVudF91bmlvbiB7CisJCQlzdHJ1Y3QgcGVyZl9ldmVudF9oZWFkZXIgaGVhZGVyOworCQkJc3RydWN0IGlwX2V2ZW50IGlwOworCQkJc3RydWN0IG1tYXBfZXZlbnQgbW1hcDsKKwkJfSBldmVudF90OworCisJCWV2ZW50X3QgKmV2ZW50ID0gKGV2ZW50X3QgKikmZGF0YVtvbGQgJiBtZC0+bWFza107CisKKwkJZXZlbnRfdCBldmVudF9jb3B5OworCisJCXNpemVfdCBzaXplID0gZXZlbnQtPmhlYWRlci5zaXplOworCisJCS8qCisJCSAqIEV2ZW50IHN0cmFkZGxlcyB0aGUgbW1hcCBib3VuZGFyeSAtLSBoZWFkZXIgc2hvdWxkIGFsd2F5cworCQkgKiBiZSBpbnNpZGUgZHVlIHRvIHU2NCBhbGlnbm1lbnQgb2Ygb3V0cHV0LgorCQkgKi8KKwkJaWYgKChvbGQgJiBtZC0+bWFzaykgKyBzaXplICE9ICgob2xkICsgc2l6ZSkgJiBtZC0+bWFzaykpIHsKKwkJCXVuc2lnbmVkIGludCBvZmZzZXQgPSBvbGQ7CisJCQl1bnNpZ25lZCBpbnQgbGVuID0gbWluKHNpemVvZigqZXZlbnQpLCBzaXplKSwgY3B5OworCQkJdm9pZCAqZHN0ID0gJmV2ZW50X2NvcHk7CisKKwkJCWRvIHsKKwkJCQljcHkgPSBtaW4obWQtPm1hc2sgKyAxIC0gKG9mZnNldCAmIG1kLT5tYXNrKSwgbGVuKTsKKwkJCQltZW1jcHkoZHN0LCAmZGF0YVtvZmZzZXQgJiBtZC0+bWFza10sIGNweSk7CisJCQkJb2Zmc2V0ICs9IGNweTsKKwkJCQlkc3QgKz0gY3B5OworCQkJCWxlbiAtPSBjcHk7CisJCQl9IHdoaWxlIChsZW4pOworCisJCQlldmVudCA9ICZldmVudF9jb3B5OworCQl9CisKKwkJb2xkICs9IHNpemU7CisKKwkJaWYgKGV2ZW50LT5oZWFkZXIubWlzYyAmIFBFUkZfRVZFTlRfTUlTQ19PVkVSRkxPVykgeworCQkJaWYgKGV2ZW50LT5oZWFkZXIudHlwZSAmIFBFUkZfU0FNUExFX0lQKQorCQkJCXByb2Nlc3NfZXZlbnQoZXZlbnQtPmlwLmlwLCBtZC0+Y291bnRlcik7CisJCX0KKwl9CisKKwltZC0+cHJldiA9IG9sZDsKK30KKworc3RhdGljIHN0cnVjdCBwb2xsZmQgZXZlbnRfYXJyYXlbTUFYX05SX0NQVVMgKiBNQVhfQ09VTlRFUlNdOworc3RhdGljIHN0cnVjdCBtbWFwX2RhdGEgbW1hcF9hcnJheVtNQVhfTlJfQ1BVU11bTUFYX0NPVU5URVJTXTsKKworc3RhdGljIHZvaWQgbW1hcF9yZWFkKHZvaWQpCit7CisJaW50IGksIGNvdW50ZXI7CisKKwlmb3IgKGkgPSAwOyBpIDwgbnJfY3B1czsgaSsrKSB7CisJCWZvciAoY291bnRlciA9IDA7IGNvdW50ZXIgPCBucl9jb3VudGVyczsgY291bnRlcisrKQorCQkJbW1hcF9yZWFkX2NvdW50ZXIoJm1tYXBfYXJyYXlbaV1bY291bnRlcl0pOworCX0KK30KKworaW50IG5yX3BvbGw7CitpbnQgZ3JvdXBfZmQ7CisKK3N0YXRpYyB2b2lkIHN0YXJ0X2NvdW50ZXIoaW50IGksIGludCBjb3VudGVyKQoreworCXN0cnVjdCBwZXJmX2NvdW50ZXJfYXR0ciAqYXR0cjsKKwl1bnNpZ25lZCBpbnQgY3B1OworCisJY3B1ID0gcHJvZmlsZV9jcHU7CisJaWYgKHRhcmdldF9waWQgPT0gLTEgJiYgcHJvZmlsZV9jcHUgPT0gLTEpCisJCWNwdSA9IGk7CisKKwlhdHRyID0gYXR0cnMgKyBjb3VudGVyOworCisJYXR0ci0+c2FtcGxlX3R5cGUJPSBQRVJGX1NBTVBMRV9JUCB8IFBFUkZfU0FNUExFX1RJRDsKKwlhdHRyLT5mcmVxCQk9IGZyZXE7CisKK3RyeV9hZ2FpbjoKKwlmZFtpXVtjb3VudGVyXSA9IHN5c19wZXJmX2NvdW50ZXJfb3BlbihhdHRyLCB0YXJnZXRfcGlkLCBjcHUsIGdyb3VwX2ZkLCAwKTsKKworCWlmIChmZFtpXVtjb3VudGVyXSA8IDApIHsKKwkJaW50IGVyciA9IGVycm5vOworCisJCWlmIChlcnIgPT0gRVBFUk0pCisJCQlkaWUoIk5vIHBlcm1pc3Npb24gLSBhcmUgeW91IHJvb3Q/XG4iKTsKKwkJLyoKKwkJICogSWYgaXQncyBjeWNsZXMgdGhlbiBmYWxsIGJhY2sgdG8gaHJ0aW1lcgorCQkgKiBiYXNlZCBjcHUtY2xvY2stdGljayBzdyBjb3VudGVyLCB3aGljaAorCQkgKiBpcyBhbHdheXMgYXZhaWxhYmxlIGV2ZW4gaWYgbm8gUE1VIHN1cHBvcnQ6CisJCSAqLworCQlpZiAoYXR0ci0+dHlwZSA9PSBQRVJGX1RZUEVfSEFSRFdBUkUKKwkJCSYmIGF0dHItPmNvbmZpZyA9PSBQRVJGX0NPVU5UX0hXX0NQVV9DWUNMRVMpIHsKKworCQkJaWYgKHZlcmJvc2UpCisJCQkJd2FybmluZygiIC4uLiB0cnlpbmcgdG8gZmFsbCBiYWNrIHRvIGNwdS1jbG9jay10aWNrc1xuIik7CisKKwkJCWF0dHItPnR5cGUgPSBQRVJGX1RZUEVfU09GVFdBUkU7CisJCQlhdHRyLT5jb25maWcgPSBQRVJGX0NPVU5UX1NXX0NQVV9DTE9DSzsKKwkJCWdvdG8gdHJ5X2FnYWluOworCQl9CisJCXByaW50ZigiXG4iKTsKKwkJZXJyb3IoInBlcmZjb3VudGVyIHN5c2NhbGwgcmV0dXJuZWQgd2l0aCAlZCAoJXMpXG4iLAorCQkJZmRbaV1bY291bnRlcl0sIHN0cmVycm9yKGVycikpOworCQlkaWUoIk5vIENPTkZJR19QRVJGX0NPVU5URVJTPXkga2VybmVsIHN1cHBvcnQgY29uZmlndXJlZD9cbiIpOworCQlleGl0KC0xKTsKKwl9CisJYXNzZXJ0KGZkW2ldW2NvdW50ZXJdID49IDApOworCWZjbnRsKGZkW2ldW2NvdW50ZXJdLCBGX1NFVEZMLCBPX05PTkJMT0NLKTsKKworCS8qCisJICogRmlyc3QgY291bnRlciBhY3RzIGFzIHRoZSBncm91cCBsZWFkZXI6CisJICovCisJaWYgKGdyb3VwICYmIGdyb3VwX2ZkID09IC0xKQorCQlncm91cF9mZCA9IGZkW2ldW2NvdW50ZXJdOworCisJZXZlbnRfYXJyYXlbbnJfcG9sbF0uZmQgPSBmZFtpXVtjb3VudGVyXTsKKwlldmVudF9hcnJheVtucl9wb2xsXS5ldmVudHMgPSBQT0xMSU47CisJbnJfcG9sbCsrOworCisJbW1hcF9hcnJheVtpXVtjb3VudGVyXS5jb3VudGVyID0gY291bnRlcjsKKwltbWFwX2FycmF5W2ldW2NvdW50ZXJdLnByZXYgPSAwOworCW1tYXBfYXJyYXlbaV1bY291bnRlcl0ubWFzayA9IG1tYXBfcGFnZXMqcGFnZV9zaXplIC0gMTsKKwltbWFwX2FycmF5W2ldW2NvdW50ZXJdLmJhc2UgPSBtbWFwKE5VTEwsIChtbWFwX3BhZ2VzKzEpKnBhZ2Vfc2l6ZSwKKwkJCVBST1RfUkVBRCwgTUFQX1NIQVJFRCwgZmRbaV1bY291bnRlcl0sIDApOworCWlmIChtbWFwX2FycmF5W2ldW2NvdW50ZXJdLmJhc2UgPT0gTUFQX0ZBSUxFRCkKKwkJZGllKCJmYWlsZWQgdG8gbW1hcCB3aXRoICVkICglcylcbiIsIGVycm5vLCBzdHJlcnJvcihlcnJubykpOworfQorCitzdGF0aWMgaW50IF9fY21kX3RvcCh2b2lkKQoreworCXB0aHJlYWRfdCB0aHJlYWQ7CisJaW50IGksIGNvdW50ZXI7CisJaW50IHJldDsKKworCWZvciAoaSA9IDA7IGkgPCBucl9jcHVzOyBpKyspIHsKKwkJZ3JvdXBfZmQgPSAtMTsKKwkJZm9yIChjb3VudGVyID0gMDsgY291bnRlciA8IG5yX2NvdW50ZXJzOyBjb3VudGVyKyspCisJCQlzdGFydF9jb3VudGVyKGksIGNvdW50ZXIpOworCX0KKworCS8qIFdhaXQgZm9yIGEgbWluaW1hbCBzZXQgb2YgZXZlbnRzIGJlZm9yZSBzdGFydGluZyB0aGUgc25hcHNob3QgKi8KKwlwb2xsKGV2ZW50X2FycmF5LCBucl9wb2xsLCAxMDApOworCisJbW1hcF9yZWFkKCk7CisKKwlpZiAocHRocmVhZF9jcmVhdGUoJnRocmVhZCwgTlVMTCwgZGlzcGxheV90aHJlYWQsIE5VTEwpKSB7CisJCXByaW50ZigiQ291bGQgbm90IGNyZWF0ZSBkaXNwbGF5IHRocmVhZC5cbiIpOworCQlleGl0KC0xKTsKKwl9CisKKwlpZiAocmVhbHRpbWVfcHJpbykgeworCQlzdHJ1Y3Qgc2NoZWRfcGFyYW0gcGFyYW07CisKKwkJcGFyYW0uc2NoZWRfcHJpb3JpdHkgPSByZWFsdGltZV9wcmlvOworCQlpZiAoc2NoZWRfc2V0c2NoZWR1bGVyKDAsIFNDSEVEX0ZJRk8sICZwYXJhbSkpIHsKKwkJCXByaW50ZigiQ291bGQgbm90IHNldCByZWFsdGltZSBwcmlvcml0eS5cbiIpOworCQkJZXhpdCgtMSk7CisJCX0KKwl9CisKKwl3aGlsZSAoMSkgeworCQlpbnQgaGl0cyA9IHNhbXBsZXM7CisKKwkJbW1hcF9yZWFkKCk7CisKKwkJaWYgKGhpdHMgPT0gc2FtcGxlcykKKwkJCXJldCA9IHBvbGwoZXZlbnRfYXJyYXksIG5yX3BvbGwsIDEwMCk7CisJfQorCisJcmV0dXJuIDA7Cit9CisKK3N0YXRpYyBjb25zdCBjaGFyICogY29uc3QgdG9wX3VzYWdlW10gPSB7CisJInBlcmYgdG9wIFs8b3B0aW9ucz5dIiwKKwlOVUxMCit9OworCitzdGF0aWMgY29uc3Qgc3RydWN0IG9wdGlvbiBvcHRpb25zW10gPSB7CisJT1BUX0NBTExCQUNLKCdlJywgImV2ZW50IiwgTlVMTCwgImV2ZW50IiwKKwkJICAgICAiZXZlbnQgc2VsZWN0b3IuIHVzZSAncGVyZiBsaXN0JyB0byBsaXN0IGF2YWlsYWJsZSBldmVudHMiLAorCQkgICAgIHBhcnNlX2V2ZW50cyksCisJT1BUX0lOVEVHRVIoJ2MnLCAiY291bnQiLCAmZGVmYXVsdF9pbnRlcnZhbCwKKwkJICAgICJldmVudCBwZXJpb2QgdG8gc2FtcGxlIiksCisJT1BUX0lOVEVHRVIoJ3AnLCAicGlkIiwgJnRhcmdldF9waWQsCisJCSAgICAicHJvZmlsZSBldmVudHMgb24gZXhpc3RpbmcgcGlkIiksCisJT1BUX0JPT0xFQU4oJ2EnLCAiYWxsLWNwdXMiLCAmc3lzdGVtX3dpZGUsCisJCQkgICAgInN5c3RlbS13aWRlIGNvbGxlY3Rpb24gZnJvbSBhbGwgQ1BVcyIpLAorCU9QVF9JTlRFR0VSKCdDJywgIkNQVSIsICZwcm9maWxlX2NwdSwKKwkJICAgICJDUFUgdG8gcHJvZmlsZSBvbiIpLAorCU9QVF9JTlRFR0VSKCdtJywgIm1tYXAtcGFnZXMiLCAmbW1hcF9wYWdlcywKKwkJICAgICJudW1iZXIgb2YgbW1hcCBkYXRhIHBhZ2VzIiksCisJT1BUX0lOVEVHRVIoJ3InLCAicmVhbHRpbWUiLCAmcmVhbHRpbWVfcHJpbywKKwkJICAgICJjb2xsZWN0IGRhdGEgd2l0aCB0aGlzIFJUIFNDSEVEX0ZJRk8gcHJpb3JpdHkiKSwKKwlPUFRfSU5URUdFUignZCcsICJkZWxheSIsICZkZWxheV9zZWNzLAorCQkgICAgIm51bWJlciBvZiBzZWNvbmRzIHRvIGRlbGF5IGJldHdlZW4gcmVmcmVzaGVzIiksCisJT1BUX0JPT0xFQU4oJ0QnLCAiZHVtcC1zeW10YWIiLCAmZHVtcF9zeW10YWIsCisJCQkgICAgImR1bXAgdGhlIHN5bWJvbCB0YWJsZSB1c2VkIGZvciBwcm9maWxpbmciKSwKKwlPUFRfSU5URUdFUignZicsICJjb3VudC1maWx0ZXIiLCAmY291bnRfZmlsdGVyLAorCQkgICAgIm9ubHkgZGlzcGxheSBmdW5jdGlvbnMgd2l0aCBtb3JlIGV2ZW50cyB0aGFuIHRoaXMiKSwKKwlPUFRfQk9PTEVBTignZycsICJncm91cCIsICZncm91cCwKKwkJCSAgICAicHV0IHRoZSBjb3VudGVycyBpbnRvIGEgY291bnRlciBncm91cCIpLAorCU9QVF9TVFJJTkcoJ3MnLCAic3ltLWZpbHRlciIsICZzeW1fZmlsdGVyLCAicGF0dGVybiIsCisJCSAgICAib25seSBkaXNwbGF5IHN5bWJvbHMgbWF0Y2hpZyB0aGlzIHBhdHRlcm4iKSwKKwlPUFRfQk9PTEVBTigneicsICJ6ZXJvIiwgJmdyb3VwLAorCQkgICAgInplcm8gaGlzdG9yeSBhY3Jvc3MgdXBkYXRlcyIpLAorCU9QVF9JTlRFR0VSKCdGJywgImZyZXEiLCAmZnJlcSwKKwkJICAgICJwcm9maWxlIGF0IHRoaXMgZnJlcXVlbmN5IiksCisJT1BUX0lOVEVHRVIoJ0UnLCAiZW50cmllcyIsICZwcmludF9lbnRyaWVzLAorCQkgICAgImRpc3BsYXkgdGhpcyBtYW55IGZ1bmN0aW9ucyIpLAorCU9QVF9CT09MRUFOKCd2JywgInZlcmJvc2UiLCAmdmVyYm9zZSwKKwkJICAgICJiZSBtb3JlIHZlcmJvc2UgKHNob3cgY291bnRlciBvcGVuIGVycm9ycywgZXRjKSIpLAorCU9QVF9FTkQoKQorfTsKKworaW50IGNtZF90b3AoaW50IGFyZ2MsIGNvbnN0IGNoYXIgKiphcmd2LCBjb25zdCBjaGFyICpwcmVmaXgpCit7CisJaW50IGNvdW50ZXI7CisKKwlwYWdlX3NpemUgPSBzeXNjb25mKF9TQ19QQUdFX1NJWkUpOworCisJYXJnYyA9IHBhcnNlX29wdGlvbnMoYXJnYywgYXJndiwgb3B0aW9ucywgdG9wX3VzYWdlLCAwKTsKKwlpZiAoYXJnYykKKwkJdXNhZ2Vfd2l0aF9vcHRpb25zKHRvcF91c2FnZSwgb3B0aW9ucyk7CisKKwlpZiAoZnJlcSkgeworCQlkZWZhdWx0X2ludGVydmFsID0gZnJlcTsKKwkJZnJlcSA9IDE7CisJfQorCisJLyogQ1BVIGFuZCBQSUQgYXJlIG11dHVhbGx5IGV4Y2x1c2l2ZSAqLworCWlmICh0YXJnZXRfcGlkICE9IC0xICYmIHByb2ZpbGVfY3B1ICE9IC0xKSB7CisJCXByaW50ZigiV0FSTklORzogUElEIHN3aXRjaCBvdmVycmlkaW5nIENQVVxuIik7CisJCXNsZWVwKDEpOworCQlwcm9maWxlX2NwdSA9IC0xOworCX0KKworCWlmICghbnJfY291bnRlcnMpCisJCW5yX2NvdW50ZXJzID0gMTsKKworCWlmIChkZWxheV9zZWNzIDwgMSkKKwkJZGVsYXlfc2VjcyA9IDE7CisKKwlwYXJzZV9zeW1ib2xzKCk7CisKKwkvKgorCSAqIEZpbGwgaW4gdGhlIG9uZXMgbm90IHNwZWNpZmljYWxseSBpbml0aWFsaXplZCB2aWEgLWM6CisJICovCisJZm9yIChjb3VudGVyID0gMDsgY291bnRlciA8IG5yX2NvdW50ZXJzOyBjb3VudGVyKyspIHsKKwkJaWYgKGF0dHJzW2NvdW50ZXJdLnNhbXBsZV9wZXJpb2QpCisJCQljb250aW51ZTsKKworCQlhdHRyc1tjb3VudGVyXS5zYW1wbGVfcGVyaW9kID0gZGVmYXVsdF9pbnRlcnZhbDsKKwl9CisKKwlucl9jcHVzID0gc3lzY29uZihfU0NfTlBST0NFU1NPUlNfT05MTik7CisJYXNzZXJ0KG5yX2NwdXMgPD0gTUFYX05SX0NQVVMpOworCWFzc2VydChucl9jcHVzID49IDApOworCisJaWYgKHRhcmdldF9waWQgIT0gLTEgfHwgcHJvZmlsZV9jcHUgIT0gLTEpCisJCW5yX2NwdXMgPSAxOworCisJcmV0dXJuIF9fY21kX3RvcCgpOworfQpkaWZmIC0tZ2l0IGEvdG9vbHMvcGVyZi9idWlsdGluLmggYi90b29scy9wZXJmL2J1aWx0aW4uaApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi41MWQxNjgyCi0tLSAvZGV2L251bGwKKysrIGIvdG9vbHMvcGVyZi9idWlsdGluLmgKQEAgLTAsMCArMSwyNiBAQAorI2lmbmRlZiBCVUlMVElOX0gKKyNkZWZpbmUgQlVJTFRJTl9ICisKKyNpbmNsdWRlICJ1dGlsL3V0aWwuaCIKKyNpbmNsdWRlICJ1dGlsL3N0cmJ1Zi5oIgorCitleHRlcm4gY29uc3QgY2hhciBwZXJmX3ZlcnNpb25fc3RyaW5nW107CitleHRlcm4gY29uc3QgY2hhciBwZXJmX3VzYWdlX3N0cmluZ1tdOworZXh0ZXJuIGNvbnN0IGNoYXIgcGVyZl9tb3JlX2luZm9fc3RyaW5nW107CisKK2V4dGVybiB2b2lkIGxpc3RfY29tbW9uX2NtZHNfaGVscCh2b2lkKTsKK2V4dGVybiBjb25zdCBjaGFyICpoZWxwX3Vua25vd25fY21kKGNvbnN0IGNoYXIgKmNtZCk7CitleHRlcm4gdm9pZCBwcnVuZV9wYWNrZWRfb2JqZWN0cyhpbnQpOworZXh0ZXJuIGludCByZWFkX2xpbmVfd2l0aF9udWwoY2hhciAqYnVmLCBpbnQgc2l6ZSwgRklMRSAqZmlsZSk7CitleHRlcm4gaW50IGNoZWNrX3BhZ2VyX2NvbmZpZyhjb25zdCBjaGFyICpjbWQpOworCitleHRlcm4gaW50IGNtZF9hbm5vdGF0ZShpbnQgYXJnYywgY29uc3QgY2hhciAqKmFyZ3YsIGNvbnN0IGNoYXIgKnByZWZpeCk7CitleHRlcm4gaW50IGNtZF9oZWxwKGludCBhcmdjLCBjb25zdCBjaGFyICoqYXJndiwgY29uc3QgY2hhciAqcHJlZml4KTsKK2V4dGVybiBpbnQgY21kX3JlY29yZChpbnQgYXJnYywgY29uc3QgY2hhciAqKmFyZ3YsIGNvbnN0IGNoYXIgKnByZWZpeCk7CitleHRlcm4gaW50IGNtZF9yZXBvcnQoaW50IGFyZ2MsIGNvbnN0IGNoYXIgKiphcmd2LCBjb25zdCBjaGFyICpwcmVmaXgpOworZXh0ZXJuIGludCBjbWRfc3RhdChpbnQgYXJnYywgY29uc3QgY2hhciAqKmFyZ3YsIGNvbnN0IGNoYXIgKnByZWZpeCk7CitleHRlcm4gaW50IGNtZF90b3AoaW50IGFyZ2MsIGNvbnN0IGNoYXIgKiphcmd2LCBjb25zdCBjaGFyICpwcmVmaXgpOworZXh0ZXJuIGludCBjbWRfdmVyc2lvbihpbnQgYXJnYywgY29uc3QgY2hhciAqKmFyZ3YsIGNvbnN0IGNoYXIgKnByZWZpeCk7CitleHRlcm4gaW50IGNtZF9saXN0KGludCBhcmdjLCBjb25zdCBjaGFyICoqYXJndiwgY29uc3QgY2hhciAqcHJlZml4KTsKKworI2VuZGlmCmRpZmYgLS1naXQgYS90b29scy9wZXJmL2NvbW1hbmQtbGlzdC50eHQgYi90b29scy9wZXJmL2NvbW1hbmQtbGlzdC50eHQKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uZWViY2UzMAotLS0gL2Rldi9udWxsCisrKyBiL3Rvb2xzL3BlcmYvY29tbWFuZC1saXN0LnR4dApAQCAtMCwwICsxLDEwIEBACisjCisjIExpc3Qgb2Yga25vd24gcGVyZiBjb21tYW5kcy4KKyMgY29tbWFuZCBuYW1lCQkJY2F0ZWdvcnkgW2RlcHJlY2F0ZWRdIFtjb21tb25dCisjCitwZXJmLWFubm90YXRlCQkJbWFpbnBvcmNlbGFpbiBjb21tb24KK3BlcmYtbGlzdAkJCW1haW5wb3JjZWxhaW4gY29tbW9uCitwZXJmLXJlY29yZAkJCW1haW5wb3JjZWxhaW4gY29tbW9uCitwZXJmLXJlcG9ydAkJCW1haW5wb3JjZWxhaW4gY29tbW9uCitwZXJmLXN0YXQJCQltYWlucG9yY2VsYWluIGNvbW1vbgorcGVyZi10b3AJCQltYWlucG9yY2VsYWluIGNvbW1vbgpkaWZmIC0tZ2l0IGEvdG9vbHMvcGVyZi9kZXNpZ24udHh0IGIvdG9vbHMvcGVyZi9kZXNpZ24udHh0Cm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjg2MGUxMTYKLS0tIC9kZXYvbnVsbAorKysgYi90b29scy9wZXJmL2Rlc2lnbi50eHQKQEAgLTAsMCArMSw0NDIgQEAKKworUGVyZm9ybWFuY2UgQ291bnRlcnMgZm9yIExpbnV4CistLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KKworUGVyZm9ybWFuY2UgY291bnRlcnMgYXJlIHNwZWNpYWwgaGFyZHdhcmUgcmVnaXN0ZXJzIGF2YWlsYWJsZSBvbiBtb3N0IG1vZGVybgorQ1BVcy4gVGhlc2UgcmVnaXN0ZXJzIGNvdW50IHRoZSBudW1iZXIgb2YgY2VydGFpbiB0eXBlcyBvZiBodyBldmVudHM6IHN1Y2gKK2FzIGluc3RydWN0aW9ucyBleGVjdXRlZCwgY2FjaGVtaXNzZXMgc3VmZmVyZWQsIG9yIGJyYW5jaGVzIG1pcy1wcmVkaWN0ZWQgLQord2l0aG91dCBzbG93aW5nIGRvd24gdGhlIGtlcm5lbCBvciBhcHBsaWNhdGlvbnMuIFRoZXNlIHJlZ2lzdGVycyBjYW4gYWxzbwordHJpZ2dlciBpbnRlcnJ1cHRzIHdoZW4gYSB0aHJlc2hvbGQgbnVtYmVyIG9mIGV2ZW50cyBoYXZlIHBhc3NlZCAtIGFuZCBjYW4KK3RodXMgYmUgdXNlZCB0byBwcm9maWxlIHRoZSBjb2RlIHRoYXQgcnVucyBvbiB0aGF0IENQVS4KKworVGhlIExpbnV4IFBlcmZvcm1hbmNlIENvdW50ZXIgc3Vic3lzdGVtIHByb3ZpZGVzIGFuIGFic3RyYWN0aW9uIG9mIHRoZXNlCitoYXJkd2FyZSBjYXBhYmlsaXRpZXMuIEl0IHByb3ZpZGVzIHBlciB0YXNrIGFuZCBwZXIgQ1BVIGNvdW50ZXJzLCBjb3VudGVyCitncm91cHMsIGFuZCBpdCBwcm92aWRlcyBldmVudCBjYXBhYmlsaXRpZXMgb24gdG9wIG9mIHRob3NlLiAgSXQKK3Byb3ZpZGVzICJ2aXJ0dWFsIiA2NC1iaXQgY291bnRlcnMsIHJlZ2FyZGxlc3Mgb2YgdGhlIHdpZHRoIG9mIHRoZQordW5kZXJseWluZyBoYXJkd2FyZSBjb3VudGVycy4KKworUGVyZm9ybWFuY2UgY291bnRlcnMgYXJlIGFjY2Vzc2VkIHZpYSBzcGVjaWFsIGZpbGUgZGVzY3JpcHRvcnMuCitUaGVyZSdzIG9uZSBmaWxlIGRlc2NyaXB0b3IgcGVyIHZpcnR1YWwgY291bnRlciB1c2VkLgorCitUaGUgc3BlY2lhbCBmaWxlIGRlc2NyaXB0b3IgaXMgb3BlbmVkIHZpYSB0aGUgcGVyZl9jb3VudGVyX29wZW4oKQorc3lzdGVtIGNhbGw6CisKKyAgIGludCBzeXNfcGVyZl9jb3VudGVyX29wZW4oc3RydWN0IHBlcmZfY291bnRlcl9od19ldmVudCAqaHdfZXZlbnRfdXB0ciwKKwkJCSAgICAgcGlkX3QgcGlkLCBpbnQgY3B1LCBpbnQgZ3JvdXBfZmQsCisJCQkgICAgIHVuc2lnbmVkIGxvbmcgZmxhZ3MpOworCitUaGUgc3lzY2FsbCByZXR1cm5zIHRoZSBuZXcgZmQuIFRoZSBmZCBjYW4gYmUgdXNlZCB2aWEgdGhlIG5vcm1hbAorVkZTIHN5c3RlbSBjYWxsczogcmVhZCgpIGNhbiBiZSB1c2VkIHRvIHJlYWQgdGhlIGNvdW50ZXIsIGZjbnRsKCkKK2NhbiBiZSB1c2VkIHRvIHNldCB0aGUgYmxvY2tpbmcgbW9kZSwgZXRjLgorCitNdWx0aXBsZSBjb3VudGVycyBjYW4gYmUga2VwdCBvcGVuIGF0IGEgdGltZSwgYW5kIHRoZSBjb3VudGVycworY2FuIGJlIHBvbGwoKWVkLgorCitXaGVuIGNyZWF0aW5nIGEgbmV3IGNvdW50ZXIgZmQsICdwZXJmX2NvdW50ZXJfaHdfZXZlbnQnIGlzOgorCitzdHJ1Y3QgcGVyZl9jb3VudGVyX2h3X2V2ZW50IHsKKyAgICAgICAgLyoKKyAgICAgICAgICogVGhlIE1TQiBvZiB0aGUgY29uZmlnIHdvcmQgc2lnbmlmaWVzIGlmIHRoZSByZXN0IGNvbnRhaW5zIGNwdQorICAgICAgICAgKiBzcGVjaWZpYyAocmF3KSBjb3VudGVyIGNvbmZpZ3VyYXRpb24gZGF0YSwgaWYgdW5zZXQsIHRoZSBuZXh0CisgICAgICAgICAqIDcgYml0cyBhcmUgYW4gZXZlbnQgdHlwZSBhbmQgdGhlIHJlc3Qgb2YgdGhlIGJpdHMgYXJlIHRoZSBldmVudAorICAgICAgICAgKiBpZGVudGlmaWVyLgorICAgICAgICAgKi8KKyAgICAgICAgX191NjQgICAgICAgICAgICAgICAgICAgY29uZmlnOworCisgICAgICAgIF9fdTY0ICAgICAgICAgICAgICAgICAgIGlycV9wZXJpb2Q7CisgICAgICAgIF9fdTMyICAgICAgICAgICAgICAgICAgIHJlY29yZF90eXBlOworICAgICAgICBfX3UzMiAgICAgICAgICAgICAgICAgICByZWFkX2Zvcm1hdDsKKworICAgICAgICBfX3U2NCAgICAgICAgICAgICAgICAgICBkaXNhYmxlZCAgICAgICA6ICAxLCAvKiBvZmYgYnkgZGVmYXVsdCAgICAgICAgKi8KKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgaW5oZXJpdCAgICAgICAgOiAgMSwgLyogY2hpbGRyZW4gaW5oZXJpdCBpdCAgICovCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHBpbm5lZCAgICAgICAgIDogIDEsIC8qIG11c3QgYWx3YXlzIGJlIG9uIFBNVSAqLworICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBleGNsdXNpdmUgICAgICA6ICAxLCAvKiBvbmx5IGdyb3VwIG9uIFBNVSAgICAgKi8KKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgZXhjbHVkZV91c2VyICAgOiAgMSwgLyogZG9uJ3QgY291bnQgdXNlciAgICAgICovCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGV4Y2x1ZGVfa2VybmVsIDogIDEsIC8qIGRpdHRvIGtlcm5lbCAgICAgICAgICAqLworICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBleGNsdWRlX2h2ICAgICA6ICAxLCAvKiBkaXR0byBoeXBlcnZpc29yICAgICAgKi8KKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgZXhjbHVkZV9pZGxlICAgOiAgMSwgLyogZG9uJ3QgY291bnQgd2hlbiBpZGxlICovCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIG1tYXAgICAgICAgICAgIDogIDEsIC8qIGluY2x1ZGUgbW1hcCBkYXRhICAgICAqLworICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBtdW5tYXAgICAgICAgICA6ICAxLCAvKiBpbmNsdWRlIG11bm1hcCBkYXRhICAgKi8KKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgY29tbSAgICAgICAgICAgOiAgMSwgLyogaW5jbHVkZSBjb21tIGRhdGEgICAgICovCisKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgX19yZXNlcnZlZF8xICAgOiA1MjsKKworICAgICAgICBfX3UzMiAgICAgICAgICAgICAgICAgICBleHRyYV9jb25maWdfbGVuOworICAgICAgICBfX3UzMiAgICAgICAgICAgICAgICAgICB3YWtldXBfZXZlbnRzOyAgLyogd2FrZXVwIGV2ZXJ5IG4gZXZlbnRzICovCisKKyAgICAgICAgX191NjQgICAgICAgICAgICAgICAgICAgX19yZXNlcnZlZF8yOworICAgICAgICBfX3U2NCAgICAgICAgICAgICAgICAgICBfX3Jlc2VydmVkXzM7Cit9OworCitUaGUgJ2NvbmZpZycgZmllbGQgc3BlY2lmaWVzIHdoYXQgdGhlIGNvdW50ZXIgc2hvdWxkIGNvdW50LiAgSXQKK2lzIGRpdmlkZWQgaW50byAzIGJpdC1maWVsZHM6CisKK3Jhd190eXBlOiAxIGJpdCAgIChtb3N0IHNpZ25pZmljYW50IGJpdCkJMHg4MDAwXzAwMDBfMDAwMF8wMDAwCit0eXBlOgkgIDcgYml0cyAgKG5leHQgbW9zdCBzaWduaWZpY2FudCkJMHg3ZjAwXzAwMDBfMDAwMF8wMDAwCitldmVudF9pZDogNTYgYml0cyAobGVhc3Qgc2lnbmlmaWNhbnQpCQkweDAwZmZfZmZmZl9mZmZmX2ZmZmYKKworSWYgJ3Jhd190eXBlJyBpcyAxLCB0aGVuIHRoZSBjb3VudGVyIHdpbGwgY291bnQgYSBoYXJkd2FyZSBldmVudAorc3BlY2lmaWVkIGJ5IHRoZSByZW1haW5pbmcgNjMgYml0cyBvZiBldmVudF9jb25maWcuICBUaGUgZW5jb2RpbmcgaXMKK21hY2hpbmUtc3BlY2lmaWMuCisKK0lmICdyYXdfdHlwZScgaXMgMCwgdGhlbiB0aGUgJ3R5cGUnIGZpZWxkIHNheXMgd2hhdCBraW5kIG9mIGNvdW50ZXIKK3RoaXMgaXMsIHdpdGggdGhlIGZvbGxvd2luZyBlbmNvZGluZzoKKworZW51bSBwZXJmX2V2ZW50X3R5cGVzIHsKKwlQRVJGX1RZUEVfSEFSRFdBUkUJCT0gMCwKKwlQRVJGX1RZUEVfU09GVFdBUkUJCT0gMSwKKwlQRVJGX1RZUEVfVFJBQ0VQT0lOVAkJPSAyLAorfTsKKworQSBjb3VudGVyIG9mIFBFUkZfVFlQRV9IQVJEV0FSRSB3aWxsIGNvdW50IHRoZSBoYXJkd2FyZSBldmVudAorc3BlY2lmaWVkIGJ5ICdldmVudF9pZCc6CisKKy8qCisgKiBHZW5lcmFsaXplZCBwZXJmb3JtYW5jZSBjb3VudGVyIGV2ZW50IHR5cGVzLCB1c2VkIGJ5IHRoZSBod19ldmVudC5ldmVudF9pZAorICogcGFyYW1ldGVyIG9mIHRoZSBzeXNfcGVyZl9jb3VudGVyX29wZW4oKSBzeXNjYWxsOgorICovCitlbnVtIGh3X2V2ZW50X2lkcyB7CisJLyoKKwkgKiBDb21tb24gaGFyZHdhcmUgZXZlbnRzLCBnZW5lcmFsaXplZCBieSB0aGUga2VybmVsOgorCSAqLworCVBFUkZfQ09VTlRfSFdfQ1BVX0NZQ0xFUwkJPSAwLAorCVBFUkZfQ09VTlRfSFdfSU5TVFJVQ1RJT05TCQk9IDEsCisJUEVSRl9DT1VOVF9IV19DQUNIRV9SRUZFUkVOQ0VTCT0gMiwKKwlQRVJGX0NPVU5UX0hXX0NBQ0hFX01JU1NFUwkJPSAzLAorCVBFUkZfQ09VTlRfSFdfQlJBTkNIX0lOU1RSVUNUSU9OUwk9IDQsCisJUEVSRl9DT1VOVF9IV19CUkFOQ0hfTUlTU0VTCT0gNSwKKwlQRVJGX0NPVU5UX0hXX0JVU19DWUNMRVMJCT0gNiwKK307CisKK1RoZXNlIGFyZSBzdGFuZGFyZGl6ZWQgdHlwZXMgb2YgZXZlbnRzIHRoYXQgd29yayByZWxhdGl2ZWx5IHVuaWZvcm1seQorb24gYWxsIENQVXMgdGhhdCBpbXBsZW1lbnQgUGVyZm9ybWFuY2UgQ291bnRlcnMgc3VwcG9ydCB1bmRlciBMaW51eCwKK2FsdGhvdWdoIHRoZXJlIG1heSBiZSB2YXJpYXRpb25zIChlLmcuLCBkaWZmZXJlbnQgQ1BVcyBtaWdodCBjb3VudAorY2FjaGUgcmVmZXJlbmNlcyBhbmQgbWlzc2VzIGF0IGRpZmZlcmVudCBsZXZlbHMgb2YgdGhlIGNhY2hlIGhpZXJhcmNoeSkuCitJZiBhIENQVSBpcyBub3QgYWJsZSB0byBjb3VudCB0aGUgc2VsZWN0ZWQgZXZlbnQsIHRoZW4gdGhlIHN5c3RlbSBjYWxsCit3aWxsIHJldHVybiAtRUlOVkFMLgorCitNb3JlIGh3X2V2ZW50X3R5cGVzIGFyZSBzdXBwb3J0ZWQgYXMgd2VsbCwgYnV0IHRoZXkgYXJlIENQVS1zcGVjaWZpYworYW5kIGFjY2Vzc2VkIGFzIHJhdyBldmVudHMuICBGb3IgZXhhbXBsZSwgdG8gY291bnQgIkV4dGVybmFsIGJ1cworY3ljbGVzIHdoaWxlIGJ1cyBsb2NrIHNpZ25hbCBhc3NlcnRlZCIgZXZlbnRzIG9uIEludGVsIENvcmUgQ1BVcywgcGFzcworaW4gYSAweDQwNjQgZXZlbnRfaWQgdmFsdWUgYW5kIHNldCBod19ldmVudC5yYXdfdHlwZSB0byAxLgorCitBIGNvdW50ZXIgb2YgdHlwZSBQRVJGX1RZUEVfU09GVFdBUkUgd2lsbCBjb3VudCBvbmUgb2YgdGhlIGF2YWlsYWJsZQorc29mdHdhcmUgZXZlbnRzLCBzZWxlY3RlZCBieSAnZXZlbnRfaWQnOgorCisvKgorICogU3BlY2lhbCAic29mdHdhcmUiIGNvdW50ZXJzIHByb3ZpZGVkIGJ5IHRoZSBrZXJuZWwsIGV2ZW4gaWYgdGhlIGhhcmR3YXJlCisgKiBkb2VzIG5vdCBzdXBwb3J0IHBlcmZvcm1hbmNlIGNvdW50ZXJzLiBUaGVzZSBjb3VudGVycyBtZWFzdXJlIHZhcmlvdXMKKyAqIHBoeXNpY2FsIGFuZCBzdyBldmVudHMgb2YgdGhlIGtlcm5lbCAoYW5kIGFsbG93IHRoZSBwcm9maWxpbmcgb2YgdGhlbSBhcworICogd2VsbCk6CisgKi8KK2VudW0gc3dfZXZlbnRfaWRzIHsKKwlQRVJGX0NPVU5UX1NXX0NQVV9DTE9DSwkJPSAwLAorCVBFUkZfQ09VTlRfU1dfVEFTS19DTE9DSwkJPSAxLAorCVBFUkZfQ09VTlRfU1dfUEFHRV9GQVVMVFMJCT0gMiwKKwlQRVJGX0NPVU5UX1NXX0NPTlRFWFRfU1dJVENIRVMJPSAzLAorCVBFUkZfQ09VTlRfU1dfQ1BVX01JR1JBVElPTlMJPSA0LAorCVBFUkZfQ09VTlRfU1dfUEFHRV9GQVVMVFNfTUlOCT0gNSwKKwlQRVJGX0NPVU5UX1NXX1BBR0VfRkFVTFRTX01BSgk9IDYsCit9OworCitDb3VudGVycyBvZiB0aGUgdHlwZSBQRVJGX1RZUEVfVFJBQ0VQT0lOVCBhcmUgYXZhaWxhYmxlIHdoZW4gdGhlIGZ0cmFjZSBldmVudAordHJhY2VyIGlzIGF2YWlsYWJsZSwgYW5kIGV2ZW50X2lkIHZhbHVlcyBjYW4gYmUgb2J0YWluZWQgZnJvbQorL2RlYnVnL3RyYWNpbmcvZXZlbnRzLyovKi9pZAorCisKK0NvdW50ZXJzIGNvbWUgaW4gdHdvIGZsYXZvdXJzOiBjb3VudGluZyBjb3VudGVycyBhbmQgc2FtcGxpbmcKK2NvdW50ZXJzLiAgQSAiY291bnRpbmciIGNvdW50ZXIgaXMgb25lIHRoYXQgaXMgdXNlZCBmb3IgY291bnRpbmcgdGhlCitudW1iZXIgb2YgZXZlbnRzIHRoYXQgb2NjdXIsIGFuZCBpcyBjaGFyYWN0ZXJpc2VkIGJ5IGhhdmluZworaXJxX3BlcmlvZCA9IDAuCisKKworQSByZWFkKCkgb24gYSBjb3VudGVyIHJldHVybnMgdGhlIGN1cnJlbnQgdmFsdWUgb2YgdGhlIGNvdW50ZXIgYW5kIHBvc3NpYmxlCithZGRpdGlvbmFsIHZhbHVlcyBhcyBzcGVjaWZpZWQgYnkgJ3JlYWRfZm9ybWF0JywgZWFjaCB2YWx1ZSBpcyBhIHU2NCAoOCBieXRlcykKK2luIHNpemUuCisKKy8qCisgKiBCaXRzIHRoYXQgY2FuIGJlIHNldCBpbiBod19ldmVudC5yZWFkX2Zvcm1hdCB0byByZXF1ZXN0IHRoYXQKKyAqIHJlYWRzIG9uIHRoZSBjb3VudGVyIHNob3VsZCByZXR1cm4gdGhlIGluZGljYXRlZCBxdWFudGl0aWVzLAorICogaW4gaW5jcmVhc2luZyBvcmRlciBvZiBiaXQgdmFsdWUsIGFmdGVyIHRoZSBjb3VudGVyIHZhbHVlLgorICovCitlbnVtIHBlcmZfY291bnRlcl9yZWFkX2Zvcm1hdCB7CisgICAgICAgIFBFUkZfRk9STUFUX1RPVEFMX1RJTUVfRU5BQkxFRCAgPSAgMSwKKyAgICAgICAgUEVSRl9GT1JNQVRfVE9UQUxfVElNRV9SVU5OSU5HICA9ICAyLAorfTsKKworVXNpbmcgdGhlc2UgYWRkaXRpb25hbCB2YWx1ZXMgb25lIGNhbiBlc3RhYmxpc2ggdGhlIG92ZXJjb21taXQgcmF0aW8gZm9yIGEKK3BhcnRpY3VsYXIgY291bnRlciBhbGxvd2luZyBvbmUgdG8gdGFrZSB0aGUgcm91bmQtcm9iaW4gc2NoZWR1bGluZyBlZmZlY3QKK2ludG8gYWNjb3VudC4KKworCitBICJzYW1wbGluZyIgY291bnRlciBpcyBvbmUgdGhhdCBpcyBzZXQgdXAgdG8gZ2VuZXJhdGUgYW4gaW50ZXJydXB0CitldmVyeSBOIGV2ZW50cywgd2hlcmUgTiBpcyBnaXZlbiBieSAnaXJxX3BlcmlvZCcuICBBIHNhbXBsaW5nIGNvdW50ZXIKK2hhcyBpcnFfcGVyaW9kID4gMC4gVGhlIHJlY29yZF90eXBlIGNvbnRyb2xzIHdoYXQgZGF0YSBpcyByZWNvcmRlZCBvbiBlYWNoCitpbnRlcnJ1cHQ6CisKKy8qCisgKiBCaXRzIHRoYXQgY2FuIGJlIHNldCBpbiBod19ldmVudC5yZWNvcmRfdHlwZSB0byByZXF1ZXN0IGluZm9ybWF0aW9uCisgKiBpbiB0aGUgb3ZlcmZsb3cgcGFja2V0cy4KKyAqLworZW51bSBwZXJmX2NvdW50ZXJfcmVjb3JkX2Zvcm1hdCB7CisgICAgICAgIFBFUkZfUkVDT1JEX0lQICAgICAgICAgID0gMVUgPDwgMCwKKyAgICAgICAgUEVSRl9SRUNPUkRfVElEICAgICAgICAgPSAxVSA8PCAxLAorICAgICAgICBQRVJGX1JFQ09SRF9USU1FICAgICAgICA9IDFVIDw8IDIsCisgICAgICAgIFBFUkZfUkVDT1JEX0FERFIgICAgICAgID0gMVUgPDwgMywKKyAgICAgICAgUEVSRl9SRUNPUkRfR1JPVVAgICAgICAgPSAxVSA8PCA0LAorICAgICAgICBQRVJGX1JFQ09SRF9DQUxMQ0hBSU4gICA9IDFVIDw8IDUsCit9OworCitTdWNoIChhbmQgb3RoZXIpIGV2ZW50cyB3aWxsIGJlIHJlY29yZGVkIGluIGEgcmluZy1idWZmZXIsIHdoaWNoIGlzCithdmFpbGFibGUgdG8gdXNlci1zcGFjZSB1c2luZyBtbWFwKCkgKHNlZSBiZWxvdykuCisKK1RoZSAnZGlzYWJsZWQnIGJpdCBzcGVjaWZpZXMgd2hldGhlciB0aGUgY291bnRlciBzdGFydHMgb3V0IGRpc2FibGVkCitvciBlbmFibGVkLiAgSWYgaXQgaXMgaW5pdGlhbGx5IGRpc2FibGVkLCBpdCBjYW4gYmUgZW5hYmxlZCBieSBpb2N0bAorb3IgcHJjdGwgKHNlZSBiZWxvdykuCisKK1RoZSAnaW5oZXJpdCcgYml0LCBpZiBzZXQsIHNwZWNpZmllcyB0aGF0IHRoaXMgY291bnRlciBzaG91bGQgY291bnQKK2V2ZW50cyBvbiBkZXNjZW5kYW50IHRhc2tzIGFzIHdlbGwgYXMgdGhlIHRhc2sgc3BlY2lmaWVkLiAgVGhpcyBvbmx5CithcHBsaWVzIHRvIG5ldyBkZXNjZW5kZW50cywgbm90IHRvIGFueSBleGlzdGluZyBkZXNjZW5kZW50cyBhdCB0aGUKK3RpbWUgdGhlIGNvdW50ZXIgaXMgY3JlYXRlZCAobm9yIHRvIGFueSBuZXcgZGVzY2VuZGVudHMgb2YgZXhpc3RpbmcKK2Rlc2NlbmRlbnRzKS4KKworVGhlICdwaW5uZWQnIGJpdCwgaWYgc2V0LCBzcGVjaWZpZXMgdGhhdCB0aGUgY291bnRlciBzaG91bGQgYWx3YXlzIGJlCitvbiB0aGUgQ1BVIGlmIGF0IGFsbCBwb3NzaWJsZS4gIEl0IG9ubHkgYXBwbGllcyB0byBoYXJkd2FyZSBjb3VudGVycworYW5kIG9ubHkgdG8gZ3JvdXAgbGVhZGVycy4gIElmIGEgcGlubmVkIGNvdW50ZXIgY2Fubm90IGJlIHB1dCBvbnRvIHRoZQorQ1BVIChlLmcuIGJlY2F1c2UgdGhlcmUgYXJlIG5vdCBlbm91Z2ggaGFyZHdhcmUgY291bnRlcnMgb3IgYmVjYXVzZSBvZgorYSBjb25mbGljdCB3aXRoIHNvbWUgb3RoZXIgZXZlbnQpLCB0aGVuIHRoZSBjb3VudGVyIGdvZXMgaW50byBhbgorJ2Vycm9yJyBzdGF0ZSwgd2hlcmUgcmVhZHMgcmV0dXJuIGVuZC1vZi1maWxlIChpLmUuIHJlYWQoKSByZXR1cm5zIDApCit1bnRpbCB0aGUgY291bnRlciBpcyBzdWJzZXF1ZW50bHkgZW5hYmxlZCBvciBkaXNhYmxlZC4KKworVGhlICdleGNsdXNpdmUnIGJpdCwgaWYgc2V0LCBzcGVjaWZpZXMgdGhhdCB3aGVuIHRoaXMgY291bnRlcidzIGdyb3VwCitpcyBvbiB0aGUgQ1BVLCBpdCBzaG91bGQgYmUgdGhlIG9ubHkgZ3JvdXAgdXNpbmcgdGhlIENQVSdzIGNvdW50ZXJzLgorSW4gZnV0dXJlLCB0aGlzIHdpbGwgYWxsb3cgc29waGlzdGljYXRlZCBtb25pdG9yaW5nIHByb2dyYW1zIHRvIHN1cHBseQorZXh0cmEgY29uZmlndXJhdGlvbiBpbmZvcm1hdGlvbiB2aWEgJ2V4dHJhX2NvbmZpZ19sZW4nIHRvIGV4cGxvaXQKK2FkdmFuY2VkIGZlYXR1cmVzIG9mIHRoZSBDUFUncyBQZXJmb3JtYW5jZSBNb25pdG9yIFVuaXQgKFBNVSkgdGhhdCBhcmUKK25vdCBvdGhlcndpc2UgYWNjZXNzaWJsZSBhbmQgdGhhdCBtaWdodCBkaXNydXB0IG90aGVyIGhhcmR3YXJlCitjb3VudGVycy4KKworVGhlICdleGNsdWRlX3VzZXInLCAnZXhjbHVkZV9rZXJuZWwnIGFuZCAnZXhjbHVkZV9odicgYml0cyBwcm92aWRlIGEKK3dheSB0byByZXF1ZXN0IHRoYXQgY291bnRpbmcgb2YgZXZlbnRzIGJlIHJlc3RyaWN0ZWQgdG8gdGltZXMgd2hlbiB0aGUKK0NQVSBpcyBpbiB1c2VyLCBrZXJuZWwgYW5kL29yIGh5cGVydmlzb3IgbW9kZS4KKworVGhlICdtbWFwJyBhbmQgJ211bm1hcCcgYml0cyBhbGxvdyByZWNvcmRpbmcgb2YgUFJPVF9FWEVDIG1tYXAvbXVubWFwCitvcGVyYXRpb25zLCB0aGVzZSBjYW4gYmUgdXNlZCB0byByZWxhdGUgdXNlcnNwYWNlIElQIGFkZHJlc3NlcyB0byBhY3R1YWwKK2NvZGUsIGV2ZW4gYWZ0ZXIgdGhlIG1hcHBpbmcgKG9yIGV2ZW4gdGhlIHdob2xlIHByb2Nlc3MpIGlzIGdvbmUsCit0aGVzZSBldmVudHMgYXJlIHJlY29yZGVkIGluIHRoZSByaW5nLWJ1ZmZlciAoc2VlIGJlbG93KS4KKworVGhlICdjb21tJyBiaXQgYWxsb3dzIHRyYWNraW5nIG9mIHByb2Nlc3MgY29tbSBkYXRhIG9uIHByb2Nlc3MgY3JlYXRpb24uCitUaGlzIHRvbyBpcyByZWNvcmRlZCBpbiB0aGUgcmluZy1idWZmZXIgKHNlZSBiZWxvdykuCisKK1RoZSAncGlkJyBwYXJhbWV0ZXIgdG8gdGhlIHBlcmZfY291bnRlcl9vcGVuKCkgc3lzdGVtIGNhbGwgYWxsb3dzIHRoZQorY291bnRlciB0byBiZSBzcGVjaWZpYyB0byBhIHRhc2s6CisKKyBwaWQgPT0gMDogaWYgdGhlIHBpZCBwYXJhbWV0ZXIgaXMgemVybywgdGhlIGNvdW50ZXIgaXMgYXR0YWNoZWQgdG8gdGhlCisgY3VycmVudCB0YXNrLgorCisgcGlkID4gMDogdGhlIGNvdW50ZXIgaXMgYXR0YWNoZWQgdG8gYSBzcGVjaWZpYyB0YXNrIChpZiB0aGUgY3VycmVudCB0YXNrCisgaGFzIHN1ZmZpY2llbnQgcHJpdmlsZWdlIHRvIGRvIHNvKQorCisgcGlkIDwgMDogYWxsIHRhc2tzIGFyZSBjb3VudGVkIChwZXIgY3B1IGNvdW50ZXJzKQorCitUaGUgJ2NwdScgcGFyYW1ldGVyIGFsbG93cyBhIGNvdW50ZXIgdG8gYmUgbWFkZSBzcGVjaWZpYyB0byBhIENQVToKKworIGNwdSA+PSAwOiB0aGUgY291bnRlciBpcyByZXN0cmljdGVkIHRvIGEgc3BlY2lmaWMgQ1BVCisgY3B1ID09IC0xOiB0aGUgY291bnRlciBjb3VudHMgb24gYWxsIENQVXMKKworKE5vdGU6IHRoZSBjb21iaW5hdGlvbiBvZiAncGlkID09IC0xJyBhbmQgJ2NwdSA9PSAtMScgaXMgbm90IHZhbGlkLikKKworQSAncGlkID4gMCcgYW5kICdjcHUgPT0gLTEnIGNvdW50ZXIgaXMgYSBwZXIgdGFzayBjb3VudGVyIHRoYXQgY291bnRzCitldmVudHMgb2YgdGhhdCB0YXNrIGFuZCAnZm9sbG93cycgdGhhdCB0YXNrIHRvIHdoYXRldmVyIENQVSB0aGUgdGFzaworZ2V0cyBzY2hlZHVsZSB0by4gUGVyIHRhc2sgY291bnRlcnMgY2FuIGJlIGNyZWF0ZWQgYnkgYW55IHVzZXIsIGZvcgordGhlaXIgb3duIHRhc2tzLgorCitBICdwaWQgPT0gLTEnIGFuZCAnY3B1ID09IHgnIGNvdW50ZXIgaXMgYSBwZXIgQ1BVIGNvdW50ZXIgdGhhdCBjb3VudHMKK2FsbCBldmVudHMgb24gQ1BVLXguIFBlciBDUFUgY291bnRlcnMgbmVlZCBDQVBfU1lTX0FETUlOIHByaXZpbGVnZS4KKworVGhlICdmbGFncycgcGFyYW1ldGVyIGlzIGN1cnJlbnRseSB1bnVzZWQgYW5kIG11c3QgYmUgemVyby4KKworVGhlICdncm91cF9mZCcgcGFyYW1ldGVyIGFsbG93cyBjb3VudGVyICJncm91cHMiIHRvIGJlIHNldCB1cC4gIEEKK2NvdW50ZXIgZ3JvdXAgaGFzIG9uZSBjb3VudGVyIHdoaWNoIGlzIHRoZSBncm91cCAibGVhZGVyIi4gIFRoZSBsZWFkZXIKK2lzIGNyZWF0ZWQgZmlyc3QsIHdpdGggZ3JvdXBfZmQgPSAtMSBpbiB0aGUgcGVyZl9jb3VudGVyX29wZW4gY2FsbAordGhhdCBjcmVhdGVzIGl0LiAgVGhlIHJlc3Qgb2YgdGhlIGdyb3VwIG1lbWJlcnMgYXJlIGNyZWF0ZWQKK3N1YnNlcXVlbnRseSwgd2l0aCBncm91cF9mZCBnaXZpbmcgdGhlIGZkIG9mIHRoZSBncm91cCBsZWFkZXIuCisoQSBzaW5nbGUgY291bnRlciBvbiBpdHMgb3duIGlzIGNyZWF0ZWQgd2l0aCBncm91cF9mZCA9IC0xIGFuZCBpcworY29uc2lkZXJlZCB0byBiZSBhIGdyb3VwIHdpdGggb25seSAxIG1lbWJlci4pCisKK0EgY291bnRlciBncm91cCBpcyBzY2hlZHVsZWQgb250byB0aGUgQ1BVIGFzIGEgdW5pdCwgdGhhdCBpcywgaXQgd2lsbAorb25seSBiZSBwdXQgb250byB0aGUgQ1BVIGlmIGFsbCBvZiB0aGUgY291bnRlcnMgaW4gdGhlIGdyb3VwIGNhbiBiZQorcHV0IG9udG8gdGhlIENQVS4gIFRoaXMgbWVhbnMgdGhhdCB0aGUgdmFsdWVzIG9mIHRoZSBtZW1iZXIgY291bnRlcnMKK2NhbiBiZSBtZWFuaW5nZnVsbHkgY29tcGFyZWQsIGFkZGVkLCBkaXZpZGVkICh0byBnZXQgcmF0aW9zKSwgZXRjLiwKK3dpdGggZWFjaCBvdGhlciwgc2luY2UgdGhleSBoYXZlIGNvdW50ZWQgZXZlbnRzIGZvciB0aGUgc2FtZSBzZXQgb2YKK2V4ZWN1dGVkIGluc3RydWN0aW9ucy4KKworCitMaWtlIHN0YXRlZCwgYXN5bmNocm9ub3VzIGV2ZW50cywgbGlrZSBjb3VudGVyIG92ZXJmbG93IG9yIFBST1RfRVhFQyBtbWFwCit0cmFja2luZyBhcmUgbG9nZ2VkIGludG8gYSByaW5nLWJ1ZmZlci4gVGhpcyByaW5nLWJ1ZmZlciBpcyBjcmVhdGVkIGFuZAorYWNjZXNzZWQgdGhyb3VnaCBtbWFwKCkuCisKK1RoZSBtbWFwIHNpemUgc2hvdWxkIGJlIDErMl5uIHBhZ2VzLCB3aGVyZSB0aGUgZmlyc3QgcGFnZSBpcyBhIG1ldGEtZGF0YSBwYWdlCisoc3RydWN0IHBlcmZfY291bnRlcl9tbWFwX3BhZ2UpIHRoYXQgY29udGFpbnMgdmFyaW91cyBiaXRzIG9mIGluZm9ybWF0aW9uIHN1Y2gKK2FzIHdoZXJlIHRoZSByaW5nLWJ1ZmZlciBoZWFkIGlzLgorCisvKgorICogU3RydWN0dXJlIG9mIHRoZSBwYWdlIHRoYXQgY2FuIGJlIG1hcHBlZCB2aWEgbW1hcAorICovCitzdHJ1Y3QgcGVyZl9jb3VudGVyX21tYXBfcGFnZSB7CisgICAgICAgIF9fdTMyICAgdmVyc2lvbjsgICAgICAgICAgICAgICAgLyogdmVyc2lvbiBudW1iZXIgb2YgdGhpcyBzdHJ1Y3R1cmUgKi8KKyAgICAgICAgX191MzIgICBjb21wYXRfdmVyc2lvbjsgICAgICAgICAvKiBsb3dlc3QgdmVyc2lvbiB0aGlzIGlzIGNvbXBhdCB3aXRoICovCisKKyAgICAgICAgLyoKKyAgICAgICAgICogQml0cyBuZWVkZWQgdG8gcmVhZCB0aGUgaHcgY291bnRlcnMgaW4gdXNlci1zcGFjZS4KKyAgICAgICAgICoKKyAgICAgICAgICogICB1MzIgc2VxOworICAgICAgICAgKiAgIHM2NCBjb3VudDsKKyAgICAgICAgICoKKyAgICAgICAgICogICBkbyB7CisgICAgICAgICAqICAgICBzZXEgPSBwYy0+bG9jazsKKyAgICAgICAgICoKKyAgICAgICAgICogICAgIGJhcnJpZXIoKQorICAgICAgICAgKiAgICAgaWYgKHBjLT5pbmRleCkgeworICAgICAgICAgKiAgICAgICBjb3VudCA9IHBtY19yZWFkKHBjLT5pbmRleCAtIDEpOworICAgICAgICAgKiAgICAgICBjb3VudCArPSBwYy0+b2Zmc2V0OworICAgICAgICAgKiAgICAgfSBlbHNlCisgICAgICAgICAqICAgICAgIGdvdG8gcmVndWxhcl9yZWFkOworICAgICAgICAgKgorICAgICAgICAgKiAgICAgYmFycmllcigpOworICAgICAgICAgKiAgIH0gd2hpbGUgKHBjLT5sb2NrICE9IHNlcSk7CisgICAgICAgICAqCisgICAgICAgICAqIE5PVEU6IGZvciBvYnZpb3VzIHJlYXNvbiB0aGlzIG9ubHkgd29ya3Mgb24gc2VsZi1tb25pdG9yaW5nCisgICAgICAgICAqICAgICAgIHByb2Nlc3Nlcy4KKyAgICAgICAgICovCisgICAgICAgIF9fdTMyICAgbG9jazsgICAgICAgICAgICAgICAgICAgLyogc2VxbG9jayBmb3Igc3luY2hyb25pemF0aW9uICovCisgICAgICAgIF9fdTMyICAgaW5kZXg7ICAgICAgICAgICAgICAgICAgLyogaGFyZHdhcmUgY291bnRlciBpZGVudGlmaWVyICovCisgICAgICAgIF9fczY0ICAgb2Zmc2V0OyAgICAgICAgICAgICAgICAgLyogYWRkIHRvIGhhcmR3YXJlIGNvdW50ZXIgdmFsdWUgKi8KKworICAgICAgICAvKgorICAgICAgICAgKiBDb250cm9sIGRhdGEgZm9yIHRoZSBtbWFwKCkgZGF0YSBidWZmZXIuCisgICAgICAgICAqCisgICAgICAgICAqIFVzZXItc3BhY2UgcmVhZGluZyB0aGlzIHZhbHVlIHNob3VsZCBpc3N1ZSBhbiBybWIoKSwgb24gU01QIGNhcGFibGUKKyAgICAgICAgICogcGxhdGZvcm1zLCBhZnRlciByZWFkaW5nIHRoaXMgdmFsdWUgLS0gc2VlIHBlcmZfY291bnRlcl93YWtldXAoKS4KKyAgICAgICAgICovCisgICAgICAgIF9fdTMyICAgZGF0YV9oZWFkOyAgICAgICAgICAgICAgLyogaGVhZCBpbiB0aGUgZGF0YSBzZWN0aW9uICovCit9OworCitOT1RFOiB0aGUgaHctY291bnRlciB1c2Vyc3BhY2UgYml0cyBhcmUgYXJjaCBzcGVjaWZpYyBhbmQgYXJlIGN1cnJlbnRseSBvbmx5CisgICAgICBpbXBsZW1lbnRlZCBvbiBwb3dlcnBjLgorCitUaGUgZm9sbG93aW5nIDJebiBwYWdlcyBhcmUgdGhlIHJpbmctYnVmZmVyIHdoaWNoIGNvbnRhaW5zIGV2ZW50cyBvZiB0aGUgZm9ybToKKworI2RlZmluZSBQRVJGX0VWRU5UX01JU0NfS0VSTkVMICAgICAgICAgICgxIDw8IDApCisjZGVmaW5lIFBFUkZfRVZFTlRfTUlTQ19VU0VSICAgICAgICAgICAgKDEgPDwgMSkKKyNkZWZpbmUgUEVSRl9FVkVOVF9NSVNDX09WRVJGTE9XICAgICAgICAoMSA8PCAyKQorCitzdHJ1Y3QgcGVyZl9ldmVudF9oZWFkZXIgeworICAgICAgICBfX3UzMiAgIHR5cGU7CisgICAgICAgIF9fdTE2ICAgbWlzYzsKKyAgICAgICAgX191MTYgICBzaXplOworfTsKKworZW51bSBwZXJmX2V2ZW50X3R5cGUgeworCisgICAgICAgIC8qCisgICAgICAgICAqIFRoZSBNTUFQIGV2ZW50cyByZWNvcmQgdGhlIFBST1RfRVhFQyBtYXBwaW5ncyBzbyB0aGF0IHdlIGNhbgorICAgICAgICAgKiBjb3JyZWxhdGUgdXNlcnNwYWNlIElQcyB0byBjb2RlLiBUaGV5IGhhdmUgdGhlIGZvbGxvd2luZyBzdHJ1Y3R1cmU6CisgICAgICAgICAqCisgICAgICAgICAqIHN0cnVjdCB7CisgICAgICAgICAqICAgICAgc3RydWN0IHBlcmZfZXZlbnRfaGVhZGVyICAgICAgICBoZWFkZXI7CisgICAgICAgICAqCisgICAgICAgICAqICAgICAgdTMyICAgICAgICAgICAgICAgICAgICAgICAgICAgICBwaWQsIHRpZDsKKyAgICAgICAgICogICAgICB1NjQgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGFkZHI7CisgICAgICAgICAqICAgICAgdTY0ICAgICAgICAgICAgICAgICAgICAgICAgICAgICBsZW47CisgICAgICAgICAqICAgICAgdTY0ICAgICAgICAgICAgICAgICAgICAgICAgICAgICBwZ29mZjsKKyAgICAgICAgICogICAgICBjaGFyICAgICAgICAgICAgICAgICAgICAgICAgICAgIGZpbGVuYW1lW107CisgICAgICAgICAqIH07CisgICAgICAgICAqLworICAgICAgICBQRVJGX0VWRU5UX01NQVAgICAgICAgICAgICAgICAgID0gMSwKKyAgICAgICAgUEVSRl9FVkVOVF9NVU5NQVAgICAgICAgICAgICAgICA9IDIsCisKKyAgICAgICAgLyoKKyAgICAgICAgICogc3RydWN0IHsKKyAgICAgICAgICogICAgICBzdHJ1Y3QgcGVyZl9ldmVudF9oZWFkZXIgICAgICAgIGhlYWRlcjsKKyAgICAgICAgICoKKyAgICAgICAgICogICAgICB1MzIgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHBpZCwgdGlkOworICAgICAgICAgKiAgICAgIGNoYXIgICAgICAgICAgICAgICAgICAgICAgICAgICAgY29tbVtdOworICAgICAgICAgKiB9OworICAgICAgICAgKi8KKyAgICAgICAgUEVSRl9FVkVOVF9DT01NICAgICAgICAgICAgICAgICA9IDMsCisKKyAgICAgICAgLyoKKyAgICAgICAgICogV2hlbiBoZWFkZXIubWlzYyAmIFBFUkZfRVZFTlRfTUlTQ19PVkVSRkxPVyB0aGUgZXZlbnRfdHlwZSBmaWVsZAorICAgICAgICAgKiB3aWxsIGJlIFBFUkZfUkVDT1JEXyoKKyAgICAgICAgICoKKyAgICAgICAgICogc3RydWN0IHsKKyAgICAgICAgICogICAgICBzdHJ1Y3QgcGVyZl9ldmVudF9oZWFkZXIgICAgICAgIGhlYWRlcjsKKyAgICAgICAgICoKKyAgICAgICAgICogICAgICB7IHU2NCAgICAgICAgICAgICAgICAgICBpcDsgICAgICAgfSAmJiBQRVJGX1JFQ09SRF9JUAorICAgICAgICAgKiAgICAgIHsgdTMyICAgICAgICAgICAgICAgICAgIHBpZCwgdGlkOyB9ICYmIFBFUkZfUkVDT1JEX1RJRAorICAgICAgICAgKiAgICAgIHsgdTY0ICAgICAgICAgICAgICAgICAgIHRpbWU7ICAgICB9ICYmIFBFUkZfUkVDT1JEX1RJTUUKKyAgICAgICAgICogICAgICB7IHU2NCAgICAgICAgICAgICAgICAgICBhZGRyOyAgICAgfSAmJiBQRVJGX1JFQ09SRF9BRERSCisgICAgICAgICAqCisgICAgICAgICAqICAgICAgeyB1NjQgICAgICAgICAgICAgICAgICAgbnI7CisgICAgICAgICAqICAgICAgICB7IHU2NCBldmVudCwgdmFsOyB9ICAgY250W25yXTsgIH0gJiYgUEVSRl9SRUNPUkRfR1JPVVAKKyAgICAgICAgICoKKyAgICAgICAgICogICAgICB7IHUxNiAgICAgICAgICAgICAgICAgICBuciwKKyAgICAgICAgICogICAgICAgICAgICAgICAgICAgICAgICAgICAgICBodiwKKyAgICAgICAgICogICAgICAgICAgICAgICAgICAgICAgICAgICAgICBrZXJuZWwsCisgICAgICAgICAqICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgdXNlcjsKKyAgICAgICAgICogICAgICAgIHU2NCAgICAgICAgICAgICAgICAgICBpcHNbbnJdOyAgfSAmJiBQRVJGX1JFQ09SRF9DQUxMQ0hBSU4KKyAgICAgICAgICogfTsKKyAgICAgICAgICovCit9OworCitOT1RFOiBQRVJGX1JFQ09SRF9DQUxMQ0hBSU4gaXMgYXJjaCBzcGVjaWZpYyBhbmQgY3VycmVudGx5IG9ubHkgaW1wbGVtZW50ZWQKKyAgICAgIG9uIHg4Ni4KKworTm90aWZpY2F0aW9uIG9mIG5ldyBldmVudHMgaXMgcG9zc2libGUgdGhyb3VnaCBwb2xsKCkvc2VsZWN0KCkvZXBvbGwoKSBhbmQKK2ZjbnRsKCkgbWFuYWdpbmcgc2lnbmFscy4KKworTm9ybWFsbHkgYSBub3RpZmljYXRpb24gaXMgZ2VuZXJhdGVkIGZvciBldmVyeSBwYWdlIGZpbGxlZCwgaG93ZXZlciBvbmUgY2FuCithZGRpdGlvbmFsbHkgc2V0IHBlcmZfY291bnRlcl9od19ldmVudC53YWtldXBfZXZlbnRzIHRvIGdlbmVyYXRlIG9uZSBldmVyeQorc28gbWFueSBjb3VudGVyIG92ZXJmbG93IGV2ZW50cy4KKworRnV0dXJlIHdvcmsgd2lsbCBpbmNsdWRlIGEgc3BsaWNlKCkgaW50ZXJmYWNlIHRvIHRoZSByaW5nLWJ1ZmZlci4KKworCitDb3VudGVycyBjYW4gYmUgZW5hYmxlZCBhbmQgZGlzYWJsZWQgaW4gdHdvIHdheXM6IHZpYSBpb2N0bCBhbmQgdmlhCitwcmN0bC4gIFdoZW4gYSBjb3VudGVyIGlzIGRpc2FibGVkLCBpdCBkb2Vzbid0IGNvdW50IG9yIGdlbmVyYXRlCitldmVudHMgYnV0IGRvZXMgY29udGludWUgdG8gZXhpc3QgYW5kIG1haW50YWluIGl0cyBjb3VudCB2YWx1ZS4KKworQW4gaW5kaXZpZHVhbCBjb3VudGVyIG9yIGNvdW50ZXIgZ3JvdXAgY2FuIGJlIGVuYWJsZWQgd2l0aAorCisJaW9jdGwoZmQsIFBFUkZfQ09VTlRFUl9JT0NfRU5BQkxFKTsKKworb3IgZGlzYWJsZWQgd2l0aAorCisJaW9jdGwoZmQsIFBFUkZfQ09VTlRFUl9JT0NfRElTQUJMRSk7CisKK0VuYWJsaW5nIG9yIGRpc2FibGluZyB0aGUgbGVhZGVyIG9mIGEgZ3JvdXAgZW5hYmxlcyBvciBkaXNhYmxlcyB0aGUKK3dob2xlIGdyb3VwOyB0aGF0IGlzLCB3aGlsZSB0aGUgZ3JvdXAgbGVhZGVyIGlzIGRpc2FibGVkLCBub25lIG9mIHRoZQorY291bnRlcnMgaW4gdGhlIGdyb3VwIHdpbGwgY291bnQuICBFbmFibGluZyBvciBkaXNhYmxpbmcgYSBtZW1iZXIgb2YgYQorZ3JvdXAgb3RoZXIgdGhhbiB0aGUgbGVhZGVyIG9ubHkgYWZmZWN0cyB0aGF0IGNvdW50ZXIgLSBkaXNhYmxpbmcgYW4KK25vbi1sZWFkZXIgc3RvcHMgdGhhdCBjb3VudGVyIGZyb20gY291bnRpbmcgYnV0IGRvZXNuJ3QgYWZmZWN0IGFueQorb3RoZXIgY291bnRlci4KKworQWRkaXRpb25hbGx5LCBub24taW5oZXJpdGVkIG92ZXJmbG93IGNvdW50ZXJzIGNhbiB1c2UKKworCWlvY3RsKGZkLCBQRVJGX0NPVU5URVJfSU9DX1JFRlJFU0gsIG5yKTsKKwordG8gZW5hYmxlIGEgY291bnRlciBmb3IgJ25yJyBldmVudHMsIGFmdGVyIHdoaWNoIGl0IGdldHMgZGlzYWJsZWQgYWdhaW4uCisKK0EgcHJvY2VzcyBjYW4gZW5hYmxlIG9yIGRpc2FibGUgYWxsIHRoZSBjb3VudGVyIGdyb3VwcyB0aGF0IGFyZQorYXR0YWNoZWQgdG8gaXQsIHVzaW5nIHByY3RsOgorCisJcHJjdGwoUFJfVEFTS19QRVJGX0NPVU5URVJTX0VOQUJMRSk7CisKKwlwcmN0bChQUl9UQVNLX1BFUkZfQ09VTlRFUlNfRElTQUJMRSk7CisKK1RoaXMgYXBwbGllcyB0byBhbGwgY291bnRlcnMgb24gdGhlIGN1cnJlbnQgcHJvY2Vzcywgd2hldGhlciBjcmVhdGVkCitieSB0aGlzIHByb2Nlc3Mgb3IgYnkgYW5vdGhlciwgYW5kIGRvZXNuJ3QgYWZmZWN0IGFueSBjb3VudGVycyB0aGF0Cit0aGlzIHByb2Nlc3MgaGFzIGNyZWF0ZWQgb24gb3RoZXIgcHJvY2Vzc2VzLiAgSXQgb25seSBlbmFibGVzIG9yCitkaXNhYmxlcyB0aGUgZ3JvdXAgbGVhZGVycywgbm90IGFueSBvdGhlciBtZW1iZXJzIGluIHRoZSBncm91cHMuCisKZGlmZiAtLWdpdCBhL3Rvb2xzL3BlcmYvcGVyZi5jIGIvdG9vbHMvcGVyZi9wZXJmLmMKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uNGViNzI1OQotLS0gL2Rldi9udWxsCisrKyBiL3Rvb2xzL3BlcmYvcGVyZi5jCkBAIC0wLDAgKzEsNDI4IEBACisvKgorICogcGVyZi5jCisgKgorICogUGVyZm9ybWFuY2UgYW5hbHlzaXMgdXRpbGl0eS4KKyAqCisgKiBUaGlzIGlzIHRoZSBtYWluIGh1YiBmcm9tIHdoaWNoIHRoZSBzdWItY29tbWFuZHMgKHBlcmYgc3RhdCwKKyAqIHBlcmYgdG9wLCBwZXJmIHJlY29yZCwgcGVyZiByZXBvcnQsIGV0Yy4pIGFyZSBzdGFydGVkLgorICovCisjaW5jbHVkZSAiYnVpbHRpbi5oIgorCisjaW5jbHVkZSAidXRpbC9leGVjX2NtZC5oIgorI2luY2x1ZGUgInV0aWwvY2FjaGUuaCIKKyNpbmNsdWRlICJ1dGlsL3F1b3RlLmgiCisjaW5jbHVkZSAidXRpbC9ydW4tY29tbWFuZC5oIgorCitjb25zdCBjaGFyIHBlcmZfdXNhZ2Vfc3RyaW5nW10gPQorCSJwZXJmIFstLXZlcnNpb25dIFstLWhlbHBdIENPTU1BTkQgW0FSR1NdIjsKKworY29uc3QgY2hhciBwZXJmX21vcmVfaW5mb19zdHJpbmdbXSA9CisJIlNlZSAncGVyZiBoZWxwIENPTU1BTkQnIGZvciBtb3JlIGluZm9ybWF0aW9uIG9uIGEgc3BlY2lmaWMgY29tbWFuZC4iOworCitzdGF0aWMgaW50IHVzZV9wYWdlciA9IC0xOworc3RydWN0IHBhZ2VyX2NvbmZpZyB7CisJY29uc3QgY2hhciAqY21kOworCWludCB2YWw7Cit9OworCitzdGF0aWMgaW50IHBhZ2VyX2NvbW1hbmRfY29uZmlnKGNvbnN0IGNoYXIgKnZhciwgY29uc3QgY2hhciAqdmFsdWUsIHZvaWQgKmRhdGEpCit7CisJc3RydWN0IHBhZ2VyX2NvbmZpZyAqYyA9IGRhdGE7CisJaWYgKCFwcmVmaXhjbXAodmFyLCAicGFnZXIuIikgJiYgIXN0cmNtcCh2YXIgKyA2LCBjLT5jbWQpKQorCQljLT52YWwgPSBwZXJmX2NvbmZpZ19ib29sKHZhciwgdmFsdWUpOworCXJldHVybiAwOworfQorCisvKiByZXR1cm5zIDAgZm9yICJubyBwYWdlciIsIDEgZm9yICJ1c2UgcGFnZXIiLCBhbmQgLTEgZm9yICJub3Qgc3BlY2lmaWVkIiAqLworaW50IGNoZWNrX3BhZ2VyX2NvbmZpZyhjb25zdCBjaGFyICpjbWQpCit7CisJc3RydWN0IHBhZ2VyX2NvbmZpZyBjOworCWMuY21kID0gY21kOworCWMudmFsID0gLTE7CisJcGVyZl9jb25maWcocGFnZXJfY29tbWFuZF9jb25maWcsICZjKTsKKwlyZXR1cm4gYy52YWw7Cit9CisKK3N0YXRpYyB2b2lkIGNvbW1pdF9wYWdlcl9jaG9pY2Uodm9pZCkgeworCXN3aXRjaCAodXNlX3BhZ2VyKSB7CisJY2FzZSAwOgorCQlzZXRlbnYoIlBFUkZfUEFHRVIiLCAiY2F0IiwgMSk7CisJCWJyZWFrOworCWNhc2UgMToKKwkJLyogc2V0dXBfcGFnZXIoKTsgKi8KKwkJYnJlYWs7CisJZGVmYXVsdDoKKwkJYnJlYWs7CisJfQorfQorCitzdGF0aWMgaW50IGhhbmRsZV9vcHRpb25zKGNvbnN0IGNoYXIqKiogYXJndiwgaW50KiBhcmdjLCBpbnQqIGVudmNoYW5nZWQpCit7CisJaW50IGhhbmRsZWQgPSAwOworCisJd2hpbGUgKCphcmdjID4gMCkgeworCQljb25zdCBjaGFyICpjbWQgPSAoKmFyZ3YpWzBdOworCQlpZiAoY21kWzBdICE9ICctJykKKwkJCWJyZWFrOworCisJCS8qCisJCSAqIEZvciBsZWdhY3kgcmVhc29ucywgdGhlICJ2ZXJzaW9uIiBhbmQgImhlbHAiCisJCSAqIGNvbW1hbmRzIGNhbiBiZSB3cml0dGVuIHdpdGggIi0tIiBwcmVwZW5kZWQKKwkJICogdG8gbWFrZSB0aGVtIGxvb2sgbGlrZSBmbGFncy4KKwkJICovCisJCWlmICghc3RyY21wKGNtZCwgIi0taGVscCIpIHx8ICFzdHJjbXAoY21kLCAiLS12ZXJzaW9uIikpCisJCQlicmVhazsKKworCQkvKgorCQkgKiBDaGVjayByZW1haW5pbmcgZmxhZ3MuCisJCSAqLworCQlpZiAoIXByZWZpeGNtcChjbWQsICItLWV4ZWMtcGF0aCIpKSB7CisJCQljbWQgKz0gMTE7CisJCQlpZiAoKmNtZCA9PSAnPScpCisJCQkJcGVyZl9zZXRfYXJndl9leGVjX3BhdGgoY21kICsgMSk7CisJCQllbHNlIHsKKwkJCQlwdXRzKHBlcmZfZXhlY19wYXRoKCkpOworCQkJCWV4aXQoMCk7CisJCQl9CisJCX0gZWxzZSBpZiAoIXN0cmNtcChjbWQsICItLWh0bWwtcGF0aCIpKSB7CisJCQlwdXRzKHN5c3RlbV9wYXRoKFBFUkZfSFRNTF9QQVRIKSk7CisJCQlleGl0KDApOworCQl9IGVsc2UgaWYgKCFzdHJjbXAoY21kLCAiLXAiKSB8fCAhc3RyY21wKGNtZCwgIi0tcGFnaW5hdGUiKSkgeworCQkJdXNlX3BhZ2VyID0gMTsKKwkJfSBlbHNlIGlmICghc3RyY21wKGNtZCwgIi0tbm8tcGFnZXIiKSkgeworCQkJdXNlX3BhZ2VyID0gMDsKKwkJCWlmIChlbnZjaGFuZ2VkKQorCQkJCSplbnZjaGFuZ2VkID0gMTsKKwkJfSBlbHNlIGlmICghc3RyY21wKGNtZCwgIi0tcGVyZi1kaXIiKSkgeworCQkJaWYgKCphcmdjIDwgMikgeworCQkJCWZwcmludGYoc3RkZXJyLCAiTm8gZGlyZWN0b3J5IGdpdmVuIGZvciAtLXBlcmYtZGlyLlxuIiApOworCQkJCXVzYWdlKHBlcmZfdXNhZ2Vfc3RyaW5nKTsKKwkJCX0KKwkJCXNldGVudihQRVJGX0RJUl9FTlZJUk9OTUVOVCwgKCphcmd2KVsxXSwgMSk7CisJCQlpZiAoZW52Y2hhbmdlZCkKKwkJCQkqZW52Y2hhbmdlZCA9IDE7CisJCQkoKmFyZ3YpKys7CisJCQkoKmFyZ2MpLS07CisJCQloYW5kbGVkKys7CisJCX0gZWxzZSBpZiAoIXByZWZpeGNtcChjbWQsICItLXBlcmYtZGlyPSIpKSB7CisJCQlzZXRlbnYoUEVSRl9ESVJfRU5WSVJPTk1FTlQsIGNtZCArIDEwLCAxKTsKKwkJCWlmIChlbnZjaGFuZ2VkKQorCQkJCSplbnZjaGFuZ2VkID0gMTsKKwkJfSBlbHNlIGlmICghc3RyY21wKGNtZCwgIi0td29yay10cmVlIikpIHsKKwkJCWlmICgqYXJnYyA8IDIpIHsKKwkJCQlmcHJpbnRmKHN0ZGVyciwgIk5vIGRpcmVjdG9yeSBnaXZlbiBmb3IgLS13b3JrLXRyZWUuXG4iICk7CisJCQkJdXNhZ2UocGVyZl91c2FnZV9zdHJpbmcpOworCQkJfQorCQkJc2V0ZW52KFBFUkZfV09SS19UUkVFX0VOVklST05NRU5ULCAoKmFyZ3YpWzFdLCAxKTsKKwkJCWlmIChlbnZjaGFuZ2VkKQorCQkJCSplbnZjaGFuZ2VkID0gMTsKKwkJCSgqYXJndikrKzsKKwkJCSgqYXJnYyktLTsKKwkJfSBlbHNlIGlmICghcHJlZml4Y21wKGNtZCwgIi0td29yay10cmVlPSIpKSB7CisJCQlzZXRlbnYoUEVSRl9XT1JLX1RSRUVfRU5WSVJPTk1FTlQsIGNtZCArIDEyLCAxKTsKKwkJCWlmIChlbnZjaGFuZ2VkKQorCQkJCSplbnZjaGFuZ2VkID0gMTsKKwkJfSBlbHNlIHsKKwkJCWZwcmludGYoc3RkZXJyLCAiVW5rbm93biBvcHRpb246ICVzXG4iLCBjbWQpOworCQkJdXNhZ2UocGVyZl91c2FnZV9zdHJpbmcpOworCQl9CisKKwkJKCphcmd2KSsrOworCQkoKmFyZ2MpLS07CisJCWhhbmRsZWQrKzsKKwl9CisJcmV0dXJuIGhhbmRsZWQ7Cit9CisKK3N0YXRpYyBpbnQgaGFuZGxlX2FsaWFzKGludCAqYXJnY3AsIGNvbnN0IGNoYXIgKioqYXJndikKK3sKKwlpbnQgZW52Y2hhbmdlZCA9IDAsIHJldCA9IDAsIHNhdmVkX2Vycm5vID0gZXJybm87CisJaW50IGNvdW50LCBvcHRpb25fY291bnQ7CisJY29uc3QgY2hhcioqIG5ld19hcmd2OworCWNvbnN0IGNoYXIgKmFsaWFzX2NvbW1hbmQ7CisJY2hhciAqYWxpYXNfc3RyaW5nOworCisJYWxpYXNfY29tbWFuZCA9ICgqYXJndilbMF07CisJYWxpYXNfc3RyaW5nID0gYWxpYXNfbG9va3VwKGFsaWFzX2NvbW1hbmQpOworCWlmIChhbGlhc19zdHJpbmcpIHsKKwkJaWYgKGFsaWFzX3N0cmluZ1swXSA9PSAnIScpIHsKKwkJCWlmICgqYXJnY3AgPiAxKSB7CisJCQkJc3RydWN0IHN0cmJ1ZiBidWY7CisKKwkJCQlzdHJidWZfaW5pdCgmYnVmLCBQQVRIX01BWCk7CisJCQkJc3RyYnVmX2FkZHN0cigmYnVmLCBhbGlhc19zdHJpbmcpOworCQkJCXNxX3F1b3RlX2FyZ3YoJmJ1ZiwgKCphcmd2KSArIDEsIFBBVEhfTUFYKTsKKwkJCQlmcmVlKGFsaWFzX3N0cmluZyk7CisJCQkJYWxpYXNfc3RyaW5nID0gYnVmLmJ1ZjsKKwkJCX0KKwkJCXJldCA9IHN5c3RlbShhbGlhc19zdHJpbmcgKyAxKTsKKwkJCWlmIChyZXQgPj0gMCAmJiBXSUZFWElURUQocmV0KSAmJgorCQkJICAgIFdFWElUU1RBVFVTKHJldCkgIT0gMTI3KQorCQkJCWV4aXQoV0VYSVRTVEFUVVMocmV0KSk7CisJCQlkaWUoIkZhaWxlZCB0byBydW4gJyVzJyB3aGVuIGV4cGFuZGluZyBhbGlhcyAnJXMnIiwKKwkJCSAgICBhbGlhc19zdHJpbmcgKyAxLCBhbGlhc19jb21tYW5kKTsKKwkJfQorCQljb3VudCA9IHNwbGl0X2NtZGxpbmUoYWxpYXNfc3RyaW5nLCAmbmV3X2FyZ3YpOworCQlpZiAoY291bnQgPCAwKQorCQkJZGllKCJCYWQgYWxpYXMuJXMgc3RyaW5nIiwgYWxpYXNfY29tbWFuZCk7CisJCW9wdGlvbl9jb3VudCA9IGhhbmRsZV9vcHRpb25zKCZuZXdfYXJndiwgJmNvdW50LCAmZW52Y2hhbmdlZCk7CisJCWlmIChlbnZjaGFuZ2VkKQorCQkJZGllKCJhbGlhcyAnJXMnIGNoYW5nZXMgZW52aXJvbm1lbnQgdmFyaWFibGVzXG4iCisJCQkJICJZb3UgY2FuIHVzZSAnIXBlcmYnIGluIHRoZSBhbGlhcyB0byBkbyB0aGlzLiIsCisJCQkJIGFsaWFzX2NvbW1hbmQpOworCQltZW1tb3ZlKG5ld19hcmd2IC0gb3B0aW9uX2NvdW50LCBuZXdfYXJndiwKKwkJCQljb3VudCAqIHNpemVvZihjaGFyICopKTsKKwkJbmV3X2FyZ3YgLT0gb3B0aW9uX2NvdW50OworCisJCWlmIChjb3VudCA8IDEpCisJCQlkaWUoImVtcHR5IGFsaWFzIGZvciAlcyIsIGFsaWFzX2NvbW1hbmQpOworCisJCWlmICghc3RyY21wKGFsaWFzX2NvbW1hbmQsIG5ld19hcmd2WzBdKSkKKwkJCWRpZSgicmVjdXJzaXZlIGFsaWFzOiAlcyIsIGFsaWFzX2NvbW1hbmQpOworCisJCW5ld19hcmd2ID0gcmVhbGxvYyhuZXdfYXJndiwgc2l6ZW9mKGNoYXIqKSAqCisJCQkJICAgIChjb3VudCArICphcmdjcCArIDEpKTsKKwkJLyogaW5zZXJ0IGFmdGVyIGNvbW1hbmQgbmFtZSAqLworCQltZW1jcHkobmV3X2FyZ3YgKyBjb3VudCwgKmFyZ3YgKyAxLCBzaXplb2YoY2hhciopICogKmFyZ2NwKTsKKwkJbmV3X2FyZ3ZbY291bnQrKmFyZ2NwXSA9IE5VTEw7CisKKwkJKmFyZ3YgPSBuZXdfYXJndjsKKwkJKmFyZ2NwICs9IGNvdW50IC0gMTsKKworCQlyZXQgPSAxOworCX0KKworCWVycm5vID0gc2F2ZWRfZXJybm87CisKKwlyZXR1cm4gcmV0OworfQorCitjb25zdCBjaGFyIHBlcmZfdmVyc2lvbl9zdHJpbmdbXSA9IFBFUkZfVkVSU0lPTjsKKworI2RlZmluZSBSVU5fU0VUVVAJKDE8PDApCisjZGVmaW5lIFVTRV9QQUdFUgkoMTw8MSkKKy8qCisgKiByZXF1aXJlIHdvcmtpbmcgdHJlZSB0byBiZSBwcmVzZW50IC0tIGFueXRoaW5nIHVzZXMgdGhpcyBuZWVkcworICogUlVOX1NFVFVQIGZvciByZWFkaW5nIGZyb20gdGhlIGNvbmZpZ3VyYXRpb24gZmlsZS4KKyAqLworI2RlZmluZSBORUVEX1dPUktfVFJFRQkoMTw8MikKKworc3RydWN0IGNtZF9zdHJ1Y3QgeworCWNvbnN0IGNoYXIgKmNtZDsKKwlpbnQgKCpmbikoaW50LCBjb25zdCBjaGFyICoqLCBjb25zdCBjaGFyICopOworCWludCBvcHRpb247Cit9OworCitzdGF0aWMgaW50IHJ1bl9idWlsdGluKHN0cnVjdCBjbWRfc3RydWN0ICpwLCBpbnQgYXJnYywgY29uc3QgY2hhciAqKmFyZ3YpCit7CisJaW50IHN0YXR1czsKKwlzdHJ1Y3Qgc3RhdCBzdDsKKwljb25zdCBjaGFyICpwcmVmaXg7CisKKwlwcmVmaXggPSBOVUxMOworCWlmIChwLT5vcHRpb24gJiBSVU5fU0VUVVApCisJCXByZWZpeCA9IE5VTEw7IC8qIHNldHVwX3BlcmZfZGlyZWN0b3J5KCk7ICovCisKKwlpZiAodXNlX3BhZ2VyID09IC0xICYmIHAtPm9wdGlvbiAmIFJVTl9TRVRVUCkKKwkJdXNlX3BhZ2VyID0gY2hlY2tfcGFnZXJfY29uZmlnKHAtPmNtZCk7CisJaWYgKHVzZV9wYWdlciA9PSAtMSAmJiBwLT5vcHRpb24gJiBVU0VfUEFHRVIpCisJCXVzZV9wYWdlciA9IDE7CisJY29tbWl0X3BhZ2VyX2Nob2ljZSgpOworCisJaWYgKHAtPm9wdGlvbiAmIE5FRURfV09SS19UUkVFKQorCQkvKiBzZXR1cF93b3JrX3RyZWUoKSAqLzsKKworCXN0YXR1cyA9IHAtPmZuKGFyZ2MsIGFyZ3YsIHByZWZpeCk7CisJaWYgKHN0YXR1cykKKwkJcmV0dXJuIHN0YXR1cyAmIDB4ZmY7CisKKwkvKiBTb21lYm9keSBjbG9zZWQgc3Rkb3V0PyAqLworCWlmIChmc3RhdChmaWxlbm8oc3Rkb3V0KSwgJnN0KSkKKwkJcmV0dXJuIDA7CisJLyogSWdub3JlIHdyaXRlIGVycm9ycyBmb3IgcGlwZXMgYW5kIHNvY2tldHMuLiAqLworCWlmIChTX0lTRklGTyhzdC5zdF9tb2RlKSB8fCBTX0lTU09DSyhzdC5zdF9tb2RlKSkKKwkJcmV0dXJuIDA7CisKKwkvKiBDaGVjayBmb3IgRU5PU1BDIGFuZCBFSU8gZXJyb3JzLi4gKi8KKwlpZiAoZmZsdXNoKHN0ZG91dCkpCisJCWRpZSgid3JpdGUgZmFpbHVyZSBvbiBzdGFuZGFyZCBvdXRwdXQ6ICVzIiwgc3RyZXJyb3IoZXJybm8pKTsKKwlpZiAoZmVycm9yKHN0ZG91dCkpCisJCWRpZSgidW5rbm93biB3cml0ZSBmYWlsdXJlIG9uIHN0YW5kYXJkIG91dHB1dCIpOworCWlmIChmY2xvc2Uoc3Rkb3V0KSkKKwkJZGllKCJjbG9zZSBmYWlsZWQgb24gc3RhbmRhcmQgb3V0cHV0OiAlcyIsIHN0cmVycm9yKGVycm5vKSk7CisJcmV0dXJuIDA7Cit9CisKK3N0YXRpYyB2b2lkIGhhbmRsZV9pbnRlcm5hbF9jb21tYW5kKGludCBhcmdjLCBjb25zdCBjaGFyICoqYXJndikKK3sKKwljb25zdCBjaGFyICpjbWQgPSBhcmd2WzBdOworCXN0YXRpYyBzdHJ1Y3QgY21kX3N0cnVjdCBjb21tYW5kc1tdID0geworCQl7ICJoZWxwIiwgY21kX2hlbHAsIDAgfSwKKwkJeyAibGlzdCIsIGNtZF9saXN0LCAwIH0sCisJCXsgInJlY29yZCIsIGNtZF9yZWNvcmQsIDAgfSwKKwkJeyAicmVwb3J0IiwgY21kX3JlcG9ydCwgMCB9LAorCQl7ICJzdGF0IiwgY21kX3N0YXQsIDAgfSwKKwkJeyAidG9wIiwgY21kX3RvcCwgMCB9LAorCQl7ICJhbm5vdGF0ZSIsIGNtZF9hbm5vdGF0ZSwgMCB9LAorCQl7ICJ2ZXJzaW9uIiwgY21kX3ZlcnNpb24sIDAgfSwKKwl9OworCWludCBpOworCXN0YXRpYyBjb25zdCBjaGFyIGV4dFtdID0gU1RSSVBfRVhURU5TSU9OOworCisJaWYgKHNpemVvZihleHQpID4gMSkgeworCQlpID0gc3RybGVuKGFyZ3ZbMF0pIC0gc3RybGVuKGV4dCk7CisJCWlmIChpID4gMCAmJiAhc3RyY21wKGFyZ3ZbMF0gKyBpLCBleHQpKSB7CisJCQljaGFyICphcmd2MCA9IHN0cmR1cChhcmd2WzBdKTsKKwkJCWFyZ3ZbMF0gPSBjbWQgPSBhcmd2MDsKKwkJCWFyZ3YwW2ldID0gJ1wwJzsKKwkJfQorCX0KKworCS8qIFR1cm4gInBlcmYgY21kIC0taGVscCIgaW50byAicGVyZiBoZWxwIGNtZCIgKi8KKwlpZiAoYXJnYyA+IDEgJiYgIXN0cmNtcChhcmd2WzFdLCAiLS1oZWxwIikpIHsKKwkJYXJndlsxXSA9IGFyZ3ZbMF07CisJCWFyZ3ZbMF0gPSBjbWQgPSAiaGVscCI7CisJfQorCisJZm9yIChpID0gMDsgaSA8IEFSUkFZX1NJWkUoY29tbWFuZHMpOyBpKyspIHsKKwkJc3RydWN0IGNtZF9zdHJ1Y3QgKnAgPSBjb21tYW5kcytpOworCQlpZiAoc3RyY21wKHAtPmNtZCwgY21kKSkKKwkJCWNvbnRpbnVlOworCQlleGl0KHJ1bl9idWlsdGluKHAsIGFyZ2MsIGFyZ3YpKTsKKwl9Cit9CisKK3N0YXRpYyB2b2lkIGV4ZWN2X2Rhc2hlZF9leHRlcm5hbChjb25zdCBjaGFyICoqYXJndikKK3sKKwlzdHJ1Y3Qgc3RyYnVmIGNtZCA9IFNUUkJVRl9JTklUOworCWNvbnN0IGNoYXIgKnRtcDsKKwlpbnQgc3RhdHVzOworCisJc3RyYnVmX2FkZGYoJmNtZCwgInBlcmYtJXMiLCBhcmd2WzBdKTsKKworCS8qCisJICogYXJndlswXSBtdXN0IGJlIHRoZSBwZXJmIGNvbW1hbmQsIGJ1dCB0aGUgYXJndiBhcnJheQorCSAqIGJlbG9uZ3MgdG8gdGhlIGNhbGxlciwgYW5kIG1heSBiZSByZXVzZWQgaW4KKwkgKiBzdWJzZXF1ZW50IGxvb3AgaXRlcmF0aW9ucy4gU2F2ZSBhcmd2WzBdIGFuZAorCSAqIHJlc3RvcmUgaXQgb24gZXJyb3IuCisJICovCisJdG1wID0gYXJndlswXTsKKwlhcmd2WzBdID0gY21kLmJ1ZjsKKworCS8qCisJICogaWYgd2UgZmFpbCBiZWNhdXNlIHRoZSBjb21tYW5kIGlzIG5vdCBmb3VuZCwgaXQgaXMKKwkgKiBPSyB0byByZXR1cm4uIE90aGVyd2lzZSwgd2UganVzdCBwYXNzIGFsb25nIHRoZSBzdGF0dXMgY29kZS4KKwkgKi8KKwlzdGF0dXMgPSBydW5fY29tbWFuZF92X29wdChhcmd2LCAwKTsKKwlpZiAoc3RhdHVzICE9IC1FUlJfUlVOX0NPTU1BTkRfRVhFQykgeworCQlpZiAoSVNfUlVOX0NPTU1BTkRfRVJSKHN0YXR1cykpCisJCQlkaWUoInVuYWJsZSB0byBydW4gJyVzJyIsIGFyZ3ZbMF0pOworCQlleGl0KC1zdGF0dXMpOworCX0KKwllcnJubyA9IEVOT0VOVDsgLyogYXMgaWYgd2UgY2FsbGVkIGV4ZWN2cCAqLworCisJYXJndlswXSA9IHRtcDsKKworCXN0cmJ1Zl9yZWxlYXNlKCZjbWQpOworfQorCitzdGF0aWMgaW50IHJ1bl9hcmd2KGludCAqYXJnY3AsIGNvbnN0IGNoYXIgKioqYXJndikKK3sKKwlpbnQgZG9uZV9hbGlhcyA9IDA7CisKKwl3aGlsZSAoMSkgeworCQkvKiBTZWUgaWYgaXQncyBhbiBpbnRlcm5hbCBjb21tYW5kICovCisJCWhhbmRsZV9pbnRlcm5hbF9jb21tYW5kKCphcmdjcCwgKmFyZ3YpOworCisJCS8qIC4uIHRoZW4gdHJ5IHRoZSBleHRlcm5hbCBvbmVzICovCisJCWV4ZWN2X2Rhc2hlZF9leHRlcm5hbCgqYXJndik7CisKKwkJLyogSXQgY291bGQgYmUgYW4gYWxpYXMgLS0gdGhpcyB3b3JrcyBhcm91bmQgdGhlIGluc2FuaXR5CisJCSAqIG9mIG92ZXJyaWRpbmcgInBlcmYgbG9nIiB3aXRoICJwZXJmIHNob3ciIGJ5IGhhdmluZworCQkgKiBhbGlhcy5sb2cgPSBzaG93CisJCSAqLworCQlpZiAoZG9uZV9hbGlhcyB8fCAhaGFuZGxlX2FsaWFzKGFyZ2NwLCBhcmd2KSkKKwkJCWJyZWFrOworCQlkb25lX2FsaWFzID0gMTsKKwl9CisKKwlyZXR1cm4gZG9uZV9hbGlhczsKK30KKworCitpbnQgbWFpbihpbnQgYXJnYywgY29uc3QgY2hhciAqKmFyZ3YpCit7CisJY29uc3QgY2hhciAqY21kOworCisJY21kID0gcGVyZl9leHRyYWN0X2FyZ3YwX3BhdGgoYXJndlswXSk7CisJaWYgKCFjbWQpCisJCWNtZCA9ICJwZXJmLWhlbHAiOworCisJLyoKKwkgKiAicGVyZi14eHh4IiBpcyB0aGUgc2FtZSBhcyAicGVyZiB4eHh4IiwgYnV0IHdlIG9idmlvdXNseToKKwkgKgorCSAqICAtIGNhbm5vdCB0YWtlIGZsYWdzIGluIGJldHdlZW4gdGhlICJwZXJmIiBhbmQgdGhlICJ4eHh4Ii4KKwkgKiAgLSBjYW5ub3QgZXhlY3V0ZSBpdCBleHRlcm5hbGx5IChzaW5jZSBpdCB3b3VsZCBqdXN0IGRvCisJICogICAgdGhlIHNhbWUgdGhpbmcgb3ZlciBhZ2FpbikKKwkgKgorCSAqIFNvIHdlIGp1c3QgZGlyZWN0bHkgY2FsbCB0aGUgaW50ZXJuYWwgY29tbWFuZCBoYW5kbGVyLCBhbmQKKwkgKiBkaWUgaWYgdGhhdCBvbmUgY2Fubm90IGhhbmRsZSBpdC4KKwkgKi8KKwlpZiAoIXByZWZpeGNtcChjbWQsICJwZXJmLSIpKSB7CisJCWNtZCArPSA1OworCQlhcmd2WzBdID0gY21kOworCQloYW5kbGVfaW50ZXJuYWxfY29tbWFuZChhcmdjLCBhcmd2KTsKKwkJZGllKCJjYW5ub3QgaGFuZGxlICVzIGludGVybmFsbHkiLCBjbWQpOworCX0KKworCS8qIExvb2sgZm9yIGZsYWdzLi4gKi8KKwlhcmd2Kys7CisJYXJnYy0tOworCWhhbmRsZV9vcHRpb25zKCZhcmd2LCAmYXJnYywgTlVMTCk7CisJY29tbWl0X3BhZ2VyX2Nob2ljZSgpOworCWlmIChhcmdjID4gMCkgeworCQlpZiAoIXByZWZpeGNtcChhcmd2WzBdLCAiLS0iKSkKKwkJCWFyZ3ZbMF0gKz0gMjsKKwl9IGVsc2UgeworCQkvKiBUaGUgdXNlciBkaWRuJ3Qgc3BlY2lmeSBhIGNvbW1hbmQ7IGdpdmUgdGhlbSBoZWxwICovCisJCXByaW50ZigiXG4gdXNhZ2U6ICVzXG5cbiIsIHBlcmZfdXNhZ2Vfc3RyaW5nKTsKKwkJbGlzdF9jb21tb25fY21kc19oZWxwKCk7CisJCXByaW50ZigiXG4gJXNcblxuIiwgcGVyZl9tb3JlX2luZm9fc3RyaW5nKTsKKwkJZXhpdCgxKTsKKwl9CisJY21kID0gYXJndlswXTsKKworCS8qCisJICogV2UgdXNlIFBBVEggdG8gZmluZCBwZXJmIGNvbW1hbmRzLCBidXQgd2UgcHJlcGVuZCBzb21lIGhpZ2hlcgorCSAqIHByZWNpZGVuY2UgcGF0aHM6IHRoZSAiLS1leGVjLXBhdGgiIG9wdGlvbiwgdGhlIFBFUkZfRVhFQ19QQVRICisJICogZW52aXJvbm1lbnQsIGFuZCB0aGUgJChwZXJmZXhlY2RpcikgZnJvbSB0aGUgTWFrZWZpbGUgYXQgYnVpbGQKKwkgKiB0aW1lLgorCSAqLworCXNldHVwX3BhdGgoKTsKKworCXdoaWxlICgxKSB7CisJCXN0YXRpYyBpbnQgZG9uZV9oZWxwID0gMDsKKwkJc3RhdGljIGludCB3YXNfYWxpYXMgPSAwOworCisJCXdhc19hbGlhcyA9IHJ1bl9hcmd2KCZhcmdjLCAmYXJndik7CisJCWlmIChlcnJubyAhPSBFTk9FTlQpCisJCQlicmVhazsKKworCQlpZiAod2FzX2FsaWFzKSB7CisJCQlmcHJpbnRmKHN0ZGVyciwgIkV4cGFuc2lvbiBvZiBhbGlhcyAnJXMnIGZhaWxlZDsgIgorCQkJCSInJXMnIGlzIG5vdCBhIHBlcmYtY29tbWFuZFxuIiwKKwkJCQljbWQsIGFyZ3ZbMF0pOworCQkJZXhpdCgxKTsKKwkJfQorCQlpZiAoIWRvbmVfaGVscCkgeworCQkJY21kID0gYXJndlswXSA9IGhlbHBfdW5rbm93bl9jbWQoY21kKTsKKwkJCWRvbmVfaGVscCA9IDE7CisJCX0gZWxzZQorCQkJYnJlYWs7CisJfQorCisJZnByaW50ZihzdGRlcnIsICJGYWlsZWQgdG8gcnVuIGNvbW1hbmQgJyVzJzogJXNcbiIsCisJCWNtZCwgc3RyZXJyb3IoZXJybm8pKTsKKworCXJldHVybiAxOworfQpkaWZmIC0tZ2l0IGEvdG9vbHMvcGVyZi9wZXJmLmggYi90b29scy9wZXJmL3BlcmYuaApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi5hZjBhNTA0Ci0tLSAvZGV2L251bGwKKysrIGIvdG9vbHMvcGVyZi9wZXJmLmgKQEAgLTAsMCArMSw2NyBAQAorI2lmbmRlZiBfUEVSRl9QRVJGX0gKKyNkZWZpbmUgX1BFUkZfUEVSRl9ICisKKyNpZiBkZWZpbmVkKF9feDg2XzY0X18pIHx8IGRlZmluZWQoX19pMzg2X18pCisjaW5jbHVkZSAiLi4vLi4vYXJjaC94ODYvaW5jbHVkZS9hc20vdW5pc3RkLmgiCisjZGVmaW5lIHJtYigpCQlhc20gdm9sYXRpbGUoImxmZW5jZSIgOjo6ICJtZW1vcnkiKQorI2RlZmluZSBjcHVfcmVsYXgoKQlhc20gdm9sYXRpbGUoInJlcDsgbm9wIiA6OjogIm1lbW9yeSIpOworI2VuZGlmCisKKyNpZmRlZiBfX3Bvd2VycGNfXworI2luY2x1ZGUgIi4uLy4uL2FyY2gvcG93ZXJwYy9pbmNsdWRlL2FzbS91bmlzdGQuaCIKKyNkZWZpbmUgcm1iKCkJCWFzbSB2b2xhdGlsZSAoInN5bmMiIDo6OiAibWVtb3J5IikKKyNkZWZpbmUgY3B1X3JlbGF4KCkJYXNtIHZvbGF0aWxlICgiIiA6OjogIm1lbW9yeSIpOworI2VuZGlmCisKKyNpbmNsdWRlIDx0aW1lLmg+CisjaW5jbHVkZSA8dW5pc3RkLmg+CisjaW5jbHVkZSA8c3lzL3R5cGVzLmg+CisjaW5jbHVkZSA8c3lzL3N5c2NhbGwuaD4KKworI2luY2x1ZGUgIi4uLy4uL2luY2x1ZGUvbGludXgvcGVyZl9jb3VudGVyLmgiCisKKy8qCisgKiBwcmN0bChQUl9UQVNLX1BFUkZfQ09VTlRFUlNfRElTQUJMRSkgd2lsbCAoY2hlYXBseSkgZGlzYWJsZSBhbGwKKyAqIGNvdW50ZXJzIGluIHRoZSBjdXJyZW50IHRhc2suCisgKi8KKyNkZWZpbmUgUFJfVEFTS19QRVJGX0NPVU5URVJTX0RJU0FCTEUgICAzMQorI2RlZmluZSBQUl9UQVNLX1BFUkZfQ09VTlRFUlNfRU5BQkxFICAgIDMyCisKKyNpZm5kZWYgTlNFQ19QRVJfU0VDCisjIGRlZmluZSBOU0VDX1BFUl9TRUMJCQkxMDAwMDAwMDAwVUxMCisjZW5kaWYKKworc3RhdGljIGlubGluZSB1bnNpZ25lZCBsb25nIGxvbmcgcmRjbG9jayh2b2lkKQoreworCXN0cnVjdCB0aW1lc3BlYyB0czsKKworCWNsb2NrX2dldHRpbWUoQ0xPQ0tfTU9OT1RPTklDLCAmdHMpOworCXJldHVybiB0cy50dl9zZWMgKiAxMDAwMDAwMDAwVUxMICsgdHMudHZfbnNlYzsKK30KKworLyoKKyAqIFBpY2sgdXAgc29tZSBrZXJuZWwgdHlwZSBjb252ZW50aW9uczoKKyAqLworI2RlZmluZSBfX3VzZXIKKyNkZWZpbmUgYXNtbGlua2FnZQorCisjZGVmaW5lIHVubGlrZWx5KHgpCV9fYnVpbHRpbl9leHBlY3QoISEoeCksIDApCisjZGVmaW5lIG1pbih4LCB5KSAoewkJCQlcCisJdHlwZW9mKHgpIF9taW4xID0gKHgpOwkJCVwKKwl0eXBlb2YoeSkgX21pbjIgPSAoeSk7CQkJXAorCSh2b2lkKSAoJl9taW4xID09ICZfbWluMik7CQlcCisJX21pbjEgPCBfbWluMiA/IF9taW4xIDogX21pbjI7IH0pCisKK3N0YXRpYyBpbmxpbmUgaW50CitzeXNfcGVyZl9jb3VudGVyX29wZW4oc3RydWN0IHBlcmZfY291bnRlcl9hdHRyICphdHRyX3VwdHIsCisJCSAgICAgIHBpZF90IHBpZCwgaW50IGNwdSwgaW50IGdyb3VwX2ZkLAorCQkgICAgICB1bnNpZ25lZCBsb25nIGZsYWdzKQoreworCXJldHVybiBzeXNjYWxsKF9fTlJfcGVyZl9jb3VudGVyX29wZW4sIGF0dHJfdXB0ciwgcGlkLCBjcHUsCisJCSAgICAgICBncm91cF9mZCwgZmxhZ3MpOworfQorCisjZGVmaW5lIE1BWF9DT1VOVEVSUwkJCTI1NgorI2RlZmluZSBNQVhfTlJfQ1BVUwkJCTI1NgorCisjZW5kaWYKZGlmZiAtLWdpdCBhL3Rvb2xzL3BlcmYvdXRpbC9QRVJGLVZFUlNJT04tR0VOIGIvdG9vbHMvcGVyZi91dGlsL1BFUkYtVkVSU0lPTi1HRU4KbmV3IGZpbGUgbW9kZSAxMDA3NTUKaW5kZXggMDAwMDAwMC4uYzU2MWQxNQotLS0gL2Rldi9udWxsCisrKyBiL3Rvb2xzL3BlcmYvdXRpbC9QRVJGLVZFUlNJT04tR0VOCkBAIC0wLDAgKzEsNDIgQEAKKyMhL2Jpbi9zaAorCitHVkY9UEVSRi1WRVJTSU9OLUZJTEUKK0RFRl9WRVI9djAuMC4xLlBFUkYKKworTEY9JworJworCisjIEZpcnN0IHNlZSBpZiB0aGVyZSBpcyBhIHZlcnNpb24gZmlsZSAoaW5jbHVkZWQgaW4gcmVsZWFzZSB0YXJiYWxscyksCisjIHRoZW4gdHJ5IGdpdC1kZXNjcmliZSwgdGhlbiBkZWZhdWx0LgoraWYgdGVzdCAtZiB2ZXJzaW9uCit0aGVuCisJVk49JChjYXQgdmVyc2lvbikgfHwgVk49IiRERUZfVkVSIgorZWxpZiB0ZXN0IC1kIC5naXQgLW8gLWYgLmdpdCAmJgorCVZOPSQoZ2l0IGRlc2NyaWJlIC0tYWJicmV2PTQgSEVBRCAyPi9kZXYvbnVsbCkgJiYKKwljYXNlICIkVk4iIGluCisJKiRMRiopIChleGl0IDEpIDs7CisJdlswLTldKikKKwkJZ2l0IHVwZGF0ZS1pbmRleCAtcSAtLXJlZnJlc2gKKwkJdGVzdCAteiAiJChnaXQgZGlmZi1pbmRleCAtLW5hbWUtb25seSBIRUFEIC0tKSIgfHwKKwkJVk49IiRWTi1kaXJ0eSIgOzsKKwllc2FjCit0aGVuCisJVk49JChlY2hvICIkVk4iIHwgc2VkIC1lICdzLy0vLi9nJyk7CitlbHNlCisJVk49IiRERUZfVkVSIgorZmkKKworVk49JChleHByICIkVk4iIDogdionXCguKlwpJykKKworaWYgdGVzdCAtciAkR1ZGCit0aGVuCisJVkM9JChzZWQgLWUgJ3MvXlBFUkZfVkVSU0lPTiA9IC8vJyA8JEdWRikKK2Vsc2UKKwlWQz11bnNldAorZmkKK3Rlc3QgIiRWTiIgPSAiJFZDIiB8fCB7CisJZWNobyA+JjIgIlBFUkZfVkVSU0lPTiA9ICRWTiIKKwllY2hvICJQRVJGX1ZFUlNJT04gPSAkVk4iID4kR1ZGCit9CisKKwpkaWZmIC0tZ2l0IGEvdG9vbHMvcGVyZi91dGlsL2Fic3BhdGguYyBiL3Rvb2xzL3BlcmYvdXRpbC9hYnNwYXRoLmMKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uNjFkMzNiOAotLS0gL2Rldi9udWxsCisrKyBiL3Rvb2xzL3BlcmYvdXRpbC9hYnNwYXRoLmMKQEAgLTAsMCArMSwxMTcgQEAKKyNpbmNsdWRlICJjYWNoZS5oIgorCisvKgorICogRG8gbm90IHVzZSB0aGlzIGZvciBpbnNwZWN0aW5nICp0cmFja2VkKiBjb250ZW50LiAgV2hlbiBwYXRoIGlzIGEKKyAqIHN5bWxpbmsgdG8gYSBkaXJlY3RvcnksIHdlIGRvIG5vdCB3YW50IHRvIHNheSBpdCBpcyBhIGRpcmVjdG9yeSB3aGVuCisgKiBkZWFsaW5nIHdpdGggdHJhY2tlZCBjb250ZW50IGluIHRoZSB3b3JraW5nIHRyZWUuCisgKi8KK3N0YXRpYyBpbnQgaXNfZGlyZWN0b3J5KGNvbnN0IGNoYXIgKnBhdGgpCit7CisJc3RydWN0IHN0YXQgc3Q7CisJcmV0dXJuICghc3RhdChwYXRoLCAmc3QpICYmIFNfSVNESVIoc3Quc3RfbW9kZSkpOworfQorCisvKiBXZSBhbGxvdyAicmVjdXJzaXZlIiBzeW1ib2xpYyBsaW5rcy4gT25seSB3aXRoaW4gcmVhc29uLCB0aG91Z2guICovCisjZGVmaW5lIE1BWERFUFRIIDUKKworY29uc3QgY2hhciAqbWFrZV9hYnNvbHV0ZV9wYXRoKGNvbnN0IGNoYXIgKnBhdGgpCit7CisJc3RhdGljIGNoYXIgYnVmc1syXVtQQVRIX01BWCArIDFdLCAqYnVmID0gYnVmc1swXSwgKm5leHRfYnVmID0gYnVmc1sxXTsKKwljaGFyIGN3ZFsxMDI0XSA9ICIiOworCWludCBidWZfaW5kZXggPSAxLCBsZW47CisKKwlpbnQgZGVwdGggPSBNQVhERVBUSDsKKwljaGFyICpsYXN0X2VsZW0gPSBOVUxMOworCXN0cnVjdCBzdGF0IHN0OworCisJaWYgKHN0cmxjcHkoYnVmLCBwYXRoLCBQQVRIX01BWCkgPj0gUEFUSF9NQVgpCisJCWRpZSAoIlRvbyBsb25nIHBhdGg6ICUuKnMiLCA2MCwgcGF0aCk7CisKKwl3aGlsZSAoZGVwdGgtLSkgeworCQlpZiAoIWlzX2RpcmVjdG9yeShidWYpKSB7CisJCQljaGFyICpsYXN0X3NsYXNoID0gc3RycmNocihidWYsICcvJyk7CisJCQlpZiAobGFzdF9zbGFzaCkgeworCQkJCSpsYXN0X3NsYXNoID0gJ1wwJzsKKwkJCQlsYXN0X2VsZW0gPSB4c3RyZHVwKGxhc3Rfc2xhc2ggKyAxKTsKKwkJCX0gZWxzZSB7CisJCQkJbGFzdF9lbGVtID0geHN0cmR1cChidWYpOworCQkJCSpidWYgPSAnXDAnOworCQkJfQorCQl9CisKKwkJaWYgKCpidWYpIHsKKwkJCWlmICghKmN3ZCAmJiAhZ2V0Y3dkKGN3ZCwgc2l6ZW9mKGN3ZCkpKQorCQkJCWRpZSAoIkNvdWxkIG5vdCBnZXQgY3VycmVudCB3b3JraW5nIGRpcmVjdG9yeSIpOworCisJCQlpZiAoY2hkaXIoYnVmKSkKKwkJCQlkaWUgKCJDb3VsZCBub3Qgc3dpdGNoIHRvICclcyciLCBidWYpOworCQl9CisJCWlmICghZ2V0Y3dkKGJ1ZiwgUEFUSF9NQVgpKQorCQkJZGllICgiQ291bGQgbm90IGdldCBjdXJyZW50IHdvcmtpbmcgZGlyZWN0b3J5Iik7CisKKwkJaWYgKGxhc3RfZWxlbSkgeworCQkJaW50IGxlbiA9IHN0cmxlbihidWYpOworCQkJaWYgKGxlbiArIHN0cmxlbihsYXN0X2VsZW0pICsgMiA+IFBBVEhfTUFYKQorCQkJCWRpZSAoIlRvbyBsb25nIHBhdGggbmFtZTogJyVzLyVzJyIsCisJCQkJCQlidWYsIGxhc3RfZWxlbSk7CisJCQlidWZbbGVuXSA9ICcvJzsKKwkJCXN0cmNweShidWYgKyBsZW4gKyAxLCBsYXN0X2VsZW0pOworCQkJZnJlZShsYXN0X2VsZW0pOworCQkJbGFzdF9lbGVtID0gTlVMTDsKKwkJfQorCisJCWlmICghbHN0YXQoYnVmLCAmc3QpICYmIFNfSVNMTksoc3Quc3RfbW9kZSkpIHsKKwkJCWxlbiA9IHJlYWRsaW5rKGJ1ZiwgbmV4dF9idWYsIFBBVEhfTUFYKTsKKwkJCWlmIChsZW4gPCAwKQorCQkJCWRpZSAoIkludmFsaWQgc3ltbGluazogJXMiLCBidWYpOworCQkJaWYgKFBBVEhfTUFYIDw9IGxlbikKKwkJCQlkaWUoInN5bWJvbGljIGxpbmsgdG9vIGxvbmc6ICVzIiwgYnVmKTsKKwkJCW5leHRfYnVmW2xlbl0gPSAnXDAnOworCQkJYnVmID0gbmV4dF9idWY7CisJCQlidWZfaW5kZXggPSAxIC0gYnVmX2luZGV4OworCQkJbmV4dF9idWYgPSBidWZzW2J1Zl9pbmRleF07CisJCX0gZWxzZQorCQkJYnJlYWs7CisJfQorCisJaWYgKCpjd2QgJiYgY2hkaXIoY3dkKSkKKwkJZGllICgiQ291bGQgbm90IGNoYW5nZSBiYWNrIHRvICclcyciLCBjd2QpOworCisJcmV0dXJuIGJ1ZjsKK30KKworc3RhdGljIGNvbnN0IGNoYXIgKmdldF9wd2RfY3dkKHZvaWQpCit7CisJc3RhdGljIGNoYXIgY3dkW1BBVEhfTUFYICsgMV07CisJY2hhciAqcHdkOworCXN0cnVjdCBzdGF0IGN3ZF9zdGF0LCBwd2Rfc3RhdDsKKwlpZiAoZ2V0Y3dkKGN3ZCwgUEFUSF9NQVgpID09IE5VTEwpCisJCXJldHVybiBOVUxMOworCXB3ZCA9IGdldGVudigiUFdEIik7CisJaWYgKHB3ZCAmJiBzdHJjbXAocHdkLCBjd2QpKSB7CisJCXN0YXQoY3dkLCAmY3dkX3N0YXQpOworCQlpZiAoIXN0YXQocHdkLCAmcHdkX3N0YXQpICYmCisJCSAgICBwd2Rfc3RhdC5zdF9kZXYgPT0gY3dkX3N0YXQuc3RfZGV2ICYmCisJCSAgICBwd2Rfc3RhdC5zdF9pbm8gPT0gY3dkX3N0YXQuc3RfaW5vKSB7CisJCQlzdHJsY3B5KGN3ZCwgcHdkLCBQQVRIX01BWCk7CisJCX0KKwl9CisJcmV0dXJuIGN3ZDsKK30KKworY29uc3QgY2hhciAqbWFrZV9ub25yZWxhdGl2ZV9wYXRoKGNvbnN0IGNoYXIgKnBhdGgpCit7CisJc3RhdGljIGNoYXIgYnVmW1BBVEhfTUFYICsgMV07CisKKwlpZiAoaXNfYWJzb2x1dGVfcGF0aChwYXRoKSkgeworCQlpZiAoc3RybGNweShidWYsIHBhdGgsIFBBVEhfTUFYKSA+PSBQQVRIX01BWCkKKwkJCWRpZSgiVG9vIGxvbmcgcGF0aDogJS4qcyIsIDYwLCBwYXRoKTsKKwl9IGVsc2UgeworCQljb25zdCBjaGFyICpjd2QgPSBnZXRfcHdkX2N3ZCgpOworCQlpZiAoIWN3ZCkKKwkJCWRpZSgiQ2Fubm90IGRldGVybWluZSB0aGUgY3VycmVudCB3b3JraW5nIGRpcmVjdG9yeSIpOworCQlpZiAoc25wcmludGYoYnVmLCBQQVRIX01BWCwgIiVzLyVzIiwgY3dkLCBwYXRoKSA+PSBQQVRIX01BWCkKKwkJCWRpZSgiVG9vIGxvbmcgcGF0aDogJS4qcyIsIDYwLCBwYXRoKTsKKwl9CisJcmV0dXJuIGJ1ZjsKK30KZGlmZiAtLWdpdCBhL3Rvb2xzL3BlcmYvdXRpbC9hbGlhcy5jIGIvdG9vbHMvcGVyZi91dGlsL2FsaWFzLmMKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uOWIzZGQyYgotLS0gL2Rldi9udWxsCisrKyBiL3Rvb2xzL3BlcmYvdXRpbC9hbGlhcy5jCkBAIC0wLDAgKzEsNzcgQEAKKyNpbmNsdWRlICJjYWNoZS5oIgorCitzdGF0aWMgY29uc3QgY2hhciAqYWxpYXNfa2V5Oworc3RhdGljIGNoYXIgKmFsaWFzX3ZhbDsKKworc3RhdGljIGludCBhbGlhc19sb29rdXBfY2IoY29uc3QgY2hhciAqaywgY29uc3QgY2hhciAqdiwgdm9pZCAqY2IpCit7CisJaWYgKCFwcmVmaXhjbXAoaywgImFsaWFzLiIpICYmICFzdHJjbXAoays2LCBhbGlhc19rZXkpKSB7CisJCWlmICghdikKKwkJCXJldHVybiBjb25maWdfZXJyb3Jfbm9uYm9vbChrKTsKKwkJYWxpYXNfdmFsID0gc3RyZHVwKHYpOworCQlyZXR1cm4gMDsKKwl9CisJcmV0dXJuIDA7Cit9CisKK2NoYXIgKmFsaWFzX2xvb2t1cChjb25zdCBjaGFyICphbGlhcykKK3sKKwlhbGlhc19rZXkgPSBhbGlhczsKKwlhbGlhc192YWwgPSBOVUxMOworCXBlcmZfY29uZmlnKGFsaWFzX2xvb2t1cF9jYiwgTlVMTCk7CisJcmV0dXJuIGFsaWFzX3ZhbDsKK30KKworaW50IHNwbGl0X2NtZGxpbmUoY2hhciAqY21kbGluZSwgY29uc3QgY2hhciAqKiphcmd2KQoreworCWludCBzcmMsIGRzdCwgY291bnQgPSAwLCBzaXplID0gMTY7CisJY2hhciBxdW90ZWQgPSAwOworCisJKmFyZ3YgPSBtYWxsb2Moc2l6ZW9mKGNoYXIqKSAqIHNpemUpOworCisJLyogc3BsaXQgYWxpYXNfc3RyaW5nICovCisJKCphcmd2KVtjb3VudCsrXSA9IGNtZGxpbmU7CisJZm9yIChzcmMgPSBkc3QgPSAwOyBjbWRsaW5lW3NyY107KSB7CisJCWNoYXIgYyA9IGNtZGxpbmVbc3JjXTsKKwkJaWYgKCFxdW90ZWQgJiYgaXNzcGFjZShjKSkgeworCQkJY21kbGluZVtkc3QrK10gPSAwOworCQkJd2hpbGUgKGNtZGxpbmVbKytzcmNdCisJCQkJCSYmIGlzc3BhY2UoY21kbGluZVtzcmNdKSkKKwkJCQk7IC8qIHNraXAgKi8KKwkJCWlmIChjb3VudCA+PSBzaXplKSB7CisJCQkJc2l6ZSArPSAxNjsKKwkJCQkqYXJndiA9IHJlYWxsb2MoKmFyZ3YsIHNpemVvZihjaGFyKikgKiBzaXplKTsKKwkJCX0KKwkJCSgqYXJndilbY291bnQrK10gPSBjbWRsaW5lICsgZHN0OworCQl9IGVsc2UgaWYgKCFxdW90ZWQgJiYgKGMgPT0gJ1wnJyB8fCBjID09ICciJykpIHsKKwkJCXF1b3RlZCA9IGM7CisJCQlzcmMrKzsKKwkJfSBlbHNlIGlmIChjID09IHF1b3RlZCkgeworCQkJcXVvdGVkID0gMDsKKwkJCXNyYysrOworCQl9IGVsc2UgeworCQkJaWYgKGMgPT0gJ1xcJyAmJiBxdW90ZWQgIT0gJ1wnJykgeworCQkJCXNyYysrOworCQkJCWMgPSBjbWRsaW5lW3NyY107CisJCQkJaWYgKCFjKSB7CisJCQkJCWZyZWUoKmFyZ3YpOworCQkJCQkqYXJndiA9IE5VTEw7CisJCQkJCXJldHVybiBlcnJvcigiY21kbGluZSBlbmRzIHdpdGggXFwiKTsKKwkJCQl9CisJCQl9CisJCQljbWRsaW5lW2RzdCsrXSA9IGM7CisJCQlzcmMrKzsKKwkJfQorCX0KKworCWNtZGxpbmVbZHN0XSA9IDA7CisKKwlpZiAocXVvdGVkKSB7CisJCWZyZWUoKmFyZ3YpOworCQkqYXJndiA9IE5VTEw7CisJCXJldHVybiBlcnJvcigidW5jbG9zZWQgcXVvdGUiKTsKKwl9CisKKwlyZXR1cm4gY291bnQ7Cit9CisKZGlmZiAtLWdpdCBhL3Rvb2xzL3BlcmYvdXRpbC9jYWNoZS5oIGIvdG9vbHMvcGVyZi91dGlsL2NhY2hlLmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uMzkzZDYxNAotLS0gL2Rldi9udWxsCisrKyBiL3Rvb2xzL3BlcmYvdXRpbC9jYWNoZS5oCkBAIC0wLDAgKzEsMTE5IEBACisjaWZuZGVmIENBQ0hFX0gKKyNkZWZpbmUgQ0FDSEVfSAorCisjaW5jbHVkZSAidXRpbC5oIgorI2luY2x1ZGUgInN0cmJ1Zi5oIgorCisjZGVmaW5lIFBFUkZfRElSX0VOVklST05NRU5UICJQRVJGX0RJUiIKKyNkZWZpbmUgUEVSRl9XT1JLX1RSRUVfRU5WSVJPTk1FTlQgIlBFUkZfV09SS19UUkVFIgorI2RlZmluZSBERUZBVUxUX1BFUkZfRElSX0VOVklST05NRU5UICIucGVyZiIKKyNkZWZpbmUgREJfRU5WSVJPTk1FTlQgIlBFUkZfT0JKRUNUX0RJUkVDVE9SWSIKKyNkZWZpbmUgSU5ERVhfRU5WSVJPTk1FTlQgIlBFUkZfSU5ERVhfRklMRSIKKyNkZWZpbmUgR1JBRlRfRU5WSVJPTk1FTlQgIlBFUkZfR1JBRlRfRklMRSIKKyNkZWZpbmUgVEVNUExBVEVfRElSX0VOVklST05NRU5UICJQRVJGX1RFTVBMQVRFX0RJUiIKKyNkZWZpbmUgQ09ORklHX0VOVklST05NRU5UICJQRVJGX0NPTkZJRyIKKyNkZWZpbmUgRVhFQ19QQVRIX0VOVklST05NRU5UICJQRVJGX0VYRUNfUEFUSCIKKyNkZWZpbmUgQ0VJTElOR19ESVJFQ1RPUklFU19FTlZJUk9OTUVOVCAiUEVSRl9DRUlMSU5HX0RJUkVDVE9SSUVTIgorI2RlZmluZSBQRVJGQVRUUklCVVRFU19GSUxFICIucGVyZmF0dHJpYnV0ZXMiCisjZGVmaW5lIElORk9BVFRSSUJVVEVTX0ZJTEUgImluZm8vYXR0cmlidXRlcyIKKyNkZWZpbmUgQVRUUklCVVRFX01BQ1JPX1BSRUZJWCAiW2F0dHJdIgorCit0eXBlZGVmIGludCAoKmNvbmZpZ19mbl90KShjb25zdCBjaGFyICosIGNvbnN0IGNoYXIgKiwgdm9pZCAqKTsKK2V4dGVybiBpbnQgcGVyZl9kZWZhdWx0X2NvbmZpZyhjb25zdCBjaGFyICosIGNvbnN0IGNoYXIgKiwgdm9pZCAqKTsKK2V4dGVybiBpbnQgcGVyZl9jb25maWdfZnJvbV9maWxlKGNvbmZpZ19mbl90IGZuLCBjb25zdCBjaGFyICosIHZvaWQgKik7CitleHRlcm4gaW50IHBlcmZfY29uZmlnKGNvbmZpZ19mbl90IGZuLCB2b2lkICopOworZXh0ZXJuIGludCBwZXJmX3BhcnNlX3Vsb25nKGNvbnN0IGNoYXIgKiwgdW5zaWduZWQgbG9uZyAqKTsKK2V4dGVybiBpbnQgcGVyZl9jb25maWdfaW50KGNvbnN0IGNoYXIgKiwgY29uc3QgY2hhciAqKTsKK2V4dGVybiB1bnNpZ25lZCBsb25nIHBlcmZfY29uZmlnX3Vsb25nKGNvbnN0IGNoYXIgKiwgY29uc3QgY2hhciAqKTsKK2V4dGVybiBpbnQgcGVyZl9jb25maWdfYm9vbF9vcl9pbnQoY29uc3QgY2hhciAqLCBjb25zdCBjaGFyICosIGludCAqKTsKK2V4dGVybiBpbnQgcGVyZl9jb25maWdfYm9vbChjb25zdCBjaGFyICosIGNvbnN0IGNoYXIgKik7CitleHRlcm4gaW50IHBlcmZfY29uZmlnX3N0cmluZyhjb25zdCBjaGFyICoqLCBjb25zdCBjaGFyICosIGNvbnN0IGNoYXIgKik7CitleHRlcm4gaW50IHBlcmZfY29uZmlnX3NldChjb25zdCBjaGFyICosIGNvbnN0IGNoYXIgKik7CitleHRlcm4gaW50IHBlcmZfY29uZmlnX3NldF9tdWx0aXZhcihjb25zdCBjaGFyICosIGNvbnN0IGNoYXIgKiwgY29uc3QgY2hhciAqLCBpbnQpOworZXh0ZXJuIGludCBwZXJmX2NvbmZpZ19yZW5hbWVfc2VjdGlvbihjb25zdCBjaGFyICosIGNvbnN0IGNoYXIgKik7CitleHRlcm4gY29uc3QgY2hhciAqcGVyZl9ldGNfcGVyZmNvbmZpZyh2b2lkKTsKK2V4dGVybiBpbnQgY2hlY2tfcmVwb3NpdG9yeV9mb3JtYXRfdmVyc2lvbihjb25zdCBjaGFyICp2YXIsIGNvbnN0IGNoYXIgKnZhbHVlLCB2b2lkICpjYik7CitleHRlcm4gaW50IHBlcmZfY29uZmlnX3N5c3RlbSh2b2lkKTsKK2V4dGVybiBpbnQgcGVyZl9jb25maWdfZ2xvYmFsKHZvaWQpOworZXh0ZXJuIGludCBjb25maWdfZXJyb3Jfbm9uYm9vbChjb25zdCBjaGFyICopOworZXh0ZXJuIGNvbnN0IGNoYXIgKmNvbmZpZ19leGNsdXNpdmVfZmlsZW5hbWU7CisKKyNkZWZpbmUgTUFYX1BFUkZOQU1FICgxMDAwKQorZXh0ZXJuIGNoYXIgcGVyZl9kZWZhdWx0X2VtYWlsW01BWF9QRVJGTkFNRV07CitleHRlcm4gY2hhciBwZXJmX2RlZmF1bHRfbmFtZVtNQVhfUEVSRk5BTUVdOworZXh0ZXJuIGludCB1c2VyX2lkZW50X2V4cGxpY2l0bHlfZ2l2ZW47CisKK2V4dGVybiBjb25zdCBjaGFyICpwZXJmX2xvZ19vdXRwdXRfZW5jb2Rpbmc7CitleHRlcm4gY29uc3QgY2hhciAqcGVyZl9tYWlsbWFwX2ZpbGU7CisKKy8qIElPIGhlbHBlciBmdW5jdGlvbnMgKi8KK2V4dGVybiB2b2lkIG1heWJlX2ZsdXNoX29yX2RpZShGSUxFICosIGNvbnN0IGNoYXIgKik7CitleHRlcm4gaW50IGNvcHlfZmQoaW50IGlmZCwgaW50IG9mZCk7CitleHRlcm4gaW50IGNvcHlfZmlsZShjb25zdCBjaGFyICpkc3QsIGNvbnN0IGNoYXIgKnNyYywgaW50IG1vZGUpOworZXh0ZXJuIHNzaXplX3QgcmVhZF9pbl9mdWxsKGludCBmZCwgdm9pZCAqYnVmLCBzaXplX3QgY291bnQpOworZXh0ZXJuIHNzaXplX3Qgd3JpdGVfaW5fZnVsbChpbnQgZmQsIGNvbnN0IHZvaWQgKmJ1Ziwgc2l6ZV90IGNvdW50KTsKK2V4dGVybiB2b2lkIHdyaXRlX29yX2RpZShpbnQgZmQsIGNvbnN0IHZvaWQgKmJ1Ziwgc2l6ZV90IGNvdW50KTsKK2V4dGVybiBpbnQgd3JpdGVfb3Jfd2hpbmUoaW50IGZkLCBjb25zdCB2b2lkICpidWYsIHNpemVfdCBjb3VudCwgY29uc3QgY2hhciAqbXNnKTsKK2V4dGVybiBpbnQgd3JpdGVfb3Jfd2hpbmVfcGlwZShpbnQgZmQsIGNvbnN0IHZvaWQgKmJ1Ziwgc2l6ZV90IGNvdW50LCBjb25zdCBjaGFyICptc2cpOworZXh0ZXJuIHZvaWQgZnN5bmNfb3JfZGllKGludCBmZCwgY29uc3QgY2hhciAqKTsKKworLyogcGFnZXIuYyAqLworZXh0ZXJuIHZvaWQgc2V0dXBfcGFnZXIodm9pZCk7CitleHRlcm4gY29uc3QgY2hhciAqcGFnZXJfcHJvZ3JhbTsKK2V4dGVybiBpbnQgcGFnZXJfaW5fdXNlKHZvaWQpOworZXh0ZXJuIGludCBwYWdlcl91c2VfY29sb3I7CisKK2V4dGVybiBjb25zdCBjaGFyICplZGl0b3JfcHJvZ3JhbTsKK2V4dGVybiBjb25zdCBjaGFyICpleGNsdWRlc19maWxlOworCitjaGFyICphbGlhc19sb29rdXAoY29uc3QgY2hhciAqYWxpYXMpOworaW50IHNwbGl0X2NtZGxpbmUoY2hhciAqY21kbGluZSwgY29uc3QgY2hhciAqKiphcmd2KTsKKworI2RlZmluZSBhbGxvY19ucih4KSAoKCh4KSsxNikqMy8yKQorCisvKgorICogUmVhbGxvYyB0aGUgYnVmZmVyIHBvaW50ZWQgYXQgYnkgdmFyaWFibGUgJ3gnIHNvIHRoYXQgaXQgY2FuIGhvbGQKKyAqIGF0IGxlYXN0ICducicgZW50cmllczsgdGhlIG51bWJlciBvZiBlbnRyaWVzIGN1cnJlbnRseSBhbGxvY2F0ZWQKKyAqIGlzICdhbGxvYycsIHVzaW5nIHRoZSBzdGFuZGFyZCBncm93aW5nIGZhY3RvciBhbGxvY19ucigpIG1hY3JvLgorICoKKyAqIERPIE5PVCBVU0UgYW55IGV4cHJlc3Npb24gd2l0aCBzaWRlLWVmZmVjdCBmb3IgJ3gnIG9yICdhbGxvYycuCisgKi8KKyNkZWZpbmUgQUxMT0NfR1JPVyh4LCBuciwgYWxsb2MpIFwKKwlkbyB7IFwKKwkJaWYgKChucikgPiBhbGxvYykgeyBcCisJCQlpZiAoYWxsb2NfbnIoYWxsb2MpIDwgKG5yKSkgXAorCQkJCWFsbG9jID0gKG5yKTsgXAorCQkJZWxzZSBcCisJCQkJYWxsb2MgPSBhbGxvY19ucihhbGxvYyk7IFwKKwkJCXggPSB4cmVhbGxvYygoeCksIGFsbG9jICogc2l6ZW9mKCooeCkpKTsgXAorCQl9IFwKKwl9IHdoaWxlKDApCisKKworc3RhdGljIGlubGluZSBpbnQgaXNfYWJzb2x1dGVfcGF0aChjb25zdCBjaGFyICpwYXRoKQoreworCXJldHVybiBwYXRoWzBdID09ICcvJzsKK30KKworY29uc3QgY2hhciAqbWFrZV9hYnNvbHV0ZV9wYXRoKGNvbnN0IGNoYXIgKnBhdGgpOworY29uc3QgY2hhciAqbWFrZV9ub25yZWxhdGl2ZV9wYXRoKGNvbnN0IGNoYXIgKnBhdGgpOworY29uc3QgY2hhciAqbWFrZV9yZWxhdGl2ZV9wYXRoKGNvbnN0IGNoYXIgKmFicywgY29uc3QgY2hhciAqYmFzZSk7CitpbnQgbm9ybWFsaXplX3BhdGhfY29weShjaGFyICpkc3QsIGNvbnN0IGNoYXIgKnNyYyk7CitpbnQgbG9uZ2VzdF9hbmNlc3Rvcl9sZW5ndGgoY29uc3QgY2hhciAqcGF0aCwgY29uc3QgY2hhciAqcHJlZml4X2xpc3QpOworY2hhciAqc3RyaXBfcGF0aF9zdWZmaXgoY29uc3QgY2hhciAqcGF0aCwgY29uc3QgY2hhciAqc3VmZml4KTsKKworZXh0ZXJuIGNoYXIgKm1rcGF0aChjb25zdCBjaGFyICpmbXQsIC4uLikgX19hdHRyaWJ1dGVfXygoZm9ybWF0IChwcmludGYsIDEsIDIpKSk7CitleHRlcm4gY2hhciAqcGVyZl9wYXRoKGNvbnN0IGNoYXIgKmZtdCwgLi4uKSBfX2F0dHJpYnV0ZV9fKChmb3JtYXQgKHByaW50ZiwgMSwgMikpKTsKKy8qIHBlcmZfbWtzdGVtcCgpIC0gY3JlYXRlIHRtcCBmaWxlIGhvbm9yaW5nIFRNUERJUiB2YXJpYWJsZSAqLworZXh0ZXJuIGludCBwZXJmX21rc3RlbXAoY2hhciAqcGF0aCwgc2l6ZV90IGxlbiwgY29uc3QgY2hhciAqdGVtcGxhdGUpOworCitleHRlcm4gY2hhciAqbWtzbnBhdGgoY2hhciAqYnVmLCBzaXplX3QgbiwgY29uc3QgY2hhciAqZm10LCAuLi4pCisJX19hdHRyaWJ1dGVfXygoZm9ybWF0IChwcmludGYsIDMsIDQpKSk7CitleHRlcm4gY2hhciAqcGVyZl9zbnBhdGgoY2hhciAqYnVmLCBzaXplX3QgbiwgY29uc3QgY2hhciAqZm10LCAuLi4pCisJX19hdHRyaWJ1dGVfXygoZm9ybWF0IChwcmludGYsIDMsIDQpKSk7CitleHRlcm4gY2hhciAqcGVyZl9wYXRoZHVwKGNvbnN0IGNoYXIgKmZtdCwgLi4uKQorCV9fYXR0cmlidXRlX18oKGZvcm1hdCAocHJpbnRmLCAxLCAyKSkpOworCitleHRlcm4gc2l6ZV90IHN0cmxjcHkoY2hhciAqZGVzdCwgY29uc3QgY2hhciAqc3JjLCBzaXplX3Qgc2l6ZSk7CisKKyNlbmRpZiAvKiBDQUNIRV9IICovCmRpZmYgLS1naXQgYS90b29scy9wZXJmL3V0aWwvY29sb3IuYyBiL3Rvb2xzL3BlcmYvdXRpbC9jb2xvci5jCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjlhOGMyMGMKLS0tIC9kZXYvbnVsbAorKysgYi90b29scy9wZXJmL3V0aWwvY29sb3IuYwpAQCAtMCwwICsxLDI0MSBAQAorI2luY2x1ZGUgImNhY2hlLmgiCisjaW5jbHVkZSAiY29sb3IuaCIKKworaW50IHBlcmZfdXNlX2NvbG9yX2RlZmF1bHQgPSAtMTsKKworc3RhdGljIGludCBwYXJzZV9jb2xvcihjb25zdCBjaGFyICpuYW1lLCBpbnQgbGVuKQoreworCXN0YXRpYyBjb25zdCBjaGFyICogY29uc3QgY29sb3JfbmFtZXNbXSA9IHsKKwkJIm5vcm1hbCIsICJibGFjayIsICJyZWQiLCAiZ3JlZW4iLCAieWVsbG93IiwKKwkJImJsdWUiLCAibWFnZW50YSIsICJjeWFuIiwgIndoaXRlIgorCX07CisJY2hhciAqZW5kOworCWludCBpOworCWZvciAoaSA9IDA7IGkgPCBBUlJBWV9TSVpFKGNvbG9yX25hbWVzKTsgaSsrKSB7CisJCWNvbnN0IGNoYXIgKnN0ciA9IGNvbG9yX25hbWVzW2ldOworCQlpZiAoIXN0cm5jYXNlY21wKG5hbWUsIHN0ciwgbGVuKSAmJiAhc3RyW2xlbl0pCisJCQlyZXR1cm4gaSAtIDE7CisJfQorCWkgPSBzdHJ0b2wobmFtZSwgJmVuZCwgMTApOworCWlmIChlbmQgLSBuYW1lID09IGxlbiAmJiBpID49IC0xICYmIGkgPD0gMjU1KQorCQlyZXR1cm4gaTsKKwlyZXR1cm4gLTI7Cit9CisKK3N0YXRpYyBpbnQgcGFyc2VfYXR0cihjb25zdCBjaGFyICpuYW1lLCBpbnQgbGVuKQoreworCXN0YXRpYyBjb25zdCBpbnQgYXR0cl92YWx1ZXNbXSA9IHsgMSwgMiwgNCwgNSwgNyB9OworCXN0YXRpYyBjb25zdCBjaGFyICogY29uc3QgYXR0cl9uYW1lc1tdID0geworCQkiYm9sZCIsICJkaW0iLCAidWwiLCAiYmxpbmsiLCAicmV2ZXJzZSIKKwl9OworCWludCBpOworCWZvciAoaSA9IDA7IGkgPCBBUlJBWV9TSVpFKGF0dHJfbmFtZXMpOyBpKyspIHsKKwkJY29uc3QgY2hhciAqc3RyID0gYXR0cl9uYW1lc1tpXTsKKwkJaWYgKCFzdHJuY2FzZWNtcChuYW1lLCBzdHIsIGxlbikgJiYgIXN0cltsZW5dKQorCQkJcmV0dXJuIGF0dHJfdmFsdWVzW2ldOworCX0KKwlyZXR1cm4gLTE7Cit9CisKK3ZvaWQgY29sb3JfcGFyc2UoY29uc3QgY2hhciAqdmFsdWUsIGNvbnN0IGNoYXIgKnZhciwgY2hhciAqZHN0KQoreworCWNvbG9yX3BhcnNlX21lbSh2YWx1ZSwgc3RybGVuKHZhbHVlKSwgdmFyLCBkc3QpOworfQorCit2b2lkIGNvbG9yX3BhcnNlX21lbShjb25zdCBjaGFyICp2YWx1ZSwgaW50IHZhbHVlX2xlbiwgY29uc3QgY2hhciAqdmFyLAorCQljaGFyICpkc3QpCit7CisJY29uc3QgY2hhciAqcHRyID0gdmFsdWU7CisJaW50IGxlbiA9IHZhbHVlX2xlbjsKKwlpbnQgYXR0ciA9IC0xOworCWludCBmZyA9IC0yOworCWludCBiZyA9IC0yOworCisJaWYgKCFzdHJuY2FzZWNtcCh2YWx1ZSwgInJlc2V0IiwgbGVuKSkgeworCQlzdHJjcHkoZHN0LCBQRVJGX0NPTE9SX1JFU0VUKTsKKwkJcmV0dXJuOworCX0KKworCS8qIFtmZyBbYmddXSBbYXR0cl0gKi8KKwl3aGlsZSAobGVuID4gMCkgeworCQljb25zdCBjaGFyICp3b3JkID0gcHRyOworCQlpbnQgdmFsLCB3b3JkbGVuID0gMDsKKworCQl3aGlsZSAobGVuID4gMCAmJiAhaXNzcGFjZSh3b3JkW3dvcmRsZW5dKSkgeworCQkJd29yZGxlbisrOworCQkJbGVuLS07CisJCX0KKworCQlwdHIgPSB3b3JkICsgd29yZGxlbjsKKwkJd2hpbGUgKGxlbiA+IDAgJiYgaXNzcGFjZSgqcHRyKSkgeworCQkJcHRyKys7CisJCQlsZW4tLTsKKwkJfQorCisJCXZhbCA9IHBhcnNlX2NvbG9yKHdvcmQsIHdvcmRsZW4pOworCQlpZiAodmFsID49IC0xKSB7CisJCQlpZiAoZmcgPT0gLTIpIHsKKwkJCQlmZyA9IHZhbDsKKwkJCQljb250aW51ZTsKKwkJCX0KKwkJCWlmIChiZyA9PSAtMikgeworCQkJCWJnID0gdmFsOworCQkJCWNvbnRpbnVlOworCQkJfQorCQkJZ290byBiYWQ7CisJCX0KKwkJdmFsID0gcGFyc2VfYXR0cih3b3JkLCB3b3JkbGVuKTsKKwkJaWYgKHZhbCA8IDAgfHwgYXR0ciAhPSAtMSkKKwkJCWdvdG8gYmFkOworCQlhdHRyID0gdmFsOworCX0KKworCWlmIChhdHRyID49IDAgfHwgZmcgPj0gMCB8fCBiZyA+PSAwKSB7CisJCWludCBzZXAgPSAwOworCisJCSpkc3QrKyA9ICdcMDMzJzsKKwkJKmRzdCsrID0gJ1snOworCQlpZiAoYXR0ciA+PSAwKSB7CisJCQkqZHN0KysgPSAnMCcgKyBhdHRyOworCQkJc2VwKys7CisJCX0KKwkJaWYgKGZnID49IDApIHsKKwkJCWlmIChzZXArKykKKwkJCQkqZHN0KysgPSAnOyc7CisJCQlpZiAoZmcgPCA4KSB7CisJCQkJKmRzdCsrID0gJzMnOworCQkJCSpkc3QrKyA9ICcwJyArIGZnOworCQkJfSBlbHNlIHsKKwkJCQlkc3QgKz0gc3ByaW50Zihkc3QsICIzODs1OyVkIiwgZmcpOworCQkJfQorCQl9CisJCWlmIChiZyA+PSAwKSB7CisJCQlpZiAoc2VwKyspCisJCQkJKmRzdCsrID0gJzsnOworCQkJaWYgKGJnIDwgOCkgeworCQkJCSpkc3QrKyA9ICc0JzsKKwkJCQkqZHN0KysgPSAnMCcgKyBiZzsKKwkJCX0gZWxzZSB7CisJCQkJZHN0ICs9IHNwcmludGYoZHN0LCAiNDg7NTslZCIsIGJnKTsKKwkJCX0KKwkJfQorCQkqZHN0KysgPSAnbSc7CisJfQorCSpkc3QgPSAwOworCXJldHVybjsKK2JhZDoKKwlkaWUoImJhZCBjb2xvciB2YWx1ZSAnJS4qcycgZm9yIHZhcmlhYmxlICclcyciLCB2YWx1ZV9sZW4sIHZhbHVlLCB2YXIpOworfQorCitpbnQgcGVyZl9jb25maWdfY29sb3Jib29sKGNvbnN0IGNoYXIgKnZhciwgY29uc3QgY2hhciAqdmFsdWUsIGludCBzdGRvdXRfaXNfdHR5KQoreworCWlmICh2YWx1ZSkgeworCQlpZiAoIXN0cmNhc2VjbXAodmFsdWUsICJuZXZlciIpKQorCQkJcmV0dXJuIDA7CisJCWlmICghc3RyY2FzZWNtcCh2YWx1ZSwgImFsd2F5cyIpKQorCQkJcmV0dXJuIDE7CisJCWlmICghc3RyY2FzZWNtcCh2YWx1ZSwgImF1dG8iKSkKKwkJCWdvdG8gYXV0b19jb2xvcjsKKwl9CisKKwkvKiBNaXNzaW5nIG9yIGV4cGxpY2l0IGZhbHNlIHRvIHR1cm4gb2ZmIGNvbG9yaXphdGlvbiAqLworCWlmICghcGVyZl9jb25maWdfYm9vbCh2YXIsIHZhbHVlKSkKKwkJcmV0dXJuIDA7CisKKwkvKiBhbnkgbm9ybWFsIHRydXRoIHZhbHVlIGRlZmF1bHRzIHRvICdhdXRvJyAqLworIGF1dG9fY29sb3I6CisJaWYgKHN0ZG91dF9pc190dHkgPCAwKQorCQlzdGRvdXRfaXNfdHR5ID0gaXNhdHR5KDEpOworCWlmIChzdGRvdXRfaXNfdHR5IHx8IChwYWdlcl9pbl91c2UoKSAmJiBwYWdlcl91c2VfY29sb3IpKSB7CisJCWNoYXIgKnRlcm0gPSBnZXRlbnYoIlRFUk0iKTsKKwkJaWYgKHRlcm0gJiYgc3RyY21wKHRlcm0sICJkdW1iIikpCisJCQlyZXR1cm4gMTsKKwl9CisJcmV0dXJuIDA7Cit9CisKK2ludCBwZXJmX2NvbG9yX2RlZmF1bHRfY29uZmlnKGNvbnN0IGNoYXIgKnZhciwgY29uc3QgY2hhciAqdmFsdWUsIHZvaWQgKmNiKQoreworCWlmICghc3RyY21wKHZhciwgImNvbG9yLnVpIikpIHsKKwkJcGVyZl91c2VfY29sb3JfZGVmYXVsdCA9IHBlcmZfY29uZmlnX2NvbG9yYm9vbCh2YXIsIHZhbHVlLCAtMSk7CisJCXJldHVybiAwOworCX0KKworCXJldHVybiBwZXJmX2RlZmF1bHRfY29uZmlnKHZhciwgdmFsdWUsIGNiKTsKK30KKworc3RhdGljIGludCBjb2xvcl92ZnByaW50ZihGSUxFICpmcCwgY29uc3QgY2hhciAqY29sb3IsIGNvbnN0IGNoYXIgKmZtdCwKKwkJdmFfbGlzdCBhcmdzLCBjb25zdCBjaGFyICp0cmFpbCkKK3sKKwlpbnQgciA9IDA7CisKKwkvKgorCSAqIEF1dG8tZGV0ZWN0OgorCSAqLworCWlmIChwZXJmX3VzZV9jb2xvcl9kZWZhdWx0IDwgMCkgeworCQlpZiAoaXNhdHR5KDEpIHx8IHBhZ2VyX2luX3VzZSgpKQorCQkJcGVyZl91c2VfY29sb3JfZGVmYXVsdCA9IDE7CisJCWVsc2UKKwkJCXBlcmZfdXNlX2NvbG9yX2RlZmF1bHQgPSAwOworCX0KKworCWlmIChwZXJmX3VzZV9jb2xvcl9kZWZhdWx0ICYmICpjb2xvcikKKwkJciArPSBmcHJpbnRmKGZwLCAiJXMiLCBjb2xvcik7CisJciArPSB2ZnByaW50ZihmcCwgZm10LCBhcmdzKTsKKwlpZiAocGVyZl91c2VfY29sb3JfZGVmYXVsdCAmJiAqY29sb3IpCisJCXIgKz0gZnByaW50ZihmcCwgIiVzIiwgUEVSRl9DT0xPUl9SRVNFVCk7CisJaWYgKHRyYWlsKQorCQlyICs9IGZwcmludGYoZnAsICIlcyIsIHRyYWlsKTsKKwlyZXR1cm4gcjsKK30KKworCisKK2ludCBjb2xvcl9mcHJpbnRmKEZJTEUgKmZwLCBjb25zdCBjaGFyICpjb2xvciwgY29uc3QgY2hhciAqZm10LCAuLi4pCit7CisJdmFfbGlzdCBhcmdzOworCWludCByOworCisJdmFfc3RhcnQoYXJncywgZm10KTsKKwlyID0gY29sb3JfdmZwcmludGYoZnAsIGNvbG9yLCBmbXQsIGFyZ3MsIE5VTEwpOworCXZhX2VuZChhcmdzKTsKKwlyZXR1cm4gcjsKK30KKworaW50IGNvbG9yX2ZwcmludGZfbG4oRklMRSAqZnAsIGNvbnN0IGNoYXIgKmNvbG9yLCBjb25zdCBjaGFyICpmbXQsIC4uLikKK3sKKwl2YV9saXN0IGFyZ3M7CisJaW50IHI7CisJdmFfc3RhcnQoYXJncywgZm10KTsKKwlyID0gY29sb3JfdmZwcmludGYoZnAsIGNvbG9yLCBmbXQsIGFyZ3MsICJcbiIpOworCXZhX2VuZChhcmdzKTsKKwlyZXR1cm4gcjsKK30KKworLyoKKyAqIFRoaXMgZnVuY3Rpb24gc3BsaXRzIHRoZSBidWZmZXIgYnkgbmV3bGluZXMgYW5kIGNvbG9ycyB0aGUgbGluZXMgaW5kaXZpZHVhbGx5LgorICoKKyAqIFJldHVybnMgMCBvbiBzdWNjZXNzLgorICovCitpbnQgY29sb3JfZndyaXRlX2xpbmVzKEZJTEUgKmZwLCBjb25zdCBjaGFyICpjb2xvciwKKwkJc2l6ZV90IGNvdW50LCBjb25zdCBjaGFyICpidWYpCit7CisJaWYgKCEqY29sb3IpCisJCXJldHVybiBmd3JpdGUoYnVmLCBjb3VudCwgMSwgZnApICE9IDE7CisJd2hpbGUgKGNvdW50KSB7CisJCWNoYXIgKnAgPSBtZW1jaHIoYnVmLCAnXG4nLCBjb3VudCk7CisJCWlmIChwICE9IGJ1ZiAmJiAoZnB1dHMoY29sb3IsIGZwKSA8IDAgfHwKKwkJCQlmd3JpdGUoYnVmLCBwID8gcCAtIGJ1ZiA6IGNvdW50LCAxLCBmcCkgIT0gMSB8fAorCQkJCWZwdXRzKFBFUkZfQ09MT1JfUkVTRVQsIGZwKSA8IDApKQorCQkJcmV0dXJuIC0xOworCQlpZiAoIXApCisJCQlyZXR1cm4gMDsKKwkJaWYgKGZwdXRjKCdcbicsIGZwKSA8IDApCisJCQlyZXR1cm4gLTE7CisJCWNvdW50IC09IHAgKyAxIC0gYnVmOworCQlidWYgPSBwICsgMTsKKwl9CisJcmV0dXJuIDA7Cit9CisKKwpkaWZmIC0tZ2l0IGEvdG9vbHMvcGVyZi91dGlsL2NvbG9yLmggYi90b29scy9wZXJmL3V0aWwvY29sb3IuaApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi41YWJmZDM3Ci0tLSAvZGV2L251bGwKKysrIGIvdG9vbHMvcGVyZi91dGlsL2NvbG9yLmgKQEAgLTAsMCArMSwzNiBAQAorI2lmbmRlZiBDT0xPUl9ICisjZGVmaW5lIENPTE9SX0gKKworLyogIlwwMzNbMTszODs1OzJ4eDs0ODs1OzJ4eG1cMCIgaXMgMjMgYnl0ZXMgKi8KKyNkZWZpbmUgQ09MT1JfTUFYTEVOIDI0CisKKyNkZWZpbmUgUEVSRl9DT0xPUl9OT1JNQUwJIiIKKyNkZWZpbmUgUEVSRl9DT0xPUl9SRVNFVAkiXDAzM1ttIgorI2RlZmluZSBQRVJGX0NPTE9SX0JPTEQJCSJcMDMzWzFtIgorI2RlZmluZSBQRVJGX0NPTE9SX1JFRAkJIlwwMzNbMzFtIgorI2RlZmluZSBQRVJGX0NPTE9SX0dSRUVOCSJcMDMzWzMybSIKKyNkZWZpbmUgUEVSRl9DT0xPUl9ZRUxMT1cJIlwwMzNbMzNtIgorI2RlZmluZSBQRVJGX0NPTE9SX0JMVUUJCSJcMDMzWzM0bSIKKyNkZWZpbmUgUEVSRl9DT0xPUl9NQUdFTlRBCSJcMDMzWzM1bSIKKyNkZWZpbmUgUEVSRl9DT0xPUl9DWUFOCQkiXDAzM1szNm0iCisjZGVmaW5lIFBFUkZfQ09MT1JfQkdfUkVECSJcMDMzWzQxbSIKKworLyoKKyAqIFRoaXMgdmFyaWFibGUgc3RvcmVzIHRoZSB2YWx1ZSBvZiBjb2xvci51aQorICovCitleHRlcm4gaW50IHBlcmZfdXNlX2NvbG9yX2RlZmF1bHQ7CisKKworLyoKKyAqIFVzZSB0aGlzIGluc3RlYWQgb2YgcGVyZl9kZWZhdWx0X2NvbmZpZyBpZiB5b3UgbmVlZCB0aGUgdmFsdWUgb2YgY29sb3IudWkuCisgKi8KK2ludCBwZXJmX2NvbG9yX2RlZmF1bHRfY29uZmlnKGNvbnN0IGNoYXIgKnZhciwgY29uc3QgY2hhciAqdmFsdWUsIHZvaWQgKmNiKTsKKworaW50IHBlcmZfY29uZmlnX2NvbG9yYm9vbChjb25zdCBjaGFyICp2YXIsIGNvbnN0IGNoYXIgKnZhbHVlLCBpbnQgc3Rkb3V0X2lzX3R0eSk7Cit2b2lkIGNvbG9yX3BhcnNlKGNvbnN0IGNoYXIgKnZhbHVlLCBjb25zdCBjaGFyICp2YXIsIGNoYXIgKmRzdCk7Cit2b2lkIGNvbG9yX3BhcnNlX21lbShjb25zdCBjaGFyICp2YWx1ZSwgaW50IGxlbiwgY29uc3QgY2hhciAqdmFyLCBjaGFyICpkc3QpOworaW50IGNvbG9yX2ZwcmludGYoRklMRSAqZnAsIGNvbnN0IGNoYXIgKmNvbG9yLCBjb25zdCBjaGFyICpmbXQsIC4uLik7CitpbnQgY29sb3JfZnByaW50Zl9sbihGSUxFICpmcCwgY29uc3QgY2hhciAqY29sb3IsIGNvbnN0IGNoYXIgKmZtdCwgLi4uKTsKK2ludCBjb2xvcl9md3JpdGVfbGluZXMoRklMRSAqZnAsIGNvbnN0IGNoYXIgKmNvbG9yLCBzaXplX3QgY291bnQsIGNvbnN0IGNoYXIgKmJ1Zik7CisKKyNlbmRpZiAvKiBDT0xPUl9IICovCmRpZmYgLS1naXQgYS90b29scy9wZXJmL3V0aWwvY29uZmlnLmMgYi90b29scy9wZXJmL3V0aWwvY29uZmlnLmMKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uM2RkMTNmYQotLS0gL2Rldi9udWxsCisrKyBiL3Rvb2xzL3BlcmYvdXRpbC9jb25maWcuYwpAQCAtMCwwICsxLDg3MyBAQAorLyoKKyAqIEdJVCAtIFRoZSBpbmZvcm1hdGlvbiBtYW5hZ2VyIGZyb20gaGVsbAorICoKKyAqIENvcHlyaWdodCAoQykgTGludXMgVG9ydmFsZHMsIDIwMDUKKyAqIENvcHlyaWdodCAoQykgSm9oYW5uZXMgU2NoaW5kZWxpbiwgMjAwNQorICoKKyAqLworI2luY2x1ZGUgInV0aWwuaCIKKyNpbmNsdWRlICJjYWNoZS5oIgorI2luY2x1ZGUgImV4ZWNfY21kLmgiCisKKyNkZWZpbmUgTUFYTkFNRSAoMjU2KQorCitzdGF0aWMgRklMRSAqY29uZmlnX2ZpbGU7CitzdGF0aWMgY29uc3QgY2hhciAqY29uZmlnX2ZpbGVfbmFtZTsKK3N0YXRpYyBpbnQgY29uZmlnX2xpbmVucjsKK3N0YXRpYyBpbnQgY29uZmlnX2ZpbGVfZW9mOworCitjb25zdCBjaGFyICpjb25maWdfZXhjbHVzaXZlX2ZpbGVuYW1lID0gTlVMTDsKKworc3RhdGljIGludCBnZXRfbmV4dF9jaGFyKHZvaWQpCit7CisJaW50IGM7CisJRklMRSAqZjsKKworCWMgPSAnXG4nOworCWlmICgoZiA9IGNvbmZpZ19maWxlKSAhPSBOVUxMKSB7CisJCWMgPSBmZ2V0YyhmKTsKKwkJaWYgKGMgPT0gJ1xyJykgeworCQkJLyogRE9TIGxpa2Ugc3lzdGVtcyAqLworCQkJYyA9IGZnZXRjKGYpOworCQkJaWYgKGMgIT0gJ1xuJykgeworCQkJCXVuZ2V0YyhjLCBmKTsKKwkJCQljID0gJ1xyJzsKKwkJCX0KKwkJfQorCQlpZiAoYyA9PSAnXG4nKQorCQkJY29uZmlnX2xpbmVucisrOworCQlpZiAoYyA9PSBFT0YpIHsKKwkJCWNvbmZpZ19maWxlX2VvZiA9IDE7CisJCQljID0gJ1xuJzsKKwkJfQorCX0KKwlyZXR1cm4gYzsKK30KKworc3RhdGljIGNoYXIgKnBhcnNlX3ZhbHVlKHZvaWQpCit7CisJc3RhdGljIGNoYXIgdmFsdWVbMTAyNF07CisJaW50IHF1b3RlID0gMCwgY29tbWVudCA9IDAsIGxlbiA9IDAsIHNwYWNlID0gMDsKKworCWZvciAoOzspIHsKKwkJaW50IGMgPSBnZXRfbmV4dF9jaGFyKCk7CisJCWlmIChsZW4gPj0gc2l6ZW9mKHZhbHVlKSAtIDEpCisJCQlyZXR1cm4gTlVMTDsKKwkJaWYgKGMgPT0gJ1xuJykgeworCQkJaWYgKHF1b3RlKQorCQkJCXJldHVybiBOVUxMOworCQkJdmFsdWVbbGVuXSA9IDA7CisJCQlyZXR1cm4gdmFsdWU7CisJCX0KKwkJaWYgKGNvbW1lbnQpCisJCQljb250aW51ZTsKKwkJaWYgKGlzc3BhY2UoYykgJiYgIXF1b3RlKSB7CisJCQlzcGFjZSA9IDE7CisJCQljb250aW51ZTsKKwkJfQorCQlpZiAoIXF1b3RlKSB7CisJCQlpZiAoYyA9PSAnOycgfHwgYyA9PSAnIycpIHsKKwkJCQljb21tZW50ID0gMTsKKwkJCQljb250aW51ZTsKKwkJCX0KKwkJfQorCQlpZiAoc3BhY2UpIHsKKwkJCWlmIChsZW4pCisJCQkJdmFsdWVbbGVuKytdID0gJyAnOworCQkJc3BhY2UgPSAwOworCQl9CisJCWlmIChjID09ICdcXCcpIHsKKwkJCWMgPSBnZXRfbmV4dF9jaGFyKCk7CisJCQlzd2l0Y2ggKGMpIHsKKwkJCWNhc2UgJ1xuJzoKKwkJCQljb250aW51ZTsKKwkJCWNhc2UgJ3QnOgorCQkJCWMgPSAnXHQnOworCQkJCWJyZWFrOworCQkJY2FzZSAnYic6CisJCQkJYyA9ICdcYic7CisJCQkJYnJlYWs7CisJCQljYXNlICduJzoKKwkJCQljID0gJ1xuJzsKKwkJCQlicmVhazsKKwkJCS8qIFNvbWUgY2hhcmFjdGVycyBlc2NhcGUgYXMgdGhlbXNlbHZlcyAqLworCQkJY2FzZSAnXFwnOiBjYXNlICciJzoKKwkJCQlicmVhazsKKwkJCS8qIFJlamVjdCB1bmtub3duIGVzY2FwZSBzZXF1ZW5jZXMgKi8KKwkJCWRlZmF1bHQ6CisJCQkJcmV0dXJuIE5VTEw7CisJCQl9CisJCQl2YWx1ZVtsZW4rK10gPSBjOworCQkJY29udGludWU7CisJCX0KKwkJaWYgKGMgPT0gJyInKSB7CisJCQlxdW90ZSA9IDEtcXVvdGU7CisJCQljb250aW51ZTsKKwkJfQorCQl2YWx1ZVtsZW4rK10gPSBjOworCX0KK30KKworc3RhdGljIGlubGluZSBpbnQgaXNrZXljaGFyKGludCBjKQoreworCXJldHVybiBpc2FsbnVtKGMpIHx8IGMgPT0gJy0nOworfQorCitzdGF0aWMgaW50IGdldF92YWx1ZShjb25maWdfZm5fdCBmbiwgdm9pZCAqZGF0YSwgY2hhciAqbmFtZSwgdW5zaWduZWQgaW50IGxlbikKK3sKKwlpbnQgYzsKKwljaGFyICp2YWx1ZTsKKworCS8qIEdldCB0aGUgZnVsbCBuYW1lICovCisJZm9yICg7OykgeworCQljID0gZ2V0X25leHRfY2hhcigpOworCQlpZiAoY29uZmlnX2ZpbGVfZW9mKQorCQkJYnJlYWs7CisJCWlmICghaXNrZXljaGFyKGMpKQorCQkJYnJlYWs7CisJCW5hbWVbbGVuKytdID0gdG9sb3dlcihjKTsKKwkJaWYgKGxlbiA+PSBNQVhOQU1FKQorCQkJcmV0dXJuIC0xOworCX0KKwluYW1lW2xlbl0gPSAwOworCXdoaWxlIChjID09ICcgJyB8fCBjID09ICdcdCcpCisJCWMgPSBnZXRfbmV4dF9jaGFyKCk7CisKKwl2YWx1ZSA9IE5VTEw7CisJaWYgKGMgIT0gJ1xuJykgeworCQlpZiAoYyAhPSAnPScpCisJCQlyZXR1cm4gLTE7CisJCXZhbHVlID0gcGFyc2VfdmFsdWUoKTsKKwkJaWYgKCF2YWx1ZSkKKwkJCXJldHVybiAtMTsKKwl9CisJcmV0dXJuIGZuKG5hbWUsIHZhbHVlLCBkYXRhKTsKK30KKworc3RhdGljIGludCBnZXRfZXh0ZW5kZWRfYmFzZV92YXIoY2hhciAqbmFtZSwgaW50IGJhc2VsZW4sIGludCBjKQoreworCWRvIHsKKwkJaWYgKGMgPT0gJ1xuJykKKwkJCXJldHVybiAtMTsKKwkJYyA9IGdldF9uZXh0X2NoYXIoKTsKKwl9IHdoaWxlIChpc3NwYWNlKGMpKTsKKworCS8qIFdlIHJlcXVpcmUgdGhlIGZvcm1hdCB0byBiZSAnW2Jhc2UgImV4dGVuc2lvbiJdJyAqLworCWlmIChjICE9ICciJykKKwkJcmV0dXJuIC0xOworCW5hbWVbYmFzZWxlbisrXSA9ICcuJzsKKworCWZvciAoOzspIHsKKwkJaW50IGMgPSBnZXRfbmV4dF9jaGFyKCk7CisJCWlmIChjID09ICdcbicpCisJCQlyZXR1cm4gLTE7CisJCWlmIChjID09ICciJykKKwkJCWJyZWFrOworCQlpZiAoYyA9PSAnXFwnKSB7CisJCQljID0gZ2V0X25leHRfY2hhcigpOworCQkJaWYgKGMgPT0gJ1xuJykKKwkJCQlyZXR1cm4gLTE7CisJCX0KKwkJbmFtZVtiYXNlbGVuKytdID0gYzsKKwkJaWYgKGJhc2VsZW4gPiBNQVhOQU1FIC8gMikKKwkJCXJldHVybiAtMTsKKwl9CisKKwkvKiBGaW5hbCAnXScgKi8KKwlpZiAoZ2V0X25leHRfY2hhcigpICE9ICddJykKKwkJcmV0dXJuIC0xOworCXJldHVybiBiYXNlbGVuOworfQorCitzdGF0aWMgaW50IGdldF9iYXNlX3ZhcihjaGFyICpuYW1lKQoreworCWludCBiYXNlbGVuID0gMDsKKworCWZvciAoOzspIHsKKwkJaW50IGMgPSBnZXRfbmV4dF9jaGFyKCk7CisJCWlmIChjb25maWdfZmlsZV9lb2YpCisJCQlyZXR1cm4gLTE7CisJCWlmIChjID09ICddJykKKwkJCXJldHVybiBiYXNlbGVuOworCQlpZiAoaXNzcGFjZShjKSkKKwkJCXJldHVybiBnZXRfZXh0ZW5kZWRfYmFzZV92YXIobmFtZSwgYmFzZWxlbiwgYyk7CisJCWlmICghaXNrZXljaGFyKGMpICYmIGMgIT0gJy4nKQorCQkJcmV0dXJuIC0xOworCQlpZiAoYmFzZWxlbiA+IE1BWE5BTUUgLyAyKQorCQkJcmV0dXJuIC0xOworCQluYW1lW2Jhc2VsZW4rK10gPSB0b2xvd2VyKGMpOworCX0KK30KKworc3RhdGljIGludCBwZXJmX3BhcnNlX2ZpbGUoY29uZmlnX2ZuX3QgZm4sIHZvaWQgKmRhdGEpCit7CisJaW50IGNvbW1lbnQgPSAwOworCWludCBiYXNlbGVuID0gMDsKKwlzdGF0aWMgY2hhciB2YXJbTUFYTkFNRV07CisKKwkvKiBVK0ZFRkYgQnl0ZSBPcmRlciBNYXJrIGluIFVURjggKi8KKwlzdGF0aWMgY29uc3QgdW5zaWduZWQgY2hhciAqdXRmOF9ib20gPSAodW5zaWduZWQgY2hhciAqKSAiXHhlZlx4YmJceGJmIjsKKwljb25zdCB1bnNpZ25lZCBjaGFyICpib21wdHIgPSB1dGY4X2JvbTsKKworCWZvciAoOzspIHsKKwkJaW50IGMgPSBnZXRfbmV4dF9jaGFyKCk7CisJCWlmIChib21wdHIgJiYgKmJvbXB0cikgeworCQkJLyogV2UgYXJlIGF0IHRoZSBmaWxlIGJlZ2lubmluZzsgc2tpcCBVVEY4LWVuY29kZWQgQk9NCisJCQkgKiBpZiBwcmVzZW50LiBTYW5lIGVkaXRvcnMgd29uJ3QgcHV0IHRoaXMgaW4gb24gdGhlaXIKKwkJCSAqIG93biwgYnV0IGUuZy4gV2luZG93cyBOb3RlcGFkIHdpbGwgZG8gaXQgaGFwcGlseS4gKi8KKwkJCWlmICgodW5zaWduZWQgY2hhcikgYyA9PSAqYm9tcHRyKSB7CisJCQkJYm9tcHRyKys7CisJCQkJY29udGludWU7CisJCQl9IGVsc2UgeworCQkJCS8qIERvIG5vdCB0b2xlcmF0ZSBwYXJ0aWFsIEJPTS4gKi8KKwkJCQlpZiAoYm9tcHRyICE9IHV0ZjhfYm9tKQorCQkJCQlicmVhazsKKwkJCQkvKiBObyBCT00gYXQgZmlsZSBiZWdpbm5pbmcuIENvb2wuICovCisJCQkJYm9tcHRyID0gTlVMTDsKKwkJCX0KKwkJfQorCQlpZiAoYyA9PSAnXG4nKSB7CisJCQlpZiAoY29uZmlnX2ZpbGVfZW9mKQorCQkJCXJldHVybiAwOworCQkJY29tbWVudCA9IDA7CisJCQljb250aW51ZTsKKwkJfQorCQlpZiAoY29tbWVudCB8fCBpc3NwYWNlKGMpKQorCQkJY29udGludWU7CisJCWlmIChjID09ICcjJyB8fCBjID09ICc7JykgeworCQkJY29tbWVudCA9IDE7CisJCQljb250aW51ZTsKKwkJfQorCQlpZiAoYyA9PSAnWycpIHsKKwkJCWJhc2VsZW4gPSBnZXRfYmFzZV92YXIodmFyKTsKKwkJCWlmIChiYXNlbGVuIDw9IDApCisJCQkJYnJlYWs7CisJCQl2YXJbYmFzZWxlbisrXSA9ICcuJzsKKwkJCXZhcltiYXNlbGVuXSA9IDA7CisJCQljb250aW51ZTsKKwkJfQorCQlpZiAoIWlzYWxwaGEoYykpCisJCQlicmVhazsKKwkJdmFyW2Jhc2VsZW5dID0gdG9sb3dlcihjKTsKKwkJaWYgKGdldF92YWx1ZShmbiwgZGF0YSwgdmFyLCBiYXNlbGVuKzEpIDwgMCkKKwkJCWJyZWFrOworCX0KKwlkaWUoImJhZCBjb25maWcgZmlsZSBsaW5lICVkIGluICVzIiwgY29uZmlnX2xpbmVuciwgY29uZmlnX2ZpbGVfbmFtZSk7Cit9CisKK3N0YXRpYyBpbnQgcGFyc2VfdW5pdF9mYWN0b3IoY29uc3QgY2hhciAqZW5kLCB1bnNpZ25lZCBsb25nICp2YWwpCit7CisJaWYgKCEqZW5kKQorCQlyZXR1cm4gMTsKKwllbHNlIGlmICghc3RyY2FzZWNtcChlbmQsICJrIikpIHsKKwkJKnZhbCAqPSAxMDI0OworCQlyZXR1cm4gMTsKKwl9CisJZWxzZSBpZiAoIXN0cmNhc2VjbXAoZW5kLCAibSIpKSB7CisJCSp2YWwgKj0gMTAyNCAqIDEwMjQ7CisJCXJldHVybiAxOworCX0KKwllbHNlIGlmICghc3RyY2FzZWNtcChlbmQsICJnIikpIHsKKwkJKnZhbCAqPSAxMDI0ICogMTAyNCAqIDEwMjQ7CisJCXJldHVybiAxOworCX0KKwlyZXR1cm4gMDsKK30KKworc3RhdGljIGludCBwZXJmX3BhcnNlX2xvbmcoY29uc3QgY2hhciAqdmFsdWUsIGxvbmcgKnJldCkKK3sKKwlpZiAodmFsdWUgJiYgKnZhbHVlKSB7CisJCWNoYXIgKmVuZDsKKwkJbG9uZyB2YWwgPSBzdHJ0b2wodmFsdWUsICZlbmQsIDApOworCQl1bnNpZ25lZCBsb25nIGZhY3RvciA9IDE7CisJCWlmICghcGFyc2VfdW5pdF9mYWN0b3IoZW5kLCAmZmFjdG9yKSkKKwkJCXJldHVybiAwOworCQkqcmV0ID0gdmFsICogZmFjdG9yOworCQlyZXR1cm4gMTsKKwl9CisJcmV0dXJuIDA7Cit9CisKK2ludCBwZXJmX3BhcnNlX3Vsb25nKGNvbnN0IGNoYXIgKnZhbHVlLCB1bnNpZ25lZCBsb25nICpyZXQpCit7CisJaWYgKHZhbHVlICYmICp2YWx1ZSkgeworCQljaGFyICplbmQ7CisJCXVuc2lnbmVkIGxvbmcgdmFsID0gc3RydG91bCh2YWx1ZSwgJmVuZCwgMCk7CisJCWlmICghcGFyc2VfdW5pdF9mYWN0b3IoZW5kLCAmdmFsKSkKKwkJCXJldHVybiAwOworCQkqcmV0ID0gdmFsOworCQlyZXR1cm4gMTsKKwl9CisJcmV0dXJuIDA7Cit9CisKK3N0YXRpYyB2b2lkIGRpZV9iYWRfY29uZmlnKGNvbnN0IGNoYXIgKm5hbWUpCit7CisJaWYgKGNvbmZpZ19maWxlX25hbWUpCisJCWRpZSgiYmFkIGNvbmZpZyB2YWx1ZSBmb3IgJyVzJyBpbiAlcyIsIG5hbWUsIGNvbmZpZ19maWxlX25hbWUpOworCWRpZSgiYmFkIGNvbmZpZyB2YWx1ZSBmb3IgJyVzJyIsIG5hbWUpOworfQorCitpbnQgcGVyZl9jb25maWdfaW50KGNvbnN0IGNoYXIgKm5hbWUsIGNvbnN0IGNoYXIgKnZhbHVlKQoreworCWxvbmcgcmV0ID0gMDsKKwlpZiAoIXBlcmZfcGFyc2VfbG9uZyh2YWx1ZSwgJnJldCkpCisJCWRpZV9iYWRfY29uZmlnKG5hbWUpOworCXJldHVybiByZXQ7Cit9CisKK3Vuc2lnbmVkIGxvbmcgcGVyZl9jb25maWdfdWxvbmcoY29uc3QgY2hhciAqbmFtZSwgY29uc3QgY2hhciAqdmFsdWUpCit7CisJdW5zaWduZWQgbG9uZyByZXQ7CisJaWYgKCFwZXJmX3BhcnNlX3Vsb25nKHZhbHVlLCAmcmV0KSkKKwkJZGllX2JhZF9jb25maWcobmFtZSk7CisJcmV0dXJuIHJldDsKK30KKworaW50IHBlcmZfY29uZmlnX2Jvb2xfb3JfaW50KGNvbnN0IGNoYXIgKm5hbWUsIGNvbnN0IGNoYXIgKnZhbHVlLCBpbnQgKmlzX2Jvb2wpCit7CisJKmlzX2Jvb2wgPSAxOworCWlmICghdmFsdWUpCisJCXJldHVybiAxOworCWlmICghKnZhbHVlKQorCQlyZXR1cm4gMDsKKwlpZiAoIXN0cmNhc2VjbXAodmFsdWUsICJ0cnVlIikgfHwgIXN0cmNhc2VjbXAodmFsdWUsICJ5ZXMiKSB8fCAhc3RyY2FzZWNtcCh2YWx1ZSwgIm9uIikpCisJCXJldHVybiAxOworCWlmICghc3RyY2FzZWNtcCh2YWx1ZSwgImZhbHNlIikgfHwgIXN0cmNhc2VjbXAodmFsdWUsICJubyIpIHx8ICFzdHJjYXNlY21wKHZhbHVlLCAib2ZmIikpCisJCXJldHVybiAwOworCSppc19ib29sID0gMDsKKwlyZXR1cm4gcGVyZl9jb25maWdfaW50KG5hbWUsIHZhbHVlKTsKK30KKworaW50IHBlcmZfY29uZmlnX2Jvb2woY29uc3QgY2hhciAqbmFtZSwgY29uc3QgY2hhciAqdmFsdWUpCit7CisJaW50IGRpc2NhcmQ7CisJcmV0dXJuICEhcGVyZl9jb25maWdfYm9vbF9vcl9pbnQobmFtZSwgdmFsdWUsICZkaXNjYXJkKTsKK30KKworaW50IHBlcmZfY29uZmlnX3N0cmluZyhjb25zdCBjaGFyICoqZGVzdCwgY29uc3QgY2hhciAqdmFyLCBjb25zdCBjaGFyICp2YWx1ZSkKK3sKKwlpZiAoIXZhbHVlKQorCQlyZXR1cm4gY29uZmlnX2Vycm9yX25vbmJvb2wodmFyKTsKKwkqZGVzdCA9IHN0cmR1cCh2YWx1ZSk7CisJcmV0dXJuIDA7Cit9CisKK3N0YXRpYyBpbnQgcGVyZl9kZWZhdWx0X2NvcmVfY29uZmlnKGNvbnN0IGNoYXIgKnZhciwgY29uc3QgY2hhciAqdmFsdWUpCit7CisJLyogQWRkIG90aGVyIGNvbmZpZyB2YXJpYWJsZXMgaGVyZSBhbmQgdG8gRG9jdW1lbnRhdGlvbi9jb25maWcudHh0LiAqLworCXJldHVybiAwOworfQorCitpbnQgcGVyZl9kZWZhdWx0X2NvbmZpZyhjb25zdCBjaGFyICp2YXIsIGNvbnN0IGNoYXIgKnZhbHVlLCB2b2lkICpkdW1teSkKK3sKKwlpZiAoIXByZWZpeGNtcCh2YXIsICJjb3JlLiIpKQorCQlyZXR1cm4gcGVyZl9kZWZhdWx0X2NvcmVfY29uZmlnKHZhciwgdmFsdWUpOworCisJLyogQWRkIG90aGVyIGNvbmZpZyB2YXJpYWJsZXMgaGVyZSBhbmQgdG8gRG9jdW1lbnRhdGlvbi9jb25maWcudHh0LiAqLworCXJldHVybiAwOworfQorCitpbnQgcGVyZl9jb25maWdfZnJvbV9maWxlKGNvbmZpZ19mbl90IGZuLCBjb25zdCBjaGFyICpmaWxlbmFtZSwgdm9pZCAqZGF0YSkKK3sKKwlpbnQgcmV0OworCUZJTEUgKmYgPSBmb3BlbihmaWxlbmFtZSwgInIiKTsKKworCXJldCA9IC0xOworCWlmIChmKSB7CisJCWNvbmZpZ19maWxlID0gZjsKKwkJY29uZmlnX2ZpbGVfbmFtZSA9IGZpbGVuYW1lOworCQljb25maWdfbGluZW5yID0gMTsKKwkJY29uZmlnX2ZpbGVfZW9mID0gMDsKKwkJcmV0ID0gcGVyZl9wYXJzZV9maWxlKGZuLCBkYXRhKTsKKwkJZmNsb3NlKGYpOworCQljb25maWdfZmlsZV9uYW1lID0gTlVMTDsKKwl9CisJcmV0dXJuIHJldDsKK30KKworY29uc3QgY2hhciAqcGVyZl9ldGNfcGVyZmNvbmZpZyh2b2lkKQoreworCXN0YXRpYyBjb25zdCBjaGFyICpzeXN0ZW1fd2lkZTsKKwlpZiAoIXN5c3RlbV93aWRlKQorCQlzeXN0ZW1fd2lkZSA9IHN5c3RlbV9wYXRoKEVUQ19QRVJGQ09ORklHKTsKKwlyZXR1cm4gc3lzdGVtX3dpZGU7Cit9CisKK3N0YXRpYyBpbnQgcGVyZl9lbnZfYm9vbChjb25zdCBjaGFyICprLCBpbnQgZGVmKQoreworCWNvbnN0IGNoYXIgKnYgPSBnZXRlbnYoayk7CisJcmV0dXJuIHYgPyBwZXJmX2NvbmZpZ19ib29sKGssIHYpIDogZGVmOworfQorCitpbnQgcGVyZl9jb25maWdfc3lzdGVtKHZvaWQpCit7CisJcmV0dXJuICFwZXJmX2Vudl9ib29sKCJQRVJGX0NPTkZJR19OT1NZU1RFTSIsIDApOworfQorCitpbnQgcGVyZl9jb25maWdfZ2xvYmFsKHZvaWQpCit7CisJcmV0dXJuICFwZXJmX2Vudl9ib29sKCJQRVJGX0NPTkZJR19OT0dMT0JBTCIsIDApOworfQorCitpbnQgcGVyZl9jb25maWcoY29uZmlnX2ZuX3QgZm4sIHZvaWQgKmRhdGEpCit7CisJaW50IHJldCA9IDAsIGZvdW5kID0gMDsKKwljaGFyICpyZXBvX2NvbmZpZyA9IE5VTEw7CisJY29uc3QgY2hhciAqaG9tZSA9IE5VTEw7CisKKwkvKiBTZXR0aW5nICRQRVJGX0NPTkZJRyBtYWtlcyBwZXJmIHJlYWQgX29ubHlfIHRoZSBnaXZlbiBjb25maWcgZmlsZS4gKi8KKwlpZiAoY29uZmlnX2V4Y2x1c2l2ZV9maWxlbmFtZSkKKwkJcmV0dXJuIHBlcmZfY29uZmlnX2Zyb21fZmlsZShmbiwgY29uZmlnX2V4Y2x1c2l2ZV9maWxlbmFtZSwgZGF0YSk7CisJaWYgKHBlcmZfY29uZmlnX3N5c3RlbSgpICYmICFhY2Nlc3MocGVyZl9ldGNfcGVyZmNvbmZpZygpLCBSX09LKSkgeworCQlyZXQgKz0gcGVyZl9jb25maWdfZnJvbV9maWxlKGZuLCBwZXJmX2V0Y19wZXJmY29uZmlnKCksCisJCQkJCSAgICBkYXRhKTsKKwkJZm91bmQgKz0gMTsKKwl9CisKKwlob21lID0gZ2V0ZW52KCJIT01FIik7CisJaWYgKHBlcmZfY29uZmlnX2dsb2JhbCgpICYmIGhvbWUpIHsKKwkJY2hhciAqdXNlcl9jb25maWcgPSBzdHJkdXAobWtwYXRoKCIlcy8ucGVyZmNvbmZpZyIsIGhvbWUpKTsKKwkJaWYgKCFhY2Nlc3ModXNlcl9jb25maWcsIFJfT0spKSB7CisJCQlyZXQgKz0gcGVyZl9jb25maWdfZnJvbV9maWxlKGZuLCB1c2VyX2NvbmZpZywgZGF0YSk7CisJCQlmb3VuZCArPSAxOworCQl9CisJCWZyZWUodXNlcl9jb25maWcpOworCX0KKworCXJlcG9fY29uZmlnID0gcGVyZl9wYXRoZHVwKCJjb25maWciKTsKKwlpZiAoIWFjY2VzcyhyZXBvX2NvbmZpZywgUl9PSykpIHsKKwkJcmV0ICs9IHBlcmZfY29uZmlnX2Zyb21fZmlsZShmbiwgcmVwb19jb25maWcsIGRhdGEpOworCQlmb3VuZCArPSAxOworCX0KKwlmcmVlKHJlcG9fY29uZmlnKTsKKwlpZiAoZm91bmQgPT0gMCkKKwkJcmV0dXJuIC0xOworCXJldHVybiByZXQ7Cit9CisKKy8qCisgKiBGaW5kIGFsbCB0aGUgc3R1ZmYgZm9yIHBlcmZfY29uZmlnX3NldCgpIGJlbG93LgorICovCisKKyNkZWZpbmUgTUFYX01BVENIRVMgNTEyCisKK3N0YXRpYyBzdHJ1Y3QgeworCWludCBiYXNlbGVuOworCWNoYXIqIGtleTsKKwlpbnQgZG9fbm90X21hdGNoOworCXJlZ2V4X3QqIHZhbHVlX3JlZ2V4OworCWludCBtdWx0aV9yZXBsYWNlOworCXNpemVfdCBvZmZzZXRbTUFYX01BVENIRVNdOworCWVudW0geyBTVEFSVCwgU0VDVElPTl9TRUVOLCBTRUNUSU9OX0VORF9TRUVOLCBLRVlfU0VFTiB9IHN0YXRlOworCWludCBzZWVuOworfSBzdG9yZTsKKworc3RhdGljIGludCBtYXRjaGVzKGNvbnN0IGNoYXIqIGtleSwgY29uc3QgY2hhciogdmFsdWUpCit7CisJcmV0dXJuICFzdHJjbXAoa2V5LCBzdG9yZS5rZXkpICYmCisJCShzdG9yZS52YWx1ZV9yZWdleCA9PSBOVUxMIHx8CisJCSAoc3RvcmUuZG9fbm90X21hdGNoIF4KKwkJICAhcmVnZXhlYyhzdG9yZS52YWx1ZV9yZWdleCwgdmFsdWUsIDAsIE5VTEwsIDApKSk7Cit9CisKK3N0YXRpYyBpbnQgc3RvcmVfYXV4KGNvbnN0IGNoYXIqIGtleSwgY29uc3QgY2hhciogdmFsdWUsIHZvaWQgKmNiKQoreworCWNvbnN0IGNoYXIgKmVwOworCXNpemVfdCBzZWN0aW9uX2xlbjsKKworCXN3aXRjaCAoc3RvcmUuc3RhdGUpIHsKKwljYXNlIEtFWV9TRUVOOgorCQlpZiAobWF0Y2hlcyhrZXksIHZhbHVlKSkgeworCQkJaWYgKHN0b3JlLnNlZW4gPT0gMSAmJiBzdG9yZS5tdWx0aV9yZXBsYWNlID09IDApIHsKKwkJCQl3YXJuaW5nKCIlcyBoYXMgbXVsdGlwbGUgdmFsdWVzIiwga2V5KTsKKwkJCX0gZWxzZSBpZiAoc3RvcmUuc2VlbiA+PSBNQVhfTUFUQ0hFUykgeworCQkJCWVycm9yKCJ0b28gbWFueSBtYXRjaGVzIGZvciAlcyIsIGtleSk7CisJCQkJcmV0dXJuIDE7CisJCQl9CisKKwkJCXN0b3JlLm9mZnNldFtzdG9yZS5zZWVuXSA9IGZ0ZWxsKGNvbmZpZ19maWxlKTsKKwkJCXN0b3JlLnNlZW4rKzsKKwkJfQorCQlicmVhazsKKwljYXNlIFNFQ1RJT05fU0VFTjoKKwkJLyoKKwkJICogV2hhdCB3ZSBhcmUgbG9va2luZyBmb3IgaXMgaW4gc3RvcmUua2V5IChib3RoCisJCSAqIHNlY3Rpb24gYW5kIHZhciksIGFuZCBpdHMgc2VjdGlvbiBwYXJ0IGlzIGJhc2VsZW4KKwkJICogbG9uZy4gIFdlIGZvdW5kIGtleSAoYWdhaW4sIGJvdGggc2VjdGlvbiBhbmQgdmFyKS4KKwkJICogV2Ugd291bGQgd2FudCB0byBrbm93IGlmIHRoaXMga2V5IGlzIGluIHRoZSBzYW1lCisJCSAqIHNlY3Rpb24gYXMgd2hhdCB3ZSBhcmUgbG9va2luZyBmb3IuICBXZSBhbHJlYWR5CisJCSAqIGtub3cgd2UgYXJlIGluIHRoZSBzYW1lIHNlY3Rpb24gYXMgd2hhdCBzaG91bGQKKwkJICogaG9sZCBzdG9yZS5rZXkuCisJCSAqLworCQllcCA9IHN0cnJjaHIoa2V5LCAnLicpOworCQlzZWN0aW9uX2xlbiA9IGVwIC0ga2V5OworCisJCWlmICgoc2VjdGlvbl9sZW4gIT0gc3RvcmUuYmFzZWxlbikgfHwKKwkJICAgIG1lbWNtcChrZXksIHN0b3JlLmtleSwgc2VjdGlvbl9sZW4rMSkpIHsKKwkJCXN0b3JlLnN0YXRlID0gU0VDVElPTl9FTkRfU0VFTjsKKwkJCWJyZWFrOworCQl9CisKKwkJLyoKKwkJICogRG8gbm90IGluY3JlbWVudCBtYXRjaGVzOiB0aGlzIGlzIG5vIG1hdGNoLCBidXQgd2UKKwkJICoganVzdCBtYWRlIHN1cmUgd2UgYXJlIGluIHRoZSBkZXNpcmVkIHNlY3Rpb24uCisJCSAqLworCQlzdG9yZS5vZmZzZXRbc3RvcmUuc2Vlbl0gPSBmdGVsbChjb25maWdfZmlsZSk7CisJCS8qIGZhbGx0aHJ1ICovCisJY2FzZSBTRUNUSU9OX0VORF9TRUVOOgorCWNhc2UgU1RBUlQ6CisJCWlmIChtYXRjaGVzKGtleSwgdmFsdWUpKSB7CisJCQlzdG9yZS5vZmZzZXRbc3RvcmUuc2Vlbl0gPSBmdGVsbChjb25maWdfZmlsZSk7CisJCQlzdG9yZS5zdGF0ZSA9IEtFWV9TRUVOOworCQkJc3RvcmUuc2VlbisrOworCQl9IGVsc2UgeworCQkJaWYgKHN0cnJjaHIoa2V5LCAnLicpIC0ga2V5ID09IHN0b3JlLmJhc2VsZW4gJiYKKwkJCSAgICAgICFzdHJuY21wKGtleSwgc3RvcmUua2V5LCBzdG9yZS5iYXNlbGVuKSkgeworCQkJCQlzdG9yZS5zdGF0ZSA9IFNFQ1RJT05fU0VFTjsKKwkJCQkJc3RvcmUub2Zmc2V0W3N0b3JlLnNlZW5dID0gZnRlbGwoY29uZmlnX2ZpbGUpOworCQkJfQorCQl9CisJfQorCXJldHVybiAwOworfQorCitzdGF0aWMgaW50IHN0b3JlX3dyaXRlX3NlY3Rpb24oaW50IGZkLCBjb25zdCBjaGFyKiBrZXkpCit7CisJY29uc3QgY2hhciAqZG90OworCWludCBpLCBzdWNjZXNzOworCXN0cnVjdCBzdHJidWYgc2IgPSBTVFJCVUZfSU5JVDsKKworCWRvdCA9IG1lbWNocihrZXksICcuJywgc3RvcmUuYmFzZWxlbik7CisJaWYgKGRvdCkgeworCQlzdHJidWZfYWRkZigmc2IsICJbJS4qcyBcIiIsIChpbnQpKGRvdCAtIGtleSksIGtleSk7CisJCWZvciAoaSA9IGRvdCAtIGtleSArIDE7IGkgPCBzdG9yZS5iYXNlbGVuOyBpKyspIHsKKwkJCWlmIChrZXlbaV0gPT0gJyInIHx8IGtleVtpXSA9PSAnXFwnKQorCQkJCXN0cmJ1Zl9hZGRjaCgmc2IsICdcXCcpOworCQkJc3RyYnVmX2FkZGNoKCZzYiwga2V5W2ldKTsKKwkJfQorCQlzdHJidWZfYWRkc3RyKCZzYiwgIlwiXVxuIik7CisJfSBlbHNlIHsKKwkJc3RyYnVmX2FkZGYoJnNiLCAiWyUuKnNdXG4iLCBzdG9yZS5iYXNlbGVuLCBrZXkpOworCX0KKworCXN1Y2Nlc3MgPSB3cml0ZV9pbl9mdWxsKGZkLCBzYi5idWYsIHNiLmxlbikgPT0gc2IubGVuOworCXN0cmJ1Zl9yZWxlYXNlKCZzYik7CisKKwlyZXR1cm4gc3VjY2VzczsKK30KKworc3RhdGljIGludCBzdG9yZV93cml0ZV9wYWlyKGludCBmZCwgY29uc3QgY2hhcioga2V5LCBjb25zdCBjaGFyKiB2YWx1ZSkKK3sKKwlpbnQgaSwgc3VjY2VzczsKKwlpbnQgbGVuZ3RoID0gc3RybGVuKGtleSArIHN0b3JlLmJhc2VsZW4gKyAxKTsKKwljb25zdCBjaGFyICpxdW90ZSA9ICIiOworCXN0cnVjdCBzdHJidWYgc2IgPSBTVFJCVUZfSU5JVDsKKworCS8qCisJICogQ2hlY2sgdG8gc2VlIGlmIHRoZSB2YWx1ZSBuZWVkcyB0byBiZSBzdXJyb3VuZGVkIHdpdGggYSBkcSBwYWlyLgorCSAqIE5vdGUgdGhhdCBwcm9ibGVtYXRpYyBjaGFyYWN0ZXJzIGFyZSBhbHdheXMgYmFja3NsYXNoLXF1b3RlZDsgdGhpcworCSAqIGNoZWNrIGlzIGFib3V0IG5vdCBsb3NpbmcgbGVhZGluZyBvciB0cmFpbGluZyBTUCBhbmQgc3RyaW5ncyB0aGF0CisJICogZm9sbG93IGJlZ2lubmluZy1vZi1jb21tZW50IGNoYXJhY3RlcnMgKGkuZS4gJzsnIGFuZCAnIycpIGJ5IHRoZQorCSAqIGNvbmZpZ3VyYXRpb24gcGFyc2VyLgorCSAqLworCWlmICh2YWx1ZVswXSA9PSAnICcpCisJCXF1b3RlID0gIlwiIjsKKwlmb3IgKGkgPSAwOyB2YWx1ZVtpXTsgaSsrKQorCQlpZiAodmFsdWVbaV0gPT0gJzsnIHx8IHZhbHVlW2ldID09ICcjJykKKwkJCXF1b3RlID0gIlwiIjsKKwlpZiAoaSAmJiB2YWx1ZVtpIC0gMV0gPT0gJyAnKQorCQlxdW90ZSA9ICJcIiI7CisKKwlzdHJidWZfYWRkZigmc2IsICJcdCUuKnMgPSAlcyIsCisJCSAgICBsZW5ndGgsIGtleSArIHN0b3JlLmJhc2VsZW4gKyAxLCBxdW90ZSk7CisKKwlmb3IgKGkgPSAwOyB2YWx1ZVtpXTsgaSsrKQorCQlzd2l0Y2ggKHZhbHVlW2ldKSB7CisJCWNhc2UgJ1xuJzoKKwkJCXN0cmJ1Zl9hZGRzdHIoJnNiLCAiXFxuIik7CisJCQlicmVhazsKKwkJY2FzZSAnXHQnOgorCQkJc3RyYnVmX2FkZHN0cigmc2IsICJcXHQiKTsKKwkJCWJyZWFrOworCQljYXNlICciJzoKKwkJY2FzZSAnXFwnOgorCQkJc3RyYnVmX2FkZGNoKCZzYiwgJ1xcJyk7CisJCWRlZmF1bHQ6CisJCQlzdHJidWZfYWRkY2goJnNiLCB2YWx1ZVtpXSk7CisJCQlicmVhazsKKwkJfQorCXN0cmJ1Zl9hZGRmKCZzYiwgIiVzXG4iLCBxdW90ZSk7CisKKwlzdWNjZXNzID0gd3JpdGVfaW5fZnVsbChmZCwgc2IuYnVmLCBzYi5sZW4pID09IHNiLmxlbjsKKwlzdHJidWZfcmVsZWFzZSgmc2IpOworCisJcmV0dXJuIHN1Y2Nlc3M7Cit9CisKK3N0YXRpYyBzc2l6ZV90IGZpbmRfYmVnaW5uaW5nX29mX2xpbmUoY29uc3QgY2hhciogY29udGVudHMsIHNpemVfdCBzaXplLAorCXNpemVfdCBvZmZzZXRfLCBpbnQqIGZvdW5kX2JyYWNrZXQpCit7CisJc2l6ZV90IGVxdWFsX29mZnNldCA9IHNpemUsIGJyYWNrZXRfb2Zmc2V0ID0gc2l6ZTsKKwlzc2l6ZV90IG9mZnNldDsKKworY29udGxpbmU6CisJZm9yIChvZmZzZXQgPSBvZmZzZXRfLTI7IG9mZnNldCA+IDAKKwkJCSYmIGNvbnRlbnRzW29mZnNldF0gIT0gJ1xuJzsgb2Zmc2V0LS0pCisJCXN3aXRjaCAoY29udGVudHNbb2Zmc2V0XSkgeworCQkJY2FzZSAnPSc6IGVxdWFsX29mZnNldCA9IG9mZnNldDsgYnJlYWs7CisJCQljYXNlICddJzogYnJhY2tldF9vZmZzZXQgPSBvZmZzZXQ7IGJyZWFrOworCQl9CisJaWYgKG9mZnNldCA+IDAgJiYgY29udGVudHNbb2Zmc2V0LTFdID09ICdcXCcpIHsKKwkJb2Zmc2V0XyA9IG9mZnNldDsKKwkJZ290byBjb250bGluZTsKKwl9CisJaWYgKGJyYWNrZXRfb2Zmc2V0IDwgZXF1YWxfb2Zmc2V0KSB7CisJCSpmb3VuZF9icmFja2V0ID0gMTsKKwkJb2Zmc2V0ID0gYnJhY2tldF9vZmZzZXQrMTsKKwl9IGVsc2UKKwkJb2Zmc2V0Kys7CisKKwlyZXR1cm4gb2Zmc2V0OworfQorCitpbnQgcGVyZl9jb25maWdfc2V0KGNvbnN0IGNoYXIqIGtleSwgY29uc3QgY2hhciogdmFsdWUpCit7CisJcmV0dXJuIHBlcmZfY29uZmlnX3NldF9tdWx0aXZhcihrZXksIHZhbHVlLCBOVUxMLCAwKTsKK30KKworLyoKKyAqIElmIHZhbHVlPT1OVUxMLCB1bnNldCBpbiAocmVtb3ZlIGZyb20pIGNvbmZpZywKKyAqIGlmIHZhbHVlX3JlZ2V4IT1OVUxMLCBkaXNyZWdhcmQga2V5L3ZhbHVlIHBhaXJzIHdoZXJlIHZhbHVlIGRvZXMgbm90IG1hdGNoLgorICogaWYgbXVsdGlfcmVwbGFjZT09MCwgbm90aGluZywgb3Igb25seSBvbmUgbWF0Y2hpbmcga2V5L3ZhbHVlIGlzIHJlcGxhY2VkLAorICogICAgIGVsc2UgYWxsIG1hdGNoaW5nIGtleS92YWx1ZXMgKHJlZ2FyZGxlc3MgaG93IG1hbnkpIGFyZSByZW1vdmVkLAorICogICAgIGJlZm9yZSB0aGUgbmV3IHBhaXIgaXMgd3JpdHRlbi4KKyAqCisgKiBSZXR1cm5zIDAgb24gc3VjY2Vzcy4KKyAqCisgKiBUaGlzIGZ1bmN0aW9uIGRvZXMgdGhpczoKKyAqCisgKiAtIGl0IGxvY2tzIHRoZSBjb25maWcgZmlsZSBieSBjcmVhdGluZyAiLnBlcmYvY29uZmlnLmxvY2siCisgKgorICogLSBpdCB0aGVuIHBhcnNlcyB0aGUgY29uZmlnIHVzaW5nIHN0b3JlX2F1eCgpIGFzIHZhbGlkYXRvciB0byBmaW5kCisgKiAgIHRoZSBwb3NpdGlvbiBvbiB0aGUga2V5L3ZhbHVlIHBhaXIgdG8gcmVwbGFjZS4gSWYgaXQgaXMgdG8gYmUgdW5zZXQsCisgKiAgIGl0IG11c3QgYmUgZm91bmQgZXhhY3RseSBvbmNlLgorICoKKyAqIC0gdGhlIGNvbmZpZyBmaWxlIGlzIG1tYXAoKWVkIGFuZCB0aGUgcGFydCBiZWZvcmUgdGhlIG1hdGNoIChpZiBhbnkpIGlzCisgKiAgIHdyaXR0ZW4gdG8gdGhlIGxvY2sgZmlsZSwgdGhlbiB0aGUgY2hhbmdlZCBwYXJ0IGFuZCB0aGUgcmVzdC4KKyAqCisgKiAtIHRoZSBjb25maWcgZmlsZSBpcyByZW1vdmVkIGFuZCB0aGUgbG9jayBmaWxlIHJlbmFtZSgpZCB0byBpdC4KKyAqCisgKi8KK2ludCBwZXJmX2NvbmZpZ19zZXRfbXVsdGl2YXIoY29uc3QgY2hhcioga2V5LCBjb25zdCBjaGFyKiB2YWx1ZSwKKwljb25zdCBjaGFyKiB2YWx1ZV9yZWdleCwgaW50IG11bHRpX3JlcGxhY2UpCit7CisJaW50IGksIGRvdDsKKwlpbnQgZmQgPSAtMSwgaW5fZmQ7CisJaW50IHJldCA9IDA7CisJY2hhciogY29uZmlnX2ZpbGVuYW1lOworCWNvbnN0IGNoYXIqIGxhc3RfZG90ID0gc3RycmNocihrZXksICcuJyk7CisKKwlpZiAoY29uZmlnX2V4Y2x1c2l2ZV9maWxlbmFtZSkKKwkJY29uZmlnX2ZpbGVuYW1lID0gc3RyZHVwKGNvbmZpZ19leGNsdXNpdmVfZmlsZW5hbWUpOworCWVsc2UKKwkJY29uZmlnX2ZpbGVuYW1lID0gcGVyZl9wYXRoZHVwKCJjb25maWciKTsKKworCS8qCisJICogU2luY2UgImtleSIgYWN0dWFsbHkgY29udGFpbnMgdGhlIHNlY3Rpb24gbmFtZSBhbmQgdGhlIHJlYWwKKwkgKiBrZXkgbmFtZSBzZXBhcmF0ZWQgYnkgYSBkb3QsIHdlIGhhdmUgdG8ga25vdyB3aGVyZSB0aGUgZG90IGlzLgorCSAqLworCisJaWYgKGxhc3RfZG90ID09IE5VTEwpIHsKKwkJZXJyb3IoImtleSBkb2VzIG5vdCBjb250YWluIGEgc2VjdGlvbjogJXMiLCBrZXkpOworCQlyZXQgPSAyOworCQlnb3RvIG91dF9mcmVlOworCX0KKwlzdG9yZS5iYXNlbGVuID0gbGFzdF9kb3QgLSBrZXk7CisKKwlzdG9yZS5tdWx0aV9yZXBsYWNlID0gbXVsdGlfcmVwbGFjZTsKKworCS8qCisJICogVmFsaWRhdGUgdGhlIGtleSBhbmQgd2hpbGUgYXQgaXQsIGxvd2VyIGNhc2UgaXQgZm9yIG1hdGNoaW5nLgorCSAqLworCXN0b3JlLmtleSA9IG1hbGxvYyhzdHJsZW4oa2V5KSArIDEpOworCWRvdCA9IDA7CisJZm9yIChpID0gMDsga2V5W2ldOyBpKyspIHsKKwkJdW5zaWduZWQgY2hhciBjID0ga2V5W2ldOworCQlpZiAoYyA9PSAnLicpCisJCQlkb3QgPSAxOworCQkvKiBMZWF2ZSB0aGUgZXh0ZW5kZWQgYmFzZW5hbWUgdW50b3VjaGVkLi4gKi8KKwkJaWYgKCFkb3QgfHwgaSA+IHN0b3JlLmJhc2VsZW4pIHsKKwkJCWlmICghaXNrZXljaGFyKGMpIHx8IChpID09IHN0b3JlLmJhc2VsZW4rMSAmJiAhaXNhbHBoYShjKSkpIHsKKwkJCQllcnJvcigiaW52YWxpZCBrZXk6ICVzIiwga2V5KTsKKwkJCQlmcmVlKHN0b3JlLmtleSk7CisJCQkJcmV0ID0gMTsKKwkJCQlnb3RvIG91dF9mcmVlOworCQkJfQorCQkJYyA9IHRvbG93ZXIoYyk7CisJCX0gZWxzZSBpZiAoYyA9PSAnXG4nKSB7CisJCQllcnJvcigiaW52YWxpZCBrZXkgKG5ld2xpbmUpOiAlcyIsIGtleSk7CisJCQlmcmVlKHN0b3JlLmtleSk7CisJCQlyZXQgPSAxOworCQkJZ290byBvdXRfZnJlZTsKKwkJfQorCQlzdG9yZS5rZXlbaV0gPSBjOworCX0KKwlzdG9yZS5rZXlbaV0gPSAwOworCisJLyoKKwkgKiBJZiAucGVyZi9jb25maWcgZG9lcyBub3QgZXhpc3QgeWV0LCB3cml0ZSBhIG1pbmltYWwgdmVyc2lvbi4KKwkgKi8KKwlpbl9mZCA9IG9wZW4oY29uZmlnX2ZpbGVuYW1lLCBPX1JET05MWSk7CisJaWYgKCBpbl9mZCA8IDAgKSB7CisJCWZyZWUoc3RvcmUua2V5KTsKKworCQlpZiAoIEVOT0VOVCAhPSBlcnJubyApIHsKKwkJCWVycm9yKCJvcGVuaW5nICVzOiAlcyIsIGNvbmZpZ19maWxlbmFtZSwKKwkJCSAgICAgIHN0cmVycm9yKGVycm5vKSk7CisJCQlyZXQgPSAzOyAvKiBzYW1lIGFzICJpbnZhbGlkIGNvbmZpZyBmaWxlIiAqLworCQkJZ290byBvdXRfZnJlZTsKKwkJfQorCQkvKiBpZiBub3RoaW5nIHRvIHVuc2V0LCBlcnJvciBvdXQgKi8KKwkJaWYgKHZhbHVlID09IE5VTEwpIHsKKwkJCXJldCA9IDU7CisJCQlnb3RvIG91dF9mcmVlOworCQl9CisKKwkJc3RvcmUua2V5ID0gKGNoYXIqKWtleTsKKwkJaWYgKCFzdG9yZV93cml0ZV9zZWN0aW9uKGZkLCBrZXkpIHx8CisJCSAgICAhc3RvcmVfd3JpdGVfcGFpcihmZCwga2V5LCB2YWx1ZSkpCisJCQlnb3RvIHdyaXRlX2Vycl9vdXQ7CisJfSBlbHNlIHsKKwkJc3RydWN0IHN0YXQgc3Q7CisJCWNoYXIqIGNvbnRlbnRzOworCQlzaXplX3QgY29udGVudHNfc3osIGNvcHlfYmVnaW4sIGNvcHlfZW5kOworCQlpbnQgaSwgbmV3X2xpbmUgPSAwOworCisJCWlmICh2YWx1ZV9yZWdleCA9PSBOVUxMKQorCQkJc3RvcmUudmFsdWVfcmVnZXggPSBOVUxMOworCQllbHNlIHsKKwkJCWlmICh2YWx1ZV9yZWdleFswXSA9PSAnIScpIHsKKwkJCQlzdG9yZS5kb19ub3RfbWF0Y2ggPSAxOworCQkJCXZhbHVlX3JlZ2V4Kys7CisJCQl9IGVsc2UKKwkJCQlzdG9yZS5kb19ub3RfbWF0Y2ggPSAwOworCisJCQlzdG9yZS52YWx1ZV9yZWdleCA9IChyZWdleF90KiltYWxsb2Moc2l6ZW9mKHJlZ2V4X3QpKTsKKwkJCWlmIChyZWdjb21wKHN0b3JlLnZhbHVlX3JlZ2V4LCB2YWx1ZV9yZWdleCwKKwkJCQkJUkVHX0VYVEVOREVEKSkgeworCQkJCWVycm9yKCJpbnZhbGlkIHBhdHRlcm46ICVzIiwgdmFsdWVfcmVnZXgpOworCQkJCWZyZWUoc3RvcmUudmFsdWVfcmVnZXgpOworCQkJCXJldCA9IDY7CisJCQkJZ290byBvdXRfZnJlZTsKKwkJCX0KKwkJfQorCisJCXN0b3JlLm9mZnNldFswXSA9IDA7CisJCXN0b3JlLnN0YXRlID0gU1RBUlQ7CisJCXN0b3JlLnNlZW4gPSAwOworCisJCS8qCisJCSAqIEFmdGVyIHRoaXMsIHN0b3JlLm9mZnNldCB3aWxsIGNvbnRhaW4gdGhlICplbmQqIG9mZnNldAorCQkgKiBvZiB0aGUgbGFzdCBtYXRjaCwgb3IgcmVtYWluIGF0IDAgaWYgbm8gbWF0Y2ggd2FzIGZvdW5kLgorCQkgKiBBcyBhIHNpZGUgZWZmZWN0LCB3ZSBtYWtlIHN1cmUgdG8gdHJhbnNmb3JtIG9ubHkgYSB2YWxpZAorCQkgKiBleGlzdGluZyBjb25maWcgZmlsZS4KKwkJICovCisJCWlmIChwZXJmX2NvbmZpZ19mcm9tX2ZpbGUoc3RvcmVfYXV4LCBjb25maWdfZmlsZW5hbWUsIE5VTEwpKSB7CisJCQllcnJvcigiaW52YWxpZCBjb25maWcgZmlsZSAlcyIsIGNvbmZpZ19maWxlbmFtZSk7CisJCQlmcmVlKHN0b3JlLmtleSk7CisJCQlpZiAoc3RvcmUudmFsdWVfcmVnZXggIT0gTlVMTCkgeworCQkJCXJlZ2ZyZWUoc3RvcmUudmFsdWVfcmVnZXgpOworCQkJCWZyZWUoc3RvcmUudmFsdWVfcmVnZXgpOworCQkJfQorCQkJcmV0ID0gMzsKKwkJCWdvdG8gb3V0X2ZyZWU7CisJCX0KKworCQlmcmVlKHN0b3JlLmtleSk7CisJCWlmIChzdG9yZS52YWx1ZV9yZWdleCAhPSBOVUxMKSB7CisJCQlyZWdmcmVlKHN0b3JlLnZhbHVlX3JlZ2V4KTsKKwkJCWZyZWUoc3RvcmUudmFsdWVfcmVnZXgpOworCQl9CisKKwkJLyogaWYgbm90aGluZyB0byB1bnNldCwgb3IgdG9vIG1hbnkgbWF0Y2hlcywgZXJyb3Igb3V0ICovCisJCWlmICgoc3RvcmUuc2VlbiA9PSAwICYmIHZhbHVlID09IE5VTEwpIHx8CisJCQkJKHN0b3JlLnNlZW4gPiAxICYmIG11bHRpX3JlcGxhY2UgPT0gMCkpIHsKKwkJCXJldCA9IDU7CisJCQlnb3RvIG91dF9mcmVlOworCQl9CisKKwkJZnN0YXQoaW5fZmQsICZzdCk7CisJCWNvbnRlbnRzX3N6ID0geHNpemVfdChzdC5zdF9zaXplKTsKKwkJY29udGVudHMgPSBtbWFwKE5VTEwsIGNvbnRlbnRzX3N6LCBQUk9UX1JFQUQsCisJCQlNQVBfUFJJVkFURSwgaW5fZmQsIDApOworCQljbG9zZShpbl9mZCk7CisKKwkJaWYgKHN0b3JlLnNlZW4gPT0gMCkKKwkJCXN0b3JlLnNlZW4gPSAxOworCisJCWZvciAoaSA9IDAsIGNvcHlfYmVnaW4gPSAwOyBpIDwgc3RvcmUuc2VlbjsgaSsrKSB7CisJCQlpZiAoc3RvcmUub2Zmc2V0W2ldID09IDApIHsKKwkJCQlzdG9yZS5vZmZzZXRbaV0gPSBjb3B5X2VuZCA9IGNvbnRlbnRzX3N6OworCQkJfSBlbHNlIGlmIChzdG9yZS5zdGF0ZSAhPSBLRVlfU0VFTikgeworCQkJCWNvcHlfZW5kID0gc3RvcmUub2Zmc2V0W2ldOworCQkJfSBlbHNlCisJCQkJY29weV9lbmQgPSBmaW5kX2JlZ2lubmluZ19vZl9saW5lKAorCQkJCQljb250ZW50cywgY29udGVudHNfc3osCisJCQkJCXN0b3JlLm9mZnNldFtpXS0yLCAmbmV3X2xpbmUpOworCisJCQlpZiAoY29weV9lbmQgPiAwICYmIGNvbnRlbnRzW2NvcHlfZW5kLTFdICE9ICdcbicpCisJCQkJbmV3X2xpbmUgPSAxOworCisJCQkvKiB3cml0ZSB0aGUgZmlyc3QgcGFydCBvZiB0aGUgY29uZmlnICovCisJCQlpZiAoY29weV9lbmQgPiBjb3B5X2JlZ2luKSB7CisJCQkJaWYgKHdyaXRlX2luX2Z1bGwoZmQsIGNvbnRlbnRzICsgY29weV9iZWdpbiwKKwkJCQkJCSAgY29weV9lbmQgLSBjb3B5X2JlZ2luKSA8CisJCQkJICAgIGNvcHlfZW5kIC0gY29weV9iZWdpbikKKwkJCQkJZ290byB3cml0ZV9lcnJfb3V0OworCQkJCWlmIChuZXdfbGluZSAmJgorCQkJCSAgICB3cml0ZV9pbl9mdWxsKGZkLCAiXG4iLCAxKSAhPSAxKQorCQkJCQlnb3RvIHdyaXRlX2Vycl9vdXQ7CisJCQl9CisJCQljb3B5X2JlZ2luID0gc3RvcmUub2Zmc2V0W2ldOworCQl9CisKKwkJLyogd3JpdGUgdGhlIHBhaXIgKHZhbHVlID09IE5VTEwgbWVhbnMgdW5zZXQpICovCisJCWlmICh2YWx1ZSAhPSBOVUxMKSB7CisJCQlpZiAoc3RvcmUuc3RhdGUgPT0gU1RBUlQpIHsKKwkJCQlpZiAoIXN0b3JlX3dyaXRlX3NlY3Rpb24oZmQsIGtleSkpCisJCQkJCWdvdG8gd3JpdGVfZXJyX291dDsKKwkJCX0KKwkJCWlmICghc3RvcmVfd3JpdGVfcGFpcihmZCwga2V5LCB2YWx1ZSkpCisJCQkJZ290byB3cml0ZV9lcnJfb3V0OworCQl9CisKKwkJLyogd3JpdGUgdGhlIHJlc3Qgb2YgdGhlIGNvbmZpZyAqLworCQlpZiAoY29weV9iZWdpbiA8IGNvbnRlbnRzX3N6KQorCQkJaWYgKHdyaXRlX2luX2Z1bGwoZmQsIGNvbnRlbnRzICsgY29weV9iZWdpbiwKKwkJCQkJICBjb250ZW50c19zeiAtIGNvcHlfYmVnaW4pIDwKKwkJCSAgICBjb250ZW50c19zeiAtIGNvcHlfYmVnaW4pCisJCQkJZ290byB3cml0ZV9lcnJfb3V0OworCisJCW11bm1hcChjb250ZW50cywgY29udGVudHNfc3opOworCX0KKworCXJldCA9IDA7CisKK291dF9mcmVlOgorCWZyZWUoY29uZmlnX2ZpbGVuYW1lKTsKKwlyZXR1cm4gcmV0OworCit3cml0ZV9lcnJfb3V0OgorCWdvdG8gb3V0X2ZyZWU7CisKK30KKworLyoKKyAqIENhbGwgdGhpcyB0byByZXBvcnQgZXJyb3IgZm9yIHlvdXIgdmFyaWFibGUgdGhhdCBzaG91bGQgbm90CisgKiBnZXQgYSBib29sZWFuIHZhbHVlIChpLmUuICJbbXldIHZhciIgbWVhbnMgInRydWUiKS4KKyAqLworaW50IGNvbmZpZ19lcnJvcl9ub25ib29sKGNvbnN0IGNoYXIgKnZhcikKK3sKKwlyZXR1cm4gZXJyb3IoIk1pc3NpbmcgdmFsdWUgZm9yICclcyciLCB2YXIpOworfQpkaWZmIC0tZ2l0IGEvdG9vbHMvcGVyZi91dGlsL2N0eXBlLmMgYi90b29scy9wZXJmL3V0aWwvY3R5cGUuYwpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi5iOTBlYzAwCi0tLSAvZGV2L251bGwKKysrIGIvdG9vbHMvcGVyZi91dGlsL2N0eXBlLmMKQEAgLTAsMCArMSwyNiBAQAorLyoKKyAqIFNhbmUgbG9jYWxlLWluZGVwZW5kZW50LCBBU0NJSSBjdHlwZS4KKyAqCisgKiBObyBzdXJwcmlzZXMsIGFuZCB3b3JrcyB3aXRoIHNpZ25lZCBhbmQgdW5zaWduZWQgY2hhcnMuCisgKi8KKyNpbmNsdWRlICJjYWNoZS5oIgorCitlbnVtIHsKKwlTID0gR0lUX1NQQUNFLAorCUEgPSBHSVRfQUxQSEEsCisJRCA9IEdJVF9ESUdJVCwKKwlHID0gR0lUX0dMT0JfU1BFQ0lBTCwJLyogKiwgPywgWywgXFwgKi8KKwlSID0gR0lUX1JFR0VYX1NQRUNJQUwsCS8qICQsICgsICksICssIC4sIF4sIHssIHwgKiAqLworfTsKKwordW5zaWduZWQgY2hhciBzYW5lX2N0eXBlWzI1Nl0gPSB7CisJMCwgMCwgMCwgMCwgMCwgMCwgMCwgMCwgMCwgUywgUywgMCwgMCwgUywgMCwgMCwJCS8qICAgMC4uIDE1ICovCisJMCwgMCwgMCwgMCwgMCwgMCwgMCwgMCwgMCwgMCwgMCwgMCwgMCwgMCwgMCwgMCwJCS8qICAxNi4uIDMxICovCisJUywgMCwgMCwgMCwgUiwgMCwgMCwgMCwgUiwgUiwgRywgUiwgMCwgMCwgUiwgMCwJCS8qICAzMi4uIDQ3ICovCisJRCwgRCwgRCwgRCwgRCwgRCwgRCwgRCwgRCwgRCwgMCwgMCwgMCwgMCwgMCwgRywJCS8qICA0OC4uIDYzICovCisJMCwgQSwgQSwgQSwgQSwgQSwgQSwgQSwgQSwgQSwgQSwgQSwgQSwgQSwgQSwgQSwJCS8qICA2NC4uIDc5ICovCisJQSwgQSwgQSwgQSwgQSwgQSwgQSwgQSwgQSwgQSwgQSwgRywgRywgMCwgUiwgMCwJCS8qICA4MC4uIDk1ICovCisJMCwgQSwgQSwgQSwgQSwgQSwgQSwgQSwgQSwgQSwgQSwgQSwgQSwgQSwgQSwgQSwJCS8qICA5Ni4uMTExICovCisJQSwgQSwgQSwgQSwgQSwgQSwgQSwgQSwgQSwgQSwgQSwgUiwgUiwgMCwgMCwgMCwJCS8qIDExMi4uMTI3ICovCisJLyogTm90aGluZyBpbiB0aGUgMTI4Li4gcmFuZ2UgKi8KK307CmRpZmYgLS1naXQgYS90b29scy9wZXJmL3V0aWwvZW52aXJvbm1lbnQuYyBiL3Rvb2xzL3BlcmYvdXRpbC9lbnZpcm9ubWVudC5jCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjI3NWIwZWUKLS0tIC9kZXYvbnVsbAorKysgYi90b29scy9wZXJmL3V0aWwvZW52aXJvbm1lbnQuYwpAQCAtMCwwICsxLDkgQEAKKy8qCisgKiBXZSBwdXQgYWxsIHRoZSBwZXJmIGNvbmZpZyB2YXJpYWJsZXMgaW4gdGhpcyBzYW1lIG9iamVjdAorICogZmlsZSwgc28gdGhhdCBwcm9ncmFtcyBjYW4gbGluayBhZ2FpbnN0IHRoZSBjb25maWcgcGFyc2VyCisgKiB3aXRob3V0IGhhdmluZyB0byBsaW5rIGFnYWluc3QgYWxsIHRoZSByZXN0IG9mIHBlcmYuCisgKi8KKyNpbmNsdWRlICJjYWNoZS5oIgorCitjb25zdCBjaGFyICpwYWdlcl9wcm9ncmFtOworaW50IHBhZ2VyX3VzZV9jb2xvciA9IDE7CmRpZmYgLS1naXQgYS90b29scy9wZXJmL3V0aWwvZXhlY19jbWQuYyBiL3Rvb2xzL3BlcmYvdXRpbC9leGVjX2NtZC5jCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLmQzOTI5MjIKLS0tIC9kZXYvbnVsbAorKysgYi90b29scy9wZXJmL3V0aWwvZXhlY19jbWQuYwpAQCAtMCwwICsxLDE2NSBAQAorI2luY2x1ZGUgImNhY2hlLmgiCisjaW5jbHVkZSAiZXhlY19jbWQuaCIKKyNpbmNsdWRlICJxdW90ZS5oIgorI2RlZmluZSBNQVhfQVJHUwkzMgorCitleHRlcm4gY2hhciAqKmVudmlyb247CitzdGF0aWMgY29uc3QgY2hhciAqYXJndl9leGVjX3BhdGg7CitzdGF0aWMgY29uc3QgY2hhciAqYXJndjBfcGF0aDsKKworY29uc3QgY2hhciAqc3lzdGVtX3BhdGgoY29uc3QgY2hhciAqcGF0aCkKK3sKKyNpZmRlZiBSVU5USU1FX1BSRUZJWAorCXN0YXRpYyBjb25zdCBjaGFyICpwcmVmaXg7CisjZWxzZQorCXN0YXRpYyBjb25zdCBjaGFyICpwcmVmaXggPSBQUkVGSVg7CisjZW5kaWYKKwlzdHJ1Y3Qgc3RyYnVmIGQgPSBTVFJCVUZfSU5JVDsKKworCWlmIChpc19hYnNvbHV0ZV9wYXRoKHBhdGgpKQorCQlyZXR1cm4gcGF0aDsKKworI2lmZGVmIFJVTlRJTUVfUFJFRklYCisJYXNzZXJ0KGFyZ3YwX3BhdGgpOworCWFzc2VydChpc19hYnNvbHV0ZV9wYXRoKGFyZ3YwX3BhdGgpKTsKKworCWlmICghcHJlZml4ICYmCisJICAgICEocHJlZml4ID0gc3RyaXBfcGF0aF9zdWZmaXgoYXJndjBfcGF0aCwgUEVSRl9FWEVDX1BBVEgpKSAmJgorCSAgICAhKHByZWZpeCA9IHN0cmlwX3BhdGhfc3VmZml4KGFyZ3YwX3BhdGgsIEJJTkRJUikpICYmCisJICAgICEocHJlZml4ID0gc3RyaXBfcGF0aF9zdWZmaXgoYXJndjBfcGF0aCwgInBlcmYiKSkpIHsKKwkJcHJlZml4ID0gUFJFRklYOworCQlmcHJpbnRmKHN0ZGVyciwgIlJVTlRJTUVfUFJFRklYIHJlcXVlc3RlZCwgIgorCQkJCSJidXQgcHJlZml4IGNvbXB1dGF0aW9uIGZhaWxlZC4gICIKKwkJCQkiVXNpbmcgc3RhdGljIGZhbGxiYWNrICclcycuXG4iLCBwcmVmaXgpOworCX0KKyNlbmRpZgorCisJc3RyYnVmX2FkZGYoJmQsICIlcy8lcyIsIHByZWZpeCwgcGF0aCk7CisJcGF0aCA9IHN0cmJ1Zl9kZXRhY2goJmQsIE5VTEwpOworCXJldHVybiBwYXRoOworfQorCitjb25zdCBjaGFyICpwZXJmX2V4dHJhY3RfYXJndjBfcGF0aChjb25zdCBjaGFyICphcmd2MCkKK3sKKwljb25zdCBjaGFyICpzbGFzaDsKKworCWlmICghYXJndjAgfHwgISphcmd2MCkKKwkJcmV0dXJuIE5VTEw7CisJc2xhc2ggPSBhcmd2MCArIHN0cmxlbihhcmd2MCk7CisKKwl3aGlsZSAoYXJndjAgPD0gc2xhc2ggJiYgIWlzX2Rpcl9zZXAoKnNsYXNoKSkKKwkJc2xhc2gtLTsKKworCWlmIChzbGFzaCA+PSBhcmd2MCkgeworCQlhcmd2MF9wYXRoID0gc3RybmR1cChhcmd2MCwgc2xhc2ggLSBhcmd2MCk7CisJCXJldHVybiBzbGFzaCArIDE7CisJfQorCisJcmV0dXJuIGFyZ3YwOworfQorCit2b2lkIHBlcmZfc2V0X2FyZ3ZfZXhlY19wYXRoKGNvbnN0IGNoYXIgKmV4ZWNfcGF0aCkKK3sKKwlhcmd2X2V4ZWNfcGF0aCA9IGV4ZWNfcGF0aDsKKwkvKgorCSAqIFByb3BhZ2F0ZSB0aGlzIHNldHRpbmcgdG8gZXh0ZXJuYWwgcHJvZ3JhbXMuCisJICovCisJc2V0ZW52KEVYRUNfUEFUSF9FTlZJUk9OTUVOVCwgZXhlY19wYXRoLCAxKTsKK30KKworCisvKiBSZXR1cm5zIHRoZSBoaWdoZXN0LXByaW9yaXR5LCBsb2NhdGlvbiB0byBsb29rIGZvciBwZXJmIHByb2dyYW1zLiAqLworY29uc3QgY2hhciAqcGVyZl9leGVjX3BhdGgodm9pZCkKK3sKKwljb25zdCBjaGFyICplbnY7CisKKwlpZiAoYXJndl9leGVjX3BhdGgpCisJCXJldHVybiBhcmd2X2V4ZWNfcGF0aDsKKworCWVudiA9IGdldGVudihFWEVDX1BBVEhfRU5WSVJPTk1FTlQpOworCWlmIChlbnYgJiYgKmVudikgeworCQlyZXR1cm4gZW52OworCX0KKworCXJldHVybiBzeXN0ZW1fcGF0aChQRVJGX0VYRUNfUEFUSCk7Cit9CisKK3N0YXRpYyB2b2lkIGFkZF9wYXRoKHN0cnVjdCBzdHJidWYgKm91dCwgY29uc3QgY2hhciAqcGF0aCkKK3sKKwlpZiAocGF0aCAmJiAqcGF0aCkgeworCQlpZiAoaXNfYWJzb2x1dGVfcGF0aChwYXRoKSkKKwkJCXN0cmJ1Zl9hZGRzdHIob3V0LCBwYXRoKTsKKwkJZWxzZQorCQkJc3RyYnVmX2FkZHN0cihvdXQsIG1ha2Vfbm9ucmVsYXRpdmVfcGF0aChwYXRoKSk7CisKKwkJc3RyYnVmX2FkZGNoKG91dCwgUEFUSF9TRVApOworCX0KK30KKwordm9pZCBzZXR1cF9wYXRoKHZvaWQpCit7CisJY29uc3QgY2hhciAqb2xkX3BhdGggPSBnZXRlbnYoIlBBVEgiKTsKKwlzdHJ1Y3Qgc3RyYnVmIG5ld19wYXRoID0gU1RSQlVGX0lOSVQ7CisKKwlhZGRfcGF0aCgmbmV3X3BhdGgsIHBlcmZfZXhlY19wYXRoKCkpOworCWFkZF9wYXRoKCZuZXdfcGF0aCwgYXJndjBfcGF0aCk7CisKKwlpZiAob2xkX3BhdGgpCisJCXN0cmJ1Zl9hZGRzdHIoJm5ld19wYXRoLCBvbGRfcGF0aCk7CisJZWxzZQorCQlzdHJidWZfYWRkc3RyKCZuZXdfcGF0aCwgIi91c3IvbG9jYWwvYmluOi91c3IvYmluOi9iaW4iKTsKKworCXNldGVudigiUEFUSCIsIG5ld19wYXRoLmJ1ZiwgMSk7CisKKwlzdHJidWZfcmVsZWFzZSgmbmV3X3BhdGgpOworfQorCitjb25zdCBjaGFyICoqcHJlcGFyZV9wZXJmX2NtZChjb25zdCBjaGFyICoqYXJndikKK3sKKwlpbnQgYXJnYzsKKwljb25zdCBjaGFyICoqbmFyZ3Y7CisKKwlmb3IgKGFyZ2MgPSAwOyBhcmd2W2FyZ2NdOyBhcmdjKyspCisJCTsgLyoganVzdCBjb3VudGluZyAqLworCW5hcmd2ID0gbWFsbG9jKHNpemVvZigqbmFyZ3YpICogKGFyZ2MgKyAyKSk7CisKKwluYXJndlswXSA9ICJwZXJmIjsKKwlmb3IgKGFyZ2MgPSAwOyBhcmd2W2FyZ2NdOyBhcmdjKyspCisJCW5hcmd2W2FyZ2MgKyAxXSA9IGFyZ3ZbYXJnY107CisJbmFyZ3ZbYXJnYyArIDFdID0gTlVMTDsKKwlyZXR1cm4gbmFyZ3Y7Cit9CisKK2ludCBleGVjdl9wZXJmX2NtZChjb25zdCBjaGFyICoqYXJndikgeworCWNvbnN0IGNoYXIgKipuYXJndiA9IHByZXBhcmVfcGVyZl9jbWQoYXJndik7CisKKwkvKiBleGVjdnAoKSBjYW4gb25seSBldmVyIHJldHVybiBpZiBpdCBmYWlscyAqLworCWV4ZWN2cCgicGVyZiIsIChjaGFyICoqKW5hcmd2KTsKKworCWZyZWUobmFyZ3YpOworCXJldHVybiAtMTsKK30KKworCitpbnQgZXhlY2xfcGVyZl9jbWQoY29uc3QgY2hhciAqY21kLC4uLikKK3sKKwlpbnQgYXJnYzsKKwljb25zdCBjaGFyICphcmd2W01BWF9BUkdTICsgMV07CisJY29uc3QgY2hhciAqYXJnOworCXZhX2xpc3QgcGFyYW07CisKKwl2YV9zdGFydChwYXJhbSwgY21kKTsKKwlhcmd2WzBdID0gY21kOworCWFyZ2MgPSAxOworCXdoaWxlIChhcmdjIDwgTUFYX0FSR1MpIHsKKwkJYXJnID0gYXJndlthcmdjKytdID0gdmFfYXJnKHBhcmFtLCBjaGFyICopOworCQlpZiAoIWFyZykKKwkJCWJyZWFrOworCX0KKwl2YV9lbmQocGFyYW0pOworCWlmIChNQVhfQVJHUyA8PSBhcmdjKQorCQlyZXR1cm4gZXJyb3IoInRvbyBtYW55IGFyZ3MgdG8gcnVuICVzIiwgY21kKTsKKworCWFyZ3ZbYXJnY10gPSBOVUxMOworCXJldHVybiBleGVjdl9wZXJmX2NtZChhcmd2KTsKK30KZGlmZiAtLWdpdCBhL3Rvb2xzL3BlcmYvdXRpbC9leGVjX2NtZC5oIGIvdG9vbHMvcGVyZi91dGlsL2V4ZWNfY21kLmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uZWZmZTI1ZQotLS0gL2Rldi9udWxsCisrKyBiL3Rvb2xzL3BlcmYvdXRpbC9leGVjX2NtZC5oCkBAIC0wLDAgKzEsMTMgQEAKKyNpZm5kZWYgUEVSRl9FWEVDX0NNRF9ICisjZGVmaW5lIFBFUkZfRVhFQ19DTURfSAorCitleHRlcm4gdm9pZCBwZXJmX3NldF9hcmd2X2V4ZWNfcGF0aChjb25zdCBjaGFyICpleGVjX3BhdGgpOworZXh0ZXJuIGNvbnN0IGNoYXIgKnBlcmZfZXh0cmFjdF9hcmd2MF9wYXRoKGNvbnN0IGNoYXIgKnBhdGgpOworZXh0ZXJuIGNvbnN0IGNoYXIgKnBlcmZfZXhlY19wYXRoKHZvaWQpOworZXh0ZXJuIHZvaWQgc2V0dXBfcGF0aCh2b2lkKTsKK2V4dGVybiBjb25zdCBjaGFyICoqcHJlcGFyZV9wZXJmX2NtZChjb25zdCBjaGFyICoqYXJndik7CitleHRlcm4gaW50IGV4ZWN2X3BlcmZfY21kKGNvbnN0IGNoYXIgKiphcmd2KTsgLyogTlVMTCB0ZXJtaW5hdGVkICovCitleHRlcm4gaW50IGV4ZWNsX3BlcmZfY21kKGNvbnN0IGNoYXIgKmNtZCwgLi4uKTsKK2V4dGVybiBjb25zdCBjaGFyICpzeXN0ZW1fcGF0aChjb25zdCBjaGFyICpwYXRoKTsKKworI2VuZGlmIC8qIFBFUkZfRVhFQ19DTURfSCAqLwpkaWZmIC0tZ2l0IGEvdG9vbHMvcGVyZi91dGlsL2dlbmVyYXRlLWNtZGxpc3Quc2ggYi90b29scy9wZXJmL3V0aWwvZ2VuZXJhdGUtY21kbGlzdC5zaApuZXcgZmlsZSBtb2RlIDEwMDc1NQppbmRleCAwMDAwMDAwLi5mMDZmNmZkCi0tLSAvZGV2L251bGwKKysrIGIvdG9vbHMvcGVyZi91dGlsL2dlbmVyYXRlLWNtZGxpc3Quc2gKQEAgLTAsMCArMSwyNCBAQAorIyEvYmluL3NoCisKK2VjaG8gIi8qIEF1dG9tYXRpY2FsbHkgZ2VuZXJhdGVkIGJ5ICQwICovCitzdHJ1Y3QgY21kbmFtZV9oZWxwCit7CisgICAgY2hhciBuYW1lWzE2XTsKKyAgICBjaGFyIGhlbHBbODBdOworfTsKKworc3RhdGljIHN0cnVjdCBjbWRuYW1lX2hlbHAgY29tbW9uX2NtZHNbXSA9IHsiCisKK3NlZCAtbiAtZSAncy9ecGVyZi1cKFteIAldKlwpWyAJXS4qIGNvbW1vbi4qL1wxL3AnIGNvbW1hbmQtbGlzdC50eHQgfAorc29ydCB8Cit3aGlsZSByZWFkIGNtZAorZG8KKyAgICAgc2VkIC1uICcKKyAgICAgL15OQU1FLywvcGVyZi0nIiRjbWQiJy9ICisgICAgICR7CisgICAgICAgICAgICB4CisgICAgICAgICAgICBzLy4qcGVyZi0nIiRjbWQiJyAtIFwoLipcKS8gIHsiJyIkY21kIiciLCAiXDEifSwvCisJICAgIHAKKyAgICAgfScgIkRvY3VtZW50YXRpb24vcGVyZi0kY21kLnR4dCIKK2RvbmUKK2VjaG8gIn07IgpkaWZmIC0tZ2l0IGEvdG9vbHMvcGVyZi91dGlsL2hlbHAuYyBiL3Rvb2xzL3BlcmYvdXRpbC9oZWxwLmMKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uNjY1M2Y3ZAotLS0gL2Rldi9udWxsCisrKyBiL3Rvb2xzL3BlcmYvdXRpbC9oZWxwLmMKQEAgLTAsMCArMSwzNjcgQEAKKyNpbmNsdWRlICJjYWNoZS5oIgorI2luY2x1ZGUgIi4uL2J1aWx0aW4uaCIKKyNpbmNsdWRlICJleGVjX2NtZC5oIgorI2luY2x1ZGUgImxldmVuc2h0ZWluLmgiCisjaW5jbHVkZSAiaGVscC5oIgorCisvKiBtb3N0IEdVSSB0ZXJtaW5hbHMgc2V0IENPTFVNTlMgKGFsdGhvdWdoIHNvbWUgZG9uJ3QgZXhwb3J0IGl0KSAqLworc3RhdGljIGludCB0ZXJtX2NvbHVtbnModm9pZCkKK3sKKwljaGFyICpjb2xfc3RyaW5nID0gZ2V0ZW52KCJDT0xVTU5TIik7CisJaW50IG5fY29sczsKKworCWlmIChjb2xfc3RyaW5nICYmIChuX2NvbHMgPSBhdG9pKGNvbF9zdHJpbmcpKSA+IDApCisJCXJldHVybiBuX2NvbHM7CisKKyNpZmRlZiBUSU9DR1dJTlNaCisJeworCQlzdHJ1Y3Qgd2luc2l6ZSB3czsKKwkJaWYgKCFpb2N0bCgxLCBUSU9DR1dJTlNaLCAmd3MpKSB7CisJCQlpZiAod3Mud3NfY29sKQorCQkJCXJldHVybiB3cy53c19jb2w7CisJCX0KKwl9CisjZW5kaWYKKworCXJldHVybiA4MDsKK30KKwordm9pZCBhZGRfY21kbmFtZShzdHJ1Y3QgY21kbmFtZXMgKmNtZHMsIGNvbnN0IGNoYXIgKm5hbWUsIGludCBsZW4pCit7CisJc3RydWN0IGNtZG5hbWUgKmVudCA9IG1hbGxvYyhzaXplb2YoKmVudCkgKyBsZW4gKyAxKTsKKworCWVudC0+bGVuID0gbGVuOworCW1lbWNweShlbnQtPm5hbWUsIG5hbWUsIGxlbik7CisJZW50LT5uYW1lW2xlbl0gPSAwOworCisJQUxMT0NfR1JPVyhjbWRzLT5uYW1lcywgY21kcy0+Y250ICsgMSwgY21kcy0+YWxsb2MpOworCWNtZHMtPm5hbWVzW2NtZHMtPmNudCsrXSA9IGVudDsKK30KKworc3RhdGljIHZvaWQgY2xlYW5fY21kbmFtZXMoc3RydWN0IGNtZG5hbWVzICpjbWRzKQoreworCWludCBpOworCWZvciAoaSA9IDA7IGkgPCBjbWRzLT5jbnQ7ICsraSkKKwkJZnJlZShjbWRzLT5uYW1lc1tpXSk7CisJZnJlZShjbWRzLT5uYW1lcyk7CisJY21kcy0+Y250ID0gMDsKKwljbWRzLT5hbGxvYyA9IDA7Cit9CisKK3N0YXRpYyBpbnQgY21kbmFtZV9jb21wYXJlKGNvbnN0IHZvaWQgKmFfLCBjb25zdCB2b2lkICpiXykKK3sKKwlzdHJ1Y3QgY21kbmFtZSAqYSA9ICooc3RydWN0IGNtZG5hbWUgKiopYV87CisJc3RydWN0IGNtZG5hbWUgKmIgPSAqKHN0cnVjdCBjbWRuYW1lICoqKWJfOworCXJldHVybiBzdHJjbXAoYS0+bmFtZSwgYi0+bmFtZSk7Cit9CisKK3N0YXRpYyB2b2lkIHVuaXEoc3RydWN0IGNtZG5hbWVzICpjbWRzKQoreworCWludCBpLCBqOworCisJaWYgKCFjbWRzLT5jbnQpCisJCXJldHVybjsKKworCWZvciAoaSA9IGogPSAxOyBpIDwgY21kcy0+Y250OyBpKyspCisJCWlmIChzdHJjbXAoY21kcy0+bmFtZXNbaV0tPm5hbWUsIGNtZHMtPm5hbWVzW2ktMV0tPm5hbWUpKQorCQkJY21kcy0+bmFtZXNbaisrXSA9IGNtZHMtPm5hbWVzW2ldOworCisJY21kcy0+Y250ID0gajsKK30KKwordm9pZCBleGNsdWRlX2NtZHMoc3RydWN0IGNtZG5hbWVzICpjbWRzLCBzdHJ1Y3QgY21kbmFtZXMgKmV4Y2x1ZGVzKQoreworCWludCBjaSwgY2osIGVpOworCWludCBjbXA7CisKKwljaSA9IGNqID0gZWkgPSAwOworCXdoaWxlIChjaSA8IGNtZHMtPmNudCAmJiBlaSA8IGV4Y2x1ZGVzLT5jbnQpIHsKKwkJY21wID0gc3RyY21wKGNtZHMtPm5hbWVzW2NpXS0+bmFtZSwgZXhjbHVkZXMtPm5hbWVzW2VpXS0+bmFtZSk7CisJCWlmIChjbXAgPCAwKQorCQkJY21kcy0+bmFtZXNbY2orK10gPSBjbWRzLT5uYW1lc1tjaSsrXTsKKwkJZWxzZSBpZiAoY21wID09IDApCisJCQljaSsrLCBlaSsrOworCQllbHNlIGlmIChjbXAgPiAwKQorCQkJZWkrKzsKKwl9CisKKwl3aGlsZSAoY2kgPCBjbWRzLT5jbnQpCisJCWNtZHMtPm5hbWVzW2NqKytdID0gY21kcy0+bmFtZXNbY2krK107CisKKwljbWRzLT5jbnQgPSBjajsKK30KKworc3RhdGljIHZvaWQgcHJldHR5X3ByaW50X3N0cmluZ19saXN0KHN0cnVjdCBjbWRuYW1lcyAqY21kcywgaW50IGxvbmdlc3QpCit7CisJaW50IGNvbHMgPSAxLCByb3dzOworCWludCBzcGFjZSA9IGxvbmdlc3QgKyAxOyAvKiBtaW4gMSBTUCBiZXR3ZWVuIHdvcmRzICovCisJaW50IG1heF9jb2xzID0gdGVybV9jb2x1bW5zKCkgLSAxOyAvKiBkb24ndCBwcmludCAqb24qIHRoZSBlZGdlICovCisJaW50IGksIGo7CisKKwlpZiAoc3BhY2UgPCBtYXhfY29scykKKwkJY29scyA9IG1heF9jb2xzIC8gc3BhY2U7CisJcm93cyA9IChjbWRzLT5jbnQgKyBjb2xzIC0gMSkgLyBjb2xzOworCisJZm9yIChpID0gMDsgaSA8IHJvd3M7IGkrKykgeworCQlwcmludGYoIiAgIik7CisKKwkJZm9yIChqID0gMDsgaiA8IGNvbHM7IGorKykgeworCQkJaW50IG4gPSBqICogcm93cyArIGk7CisJCQlpbnQgc2l6ZSA9IHNwYWNlOworCQkJaWYgKG4gPj0gY21kcy0+Y250KQorCQkJCWJyZWFrOworCQkJaWYgKGogPT0gY29scy0xIHx8IG4gKyByb3dzID49IGNtZHMtPmNudCkKKwkJCQlzaXplID0gMTsKKwkJCXByaW50ZigiJS0qcyIsIHNpemUsIGNtZHMtPm5hbWVzW25dLT5uYW1lKTsKKwkJfQorCQlwdXRjaGFyKCdcbicpOworCX0KK30KKworc3RhdGljIGludCBpc19leGVjdXRhYmxlKGNvbnN0IGNoYXIgKm5hbWUpCit7CisJc3RydWN0IHN0YXQgc3Q7CisKKwlpZiAoc3RhdChuYW1lLCAmc3QpIHx8IC8qIHN0YXQsIG5vdCBsc3RhdCAqLworCSAgICAhU19JU1JFRyhzdC5zdF9tb2RlKSkKKwkJcmV0dXJuIDA7CisKKyNpZmRlZiBfX01JTkdXMzJfXworCS8qIGNhbm5vdCB0cnVzdCB0aGUgZXhlY3V0YWJsZSBiaXQsIHBlZWsgaW50byB0aGUgZmlsZSBpbnN0ZWFkICovCisJY2hhciBidWZbM10gPSB7IDAgfTsKKwlpbnQgbjsKKwlpbnQgZmQgPSBvcGVuKG5hbWUsIE9fUkRPTkxZKTsKKwlzdC5zdF9tb2RlICY9IH5TX0lYVVNSOworCWlmIChmZCA+PSAwKSB7CisJCW4gPSByZWFkKGZkLCBidWYsIDIpOworCQlpZiAobiA9PSAyKQorCQkJLyogRE9TIGV4ZWN1dGFibGVzIHN0YXJ0IHdpdGggIk1aIiAqLworCQkJaWYgKCFzdHJjbXAoYnVmLCAiIyEiKSB8fCAhc3RyY21wKGJ1ZiwgIk1aIikpCisJCQkJc3Quc3RfbW9kZSB8PSBTX0lYVVNSOworCQljbG9zZShmZCk7CisJfQorI2VuZGlmCisJcmV0dXJuIHN0LnN0X21vZGUgJiBTX0lYVVNSOworfQorCitzdGF0aWMgdm9pZCBsaXN0X2NvbW1hbmRzX2luX2RpcihzdHJ1Y3QgY21kbmFtZXMgKmNtZHMsCisJCQkJCSBjb25zdCBjaGFyICpwYXRoLAorCQkJCQkgY29uc3QgY2hhciAqcHJlZml4KQoreworCWludCBwcmVmaXhfbGVuOworCURJUiAqZGlyID0gb3BlbmRpcihwYXRoKTsKKwlzdHJ1Y3QgZGlyZW50ICpkZTsKKwlzdHJ1Y3Qgc3RyYnVmIGJ1ZiA9IFNUUkJVRl9JTklUOworCWludCBsZW47CisKKwlpZiAoIWRpcikKKwkJcmV0dXJuOworCWlmICghcHJlZml4KQorCQlwcmVmaXggPSAicGVyZi0iOworCXByZWZpeF9sZW4gPSBzdHJsZW4ocHJlZml4KTsKKworCXN0cmJ1Zl9hZGRmKCZidWYsICIlcy8iLCBwYXRoKTsKKwlsZW4gPSBidWYubGVuOworCisJd2hpbGUgKChkZSA9IHJlYWRkaXIoZGlyKSkgIT0gTlVMTCkgeworCQlpbnQgZW50bGVuOworCisJCWlmIChwcmVmaXhjbXAoZGUtPmRfbmFtZSwgcHJlZml4KSkKKwkJCWNvbnRpbnVlOworCisJCXN0cmJ1Zl9zZXRsZW4oJmJ1ZiwgbGVuKTsKKwkJc3RyYnVmX2FkZHN0cigmYnVmLCBkZS0+ZF9uYW1lKTsKKwkJaWYgKCFpc19leGVjdXRhYmxlKGJ1Zi5idWYpKQorCQkJY29udGludWU7CisKKwkJZW50bGVuID0gc3RybGVuKGRlLT5kX25hbWUpIC0gcHJlZml4X2xlbjsKKwkJaWYgKGhhc19leHRlbnNpb24oZGUtPmRfbmFtZSwgIi5leGUiKSkKKwkJCWVudGxlbiAtPSA0OworCisJCWFkZF9jbWRuYW1lKGNtZHMsIGRlLT5kX25hbWUgKyBwcmVmaXhfbGVuLCBlbnRsZW4pOworCX0KKwljbG9zZWRpcihkaXIpOworCXN0cmJ1Zl9yZWxlYXNlKCZidWYpOworfQorCit2b2lkIGxvYWRfY29tbWFuZF9saXN0KGNvbnN0IGNoYXIgKnByZWZpeCwKKwkJc3RydWN0IGNtZG5hbWVzICptYWluX2NtZHMsCisJCXN0cnVjdCBjbWRuYW1lcyAqb3RoZXJfY21kcykKK3sKKwljb25zdCBjaGFyICplbnZfcGF0aCA9IGdldGVudigiUEFUSCIpOworCWNvbnN0IGNoYXIgKmV4ZWNfcGF0aCA9IHBlcmZfZXhlY19wYXRoKCk7CisKKwlpZiAoZXhlY19wYXRoKSB7CisJCWxpc3RfY29tbWFuZHNfaW5fZGlyKG1haW5fY21kcywgZXhlY19wYXRoLCBwcmVmaXgpOworCQlxc29ydChtYWluX2NtZHMtPm5hbWVzLCBtYWluX2NtZHMtPmNudCwKKwkJICAgICAgc2l6ZW9mKCptYWluX2NtZHMtPm5hbWVzKSwgY21kbmFtZV9jb21wYXJlKTsKKwkJdW5pcShtYWluX2NtZHMpOworCX0KKworCWlmIChlbnZfcGF0aCkgeworCQljaGFyICpwYXRocywgKnBhdGgsICpjb2xvbjsKKwkJcGF0aCA9IHBhdGhzID0gc3RyZHVwKGVudl9wYXRoKTsKKwkJd2hpbGUgKDEpIHsKKwkJCWlmICgoY29sb24gPSBzdHJjaHIocGF0aCwgUEFUSF9TRVApKSkKKwkJCQkqY29sb24gPSAwOworCQkJaWYgKCFleGVjX3BhdGggfHwgc3RyY21wKHBhdGgsIGV4ZWNfcGF0aCkpCisJCQkJbGlzdF9jb21tYW5kc19pbl9kaXIob3RoZXJfY21kcywgcGF0aCwgcHJlZml4KTsKKworCQkJaWYgKCFjb2xvbikKKwkJCQlicmVhazsKKwkJCXBhdGggPSBjb2xvbiArIDE7CisJCX0KKwkJZnJlZShwYXRocyk7CisKKwkJcXNvcnQob3RoZXJfY21kcy0+bmFtZXMsIG90aGVyX2NtZHMtPmNudCwKKwkJICAgICAgc2l6ZW9mKCpvdGhlcl9jbWRzLT5uYW1lcyksIGNtZG5hbWVfY29tcGFyZSk7CisJCXVuaXEob3RoZXJfY21kcyk7CisJfQorCWV4Y2x1ZGVfY21kcyhvdGhlcl9jbWRzLCBtYWluX2NtZHMpOworfQorCit2b2lkIGxpc3RfY29tbWFuZHMoY29uc3QgY2hhciAqdGl0bGUsIHN0cnVjdCBjbWRuYW1lcyAqbWFpbl9jbWRzLAorCQkgICBzdHJ1Y3QgY21kbmFtZXMgKm90aGVyX2NtZHMpCit7CisJaW50IGksIGxvbmdlc3QgPSAwOworCisJZm9yIChpID0gMDsgaSA8IG1haW5fY21kcy0+Y250OyBpKyspCisJCWlmIChsb25nZXN0IDwgbWFpbl9jbWRzLT5uYW1lc1tpXS0+bGVuKQorCQkJbG9uZ2VzdCA9IG1haW5fY21kcy0+bmFtZXNbaV0tPmxlbjsKKwlmb3IgKGkgPSAwOyBpIDwgb3RoZXJfY21kcy0+Y250OyBpKyspCisJCWlmIChsb25nZXN0IDwgb3RoZXJfY21kcy0+bmFtZXNbaV0tPmxlbikKKwkJCWxvbmdlc3QgPSBvdGhlcl9jbWRzLT5uYW1lc1tpXS0+bGVuOworCisJaWYgKG1haW5fY21kcy0+Y250KSB7CisJCWNvbnN0IGNoYXIgKmV4ZWNfcGF0aCA9IHBlcmZfZXhlY19wYXRoKCk7CisJCXByaW50ZigiYXZhaWxhYmxlICVzIGluICclcydcbiIsIHRpdGxlLCBleGVjX3BhdGgpOworCQlwcmludGYoIi0tLS0tLS0tLS0tLS0tLS0iKTsKKwkJbXB1dF9jaGFyKCctJywgc3RybGVuKHRpdGxlKSArIHN0cmxlbihleGVjX3BhdGgpKTsKKwkJcHV0Y2hhcignXG4nKTsKKwkJcHJldHR5X3ByaW50X3N0cmluZ19saXN0KG1haW5fY21kcywgbG9uZ2VzdCk7CisJCXB1dGNoYXIoJ1xuJyk7CisJfQorCisJaWYgKG90aGVyX2NtZHMtPmNudCkgeworCQlwcmludGYoIiVzIGF2YWlsYWJsZSBmcm9tIGVsc2V3aGVyZSBvbiB5b3VyICRQQVRIXG4iLCB0aXRsZSk7CisJCXByaW50ZigiLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tIik7CisJCW1wdXRfY2hhcignLScsIHN0cmxlbih0aXRsZSkpOworCQlwdXRjaGFyKCdcbicpOworCQlwcmV0dHlfcHJpbnRfc3RyaW5nX2xpc3Qob3RoZXJfY21kcywgbG9uZ2VzdCk7CisJCXB1dGNoYXIoJ1xuJyk7CisJfQorfQorCitpbnQgaXNfaW5fY21kbGlzdChzdHJ1Y3QgY21kbmFtZXMgKmMsIGNvbnN0IGNoYXIgKnMpCit7CisJaW50IGk7CisJZm9yIChpID0gMDsgaSA8IGMtPmNudDsgaSsrKQorCQlpZiAoIXN0cmNtcChzLCBjLT5uYW1lc1tpXS0+bmFtZSkpCisJCQlyZXR1cm4gMTsKKwlyZXR1cm4gMDsKK30KKworc3RhdGljIGludCBhdXRvY29ycmVjdDsKK3N0YXRpYyBzdHJ1Y3QgY21kbmFtZXMgYWxpYXNlczsKKworc3RhdGljIGludCBwZXJmX3Vua25vd25fY21kX2NvbmZpZyhjb25zdCBjaGFyICp2YXIsIGNvbnN0IGNoYXIgKnZhbHVlLCB2b2lkICpjYikKK3sKKwlpZiAoIXN0cmNtcCh2YXIsICJoZWxwLmF1dG9jb3JyZWN0IikpCisJCWF1dG9jb3JyZWN0ID0gcGVyZl9jb25maWdfaW50KHZhcix2YWx1ZSk7CisJLyogQWxzbyB1c2UgYWxpYXNlcyBmb3IgY29tbWFuZCBsb29rdXAgKi8KKwlpZiAoIXByZWZpeGNtcCh2YXIsICJhbGlhcy4iKSkKKwkJYWRkX2NtZG5hbWUoJmFsaWFzZXMsIHZhciArIDYsIHN0cmxlbih2YXIgKyA2KSk7CisKKwlyZXR1cm4gcGVyZl9kZWZhdWx0X2NvbmZpZyh2YXIsIHZhbHVlLCBjYik7Cit9CisKK3N0YXRpYyBpbnQgbGV2ZW5zaHRlaW5fY29tcGFyZShjb25zdCB2b2lkICpwMSwgY29uc3Qgdm9pZCAqcDIpCit7CisJY29uc3Qgc3RydWN0IGNtZG5hbWUgKmNvbnN0ICpjMSA9IHAxLCAqY29uc3QgKmMyID0gcDI7CisJY29uc3QgY2hhciAqczEgPSAoKmMxKS0+bmFtZSwgKnMyID0gKCpjMiktPm5hbWU7CisJaW50IGwxID0gKCpjMSktPmxlbjsKKwlpbnQgbDIgPSAoKmMyKS0+bGVuOworCXJldHVybiBsMSAhPSBsMiA/IGwxIC0gbDIgOiBzdHJjbXAoczEsIHMyKTsKK30KKworc3RhdGljIHZvaWQgYWRkX2NtZF9saXN0KHN0cnVjdCBjbWRuYW1lcyAqY21kcywgc3RydWN0IGNtZG5hbWVzICpvbGQpCit7CisJaW50IGk7CisJQUxMT0NfR1JPVyhjbWRzLT5uYW1lcywgY21kcy0+Y250ICsgb2xkLT5jbnQsIGNtZHMtPmFsbG9jKTsKKworCWZvciAoaSA9IDA7IGkgPCBvbGQtPmNudDsgaSsrKQorCQljbWRzLT5uYW1lc1tjbWRzLT5jbnQrK10gPSBvbGQtPm5hbWVzW2ldOworCWZyZWUob2xkLT5uYW1lcyk7CisJb2xkLT5jbnQgPSAwOworCW9sZC0+bmFtZXMgPSBOVUxMOworfQorCitjb25zdCBjaGFyICpoZWxwX3Vua25vd25fY21kKGNvbnN0IGNoYXIgKmNtZCkKK3sKKwlpbnQgaSwgbiA9IDAsIGJlc3Rfc2ltaWxhcml0eSA9IDA7CisJc3RydWN0IGNtZG5hbWVzIG1haW5fY21kcywgb3RoZXJfY21kczsKKworCW1lbXNldCgmbWFpbl9jbWRzLCAwLCBzaXplb2YobWFpbl9jbWRzKSk7CisJbWVtc2V0KCZvdGhlcl9jbWRzLCAwLCBzaXplb2YobWFpbl9jbWRzKSk7CisJbWVtc2V0KCZhbGlhc2VzLCAwLCBzaXplb2YoYWxpYXNlcykpOworCisJcGVyZl9jb25maWcocGVyZl91bmtub3duX2NtZF9jb25maWcsIE5VTEwpOworCisJbG9hZF9jb21tYW5kX2xpc3QoInBlcmYtIiwgJm1haW5fY21kcywgJm90aGVyX2NtZHMpOworCisJYWRkX2NtZF9saXN0KCZtYWluX2NtZHMsICZhbGlhc2VzKTsKKwlhZGRfY21kX2xpc3QoJm1haW5fY21kcywgJm90aGVyX2NtZHMpOworCXFzb3J0KG1haW5fY21kcy5uYW1lcywgbWFpbl9jbWRzLmNudCwKKwkgICAgICBzaXplb2YobWFpbl9jbWRzLm5hbWVzKSwgY21kbmFtZV9jb21wYXJlKTsKKwl1bmlxKCZtYWluX2NtZHMpOworCisJaWYgKG1haW5fY21kcy5jbnQpIHsKKwkJLyogVGhpcyByZXVzZXMgY21kbmFtZS0+bGVuIGZvciBzaW1pbGFyaXR5IGluZGV4ICovCisJCWZvciAoaSA9IDA7IGkgPCBtYWluX2NtZHMuY250OyArK2kpCisJCQltYWluX2NtZHMubmFtZXNbaV0tPmxlbiA9CisJCQkJbGV2ZW5zaHRlaW4oY21kLCBtYWluX2NtZHMubmFtZXNbaV0tPm5hbWUsIDAsIDIsIDEsIDQpOworCisJCXFzb3J0KG1haW5fY21kcy5uYW1lcywgbWFpbl9jbWRzLmNudCwKKwkJICAgICAgc2l6ZW9mKCptYWluX2NtZHMubmFtZXMpLCBsZXZlbnNodGVpbl9jb21wYXJlKTsKKworCQliZXN0X3NpbWlsYXJpdHkgPSBtYWluX2NtZHMubmFtZXNbMF0tPmxlbjsKKwkJbiA9IDE7CisJCXdoaWxlIChuIDwgbWFpbl9jbWRzLmNudCAmJiBiZXN0X3NpbWlsYXJpdHkgPT0gbWFpbl9jbWRzLm5hbWVzW25dLT5sZW4pCisJCQkrK247CisJfQorCisJaWYgKGF1dG9jb3JyZWN0ICYmIG4gPT0gMSkgeworCQljb25zdCBjaGFyICphc3N1bWVkID0gbWFpbl9jbWRzLm5hbWVzWzBdLT5uYW1lOworCisJCW1haW5fY21kcy5uYW1lc1swXSA9IE5VTEw7CisJCWNsZWFuX2NtZG5hbWVzKCZtYWluX2NtZHMpOworCQlmcHJpbnRmKHN0ZGVyciwgIldBUk5JTkc6IFlvdSBjYWxsZWQgYSBHaXQgcHJvZ3JhbSBuYW1lZCAnJXMnLCAiCisJCQkid2hpY2ggZG9lcyBub3QgZXhpc3QuXG4iCisJCQkiQ29udGludWluZyB1bmRlciB0aGUgYXNzdW1wdGlvbiB0aGF0IHlvdSBtZWFudCAnJXMnXG4iLAorCQkJY21kLCBhc3N1bWVkKTsKKwkJaWYgKGF1dG9jb3JyZWN0ID4gMCkgeworCQkJZnByaW50ZihzdGRlcnIsICJpbiAlMC4xZiBzZWNvbmRzIGF1dG9tYXRpY2FsbHkuLi5cbiIsCisJCQkJKGZsb2F0KWF1dG9jb3JyZWN0LzEwLjApOworCQkJcG9sbChOVUxMLCAwLCBhdXRvY29ycmVjdCAqIDEwMCk7CisJCX0KKwkJcmV0dXJuIGFzc3VtZWQ7CisJfQorCisJZnByaW50ZihzdGRlcnIsICJwZXJmOiAnJXMnIGlzIG5vdCBhIHBlcmYtY29tbWFuZC4gU2VlICdwZXJmIC0taGVscCcuXG4iLCBjbWQpOworCisJaWYgKG1haW5fY21kcy5jbnQgJiYgYmVzdF9zaW1pbGFyaXR5IDwgNikgeworCQlmcHJpbnRmKHN0ZGVyciwgIlxuRGlkIHlvdSBtZWFuICVzP1xuIiwKKwkJCW4gPCAyID8gInRoaXMiOiAib25lIG9mIHRoZXNlIik7CisKKwkJZm9yIChpID0gMDsgaSA8IG47IGkrKykKKwkJCWZwcmludGYoc3RkZXJyLCAiXHQlc1xuIiwgbWFpbl9jbWRzLm5hbWVzW2ldLT5uYW1lKTsKKwl9CisKKwlleGl0KDEpOworfQorCitpbnQgY21kX3ZlcnNpb24oaW50IGFyZ2MsIGNvbnN0IGNoYXIgKiphcmd2LCBjb25zdCBjaGFyICpwcmVmaXgpCit7CisJcHJpbnRmKCJwZXJmIHZlcnNpb24gJXNcbiIsIHBlcmZfdmVyc2lvbl9zdHJpbmcpOworCXJldHVybiAwOworfQpkaWZmIC0tZ2l0IGEvdG9vbHMvcGVyZi91dGlsL2hlbHAuaCBiL3Rvb2xzL3BlcmYvdXRpbC9oZWxwLmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uNTZiYzE1NAotLS0gL2Rldi9udWxsCisrKyBiL3Rvb2xzL3BlcmYvdXRpbC9oZWxwLmgKQEAgLTAsMCArMSwyOSBAQAorI2lmbmRlZiBIRUxQX0gKKyNkZWZpbmUgSEVMUF9ICisKK3N0cnVjdCBjbWRuYW1lcyB7CisJaW50IGFsbG9jOworCWludCBjbnQ7CisJc3RydWN0IGNtZG5hbWUgeworCQlzaXplX3QgbGVuOyAvKiBhbHNvIHVzZWQgZm9yIHNpbWlsYXJpdHkgaW5kZXggaW4gaGVscC5jICovCisJCWNoYXIgbmFtZVtGTEVYX0FSUkFZXTsKKwl9ICoqbmFtZXM7Cit9OworCitzdGF0aWMgaW5saW5lIHZvaWQgbXB1dF9jaGFyKGNoYXIgYywgdW5zaWduZWQgaW50IG51bSkKK3sKKwl3aGlsZShudW0tLSkKKwkJcHV0Y2hhcihjKTsKK30KKwordm9pZCBsb2FkX2NvbW1hbmRfbGlzdChjb25zdCBjaGFyICpwcmVmaXgsCisJCXN0cnVjdCBjbWRuYW1lcyAqbWFpbl9jbWRzLAorCQlzdHJ1Y3QgY21kbmFtZXMgKm90aGVyX2NtZHMpOwordm9pZCBhZGRfY21kbmFtZShzdHJ1Y3QgY21kbmFtZXMgKmNtZHMsIGNvbnN0IGNoYXIgKm5hbWUsIGludCBsZW4pOworLyogSGVyZSB3ZSByZXF1aXJlIHRoYXQgZXhjbHVkZXMgaXMgYSBzb3J0ZWQgbGlzdC4gKi8KK3ZvaWQgZXhjbHVkZV9jbWRzKHN0cnVjdCBjbWRuYW1lcyAqY21kcywgc3RydWN0IGNtZG5hbWVzICpleGNsdWRlcyk7CitpbnQgaXNfaW5fY21kbGlzdChzdHJ1Y3QgY21kbmFtZXMgKmMsIGNvbnN0IGNoYXIgKnMpOwordm9pZCBsaXN0X2NvbW1hbmRzKGNvbnN0IGNoYXIgKnRpdGxlLCBzdHJ1Y3QgY21kbmFtZXMgKm1haW5fY21kcywKKwkJICAgc3RydWN0IGNtZG5hbWVzICpvdGhlcl9jbWRzKTsKKworI2VuZGlmIC8qIEhFTFBfSCAqLwpkaWZmIC0tZ2l0IGEvdG9vbHMvcGVyZi91dGlsL2xldmVuc2h0ZWluLmMgYi90b29scy9wZXJmL3V0aWwvbGV2ZW5zaHRlaW4uYwpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi5lNTIxZDE1Ci0tLSAvZGV2L251bGwKKysrIGIvdG9vbHMvcGVyZi91dGlsL2xldmVuc2h0ZWluLmMKQEAgLTAsMCArMSw4NCBAQAorI2luY2x1ZGUgImNhY2hlLmgiCisjaW5jbHVkZSAibGV2ZW5zaHRlaW4uaCIKKworLyoKKyAqIFRoaXMgZnVuY3Rpb24gaW1wbGVtZW50cyB0aGUgRGFtZXJhdS1MZXZlbnNodGVpbiBhbGdvcml0aG0gdG8KKyAqIGNhbGN1bGF0ZSBhIGRpc3RhbmNlIGJldHdlZW4gc3RyaW5ncy4KKyAqCisgKiBCYXNpY2FsbHksIGl0IHNheXMgaG93IG1hbnkgbGV0dGVycyBuZWVkIHRvIGJlIHN3YXBwZWQsIHN1YnN0aXR1dGVkLAorICogZGVsZXRlZCBmcm9tLCBvciBhZGRlZCB0byBzdHJpbmcxLCBhdCBsZWFzdCwgdG8gZ2V0IHN0cmluZzIuCisgKgorICogVGhlIGlkZWEgaXMgdG8gYnVpbGQgYSBkaXN0YW5jZSBtYXRyaXggZm9yIHRoZSBzdWJzdHJpbmdzIG9mIGJvdGgKKyAqIHN0cmluZ3MuICBUbyBhdm9pZCBhIGxhcmdlIHNwYWNlIGNvbXBsZXhpdHksIG9ubHkgdGhlIGxhc3QgdGhyZWUgcm93cworICogYXJlIGtlcHQgaW4gbWVtb3J5IChpZiBzd2FwcyBoYWQgdGhlIHNhbWUgb3IgaGlnaGVyIGNvc3QgYXMgb25lIGRlbGV0aW9uCisgKiBwbHVzIG9uZSBpbnNlcnRpb24sIG9ubHkgdHdvIHJvd3Mgd291bGQgYmUgbmVlZGVkKS4KKyAqCisgKiBBdCBhbnkgc3RhZ2UsICJpICsgMSIgZGVub3RlcyB0aGUgbGVuZ3RoIG9mIHRoZSBjdXJyZW50IHN1YnN0cmluZyBvZgorICogc3RyaW5nMSB0aGF0IHRoZSBkaXN0YW5jZSBpcyBjYWxjdWxhdGVkIGZvci4KKyAqCisgKiByb3cyIGhvbGRzIHRoZSBjdXJyZW50IHJvdywgcm93MSB0aGUgcHJldmlvdXMgcm93IChpLmUuIGZvciB0aGUgc3Vic3RyaW5nCisgKiBvZiBzdHJpbmcxIG9mIGxlbmd0aCAiaSIpLCBhbmQgcm93MCB0aGUgcm93IGJlZm9yZSB0aGF0LgorICoKKyAqIEluIG90aGVyIHdvcmRzLCBhdCB0aGUgc3RhcnQgb2YgdGhlIGJpZyBsb29wLCByb3cyW2ogKyAxXSBjb250YWlucyB0aGUKKyAqIERhbWVyYXUtTGV2ZW5zaHRlaW4gZGlzdGFuY2UgYmV0d2VlbiB0aGUgc3Vic3RyaW5nIG9mIHN0cmluZzEgb2YgbGVuZ3RoCisgKiAiaSIgYW5kIHRoZSBzdWJzdHJpbmcgb2Ygc3RyaW5nMiBvZiBsZW5ndGggImogKyAxIi4KKyAqCisgKiBBbGwgdGhlIGJpZyBsb29wIGRvZXMgaXMgZGV0ZXJtaW5lIHRoZSBwYXJ0aWFsIG1pbmltdW0tY29zdCBwYXRocy4KKyAqCisgKiBJdCBkb2VzIHNvIGJ5IGNhbGN1bGF0aW5nIHRoZSBjb3N0cyBvZiB0aGUgcGF0aCBlbmRpbmcgaW4gY2hhcmFjdGVycworICogaSAoaW4gc3RyaW5nMSkgYW5kIGogKGluIHN0cmluZzIpLCByZXNwZWN0aXZlbHksIGdpdmVuIHRoYXQgdGhlIGxhc3QKKyAqIG9wZXJhdGlvbiBpcyBhIHN1YnN0aXRpb24sIGEgc3dhcCwgYSBkZWxldGlvbiwgb3IgYW4gaW5zZXJ0aW9uLgorICoKKyAqIFRoaXMgaW1wbGVtZW50YXRpb24gYWxsb3dzIHRoZSBjb3N0cyB0byBiZSB3ZWlnaHRlZDoKKyAqCisgKiAtIHcgKGFzIGluICJzV2FwIikKKyAqIC0gcyAoYXMgaW4gIlN1YnN0aXR1dGlvbiIpCisgKiAtIGEgKGZvciBpbnNlcnRpb24sIEFLQSAiQWRkIikKKyAqIC0gZCAoYXMgaW4gIkRlbGV0aW9uIikKKyAqCisgKiBOb3RlIHRoYXQgdGhpcyBhbGdvcml0aG0gY2FsY3VsYXRlcyBhIGRpc3RhbmNlIF9pZmZfIGQgPT0gYS4KKyAqLworaW50IGxldmVuc2h0ZWluKGNvbnN0IGNoYXIgKnN0cmluZzEsIGNvbnN0IGNoYXIgKnN0cmluZzIsCisJCWludCB3LCBpbnQgcywgaW50IGEsIGludCBkKQoreworCWludCBsZW4xID0gc3RybGVuKHN0cmluZzEpLCBsZW4yID0gc3RybGVuKHN0cmluZzIpOworCWludCAqcm93MCA9IG1hbGxvYyhzaXplb2YoaW50KSAqIChsZW4yICsgMSkpOworCWludCAqcm93MSA9IG1hbGxvYyhzaXplb2YoaW50KSAqIChsZW4yICsgMSkpOworCWludCAqcm93MiA9IG1hbGxvYyhzaXplb2YoaW50KSAqIChsZW4yICsgMSkpOworCWludCBpLCBqOworCisJZm9yIChqID0gMDsgaiA8PSBsZW4yOyBqKyspCisJCXJvdzFbal0gPSBqICogYTsKKwlmb3IgKGkgPSAwOyBpIDwgbGVuMTsgaSsrKSB7CisJCWludCAqZHVtbXk7CisKKwkJcm93MlswXSA9IChpICsgMSkgKiBkOworCQlmb3IgKGogPSAwOyBqIDwgbGVuMjsgaisrKSB7CisJCQkvKiBzdWJzdGl0dXRpb24gKi8KKwkJCXJvdzJbaiArIDFdID0gcm93MVtqXSArIHMgKiAoc3RyaW5nMVtpXSAhPSBzdHJpbmcyW2pdKTsKKwkJCS8qIHN3YXAgKi8KKwkJCWlmIChpID4gMCAmJiBqID4gMCAmJiBzdHJpbmcxW2kgLSAxXSA9PSBzdHJpbmcyW2pdICYmCisJCQkJCXN0cmluZzFbaV0gPT0gc3RyaW5nMltqIC0gMV0gJiYKKwkJCQkJcm93MltqICsgMV0gPiByb3cwW2ogLSAxXSArIHcpCisJCQkJcm93MltqICsgMV0gPSByb3cwW2ogLSAxXSArIHc7CisJCQkvKiBkZWxldGlvbiAqLworCQkJaWYgKHJvdzJbaiArIDFdID4gcm93MVtqICsgMV0gKyBkKQorCQkJCXJvdzJbaiArIDFdID0gcm93MVtqICsgMV0gKyBkOworCQkJLyogaW5zZXJ0aW9uICovCisJCQlpZiAocm93MltqICsgMV0gPiByb3cyW2pdICsgYSkKKwkJCQlyb3cyW2ogKyAxXSA9IHJvdzJbal0gKyBhOworCQl9CisKKwkJZHVtbXkgPSByb3cwOworCQlyb3cwID0gcm93MTsKKwkJcm93MSA9IHJvdzI7CisJCXJvdzIgPSBkdW1teTsKKwl9CisKKwlpID0gcm93MVtsZW4yXTsKKwlmcmVlKHJvdzApOworCWZyZWUocm93MSk7CisJZnJlZShyb3cyKTsKKworCXJldHVybiBpOworfQpkaWZmIC0tZ2l0IGEvdG9vbHMvcGVyZi91dGlsL2xldmVuc2h0ZWluLmggYi90b29scy9wZXJmL3V0aWwvbGV2ZW5zaHRlaW4uaApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi4wMTczYWJlCi0tLSAvZGV2L251bGwKKysrIGIvdG9vbHMvcGVyZi91dGlsL2xldmVuc2h0ZWluLmgKQEAgLTAsMCArMSw4IEBACisjaWZuZGVmIExFVkVOU0hURUlOX0gKKyNkZWZpbmUgTEVWRU5TSFRFSU5fSAorCitpbnQgbGV2ZW5zaHRlaW4oY29uc3QgY2hhciAqc3RyaW5nMSwgY29uc3QgY2hhciAqc3RyaW5nMiwKKwlpbnQgc3dhcF9wZW5hbHR5LCBpbnQgc3Vic3RpdGlvbl9wZW5hbHR5LAorCWludCBpbnNlcnRpb25fcGVuYWx0eSwgaW50IGRlbGV0aW9uX3BlbmFsdHkpOworCisjZW5kaWYKZGlmZiAtLWdpdCBhL3Rvb2xzL3BlcmYvdXRpbC9saXN0LmggYi90b29scy9wZXJmL3V0aWwvbGlzdC5oCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLmUyNTQ4ZTgKLS0tIC9kZXYvbnVsbAorKysgYi90b29scy9wZXJmL3V0aWwvbGlzdC5oCkBAIC0wLDAgKzEsNjAzIEBACisjaWZuZGVmIF9MSU5VWF9MSVNUX0gKKyNkZWZpbmUgX0xJTlVYX0xJU1RfSAorLyoKKyAgQ29weXJpZ2h0IChDKSBDYXN0IG9mIGRvemVucywgY29tZXMgZnJvbSB0aGUgTGludXgga2VybmVsCisKKyAgVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkgaXQKKyAgdW5kZXIgdGhlIHRlcm1zIG9mIHZlcnNpb24gMiBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgYXMKKyAgcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24uCisqLworCisjaW5jbHVkZSA8c3RkZGVmLmg+CisKKy8qCisgKiBUaGVzZSBhcmUgbm9uLU5VTEwgcG9pbnRlcnMgdGhhdCB3aWxsIHJlc3VsdCBpbiBwYWdlIGZhdWx0cworICogdW5kZXIgbm9ybWFsIGNpcmN1bXN0YW5jZXMsIHVzZWQgdG8gdmVyaWZ5IHRoYXQgbm9ib2R5IHVzZXMKKyAqIG5vbi1pbml0aWFsaXplZCBsaXN0IGVudHJpZXMuCisgKi8KKyNkZWZpbmUgTElTVF9QT0lTT04xICgodm9pZCAqKTB4MDAxMDAxMDApCisjZGVmaW5lIExJU1RfUE9JU09OMiAoKHZvaWQgKikweDAwMjAwMjAwKQorCisvKioKKyAqIGNvbnRhaW5lcl9vZiAtIGNhc3QgYSBtZW1iZXIgb2YgYSBzdHJ1Y3R1cmUgb3V0IHRvIHRoZSBjb250YWluaW5nIHN0cnVjdHVyZQorICogQHB0cjoJdGhlIHBvaW50ZXIgdG8gdGhlIG1lbWJlci4KKyAqIEB0eXBlOgl0aGUgdHlwZSBvZiB0aGUgY29udGFpbmVyIHN0cnVjdCB0aGlzIGlzIGVtYmVkZGVkIGluLgorICogQG1lbWJlcjoJdGhlIG5hbWUgb2YgdGhlIG1lbWJlciB3aXRoaW4gdGhlIHN0cnVjdC4KKyAqCisgKi8KKyNkZWZpbmUgY29udGFpbmVyX29mKHB0ciwgdHlwZSwgbWVtYmVyKSAoewkJCVwKKyAgICAgICAgY29uc3QgdHlwZW9mKCAoKHR5cGUgKikwKS0+bWVtYmVyICkgKl9fbXB0ciA9IChwdHIpOwlcCisgICAgICAgICh0eXBlICopKCAoY2hhciAqKV9fbXB0ciAtIG9mZnNldG9mKHR5cGUsbWVtYmVyKSApO30pCisKKy8qCisgKiBTaW1wbGUgZG91Ymx5IGxpbmtlZCBsaXN0IGltcGxlbWVudGF0aW9uLgorICoKKyAqIFNvbWUgb2YgdGhlIGludGVybmFsIGZ1bmN0aW9ucyAoIl9feHh4IikgYXJlIHVzZWZ1bCB3aGVuCisgKiBtYW5pcHVsYXRpbmcgd2hvbGUgbGlzdHMgcmF0aGVyIHRoYW4gc2luZ2xlIGVudHJpZXMsIGFzCisgKiBzb21ldGltZXMgd2UgYWxyZWFkeSBrbm93IHRoZSBuZXh0L3ByZXYgZW50cmllcyBhbmQgd2UgY2FuCisgKiBnZW5lcmF0ZSBiZXR0ZXIgY29kZSBieSB1c2luZyB0aGVtIGRpcmVjdGx5IHJhdGhlciB0aGFuCisgKiB1c2luZyB0aGUgZ2VuZXJpYyBzaW5nbGUtZW50cnkgcm91dGluZXMuCisgKi8KKworc3RydWN0IGxpc3RfaGVhZCB7CisJc3RydWN0IGxpc3RfaGVhZCAqbmV4dCwgKnByZXY7Cit9OworCisjZGVmaW5lIExJU1RfSEVBRF9JTklUKG5hbWUpIHsgJihuYW1lKSwgJihuYW1lKSB9CisKKyNkZWZpbmUgTElTVF9IRUFEKG5hbWUpIFwKKwlzdHJ1Y3QgbGlzdF9oZWFkIG5hbWUgPSBMSVNUX0hFQURfSU5JVChuYW1lKQorCitzdGF0aWMgaW5saW5lIHZvaWQgSU5JVF9MSVNUX0hFQUQoc3RydWN0IGxpc3RfaGVhZCAqbGlzdCkKK3sKKwlsaXN0LT5uZXh0ID0gbGlzdDsKKwlsaXN0LT5wcmV2ID0gbGlzdDsKK30KKworLyoKKyAqIEluc2VydCBhIG5ldyBlbnRyeSBiZXR3ZWVuIHR3byBrbm93biBjb25zZWN1dGl2ZSBlbnRyaWVzLgorICoKKyAqIFRoaXMgaXMgb25seSBmb3IgaW50ZXJuYWwgbGlzdCBtYW5pcHVsYXRpb24gd2hlcmUgd2Uga25vdworICogdGhlIHByZXYvbmV4dCBlbnRyaWVzIGFscmVhZHkhCisgKi8KK3N0YXRpYyBpbmxpbmUgdm9pZCBfX2xpc3RfYWRkKHN0cnVjdCBsaXN0X2hlYWQgKm5ldywKKwkJCSAgICAgIHN0cnVjdCBsaXN0X2hlYWQgKnByZXYsCisJCQkgICAgICBzdHJ1Y3QgbGlzdF9oZWFkICpuZXh0KQoreworCW5leHQtPnByZXYgPSBuZXc7CisJbmV3LT5uZXh0ID0gbmV4dDsKKwluZXctPnByZXYgPSBwcmV2OworCXByZXYtPm5leHQgPSBuZXc7Cit9CisKKy8qKgorICogbGlzdF9hZGQgLSBhZGQgYSBuZXcgZW50cnkKKyAqIEBuZXc6IG5ldyBlbnRyeSB0byBiZSBhZGRlZAorICogQGhlYWQ6IGxpc3QgaGVhZCB0byBhZGQgaXQgYWZ0ZXIKKyAqCisgKiBJbnNlcnQgYSBuZXcgZW50cnkgYWZ0ZXIgdGhlIHNwZWNpZmllZCBoZWFkLgorICogVGhpcyBpcyBnb29kIGZvciBpbXBsZW1lbnRpbmcgc3RhY2tzLgorICovCitzdGF0aWMgaW5saW5lIHZvaWQgbGlzdF9hZGQoc3RydWN0IGxpc3RfaGVhZCAqbmV3LCBzdHJ1Y3QgbGlzdF9oZWFkICpoZWFkKQoreworCV9fbGlzdF9hZGQobmV3LCBoZWFkLCBoZWFkLT5uZXh0KTsKK30KKworLyoqCisgKiBsaXN0X2FkZF90YWlsIC0gYWRkIGEgbmV3IGVudHJ5CisgKiBAbmV3OiBuZXcgZW50cnkgdG8gYmUgYWRkZWQKKyAqIEBoZWFkOiBsaXN0IGhlYWQgdG8gYWRkIGl0IGJlZm9yZQorICoKKyAqIEluc2VydCBhIG5ldyBlbnRyeSBiZWZvcmUgdGhlIHNwZWNpZmllZCBoZWFkLgorICogVGhpcyBpcyB1c2VmdWwgZm9yIGltcGxlbWVudGluZyBxdWV1ZXMuCisgKi8KK3N0YXRpYyBpbmxpbmUgdm9pZCBsaXN0X2FkZF90YWlsKHN0cnVjdCBsaXN0X2hlYWQgKm5ldywgc3RydWN0IGxpc3RfaGVhZCAqaGVhZCkKK3sKKwlfX2xpc3RfYWRkKG5ldywgaGVhZC0+cHJldiwgaGVhZCk7Cit9CisKKy8qCisgKiBEZWxldGUgYSBsaXN0IGVudHJ5IGJ5IG1ha2luZyB0aGUgcHJldi9uZXh0IGVudHJpZXMKKyAqIHBvaW50IHRvIGVhY2ggb3RoZXIuCisgKgorICogVGhpcyBpcyBvbmx5IGZvciBpbnRlcm5hbCBsaXN0IG1hbmlwdWxhdGlvbiB3aGVyZSB3ZSBrbm93CisgKiB0aGUgcHJldi9uZXh0IGVudHJpZXMgYWxyZWFkeSEKKyAqLworc3RhdGljIGlubGluZSB2b2lkIF9fbGlzdF9kZWwoc3RydWN0IGxpc3RfaGVhZCAqIHByZXYsIHN0cnVjdCBsaXN0X2hlYWQgKiBuZXh0KQoreworCW5leHQtPnByZXYgPSBwcmV2OworCXByZXYtPm5leHQgPSBuZXh0OworfQorCisvKioKKyAqIGxpc3RfZGVsIC0gZGVsZXRlcyBlbnRyeSBmcm9tIGxpc3QuCisgKiBAZW50cnk6IHRoZSBlbGVtZW50IHRvIGRlbGV0ZSBmcm9tIHRoZSBsaXN0LgorICogTm90ZTogbGlzdF9lbXB0eSBvbiBlbnRyeSBkb2VzIG5vdCByZXR1cm4gdHJ1ZSBhZnRlciB0aGlzLCB0aGUgZW50cnkgaXMKKyAqIGluIGFuIHVuZGVmaW5lZCBzdGF0ZS4KKyAqLworc3RhdGljIGlubGluZSB2b2lkIGxpc3RfZGVsKHN0cnVjdCBsaXN0X2hlYWQgKmVudHJ5KQoreworCV9fbGlzdF9kZWwoZW50cnktPnByZXYsIGVudHJ5LT5uZXh0KTsKKwllbnRyeS0+bmV4dCA9IExJU1RfUE9JU09OMTsKKwllbnRyeS0+cHJldiA9IExJU1RfUE9JU09OMjsKK30KKworLyoqCisgKiBsaXN0X2RlbF9yYW5nZSAtIGRlbGV0ZXMgcmFuZ2Ugb2YgZW50cmllcyBmcm9tIGxpc3QuCisgKiBAYmVnaW5nOiBmaXJzdCBlbGVtZW50IGluIHRoZSByYW5nZSB0byBkZWxldGUgZnJvbSB0aGUgbGlzdC4KKyAqIEBiZWdpbmc6IGZpcnN0IGVsZW1lbnQgaW4gdGhlIHJhbmdlIHRvIGRlbGV0ZSBmcm9tIHRoZSBsaXN0LgorICogTm90ZTogbGlzdF9lbXB0eSBvbiB0aGUgcmFuZ2Ugb2YgZW50cmllcyBkb2VzIG5vdCByZXR1cm4gdHJ1ZSBhZnRlciB0aGlzLAorICogdGhlIGVudHJpZXMgaXMgaW4gYW4gdW5kZWZpbmVkIHN0YXRlLgorICovCitzdGF0aWMgaW5saW5lIHZvaWQgbGlzdF9kZWxfcmFuZ2Uoc3RydWN0IGxpc3RfaGVhZCAqYmVnaW4sCisJCQkJICBzdHJ1Y3QgbGlzdF9oZWFkICplbmQpCit7CisJYmVnaW4tPnByZXYtPm5leHQgPSBlbmQtPm5leHQ7CisJZW5kLT5uZXh0LT5wcmV2ID0gYmVnaW4tPnByZXY7Cit9CisKKy8qKgorICogbGlzdF9yZXBsYWNlIC0gcmVwbGFjZSBvbGQgZW50cnkgYnkgbmV3IG9uZQorICogQG9sZCA6IHRoZSBlbGVtZW50IHRvIGJlIHJlcGxhY2VkCisgKiBAbmV3IDogdGhlIG5ldyBlbGVtZW50IHRvIGluc2VydAorICogTm90ZTogaWYgJ29sZCcgd2FzIGVtcHR5LCBpdCB3aWxsIGJlIG92ZXJ3cml0dGVuLgorICovCitzdGF0aWMgaW5saW5lIHZvaWQgbGlzdF9yZXBsYWNlKHN0cnVjdCBsaXN0X2hlYWQgKm9sZCwKKwkJCQlzdHJ1Y3QgbGlzdF9oZWFkICpuZXcpCit7CisJbmV3LT5uZXh0ID0gb2xkLT5uZXh0OworCW5ldy0+bmV4dC0+cHJldiA9IG5ldzsKKwluZXctPnByZXYgPSBvbGQtPnByZXY7CisJbmV3LT5wcmV2LT5uZXh0ID0gbmV3OworfQorCitzdGF0aWMgaW5saW5lIHZvaWQgbGlzdF9yZXBsYWNlX2luaXQoc3RydWN0IGxpc3RfaGVhZCAqb2xkLAorCQkJCQlzdHJ1Y3QgbGlzdF9oZWFkICpuZXcpCit7CisJbGlzdF9yZXBsYWNlKG9sZCwgbmV3KTsKKwlJTklUX0xJU1RfSEVBRChvbGQpOworfQorCisvKioKKyAqIGxpc3RfZGVsX2luaXQgLSBkZWxldGVzIGVudHJ5IGZyb20gbGlzdCBhbmQgcmVpbml0aWFsaXplIGl0LgorICogQGVudHJ5OiB0aGUgZWxlbWVudCB0byBkZWxldGUgZnJvbSB0aGUgbGlzdC4KKyAqLworc3RhdGljIGlubGluZSB2b2lkIGxpc3RfZGVsX2luaXQoc3RydWN0IGxpc3RfaGVhZCAqZW50cnkpCit7CisJX19saXN0X2RlbChlbnRyeS0+cHJldiwgZW50cnktPm5leHQpOworCUlOSVRfTElTVF9IRUFEKGVudHJ5KTsKK30KKworLyoqCisgKiBsaXN0X21vdmUgLSBkZWxldGUgZnJvbSBvbmUgbGlzdCBhbmQgYWRkIGFzIGFub3RoZXIncyBoZWFkCisgKiBAbGlzdDogdGhlIGVudHJ5IHRvIG1vdmUKKyAqIEBoZWFkOiB0aGUgaGVhZCB0aGF0IHdpbGwgcHJlY2VkZSBvdXIgZW50cnkKKyAqLworc3RhdGljIGlubGluZSB2b2lkIGxpc3RfbW92ZShzdHJ1Y3QgbGlzdF9oZWFkICpsaXN0LCBzdHJ1Y3QgbGlzdF9oZWFkICpoZWFkKQoreworICAgICAgICBfX2xpc3RfZGVsKGxpc3QtPnByZXYsIGxpc3QtPm5leHQpOworICAgICAgICBsaXN0X2FkZChsaXN0LCBoZWFkKTsKK30KKworLyoqCisgKiBsaXN0X21vdmVfdGFpbCAtIGRlbGV0ZSBmcm9tIG9uZSBsaXN0IGFuZCBhZGQgYXMgYW5vdGhlcidzIHRhaWwKKyAqIEBsaXN0OiB0aGUgZW50cnkgdG8gbW92ZQorICogQGhlYWQ6IHRoZSBoZWFkIHRoYXQgd2lsbCBmb2xsb3cgb3VyIGVudHJ5CisgKi8KK3N0YXRpYyBpbmxpbmUgdm9pZCBsaXN0X21vdmVfdGFpbChzdHJ1Y3QgbGlzdF9oZWFkICpsaXN0LAorCQkJCSAgc3RydWN0IGxpc3RfaGVhZCAqaGVhZCkKK3sKKyAgICAgICAgX19saXN0X2RlbChsaXN0LT5wcmV2LCBsaXN0LT5uZXh0KTsKKyAgICAgICAgbGlzdF9hZGRfdGFpbChsaXN0LCBoZWFkKTsKK30KKworLyoqCisgKiBsaXN0X2lzX2xhc3QgLSB0ZXN0cyB3aGV0aGVyIEBsaXN0IGlzIHRoZSBsYXN0IGVudHJ5IGluIGxpc3QgQGhlYWQKKyAqIEBsaXN0OiB0aGUgZW50cnkgdG8gdGVzdAorICogQGhlYWQ6IHRoZSBoZWFkIG9mIHRoZSBsaXN0CisgKi8KK3N0YXRpYyBpbmxpbmUgaW50IGxpc3RfaXNfbGFzdChjb25zdCBzdHJ1Y3QgbGlzdF9oZWFkICpsaXN0LAorCQkJCWNvbnN0IHN0cnVjdCBsaXN0X2hlYWQgKmhlYWQpCit7CisJcmV0dXJuIGxpc3QtPm5leHQgPT0gaGVhZDsKK30KKworLyoqCisgKiBsaXN0X2VtcHR5IC0gdGVzdHMgd2hldGhlciBhIGxpc3QgaXMgZW1wdHkKKyAqIEBoZWFkOiB0aGUgbGlzdCB0byB0ZXN0LgorICovCitzdGF0aWMgaW5saW5lIGludCBsaXN0X2VtcHR5KGNvbnN0IHN0cnVjdCBsaXN0X2hlYWQgKmhlYWQpCit7CisJcmV0dXJuIGhlYWQtPm5leHQgPT0gaGVhZDsKK30KKworLyoqCisgKiBsaXN0X2VtcHR5X2NhcmVmdWwgLSB0ZXN0cyB3aGV0aGVyIGEgbGlzdCBpcyBlbXB0eSBhbmQgbm90IGJlaW5nIG1vZGlmaWVkCisgKiBAaGVhZDogdGhlIGxpc3QgdG8gdGVzdAorICoKKyAqIERlc2NyaXB0aW9uOgorICogdGVzdHMgd2hldGhlciBhIGxpc3QgaXMgZW1wdHkgX2FuZF8gY2hlY2tzIHRoYXQgbm8gb3RoZXIgQ1BVIG1pZ2h0IGJlCisgKiBpbiB0aGUgcHJvY2VzcyBvZiBtb2RpZnlpbmcgZWl0aGVyIG1lbWJlciAobmV4dCBvciBwcmV2KQorICoKKyAqIE5PVEU6IHVzaW5nIGxpc3RfZW1wdHlfY2FyZWZ1bCgpIHdpdGhvdXQgc3luY2hyb25pemF0aW9uCisgKiBjYW4gb25seSBiZSBzYWZlIGlmIHRoZSBvbmx5IGFjdGl2aXR5IHRoYXQgY2FuIGhhcHBlbgorICogdG8gdGhlIGxpc3QgZW50cnkgaXMgbGlzdF9kZWxfaW5pdCgpLiBFZy4gaXQgY2Fubm90IGJlIHVzZWQKKyAqIGlmIGFub3RoZXIgQ1BVIGNvdWxkIHJlLWxpc3RfYWRkKCkgaXQuCisgKi8KK3N0YXRpYyBpbmxpbmUgaW50IGxpc3RfZW1wdHlfY2FyZWZ1bChjb25zdCBzdHJ1Y3QgbGlzdF9oZWFkICpoZWFkKQoreworCXN0cnVjdCBsaXN0X2hlYWQgKm5leHQgPSBoZWFkLT5uZXh0OworCXJldHVybiAobmV4dCA9PSBoZWFkKSAmJiAobmV4dCA9PSBoZWFkLT5wcmV2KTsKK30KKworc3RhdGljIGlubGluZSB2b2lkIF9fbGlzdF9zcGxpY2Uoc3RydWN0IGxpc3RfaGVhZCAqbGlzdCwKKwkJCQkgc3RydWN0IGxpc3RfaGVhZCAqaGVhZCkKK3sKKwlzdHJ1Y3QgbGlzdF9oZWFkICpmaXJzdCA9IGxpc3QtPm5leHQ7CisJc3RydWN0IGxpc3RfaGVhZCAqbGFzdCA9IGxpc3QtPnByZXY7CisJc3RydWN0IGxpc3RfaGVhZCAqYXQgPSBoZWFkLT5uZXh0OworCisJZmlyc3QtPnByZXYgPSBoZWFkOworCWhlYWQtPm5leHQgPSBmaXJzdDsKKworCWxhc3QtPm5leHQgPSBhdDsKKwlhdC0+cHJldiA9IGxhc3Q7Cit9CisKKy8qKgorICogbGlzdF9zcGxpY2UgLSBqb2luIHR3byBsaXN0cworICogQGxpc3Q6IHRoZSBuZXcgbGlzdCB0byBhZGQuCisgKiBAaGVhZDogdGhlIHBsYWNlIHRvIGFkZCBpdCBpbiB0aGUgZmlyc3QgbGlzdC4KKyAqLworc3RhdGljIGlubGluZSB2b2lkIGxpc3Rfc3BsaWNlKHN0cnVjdCBsaXN0X2hlYWQgKmxpc3QsIHN0cnVjdCBsaXN0X2hlYWQgKmhlYWQpCit7CisJaWYgKCFsaXN0X2VtcHR5KGxpc3QpKQorCQlfX2xpc3Rfc3BsaWNlKGxpc3QsIGhlYWQpOworfQorCisvKioKKyAqIGxpc3Rfc3BsaWNlX2luaXQgLSBqb2luIHR3byBsaXN0cyBhbmQgcmVpbml0aWFsaXNlIHRoZSBlbXB0aWVkIGxpc3QuCisgKiBAbGlzdDogdGhlIG5ldyBsaXN0IHRvIGFkZC4KKyAqIEBoZWFkOiB0aGUgcGxhY2UgdG8gYWRkIGl0IGluIHRoZSBmaXJzdCBsaXN0LgorICoKKyAqIFRoZSBsaXN0IGF0IEBsaXN0IGlzIHJlaW5pdGlhbGlzZWQKKyAqLworc3RhdGljIGlubGluZSB2b2lkIGxpc3Rfc3BsaWNlX2luaXQoc3RydWN0IGxpc3RfaGVhZCAqbGlzdCwKKwkJCQkgICAgc3RydWN0IGxpc3RfaGVhZCAqaGVhZCkKK3sKKwlpZiAoIWxpc3RfZW1wdHkobGlzdCkpIHsKKwkJX19saXN0X3NwbGljZShsaXN0LCBoZWFkKTsKKwkJSU5JVF9MSVNUX0hFQUQobGlzdCk7CisJfQorfQorCisvKioKKyAqIGxpc3RfZW50cnkgLSBnZXQgdGhlIHN0cnVjdCBmb3IgdGhpcyBlbnRyeQorICogQHB0cjoJdGhlICZzdHJ1Y3QgbGlzdF9oZWFkIHBvaW50ZXIuCisgKiBAdHlwZToJdGhlIHR5cGUgb2YgdGhlIHN0cnVjdCB0aGlzIGlzIGVtYmVkZGVkIGluLgorICogQG1lbWJlcjoJdGhlIG5hbWUgb2YgdGhlIGxpc3Rfc3RydWN0IHdpdGhpbiB0aGUgc3RydWN0LgorICovCisjZGVmaW5lIGxpc3RfZW50cnkocHRyLCB0eXBlLCBtZW1iZXIpIFwKKwljb250YWluZXJfb2YocHRyLCB0eXBlLCBtZW1iZXIpCisKKy8qKgorICogbGlzdF9maXJzdF9lbnRyeSAtIGdldCB0aGUgZmlyc3QgZWxlbWVudCBmcm9tIGEgbGlzdAorICogQHB0cjogICAgICAgdGhlIGxpc3QgaGVhZCB0byB0YWtlIHRoZSBlbGVtZW50IGZyb20uCisgKiBAdHlwZTogICAgICB0aGUgdHlwZSBvZiB0aGUgc3RydWN0IHRoaXMgaXMgZW1iZWRkZWQgaW4uCisgKiBAbWVtYmVyOiAgICB0aGUgbmFtZSBvZiB0aGUgbGlzdF9zdHJ1Y3Qgd2l0aGluIHRoZSBzdHJ1Y3QuCisgKgorICogTm90ZSwgdGhhdCBsaXN0IGlzIGV4cGVjdGVkIHRvIGJlIG5vdCBlbXB0eS4KKyAqLworI2RlZmluZSBsaXN0X2ZpcnN0X2VudHJ5KHB0ciwgdHlwZSwgbWVtYmVyKSBcCisJbGlzdF9lbnRyeSgocHRyKS0+bmV4dCwgdHlwZSwgbWVtYmVyKQorCisvKioKKyAqIGxpc3RfZm9yX2VhY2gJLQlpdGVyYXRlIG92ZXIgYSBsaXN0CisgKiBAcG9zOgl0aGUgJnN0cnVjdCBsaXN0X2hlYWQgdG8gdXNlIGFzIGEgbG9vcCBjdXJzb3IuCisgKiBAaGVhZDoJdGhlIGhlYWQgZm9yIHlvdXIgbGlzdC4KKyAqLworI2RlZmluZSBsaXN0X2Zvcl9lYWNoKHBvcywgaGVhZCkgXAorCWZvciAocG9zID0gKGhlYWQpLT5uZXh0OyBwb3MgIT0gKGhlYWQpOyBcCisgICAgICAgIAlwb3MgPSBwb3MtPm5leHQpCisKKy8qKgorICogX19saXN0X2Zvcl9lYWNoCS0JaXRlcmF0ZSBvdmVyIGEgbGlzdAorICogQHBvczoJdGhlICZzdHJ1Y3QgbGlzdF9oZWFkIHRvIHVzZSBhcyBhIGxvb3AgY3Vyc29yLgorICogQGhlYWQ6CXRoZSBoZWFkIGZvciB5b3VyIGxpc3QuCisgKgorICogVGhpcyB2YXJpYW50IGRpZmZlcnMgZnJvbSBsaXN0X2Zvcl9lYWNoKCkgaW4gdGhhdCBpdCdzIHRoZQorICogc2ltcGxlc3QgcG9zc2libGUgbGlzdCBpdGVyYXRpb24gY29kZSwgbm8gcHJlZmV0Y2hpbmcgaXMgZG9uZS4KKyAqIFVzZSB0aGlzIGZvciBjb2RlIHRoYXQga25vd3MgdGhlIGxpc3QgdG8gYmUgdmVyeSBzaG9ydCAoZW1wdHkKKyAqIG9yIDEgZW50cnkpIG1vc3Qgb2YgdGhlIHRpbWUuCisgKi8KKyNkZWZpbmUgX19saXN0X2Zvcl9lYWNoKHBvcywgaGVhZCkgXAorCWZvciAocG9zID0gKGhlYWQpLT5uZXh0OyBwb3MgIT0gKGhlYWQpOyBwb3MgPSBwb3MtPm5leHQpCisKKy8qKgorICogbGlzdF9mb3JfZWFjaF9wcmV2CS0JaXRlcmF0ZSBvdmVyIGEgbGlzdCBiYWNrd2FyZHMKKyAqIEBwb3M6CXRoZSAmc3RydWN0IGxpc3RfaGVhZCB0byB1c2UgYXMgYSBsb29wIGN1cnNvci4KKyAqIEBoZWFkOgl0aGUgaGVhZCBmb3IgeW91ciBsaXN0LgorICovCisjZGVmaW5lIGxpc3RfZm9yX2VhY2hfcHJldihwb3MsIGhlYWQpIFwKKwlmb3IgKHBvcyA9IChoZWFkKS0+cHJldjsgcG9zICE9IChoZWFkKTsgXAorICAgICAgICAJcG9zID0gcG9zLT5wcmV2KQorCisvKioKKyAqIGxpc3RfZm9yX2VhY2hfc2FmZSAtIGl0ZXJhdGUgb3ZlciBhIGxpc3Qgc2FmZSBhZ2FpbnN0IHJlbW92YWwgb2YgbGlzdCBlbnRyeQorICogQHBvczoJdGhlICZzdHJ1Y3QgbGlzdF9oZWFkIHRvIHVzZSBhcyBhIGxvb3AgY3Vyc29yLgorICogQG46CQlhbm90aGVyICZzdHJ1Y3QgbGlzdF9oZWFkIHRvIHVzZSBhcyB0ZW1wb3Jhcnkgc3RvcmFnZQorICogQGhlYWQ6CXRoZSBoZWFkIGZvciB5b3VyIGxpc3QuCisgKi8KKyNkZWZpbmUgbGlzdF9mb3JfZWFjaF9zYWZlKHBvcywgbiwgaGVhZCkgXAorCWZvciAocG9zID0gKGhlYWQpLT5uZXh0LCBuID0gcG9zLT5uZXh0OyBwb3MgIT0gKGhlYWQpOyBcCisJCXBvcyA9IG4sIG4gPSBwb3MtPm5leHQpCisKKy8qKgorICogbGlzdF9mb3JfZWFjaF9lbnRyeQktCWl0ZXJhdGUgb3ZlciBsaXN0IG9mIGdpdmVuIHR5cGUKKyAqIEBwb3M6CXRoZSB0eXBlICogdG8gdXNlIGFzIGEgbG9vcCBjdXJzb3IuCisgKiBAaGVhZDoJdGhlIGhlYWQgZm9yIHlvdXIgbGlzdC4KKyAqIEBtZW1iZXI6CXRoZSBuYW1lIG9mIHRoZSBsaXN0X3N0cnVjdCB3aXRoaW4gdGhlIHN0cnVjdC4KKyAqLworI2RlZmluZSBsaXN0X2Zvcl9lYWNoX2VudHJ5KHBvcywgaGVhZCwgbWVtYmVyKQkJCQlcCisJZm9yIChwb3MgPSBsaXN0X2VudHJ5KChoZWFkKS0+bmV4dCwgdHlwZW9mKCpwb3MpLCBtZW1iZXIpOwlcCisJICAgICAmcG9zLT5tZW1iZXIgIT0gKGhlYWQpOyAJXAorCSAgICAgcG9zID0gbGlzdF9lbnRyeShwb3MtPm1lbWJlci5uZXh0LCB0eXBlb2YoKnBvcyksIG1lbWJlcikpCisKKy8qKgorICogbGlzdF9mb3JfZWFjaF9lbnRyeV9yZXZlcnNlIC0gaXRlcmF0ZSBiYWNrd2FyZHMgb3ZlciBsaXN0IG9mIGdpdmVuIHR5cGUuCisgKiBAcG9zOgl0aGUgdHlwZSAqIHRvIHVzZSBhcyBhIGxvb3AgY3Vyc29yLgorICogQGhlYWQ6CXRoZSBoZWFkIGZvciB5b3VyIGxpc3QuCisgKiBAbWVtYmVyOgl0aGUgbmFtZSBvZiB0aGUgbGlzdF9zdHJ1Y3Qgd2l0aGluIHRoZSBzdHJ1Y3QuCisgKi8KKyNkZWZpbmUgbGlzdF9mb3JfZWFjaF9lbnRyeV9yZXZlcnNlKHBvcywgaGVhZCwgbWVtYmVyKQkJCVwKKwlmb3IgKHBvcyA9IGxpc3RfZW50cnkoKGhlYWQpLT5wcmV2LCB0eXBlb2YoKnBvcyksIG1lbWJlcik7CVwKKwkgICAgICZwb3MtPm1lbWJlciAhPSAoaGVhZCk7IAlcCisJICAgICBwb3MgPSBsaXN0X2VudHJ5KHBvcy0+bWVtYmVyLnByZXYsIHR5cGVvZigqcG9zKSwgbWVtYmVyKSkKKworLyoqCisgKiBsaXN0X3ByZXBhcmVfZW50cnkgLSBwcmVwYXJlIGEgcG9zIGVudHJ5IGZvciB1c2UgaW4gbGlzdF9mb3JfZWFjaF9lbnRyeV9jb250aW51ZQorICogQHBvczoJdGhlIHR5cGUgKiB0byB1c2UgYXMgYSBzdGFydCBwb2ludAorICogQGhlYWQ6CXRoZSBoZWFkIG9mIHRoZSBsaXN0CisgKiBAbWVtYmVyOgl0aGUgbmFtZSBvZiB0aGUgbGlzdF9zdHJ1Y3Qgd2l0aGluIHRoZSBzdHJ1Y3QuCisgKgorICogUHJlcGFyZXMgYSBwb3MgZW50cnkgZm9yIHVzZSBhcyBhIHN0YXJ0IHBvaW50IGluIGxpc3RfZm9yX2VhY2hfZW50cnlfY29udGludWUuCisgKi8KKyNkZWZpbmUgbGlzdF9wcmVwYXJlX2VudHJ5KHBvcywgaGVhZCwgbWVtYmVyKSBcCisJKChwb3MpID8gOiBsaXN0X2VudHJ5KGhlYWQsIHR5cGVvZigqcG9zKSwgbWVtYmVyKSkKKworLyoqCisgKiBsaXN0X2Zvcl9lYWNoX2VudHJ5X2NvbnRpbnVlIC0gY29udGludWUgaXRlcmF0aW9uIG92ZXIgbGlzdCBvZiBnaXZlbiB0eXBlCisgKiBAcG9zOgl0aGUgdHlwZSAqIHRvIHVzZSBhcyBhIGxvb3AgY3Vyc29yLgorICogQGhlYWQ6CXRoZSBoZWFkIGZvciB5b3VyIGxpc3QuCisgKiBAbWVtYmVyOgl0aGUgbmFtZSBvZiB0aGUgbGlzdF9zdHJ1Y3Qgd2l0aGluIHRoZSBzdHJ1Y3QuCisgKgorICogQ29udGludWUgdG8gaXRlcmF0ZSBvdmVyIGxpc3Qgb2YgZ2l2ZW4gdHlwZSwgY29udGludWluZyBhZnRlcgorICogdGhlIGN1cnJlbnQgcG9zaXRpb24uCisgKi8KKyNkZWZpbmUgbGlzdF9mb3JfZWFjaF9lbnRyeV9jb250aW51ZShwb3MsIGhlYWQsIG1lbWJlcikgCQlcCisJZm9yIChwb3MgPSBsaXN0X2VudHJ5KHBvcy0+bWVtYmVyLm5leHQsIHR5cGVvZigqcG9zKSwgbWVtYmVyKTsJXAorCSAgICAgJnBvcy0+bWVtYmVyICE9IChoZWFkKTsJXAorCSAgICAgcG9zID0gbGlzdF9lbnRyeShwb3MtPm1lbWJlci5uZXh0LCB0eXBlb2YoKnBvcyksIG1lbWJlcikpCisKKy8qKgorICogbGlzdF9mb3JfZWFjaF9lbnRyeV9mcm9tIC0gaXRlcmF0ZSBvdmVyIGxpc3Qgb2YgZ2l2ZW4gdHlwZSBmcm9tIHRoZSBjdXJyZW50IHBvaW50CisgKiBAcG9zOgl0aGUgdHlwZSAqIHRvIHVzZSBhcyBhIGxvb3AgY3Vyc29yLgorICogQGhlYWQ6CXRoZSBoZWFkIGZvciB5b3VyIGxpc3QuCisgKiBAbWVtYmVyOgl0aGUgbmFtZSBvZiB0aGUgbGlzdF9zdHJ1Y3Qgd2l0aGluIHRoZSBzdHJ1Y3QuCisgKgorICogSXRlcmF0ZSBvdmVyIGxpc3Qgb2YgZ2l2ZW4gdHlwZSwgY29udGludWluZyBmcm9tIGN1cnJlbnQgcG9zaXRpb24uCisgKi8KKyNkZWZpbmUgbGlzdF9mb3JfZWFjaF9lbnRyeV9mcm9tKHBvcywgaGVhZCwgbWVtYmVyKSAJCQlcCisJZm9yICg7ICZwb3MtPm1lbWJlciAhPSAoaGVhZCk7CVwKKwkgICAgIHBvcyA9IGxpc3RfZW50cnkocG9zLT5tZW1iZXIubmV4dCwgdHlwZW9mKCpwb3MpLCBtZW1iZXIpKQorCisvKioKKyAqIGxpc3RfZm9yX2VhY2hfZW50cnlfc2FmZSAtIGl0ZXJhdGUgb3ZlciBsaXN0IG9mIGdpdmVuIHR5cGUgc2FmZSBhZ2FpbnN0IHJlbW92YWwgb2YgbGlzdCBlbnRyeQorICogQHBvczoJdGhlIHR5cGUgKiB0byB1c2UgYXMgYSBsb29wIGN1cnNvci4KKyAqIEBuOgkJYW5vdGhlciB0eXBlICogdG8gdXNlIGFzIHRlbXBvcmFyeSBzdG9yYWdlCisgKiBAaGVhZDoJdGhlIGhlYWQgZm9yIHlvdXIgbGlzdC4KKyAqIEBtZW1iZXI6CXRoZSBuYW1lIG9mIHRoZSBsaXN0X3N0cnVjdCB3aXRoaW4gdGhlIHN0cnVjdC4KKyAqLworI2RlZmluZSBsaXN0X2Zvcl9lYWNoX2VudHJ5X3NhZmUocG9zLCBuLCBoZWFkLCBtZW1iZXIpCQkJXAorCWZvciAocG9zID0gbGlzdF9lbnRyeSgoaGVhZCktPm5leHQsIHR5cGVvZigqcG9zKSwgbWVtYmVyKSwJXAorCQluID0gbGlzdF9lbnRyeShwb3MtPm1lbWJlci5uZXh0LCB0eXBlb2YoKnBvcyksIG1lbWJlcik7CVwKKwkgICAgICZwb3MtPm1lbWJlciAhPSAoaGVhZCk7IAkJCQkJXAorCSAgICAgcG9zID0gbiwgbiA9IGxpc3RfZW50cnkobi0+bWVtYmVyLm5leHQsIHR5cGVvZigqbiksIG1lbWJlcikpCisKKy8qKgorICogbGlzdF9mb3JfZWFjaF9lbnRyeV9zYWZlX2NvbnRpbnVlCisgKiBAcG9zOgl0aGUgdHlwZSAqIHRvIHVzZSBhcyBhIGxvb3AgY3Vyc29yLgorICogQG46CQlhbm90aGVyIHR5cGUgKiB0byB1c2UgYXMgdGVtcG9yYXJ5IHN0b3JhZ2UKKyAqIEBoZWFkOgl0aGUgaGVhZCBmb3IgeW91ciBsaXN0LgorICogQG1lbWJlcjoJdGhlIG5hbWUgb2YgdGhlIGxpc3Rfc3RydWN0IHdpdGhpbiB0aGUgc3RydWN0LgorICoKKyAqIEl0ZXJhdGUgb3ZlciBsaXN0IG9mIGdpdmVuIHR5cGUsIGNvbnRpbnVpbmcgYWZ0ZXIgY3VycmVudCBwb2ludCwKKyAqIHNhZmUgYWdhaW5zdCByZW1vdmFsIG9mIGxpc3QgZW50cnkuCisgKi8KKyNkZWZpbmUgbGlzdF9mb3JfZWFjaF9lbnRyeV9zYWZlX2NvbnRpbnVlKHBvcywgbiwgaGVhZCwgbWVtYmVyKSAJCVwKKwlmb3IgKHBvcyA9IGxpc3RfZW50cnkocG9zLT5tZW1iZXIubmV4dCwgdHlwZW9mKCpwb3MpLCBtZW1iZXIpLCAJCVwKKwkJbiA9IGxpc3RfZW50cnkocG9zLT5tZW1iZXIubmV4dCwgdHlwZW9mKCpwb3MpLCBtZW1iZXIpOwkJXAorCSAgICAgJnBvcy0+bWVtYmVyICE9IChoZWFkKTsJCQkJCQlcCisJICAgICBwb3MgPSBuLCBuID0gbGlzdF9lbnRyeShuLT5tZW1iZXIubmV4dCwgdHlwZW9mKCpuKSwgbWVtYmVyKSkKKworLyoqCisgKiBsaXN0X2Zvcl9lYWNoX2VudHJ5X3NhZmVfZnJvbQorICogQHBvczoJdGhlIHR5cGUgKiB0byB1c2UgYXMgYSBsb29wIGN1cnNvci4KKyAqIEBuOgkJYW5vdGhlciB0eXBlICogdG8gdXNlIGFzIHRlbXBvcmFyeSBzdG9yYWdlCisgKiBAaGVhZDoJdGhlIGhlYWQgZm9yIHlvdXIgbGlzdC4KKyAqIEBtZW1iZXI6CXRoZSBuYW1lIG9mIHRoZSBsaXN0X3N0cnVjdCB3aXRoaW4gdGhlIHN0cnVjdC4KKyAqCisgKiBJdGVyYXRlIG92ZXIgbGlzdCBvZiBnaXZlbiB0eXBlIGZyb20gY3VycmVudCBwb2ludCwgc2FmZSBhZ2FpbnN0CisgKiByZW1vdmFsIG9mIGxpc3QgZW50cnkuCisgKi8KKyNkZWZpbmUgbGlzdF9mb3JfZWFjaF9lbnRyeV9zYWZlX2Zyb20ocG9zLCBuLCBoZWFkLCBtZW1iZXIpIAkJCVwKKwlmb3IgKG4gPSBsaXN0X2VudHJ5KHBvcy0+bWVtYmVyLm5leHQsIHR5cGVvZigqcG9zKSwgbWVtYmVyKTsJCVwKKwkgICAgICZwb3MtPm1lbWJlciAhPSAoaGVhZCk7CQkJCQkJXAorCSAgICAgcG9zID0gbiwgbiA9IGxpc3RfZW50cnkobi0+bWVtYmVyLm5leHQsIHR5cGVvZigqbiksIG1lbWJlcikpCisKKy8qKgorICogbGlzdF9mb3JfZWFjaF9lbnRyeV9zYWZlX3JldmVyc2UKKyAqIEBwb3M6CXRoZSB0eXBlICogdG8gdXNlIGFzIGEgbG9vcCBjdXJzb3IuCisgKiBAbjoJCWFub3RoZXIgdHlwZSAqIHRvIHVzZSBhcyB0ZW1wb3Jhcnkgc3RvcmFnZQorICogQGhlYWQ6CXRoZSBoZWFkIGZvciB5b3VyIGxpc3QuCisgKiBAbWVtYmVyOgl0aGUgbmFtZSBvZiB0aGUgbGlzdF9zdHJ1Y3Qgd2l0aGluIHRoZSBzdHJ1Y3QuCisgKgorICogSXRlcmF0ZSBiYWNrd2FyZHMgb3ZlciBsaXN0IG9mIGdpdmVuIHR5cGUsIHNhZmUgYWdhaW5zdCByZW1vdmFsCisgKiBvZiBsaXN0IGVudHJ5LgorICovCisjZGVmaW5lIGxpc3RfZm9yX2VhY2hfZW50cnlfc2FmZV9yZXZlcnNlKHBvcywgbiwgaGVhZCwgbWVtYmVyKQkJXAorCWZvciAocG9zID0gbGlzdF9lbnRyeSgoaGVhZCktPnByZXYsIHR5cGVvZigqcG9zKSwgbWVtYmVyKSwJXAorCQluID0gbGlzdF9lbnRyeShwb3MtPm1lbWJlci5wcmV2LCB0eXBlb2YoKnBvcyksIG1lbWJlcik7CVwKKwkgICAgICZwb3MtPm1lbWJlciAhPSAoaGVhZCk7IAkJCQkJXAorCSAgICAgcG9zID0gbiwgbiA9IGxpc3RfZW50cnkobi0+bWVtYmVyLnByZXYsIHR5cGVvZigqbiksIG1lbWJlcikpCisKKy8qCisgKiBEb3VibGUgbGlua2VkIGxpc3RzIHdpdGggYSBzaW5nbGUgcG9pbnRlciBsaXN0IGhlYWQuCisgKiBNb3N0bHkgdXNlZnVsIGZvciBoYXNoIHRhYmxlcyB3aGVyZSB0aGUgdHdvIHBvaW50ZXIgbGlzdCBoZWFkIGlzCisgKiB0b28gd2FzdGVmdWwuCisgKiBZb3UgbG9zZSB0aGUgYWJpbGl0eSB0byBhY2Nlc3MgdGhlIHRhaWwgaW4gTygxKS4KKyAqLworCitzdHJ1Y3QgaGxpc3RfaGVhZCB7CisJc3RydWN0IGhsaXN0X25vZGUgKmZpcnN0OworfTsKKworc3RydWN0IGhsaXN0X25vZGUgeworCXN0cnVjdCBobGlzdF9ub2RlICpuZXh0LCAqKnBwcmV2OworfTsKKworI2RlZmluZSBITElTVF9IRUFEX0lOSVQgeyAuZmlyc3QgPSBOVUxMIH0KKyNkZWZpbmUgSExJU1RfSEVBRChuYW1lKSBzdHJ1Y3QgaGxpc3RfaGVhZCBuYW1lID0geyAgLmZpcnN0ID0gTlVMTCB9CisjZGVmaW5lIElOSVRfSExJU1RfSEVBRChwdHIpICgocHRyKS0+Zmlyc3QgPSBOVUxMKQorc3RhdGljIGlubGluZSB2b2lkIElOSVRfSExJU1RfTk9ERShzdHJ1Y3QgaGxpc3Rfbm9kZSAqaCkKK3sKKwloLT5uZXh0ID0gTlVMTDsKKwloLT5wcHJldiA9IE5VTEw7Cit9CisKK3N0YXRpYyBpbmxpbmUgaW50IGhsaXN0X3VuaGFzaGVkKGNvbnN0IHN0cnVjdCBobGlzdF9ub2RlICpoKQoreworCXJldHVybiAhaC0+cHByZXY7Cit9CisKK3N0YXRpYyBpbmxpbmUgaW50IGhsaXN0X2VtcHR5KGNvbnN0IHN0cnVjdCBobGlzdF9oZWFkICpoKQoreworCXJldHVybiAhaC0+Zmlyc3Q7Cit9CisKK3N0YXRpYyBpbmxpbmUgdm9pZCBfX2hsaXN0X2RlbChzdHJ1Y3QgaGxpc3Rfbm9kZSAqbikKK3sKKwlzdHJ1Y3QgaGxpc3Rfbm9kZSAqbmV4dCA9IG4tPm5leHQ7CisJc3RydWN0IGhsaXN0X25vZGUgKipwcHJldiA9IG4tPnBwcmV2OworCSpwcHJldiA9IG5leHQ7CisJaWYgKG5leHQpCisJCW5leHQtPnBwcmV2ID0gcHByZXY7Cit9CisKK3N0YXRpYyBpbmxpbmUgdm9pZCBobGlzdF9kZWwoc3RydWN0IGhsaXN0X25vZGUgKm4pCit7CisJX19obGlzdF9kZWwobik7CisJbi0+bmV4dCA9IExJU1RfUE9JU09OMTsKKwluLT5wcHJldiA9IExJU1RfUE9JU09OMjsKK30KKworc3RhdGljIGlubGluZSB2b2lkIGhsaXN0X2RlbF9pbml0KHN0cnVjdCBobGlzdF9ub2RlICpuKQoreworCWlmICghaGxpc3RfdW5oYXNoZWQobikpIHsKKwkJX19obGlzdF9kZWwobik7CisJCUlOSVRfSExJU1RfTk9ERShuKTsKKwl9Cit9CisKK3N0YXRpYyBpbmxpbmUgdm9pZCBobGlzdF9hZGRfaGVhZChzdHJ1Y3QgaGxpc3Rfbm9kZSAqbiwgc3RydWN0IGhsaXN0X2hlYWQgKmgpCit7CisJc3RydWN0IGhsaXN0X25vZGUgKmZpcnN0ID0gaC0+Zmlyc3Q7CisJbi0+bmV4dCA9IGZpcnN0OworCWlmIChmaXJzdCkKKwkJZmlyc3QtPnBwcmV2ID0gJm4tPm5leHQ7CisJaC0+Zmlyc3QgPSBuOworCW4tPnBwcmV2ID0gJmgtPmZpcnN0OworfQorCisvKiBuZXh0IG11c3QgYmUgIT0gTlVMTCAqLworc3RhdGljIGlubGluZSB2b2lkIGhsaXN0X2FkZF9iZWZvcmUoc3RydWN0IGhsaXN0X25vZGUgKm4sCisJCQkJCXN0cnVjdCBobGlzdF9ub2RlICpuZXh0KQoreworCW4tPnBwcmV2ID0gbmV4dC0+cHByZXY7CisJbi0+bmV4dCA9IG5leHQ7CisJbmV4dC0+cHByZXYgPSAmbi0+bmV4dDsKKwkqKG4tPnBwcmV2KSA9IG47Cit9CisKK3N0YXRpYyBpbmxpbmUgdm9pZCBobGlzdF9hZGRfYWZ0ZXIoc3RydWN0IGhsaXN0X25vZGUgKm4sCisJCQkJCXN0cnVjdCBobGlzdF9ub2RlICpuZXh0KQoreworCW5leHQtPm5leHQgPSBuLT5uZXh0OworCW4tPm5leHQgPSBuZXh0OworCW5leHQtPnBwcmV2ID0gJm4tPm5leHQ7CisKKwlpZihuZXh0LT5uZXh0KQorCQluZXh0LT5uZXh0LT5wcHJldiAgPSAmbmV4dC0+bmV4dDsKK30KKworI2RlZmluZSBobGlzdF9lbnRyeShwdHIsIHR5cGUsIG1lbWJlcikgY29udGFpbmVyX29mKHB0cix0eXBlLG1lbWJlcikKKworI2RlZmluZSBobGlzdF9mb3JfZWFjaChwb3MsIGhlYWQpIFwKKwlmb3IgKHBvcyA9IChoZWFkKS0+Zmlyc3Q7IHBvczsgXAorCSAgICAgcG9zID0gcG9zLT5uZXh0KQorCisjZGVmaW5lIGhsaXN0X2Zvcl9lYWNoX3NhZmUocG9zLCBuLCBoZWFkKSBcCisJZm9yIChwb3MgPSAoaGVhZCktPmZpcnN0OyBwb3MgJiYgKHsgbiA9IHBvcy0+bmV4dDsgMTsgfSk7IFwKKwkgICAgIHBvcyA9IG4pCisKKy8qKgorICogaGxpc3RfZm9yX2VhY2hfZW50cnkJLSBpdGVyYXRlIG92ZXIgbGlzdCBvZiBnaXZlbiB0eXBlCisgKiBAdHBvczoJdGhlIHR5cGUgKiB0byB1c2UgYXMgYSBsb29wIGN1cnNvci4KKyAqIEBwb3M6CXRoZSAmc3RydWN0IGhsaXN0X25vZGUgdG8gdXNlIGFzIGEgbG9vcCBjdXJzb3IuCisgKiBAaGVhZDoJdGhlIGhlYWQgZm9yIHlvdXIgbGlzdC4KKyAqIEBtZW1iZXI6CXRoZSBuYW1lIG9mIHRoZSBobGlzdF9ub2RlIHdpdGhpbiB0aGUgc3RydWN0LgorICovCisjZGVmaW5lIGhsaXN0X2Zvcl9lYWNoX2VudHJ5KHRwb3MsIHBvcywgaGVhZCwgbWVtYmVyKQkJCSBcCisJZm9yIChwb3MgPSAoaGVhZCktPmZpcnN0OwkJCQkJIFwKKwkgICAgIHBvcyAmJiAJCQkgXAorCQkoeyB0cG9zID0gaGxpc3RfZW50cnkocG9zLCB0eXBlb2YoKnRwb3MpLCBtZW1iZXIpOyAxO30pOyBcCisJICAgICBwb3MgPSBwb3MtPm5leHQpCisKKy8qKgorICogaGxpc3RfZm9yX2VhY2hfZW50cnlfY29udGludWUgLSBpdGVyYXRlIG92ZXIgYSBobGlzdCBjb250aW51aW5nIGFmdGVyIGN1cnJlbnQgcG9pbnQKKyAqIEB0cG9zOgl0aGUgdHlwZSAqIHRvIHVzZSBhcyBhIGxvb3AgY3Vyc29yLgorICogQHBvczoJdGhlICZzdHJ1Y3QgaGxpc3Rfbm9kZSB0byB1c2UgYXMgYSBsb29wIGN1cnNvci4KKyAqIEBtZW1iZXI6CXRoZSBuYW1lIG9mIHRoZSBobGlzdF9ub2RlIHdpdGhpbiB0aGUgc3RydWN0LgorICovCisjZGVmaW5lIGhsaXN0X2Zvcl9lYWNoX2VudHJ5X2NvbnRpbnVlKHRwb3MsIHBvcywgbWVtYmVyKQkJIFwKKwlmb3IgKHBvcyA9IChwb3MpLT5uZXh0OwkJCQkJCSBcCisJICAgICBwb3MgJiYgCQkJIFwKKwkJKHsgdHBvcyA9IGhsaXN0X2VudHJ5KHBvcywgdHlwZW9mKCp0cG9zKSwgbWVtYmVyKTsgMTt9KTsgXAorCSAgICAgcG9zID0gcG9zLT5uZXh0KQorCisvKioKKyAqIGhsaXN0X2Zvcl9lYWNoX2VudHJ5X2Zyb20gLSBpdGVyYXRlIG92ZXIgYSBobGlzdCBjb250aW51aW5nIGZyb20gY3VycmVudCBwb2ludAorICogQHRwb3M6CXRoZSB0eXBlICogdG8gdXNlIGFzIGEgbG9vcCBjdXJzb3IuCisgKiBAcG9zOgl0aGUgJnN0cnVjdCBobGlzdF9ub2RlIHRvIHVzZSBhcyBhIGxvb3AgY3Vyc29yLgorICogQG1lbWJlcjoJdGhlIG5hbWUgb2YgdGhlIGhsaXN0X25vZGUgd2l0aGluIHRoZSBzdHJ1Y3QuCisgKi8KKyNkZWZpbmUgaGxpc3RfZm9yX2VhY2hfZW50cnlfZnJvbSh0cG9zLCBwb3MsIG1lbWJlcikJCQkgXAorCWZvciAoOyBwb3MgJiYgCQkJIFwKKwkJKHsgdHBvcyA9IGhsaXN0X2VudHJ5KHBvcywgdHlwZW9mKCp0cG9zKSwgbWVtYmVyKTsgMTt9KTsgXAorCSAgICAgcG9zID0gcG9zLT5uZXh0KQorCisvKioKKyAqIGhsaXN0X2Zvcl9lYWNoX2VudHJ5X3NhZmUgLSBpdGVyYXRlIG92ZXIgbGlzdCBvZiBnaXZlbiB0eXBlIHNhZmUgYWdhaW5zdCByZW1vdmFsIG9mIGxpc3QgZW50cnkKKyAqIEB0cG9zOgl0aGUgdHlwZSAqIHRvIHVzZSBhcyBhIGxvb3AgY3Vyc29yLgorICogQHBvczoJdGhlICZzdHJ1Y3QgaGxpc3Rfbm9kZSB0byB1c2UgYXMgYSBsb29wIGN1cnNvci4KKyAqIEBuOgkJYW5vdGhlciAmc3RydWN0IGhsaXN0X25vZGUgdG8gdXNlIGFzIHRlbXBvcmFyeSBzdG9yYWdlCisgKiBAaGVhZDoJdGhlIGhlYWQgZm9yIHlvdXIgbGlzdC4KKyAqIEBtZW1iZXI6CXRoZSBuYW1lIG9mIHRoZSBobGlzdF9ub2RlIHdpdGhpbiB0aGUgc3RydWN0LgorICovCisjZGVmaW5lIGhsaXN0X2Zvcl9lYWNoX2VudHJ5X3NhZmUodHBvcywgcG9zLCBuLCBoZWFkLCBtZW1iZXIpIAkJIFwKKwlmb3IgKHBvcyA9IChoZWFkKS0+Zmlyc3Q7CQkJCQkgXAorCSAgICAgcG9zICYmICh7IG4gPSBwb3MtPm5leHQ7IDE7IH0pICYmIAkJCQkgXAorCQkoeyB0cG9zID0gaGxpc3RfZW50cnkocG9zLCB0eXBlb2YoKnRwb3MpLCBtZW1iZXIpOyAxO30pOyBcCisJICAgICBwb3MgPSBuKQorCisjZW5kaWYKZGlmZiAtLWdpdCBhL3Rvb2xzL3BlcmYvdXRpbC9wYWdlci5jIGIvdG9vbHMvcGVyZi91dGlsL3BhZ2VyLmMKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uYTI4YmNjYQotLS0gL2Rldi9udWxsCisrKyBiL3Rvb2xzL3BlcmYvdXRpbC9wYWdlci5jCkBAIC0wLDAgKzEsOTkgQEAKKyNpbmNsdWRlICJjYWNoZS5oIgorI2luY2x1ZGUgInJ1bi1jb21tYW5kLmgiCisjaW5jbHVkZSAic2lnY2hhaW4uaCIKKworLyoKKyAqIFRoaXMgaXMgc3BsaXQgdXAgZnJvbSB0aGUgcmVzdCBvZiBnaXQgc28gdGhhdCB3ZSBjYW4gZG8KKyAqIHNvbWV0aGluZyBkaWZmZXJlbnQgb24gV2luZG93cy4KKyAqLworCitzdGF0aWMgaW50IHNwYXduZWRfcGFnZXI7CisKKyNpZm5kZWYgX19NSU5HVzMyX18KK3N0YXRpYyB2b2lkIHBhZ2VyX3ByZWV4ZWModm9pZCkKK3sKKwkvKgorCSAqIFdvcmsgYXJvdW5kIGJ1ZyBpbiAibGVzcyIgYnkgbm90IHN0YXJ0aW5nIGl0IHVudGlsIHdlCisJICogaGF2ZSByZWFsIGlucHV0CisJICovCisJZmRfc2V0IGluOworCisJRkRfWkVSTygmaW4pOworCUZEX1NFVCgwLCAmaW4pOworCXNlbGVjdCgxLCAmaW4sIE5VTEwsICZpbiwgTlVMTCk7CisKKwlzZXRlbnYoIkxFU1MiLCAiRlJTWCIsIDApOworfQorI2VuZGlmCisKK3N0YXRpYyBjb25zdCBjaGFyICpwYWdlcl9hcmd2W10gPSB7ICJzaCIsICItYyIsIE5VTEwsIE5VTEwgfTsKK3N0YXRpYyBzdHJ1Y3QgY2hpbGRfcHJvY2VzcyBwYWdlcl9wcm9jZXNzOworCitzdGF0aWMgdm9pZCB3YWl0X2Zvcl9wYWdlcih2b2lkKQoreworCWZmbHVzaChzdGRvdXQpOworCWZmbHVzaChzdGRlcnIpOworCS8qIHNpZ25hbCBFT0YgdG8gcGFnZXIgKi8KKwljbG9zZSgxKTsKKwljbG9zZSgyKTsKKwlmaW5pc2hfY29tbWFuZCgmcGFnZXJfcHJvY2Vzcyk7Cit9CisKK3N0YXRpYyB2b2lkIHdhaXRfZm9yX3BhZ2VyX3NpZ25hbChpbnQgc2lnbm8pCit7CisJd2FpdF9mb3JfcGFnZXIoKTsKKwlzaWdjaGFpbl9wb3Aoc2lnbm8pOworCXJhaXNlKHNpZ25vKTsKK30KKwordm9pZCBzZXR1cF9wYWdlcih2b2lkKQoreworCWNvbnN0IGNoYXIgKnBhZ2VyID0gZ2V0ZW52KCJQRVJGX1BBR0VSIik7CisKKwlpZiAoIWlzYXR0eSgxKSkKKwkJcmV0dXJuOworCWlmICghcGFnZXIpIHsKKwkJaWYgKCFwYWdlcl9wcm9ncmFtKQorCQkJcGVyZl9jb25maWcocGVyZl9kZWZhdWx0X2NvbmZpZywgTlVMTCk7CisJCXBhZ2VyID0gcGFnZXJfcHJvZ3JhbTsKKwl9CisJaWYgKCFwYWdlcikKKwkJcGFnZXIgPSBnZXRlbnYoIlBBR0VSIik7CisJaWYgKCFwYWdlcikKKwkJcGFnZXIgPSAibGVzcyI7CisJZWxzZSBpZiAoISpwYWdlciB8fCAhc3RyY21wKHBhZ2VyLCAiY2F0IikpCisJCXJldHVybjsKKworCXNwYXduZWRfcGFnZXIgPSAxOyAvKiBtZWFucyB3ZSBhcmUgZW1pdHRpbmcgdG8gdGVybWluYWwgKi8KKworCS8qIHNwYXduIHRoZSBwYWdlciAqLworCXBhZ2VyX2FyZ3ZbMl0gPSBwYWdlcjsKKwlwYWdlcl9wcm9jZXNzLmFyZ3YgPSBwYWdlcl9hcmd2OworCXBhZ2VyX3Byb2Nlc3MuaW4gPSAtMTsKKyNpZm5kZWYgX19NSU5HVzMyX18KKwlwYWdlcl9wcm9jZXNzLnByZWV4ZWNfY2IgPSBwYWdlcl9wcmVleGVjOworI2VuZGlmCisJaWYgKHN0YXJ0X2NvbW1hbmQoJnBhZ2VyX3Byb2Nlc3MpKQorCQlyZXR1cm47CisKKwkvKiBvcmlnaW5hbCBwcm9jZXNzIGNvbnRpbnVlcywgYnV0IHdyaXRlcyB0byB0aGUgcGlwZSAqLworCWR1cDIocGFnZXJfcHJvY2Vzcy5pbiwgMSk7CisJaWYgKGlzYXR0eSgyKSkKKwkJZHVwMihwYWdlcl9wcm9jZXNzLmluLCAyKTsKKwljbG9zZShwYWdlcl9wcm9jZXNzLmluKTsKKworCS8qIHRoaXMgbWFrZXMgc3VyZSB0aGF0IHRoZSBwYXJlbnQgdGVybWluYXRlcyBhZnRlciB0aGUgcGFnZXIgKi8KKwlzaWdjaGFpbl9wdXNoX2NvbW1vbih3YWl0X2Zvcl9wYWdlcl9zaWduYWwpOworCWF0ZXhpdCh3YWl0X2Zvcl9wYWdlcik7Cit9CisKK2ludCBwYWdlcl9pbl91c2Uodm9pZCkKK3sKKwljb25zdCBjaGFyICplbnY7CisKKwlpZiAoc3Bhd25lZF9wYWdlcikKKwkJcmV0dXJuIDE7CisKKwllbnYgPSBnZXRlbnYoIlBFUkZfUEFHRVJfSU5fVVNFIik7CisJcmV0dXJuIGVudiA/IHBlcmZfY29uZmlnX2Jvb2woIlBFUkZfUEFHRVJfSU5fVVNFIiwgZW52KSA6IDA7Cit9CmRpZmYgLS1naXQgYS90b29scy9wZXJmL3V0aWwvcGFyc2UtZXZlbnRzLmMgYi90b29scy9wZXJmL3V0aWwvcGFyc2UtZXZlbnRzLmMKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uOWQ1ZjFjYQotLS0gL2Rldi9udWxsCisrKyBiL3Rvb2xzL3BlcmYvdXRpbC9wYXJzZS1ldmVudHMuYwpAQCAtMCwwICsxLDMxNiBAQAorCisjaW5jbHVkZSAiLi4vcGVyZi5oIgorI2luY2x1ZGUgInV0aWwuaCIKKyNpbmNsdWRlICJwYXJzZS1vcHRpb25zLmgiCisjaW5jbHVkZSAicGFyc2UtZXZlbnRzLmgiCisjaW5jbHVkZSAiZXhlY19jbWQuaCIKKyNpbmNsdWRlICJzdHJpbmcuaCIKKworZXh0ZXJuIGNoYXIgKnN0cmNhc2VzdHIoY29uc3QgY2hhciAqaGF5c3RhY2ssIGNvbnN0IGNoYXIgKm5lZWRsZSk7CisKK2ludAkJCQkJbnJfY291bnRlcnM7CisKK3N0cnVjdCBwZXJmX2NvdW50ZXJfYXR0cgkJYXR0cnNbTUFYX0NPVU5URVJTXTsKKworc3RydWN0IGV2ZW50X3N5bWJvbCB7CisJX191OAl0eXBlOworCV9fdTY0CWNvbmZpZzsKKwljaGFyCSpzeW1ib2w7Cit9OworCisjZGVmaW5lIEMoeCwgeSkgLnR5cGUgPSBQRVJGX1RZUEVfIyN4LCAuY29uZmlnID0gUEVSRl9DT1VOVF8jI3kKKyNkZWZpbmUgQ1IoeCwgeSkgLnR5cGUgPSBQRVJGX1RZUEVfIyN4LCAuY29uZmlnID0geQorCitzdGF0aWMgc3RydWN0IGV2ZW50X3N5bWJvbCBldmVudF9zeW1ib2xzW10gPSB7CisgIHsgQyhIQVJEV0FSRSwgSFdfQ1BVX0NZQ0xFUyksCQkiY3B1LWN5Y2xlcyIsCQl9LAorICB7IEMoSEFSRFdBUkUsIEhXX0NQVV9DWUNMRVMpLAkJImN5Y2xlcyIsCQl9LAorICB7IEMoSEFSRFdBUkUsIEhXX0lOU1RSVUNUSU9OUyksCSJpbnN0cnVjdGlvbnMiLAkJfSwKKyAgeyBDKEhBUkRXQVJFLCBIV19DQUNIRV9SRUZFUkVOQ0VTKSwJImNhY2hlLXJlZmVyZW5jZXMiLAl9LAorICB7IEMoSEFSRFdBUkUsIEhXX0NBQ0hFX01JU1NFUyksCSJjYWNoZS1taXNzZXMiLAkJfSwKKyAgeyBDKEhBUkRXQVJFLCBIV19CUkFOQ0hfSU5TVFJVQ1RJT05TKSwiYnJhbmNoLWluc3RydWN0aW9ucyIsCX0sCisgIHsgQyhIQVJEV0FSRSwgSFdfQlJBTkNIX0lOU1RSVUNUSU9OUyksImJyYW5jaGVzIiwJCX0sCisgIHsgQyhIQVJEV0FSRSwgSFdfQlJBTkNIX01JU1NFUyksCSJicmFuY2gtbWlzc2VzIiwJfSwKKyAgeyBDKEhBUkRXQVJFLCBIV19CVVNfQ1lDTEVTKSwJCSJidXMtY3ljbGVzIiwJCX0sCisKKyAgeyBDKFNPRlRXQVJFLCBTV19DUFVfQ0xPQ0spLAkJImNwdS1jbG9jayIsCQl9LAorICB7IEMoU09GVFdBUkUsIFNXX1RBU0tfQ0xPQ0spLAkJInRhc2stY2xvY2siLAkJfSwKKyAgeyBDKFNPRlRXQVJFLCBTV19QQUdFX0ZBVUxUUyksCSJwYWdlLWZhdWx0cyIsCQl9LAorICB7IEMoU09GVFdBUkUsIFNXX1BBR0VfRkFVTFRTKSwJImZhdWx0cyIsCQl9LAorICB7IEMoU09GVFdBUkUsIFNXX1BBR0VfRkFVTFRTX01JTiksCSJtaW5vci1mYXVsdHMiLAkJfSwKKyAgeyBDKFNPRlRXQVJFLCBTV19QQUdFX0ZBVUxUU19NQUopLAkibWFqb3ItZmF1bHRzIiwJCX0sCisgIHsgQyhTT0ZUV0FSRSwgU1dfQ09OVEVYVF9TV0lUQ0hFUyksCSJjb250ZXh0LXN3aXRjaGVzIiwJfSwKKyAgeyBDKFNPRlRXQVJFLCBTV19DT05URVhUX1NXSVRDSEVTKSwJImNzIiwJCQl9LAorICB7IEMoU09GVFdBUkUsIFNXX0NQVV9NSUdSQVRJT05TKSwJImNwdS1taWdyYXRpb25zIiwJfSwKKyAgeyBDKFNPRlRXQVJFLCBTV19DUFVfTUlHUkFUSU9OUyksCSJtaWdyYXRpb25zIiwJCX0sCit9OworCisjZGVmaW5lIF9fUEVSRl9DT1VOVEVSX0ZJRUxEKGNvbmZpZywgbmFtZSkgXAorCSgoY29uZmlnICYgUEVSRl9DT1VOVEVSXyMjbmFtZSMjX01BU0spID4+IFBFUkZfQ09VTlRFUl8jI25hbWUjI19TSElGVCkKKworI2RlZmluZSBQRVJGX0NPVU5URVJfUkFXKGNvbmZpZykJX19QRVJGX0NPVU5URVJfRklFTEQoY29uZmlnLCBSQVcpCisjZGVmaW5lIFBFUkZfQ09VTlRFUl9DT05GSUcoY29uZmlnKQlfX1BFUkZfQ09VTlRFUl9GSUVMRChjb25maWcsIENPTkZJRykKKyNkZWZpbmUgUEVSRl9DT1VOVEVSX1RZUEUoY29uZmlnKQlfX1BFUkZfQ09VTlRFUl9GSUVMRChjb25maWcsIFRZUEUpCisjZGVmaW5lIFBFUkZfQ09VTlRFUl9JRChjb25maWcpCQlfX1BFUkZfQ09VTlRFUl9GSUVMRChjb25maWcsIEVWRU5UKQorCitzdGF0aWMgY2hhciAqaHdfZXZlbnRfbmFtZXNbXSA9IHsKKwkiY3ljbGVzIiwKKwkiaW5zdHJ1Y3Rpb25zIiwKKwkiY2FjaGUtcmVmZXJlbmNlcyIsCisJImNhY2hlLW1pc3NlcyIsCisJImJyYW5jaGVzIiwKKwkiYnJhbmNoLW1pc3NlcyIsCisJImJ1cy1jeWNsZXMiLAorfTsKKworc3RhdGljIGNoYXIgKnN3X2V2ZW50X25hbWVzW10gPSB7CisJImNwdS1jbG9jay10aWNrcyIsCisJInRhc2stY2xvY2stdGlja3MiLAorCSJwYWdlLWZhdWx0cyIsCisJImNvbnRleHQtc3dpdGNoZXMiLAorCSJDUFUtbWlncmF0aW9ucyIsCisJIm1pbm9yLWZhdWx0cyIsCisJIm1ham9yLWZhdWx0cyIsCit9OworCisjZGVmaW5lIE1BWF9BTElBU0VTIDgKKworc3RhdGljIGNoYXIgKmh3X2NhY2hlIFtdW01BWF9BTElBU0VTXSA9IHsKKwl7ICJMMS1kYXRhIgkJLCAibDEtZCIsICJsMWQiLCAibDEiCQkJCX0sCisJeyAiTDEtaW5zdHJ1Y3Rpb24iCSwgImwxLWkiLCAibDFpIgkJCQkJfSwKKwl7ICJMMiIJCQksICJsMiIJCQkJCQl9LAorCXsgIkRhdGEtVExCIgkJLCAiZHRsYiIsICJkLXRsYiIJCQkJfSwKKwl7ICJJbnN0cnVjdGlvbi1UTEIiCSwgIml0bGIiLCAiaS10bGIiCQkJCX0sCisJeyAiQnJhbmNoIgkJLCAiYnB1IiAsICJidGIiLCAiYnBjIgkJCQl9LAorfTsKKworc3RhdGljIGNoYXIgKmh3X2NhY2hlX29wIFtdW01BWF9BTElBU0VTXSA9IHsKKwl7ICJMb2FkIgkJLCAicmVhZCIJCQkJCX0sCisJeyAiU3RvcmUiCQksICJ3cml0ZSIJCQkJCX0sCisJeyAiUHJlZmV0Y2giCQksICJzcGVjdWxhdGl2ZS1yZWFkIiwgInNwZWN1bGF0aXZlLWxvYWQiCX0sCit9OworCitzdGF0aWMgY2hhciAqaHdfY2FjaGVfcmVzdWx0IFtdW01BWF9BTElBU0VTXSA9IHsKKwl7ICJSZWZlcmVuY2UiCQksICJvcHMiLCAiYWNjZXNzIgkJCQl9LAorCXsgIk1pc3MiCQkJCQkJCQl9LAorfTsKKworY2hhciAqZXZlbnRfbmFtZShpbnQgY291bnRlcikKK3sKKwlfX3U2NCBjb25maWcgPSBhdHRyc1tjb3VudGVyXS5jb25maWc7CisJaW50IHR5cGUgPSBhdHRyc1tjb3VudGVyXS50eXBlOworCXN0YXRpYyBjaGFyIGJ1ZlszMl07CisKKwlpZiAoYXR0cnNbY291bnRlcl0udHlwZSA9PSBQRVJGX1RZUEVfUkFXKSB7CisJCXNwcmludGYoYnVmLCAicmF3IDB4JWxseCIsIGNvbmZpZyk7CisJCXJldHVybiBidWY7CisJfQorCisJc3dpdGNoICh0eXBlKSB7CisJY2FzZSBQRVJGX1RZUEVfSEFSRFdBUkU6CisJCWlmIChjb25maWcgPCBQRVJGX0NPVU5UX0hXX01BWCkKKwkJCXJldHVybiBod19ldmVudF9uYW1lc1tjb25maWddOworCQlyZXR1cm4gInVua25vd24taGFyZHdhcmUiOworCisJY2FzZSBQRVJGX1RZUEVfSFdfQ0FDSEU6IHsKKwkJX191OCBjYWNoZV90eXBlLCBjYWNoZV9vcCwgY2FjaGVfcmVzdWx0OworCQlzdGF0aWMgY2hhciBuYW1lWzEwMF07CisKKwkJY2FjaGVfdHlwZSAgID0gKGNvbmZpZyA+PiAgMCkgJiAweGZmOworCQlpZiAoY2FjaGVfdHlwZSA+IFBFUkZfQ09VTlRfSFdfQ0FDSEVfTUFYKQorCQkJcmV0dXJuICJ1bmtub3duLWV4dC1oYXJkd2FyZS1jYWNoZS10eXBlIjsKKworCQljYWNoZV9vcCAgICAgPSAoY29uZmlnID4+ICA4KSAmIDB4ZmY7CisJCWlmIChjYWNoZV9vcCA+IFBFUkZfQ09VTlRfSFdfQ0FDSEVfT1BfTUFYKQorCQkJcmV0dXJuICJ1bmtub3duLWV4dC1oYXJkd2FyZS1jYWNoZS1vcCI7CisKKwkJY2FjaGVfcmVzdWx0ID0gKGNvbmZpZyA+PiAxNikgJiAweGZmOworCQlpZiAoY2FjaGVfcmVzdWx0ID4gUEVSRl9DT1VOVF9IV19DQUNIRV9SRVNVTFRfTUFYKQorCQkJcmV0dXJuICJ1bmtub3duLWV4dC1oYXJkd2FyZS1jYWNoZS1yZXN1bHQiOworCisJCXNwcmludGYobmFtZSwgIiVzLUNhY2hlLSVzLSVzZXMiLAorCQkJaHdfY2FjaGVbY2FjaGVfdHlwZV1bMF0sCisJCQlod19jYWNoZV9vcFtjYWNoZV9vcF1bMF0sCisJCQlod19jYWNoZV9yZXN1bHRbY2FjaGVfcmVzdWx0XVswXSk7CisKKwkJcmV0dXJuIG5hbWU7CisJfQorCisJY2FzZSBQRVJGX1RZUEVfU09GVFdBUkU6CisJCWlmIChjb25maWcgPCBQRVJGX0NPVU5UX1NXX01BWCkKKwkJCXJldHVybiBzd19ldmVudF9uYW1lc1tjb25maWddOworCQlyZXR1cm4gInVua25vd24tc29mdHdhcmUiOworCisJZGVmYXVsdDoKKwkJYnJlYWs7CisJfQorCisJcmV0dXJuICJ1bmtub3duIjsKK30KKworc3RhdGljIGludCBwYXJzZV9hbGlhc2VzKGNvbnN0IGNoYXIgKnN0ciwgY2hhciAqbmFtZXNbXVtNQVhfQUxJQVNFU10sIGludCBzaXplKQoreworCWludCBpLCBqOworCisJZm9yIChpID0gMDsgaSA8IHNpemU7IGkrKykgeworCQlmb3IgKGogPSAwOyBqIDwgTUFYX0FMSUFTRVM7IGorKykgeworCQkJaWYgKCFuYW1lc1tpXVtqXSkKKwkJCQlicmVhazsKKwkJCWlmIChzdHJjYXNlc3RyKHN0ciwgbmFtZXNbaV1bal0pKQorCQkJCXJldHVybiBpOworCQl9CisJfQorCisJcmV0dXJuIC0xOworfQorCitzdGF0aWMgaW50IHBhcnNlX2dlbmVyaWNfaHdfc3ltYm9scyhjb25zdCBjaGFyICpzdHIsIHN0cnVjdCBwZXJmX2NvdW50ZXJfYXR0ciAqYXR0cikKK3sKKwlpbnQgY2FjaGVfdHlwZSA9IC0xLCBjYWNoZV9vcCA9IDAsIGNhY2hlX3Jlc3VsdCA9IDA7CisKKwljYWNoZV90eXBlID0gcGFyc2VfYWxpYXNlcyhzdHIsIGh3X2NhY2hlLCBQRVJGX0NPVU5UX0hXX0NBQ0hFX01BWCk7CisJLyoKKwkgKiBObyBmYWxsYmFjayAtIGlmIHdlIGNhbm5vdCBnZXQgYSBjbGVhciBjYWNoZSB0eXBlCisJICogdGhlbiBiYWlsIG91dDoKKwkgKi8KKwlpZiAoY2FjaGVfdHlwZSA9PSAtMSkKKwkJcmV0dXJuIC1FSU5WQUw7CisKKwljYWNoZV9vcCA9IHBhcnNlX2FsaWFzZXMoc3RyLCBod19jYWNoZV9vcCwgUEVSRl9DT1VOVF9IV19DQUNIRV9PUF9NQVgpOworCS8qCisJICogRmFsbCBiYWNrIHRvIHJlYWRzOgorCSAqLworCWlmIChjYWNoZV9vcCA9PSAtMSkKKwkJY2FjaGVfb3AgPSBQRVJGX0NPVU5UX0hXX0NBQ0hFX09QX1JFQUQ7CisKKwljYWNoZV9yZXN1bHQgPSBwYXJzZV9hbGlhc2VzKHN0ciwgaHdfY2FjaGVfcmVzdWx0LAorCQkJCQlQRVJGX0NPVU5UX0hXX0NBQ0hFX1JFU1VMVF9NQVgpOworCS8qCisJICogRmFsbCBiYWNrIHRvIGFjY2Vzc2VzOgorCSAqLworCWlmIChjYWNoZV9yZXN1bHQgPT0gLTEpCisJCWNhY2hlX3Jlc3VsdCA9IFBFUkZfQ09VTlRfSFdfQ0FDSEVfUkVTVUxUX0FDQ0VTUzsKKworCWF0dHItPmNvbmZpZyA9IGNhY2hlX3R5cGUgfCAoY2FjaGVfb3AgPDwgOCkgfCAoY2FjaGVfcmVzdWx0IDw8IDE2KTsKKwlhdHRyLT50eXBlID0gUEVSRl9UWVBFX0hXX0NBQ0hFOworCisJcmV0dXJuIDA7Cit9CisKKy8qCisgKiBFYWNoIGV2ZW50IGNhbiBoYXZlIG11bHRpcGxlIHN5bWJvbGljIG5hbWVzLgorICogU3ltYm9saWMgbmFtZXMgYXJlIChhbG1vc3QpIGV4YWN0bHkgbWF0Y2hlZC4KKyAqLworc3RhdGljIGludCBwYXJzZV9ldmVudF9zeW1ib2xzKGNvbnN0IGNoYXIgKnN0ciwgc3RydWN0IHBlcmZfY291bnRlcl9hdHRyICphdHRyKQoreworCV9fdTY0IGNvbmZpZywgaWQ7CisJaW50IHR5cGU7CisJdW5zaWduZWQgaW50IGk7CisJY29uc3QgY2hhciAqc2VwLCAqcHN0cjsKKworCWlmIChzdHJbMF0gPT0gJ3InICYmIGhleDJ1NjQoc3RyICsgMSwgJmNvbmZpZykgPiAwKSB7CisJCWF0dHItPnR5cGUgPSBQRVJGX1RZUEVfUkFXOworCQlhdHRyLT5jb25maWcgPSBjb25maWc7CisKKwkJcmV0dXJuIDA7CisJfQorCisJcHN0ciA9IHN0cjsKKwlzZXAgPSBzdHJjaHIocHN0ciwgJzonKTsKKwlpZiAoc2VwKSB7CisJCXR5cGUgPSBhdG9pKHBzdHIpOworCQlwc3RyID0gc2VwICsgMTsKKwkJaWQgPSBhdG9pKHBzdHIpOworCQlzZXAgPSBzdHJjaHIocHN0ciwgJzonKTsKKwkJaWYgKHNlcCkgeworCQkJcHN0ciA9IHNlcCArIDE7CisJCQlpZiAoc3RyY2hyKHBzdHIsICdrJykpCisJCQkJYXR0ci0+ZXhjbHVkZV91c2VyID0gMTsKKwkJCWlmIChzdHJjaHIocHN0ciwgJ3UnKSkKKwkJCQlhdHRyLT5leGNsdWRlX2tlcm5lbCA9IDE7CisJCX0KKwkJYXR0ci0+dHlwZSA9IHR5cGU7CisJCWF0dHItPmNvbmZpZyA9IGlkOworCisJCXJldHVybiAwOworCX0KKworCWZvciAoaSA9IDA7IGkgPCBBUlJBWV9TSVpFKGV2ZW50X3N5bWJvbHMpOyBpKyspIHsKKwkJaWYgKCFzdHJuY21wKHN0ciwgZXZlbnRfc3ltYm9sc1tpXS5zeW1ib2wsCisJCQkgICAgIHN0cmxlbihldmVudF9zeW1ib2xzW2ldLnN5bWJvbCkpKSB7CisKKwkJCWF0dHItPnR5cGUgPSBldmVudF9zeW1ib2xzW2ldLnR5cGU7CisJCQlhdHRyLT5jb25maWcgPSBldmVudF9zeW1ib2xzW2ldLmNvbmZpZzsKKworCQkJcmV0dXJuIDA7CisJCX0KKwl9CisKKwlyZXR1cm4gcGFyc2VfZ2VuZXJpY19od19zeW1ib2xzKHN0ciwgYXR0cik7Cit9CisKK2ludCBwYXJzZV9ldmVudHMoY29uc3Qgc3RydWN0IG9wdGlvbiAqb3B0LCBjb25zdCBjaGFyICpzdHIsIGludCB1bnNldCkKK3sKKwlzdHJ1Y3QgcGVyZl9jb3VudGVyX2F0dHIgYXR0cjsKKwlpbnQgcmV0OworCisJbWVtc2V0KCZhdHRyLCAwLCBzaXplb2YoYXR0cikpOworYWdhaW46CisJaWYgKG5yX2NvdW50ZXJzID09IE1BWF9DT1VOVEVSUykKKwkJcmV0dXJuIC0xOworCisJcmV0ID0gcGFyc2VfZXZlbnRfc3ltYm9scyhzdHIsICZhdHRyKTsKKwlpZiAocmV0IDwgMCkKKwkJcmV0dXJuIHJldDsKKworCWF0dHJzW25yX2NvdW50ZXJzXSA9IGF0dHI7CisJbnJfY291bnRlcnMrKzsKKworCXN0ciA9IHN0cnN0cihzdHIsICIsIik7CisJaWYgKHN0cikgeworCQlzdHIrKzsKKwkJZ290byBhZ2FpbjsKKwl9CisKKwlyZXR1cm4gMDsKK30KKworc3RhdGljIGNvbnN0IGNoYXIgKiBjb25zdCBldmVudF90eXBlX2Rlc2NyaXB0b3JzW10gPSB7CisJIiIsCisJIkhhcmR3YXJlIGV2ZW50IiwKKwkiU29mdHdhcmUgZXZlbnQiLAorCSJUcmFjZXBvaW50IGV2ZW50IiwKKwkiSGFyZHdhcmUgY2FjaGUgZXZlbnQiLAorfTsKKworLyoKKyAqIFByaW50IHRoZSBoZWxwIHRleHQgZm9yIHRoZSBldmVudCBzeW1ib2xzOgorICovCit2b2lkIHByaW50X2V2ZW50cyh2b2lkKQoreworCXN0cnVjdCBldmVudF9zeW1ib2wgKnN5bXMgPSBldmVudF9zeW1ib2xzOworCXVuc2lnbmVkIGludCBpLCB0eXBlLCBwcmV2X3R5cGUgPSAtMTsKKworCWZwcmludGYoc3RkZXJyLCAiXG4iKTsKKwlmcHJpbnRmKHN0ZGVyciwgIkxpc3Qgb2YgcHJlLWRlZmluZWQgZXZlbnRzICh0byBiZSB1c2VkIGluIC1lKTpcbiIpOworCisJZm9yIChpID0gMDsgaSA8IEFSUkFZX1NJWkUoZXZlbnRfc3ltYm9scyk7IGkrKywgc3ltcysrKSB7CisJCXR5cGUgPSBzeW1zLT50eXBlICsgMTsKKwkJaWYgKHR5cGUgPiBBUlJBWV9TSVpFKGV2ZW50X3R5cGVfZGVzY3JpcHRvcnMpKQorCQkJdHlwZSA9IDA7CisKKwkJaWYgKHR5cGUgIT0gcHJldl90eXBlKQorCQkJZnByaW50ZihzdGRlcnIsICJcbiIpOworCisJCWZwcmludGYoc3RkZXJyLCAiICAlLTMwcyBbJXNdXG4iLCBzeW1zLT5zeW1ib2wsCisJCQlldmVudF90eXBlX2Rlc2NyaXB0b3JzW3R5cGVdKTsKKworCQlwcmV2X3R5cGUgPSB0eXBlOworCX0KKworCWZwcmludGYoc3RkZXJyLCAiXG4iKTsKKwlmcHJpbnRmKHN0ZGVyciwgIiAgJS0zMHMgW3JhdyBoYXJkd2FyZSBldmVudCBkZXNjcmlwdG9yXVxuIiwKKwkJInJOTk4iKTsKKwlmcHJpbnRmKHN0ZGVyciwgIlxuIik7CisKKwlleGl0KDEyOSk7Cit9CmRpZmYgLS1naXQgYS90b29scy9wZXJmL3V0aWwvcGFyc2UtZXZlbnRzLmggYi90b29scy9wZXJmL3V0aWwvcGFyc2UtZXZlbnRzLmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uZTNkNTUyOQotLS0gL2Rldi9udWxsCisrKyBiL3Rvb2xzL3BlcmYvdXRpbC9wYXJzZS1ldmVudHMuaApAQCAtMCwwICsxLDE3IEBACisKKy8qCisgKiBQYXJzZSBzeW1ib2xpYyBldmVudHMvY291bnRzIHBhc3NlZCBpbiBhcyBvcHRpb25zOgorICovCisKK2V4dGVybiBpbnQJCQlucl9jb3VudGVyczsKKworZXh0ZXJuIHN0cnVjdCBwZXJmX2NvdW50ZXJfYXR0ciBhdHRyc1tNQVhfQ09VTlRFUlNdOworCitleHRlcm4gY2hhciAqZXZlbnRfbmFtZShpbnQgY3RyKTsKKworZXh0ZXJuIGludCBwYXJzZV9ldmVudHMoY29uc3Qgc3RydWN0IG9wdGlvbiAqb3B0LCBjb25zdCBjaGFyICpzdHIsIGludCB1bnNldCk7CisKKyNkZWZpbmUgRVZFTlRTX0hFTFBfTUFYICgxMjgqMTAyNCkKKworZXh0ZXJuIHZvaWQgcHJpbnRfZXZlbnRzKHZvaWQpOworCmRpZmYgLS1naXQgYS90b29scy9wZXJmL3V0aWwvcGFyc2Utb3B0aW9ucy5jIGIvdG9vbHMvcGVyZi91dGlsL3BhcnNlLW9wdGlvbnMuYwpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi5iM2FmZmIxCi0tLSAvZGV2L251bGwKKysrIGIvdG9vbHMvcGVyZi91dGlsL3BhcnNlLW9wdGlvbnMuYwpAQCAtMCwwICsxLDUwOCBAQAorI2luY2x1ZGUgInV0aWwuaCIKKyNpbmNsdWRlICJwYXJzZS1vcHRpb25zLmgiCisjaW5jbHVkZSAiY2FjaGUuaCIKKworI2RlZmluZSBPUFRfU0hPUlQgMQorI2RlZmluZSBPUFRfVU5TRVQgMgorCitzdGF0aWMgaW50IG9wdGVycm9yKGNvbnN0IHN0cnVjdCBvcHRpb24gKm9wdCwgY29uc3QgY2hhciAqcmVhc29uLCBpbnQgZmxhZ3MpCit7CisJaWYgKGZsYWdzICYgT1BUX1NIT1JUKQorCQlyZXR1cm4gZXJyb3IoInN3aXRjaCBgJWMnICVzIiwgb3B0LT5zaG9ydF9uYW1lLCByZWFzb24pOworCWlmIChmbGFncyAmIE9QVF9VTlNFVCkKKwkJcmV0dXJuIGVycm9yKCJvcHRpb24gYG5vLSVzJyAlcyIsIG9wdC0+bG9uZ19uYW1lLCByZWFzb24pOworCXJldHVybiBlcnJvcigib3B0aW9uIGAlcycgJXMiLCBvcHQtPmxvbmdfbmFtZSwgcmVhc29uKTsKK30KKworc3RhdGljIGludCBnZXRfYXJnKHN0cnVjdCBwYXJzZV9vcHRfY3R4X3QgKnAsIGNvbnN0IHN0cnVjdCBvcHRpb24gKm9wdCwKKwkJICAgaW50IGZsYWdzLCBjb25zdCBjaGFyICoqYXJnKQoreworCWlmIChwLT5vcHQpIHsKKwkJKmFyZyA9IHAtPm9wdDsKKwkJcC0+b3B0ID0gTlVMTDsKKwl9IGVsc2UgaWYgKHAtPmFyZ2MgPT0gMSAmJiAob3B0LT5mbGFncyAmIFBBUlNFX09QVF9MQVNUQVJHX0RFRkFVTFQpKSB7CisJCSphcmcgPSAoY29uc3QgY2hhciAqKW9wdC0+ZGVmdmFsOworCX0gZWxzZSBpZiAocC0+YXJnYyA+IDEpIHsKKwkJcC0+YXJnYy0tOworCQkqYXJnID0gKisrcC0+YXJndjsKKwl9IGVsc2UKKwkJcmV0dXJuIG9wdGVycm9yKG9wdCwgInJlcXVpcmVzIGEgdmFsdWUiLCBmbGFncyk7CisJcmV0dXJuIDA7Cit9CisKK3N0YXRpYyBpbnQgZ2V0X3ZhbHVlKHN0cnVjdCBwYXJzZV9vcHRfY3R4X3QgKnAsCisJCSAgICAgY29uc3Qgc3RydWN0IG9wdGlvbiAqb3B0LCBpbnQgZmxhZ3MpCit7CisJY29uc3QgY2hhciAqcywgKmFyZyA9IE5VTEw7CisJY29uc3QgaW50IHVuc2V0ID0gZmxhZ3MgJiBPUFRfVU5TRVQ7CisKKwlpZiAodW5zZXQgJiYgcC0+b3B0KQorCQlyZXR1cm4gb3B0ZXJyb3Iob3B0LCAidGFrZXMgbm8gdmFsdWUiLCBmbGFncyk7CisJaWYgKHVuc2V0ICYmIChvcHQtPmZsYWdzICYgUEFSU0VfT1BUX05PTkVHKSkKKwkJcmV0dXJuIG9wdGVycm9yKG9wdCwgImlzbid0IGF2YWlsYWJsZSIsIGZsYWdzKTsKKworCWlmICghKGZsYWdzICYgT1BUX1NIT1JUKSAmJiBwLT5vcHQpIHsKKwkJc3dpdGNoIChvcHQtPnR5cGUpIHsKKwkJY2FzZSBPUFRJT05fQ0FMTEJBQ0s6CisJCQlpZiAoIShvcHQtPmZsYWdzICYgUEFSU0VfT1BUX05PQVJHKSkKKwkJCQlicmVhazsKKwkJCS8qIEZBTExUSFJPVUdIICovCisJCWNhc2UgT1BUSU9OX0JPT0xFQU46CisJCWNhc2UgT1BUSU9OX0JJVDoKKwkJY2FzZSBPUFRJT05fU0VUX0lOVDoKKwkJY2FzZSBPUFRJT05fU0VUX1BUUjoKKwkJCXJldHVybiBvcHRlcnJvcihvcHQsICJ0YWtlcyBubyB2YWx1ZSIsIGZsYWdzKTsKKwkJZGVmYXVsdDoKKwkJCWJyZWFrOworCQl9CisJfQorCisJc3dpdGNoIChvcHQtPnR5cGUpIHsKKwljYXNlIE9QVElPTl9CSVQ6CisJCWlmICh1bnNldCkKKwkJCSooaW50ICopb3B0LT52YWx1ZSAmPSB+b3B0LT5kZWZ2YWw7CisJCWVsc2UKKwkJCSooaW50ICopb3B0LT52YWx1ZSB8PSBvcHQtPmRlZnZhbDsKKwkJcmV0dXJuIDA7CisKKwljYXNlIE9QVElPTl9CT09MRUFOOgorCQkqKGludCAqKW9wdC0+dmFsdWUgPSB1bnNldCA/IDAgOiAqKGludCAqKW9wdC0+dmFsdWUgKyAxOworCQlyZXR1cm4gMDsKKworCWNhc2UgT1BUSU9OX1NFVF9JTlQ6CisJCSooaW50ICopb3B0LT52YWx1ZSA9IHVuc2V0ID8gMCA6IG9wdC0+ZGVmdmFsOworCQlyZXR1cm4gMDsKKworCWNhc2UgT1BUSU9OX1NFVF9QVFI6CisJCSoodm9pZCAqKilvcHQtPnZhbHVlID0gdW5zZXQgPyBOVUxMIDogKHZvaWQgKilvcHQtPmRlZnZhbDsKKwkJcmV0dXJuIDA7CisKKwljYXNlIE9QVElPTl9TVFJJTkc6CisJCWlmICh1bnNldCkKKwkJCSooY29uc3QgY2hhciAqKilvcHQtPnZhbHVlID0gTlVMTDsKKwkJZWxzZSBpZiAob3B0LT5mbGFncyAmIFBBUlNFX09QVF9PUFRBUkcgJiYgIXAtPm9wdCkKKwkJCSooY29uc3QgY2hhciAqKilvcHQtPnZhbHVlID0gKGNvbnN0IGNoYXIgKilvcHQtPmRlZnZhbDsKKwkJZWxzZQorCQkJcmV0dXJuIGdldF9hcmcocCwgb3B0LCBmbGFncywgKGNvbnN0IGNoYXIgKiopb3B0LT52YWx1ZSk7CisJCXJldHVybiAwOworCisJY2FzZSBPUFRJT05fQ0FMTEJBQ0s6CisJCWlmICh1bnNldCkKKwkJCXJldHVybiAoKm9wdC0+Y2FsbGJhY2spKG9wdCwgTlVMTCwgMSkgPyAoLTEpIDogMDsKKwkJaWYgKG9wdC0+ZmxhZ3MgJiBQQVJTRV9PUFRfTk9BUkcpCisJCQlyZXR1cm4gKCpvcHQtPmNhbGxiYWNrKShvcHQsIE5VTEwsIDApID8gKC0xKSA6IDA7CisJCWlmIChvcHQtPmZsYWdzICYgUEFSU0VfT1BUX09QVEFSRyAmJiAhcC0+b3B0KQorCQkJcmV0dXJuICgqb3B0LT5jYWxsYmFjaykob3B0LCBOVUxMLCAwKSA/ICgtMSkgOiAwOworCQlpZiAoZ2V0X2FyZyhwLCBvcHQsIGZsYWdzLCAmYXJnKSkKKwkJCXJldHVybiAtMTsKKwkJcmV0dXJuICgqb3B0LT5jYWxsYmFjaykob3B0LCBhcmcsIDApID8gKC0xKSA6IDA7CisKKwljYXNlIE9QVElPTl9JTlRFR0VSOgorCQlpZiAodW5zZXQpIHsKKwkJCSooaW50ICopb3B0LT52YWx1ZSA9IDA7CisJCQlyZXR1cm4gMDsKKwkJfQorCQlpZiAob3B0LT5mbGFncyAmIFBBUlNFX09QVF9PUFRBUkcgJiYgIXAtPm9wdCkgeworCQkJKihpbnQgKilvcHQtPnZhbHVlID0gb3B0LT5kZWZ2YWw7CisJCQlyZXR1cm4gMDsKKwkJfQorCQlpZiAoZ2V0X2FyZyhwLCBvcHQsIGZsYWdzLCAmYXJnKSkKKwkJCXJldHVybiAtMTsKKwkJKihpbnQgKilvcHQtPnZhbHVlID0gc3RydG9sKGFyZywgKGNoYXIgKiopJnMsIDEwKTsKKwkJaWYgKCpzKQorCQkJcmV0dXJuIG9wdGVycm9yKG9wdCwgImV4cGVjdHMgYSBudW1lcmljYWwgdmFsdWUiLCBmbGFncyk7CisJCXJldHVybiAwOworCisJY2FzZSBPUFRJT05fTE9ORzoKKwkJaWYgKHVuc2V0KSB7CisJCQkqKGxvbmcgKilvcHQtPnZhbHVlID0gMDsKKwkJCXJldHVybiAwOworCQl9CisJCWlmIChvcHQtPmZsYWdzICYgUEFSU0VfT1BUX09QVEFSRyAmJiAhcC0+b3B0KSB7CisJCQkqKGxvbmcgKilvcHQtPnZhbHVlID0gb3B0LT5kZWZ2YWw7CisJCQlyZXR1cm4gMDsKKwkJfQorCQlpZiAoZ2V0X2FyZyhwLCBvcHQsIGZsYWdzLCAmYXJnKSkKKwkJCXJldHVybiAtMTsKKwkJKihsb25nICopb3B0LT52YWx1ZSA9IHN0cnRvbChhcmcsIChjaGFyICoqKSZzLCAxMCk7CisJCWlmICgqcykKKwkJCXJldHVybiBvcHRlcnJvcihvcHQsICJleHBlY3RzIGEgbnVtZXJpY2FsIHZhbHVlIiwgZmxhZ3MpOworCQlyZXR1cm4gMDsKKworCWRlZmF1bHQ6CisJCWRpZSgic2hvdWxkIG5vdCBoYXBwZW4sIHNvbWVvbmUgbXVzdCBiZSBoaXQgb24gdGhlIGZvcmVoZWFkIik7CisJfQorfQorCitzdGF0aWMgaW50IHBhcnNlX3Nob3J0X29wdChzdHJ1Y3QgcGFyc2Vfb3B0X2N0eF90ICpwLCBjb25zdCBzdHJ1Y3Qgb3B0aW9uICpvcHRpb25zKQoreworCWZvciAoOyBvcHRpb25zLT50eXBlICE9IE9QVElPTl9FTkQ7IG9wdGlvbnMrKykgeworCQlpZiAob3B0aW9ucy0+c2hvcnRfbmFtZSA9PSAqcC0+b3B0KSB7CisJCQlwLT5vcHQgPSBwLT5vcHRbMV0gPyBwLT5vcHQgKyAxIDogTlVMTDsKKwkJCXJldHVybiBnZXRfdmFsdWUocCwgb3B0aW9ucywgT1BUX1NIT1JUKTsKKwkJfQorCX0KKwlyZXR1cm4gLTI7Cit9CisKK3N0YXRpYyBpbnQgcGFyc2VfbG9uZ19vcHQoc3RydWN0IHBhcnNlX29wdF9jdHhfdCAqcCwgY29uc3QgY2hhciAqYXJnLAorICAgICAgICAgICAgICAgICAgICAgICAgICBjb25zdCBzdHJ1Y3Qgb3B0aW9uICpvcHRpb25zKQoreworCWNvbnN0IGNoYXIgKmFyZ19lbmQgPSBzdHJjaHIoYXJnLCAnPScpOworCWNvbnN0IHN0cnVjdCBvcHRpb24gKmFiYnJldl9vcHRpb24gPSBOVUxMLCAqYW1iaWd1b3VzX29wdGlvbiA9IE5VTEw7CisJaW50IGFiYnJldl9mbGFncyA9IDAsIGFtYmlndW91c19mbGFncyA9IDA7CisKKwlpZiAoIWFyZ19lbmQpCisJCWFyZ19lbmQgPSBhcmcgKyBzdHJsZW4oYXJnKTsKKworCWZvciAoOyBvcHRpb25zLT50eXBlICE9IE9QVElPTl9FTkQ7IG9wdGlvbnMrKykgeworCQljb25zdCBjaGFyICpyZXN0OworCQlpbnQgZmxhZ3MgPSAwOworCisJCWlmICghb3B0aW9ucy0+bG9uZ19uYW1lKQorCQkJY29udGludWU7CisKKwkJcmVzdCA9IHNraXBfcHJlZml4KGFyZywgb3B0aW9ucy0+bG9uZ19uYW1lKTsKKwkJaWYgKG9wdGlvbnMtPnR5cGUgPT0gT1BUSU9OX0FSR1VNRU5UKSB7CisJCQlpZiAoIXJlc3QpCisJCQkJY29udGludWU7CisJCQlpZiAoKnJlc3QgPT0gJz0nKQorCQkJCXJldHVybiBvcHRlcnJvcihvcHRpb25zLCAidGFrZXMgbm8gdmFsdWUiLCBmbGFncyk7CisJCQlpZiAoKnJlc3QpCisJCQkJY29udGludWU7CisJCQlwLT5vdXRbcC0+Y3BpZHgrK10gPSBhcmcgLSAyOworCQkJcmV0dXJuIDA7CisJCX0KKwkJaWYgKCFyZXN0KSB7CisJCQkvKiBhYmJyZXZpYXRlZD8gKi8KKwkJCWlmICghc3RybmNtcChvcHRpb25zLT5sb25nX25hbWUsIGFyZywgYXJnX2VuZCAtIGFyZykpIHsKK2lzX2FiYnJldmlhdGVkOgorCQkJCWlmIChhYmJyZXZfb3B0aW9uKSB7CisJCQkJCS8qCisJCQkJCSAqIElmIHRoaXMgaXMgYWJicmV2aWF0ZWQsIGl0IGlzCisJCQkJCSAqIGFtYmlndW91cy4gU28gd2hlbiB0aGVyZSBpcyBubworCQkJCQkgKiBleGFjdCBtYXRjaCBsYXRlciwgd2UgbmVlZCB0bworCQkJCQkgKiBlcnJvciBvdXQuCisJCQkJCSAqLworCQkJCQlhbWJpZ3VvdXNfb3B0aW9uID0gYWJicmV2X29wdGlvbjsKKwkJCQkJYW1iaWd1b3VzX2ZsYWdzID0gYWJicmV2X2ZsYWdzOworCQkJCX0KKwkJCQlpZiAoIShmbGFncyAmIE9QVF9VTlNFVCkgJiYgKmFyZ19lbmQpCisJCQkJCXAtPm9wdCA9IGFyZ19lbmQgKyAxOworCQkJCWFiYnJldl9vcHRpb24gPSBvcHRpb25zOworCQkJCWFiYnJldl9mbGFncyA9IGZsYWdzOworCQkJCWNvbnRpbnVlOworCQkJfQorCQkJLyogbmVnYXRlZCBhbmQgYWJicmV2aWF0ZWQgdmVyeSBtdWNoPyAqLworCQkJaWYgKCFwcmVmaXhjbXAoIm5vLSIsIGFyZykpIHsKKwkJCQlmbGFncyB8PSBPUFRfVU5TRVQ7CisJCQkJZ290byBpc19hYmJyZXZpYXRlZDsKKwkJCX0KKwkJCS8qIG5lZ2F0ZWQ/ICovCisJCQlpZiAoc3RybmNtcChhcmcsICJuby0iLCAzKSkKKwkJCQljb250aW51ZTsKKwkJCWZsYWdzIHw9IE9QVF9VTlNFVDsKKwkJCXJlc3QgPSBza2lwX3ByZWZpeChhcmcgKyAzLCBvcHRpb25zLT5sb25nX25hbWUpOworCQkJLyogYWJicmV2aWF0ZWQgYW5kIG5lZ2F0ZWQ/ICovCisJCQlpZiAoIXJlc3QgJiYgIXByZWZpeGNtcChvcHRpb25zLT5sb25nX25hbWUsIGFyZyArIDMpKQorCQkJCWdvdG8gaXNfYWJicmV2aWF0ZWQ7CisJCQlpZiAoIXJlc3QpCisJCQkJY29udGludWU7CisJCX0KKwkJaWYgKCpyZXN0KSB7CisJCQlpZiAoKnJlc3QgIT0gJz0nKQorCQkJCWNvbnRpbnVlOworCQkJcC0+b3B0ID0gcmVzdCArIDE7CisJCX0KKwkJcmV0dXJuIGdldF92YWx1ZShwLCBvcHRpb25zLCBmbGFncyk7CisJfQorCisJaWYgKGFtYmlndW91c19vcHRpb24pCisJCXJldHVybiBlcnJvcigiQW1iaWd1b3VzIG9wdGlvbjogJXMgIgorCQkJIihjb3VsZCBiZSAtLSVzJXMgb3IgLS0lcyVzKSIsCisJCQlhcmcsCisJCQkoYW1iaWd1b3VzX2ZsYWdzICYgT1BUX1VOU0VUKSA/ICAibm8tIiA6ICIiLAorCQkJYW1iaWd1b3VzX29wdGlvbi0+bG9uZ19uYW1lLAorCQkJKGFiYnJldl9mbGFncyAmIE9QVF9VTlNFVCkgPyAgIm5vLSIgOiAiIiwKKwkJCWFiYnJldl9vcHRpb24tPmxvbmdfbmFtZSk7CisJaWYgKGFiYnJldl9vcHRpb24pCisJCXJldHVybiBnZXRfdmFsdWUocCwgYWJicmV2X29wdGlvbiwgYWJicmV2X2ZsYWdzKTsKKwlyZXR1cm4gLTI7Cit9CisKK3N0YXRpYyB2b2lkIGNoZWNrX3R5cG9zKGNvbnN0IGNoYXIgKmFyZywgY29uc3Qgc3RydWN0IG9wdGlvbiAqb3B0aW9ucykKK3sKKwlpZiAoc3RybGVuKGFyZykgPCAzKQorCQlyZXR1cm47CisKKwlpZiAoIXByZWZpeGNtcChhcmcsICJuby0iKSkgeworCQllcnJvciAoImRpZCB5b3UgbWVhbiBgLS0lc2AgKHdpdGggdHdvIGRhc2hlcyA/KSIsIGFyZyk7CisJCWV4aXQoMTI5KTsKKwl9CisKKwlmb3IgKDsgb3B0aW9ucy0+dHlwZSAhPSBPUFRJT05fRU5EOyBvcHRpb25zKyspIHsKKwkJaWYgKCFvcHRpb25zLT5sb25nX25hbWUpCisJCQljb250aW51ZTsKKwkJaWYgKCFwcmVmaXhjbXAob3B0aW9ucy0+bG9uZ19uYW1lLCBhcmcpKSB7CisJCQllcnJvciAoImRpZCB5b3UgbWVhbiBgLS0lc2AgKHdpdGggdHdvIGRhc2hlcyA/KSIsIGFyZyk7CisJCQlleGl0KDEyOSk7CisJCX0KKwl9Cit9CisKK3ZvaWQgcGFyc2Vfb3B0aW9uc19zdGFydChzdHJ1Y3QgcGFyc2Vfb3B0X2N0eF90ICpjdHgsCisJCQkgaW50IGFyZ2MsIGNvbnN0IGNoYXIgKiphcmd2LCBpbnQgZmxhZ3MpCit7CisJbWVtc2V0KGN0eCwgMCwgc2l6ZW9mKCpjdHgpKTsKKwljdHgtPmFyZ2MgPSBhcmdjIC0gMTsKKwljdHgtPmFyZ3YgPSBhcmd2ICsgMTsKKwljdHgtPm91dCAgPSBhcmd2OworCWN0eC0+Y3BpZHggPSAoKGZsYWdzICYgUEFSU0VfT1BUX0tFRVBfQVJHVjApICE9IDApOworCWN0eC0+ZmxhZ3MgPSBmbGFnczsKKwlpZiAoKGZsYWdzICYgUEFSU0VfT1BUX0tFRVBfVU5LTk9XTikgJiYKKwkgICAgKGZsYWdzICYgUEFSU0VfT1BUX1NUT1BfQVRfTk9OX09QVElPTikpCisJCWRpZSgiU1RPUF9BVF9OT05fT1BUSU9OIGFuZCBLRUVQX1VOS05PV04gZG9uJ3QgZ28gdG9nZXRoZXIiKTsKK30KKworc3RhdGljIGludCB1c2FnZV93aXRoX29wdGlvbnNfaW50ZXJuYWwoY29uc3QgY2hhciAqIGNvbnN0ICosCisJCQkJICAgICAgIGNvbnN0IHN0cnVjdCBvcHRpb24gKiwgaW50KTsKKworaW50IHBhcnNlX29wdGlvbnNfc3RlcChzdHJ1Y3QgcGFyc2Vfb3B0X2N0eF90ICpjdHgsCisJCSAgICAgICBjb25zdCBzdHJ1Y3Qgb3B0aW9uICpvcHRpb25zLAorCQkgICAgICAgY29uc3QgY2hhciAqIGNvbnN0IHVzYWdlc3RyW10pCit7CisJaW50IGludGVybmFsX2hlbHAgPSAhKGN0eC0+ZmxhZ3MgJiBQQVJTRV9PUFRfTk9fSU5URVJOQUxfSEVMUCk7CisKKwkvKiB3ZSBtdXN0IHJlc2V0IC0+b3B0LCB1bmtub3duIHNob3J0IG9wdGlvbiBsZWF2ZSBpdCBkYW5nbGluZyAqLworCWN0eC0+b3B0ID0gTlVMTDsKKworCWZvciAoOyBjdHgtPmFyZ2M7IGN0eC0+YXJnYy0tLCBjdHgtPmFyZ3YrKykgeworCQljb25zdCBjaGFyICphcmcgPSBjdHgtPmFyZ3ZbMF07CisKKwkJaWYgKCphcmcgIT0gJy0nIHx8ICFhcmdbMV0pIHsKKwkJCWlmIChjdHgtPmZsYWdzICYgUEFSU0VfT1BUX1NUT1BfQVRfTk9OX09QVElPTikKKwkJCQlicmVhazsKKwkJCWN0eC0+b3V0W2N0eC0+Y3BpZHgrK10gPSBjdHgtPmFyZ3ZbMF07CisJCQljb250aW51ZTsKKwkJfQorCisJCWlmIChhcmdbMV0gIT0gJy0nKSB7CisJCQljdHgtPm9wdCA9IGFyZyArIDE7CisJCQlpZiAoaW50ZXJuYWxfaGVscCAmJiAqY3R4LT5vcHQgPT0gJ2gnKQorCQkJCXJldHVybiBwYXJzZV9vcHRpb25zX3VzYWdlKHVzYWdlc3RyLCBvcHRpb25zKTsKKwkJCXN3aXRjaCAocGFyc2Vfc2hvcnRfb3B0KGN0eCwgb3B0aW9ucykpIHsKKwkJCWNhc2UgLTE6CisJCQkJcmV0dXJuIHBhcnNlX29wdGlvbnNfdXNhZ2UodXNhZ2VzdHIsIG9wdGlvbnMpOworCQkJY2FzZSAtMjoKKwkJCQlnb3RvIHVua25vd247CisJCQl9CisJCQlpZiAoY3R4LT5vcHQpCisJCQkJY2hlY2tfdHlwb3MoYXJnICsgMSwgb3B0aW9ucyk7CisJCQl3aGlsZSAoY3R4LT5vcHQpIHsKKwkJCQlpZiAoaW50ZXJuYWxfaGVscCAmJiAqY3R4LT5vcHQgPT0gJ2gnKQorCQkJCQlyZXR1cm4gcGFyc2Vfb3B0aW9uc191c2FnZSh1c2FnZXN0ciwgb3B0aW9ucyk7CisJCQkJc3dpdGNoIChwYXJzZV9zaG9ydF9vcHQoY3R4LCBvcHRpb25zKSkgeworCQkJCWNhc2UgLTE6CisJCQkJCXJldHVybiBwYXJzZV9vcHRpb25zX3VzYWdlKHVzYWdlc3RyLCBvcHRpb25zKTsKKwkJCQljYXNlIC0yOgorCQkJCQkvKiBmYWtlIGEgc2hvcnQgb3B0aW9uIHRoaW5nIHRvIGhpZGUgdGhlIGZhY3QgdGhhdCB3ZSBtYXkgaGF2ZQorCQkJCQkgKiBzdGFydGVkIHRvIHBhcnNlIGFnZ3JlZ2F0ZWQgc3R1ZmYKKwkJCQkJICoKKwkJCQkJICogVGhpcyBpcyBsZWFreSwgdG9vIGJhZC4KKwkJCQkJICovCisJCQkJCWN0eC0+YXJndlswXSA9IHN0cmR1cChjdHgtPm9wdCAtIDEpOworCQkJCQkqKGNoYXIgKiljdHgtPmFyZ3ZbMF0gPSAnLSc7CisJCQkJCWdvdG8gdW5rbm93bjsKKwkJCQl9CisJCQl9CisJCQljb250aW51ZTsKKwkJfQorCisJCWlmICghYXJnWzJdKSB7IC8qICItLSIgKi8KKwkJCWlmICghKGN0eC0+ZmxhZ3MgJiBQQVJTRV9PUFRfS0VFUF9EQVNIREFTSCkpIHsKKwkJCQljdHgtPmFyZ2MtLTsKKwkJCQljdHgtPmFyZ3YrKzsKKwkJCX0KKwkJCWJyZWFrOworCQl9CisKKwkJaWYgKGludGVybmFsX2hlbHAgJiYgIXN0cmNtcChhcmcgKyAyLCAiaGVscC1hbGwiKSkKKwkJCXJldHVybiB1c2FnZV93aXRoX29wdGlvbnNfaW50ZXJuYWwodXNhZ2VzdHIsIG9wdGlvbnMsIDEpOworCQlpZiAoaW50ZXJuYWxfaGVscCAmJiAhc3RyY21wKGFyZyArIDIsICJoZWxwIikpCisJCQlyZXR1cm4gcGFyc2Vfb3B0aW9uc191c2FnZSh1c2FnZXN0ciwgb3B0aW9ucyk7CisJCXN3aXRjaCAocGFyc2VfbG9uZ19vcHQoY3R4LCBhcmcgKyAyLCBvcHRpb25zKSkgeworCQljYXNlIC0xOgorCQkJcmV0dXJuIHBhcnNlX29wdGlvbnNfdXNhZ2UodXNhZ2VzdHIsIG9wdGlvbnMpOworCQljYXNlIC0yOgorCQkJZ290byB1bmtub3duOworCQl9CisJCWNvbnRpbnVlOwordW5rbm93bjoKKwkJaWYgKCEoY3R4LT5mbGFncyAmIFBBUlNFX09QVF9LRUVQX1VOS05PV04pKQorCQkJcmV0dXJuIFBBUlNFX09QVF9VTktOT1dOOworCQljdHgtPm91dFtjdHgtPmNwaWR4KytdID0gY3R4LT5hcmd2WzBdOworCQljdHgtPm9wdCA9IE5VTEw7CisJfQorCXJldHVybiBQQVJTRV9PUFRfRE9ORTsKK30KKworaW50IHBhcnNlX29wdGlvbnNfZW5kKHN0cnVjdCBwYXJzZV9vcHRfY3R4X3QgKmN0eCkKK3sKKwltZW1tb3ZlKGN0eC0+b3V0ICsgY3R4LT5jcGlkeCwgY3R4LT5hcmd2LCBjdHgtPmFyZ2MgKiBzaXplb2YoKmN0eC0+b3V0KSk7CisJY3R4LT5vdXRbY3R4LT5jcGlkeCArIGN0eC0+YXJnY10gPSBOVUxMOworCXJldHVybiBjdHgtPmNwaWR4ICsgY3R4LT5hcmdjOworfQorCitpbnQgcGFyc2Vfb3B0aW9ucyhpbnQgYXJnYywgY29uc3QgY2hhciAqKmFyZ3YsIGNvbnN0IHN0cnVjdCBvcHRpb24gKm9wdGlvbnMsCisJCSAgY29uc3QgY2hhciAqIGNvbnN0IHVzYWdlc3RyW10sIGludCBmbGFncykKK3sKKwlzdHJ1Y3QgcGFyc2Vfb3B0X2N0eF90IGN0eDsKKworCXBhcnNlX29wdGlvbnNfc3RhcnQoJmN0eCwgYXJnYywgYXJndiwgZmxhZ3MpOworCXN3aXRjaCAocGFyc2Vfb3B0aW9uc19zdGVwKCZjdHgsIG9wdGlvbnMsIHVzYWdlc3RyKSkgeworCWNhc2UgUEFSU0VfT1BUX0hFTFA6CisJCWV4aXQoMTI5KTsKKwljYXNlIFBBUlNFX09QVF9ET05FOgorCQlicmVhazsKKwlkZWZhdWx0OiAvKiBQQVJTRV9PUFRfVU5LTk9XTiAqLworCQlpZiAoY3R4LmFyZ3ZbMF1bMV0gPT0gJy0nKSB7CisJCQllcnJvcigidW5rbm93biBvcHRpb24gYCVzJyIsIGN0eC5hcmd2WzBdICsgMik7CisJCX0gZWxzZSB7CisJCQllcnJvcigidW5rbm93biBzd2l0Y2ggYCVjJyIsICpjdHgub3B0KTsKKwkJfQorCQl1c2FnZV93aXRoX29wdGlvbnModXNhZ2VzdHIsIG9wdGlvbnMpOworCX0KKworCXJldHVybiBwYXJzZV9vcHRpb25zX2VuZCgmY3R4KTsKK30KKworI2RlZmluZSBVU0FHRV9PUFRTX1dJRFRIIDI0CisjZGVmaW5lIFVTQUdFX0dBUCAgICAgICAgIDIKKworaW50IHVzYWdlX3dpdGhfb3B0aW9uc19pbnRlcm5hbChjb25zdCBjaGFyICogY29uc3QgKnVzYWdlc3RyLAorCQkJCWNvbnN0IHN0cnVjdCBvcHRpb24gKm9wdHMsIGludCBmdWxsKQoreworCWlmICghdXNhZ2VzdHIpCisJCXJldHVybiBQQVJTRV9PUFRfSEVMUDsKKworCWZwcmludGYoc3RkZXJyLCAiXG4gdXNhZ2U6ICVzXG4iLCAqdXNhZ2VzdHIrKyk7CisJd2hpbGUgKCp1c2FnZXN0ciAmJiAqKnVzYWdlc3RyKQorCQlmcHJpbnRmKHN0ZGVyciwgIiAgICBvcjogJXNcbiIsICp1c2FnZXN0cisrKTsKKwl3aGlsZSAoKnVzYWdlc3RyKSB7CisJCWZwcmludGYoc3RkZXJyLCAiJXMlc1xuIiwKKwkJCQkqKnVzYWdlc3RyID8gIiAgICAiIDogIiIsCisJCQkJKnVzYWdlc3RyKTsKKwkJdXNhZ2VzdHIrKzsKKwl9CisKKwlpZiAob3B0cy0+dHlwZSAhPSBPUFRJT05fR1JPVVApCisJCWZwdXRjKCdcbicsIHN0ZGVycik7CisKKwlmb3IgKDsgb3B0cy0+dHlwZSAhPSBPUFRJT05fRU5EOyBvcHRzKyspIHsKKwkJc2l6ZV90IHBvczsKKwkJaW50IHBhZDsKKworCQlpZiAob3B0cy0+dHlwZSA9PSBPUFRJT05fR1JPVVApIHsKKwkJCWZwdXRjKCdcbicsIHN0ZGVycik7CisJCQlpZiAoKm9wdHMtPmhlbHApCisJCQkJZnByaW50ZihzdGRlcnIsICIlc1xuIiwgb3B0cy0+aGVscCk7CisJCQljb250aW51ZTsKKwkJfQorCQlpZiAoIWZ1bGwgJiYgKG9wdHMtPmZsYWdzICYgUEFSU0VfT1BUX0hJRERFTikpCisJCQljb250aW51ZTsKKworCQlwb3MgPSBmcHJpbnRmKHN0ZGVyciwgIiAgICAiKTsKKwkJaWYgKG9wdHMtPnNob3J0X25hbWUpCisJCQlwb3MgKz0gZnByaW50ZihzdGRlcnIsICItJWMiLCBvcHRzLT5zaG9ydF9uYW1lKTsKKwkJaWYgKG9wdHMtPmxvbmdfbmFtZSAmJiBvcHRzLT5zaG9ydF9uYW1lKQorCQkJcG9zICs9IGZwcmludGYoc3RkZXJyLCAiLCAiKTsKKwkJaWYgKG9wdHMtPmxvbmdfbmFtZSkKKwkJCXBvcyArPSBmcHJpbnRmKHN0ZGVyciwgIi0tJXMiLCBvcHRzLT5sb25nX25hbWUpOworCisJCXN3aXRjaCAob3B0cy0+dHlwZSkgeworCQljYXNlIE9QVElPTl9BUkdVTUVOVDoKKwkJCWJyZWFrOworCQljYXNlIE9QVElPTl9JTlRFR0VSOgorCQkJaWYgKG9wdHMtPmZsYWdzICYgUEFSU0VfT1BUX09QVEFSRykKKwkJCQlpZiAob3B0cy0+bG9uZ19uYW1lKQorCQkJCQlwb3MgKz0gZnByaW50ZihzdGRlcnIsICJbPTxuPl0iKTsKKwkJCQllbHNlCisJCQkJCXBvcyArPSBmcHJpbnRmKHN0ZGVyciwgIls8bj5dIik7CisJCQllbHNlCisJCQkJcG9zICs9IGZwcmludGYoc3RkZXJyLCAiIDxuPiIpOworCQkJYnJlYWs7CisJCWNhc2UgT1BUSU9OX0NBTExCQUNLOgorCQkJaWYgKG9wdHMtPmZsYWdzICYgUEFSU0VfT1BUX05PQVJHKQorCQkJCWJyZWFrOworCQkJLyogRkFMTFRIUk9VR0ggKi8KKwkJY2FzZSBPUFRJT05fU1RSSU5HOgorCQkJaWYgKG9wdHMtPmFyZ2gpIHsKKwkJCQlpZiAob3B0cy0+ZmxhZ3MgJiBQQVJTRV9PUFRfT1BUQVJHKQorCQkJCQlpZiAob3B0cy0+bG9uZ19uYW1lKQorCQkJCQkJcG9zICs9IGZwcmludGYoc3RkZXJyLCAiWz08JXM+XSIsIG9wdHMtPmFyZ2gpOworCQkJCQllbHNlCisJCQkJCQlwb3MgKz0gZnByaW50ZihzdGRlcnIsICJbPCVzPl0iLCBvcHRzLT5hcmdoKTsKKwkJCQllbHNlCisJCQkJCXBvcyArPSBmcHJpbnRmKHN0ZGVyciwgIiA8JXM+Iiwgb3B0cy0+YXJnaCk7CisJCQl9IGVsc2UgeworCQkJCWlmIChvcHRzLT5mbGFncyAmIFBBUlNFX09QVF9PUFRBUkcpCisJCQkJCWlmIChvcHRzLT5sb25nX25hbWUpCisJCQkJCQlwb3MgKz0gZnByaW50ZihzdGRlcnIsICJbPS4uLl0iKTsKKwkJCQkJZWxzZQorCQkJCQkJcG9zICs9IGZwcmludGYoc3RkZXJyLCAiWy4uLl0iKTsKKwkJCQllbHNlCisJCQkJCXBvcyArPSBmcHJpbnRmKHN0ZGVyciwgIiAuLi4iKTsKKwkJCX0KKwkJCWJyZWFrOworCQlkZWZhdWx0OiAvKiBPUFRJT05fe0JJVCxCT09MRUFOLFNFVF9JTlQsU0VUX1BUUn0gKi8KKwkJCWJyZWFrOworCQl9CisKKwkJaWYgKHBvcyA8PSBVU0FHRV9PUFRTX1dJRFRIKQorCQkJcGFkID0gVVNBR0VfT1BUU19XSURUSCAtIHBvczsKKwkJZWxzZSB7CisJCQlmcHV0YygnXG4nLCBzdGRlcnIpOworCQkJcGFkID0gVVNBR0VfT1BUU19XSURUSDsKKwkJfQorCQlmcHJpbnRmKHN0ZGVyciwgIiUqcyVzXG4iLCBwYWQgKyBVU0FHRV9HQVAsICIiLCBvcHRzLT5oZWxwKTsKKwl9CisJZnB1dGMoJ1xuJywgc3RkZXJyKTsKKworCXJldHVybiBQQVJTRV9PUFRfSEVMUDsKK30KKwordm9pZCB1c2FnZV93aXRoX29wdGlvbnMoY29uc3QgY2hhciAqIGNvbnN0ICp1c2FnZXN0ciwKKwkJCWNvbnN0IHN0cnVjdCBvcHRpb24gKm9wdHMpCit7CisJdXNhZ2Vfd2l0aF9vcHRpb25zX2ludGVybmFsKHVzYWdlc3RyLCBvcHRzLCAwKTsKKwlleGl0KDEyOSk7Cit9CisKK2ludCBwYXJzZV9vcHRpb25zX3VzYWdlKGNvbnN0IGNoYXIgKiBjb25zdCAqdXNhZ2VzdHIsCisJCQljb25zdCBzdHJ1Y3Qgb3B0aW9uICpvcHRzKQoreworCXJldHVybiB1c2FnZV93aXRoX29wdGlvbnNfaW50ZXJuYWwodXNhZ2VzdHIsIG9wdHMsIDApOworfQorCisKK2ludCBwYXJzZV9vcHRfdmVyYm9zaXR5X2NiKGNvbnN0IHN0cnVjdCBvcHRpb24gKm9wdCwgY29uc3QgY2hhciAqYXJnLAorCQkJICAgaW50IHVuc2V0KQoreworCWludCAqdGFyZ2V0ID0gb3B0LT52YWx1ZTsKKworCWlmICh1bnNldCkKKwkJLyogLS1uby1xdWlldCwgLS1uby12ZXJib3NlICovCisJCSp0YXJnZXQgPSAwOworCWVsc2UgaWYgKG9wdC0+c2hvcnRfbmFtZSA9PSAndicpIHsKKwkJaWYgKCp0YXJnZXQgPj0gMCkKKwkJCSgqdGFyZ2V0KSsrOworCQllbHNlCisJCQkqdGFyZ2V0ID0gMTsKKwl9IGVsc2UgeworCQlpZiAoKnRhcmdldCA8PSAwKQorCQkJKCp0YXJnZXQpLS07CisJCWVsc2UKKwkJCSp0YXJnZXQgPSAtMTsKKwl9CisJcmV0dXJuIDA7Cit9CmRpZmYgLS1naXQgYS90b29scy9wZXJmL3V0aWwvcGFyc2Utb3B0aW9ucy5oIGIvdG9vbHMvcGVyZi91dGlsL3BhcnNlLW9wdGlvbnMuaApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi5hMTAzOWE2Ci0tLSAvZGV2L251bGwKKysrIGIvdG9vbHMvcGVyZi91dGlsL3BhcnNlLW9wdGlvbnMuaApAQCAtMCwwICsxLDE3NCBAQAorI2lmbmRlZiBQQVJTRV9PUFRJT05TX0gKKyNkZWZpbmUgUEFSU0VfT1BUSU9OU19ICisKK2VudW0gcGFyc2Vfb3B0X3R5cGUgeworCS8qIHNwZWNpYWwgdHlwZXMgKi8KKwlPUFRJT05fRU5ELAorCU9QVElPTl9BUkdVTUVOVCwKKwlPUFRJT05fR1JPVVAsCisJLyogb3B0aW9ucyB3aXRoIG5vIGFyZ3VtZW50cyAqLworCU9QVElPTl9CSVQsCisJT1BUSU9OX0JPT0xFQU4sIC8qIF9JTkNSIHdvdWxkIGhhdmUgYmVlbiBhIGJldHRlciBuYW1lICovCisJT1BUSU9OX1NFVF9JTlQsCisJT1BUSU9OX1NFVF9QVFIsCisJLyogb3B0aW9ucyB3aXRoIGFyZ3VtZW50cyAodXN1YWxseSkgKi8KKwlPUFRJT05fU1RSSU5HLAorCU9QVElPTl9JTlRFR0VSLAorCU9QVElPTl9MT05HLAorCU9QVElPTl9DQUxMQkFDSywKK307CisKK2VudW0gcGFyc2Vfb3B0X2ZsYWdzIHsKKwlQQVJTRV9PUFRfS0VFUF9EQVNIREFTSCA9IDEsCisJUEFSU0VfT1BUX1NUT1BfQVRfTk9OX09QVElPTiA9IDIsCisJUEFSU0VfT1BUX0tFRVBfQVJHVjAgPSA0LAorCVBBUlNFX09QVF9LRUVQX1VOS05PV04gPSA4LAorCVBBUlNFX09QVF9OT19JTlRFUk5BTF9IRUxQID0gMTYsCit9OworCitlbnVtIHBhcnNlX29wdF9vcHRpb25fZmxhZ3MgeworCVBBUlNFX09QVF9PUFRBUkcgID0gMSwKKwlQQVJTRV9PUFRfTk9BUkcgICA9IDIsCisJUEFSU0VfT1BUX05PTkVHICAgPSA0LAorCVBBUlNFX09QVF9ISURERU4gID0gOCwKKwlQQVJTRV9PUFRfTEFTVEFSR19ERUZBVUxUID0gMTYsCit9OworCitzdHJ1Y3Qgb3B0aW9uOwordHlwZWRlZiBpbnQgcGFyc2Vfb3B0X2NiKGNvbnN0IHN0cnVjdCBvcHRpb24gKiwgY29uc3QgY2hhciAqYXJnLCBpbnQgdW5zZXQpOworCisvKgorICogYHR5cGVgOjoKKyAqICAgaG9sZHMgdGhlIHR5cGUgb2YgdGhlIG9wdGlvbiwgeW91IG11c3QgaGF2ZSBhbiBPUFRJT05fRU5EIGxhc3QgaW4geW91cgorICogICBhcnJheS4KKyAqCisgKiBgc2hvcnRfbmFtZWA6OgorICogICB0aGUgY2hhcmFjdGVyIHRvIHVzZSBhcyBhIHNob3J0IG9wdGlvbiBuYW1lLCAnXDAnIGlmIG5vbmUuCisgKgorICogYGxvbmdfbmFtZWA6OgorICogICB0aGUgbG9uZyBvcHRpb24gbmFtZSwgd2l0aG91dCB0aGUgbGVhZGluZyBkYXNoZXMsIE5VTEwgaWYgbm9uZS4KKyAqCisgKiBgdmFsdWVgOjoKKyAqICAgc3RvcmVzIHBvaW50ZXJzIHRvIHRoZSB2YWx1ZXMgdG8gYmUgZmlsbGVkLgorICoKKyAqIGBhcmdoYDo6CisgKiAgIHRva2VuIHRvIGV4cGxhaW4gdGhlIGtpbmQgb2YgYXJndW1lbnQgdGhpcyBvcHRpb24gd2FudHMuIEtlZXAgaXQKKyAqICAgaG9tb2dlbm91cyBhY3Jvc3MgdGhlIHJlcG9zaXRvcnkuCisgKgorICogYGhlbHBgOjoKKyAqICAgdGhlIHNob3J0IGhlbHAgYXNzb2NpYXRlZCB0byB3aGF0IHRoZSBvcHRpb24gZG9lcy4KKyAqICAgTXVzdCBuZXZlciBiZSBOVUxMIChleGNlcHQgZm9yIE9QVElPTl9FTkQpLgorICogICBPUFRJT05fR1JPVVAgdXNlcyB0aGlzIHBvaW50ZXIgdG8gc3RvcmUgdGhlIGdyb3VwIGhlYWRlci4KKyAqCisgKiBgZmxhZ3NgOjoKKyAqICAgbWFzayBvZiBwYXJzZV9vcHRfb3B0aW9uX2ZsYWdzLgorICogICBQQVJTRV9PUFRfT1BUQVJHOiBzYXlzIHRoYXQgdGhlIGFyZ3VtZW50IGlzIG9wdGlvbm5hbCAobm90IGZvciBCT09MRUFOcykKKyAqICAgUEFSU0VfT1BUX05PQVJHOiBzYXlzIHRoYXQgdGhpcyBvcHRpb24gdGFrZXMgbm8gYXJndW1lbnQsIGZvciBDQUxMQkFDS3MKKyAqICAgUEFSU0VfT1BUX05PTkVHOiBzYXlzIHRoYXQgdGhpcyBvcHRpb24gY2Fubm90IGJlIG5lZ2F0ZWQKKyAqICAgUEFSU0VfT1BUX0hJRERFTiB0aGlzIG9wdGlvbiBpcyBza2lwcGVkIGluIHRoZSBkZWZhdWx0IHVzYWdlLCBzaG93ZWQgaW4KKyAqICAgICAgICAgICAgICAgICAgICB0aGUgbG9uZyBvbmUuCisgKgorICogYGNhbGxiYWNrYDo6CisgKiAgIHBvaW50ZXIgdG8gdGhlIGNhbGxiYWNrIHRvIHVzZSBmb3IgT1BUSU9OX0NBTExCQUNLLgorICoKKyAqIGBkZWZ2YWxgOjoKKyAqICAgZGVmYXVsdCB2YWx1ZSB0byBmaWxsICgqLT52YWx1ZSkgd2l0aCBmb3IgUEFSU0VfT1BUX09QVEFSRy4KKyAqICAgT1BUSU9OX3tCSVQsU0VUX0lOVCxTRVRfUFRSfSBzdG9yZSB0aGUge21hc2ssaW50ZWdlcixwb2ludGVyfSB0byBwdXQgaW4KKyAqICAgdGhlIHZhbHVlIHdoZW4gbWV0LgorICogICBDQUxMQkFDS1MgY2FuIHVzZSBpdCBsaWtlIHRoZXkgd2FudC4KKyAqLworc3RydWN0IG9wdGlvbiB7CisJZW51bSBwYXJzZV9vcHRfdHlwZSB0eXBlOworCWludCBzaG9ydF9uYW1lOworCWNvbnN0IGNoYXIgKmxvbmdfbmFtZTsKKwl2b2lkICp2YWx1ZTsKKwljb25zdCBjaGFyICphcmdoOworCWNvbnN0IGNoYXIgKmhlbHA7CisKKwlpbnQgZmxhZ3M7CisJcGFyc2Vfb3B0X2NiICpjYWxsYmFjazsKKwlpbnRwdHJfdCBkZWZ2YWw7Cit9OworCisjZGVmaW5lIE9QVF9FTkQoKSAgICAgICAgICAgICAgICAgICB7IE9QVElPTl9FTkQgfQorI2RlZmluZSBPUFRfQVJHVU1FTlQobCwgaCkgICAgICAgICAgeyBPUFRJT05fQVJHVU1FTlQsIDAsIChsKSwgTlVMTCwgTlVMTCwgKGgpIH0KKyNkZWZpbmUgT1BUX0dST1VQKGgpICAgICAgICAgICAgICAgIHsgT1BUSU9OX0dST1VQLCAwLCBOVUxMLCBOVUxMLCBOVUxMLCAoaCkgfQorI2RlZmluZSBPUFRfQklUKHMsIGwsIHYsIGgsIGIpICAgICAgeyBPUFRJT05fQklULCAocyksIChsKSwgKHYpLCBOVUxMLCAoaCksIDAsIE5VTEwsIChiKSB9CisjZGVmaW5lIE9QVF9CT09MRUFOKHMsIGwsIHYsIGgpICAgICB7IE9QVElPTl9CT09MRUFOLCAocyksIChsKSwgKHYpLCBOVUxMLCAoaCkgfQorI2RlZmluZSBPUFRfU0VUX0lOVChzLCBsLCB2LCBoLCBpKSAgeyBPUFRJT05fU0VUX0lOVCwgKHMpLCAobCksICh2KSwgTlVMTCwgKGgpLCAwLCBOVUxMLCAoaSkgfQorI2RlZmluZSBPUFRfU0VUX1BUUihzLCBsLCB2LCBoLCBwKSAgeyBPUFRJT05fU0VUX1BUUiwgKHMpLCAobCksICh2KSwgTlVMTCwgKGgpLCAwLCBOVUxMLCAocCkgfQorI2RlZmluZSBPUFRfSU5URUdFUihzLCBsLCB2LCBoKSAgICAgeyBPUFRJT05fSU5URUdFUiwgKHMpLCAobCksICh2KSwgTlVMTCwgKGgpIH0KKyNkZWZpbmUgT1BUX0xPTkcocywgbCwgdiwgaCkgICAgICAgIHsgT1BUSU9OX0xPTkcsIChzKSwgKGwpLCAodiksIE5VTEwsIChoKSB9CisjZGVmaW5lIE9QVF9TVFJJTkcocywgbCwgdiwgYSwgaCkgICB7IE9QVElPTl9TVFJJTkcsICAocyksIChsKSwgKHYpLCAoYSksIChoKSB9CisjZGVmaW5lIE9QVF9EQVRFKHMsIGwsIHYsIGgpIFwKKwl7IE9QVElPTl9DQUxMQkFDSywgKHMpLCAobCksICh2KSwgInRpbWUiLChoKSwgMCwgXAorCSAgcGFyc2Vfb3B0X2FwcHJveGlkYXRlX2NiIH0KKyNkZWZpbmUgT1BUX0NBTExCQUNLKHMsIGwsIHYsIGEsIGgsIGYpIFwKKwl7IE9QVElPTl9DQUxMQkFDSywgKHMpLCAobCksICh2KSwgKGEpLCAoaCksIDAsIChmKSB9CisKKy8qIHBhcnNlX29wdGlvbnMoKSB3aWxsIGZpbHRlciBvdXQgdGhlIHByb2Nlc3NlZCBvcHRpb25zIGFuZCBsZWF2ZSB0aGUKKyAqIG5vbi1vcHRpb24gYXJnbWVudHMgaW4gYXJndltdLgorICogUmV0dXJucyB0aGUgbnVtYmVyIG9mIGFyZ3VtZW50cyBsZWZ0IGluIGFyZ3ZbXS4KKyAqLworZXh0ZXJuIGludCBwYXJzZV9vcHRpb25zKGludCBhcmdjLCBjb25zdCBjaGFyICoqYXJndiwKKyAgICAgICAgICAgICAgICAgICAgICAgICBjb25zdCBzdHJ1Y3Qgb3B0aW9uICpvcHRpb25zLAorICAgICAgICAgICAgICAgICAgICAgICAgIGNvbnN0IGNoYXIgKiBjb25zdCB1c2FnZXN0cltdLCBpbnQgZmxhZ3MpOworCitleHRlcm4gTk9SRVRVUk4gdm9pZCB1c2FnZV93aXRoX29wdGlvbnMoY29uc3QgY2hhciAqIGNvbnN0ICp1c2FnZXN0ciwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBjb25zdCBzdHJ1Y3Qgb3B0aW9uICpvcHRpb25zKTsKKworLyotLS0tLSBpbmNyZW1hbnRhbCBhZHZhbmNlZCBBUElzIC0tLS0tKi8KKworZW51bSB7CisJUEFSU0VfT1BUX0hFTFAgPSAtMSwKKwlQQVJTRV9PUFRfRE9ORSwKKwlQQVJTRV9PUFRfVU5LTk9XTiwKK307CisKKy8qCisgKiBJdCdzIG9rYXkgZm9yIHRoZSBjYWxsZXIgdG8gY29uc3VtZSBhcmd2L2FyZ2MgaW4gdGhlIHVzdWFsIHdheS4KKyAqIE90aGVyIGZpZWxkcyBvZiB0aGF0IHN0cnVjdHVyZSBhcmUgcHJpdmF0ZSB0byBwYXJzZS1vcHRpb25zIGFuZCBzaG91bGQgbm90CisgKiBiZSBtb2RpZmllZCBpbiBhbnkgd2F5LgorICovCitzdHJ1Y3QgcGFyc2Vfb3B0X2N0eF90IHsKKwljb25zdCBjaGFyICoqYXJndjsKKwljb25zdCBjaGFyICoqb3V0OworCWludCBhcmdjLCBjcGlkeDsKKwljb25zdCBjaGFyICpvcHQ7CisJaW50IGZsYWdzOworfTsKKworZXh0ZXJuIGludCBwYXJzZV9vcHRpb25zX3VzYWdlKGNvbnN0IGNoYXIgKiBjb25zdCAqdXNhZ2VzdHIsCisJCQkgICAgICAgY29uc3Qgc3RydWN0IG9wdGlvbiAqb3B0cyk7CisKK2V4dGVybiB2b2lkIHBhcnNlX29wdGlvbnNfc3RhcnQoc3RydWN0IHBhcnNlX29wdF9jdHhfdCAqY3R4LAorCQkJCWludCBhcmdjLCBjb25zdCBjaGFyICoqYXJndiwgaW50IGZsYWdzKTsKKworZXh0ZXJuIGludCBwYXJzZV9vcHRpb25zX3N0ZXAoc3RydWN0IHBhcnNlX29wdF9jdHhfdCAqY3R4LAorCQkJICAgICAgY29uc3Qgc3RydWN0IG9wdGlvbiAqb3B0aW9ucywKKwkJCSAgICAgIGNvbnN0IGNoYXIgKiBjb25zdCB1c2FnZXN0cltdKTsKKworZXh0ZXJuIGludCBwYXJzZV9vcHRpb25zX2VuZChzdHJ1Y3QgcGFyc2Vfb3B0X2N0eF90ICpjdHgpOworCisKKy8qLS0tLS0gc29tZSBvZnRlbiB1c2VkIG9wdGlvbnMgLS0tLS0qLworZXh0ZXJuIGludCBwYXJzZV9vcHRfYWJicmV2X2NiKGNvbnN0IHN0cnVjdCBvcHRpb24gKiwgY29uc3QgY2hhciAqLCBpbnQpOworZXh0ZXJuIGludCBwYXJzZV9vcHRfYXBwcm94aWRhdGVfY2IoY29uc3Qgc3RydWN0IG9wdGlvbiAqLCBjb25zdCBjaGFyICosIGludCk7CitleHRlcm4gaW50IHBhcnNlX29wdF92ZXJib3NpdHlfY2IoY29uc3Qgc3RydWN0IG9wdGlvbiAqLCBjb25zdCBjaGFyICosIGludCk7CisKKyNkZWZpbmUgT1BUX19WRVJCT1NFKHZhcikgIE9QVF9CT09MRUFOKCd2JywgInZlcmJvc2UiLCAodmFyKSwgImJlIHZlcmJvc2UiKQorI2RlZmluZSBPUFRfX1FVSUVUKHZhcikgICAgT1BUX0JPT0xFQU4oJ3EnLCAicXVpZXQiLCAgICh2YXIpLCAiYmUgcXVpZXQiKQorI2RlZmluZSBPUFRfX1ZFUkJPU0lUWSh2YXIpIFwKKwl7IE9QVElPTl9DQUxMQkFDSywgJ3YnLCAidmVyYm9zZSIsICh2YXIpLCBOVUxMLCAiYmUgbW9yZSB2ZXJib3NlIiwgXAorCSAgUEFSU0VfT1BUX05PQVJHLCAmcGFyc2Vfb3B0X3ZlcmJvc2l0eV9jYiwgMCB9LCBcCisJeyBPUFRJT05fQ0FMTEJBQ0ssICdxJywgInF1aWV0IiwgKHZhciksIE5VTEwsICJiZSBtb3JlIHF1aWV0IiwgXAorCSAgUEFSU0VfT1BUX05PQVJHLCAmcGFyc2Vfb3B0X3ZlcmJvc2l0eV9jYiwgMCB9CisjZGVmaW5lIE9QVF9fRFJZX1JVTih2YXIpICBPUFRfQk9PTEVBTignbicsICJkcnktcnVuIiwgKHZhciksICJkcnkgcnVuIikKKyNkZWZpbmUgT1BUX19BQkJSRVYodmFyKSAgXAorCXsgT1BUSU9OX0NBTExCQUNLLCAwLCAiYWJicmV2IiwgKHZhciksICJuIiwgXAorCSAgInVzZSA8bj4gZGlnaXRzIHRvIGRpc3BsYXkgU0hBLTFzIiwgXAorCSAgUEFSU0VfT1BUX09QVEFSRywgJnBhcnNlX29wdF9hYmJyZXZfY2IsIDAgfQorCitleHRlcm4gY29uc3QgY2hhciAqcGFyc2Vfb3B0aW9uc19maXhfZmlsZW5hbWUoY29uc3QgY2hhciAqcHJlZml4LCBjb25zdCBjaGFyICpmaWxlKTsKKworI2VuZGlmCmRpZmYgLS1naXQgYS90b29scy9wZXJmL3V0aWwvcGF0aC5jIGIvdG9vbHMvcGVyZi91dGlsL3BhdGguYwpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi5hNTAxYTQwCi0tLSAvZGV2L251bGwKKysrIGIvdG9vbHMvcGVyZi91dGlsL3BhdGguYwpAQCAtMCwwICsxLDM1MyBAQAorLyoKKyAqIEknbSB0aXJlZCBvZiBkb2luZyAidnNucHJpbnRmKCkiIGV0YyBqdXN0IHRvIG9wZW4gYQorICogZmlsZSwgc28gaGVyZSdzIGEgInJldHVybiBzdGF0aWMgYnVmZmVyIHdpdGggcHJpbnRmIgorICogaW50ZXJmYWNlIGZvciBwYXRocy4KKyAqCisgKiBJdCdzIG9idmlvdXNseSBub3QgdGhyZWFkLXNhZmUuIFN1ZSBtZS4gQnV0IGl0J3MgcXVpdGUKKyAqIHVzZWZ1bCBmb3IgZG9pbmcgdGhpbmdzIGxpa2UKKyAqCisgKiAgIGYgPSBvcGVuKG1rcGF0aCgiJXMvJXMucGVyZiIsIGJhc2UsIG5hbWUpLCBPX1JET05MWSk7CisgKgorICogd2hpY2ggaXMgd2hhdCBpdCdzIGRlc2lnbmVkIGZvci4KKyAqLworI2luY2x1ZGUgImNhY2hlLmgiCisKK3N0YXRpYyBjaGFyIGJhZF9wYXRoW10gPSAiL2JhZC1wYXRoLyI7CisvKgorICogVHdvIGhhY2tzOgorICovCisKK3N0YXRpYyBjaGFyICpnZXRfcGVyZl9kaXIodm9pZCkKK3sKKwlyZXR1cm4gIi4iOworfQorCitzaXplX3Qgc3RybGNweShjaGFyICpkZXN0LCBjb25zdCBjaGFyICpzcmMsIHNpemVfdCBzaXplKQoreworCXNpemVfdCByZXQgPSBzdHJsZW4oc3JjKTsKKworCWlmIChzaXplKSB7CisJCXNpemVfdCBsZW4gPSAocmV0ID49IHNpemUpID8gc2l6ZSAtIDEgOiByZXQ7CisJCW1lbWNweShkZXN0LCBzcmMsIGxlbik7CisJCWRlc3RbbGVuXSA9ICdcMCc7CisJfQorCXJldHVybiByZXQ7Cit9CisKKworc3RhdGljIGNoYXIgKmdldF9wYXRobmFtZSh2b2lkKQoreworCXN0YXRpYyBjaGFyIHBhdGhuYW1lX2FycmF5WzRdW1BBVEhfTUFYXTsKKwlzdGF0aWMgaW50IGluZGV4OworCXJldHVybiBwYXRobmFtZV9hcnJheVszICYgKytpbmRleF07Cit9CisKK3N0YXRpYyBjaGFyICpjbGVhbnVwX3BhdGgoY2hhciAqcGF0aCkKK3sKKwkvKiBDbGVhbiBpdCB1cCAqLworCWlmICghbWVtY21wKHBhdGgsICIuLyIsIDIpKSB7CisJCXBhdGggKz0gMjsKKwkJd2hpbGUgKCpwYXRoID09ICcvJykKKwkJCXBhdGgrKzsKKwl9CisJcmV0dXJuIHBhdGg7Cit9CisKK2NoYXIgKm1rc25wYXRoKGNoYXIgKmJ1Ziwgc2l6ZV90IG4sIGNvbnN0IGNoYXIgKmZtdCwgLi4uKQoreworCXZhX2xpc3QgYXJnczsKKwl1bnNpZ25lZCBsZW47CisKKwl2YV9zdGFydChhcmdzLCBmbXQpOworCWxlbiA9IHZzbnByaW50ZihidWYsIG4sIGZtdCwgYXJncyk7CisJdmFfZW5kKGFyZ3MpOworCWlmIChsZW4gPj0gbikgeworCQlzdHJsY3B5KGJ1ZiwgYmFkX3BhdGgsIG4pOworCQlyZXR1cm4gYnVmOworCX0KKwlyZXR1cm4gY2xlYW51cF9wYXRoKGJ1Zik7Cit9CisKK3N0YXRpYyBjaGFyICpwZXJmX3ZzbnBhdGgoY2hhciAqYnVmLCBzaXplX3QgbiwgY29uc3QgY2hhciAqZm10LCB2YV9saXN0IGFyZ3MpCit7CisJY29uc3QgY2hhciAqcGVyZl9kaXIgPSBnZXRfcGVyZl9kaXIoKTsKKwlzaXplX3QgbGVuOworCisJbGVuID0gc3RybGVuKHBlcmZfZGlyKTsKKwlpZiAobiA8IGxlbiArIDEpCisJCWdvdG8gYmFkOworCW1lbWNweShidWYsIHBlcmZfZGlyLCBsZW4pOworCWlmIChsZW4gJiYgIWlzX2Rpcl9zZXAocGVyZl9kaXJbbGVuLTFdKSkKKwkJYnVmW2xlbisrXSA9ICcvJzsKKwlsZW4gKz0gdnNucHJpbnRmKGJ1ZiArIGxlbiwgbiAtIGxlbiwgZm10LCBhcmdzKTsKKwlpZiAobGVuID49IG4pCisJCWdvdG8gYmFkOworCXJldHVybiBjbGVhbnVwX3BhdGgoYnVmKTsKK2JhZDoKKwlzdHJsY3B5KGJ1ZiwgYmFkX3BhdGgsIG4pOworCXJldHVybiBidWY7Cit9CisKK2NoYXIgKnBlcmZfc25wYXRoKGNoYXIgKmJ1Ziwgc2l6ZV90IG4sIGNvbnN0IGNoYXIgKmZtdCwgLi4uKQoreworCXZhX2xpc3QgYXJnczsKKwl2YV9zdGFydChhcmdzLCBmbXQpOworCSh2b2lkKXBlcmZfdnNucGF0aChidWYsIG4sIGZtdCwgYXJncyk7CisJdmFfZW5kKGFyZ3MpOworCXJldHVybiBidWY7Cit9CisKK2NoYXIgKnBlcmZfcGF0aGR1cChjb25zdCBjaGFyICpmbXQsIC4uLikKK3sKKwljaGFyIHBhdGhbUEFUSF9NQVhdOworCXZhX2xpc3QgYXJnczsKKwl2YV9zdGFydChhcmdzLCBmbXQpOworCSh2b2lkKXBlcmZfdnNucGF0aChwYXRoLCBzaXplb2YocGF0aCksIGZtdCwgYXJncyk7CisJdmFfZW5kKGFyZ3MpOworCXJldHVybiB4c3RyZHVwKHBhdGgpOworfQorCitjaGFyICpta3BhdGgoY29uc3QgY2hhciAqZm10LCAuLi4pCit7CisJdmFfbGlzdCBhcmdzOworCXVuc2lnbmVkIGxlbjsKKwljaGFyICpwYXRobmFtZSA9IGdldF9wYXRobmFtZSgpOworCisJdmFfc3RhcnQoYXJncywgZm10KTsKKwlsZW4gPSB2c25wcmludGYocGF0aG5hbWUsIFBBVEhfTUFYLCBmbXQsIGFyZ3MpOworCXZhX2VuZChhcmdzKTsKKwlpZiAobGVuID49IFBBVEhfTUFYKQorCQlyZXR1cm4gYmFkX3BhdGg7CisJcmV0dXJuIGNsZWFudXBfcGF0aChwYXRobmFtZSk7Cit9CisKK2NoYXIgKnBlcmZfcGF0aChjb25zdCBjaGFyICpmbXQsIC4uLikKK3sKKwljb25zdCBjaGFyICpwZXJmX2RpciA9IGdldF9wZXJmX2RpcigpOworCWNoYXIgKnBhdGhuYW1lID0gZ2V0X3BhdGhuYW1lKCk7CisJdmFfbGlzdCBhcmdzOworCXVuc2lnbmVkIGxlbjsKKworCWxlbiA9IHN0cmxlbihwZXJmX2Rpcik7CisJaWYgKGxlbiA+IFBBVEhfTUFYLTEwMCkKKwkJcmV0dXJuIGJhZF9wYXRoOworCW1lbWNweShwYXRobmFtZSwgcGVyZl9kaXIsIGxlbik7CisJaWYgKGxlbiAmJiBwZXJmX2RpcltsZW4tMV0gIT0gJy8nKQorCQlwYXRobmFtZVtsZW4rK10gPSAnLyc7CisJdmFfc3RhcnQoYXJncywgZm10KTsKKwlsZW4gKz0gdnNucHJpbnRmKHBhdGhuYW1lICsgbGVuLCBQQVRIX01BWCAtIGxlbiwgZm10LCBhcmdzKTsKKwl2YV9lbmQoYXJncyk7CisJaWYgKGxlbiA+PSBQQVRIX01BWCkKKwkJcmV0dXJuIGJhZF9wYXRoOworCXJldHVybiBjbGVhbnVwX3BhdGgocGF0aG5hbWUpOworfQorCisKKy8qIHBlcmZfbWtzdGVtcCgpIC0gY3JlYXRlIHRtcCBmaWxlIGhvbm9yaW5nIFRNUERJUiB2YXJpYWJsZSAqLworaW50IHBlcmZfbWtzdGVtcChjaGFyICpwYXRoLCBzaXplX3QgbGVuLCBjb25zdCBjaGFyICp0ZW1wbGF0ZSkKK3sKKwljb25zdCBjaGFyICp0bXA7CisJc2l6ZV90IG47CisKKwl0bXAgPSBnZXRlbnYoIlRNUERJUiIpOworCWlmICghdG1wKQorCQl0bXAgPSAiL3RtcCI7CisJbiA9IHNucHJpbnRmKHBhdGgsIGxlbiwgIiVzLyVzIiwgdG1wLCB0ZW1wbGF0ZSk7CisJaWYgKGxlbiA8PSBuKSB7CisJCWVycm5vID0gRU5BTUVUT09MT05HOworCQlyZXR1cm4gLTE7CisJfQorCXJldHVybiBta3N0ZW1wKHBhdGgpOworfQorCisKK2NvbnN0IGNoYXIgKm1ha2VfcmVsYXRpdmVfcGF0aChjb25zdCBjaGFyICphYnMsIGNvbnN0IGNoYXIgKmJhc2UpCit7CisJc3RhdGljIGNoYXIgYnVmW1BBVEhfTUFYICsgMV07CisJaW50IGJhc2VsZW47CisJaWYgKCFiYXNlKQorCQlyZXR1cm4gYWJzOworCWJhc2VsZW4gPSBzdHJsZW4oYmFzZSk7CisJaWYgKHByZWZpeGNtcChhYnMsIGJhc2UpKQorCQlyZXR1cm4gYWJzOworCWlmIChhYnNbYmFzZWxlbl0gPT0gJy8nKQorCQliYXNlbGVuKys7CisJZWxzZSBpZiAoYmFzZVtiYXNlbGVuIC0gMV0gIT0gJy8nKQorCQlyZXR1cm4gYWJzOworCXN0cmNweShidWYsIGFicyArIGJhc2VsZW4pOworCXJldHVybiBidWY7Cit9CisKKy8qCisgKiBJdCBpcyBva2F5IGlmIGRzdCA9PSBzcmMsIGJ1dCB0aGV5IHNob3VsZCBub3Qgb3ZlcmxhcCBvdGhlcndpc2UuCisgKgorICogUGVyZm9ybXMgdGhlIGZvbGxvd2luZyBub3JtYWxpemF0aW9ucyBvbiBzcmMsIHN0b3JpbmcgdGhlIHJlc3VsdCBpbiBkc3Q6CisgKiAtIEVuc3VyZXMgdGhhdCBjb21wb25lbnRzIGFyZSBzZXBhcmF0ZWQgYnkgJy8nIChXaW5kb3dzIG9ubHkpCisgKiAtIFNxdWFzaGVzIHNlcXVlbmNlcyBvZiAnLycuCisgKiAtIFJlbW92ZXMgIi4iIGNvbXBvbmVudHMuCisgKiAtIFJlbW92ZXMgIi4uIiBjb21wb25lbnRzLCBhbmQgdGhlIGNvbXBvbmVudHMgdGhlIHByZWNlZGUgdGhlbS4KKyAqIFJldHVybnMgZmFpbHVyZSAobm9uLXplcm8pIGlmIGEgIi4uIiBjb21wb25lbnQgYXBwZWFycyBhcyBmaXJzdCBwYXRoCisgKiBjb21wb25lbnQgYW55dGltZSBkdXJpbmcgdGhlIG5vcm1hbGl6YXRpb24uIE90aGVyd2lzZSwgcmV0dXJucyBzdWNjZXNzICgwKS4KKyAqCisgKiBOb3RlIHRoYXQgdGhpcyBmdW5jdGlvbiBpcyBwdXJlbHkgdGV4dHVhbC4gIEl0IGRvZXMgbm90IGZvbGxvdyBzeW1saW5rcywKKyAqIHZlcmlmeSB0aGUgZXhpc3RlbmNlIG9mIHRoZSBwYXRoLCBvciBtYWtlIGFueSBzeXN0ZW0gY2FsbHMuCisgKi8KK2ludCBub3JtYWxpemVfcGF0aF9jb3B5KGNoYXIgKmRzdCwgY29uc3QgY2hhciAqc3JjKQoreworCWNoYXIgKmRzdDA7CisKKwlpZiAoaGFzX2Rvc19kcml2ZV9wcmVmaXgoc3JjKSkgeworCQkqZHN0KysgPSAqc3JjKys7CisJCSpkc3QrKyA9ICpzcmMrKzsKKwl9CisJZHN0MCA9IGRzdDsKKworCWlmIChpc19kaXJfc2VwKCpzcmMpKSB7CisJCSpkc3QrKyA9ICcvJzsKKwkJd2hpbGUgKGlzX2Rpcl9zZXAoKnNyYykpCisJCQlzcmMrKzsKKwl9CisKKwlmb3IgKDs7KSB7CisJCWNoYXIgYyA9ICpzcmM7CisKKwkJLyoKKwkJICogQSBwYXRoIGNvbXBvbmVudCB0aGF0IGJlZ2lucyB3aXRoIC4gY291bGQgYmUKKwkJICogc3BlY2lhbDoKKwkJICogKDEpICIuIiBhbmQgZW5kcyAgIC0tIGlnbm9yZSBhbmQgdGVybWluYXRlLgorCQkgKiAoMikgIi4vIiAgICAgICAgICAgLS0gaWdub3JlIHRoZW0sIGVhdCBzbGFzaCBhbmQgY29udGludWUuCisJCSAqICgzKSAiLi4iIGFuZCBlbmRzICAtLSBzdHJpcCBvbmUgYW5kIHRlcm1pbmF0ZS4KKwkJICogKDQpICIuLi8iICAgICAgICAgIC0tIHN0cmlwIG9uZSwgZWF0IHNsYXNoIGFuZCBjb250aW51ZS4KKwkJICovCisJCWlmIChjID09ICcuJykgeworCQkJaWYgKCFzcmNbMV0pIHsKKwkJCQkvKiAoMSkgKi8KKwkJCQlzcmMrKzsKKwkJCX0gZWxzZSBpZiAoaXNfZGlyX3NlcChzcmNbMV0pKSB7CisJCQkJLyogKDIpICovCisJCQkJc3JjICs9IDI7CisJCQkJd2hpbGUgKGlzX2Rpcl9zZXAoKnNyYykpCisJCQkJCXNyYysrOworCQkJCWNvbnRpbnVlOworCQkJfSBlbHNlIGlmIChzcmNbMV0gPT0gJy4nKSB7CisJCQkJaWYgKCFzcmNbMl0pIHsKKwkJCQkJLyogKDMpICovCisJCQkJCXNyYyArPSAyOworCQkJCQlnb3RvIHVwX29uZTsKKwkJCQl9IGVsc2UgaWYgKGlzX2Rpcl9zZXAoc3JjWzJdKSkgeworCQkJCQkvKiAoNCkgKi8KKwkJCQkJc3JjICs9IDM7CisJCQkJCXdoaWxlIChpc19kaXJfc2VwKCpzcmMpKQorCQkJCQkJc3JjKys7CisJCQkJCWdvdG8gdXBfb25lOworCQkJCX0KKwkJCX0KKwkJfQorCisJCS8qIGNvcHkgdXAgdG8gdGhlIG5leHQgJy8nLCBhbmQgZWF0IGFsbCAnLycgKi8KKwkJd2hpbGUgKChjID0gKnNyYysrKSAhPSAnXDAnICYmICFpc19kaXJfc2VwKGMpKQorCQkJKmRzdCsrID0gYzsKKwkJaWYgKGlzX2Rpcl9zZXAoYykpIHsKKwkJCSpkc3QrKyA9ICcvJzsKKwkJCXdoaWxlIChpc19kaXJfc2VwKGMpKQorCQkJCWMgPSAqc3JjKys7CisJCQlzcmMtLTsKKwkJfSBlbHNlIGlmICghYykKKwkJCWJyZWFrOworCQljb250aW51ZTsKKworCXVwX29uZToKKwkJLyoKKwkJICogZHN0MC4uZHN0IGlzIHByZWZpeCBwb3J0aW9uLCBhbmQgZHN0Wy0xXSBpcyAnLyc7CisJCSAqIGdvIHVwIG9uZSBsZXZlbC4KKwkJICovCisJCWRzdC0tOwkvKiBnbyB0byB0cmFpbGluZyAnLycgKi8KKwkJaWYgKGRzdCA8PSBkc3QwKQorCQkJcmV0dXJuIC0xOworCQkvKiBXaW5kb3dzOiBkc3RbLTFdIGNhbm5vdCBiZSBiYWNrc2xhc2ggYW55bW9yZSAqLworCQl3aGlsZSAoZHN0MCA8IGRzdCAmJiBkc3RbLTFdICE9ICcvJykKKwkJCWRzdC0tOworCX0KKwkqZHN0ID0gJ1wwJzsKKwlyZXR1cm4gMDsKK30KKworLyoKKyAqIHBhdGggPSBDYW5vbmljYWwgYWJzb2x1dGUgcGF0aAorICogcHJlZml4X2xpc3QgPSBDb2xvbi1zZXBhcmF0ZWQgbGlzdCBvZiBhYnNvbHV0ZSBwYXRocworICoKKyAqIERldGVybWluZXMsIGZvciBlYWNoIHBhdGggaW4gcHJlZml4X2xpc3QsIHdoZXRoZXIgdGhlICJwcmVmaXgiIHJlYWxseQorICogaXMgYW4gYW5jZXN0b3IgZGlyZWN0b3J5IG9mIHBhdGguICBSZXR1cm5zIHRoZSBsZW5ndGggb2YgdGhlIGxvbmdlc3QKKyAqIGFuY2VzdG9yIGRpcmVjdG9yeSwgZXhjbHVkaW5nIGFueSB0cmFpbGluZyBzbGFzaGVzLCBvciAtMSBpZiBubyBwcmVmaXgKKyAqIGlzIGFuIGFuY2VzdG9yLiAgKE5vdGUgdGhhdCB0aGlzIG1lYW5zIDAgaXMgcmV0dXJuZWQgaWYgcHJlZml4X2xpc3QgaXMKKyAqICIvIi4pICIvZm9vIiBpcyBub3QgY29uc2lkZXJlZCBhbiBhbmNlc3RvciBvZiAiL2Zvb2JhciIuICBEaXJlY3RvcmllcworICogYXJlIG5vdCBjb25zaWRlcmVkIHRvIGJlIHRoZWlyIG93biBhbmNlc3RvcnMuICBwYXRoIG11c3QgYmUgaW4gYQorICogY2Fub25pY2FsIGZvcm06IGVtcHR5IGNvbXBvbmVudHMsIG9yICIuIiBvciAiLi4iIGNvbXBvbmVudHMgYXJlIG5vdAorICogYWxsb3dlZC4gIHByZWZpeF9saXN0IG1heSBiZSBudWxsLCB3aGljaCBpcyBsaWtlICIiLgorICovCitpbnQgbG9uZ2VzdF9hbmNlc3Rvcl9sZW5ndGgoY29uc3QgY2hhciAqcGF0aCwgY29uc3QgY2hhciAqcHJlZml4X2xpc3QpCit7CisJY2hhciBidWZbUEFUSF9NQVgrMV07CisJY29uc3QgY2hhciAqY2VpbCwgKmNvbG9uOworCWludCBsZW4sIG1heF9sZW4gPSAtMTsKKworCWlmIChwcmVmaXhfbGlzdCA9PSBOVUxMIHx8ICFzdHJjbXAocGF0aCwgIi8iKSkKKwkJcmV0dXJuIC0xOworCisJZm9yIChjb2xvbiA9IGNlaWwgPSBwcmVmaXhfbGlzdDsgKmNvbG9uOyBjZWlsID0gY29sb24rMSkgeworCQlmb3IgKGNvbG9uID0gY2VpbDsgKmNvbG9uICYmICpjb2xvbiAhPSBQQVRIX1NFUDsgY29sb24rKyk7CisJCWxlbiA9IGNvbG9uIC0gY2VpbDsKKwkJaWYgKGxlbiA9PSAwIHx8IGxlbiA+IFBBVEhfTUFYIHx8ICFpc19hYnNvbHV0ZV9wYXRoKGNlaWwpKQorCQkJY29udGludWU7CisJCXN0cmxjcHkoYnVmLCBjZWlsLCBsZW4rMSk7CisJCWlmIChub3JtYWxpemVfcGF0aF9jb3B5KGJ1ZiwgYnVmKSA8IDApCisJCQljb250aW51ZTsKKwkJbGVuID0gc3RybGVuKGJ1Zik7CisJCWlmIChsZW4gPiAwICYmIGJ1ZltsZW4tMV0gPT0gJy8nKQorCQkJYnVmWy0tbGVuXSA9ICdcMCc7CisKKwkJaWYgKCFzdHJuY21wKHBhdGgsIGJ1ZiwgbGVuKSAmJgorCQkgICAgcGF0aFtsZW5dID09ICcvJyAmJgorCQkgICAgbGVuID4gbWF4X2xlbikgeworCQkJbWF4X2xlbiA9IGxlbjsKKwkJfQorCX0KKworCXJldHVybiBtYXhfbGVuOworfQorCisvKiBzdHJpcCBhcmJpdHJhcnkgYW1vdW50IG9mIGRpcmVjdG9yeSBzZXBhcmF0b3JzIGF0IGVuZCBvZiBwYXRoICovCitzdGF0aWMgaW5saW5lIGludCBjaG9tcF90cmFpbGluZ19kaXJfc2VwKGNvbnN0IGNoYXIgKnBhdGgsIGludCBsZW4pCit7CisJd2hpbGUgKGxlbiAmJiBpc19kaXJfc2VwKHBhdGhbbGVuIC0gMV0pKQorCQlsZW4tLTsKKwlyZXR1cm4gbGVuOworfQorCisvKgorICogSWYgcGF0aCBlbmRzIHdpdGggc3VmZml4IChjb21wbGV0ZSBwYXRoIGNvbXBvbmVudHMpLCByZXR1cm5zIHRoZQorICogcGFydCBiZWZvcmUgc3VmZml4IChzYW5zIHRyYWlsaW5nIGRpcmVjdG9yeSBzZXBhcmF0b3JzKS4KKyAqIE90aGVyd2lzZSByZXR1cm5zIE5VTEwuCisgKi8KK2NoYXIgKnN0cmlwX3BhdGhfc3VmZml4KGNvbnN0IGNoYXIgKnBhdGgsIGNvbnN0IGNoYXIgKnN1ZmZpeCkKK3sKKwlpbnQgcGF0aF9sZW4gPSBzdHJsZW4ocGF0aCksIHN1ZmZpeF9sZW4gPSBzdHJsZW4oc3VmZml4KTsKKworCXdoaWxlIChzdWZmaXhfbGVuKSB7CisJCWlmICghcGF0aF9sZW4pCisJCQlyZXR1cm4gTlVMTDsKKworCQlpZiAoaXNfZGlyX3NlcChwYXRoW3BhdGhfbGVuIC0gMV0pKSB7CisJCQlpZiAoIWlzX2Rpcl9zZXAoc3VmZml4W3N1ZmZpeF9sZW4gLSAxXSkpCisJCQkJcmV0dXJuIE5VTEw7CisJCQlwYXRoX2xlbiA9IGNob21wX3RyYWlsaW5nX2Rpcl9zZXAocGF0aCwgcGF0aF9sZW4pOworCQkJc3VmZml4X2xlbiA9IGNob21wX3RyYWlsaW5nX2Rpcl9zZXAoc3VmZml4LCBzdWZmaXhfbGVuKTsKKwkJfQorCQllbHNlIGlmIChwYXRoWy0tcGF0aF9sZW5dICE9IHN1ZmZpeFstLXN1ZmZpeF9sZW5dKQorCQkJcmV0dXJuIE5VTEw7CisJfQorCisJaWYgKHBhdGhfbGVuICYmICFpc19kaXJfc2VwKHBhdGhbcGF0aF9sZW4gLSAxXSkpCisJCXJldHVybiBOVUxMOworCXJldHVybiB4c3RybmR1cChwYXRoLCBjaG9tcF90cmFpbGluZ19kaXJfc2VwKHBhdGgsIHBhdGhfbGVuKSk7Cit9CmRpZmYgLS1naXQgYS90b29scy9wZXJmL3V0aWwvcXVvdGUuYyBiL3Rvb2xzL3BlcmYvdXRpbC9xdW90ZS5jCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLmYxOGM1MjEKLS0tIC9kZXYvbnVsbAorKysgYi90b29scy9wZXJmL3V0aWwvcXVvdGUuYwpAQCAtMCwwICsxLDQ4MSBAQAorI2luY2x1ZGUgImNhY2hlLmgiCisjaW5jbHVkZSAicXVvdGUuaCIKKworaW50IHF1b3RlX3BhdGhfZnVsbHkgPSAxOworCisvKiBIZWxwIHRvIGNvcHkgdGhlIHRoaW5nIHByb3Blcmx5IHF1b3RlZCBmb3IgdGhlIHNoZWxsIHNhZmV0eS4KKyAqIGFueSBzaW5nbGUgcXVvdGUgaXMgcmVwbGFjZWQgd2l0aCAnXCcnLCBhbnkgZXhjbGFtYXRpb24gcG9pbnQKKyAqIGlzIHJlcGxhY2VkIHdpdGggJ1whJywgYW5kIHRoZSB3aG9sZSB0aGluZyBpcyBlbmNsb3NlZCBpbiBhCisgKgorICogRS5nLgorICogIG9yaWdpbmFsICAgICBzcV9xdW90ZSAgICAgcmVzdWx0CisgKiAgbmFtZSAgICAgPT0+IG5hbWUgICAgICA9PT4gJ25hbWUnCisgKiAgYSBiICAgICAgPT0+IGEgYiAgICAgICA9PT4gJ2EgYicKKyAqICBhJ2IgICAgICA9PT4gYSdcJydiICAgID09PiAnYSdcJydiJworICogIGEhYiAgICAgID09PiBhJ1whJ2IgICAgPT0+ICdhJ1whJ2InCisgKi8KK3N0YXRpYyBpbmxpbmUgaW50IG5lZWRfYnNfcXVvdGUoY2hhciBjKQoreworCXJldHVybiAoYyA9PSAnXCcnIHx8IGMgPT0gJyEnKTsKK30KKwordm9pZCBzcV9xdW90ZV9idWYoc3RydWN0IHN0cmJ1ZiAqZHN0LCBjb25zdCBjaGFyICpzcmMpCit7CisJY2hhciAqdG9fZnJlZSA9IE5VTEw7CisKKwlpZiAoZHN0LT5idWYgPT0gc3JjKQorCQl0b19mcmVlID0gc3RyYnVmX2RldGFjaChkc3QsIE5VTEwpOworCisJc3RyYnVmX2FkZGNoKGRzdCwgJ1wnJyk7CisJd2hpbGUgKCpzcmMpIHsKKwkJc2l6ZV90IGxlbiA9IHN0cmNzcG4oc3JjLCAiJyEiKTsKKwkJc3RyYnVmX2FkZChkc3QsIHNyYywgbGVuKTsKKwkJc3JjICs9IGxlbjsKKwkJd2hpbGUgKG5lZWRfYnNfcXVvdGUoKnNyYykpIHsKKwkJCXN0cmJ1Zl9hZGRzdHIoZHN0LCAiJ1xcIik7CisJCQlzdHJidWZfYWRkY2goZHN0LCAqc3JjKyspOworCQkJc3RyYnVmX2FkZGNoKGRzdCwgJ1wnJyk7CisJCX0KKwl9CisJc3RyYnVmX2FkZGNoKGRzdCwgJ1wnJyk7CisJZnJlZSh0b19mcmVlKTsKK30KKwordm9pZCBzcV9xdW90ZV9wcmludChGSUxFICpzdHJlYW0sIGNvbnN0IGNoYXIgKnNyYykKK3sKKwljaGFyIGM7CisKKwlmcHV0YygnXCcnLCBzdHJlYW0pOworCXdoaWxlICgoYyA9ICpzcmMrKykpIHsKKwkJaWYgKG5lZWRfYnNfcXVvdGUoYykpIHsKKwkJCWZwdXRzKCInXFwiLCBzdHJlYW0pOworCQkJZnB1dGMoYywgc3RyZWFtKTsKKwkJCWZwdXRjKCdcJycsIHN0cmVhbSk7CisJCX0gZWxzZSB7CisJCQlmcHV0YyhjLCBzdHJlYW0pOworCQl9CisJfQorCWZwdXRjKCdcJycsIHN0cmVhbSk7Cit9CisKK3ZvaWQgc3FfcXVvdGVfYXJndihzdHJ1Y3Qgc3RyYnVmICpkc3QsIGNvbnN0IGNoYXIqKiBhcmd2LCBzaXplX3QgbWF4bGVuKQoreworCWludCBpOworCisJLyogQ29weSBpbnRvIGRlc3RpbmF0aW9uIGJ1ZmZlci4gKi8KKwlzdHJidWZfZ3Jvdyhkc3QsIDI1NSk7CisJZm9yIChpID0gMDsgYXJndltpXTsgKytpKSB7CisJCXN0cmJ1Zl9hZGRjaChkc3QsICcgJyk7CisJCXNxX3F1b3RlX2J1Zihkc3QsIGFyZ3ZbaV0pOworCQlpZiAobWF4bGVuICYmIGRzdC0+bGVuID4gbWF4bGVuKQorCQkJZGllKCJUb28gbWFueSBvciBsb25nIGFyZ3VtZW50cyIpOworCX0KK30KKworY2hhciAqc3FfZGVxdW90ZV9zdGVwKGNoYXIgKmFyZywgY2hhciAqKm5leHQpCit7CisJY2hhciAqZHN0ID0gYXJnOworCWNoYXIgKnNyYyA9IGFyZzsKKwljaGFyIGM7CisKKwlpZiAoKnNyYyAhPSAnXCcnKQorCQlyZXR1cm4gTlVMTDsKKwlmb3IgKDs7KSB7CisJCWMgPSAqKytzcmM7CisJCWlmICghYykKKwkJCXJldHVybiBOVUxMOworCQlpZiAoYyAhPSAnXCcnKSB7CisJCQkqZHN0KysgPSBjOworCQkJY29udGludWU7CisJCX0KKwkJLyogV2Ugc3RlcHBlZCBvdXQgb2Ygc3EgKi8KKwkJc3dpdGNoICgqKytzcmMpIHsKKwkJY2FzZSAnXDAnOgorCQkJKmRzdCA9IDA7CisJCQlpZiAobmV4dCkKKwkJCQkqbmV4dCA9IE5VTEw7CisJCQlyZXR1cm4gYXJnOworCQljYXNlICdcXCc6CisJCQljID0gKisrc3JjOworCQkJaWYgKG5lZWRfYnNfcXVvdGUoYykgJiYgKisrc3JjID09ICdcJycpIHsKKwkJCQkqZHN0KysgPSBjOworCQkJCWNvbnRpbnVlOworCQkJfQorCQkvKiBGYWxsdGhyb3VnaCAqLworCQlkZWZhdWx0OgorCQkJaWYgKCFuZXh0IHx8ICFpc3NwYWNlKCpzcmMpKQorCQkJCXJldHVybiBOVUxMOworCQkJZG8geworCQkJCWMgPSAqKytzcmM7CisJCQl9IHdoaWxlIChpc3NwYWNlKGMpKTsKKwkJCSpkc3QgPSAwOworCQkJKm5leHQgPSBzcmM7CisJCQlyZXR1cm4gYXJnOworCQl9CisJfQorfQorCitjaGFyICpzcV9kZXF1b3RlKGNoYXIgKmFyZykKK3sKKwlyZXR1cm4gc3FfZGVxdW90ZV9zdGVwKGFyZywgTlVMTCk7Cit9CisKK2ludCBzcV9kZXF1b3RlX3RvX2FyZ3YoY2hhciAqYXJnLCBjb25zdCBjaGFyICoqKmFyZ3YsIGludCAqbnIsIGludCAqYWxsb2MpCit7CisJY2hhciAqbmV4dCA9IGFyZzsKKworCWlmICghKmFyZykKKwkJcmV0dXJuIDA7CisJZG8geworCQljaGFyICpkZXF1b3RlZCA9IHNxX2RlcXVvdGVfc3RlcChuZXh0LCAmbmV4dCk7CisJCWlmICghZGVxdW90ZWQpCisJCQlyZXR1cm4gLTE7CisJCUFMTE9DX0dST1coKmFyZ3YsICpuciArIDEsICphbGxvYyk7CisJCSgqYXJndilbKCpucikrK10gPSBkZXF1b3RlZDsKKwl9IHdoaWxlIChuZXh0KTsKKworCXJldHVybiAwOworfQorCisvKiAxIG1lYW5zOiBxdW90ZSBhcyBvY3RhbAorICogMCBtZWFuczogcXVvdGUgYXMgb2N0YWwgaWYgKHF1b3RlX3BhdGhfZnVsbHkpCisgKiAtMSBtZWFuczogbmV2ZXIgcXVvdGUKKyAqIGM6IHF1b3RlIGFzICJcXGMiCisgKi8KKyNkZWZpbmUgWDgoeCkgICB4LCB4LCB4LCB4LCB4LCB4LCB4LCB4CisjZGVmaW5lIFgxNih4KSAgWDgoeCksIFg4KHgpCitzdGF0aWMgc2lnbmVkIGNoYXIgY29uc3Qgc3FfbG9va3VwWzI1Nl0gPSB7CisJLyogICAgICAgICAgIDAgICAgMSAgICAyICAgIDMgICAgNCAgICA1ICAgIDYgICAgNyAqLworCS8qIDB4MDAgKi8gICAxLCAgIDEsICAgMSwgICAxLCAgIDEsICAgMSwgICAxLCAnYScsCisJLyogMHgwOCAqLyAnYicsICd0JywgJ24nLCAndicsICdmJywgJ3InLCAgIDEsICAgMSwKKwkvKiAweDEwICovIFgxNigxKSwKKwkvKiAweDIwICovICAtMSwgIC0xLCAnIicsICAtMSwgIC0xLCAgLTEsICAtMSwgIC0xLAorCS8qIDB4MjggKi8gWDE2KC0xKSwgWDE2KC0xKSwgWDE2KC0xKSwKKwkvKiAweDU4ICovICAtMSwgIC0xLCAgLTEsICAtMSwnXFwnLCAgLTEsICAtMSwgIC0xLAorCS8qIDB4NjAgKi8gWDE2KC0xKSwgWDgoLTEpLAorCS8qIDB4NzggKi8gIC0xLCAgLTEsICAtMSwgIC0xLCAgLTEsICAtMSwgIC0xLCAgIDEsCisJLyogMHg4MCAqLyAvKiBzZXQgdG8gMCAqLworfTsKKworc3RhdGljIGlubGluZSBpbnQgc3FfbXVzdF9xdW90ZShjaGFyIGMpCit7CisJcmV0dXJuIHNxX2xvb2t1cFsodW5zaWduZWQgY2hhciljXSArIHF1b3RlX3BhdGhfZnVsbHkgPiAwOworfQorCisvKiByZXR1cm5zIHRoZSBsb25nZXN0IHByZWZpeCBub3QgbmVlZGluZyBhIHF1b3RlIHVwIHRvIG1heGxlbiBpZiBwb3NpdGl2ZS4KKyAgIFRoaXMgc3RvcHMgYXQgdGhlIGZpcnN0IFwwIGJlY2F1c2UgaXQncyBtYXJrZWQgYXMgYSBjaGFyYWN0ZXIgbmVlZGluZyBhbgorICAgZXNjYXBlICovCitzdGF0aWMgc2l6ZV90IG5leHRfcXVvdGVfcG9zKGNvbnN0IGNoYXIgKnMsIHNzaXplX3QgbWF4bGVuKQoreworCXNpemVfdCBsZW47CisJaWYgKG1heGxlbiA8IDApIHsKKwkJZm9yIChsZW4gPSAwOyAhc3FfbXVzdF9xdW90ZShzW2xlbl0pOyBsZW4rKyk7CisJfSBlbHNlIHsKKwkJZm9yIChsZW4gPSAwOyBsZW4gPCBtYXhsZW4gJiYgIXNxX211c3RfcXVvdGUoc1tsZW5dKTsgbGVuKyspOworCX0KKwlyZXR1cm4gbGVuOworfQorCisvKgorICogQy1zdHlsZSBuYW1lIHF1b3RpbmcuCisgKgorICogKDEpIGlmIHNiIGFuZCBmcCBhcmUgYm90aCBOVUxMLCBpbnNwZWN0IHRoZSBpbnB1dCBuYW1lIGFuZCBjb3VudHMgdGhlCisgKiAgICAgbnVtYmVyIG9mIGJ5dGVzIHRoYXQgYXJlIG5lZWRlZCB0byBob2xkIGNfc3R5bGUgcXVvdGVkIHZlcnNpb24gb2YgbmFtZSwKKyAqICAgICBjb3VudGluZyB0aGUgZG91YmxlIHF1b3RlcyBhcm91bmQgaXQgYnV0IG5vdCB0ZXJtaW5hdGluZyBOVUwsIGFuZAorICogICAgIHJldHVybnMgaXQuCisgKiAgICAgSG93ZXZlciwgaWYgbmFtZSBkb2VzIG5vdCBuZWVkIGNfc3R5bGUgcXVvdGluZywgaXQgcmV0dXJucyAwLgorICoKKyAqICgyKSBpZiBzYiBvciBmcCBhcmUgbm90IE5VTEwsIGl0IGVtaXRzIHRoZSBjX3N0eWxlIHF1b3RlZCB2ZXJzaW9uCisgKiAgICAgb2YgbmFtZSwgZW5jbG9zZWQgd2l0aCBkb3VibGUgcXVvdGVzIGlmIGFza2VkIGFuZCBuZWVkZWQgb25seS4KKyAqICAgICBSZXR1cm4gdmFsdWUgaXMgdGhlIHNhbWUgYXMgaW4gKDEpLgorICovCitzdGF0aWMgc2l6ZV90IHF1b3RlX2Nfc3R5bGVfY291bnRlZChjb25zdCBjaGFyICpuYW1lLCBzc2l6ZV90IG1heGxlbiwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHN0cnVjdCBzdHJidWYgKnNiLCBGSUxFICpmcCwgaW50IG5vX2RxKQoreworI3VuZGVmIEVNSVQKKyNkZWZpbmUgRU1JVChjKSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIFwKKwlkbyB7ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIFwKKwkJaWYgKHNiKSBzdHJidWZfYWRkY2goc2IsIChjKSk7ICAgICAgICAgIFwKKwkJaWYgKGZwKSBmcHV0YygoYyksIGZwKTsgICAgICAgICAgICAgICAgIFwKKwkJY291bnQrKzsgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIFwKKwl9IHdoaWxlICgwKQorI2RlZmluZSBFTUlUQlVGKHMsIGwpICAgICAgICAgICAgICAgICAgICAgICAgICAgXAorCWRvIHsgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgXAorCQlpbnQgX19yZXQ7CQkJCVwKKwkJaWYgKHNiKSBzdHJidWZfYWRkKHNiLCAocyksIChsKSk7ICAgICAgIFwKKwkJaWYgKGZwKSBfX3JldCA9IGZ3cml0ZSgocyksIChsKSwgMSwgZnApOyAgICAgICAgXAorCQljb3VudCArPSAobCk7ICAgICAgICAgICAgICAgICAgICAgICAgICAgXAorCX0gd2hpbGUgKDApCisKKwlzaXplX3QgbGVuLCBjb3VudCA9IDA7CisJY29uc3QgY2hhciAqcCA9IG5hbWU7CisKKwlmb3IgKDs7KSB7CisJCWludCBjaDsKKworCQlsZW4gPSBuZXh0X3F1b3RlX3BvcyhwLCBtYXhsZW4pOworCQlpZiAobGVuID09IG1heGxlbiB8fCAhcFtsZW5dKQorCQkJYnJlYWs7CisKKwkJaWYgKCFub19kcSAmJiBwID09IG5hbWUpCisJCQlFTUlUKCciJyk7CisKKwkJRU1JVEJVRihwLCBsZW4pOworCQlFTUlUKCdcXCcpOworCQlwICs9IGxlbjsKKwkJY2ggPSAodW5zaWduZWQgY2hhcikqcCsrOworCQlpZiAoc3FfbG9va3VwW2NoXSA+PSAnICcpIHsKKwkJCUVNSVQoc3FfbG9va3VwW2NoXSk7CisJCX0gZWxzZSB7CisJCQlFTUlUKCgoY2ggPj4gNikgJiAwMykgKyAnMCcpOworCQkJRU1JVCgoKGNoID4+IDMpICYgMDcpICsgJzAnKTsKKwkJCUVNSVQoKChjaCA+PiAwKSAmIDA3KSArICcwJyk7CisJCX0KKwl9CisKKwlFTUlUQlVGKHAsIGxlbik7CisJaWYgKHAgPT0gbmFtZSkgICAvKiBubyBlbmRpbmcgcXVvdGUgbmVlZGVkICovCisJCXJldHVybiAwOworCisJaWYgKCFub19kcSkKKwkJRU1JVCgnIicpOworCXJldHVybiBjb3VudDsKK30KKworc2l6ZV90IHF1b3RlX2Nfc3R5bGUoY29uc3QgY2hhciAqbmFtZSwgc3RydWN0IHN0cmJ1ZiAqc2IsIEZJTEUgKmZwLCBpbnQgbm9kcSkKK3sKKwlyZXR1cm4gcXVvdGVfY19zdHlsZV9jb3VudGVkKG5hbWUsIC0xLCBzYiwgZnAsIG5vZHEpOworfQorCit2b2lkIHF1b3RlX3R3b19jX3N0eWxlKHN0cnVjdCBzdHJidWYgKnNiLCBjb25zdCBjaGFyICpwcmVmaXgsIGNvbnN0IGNoYXIgKnBhdGgsIGludCBub2RxKQoreworCWlmIChxdW90ZV9jX3N0eWxlKHByZWZpeCwgTlVMTCwgTlVMTCwgMCkgfHwKKwkgICAgcXVvdGVfY19zdHlsZShwYXRoLCBOVUxMLCBOVUxMLCAwKSkgeworCQlpZiAoIW5vZHEpCisJCQlzdHJidWZfYWRkY2goc2IsICciJyk7CisJCXF1b3RlX2Nfc3R5bGUocHJlZml4LCBzYiwgTlVMTCwgMSk7CisJCXF1b3RlX2Nfc3R5bGUocGF0aCwgc2IsIE5VTEwsIDEpOworCQlpZiAoIW5vZHEpCisJCQlzdHJidWZfYWRkY2goc2IsICciJyk7CisJfSBlbHNlIHsKKwkJc3RyYnVmX2FkZHN0cihzYiwgcHJlZml4KTsKKwkJc3RyYnVmX2FkZHN0cihzYiwgcGF0aCk7CisJfQorfQorCit2b2lkIHdyaXRlX25hbWVfcXVvdGVkKGNvbnN0IGNoYXIgKm5hbWUsIEZJTEUgKmZwLCBpbnQgdGVybWluYXRvcikKK3sKKwlpZiAodGVybWluYXRvcikgeworCQlxdW90ZV9jX3N0eWxlKG5hbWUsIE5VTEwsIGZwLCAwKTsKKwl9IGVsc2UgeworCQlmcHV0cyhuYW1lLCBmcCk7CisJfQorCWZwdXRjKHRlcm1pbmF0b3IsIGZwKTsKK30KKworZXh0ZXJuIHZvaWQgd3JpdGVfbmFtZV9xdW90ZWRwZngoY29uc3QgY2hhciAqcGZ4LCBzaXplX3QgcGZ4bGVuLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgY29uc3QgY2hhciAqbmFtZSwgRklMRSAqZnAsIGludCB0ZXJtaW5hdG9yKQoreworCWludCBuZWVkcXVvdGUgPSAwOworCisJaWYgKHRlcm1pbmF0b3IpIHsKKwkJbmVlZHF1b3RlID0gbmV4dF9xdW90ZV9wb3MocGZ4LCBwZnhsZW4pIDwgcGZ4bGVuCisJCQl8fCBuYW1lW25leHRfcXVvdGVfcG9zKG5hbWUsIC0xKV07CisJfQorCWlmIChuZWVkcXVvdGUpIHsKKwkJZnB1dGMoJyInLCBmcCk7CisJCXF1b3RlX2Nfc3R5bGVfY291bnRlZChwZngsIHBmeGxlbiwgTlVMTCwgZnAsIDEpOworCQlxdW90ZV9jX3N0eWxlKG5hbWUsIE5VTEwsIGZwLCAxKTsKKwkJZnB1dGMoJyInLCBmcCk7CisJfSBlbHNlIHsKKwkJaW50IHJldDsKKworCQlyZXQgPSBmd3JpdGUocGZ4LCBwZnhsZW4sIDEsIGZwKTsKKwkJZnB1dHMobmFtZSwgZnApOworCX0KKwlmcHV0Yyh0ZXJtaW5hdG9yLCBmcCk7Cit9CisKKy8qIHF1b3RlIHBhdGggYXMgcmVsYXRpdmUgdG8gdGhlIGdpdmVuIHByZWZpeCAqLworY2hhciAqcXVvdGVfcGF0aF9yZWxhdGl2ZShjb25zdCBjaGFyICppbiwgaW50IGxlbiwKKwkJCSAgc3RydWN0IHN0cmJ1ZiAqb3V0LCBjb25zdCBjaGFyICpwcmVmaXgpCit7CisJaW50IG5lZWRxdW90ZTsKKworCWlmIChsZW4gPCAwKQorCQlsZW4gPSBzdHJsZW4oaW4pOworCisJLyogIi4uLyIgcHJlZml4IGl0c2VsZiBkb2VzIG5vdCBuZWVkIHF1b3RpbmcsIGJ1dCAiaW4iIG1pZ2h0LiAqLworCW5lZWRxdW90ZSA9IG5leHRfcXVvdGVfcG9zKGluLCBsZW4pIDwgbGVuOworCXN0cmJ1Zl9zZXRsZW4ob3V0LCAwKTsKKwlzdHJidWZfZ3JvdyhvdXQsIGxlbik7CisKKwlpZiAobmVlZHF1b3RlKQorCQlzdHJidWZfYWRkY2gob3V0LCAnIicpOworCWlmIChwcmVmaXgpIHsKKwkJaW50IG9mZiA9IDA7CisJCXdoaWxlIChwcmVmaXhbb2ZmXSAmJiBvZmYgPCBsZW4gJiYgcHJlZml4W29mZl0gPT0gaW5bb2ZmXSkKKwkJCWlmIChwcmVmaXhbb2ZmXSA9PSAnLycpIHsKKwkJCQlwcmVmaXggKz0gb2ZmICsgMTsKKwkJCQlpbiArPSBvZmYgKyAxOworCQkJCWxlbiAtPSBvZmYgKyAxOworCQkJCW9mZiA9IDA7CisJCQl9IGVsc2UKKwkJCQlvZmYrKzsKKworCQlmb3IgKDsgKnByZWZpeDsgcHJlZml4KyspCisJCQlpZiAoKnByZWZpeCA9PSAnLycpCisJCQkJc3RyYnVmX2FkZHN0cihvdXQsICIuLi8iKTsKKwl9CisKKwlxdW90ZV9jX3N0eWxlX2NvdW50ZWQgKGluLCBsZW4sIG91dCwgTlVMTCwgMSk7CisKKwlpZiAobmVlZHF1b3RlKQorCQlzdHJidWZfYWRkY2gob3V0LCAnIicpOworCWlmICghb3V0LT5sZW4pCisJCXN0cmJ1Zl9hZGRzdHIob3V0LCAiLi8iKTsKKworCXJldHVybiBvdXQtPmJ1ZjsKK30KKworLyoKKyAqIEMtc3R5bGUgbmFtZSB1bnF1b3RpbmcuCisgKgorICogUXVvdGVkIHNob3VsZCBwb2ludCBhdCB0aGUgb3BlbmluZyBkb3VibGUgcXVvdGUuCisgKiArIFJldHVybnMgMCBpZiBpdCB3YXMgYWJsZSB0byB1bnF1b3RlIHRoZSBzdHJpbmcgcHJvcGVybHksIGFuZCBhcHBlbmRzIHRoZQorICogICByZXN1bHQgaW4gdGhlIHN0cmJ1ZiBgc2InLgorICogKyBSZXR1cm5zIC0xIGluIGNhc2Ugb2YgZXJyb3IsIGFuZCBkb2Vzbid0IHRvdWNoIHRoZSBzdHJidWYuIFRob3VnaCBub3RlCisgKiAgIHRoYXQgdGhpcyBmdW5jdGlvbiB3aWxsIGFsbG9jYXRlIG1lbW9yeSBpbiB0aGUgc3RyYnVmLCBzbyBjYWxsaW5nCisgKiAgIHN0cmJ1Zl9yZWxlYXNlIGlzIG1hbmRhdG9yeSB3aGljaGV2ZXIgcmVzdWx0IHVucXVvdGVfY19zdHlsZSByZXR1cm5zLgorICoKKyAqIFVwZGF0ZXMgZW5kcCBwb2ludGVyIHRvIHBvaW50IGF0IG9uZSBwYXN0IHRoZSBlbmRpbmcgZG91YmxlIHF1b3RlIGlmIGdpdmVuLgorICovCitpbnQgdW5xdW90ZV9jX3N0eWxlKHN0cnVjdCBzdHJidWYgKnNiLCBjb25zdCBjaGFyICpxdW90ZWQsIGNvbnN0IGNoYXIgKiplbmRwKQoreworCXNpemVfdCBvbGRsZW4gPSBzYi0+bGVuLCBsZW47CisJaW50IGNoLCBhYzsKKworCWlmICgqcXVvdGVkKysgIT0gJyInKQorCQlyZXR1cm4gLTE7CisKKwlmb3IgKDs7KSB7CisJCWxlbiA9IHN0cmNzcG4ocXVvdGVkLCAiXCJcXCIpOworCQlzdHJidWZfYWRkKHNiLCBxdW90ZWQsIGxlbik7CisJCXF1b3RlZCArPSBsZW47CisKKwkJc3dpdGNoICgqcXVvdGVkKyspIHsKKwkJICBjYXNlICciJzoKKwkJCWlmIChlbmRwKQorCQkJCSplbmRwID0gcXVvdGVkOworCQkJcmV0dXJuIDA7CisJCSAgY2FzZSAnXFwnOgorCQkJYnJlYWs7CisJCSAgZGVmYXVsdDoKKwkJCWdvdG8gZXJyb3I7CisJCX0KKworCQlzd2l0Y2ggKChjaCA9ICpxdW90ZWQrKykpIHsKKwkJY2FzZSAnYSc6IGNoID0gJ1xhJzsgYnJlYWs7CisJCWNhc2UgJ2InOiBjaCA9ICdcYic7IGJyZWFrOworCQljYXNlICdmJzogY2ggPSAnXGYnOyBicmVhazsKKwkJY2FzZSAnbic6IGNoID0gJ1xuJzsgYnJlYWs7CisJCWNhc2UgJ3InOiBjaCA9ICdccic7IGJyZWFrOworCQljYXNlICd0JzogY2ggPSAnXHQnOyBicmVhazsKKwkJY2FzZSAndic6IGNoID0gJ1x2JzsgYnJlYWs7CisKKwkJY2FzZSAnXFwnOiBjYXNlICciJzoKKwkJCWJyZWFrOyAvKiB2ZXJiYXRpbSAqLworCisJCS8qIG9jdGFsIHZhbHVlcyB3aXRoIGZpcnN0IGRpZ2l0IG92ZXIgNCBvdmVyZmxvdyAqLworCQljYXNlICcwJzogY2FzZSAnMSc6IGNhc2UgJzInOiBjYXNlICczJzoKKwkJCQkJYWMgPSAoKGNoIC0gJzAnKSA8PCA2KTsKKwkJCWlmICgoY2ggPSAqcXVvdGVkKyspIDwgJzAnIHx8ICc3JyA8IGNoKQorCQkJCWdvdG8gZXJyb3I7CisJCQkJCWFjIHw9ICgoY2ggLSAnMCcpIDw8IDMpOworCQkJaWYgKChjaCA9ICpxdW90ZWQrKykgPCAnMCcgfHwgJzcnIDwgY2gpCisJCQkJZ290byBlcnJvcjsKKwkJCQkJYWMgfD0gKGNoIC0gJzAnKTsKKwkJCQkJY2ggPSBhYzsKKwkJCQkJYnJlYWs7CisJCQkJZGVmYXVsdDoKKwkJCWdvdG8gZXJyb3I7CisJCQl9CisJCXN0cmJ1Zl9hZGRjaChzYiwgY2gpOworCQl9CisKKyAgZXJyb3I6CisJc3RyYnVmX3NldGxlbihzYiwgb2xkbGVuKTsKKwlyZXR1cm4gLTE7Cit9CisKKy8qIHF1b3RpbmcgYXMgYSBzdHJpbmcgbGl0ZXJhbCBmb3Igb3RoZXIgbGFuZ3VhZ2VzICovCisKK3ZvaWQgcGVybF9xdW90ZV9wcmludChGSUxFICpzdHJlYW0sIGNvbnN0IGNoYXIgKnNyYykKK3sKKwljb25zdCBjaGFyIHNxID0gJ1wnJzsKKwljb25zdCBjaGFyIGJxID0gJ1xcJzsKKwljaGFyIGM7CisKKwlmcHV0YyhzcSwgc3RyZWFtKTsKKwl3aGlsZSAoKGMgPSAqc3JjKyspKSB7CisJCWlmIChjID09IHNxIHx8IGMgPT0gYnEpCisJCQlmcHV0YyhicSwgc3RyZWFtKTsKKwkJZnB1dGMoYywgc3RyZWFtKTsKKwl9CisJZnB1dGMoc3EsIHN0cmVhbSk7Cit9CisKK3ZvaWQgcHl0aG9uX3F1b3RlX3ByaW50KEZJTEUgKnN0cmVhbSwgY29uc3QgY2hhciAqc3JjKQoreworCWNvbnN0IGNoYXIgc3EgPSAnXCcnOworCWNvbnN0IGNoYXIgYnEgPSAnXFwnOworCWNvbnN0IGNoYXIgbmwgPSAnXG4nOworCWNoYXIgYzsKKworCWZwdXRjKHNxLCBzdHJlYW0pOworCXdoaWxlICgoYyA9ICpzcmMrKykpIHsKKwkJaWYgKGMgPT0gbmwpIHsKKwkJCWZwdXRjKGJxLCBzdHJlYW0pOworCQkJZnB1dGMoJ24nLCBzdHJlYW0pOworCQkJY29udGludWU7CisJCX0KKwkJaWYgKGMgPT0gc3EgfHwgYyA9PSBicSkKKwkJCWZwdXRjKGJxLCBzdHJlYW0pOworCQlmcHV0YyhjLCBzdHJlYW0pOworCX0KKwlmcHV0YyhzcSwgc3RyZWFtKTsKK30KKwordm9pZCB0Y2xfcXVvdGVfcHJpbnQoRklMRSAqc3RyZWFtLCBjb25zdCBjaGFyICpzcmMpCit7CisJY2hhciBjOworCisJZnB1dGMoJyInLCBzdHJlYW0pOworCXdoaWxlICgoYyA9ICpzcmMrKykpIHsKKwkJc3dpdGNoIChjKSB7CisJCWNhc2UgJ1snOiBjYXNlICddJzoKKwkJY2FzZSAneyc6IGNhc2UgJ30nOgorCQljYXNlICckJzogY2FzZSAnXFwnOiBjYXNlICciJzoKKwkJCWZwdXRjKCdcXCcsIHN0cmVhbSk7CisJCWRlZmF1bHQ6CisJCQlmcHV0YyhjLCBzdHJlYW0pOworCQkJYnJlYWs7CisJCWNhc2UgJ1xmJzoKKwkJCWZwdXRzKCJcXGYiLCBzdHJlYW0pOworCQkJYnJlYWs7CisJCWNhc2UgJ1xyJzoKKwkJCWZwdXRzKCJcXHIiLCBzdHJlYW0pOworCQkJYnJlYWs7CisJCWNhc2UgJ1xuJzoKKwkJCWZwdXRzKCJcXG4iLCBzdHJlYW0pOworCQkJYnJlYWs7CisJCWNhc2UgJ1x0JzoKKwkJCWZwdXRzKCJcXHQiLCBzdHJlYW0pOworCQkJYnJlYWs7CisJCWNhc2UgJ1x2JzoKKwkJCWZwdXRzKCJcXHYiLCBzdHJlYW0pOworCQkJYnJlYWs7CisJCX0KKwl9CisJZnB1dGMoJyInLCBzdHJlYW0pOworfQpkaWZmIC0tZ2l0IGEvdG9vbHMvcGVyZi91dGlsL3F1b3RlLmggYi90b29scy9wZXJmL3V0aWwvcXVvdGUuaApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi41ZGZhZDg5Ci0tLSAvZGV2L251bGwKKysrIGIvdG9vbHMvcGVyZi91dGlsL3F1b3RlLmgKQEAgLTAsMCArMSw2OCBAQAorI2lmbmRlZiBRVU9URV9ICisjZGVmaW5lIFFVT1RFX0gKKworI2luY2x1ZGUgPHN0ZGRlZi5oPgorI2luY2x1ZGUgPHN0ZGlvLmg+CisKKy8qIEhlbHAgdG8gY29weSB0aGUgdGhpbmcgcHJvcGVybHkgcXVvdGVkIGZvciB0aGUgc2hlbGwgc2FmZXR5LgorICogYW55IHNpbmdsZSBxdW90ZSBpcyByZXBsYWNlZCB3aXRoICdcJycsIGFueSBleGNsYW1hdGlvbiBwb2ludAorICogaXMgcmVwbGFjZWQgd2l0aCAnXCEnLCBhbmQgdGhlIHdob2xlIHRoaW5nIGlzIGVuY2xvc2VkIGluIGEKKyAqIHNpbmdsZSBxdW90ZSBwYWlyLgorICoKKyAqIEZvciBleGFtcGxlLCBpZiB5b3UgYXJlIHBhc3NpbmcgdGhlIHJlc3VsdCB0byBzeXN0ZW0oKSBhcyBhbgorICogYXJndW1lbnQ6CisgKgorICogc3ByaW50ZihjbWQsICJmb29iYXIgJXMgJXMiLCBzcV9xdW90ZShhcmcwKSwgc3FfcXVvdGUoYXJnMSkpCisgKgorICogd291bGQgYmUgYXBwcm9wcmlhdGUuICBJZiB0aGUgc3lzdGVtKCkgaXMgZ29pbmcgdG8gY2FsbCBzc2ggdG8KKyAqIHJ1biB0aGUgY29tbWFuZCBvbiB0aGUgb3RoZXIgc2lkZToKKyAqCisgKiBzcHJpbnRmKGNtZCwgImdpdC1kaWZmLXRyZWUgJXMgJXMiLCBzcV9xdW90ZShhcmcwKSwgc3FfcXVvdGUoYXJnMSkpOworICogc3ByaW50ZihyY21kLCAic3NoICVzICVzIiwgc3FfdXRpbC9xdW90ZS5ob3N0KSwgc3FfcXVvdGUoY21kKSk7CisgKgorICogTm90ZSB0aGF0IHRoZSBhYm92ZSBleGFtcGxlcyBsZWFrIG1lbW9yeSEgIFJlbWVtYmVyIHRvIGZyZWUgcmVzdWx0IGZyb20KKyAqIHNxX3F1b3RlKCkgaW4gYSByZWFsIGFwcGxpY2F0aW9uLgorICoKKyAqIHNxX3F1b3RlX2J1ZigpIHdyaXRlcyB0byBhbiBleGlzdGluZyBidWZmZXIgb2Ygc3BlY2lmaWVkIHNpemU7IGl0CisgKiB3aWxsIHJldHVybiB0aGUgbnVtYmVyIG9mIGNoYXJhY3RlcnMgdGhhdCB3b3VsZCBoYXZlIGJlZW4gd3JpdHRlbgorICogZXhjbHVkaW5nIHRoZSBmaW5hbCBudWxsIHJlZ2FyZGxlc3Mgb2YgdGhlIGJ1ZmZlciBzaXplLgorICovCisKK2V4dGVybiB2b2lkIHNxX3F1b3RlX3ByaW50KEZJTEUgKnN0cmVhbSwgY29uc3QgY2hhciAqc3JjKTsKKworZXh0ZXJuIHZvaWQgc3FfcXVvdGVfYnVmKHN0cnVjdCBzdHJidWYgKiwgY29uc3QgY2hhciAqc3JjKTsKK2V4dGVybiB2b2lkIHNxX3F1b3RlX2FyZ3Yoc3RydWN0IHN0cmJ1ZiAqLCBjb25zdCBjaGFyICoqYXJndiwgc2l6ZV90IG1heGxlbik7CisKKy8qIFRoaXMgdW53cmFwcyB3aGF0IHNxX3F1b3RlKCkgcHJvZHVjZXMgaW4gcGxhY2UsIGJ1dCByZXR1cm5zCisgKiBOVUxMIGlmIHRoZSBpbnB1dCBkb2VzIG5vdCBsb29rIGxpa2Ugd2hhdCBzcV9xdW90ZSB3b3VsZCBoYXZlCisgKiBwcm9kdWNlZC4KKyAqLworZXh0ZXJuIGNoYXIgKnNxX2RlcXVvdGUoY2hhciAqKTsKKworLyoKKyAqIFNhbWUgYXMgdGhlIGFib3ZlLCBidXQgY2FuIGJlIHVzZWQgdG8gdW53cmFwIG1hbnkgYXJndW1lbnRzIGluIHRoZQorICogc2FtZSBzdHJpbmcgc2VwYXJhdGVkIGJ5IHNwYWNlLiAibmV4dCIgaXMgY2hhbmdlZCB0byBwb2ludCB0byB0aGUKKyAqIG5leHQgYXJndW1lbnQgdGhhdCBzaG91bGQgYmUgcGFzc2VkIGFzIGZpcnN0IHBhcmFtZXRlci4gV2hlbiB0aGVyZQorICogaXMgbm8gbW9yZSBhcmd1bWVudCB0byBiZSBkZXF1b3RlZCwgIm5leHQiIGlzIHVwZGF0ZWQgdG8gcG9pbnQgdG8gTlVMTC4KKyAqLworZXh0ZXJuIGNoYXIgKnNxX2RlcXVvdGVfc3RlcChjaGFyICphcmcsIGNoYXIgKipuZXh0KTsKK2V4dGVybiBpbnQgc3FfZGVxdW90ZV90b19hcmd2KGNoYXIgKmFyZywgY29uc3QgY2hhciAqKiphcmd2LCBpbnQgKm5yLCBpbnQgKmFsbG9jKTsKKworZXh0ZXJuIGludCB1bnF1b3RlX2Nfc3R5bGUoc3RydWN0IHN0cmJ1ZiAqLCBjb25zdCBjaGFyICpxdW90ZWQsIGNvbnN0IGNoYXIgKiplbmRwKTsKK2V4dGVybiBzaXplX3QgcXVvdGVfY19zdHlsZShjb25zdCBjaGFyICpuYW1lLCBzdHJ1Y3Qgc3RyYnVmICosIEZJTEUgKiwgaW50IG5vX2RxKTsKK2V4dGVybiB2b2lkIHF1b3RlX3R3b19jX3N0eWxlKHN0cnVjdCBzdHJidWYgKiwgY29uc3QgY2hhciAqLCBjb25zdCBjaGFyICosIGludCk7CisKK2V4dGVybiB2b2lkIHdyaXRlX25hbWVfcXVvdGVkKGNvbnN0IGNoYXIgKm5hbWUsIEZJTEUgKiwgaW50IHRlcm1pbmF0b3IpOworZXh0ZXJuIHZvaWQgd3JpdGVfbmFtZV9xdW90ZWRwZngoY29uc3QgY2hhciAqcGZ4LCBzaXplX3QgcGZ4bGVuLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgY29uc3QgY2hhciAqbmFtZSwgRklMRSAqLCBpbnQgdGVybWluYXRvcik7CisKKy8qIHF1b3RlIHBhdGggYXMgcmVsYXRpdmUgdG8gdGhlIGdpdmVuIHByZWZpeCAqLworY2hhciAqcXVvdGVfcGF0aF9yZWxhdGl2ZShjb25zdCBjaGFyICppbiwgaW50IGxlbiwKKwkJCSAgc3RydWN0IHN0cmJ1ZiAqb3V0LCBjb25zdCBjaGFyICpwcmVmaXgpOworCisvKiBxdW90aW5nIGFzIGEgc3RyaW5nIGxpdGVyYWwgZm9yIG90aGVyIGxhbmd1YWdlcyAqLworZXh0ZXJuIHZvaWQgcGVybF9xdW90ZV9wcmludChGSUxFICpzdHJlYW0sIGNvbnN0IGNoYXIgKnNyYyk7CitleHRlcm4gdm9pZCBweXRob25fcXVvdGVfcHJpbnQoRklMRSAqc3RyZWFtLCBjb25zdCBjaGFyICpzcmMpOworZXh0ZXJuIHZvaWQgdGNsX3F1b3RlX3ByaW50KEZJTEUgKnN0cmVhbSwgY29uc3QgY2hhciAqc3JjKTsKKworI2VuZGlmCmRpZmYgLS1naXQgYS90b29scy9wZXJmL3V0aWwvcmJ0cmVlLmMgYi90b29scy9wZXJmL3V0aWwvcmJ0cmVlLmMKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uYjE1YmE5YwotLS0gL2Rldi9udWxsCisrKyBiL3Rvb2xzL3BlcmYvdXRpbC9yYnRyZWUuYwpAQCAtMCwwICsxLDM4MyBAQAorLyoKKyAgUmVkIEJsYWNrIFRyZWVzCisgIChDKSAxOTk5ICBBbmRyZWEgQXJjYW5nZWxpIDxhbmRyZWFAc3VzZS5kZT4KKyAgKEMpIDIwMDIgIERhdmlkIFdvb2Rob3VzZSA8ZHdtdzJAaW5mcmFkZWFkLm9yZz4KKyAgCisgIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5CisgIGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgYXMgcHVibGlzaGVkIGJ5CisgIHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb247IGVpdGhlciB2ZXJzaW9uIDIgb2YgdGhlIExpY2Vuc2UsIG9yCisgIChhdCB5b3VyIG9wdGlvbikgYW55IGxhdGVyIHZlcnNpb24uCisKKyAgVGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsCisgIGJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCisgIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUKKyAgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KKworICBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZQorICBhbG9uZyB3aXRoIHRoaXMgcHJvZ3JhbTsgaWYgbm90LCB3cml0ZSB0byB0aGUgRnJlZSBTb2Z0d2FyZQorICBGb3VuZGF0aW9uLCBJbmMuLCA1OSBUZW1wbGUgUGxhY2UsIFN1aXRlIDMzMCwgQm9zdG9uLCBNQSAgMDIxMTEtMTMwNyAgVVNBCisKKyAgbGludXgvbGliL3JidHJlZS5jCisqLworCisjaW5jbHVkZSAicmJ0cmVlLmgiCisKK3N0YXRpYyB2b2lkIF9fcmJfcm90YXRlX2xlZnQoc3RydWN0IHJiX25vZGUgKm5vZGUsIHN0cnVjdCByYl9yb290ICpyb290KQoreworCXN0cnVjdCByYl9ub2RlICpyaWdodCA9IG5vZGUtPnJiX3JpZ2h0OworCXN0cnVjdCByYl9ub2RlICpwYXJlbnQgPSByYl9wYXJlbnQobm9kZSk7CisKKwlpZiAoKG5vZGUtPnJiX3JpZ2h0ID0gcmlnaHQtPnJiX2xlZnQpKQorCQlyYl9zZXRfcGFyZW50KHJpZ2h0LT5yYl9sZWZ0LCBub2RlKTsKKwlyaWdodC0+cmJfbGVmdCA9IG5vZGU7CisKKwlyYl9zZXRfcGFyZW50KHJpZ2h0LCBwYXJlbnQpOworCisJaWYgKHBhcmVudCkKKwl7CisJCWlmIChub2RlID09IHBhcmVudC0+cmJfbGVmdCkKKwkJCXBhcmVudC0+cmJfbGVmdCA9IHJpZ2h0OworCQllbHNlCisJCQlwYXJlbnQtPnJiX3JpZ2h0ID0gcmlnaHQ7CisJfQorCWVsc2UKKwkJcm9vdC0+cmJfbm9kZSA9IHJpZ2h0OworCXJiX3NldF9wYXJlbnQobm9kZSwgcmlnaHQpOworfQorCitzdGF0aWMgdm9pZCBfX3JiX3JvdGF0ZV9yaWdodChzdHJ1Y3QgcmJfbm9kZSAqbm9kZSwgc3RydWN0IHJiX3Jvb3QgKnJvb3QpCit7CisJc3RydWN0IHJiX25vZGUgKmxlZnQgPSBub2RlLT5yYl9sZWZ0OworCXN0cnVjdCByYl9ub2RlICpwYXJlbnQgPSByYl9wYXJlbnQobm9kZSk7CisKKwlpZiAoKG5vZGUtPnJiX2xlZnQgPSBsZWZ0LT5yYl9yaWdodCkpCisJCXJiX3NldF9wYXJlbnQobGVmdC0+cmJfcmlnaHQsIG5vZGUpOworCWxlZnQtPnJiX3JpZ2h0ID0gbm9kZTsKKworCXJiX3NldF9wYXJlbnQobGVmdCwgcGFyZW50KTsKKworCWlmIChwYXJlbnQpCisJeworCQlpZiAobm9kZSA9PSBwYXJlbnQtPnJiX3JpZ2h0KQorCQkJcGFyZW50LT5yYl9yaWdodCA9IGxlZnQ7CisJCWVsc2UKKwkJCXBhcmVudC0+cmJfbGVmdCA9IGxlZnQ7CisJfQorCWVsc2UKKwkJcm9vdC0+cmJfbm9kZSA9IGxlZnQ7CisJcmJfc2V0X3BhcmVudChub2RlLCBsZWZ0KTsKK30KKwordm9pZCByYl9pbnNlcnRfY29sb3Ioc3RydWN0IHJiX25vZGUgKm5vZGUsIHN0cnVjdCByYl9yb290ICpyb290KQoreworCXN0cnVjdCByYl9ub2RlICpwYXJlbnQsICpncGFyZW50OworCisJd2hpbGUgKChwYXJlbnQgPSByYl9wYXJlbnQobm9kZSkpICYmIHJiX2lzX3JlZChwYXJlbnQpKQorCXsKKwkJZ3BhcmVudCA9IHJiX3BhcmVudChwYXJlbnQpOworCisJCWlmIChwYXJlbnQgPT0gZ3BhcmVudC0+cmJfbGVmdCkKKwkJeworCQkJeworCQkJCXJlZ2lzdGVyIHN0cnVjdCByYl9ub2RlICp1bmNsZSA9IGdwYXJlbnQtPnJiX3JpZ2h0OworCQkJCWlmICh1bmNsZSAmJiByYl9pc19yZWQodW5jbGUpKQorCQkJCXsKKwkJCQkJcmJfc2V0X2JsYWNrKHVuY2xlKTsKKwkJCQkJcmJfc2V0X2JsYWNrKHBhcmVudCk7CisJCQkJCXJiX3NldF9yZWQoZ3BhcmVudCk7CisJCQkJCW5vZGUgPSBncGFyZW50OworCQkJCQljb250aW51ZTsKKwkJCQl9CisJCQl9CisKKwkJCWlmIChwYXJlbnQtPnJiX3JpZ2h0ID09IG5vZGUpCisJCQl7CisJCQkJcmVnaXN0ZXIgc3RydWN0IHJiX25vZGUgKnRtcDsKKwkJCQlfX3JiX3JvdGF0ZV9sZWZ0KHBhcmVudCwgcm9vdCk7CisJCQkJdG1wID0gcGFyZW50OworCQkJCXBhcmVudCA9IG5vZGU7CisJCQkJbm9kZSA9IHRtcDsKKwkJCX0KKworCQkJcmJfc2V0X2JsYWNrKHBhcmVudCk7CisJCQlyYl9zZXRfcmVkKGdwYXJlbnQpOworCQkJX19yYl9yb3RhdGVfcmlnaHQoZ3BhcmVudCwgcm9vdCk7CisJCX0gZWxzZSB7CisJCQl7CisJCQkJcmVnaXN0ZXIgc3RydWN0IHJiX25vZGUgKnVuY2xlID0gZ3BhcmVudC0+cmJfbGVmdDsKKwkJCQlpZiAodW5jbGUgJiYgcmJfaXNfcmVkKHVuY2xlKSkKKwkJCQl7CisJCQkJCXJiX3NldF9ibGFjayh1bmNsZSk7CisJCQkJCXJiX3NldF9ibGFjayhwYXJlbnQpOworCQkJCQlyYl9zZXRfcmVkKGdwYXJlbnQpOworCQkJCQlub2RlID0gZ3BhcmVudDsKKwkJCQkJY29udGludWU7CisJCQkJfQorCQkJfQorCisJCQlpZiAocGFyZW50LT5yYl9sZWZ0ID09IG5vZGUpCisJCQl7CisJCQkJcmVnaXN0ZXIgc3RydWN0IHJiX25vZGUgKnRtcDsKKwkJCQlfX3JiX3JvdGF0ZV9yaWdodChwYXJlbnQsIHJvb3QpOworCQkJCXRtcCA9IHBhcmVudDsKKwkJCQlwYXJlbnQgPSBub2RlOworCQkJCW5vZGUgPSB0bXA7CisJCQl9CisKKwkJCXJiX3NldF9ibGFjayhwYXJlbnQpOworCQkJcmJfc2V0X3JlZChncGFyZW50KTsKKwkJCV9fcmJfcm90YXRlX2xlZnQoZ3BhcmVudCwgcm9vdCk7CisJCX0KKwl9CisKKwlyYl9zZXRfYmxhY2socm9vdC0+cmJfbm9kZSk7Cit9CisKK3N0YXRpYyB2b2lkIF9fcmJfZXJhc2VfY29sb3Ioc3RydWN0IHJiX25vZGUgKm5vZGUsIHN0cnVjdCByYl9ub2RlICpwYXJlbnQsCisJCQkgICAgIHN0cnVjdCByYl9yb290ICpyb290KQoreworCXN0cnVjdCByYl9ub2RlICpvdGhlcjsKKworCXdoaWxlICgoIW5vZGUgfHwgcmJfaXNfYmxhY2sobm9kZSkpICYmIG5vZGUgIT0gcm9vdC0+cmJfbm9kZSkKKwl7CisJCWlmIChwYXJlbnQtPnJiX2xlZnQgPT0gbm9kZSkKKwkJeworCQkJb3RoZXIgPSBwYXJlbnQtPnJiX3JpZ2h0OworCQkJaWYgKHJiX2lzX3JlZChvdGhlcikpCisJCQl7CisJCQkJcmJfc2V0X2JsYWNrKG90aGVyKTsKKwkJCQlyYl9zZXRfcmVkKHBhcmVudCk7CisJCQkJX19yYl9yb3RhdGVfbGVmdChwYXJlbnQsIHJvb3QpOworCQkJCW90aGVyID0gcGFyZW50LT5yYl9yaWdodDsKKwkJCX0KKwkJCWlmICgoIW90aGVyLT5yYl9sZWZ0IHx8IHJiX2lzX2JsYWNrKG90aGVyLT5yYl9sZWZ0KSkgJiYKKwkJCSAgICAoIW90aGVyLT5yYl9yaWdodCB8fCByYl9pc19ibGFjayhvdGhlci0+cmJfcmlnaHQpKSkKKwkJCXsKKwkJCQlyYl9zZXRfcmVkKG90aGVyKTsKKwkJCQlub2RlID0gcGFyZW50OworCQkJCXBhcmVudCA9IHJiX3BhcmVudChub2RlKTsKKwkJCX0KKwkJCWVsc2UKKwkJCXsKKwkJCQlpZiAoIW90aGVyLT5yYl9yaWdodCB8fCByYl9pc19ibGFjayhvdGhlci0+cmJfcmlnaHQpKQorCQkJCXsKKwkJCQkJcmJfc2V0X2JsYWNrKG90aGVyLT5yYl9sZWZ0KTsKKwkJCQkJcmJfc2V0X3JlZChvdGhlcik7CisJCQkJCV9fcmJfcm90YXRlX3JpZ2h0KG90aGVyLCByb290KTsKKwkJCQkJb3RoZXIgPSBwYXJlbnQtPnJiX3JpZ2h0OworCQkJCX0KKwkJCQlyYl9zZXRfY29sb3Iob3RoZXIsIHJiX2NvbG9yKHBhcmVudCkpOworCQkJCXJiX3NldF9ibGFjayhwYXJlbnQpOworCQkJCXJiX3NldF9ibGFjayhvdGhlci0+cmJfcmlnaHQpOworCQkJCV9fcmJfcm90YXRlX2xlZnQocGFyZW50LCByb290KTsKKwkJCQlub2RlID0gcm9vdC0+cmJfbm9kZTsKKwkJCQlicmVhazsKKwkJCX0KKwkJfQorCQllbHNlCisJCXsKKwkJCW90aGVyID0gcGFyZW50LT5yYl9sZWZ0OworCQkJaWYgKHJiX2lzX3JlZChvdGhlcikpCisJCQl7CisJCQkJcmJfc2V0X2JsYWNrKG90aGVyKTsKKwkJCQlyYl9zZXRfcmVkKHBhcmVudCk7CisJCQkJX19yYl9yb3RhdGVfcmlnaHQocGFyZW50LCByb290KTsKKwkJCQlvdGhlciA9IHBhcmVudC0+cmJfbGVmdDsKKwkJCX0KKwkJCWlmICgoIW90aGVyLT5yYl9sZWZ0IHx8IHJiX2lzX2JsYWNrKG90aGVyLT5yYl9sZWZ0KSkgJiYKKwkJCSAgICAoIW90aGVyLT5yYl9yaWdodCB8fCByYl9pc19ibGFjayhvdGhlci0+cmJfcmlnaHQpKSkKKwkJCXsKKwkJCQlyYl9zZXRfcmVkKG90aGVyKTsKKwkJCQlub2RlID0gcGFyZW50OworCQkJCXBhcmVudCA9IHJiX3BhcmVudChub2RlKTsKKwkJCX0KKwkJCWVsc2UKKwkJCXsKKwkJCQlpZiAoIW90aGVyLT5yYl9sZWZ0IHx8IHJiX2lzX2JsYWNrKG90aGVyLT5yYl9sZWZ0KSkKKwkJCQl7CisJCQkJCXJiX3NldF9ibGFjayhvdGhlci0+cmJfcmlnaHQpOworCQkJCQlyYl9zZXRfcmVkKG90aGVyKTsKKwkJCQkJX19yYl9yb3RhdGVfbGVmdChvdGhlciwgcm9vdCk7CisJCQkJCW90aGVyID0gcGFyZW50LT5yYl9sZWZ0OworCQkJCX0KKwkJCQlyYl9zZXRfY29sb3Iob3RoZXIsIHJiX2NvbG9yKHBhcmVudCkpOworCQkJCXJiX3NldF9ibGFjayhwYXJlbnQpOworCQkJCXJiX3NldF9ibGFjayhvdGhlci0+cmJfbGVmdCk7CisJCQkJX19yYl9yb3RhdGVfcmlnaHQocGFyZW50LCByb290KTsKKwkJCQlub2RlID0gcm9vdC0+cmJfbm9kZTsKKwkJCQlicmVhazsKKwkJCX0KKwkJfQorCX0KKwlpZiAobm9kZSkKKwkJcmJfc2V0X2JsYWNrKG5vZGUpOworfQorCit2b2lkIHJiX2VyYXNlKHN0cnVjdCByYl9ub2RlICpub2RlLCBzdHJ1Y3QgcmJfcm9vdCAqcm9vdCkKK3sKKwlzdHJ1Y3QgcmJfbm9kZSAqY2hpbGQsICpwYXJlbnQ7CisJaW50IGNvbG9yOworCisJaWYgKCFub2RlLT5yYl9sZWZ0KQorCQljaGlsZCA9IG5vZGUtPnJiX3JpZ2h0OworCWVsc2UgaWYgKCFub2RlLT5yYl9yaWdodCkKKwkJY2hpbGQgPSBub2RlLT5yYl9sZWZ0OworCWVsc2UKKwl7CisJCXN0cnVjdCByYl9ub2RlICpvbGQgPSBub2RlLCAqbGVmdDsKKworCQlub2RlID0gbm9kZS0+cmJfcmlnaHQ7CisJCXdoaWxlICgobGVmdCA9IG5vZGUtPnJiX2xlZnQpICE9IE5VTEwpCisJCQlub2RlID0gbGVmdDsKKwkJY2hpbGQgPSBub2RlLT5yYl9yaWdodDsKKwkJcGFyZW50ID0gcmJfcGFyZW50KG5vZGUpOworCQljb2xvciA9IHJiX2NvbG9yKG5vZGUpOworCisJCWlmIChjaGlsZCkKKwkJCXJiX3NldF9wYXJlbnQoY2hpbGQsIHBhcmVudCk7CisJCWlmIChwYXJlbnQgPT0gb2xkKSB7CisJCQlwYXJlbnQtPnJiX3JpZ2h0ID0gY2hpbGQ7CisJCQlwYXJlbnQgPSBub2RlOworCQl9IGVsc2UKKwkJCXBhcmVudC0+cmJfbGVmdCA9IGNoaWxkOworCisJCW5vZGUtPnJiX3BhcmVudF9jb2xvciA9IG9sZC0+cmJfcGFyZW50X2NvbG9yOworCQlub2RlLT5yYl9yaWdodCA9IG9sZC0+cmJfcmlnaHQ7CisJCW5vZGUtPnJiX2xlZnQgPSBvbGQtPnJiX2xlZnQ7CisKKwkJaWYgKHJiX3BhcmVudChvbGQpKQorCQl7CisJCQlpZiAocmJfcGFyZW50KG9sZCktPnJiX2xlZnQgPT0gb2xkKQorCQkJCXJiX3BhcmVudChvbGQpLT5yYl9sZWZ0ID0gbm9kZTsKKwkJCWVsc2UKKwkJCQlyYl9wYXJlbnQob2xkKS0+cmJfcmlnaHQgPSBub2RlOworCQl9IGVsc2UKKwkJCXJvb3QtPnJiX25vZGUgPSBub2RlOworCisJCXJiX3NldF9wYXJlbnQob2xkLT5yYl9sZWZ0LCBub2RlKTsKKwkJaWYgKG9sZC0+cmJfcmlnaHQpCisJCQlyYl9zZXRfcGFyZW50KG9sZC0+cmJfcmlnaHQsIG5vZGUpOworCQlnb3RvIGNvbG9yOworCX0KKworCXBhcmVudCA9IHJiX3BhcmVudChub2RlKTsKKwljb2xvciA9IHJiX2NvbG9yKG5vZGUpOworCisJaWYgKGNoaWxkKQorCQlyYl9zZXRfcGFyZW50KGNoaWxkLCBwYXJlbnQpOworCWlmIChwYXJlbnQpCisJeworCQlpZiAocGFyZW50LT5yYl9sZWZ0ID09IG5vZGUpCisJCQlwYXJlbnQtPnJiX2xlZnQgPSBjaGlsZDsKKwkJZWxzZQorCQkJcGFyZW50LT5yYl9yaWdodCA9IGNoaWxkOworCX0KKwllbHNlCisJCXJvb3QtPnJiX25vZGUgPSBjaGlsZDsKKworIGNvbG9yOgorCWlmIChjb2xvciA9PSBSQl9CTEFDSykKKwkJX19yYl9lcmFzZV9jb2xvcihjaGlsZCwgcGFyZW50LCByb290KTsKK30KKworLyoKKyAqIFRoaXMgZnVuY3Rpb24gcmV0dXJucyB0aGUgZmlyc3Qgbm9kZSAoaW4gc29ydCBvcmRlcikgb2YgdGhlIHRyZWUuCisgKi8KK3N0cnVjdCByYl9ub2RlICpyYl9maXJzdChjb25zdCBzdHJ1Y3QgcmJfcm9vdCAqcm9vdCkKK3sKKwlzdHJ1Y3QgcmJfbm9kZQkqbjsKKworCW4gPSByb290LT5yYl9ub2RlOworCWlmICghbikKKwkJcmV0dXJuIE5VTEw7CisJd2hpbGUgKG4tPnJiX2xlZnQpCisJCW4gPSBuLT5yYl9sZWZ0OworCXJldHVybiBuOworfQorCitzdHJ1Y3QgcmJfbm9kZSAqcmJfbGFzdChjb25zdCBzdHJ1Y3QgcmJfcm9vdCAqcm9vdCkKK3sKKwlzdHJ1Y3QgcmJfbm9kZQkqbjsKKworCW4gPSByb290LT5yYl9ub2RlOworCWlmICghbikKKwkJcmV0dXJuIE5VTEw7CisJd2hpbGUgKG4tPnJiX3JpZ2h0KQorCQluID0gbi0+cmJfcmlnaHQ7CisJcmV0dXJuIG47Cit9CisKK3N0cnVjdCByYl9ub2RlICpyYl9uZXh0KGNvbnN0IHN0cnVjdCByYl9ub2RlICpub2RlKQoreworCXN0cnVjdCByYl9ub2RlICpwYXJlbnQ7CisKKwlpZiAocmJfcGFyZW50KG5vZGUpID09IG5vZGUpCisJCXJldHVybiBOVUxMOworCisJLyogSWYgd2UgaGF2ZSBhIHJpZ2h0LWhhbmQgY2hpbGQsIGdvIGRvd24gYW5kIHRoZW4gbGVmdCBhcyBmYXIKKwkgICBhcyB3ZSBjYW4uICovCisJaWYgKG5vZGUtPnJiX3JpZ2h0KSB7CisJCW5vZGUgPSBub2RlLT5yYl9yaWdodDsgCisJCXdoaWxlIChub2RlLT5yYl9sZWZ0KQorCQkJbm9kZT1ub2RlLT5yYl9sZWZ0OworCQlyZXR1cm4gKHN0cnVjdCByYl9ub2RlICopbm9kZTsKKwl9CisKKwkvKiBObyByaWdodC1oYW5kIGNoaWxkcmVuLiAgRXZlcnl0aGluZyBkb3duIGFuZCBsZWZ0IGlzCisJICAgc21hbGxlciB0aGFuIHVzLCBzbyBhbnkgJ25leHQnIG5vZGUgbXVzdCBiZSBpbiB0aGUgZ2VuZXJhbAorCSAgIGRpcmVjdGlvbiBvZiBvdXIgcGFyZW50LiBHbyB1cCB0aGUgdHJlZTsgYW55IHRpbWUgdGhlCisJICAgYW5jZXN0b3IgaXMgYSByaWdodC1oYW5kIGNoaWxkIG9mIGl0cyBwYXJlbnQsIGtlZXAgZ29pbmcKKwkgICB1cC4gRmlyc3QgdGltZSBpdCdzIGEgbGVmdC1oYW5kIGNoaWxkIG9mIGl0cyBwYXJlbnQsIHNhaWQKKwkgICBwYXJlbnQgaXMgb3VyICduZXh0JyBub2RlLiAqLworCXdoaWxlICgocGFyZW50ID0gcmJfcGFyZW50KG5vZGUpKSAmJiBub2RlID09IHBhcmVudC0+cmJfcmlnaHQpCisJCW5vZGUgPSBwYXJlbnQ7CisKKwlyZXR1cm4gcGFyZW50OworfQorCitzdHJ1Y3QgcmJfbm9kZSAqcmJfcHJldihjb25zdCBzdHJ1Y3QgcmJfbm9kZSAqbm9kZSkKK3sKKwlzdHJ1Y3QgcmJfbm9kZSAqcGFyZW50OworCisJaWYgKHJiX3BhcmVudChub2RlKSA9PSBub2RlKQorCQlyZXR1cm4gTlVMTDsKKworCS8qIElmIHdlIGhhdmUgYSBsZWZ0LWhhbmQgY2hpbGQsIGdvIGRvd24gYW5kIHRoZW4gcmlnaHQgYXMgZmFyCisJICAgYXMgd2UgY2FuLiAqLworCWlmIChub2RlLT5yYl9sZWZ0KSB7CisJCW5vZGUgPSBub2RlLT5yYl9sZWZ0OyAKKwkJd2hpbGUgKG5vZGUtPnJiX3JpZ2h0KQorCQkJbm9kZT1ub2RlLT5yYl9yaWdodDsKKwkJcmV0dXJuIChzdHJ1Y3QgcmJfbm9kZSAqKW5vZGU7CisJfQorCisJLyogTm8gbGVmdC1oYW5kIGNoaWxkcmVuLiBHbyB1cCB0aWxsIHdlIGZpbmQgYW4gYW5jZXN0b3Igd2hpY2gKKwkgICBpcyBhIHJpZ2h0LWhhbmQgY2hpbGQgb2YgaXRzIHBhcmVudCAqLworCXdoaWxlICgocGFyZW50ID0gcmJfcGFyZW50KG5vZGUpKSAmJiBub2RlID09IHBhcmVudC0+cmJfbGVmdCkKKwkJbm9kZSA9IHBhcmVudDsKKworCXJldHVybiBwYXJlbnQ7Cit9CisKK3ZvaWQgcmJfcmVwbGFjZV9ub2RlKHN0cnVjdCByYl9ub2RlICp2aWN0aW0sIHN0cnVjdCByYl9ub2RlICpuZXcsCisJCSAgICAgc3RydWN0IHJiX3Jvb3QgKnJvb3QpCit7CisJc3RydWN0IHJiX25vZGUgKnBhcmVudCA9IHJiX3BhcmVudCh2aWN0aW0pOworCisJLyogU2V0IHRoZSBzdXJyb3VuZGluZyBub2RlcyB0byBwb2ludCB0byB0aGUgcmVwbGFjZW1lbnQgKi8KKwlpZiAocGFyZW50KSB7CisJCWlmICh2aWN0aW0gPT0gcGFyZW50LT5yYl9sZWZ0KQorCQkJcGFyZW50LT5yYl9sZWZ0ID0gbmV3OworCQllbHNlCisJCQlwYXJlbnQtPnJiX3JpZ2h0ID0gbmV3OworCX0gZWxzZSB7CisJCXJvb3QtPnJiX25vZGUgPSBuZXc7CisJfQorCWlmICh2aWN0aW0tPnJiX2xlZnQpCisJCXJiX3NldF9wYXJlbnQodmljdGltLT5yYl9sZWZ0LCBuZXcpOworCWlmICh2aWN0aW0tPnJiX3JpZ2h0KQorCQlyYl9zZXRfcGFyZW50KHZpY3RpbS0+cmJfcmlnaHQsIG5ldyk7CisKKwkvKiBDb3B5IHRoZSBwb2ludGVycy9jb2xvdXIgZnJvbSB0aGUgdmljdGltIHRvIHRoZSByZXBsYWNlbWVudCAqLworCSpuZXcgPSAqdmljdGltOworfQpkaWZmIC0tZ2l0IGEvdG9vbHMvcGVyZi91dGlsL3JidHJlZS5oIGIvdG9vbHMvcGVyZi91dGlsL3JidHJlZS5oCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjZiZGM0ODgKLS0tIC9kZXYvbnVsbAorKysgYi90b29scy9wZXJmL3V0aWwvcmJ0cmVlLmgKQEAgLTAsMCArMSwxNzEgQEAKKy8qCisgIFJlZCBCbGFjayBUcmVlcworICAoQykgMTk5OSAgQW5kcmVhIEFyY2FuZ2VsaSA8YW5kcmVhQHN1c2UuZGU+CisgIAorICBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeQorICBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGFzIHB1Ymxpc2hlZCBieQorICB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uOyBlaXRoZXIgdmVyc2lvbiAyIG9mIHRoZSBMaWNlbnNlLCBvcgorICAoYXQgeW91ciBvcHRpb24pIGFueSBsYXRlciB2ZXJzaW9uLgorCisgIFRoaXMgcHJvZ3JhbSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLAorICBidXQgV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgorICBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlCisgIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCisKKyAgWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29weSBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UKKyAgYWxvbmcgd2l0aCB0aGlzIHByb2dyYW07IGlmIG5vdCwgd3JpdGUgdG8gdGhlIEZyZWUgU29mdHdhcmUKKyAgRm91bmRhdGlvbiwgSW5jLiwgNTkgVGVtcGxlIFBsYWNlLCBTdWl0ZSAzMzAsIEJvc3RvbiwgTUEgIDAyMTExLTEzMDcgIFVTQQorCisgIGxpbnV4L2luY2x1ZGUvbGludXgvcmJ0cmVlLmgKKworICBUbyB1c2UgcmJ0cmVlcyB5b3UnbGwgaGF2ZSB0byBpbXBsZW1lbnQgeW91ciBvd24gaW5zZXJ0IGFuZCBzZWFyY2ggY29yZXMuCisgIFRoaXMgd2lsbCBhdm9pZCB1cyB0byB1c2UgY2FsbGJhY2tzIGFuZCB0byBkcm9wIGRyYW1tYXRpY2FsbHkgcGVyZm9ybWFuY2VzLgorICBJIGtub3cgaXQncyBub3QgdGhlIGNsZWFuZXIgd2F5LCAgYnV0IGluIEMgKG5vdCBpbiBDKyspIHRvIGdldAorICBwZXJmb3JtYW5jZXMgYW5kIGdlbmVyaWNpdHkuLi4KKworICBTb21lIGV4YW1wbGUgb2YgaW5zZXJ0IGFuZCBzZWFyY2ggZm9sbG93cyBoZXJlLiBUaGUgc2VhcmNoIGlzIGEgcGxhaW4KKyAgbm9ybWFsIHNlYXJjaCBvdmVyIGFuIG9yZGVyZWQgdHJlZS4gVGhlIGluc2VydCBpbnN0ZWFkIG11c3QgYmUgaW1wbGVtZW50ZWQKKyAgaW50IHR3byBzdGVwczogYXMgZmlyc3QgdGhpbmcgdGhlIGNvZGUgbXVzdCBpbnNlcnQgdGhlIGVsZW1lbnQgaW4KKyAgb3JkZXIgYXMgYSByZWQgbGVhZiBpbiB0aGUgdHJlZSwgdGhlbiB0aGUgc3VwcG9ydCBsaWJyYXJ5IGZ1bmN0aW9uCisgIHJiX2luc2VydF9jb2xvcigpIG11c3QgYmUgY2FsbGVkLiBTdWNoIGZ1bmN0aW9uIHdpbGwgZG8gdGhlCisgIG5vdCB0cml2aWFsIHdvcmsgdG8gcmViYWxhbmNlIHRoZSByYnRyZWUgaWYgbmVjZXNzYXJ5LgorCistLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQorc3RhdGljIGlubGluZSBzdHJ1Y3QgcGFnZSAqIHJiX3NlYXJjaF9wYWdlX2NhY2hlKHN0cnVjdCBpbm9kZSAqIGlub2RlLAorCQkJCQkJIHVuc2lnbmVkIGxvbmcgb2Zmc2V0KQoreworCXN0cnVjdCByYl9ub2RlICogbiA9IGlub2RlLT5pX3JiX3BhZ2VfY2FjaGUucmJfbm9kZTsKKwlzdHJ1Y3QgcGFnZSAqIHBhZ2U7CisKKwl3aGlsZSAobikKKwl7CisJCXBhZ2UgPSByYl9lbnRyeShuLCBzdHJ1Y3QgcGFnZSwgcmJfcGFnZV9jYWNoZSk7CisKKwkJaWYgKG9mZnNldCA8IHBhZ2UtPm9mZnNldCkKKwkJCW4gPSBuLT5yYl9sZWZ0OworCQllbHNlIGlmIChvZmZzZXQgPiBwYWdlLT5vZmZzZXQpCisJCQluID0gbi0+cmJfcmlnaHQ7CisJCWVsc2UKKwkJCXJldHVybiBwYWdlOworCX0KKwlyZXR1cm4gTlVMTDsKK30KKworc3RhdGljIGlubGluZSBzdHJ1Y3QgcGFnZSAqIF9fcmJfaW5zZXJ0X3BhZ2VfY2FjaGUoc3RydWN0IGlub2RlICogaW5vZGUsCisJCQkJCQkgICB1bnNpZ25lZCBsb25nIG9mZnNldCwKKwkJCQkJCSAgIHN0cnVjdCByYl9ub2RlICogbm9kZSkKK3sKKwlzdHJ1Y3QgcmJfbm9kZSAqKiBwID0gJmlub2RlLT5pX3JiX3BhZ2VfY2FjaGUucmJfbm9kZTsKKwlzdHJ1Y3QgcmJfbm9kZSAqIHBhcmVudCA9IE5VTEw7CisJc3RydWN0IHBhZ2UgKiBwYWdlOworCisJd2hpbGUgKCpwKQorCXsKKwkJcGFyZW50ID0gKnA7CisJCXBhZ2UgPSByYl9lbnRyeShwYXJlbnQsIHN0cnVjdCBwYWdlLCByYl9wYWdlX2NhY2hlKTsKKworCQlpZiAob2Zmc2V0IDwgcGFnZS0+b2Zmc2V0KQorCQkJcCA9ICYoKnApLT5yYl9sZWZ0OworCQllbHNlIGlmIChvZmZzZXQgPiBwYWdlLT5vZmZzZXQpCisJCQlwID0gJigqcCktPnJiX3JpZ2h0OworCQllbHNlCisJCQlyZXR1cm4gcGFnZTsKKwl9CisKKwlyYl9saW5rX25vZGUobm9kZSwgcGFyZW50LCBwKTsKKworCXJldHVybiBOVUxMOworfQorCitzdGF0aWMgaW5saW5lIHN0cnVjdCBwYWdlICogcmJfaW5zZXJ0X3BhZ2VfY2FjaGUoc3RydWN0IGlub2RlICogaW5vZGUsCisJCQkJCQkgdW5zaWduZWQgbG9uZyBvZmZzZXQsCisJCQkJCQkgc3RydWN0IHJiX25vZGUgKiBub2RlKQoreworCXN0cnVjdCBwYWdlICogcmV0OworCWlmICgocmV0ID0gX19yYl9pbnNlcnRfcGFnZV9jYWNoZShpbm9kZSwgb2Zmc2V0LCBub2RlKSkpCisJCWdvdG8gb3V0OworCXJiX2luc2VydF9jb2xvcihub2RlLCAmaW5vZGUtPmlfcmJfcGFnZV9jYWNoZSk7Cisgb3V0OgorCXJldHVybiByZXQ7Cit9CistLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQorKi8KKworI2lmbmRlZglfTElOVVhfUkJUUkVFX0gKKyNkZWZpbmUJX0xJTlVYX1JCVFJFRV9ICisKKyNpbmNsdWRlIDxzdGRkZWYuaD4KKworLyoqCisgKiBjb250YWluZXJfb2YgLSBjYXN0IGEgbWVtYmVyIG9mIGEgc3RydWN0dXJlIG91dCB0byB0aGUgY29udGFpbmluZyBzdHJ1Y3R1cmUKKyAqIEBwdHI6CXRoZSBwb2ludGVyIHRvIHRoZSBtZW1iZXIuCisgKiBAdHlwZToJdGhlIHR5cGUgb2YgdGhlIGNvbnRhaW5lciBzdHJ1Y3QgdGhpcyBpcyBlbWJlZGRlZCBpbi4KKyAqIEBtZW1iZXI6CXRoZSBuYW1lIG9mIHRoZSBtZW1iZXIgd2l0aGluIHRoZSBzdHJ1Y3QuCisgKgorICovCisjZGVmaW5lIGNvbnRhaW5lcl9vZihwdHIsIHR5cGUsIG1lbWJlcikgKHsJCQlcCisJY29uc3QgdHlwZW9mKCAoKHR5cGUgKikwKS0+bWVtYmVyICkgKl9fbXB0ciA9IChwdHIpOwlcCisJKHR5cGUgKikoIChjaGFyICopX19tcHRyIC0gb2Zmc2V0b2YodHlwZSxtZW1iZXIpICk7fSkKKworc3RydWN0IHJiX25vZGUKK3sKKwl1bnNpZ25lZCBsb25nICByYl9wYXJlbnRfY29sb3I7CisjZGVmaW5lCVJCX1JFRAkJMAorI2RlZmluZQlSQl9CTEFDSwkxCisJc3RydWN0IHJiX25vZGUgKnJiX3JpZ2h0OworCXN0cnVjdCByYl9ub2RlICpyYl9sZWZ0OworfSBfX2F0dHJpYnV0ZV9fKChhbGlnbmVkKHNpemVvZihsb25nKSkpKTsKKyAgICAvKiBUaGUgYWxpZ25tZW50IG1pZ2h0IHNlZW0gcG9pbnRsZXNzLCBidXQgYWxsZWdlZGx5IENSSVMgbmVlZHMgaXQgKi8KKworc3RydWN0IHJiX3Jvb3QKK3sKKwlzdHJ1Y3QgcmJfbm9kZSAqcmJfbm9kZTsKK307CisKKworI2RlZmluZSByYl9wYXJlbnQocikgICAoKHN0cnVjdCByYl9ub2RlICopKChyKS0+cmJfcGFyZW50X2NvbG9yICYgfjMpKQorI2RlZmluZSByYl9jb2xvcihyKSAgICgociktPnJiX3BhcmVudF9jb2xvciAmIDEpCisjZGVmaW5lIHJiX2lzX3JlZChyKSAgICghcmJfY29sb3IocikpCisjZGVmaW5lIHJiX2lzX2JsYWNrKHIpIHJiX2NvbG9yKHIpCisjZGVmaW5lIHJiX3NldF9yZWQocikgIGRvIHsgKHIpLT5yYl9wYXJlbnRfY29sb3IgJj0gfjE7IH0gd2hpbGUgKDApCisjZGVmaW5lIHJiX3NldF9ibGFjayhyKSAgZG8geyAociktPnJiX3BhcmVudF9jb2xvciB8PSAxOyB9IHdoaWxlICgwKQorCitzdGF0aWMgaW5saW5lIHZvaWQgcmJfc2V0X3BhcmVudChzdHJ1Y3QgcmJfbm9kZSAqcmIsIHN0cnVjdCByYl9ub2RlICpwKQoreworCXJiLT5yYl9wYXJlbnRfY29sb3IgPSAocmItPnJiX3BhcmVudF9jb2xvciAmIDMpIHwgKHVuc2lnbmVkIGxvbmcpcDsKK30KK3N0YXRpYyBpbmxpbmUgdm9pZCByYl9zZXRfY29sb3Ioc3RydWN0IHJiX25vZGUgKnJiLCBpbnQgY29sb3IpCit7CisJcmItPnJiX3BhcmVudF9jb2xvciA9IChyYi0+cmJfcGFyZW50X2NvbG9yICYgfjEpIHwgY29sb3I7Cit9CisKKyNkZWZpbmUgUkJfUk9PVAkoc3RydWN0IHJiX3Jvb3QpIHsgTlVMTCwgfQorI2RlZmluZQlyYl9lbnRyeShwdHIsIHR5cGUsIG1lbWJlcikgY29udGFpbmVyX29mKHB0ciwgdHlwZSwgbWVtYmVyKQorCisjZGVmaW5lIFJCX0VNUFRZX1JPT1Qocm9vdCkJKChyb290KS0+cmJfbm9kZSA9PSBOVUxMKQorI2RlZmluZSBSQl9FTVBUWV9OT0RFKG5vZGUpCShyYl9wYXJlbnQobm9kZSkgPT0gbm9kZSkKKyNkZWZpbmUgUkJfQ0xFQVJfTk9ERShub2RlKQkocmJfc2V0X3BhcmVudChub2RlLCBub2RlKSkKKworZXh0ZXJuIHZvaWQgcmJfaW5zZXJ0X2NvbG9yKHN0cnVjdCByYl9ub2RlICosIHN0cnVjdCByYl9yb290ICopOworZXh0ZXJuIHZvaWQgcmJfZXJhc2Uoc3RydWN0IHJiX25vZGUgKiwgc3RydWN0IHJiX3Jvb3QgKik7CisKKy8qIEZpbmQgbG9naWNhbCBuZXh0IGFuZCBwcmV2aW91cyBub2RlcyBpbiBhIHRyZWUgKi8KK2V4dGVybiBzdHJ1Y3QgcmJfbm9kZSAqcmJfbmV4dChjb25zdCBzdHJ1Y3QgcmJfbm9kZSAqKTsKK2V4dGVybiBzdHJ1Y3QgcmJfbm9kZSAqcmJfcHJldihjb25zdCBzdHJ1Y3QgcmJfbm9kZSAqKTsKK2V4dGVybiBzdHJ1Y3QgcmJfbm9kZSAqcmJfZmlyc3QoY29uc3Qgc3RydWN0IHJiX3Jvb3QgKik7CitleHRlcm4gc3RydWN0IHJiX25vZGUgKnJiX2xhc3QoY29uc3Qgc3RydWN0IHJiX3Jvb3QgKik7CisKKy8qIEZhc3QgcmVwbGFjZW1lbnQgb2YgYSBzaW5nbGUgbm9kZSB3aXRob3V0IHJlbW92ZS9yZWJhbGFuY2UvYWRkL3JlYmFsYW5jZSAqLworZXh0ZXJuIHZvaWQgcmJfcmVwbGFjZV9ub2RlKHN0cnVjdCByYl9ub2RlICp2aWN0aW0sIHN0cnVjdCByYl9ub2RlICpuZXcsIAorCQkJICAgIHN0cnVjdCByYl9yb290ICpyb290KTsKKworc3RhdGljIGlubGluZSB2b2lkIHJiX2xpbmtfbm9kZShzdHJ1Y3QgcmJfbm9kZSAqIG5vZGUsIHN0cnVjdCByYl9ub2RlICogcGFyZW50LAorCQkJCXN0cnVjdCByYl9ub2RlICoqIHJiX2xpbmspCit7CisJbm9kZS0+cmJfcGFyZW50X2NvbG9yID0gKHVuc2lnbmVkIGxvbmcgKXBhcmVudDsKKwlub2RlLT5yYl9sZWZ0ID0gbm9kZS0+cmJfcmlnaHQgPSBOVUxMOworCisJKnJiX2xpbmsgPSBub2RlOworfQorCisjZW5kaWYJLyogX0xJTlVYX1JCVFJFRV9IICovCmRpZmYgLS1naXQgYS90b29scy9wZXJmL3V0aWwvcnVuLWNvbW1hbmQuYyBiL3Rvb2xzL3BlcmYvdXRpbC9ydW4tY29tbWFuZC5jCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLmIyZjVlODUKLS0tIC9kZXYvbnVsbAorKysgYi90b29scy9wZXJmL3V0aWwvcnVuLWNvbW1hbmQuYwpAQCAtMCwwICsxLDM5NSBAQAorI2luY2x1ZGUgImNhY2hlLmgiCisjaW5jbHVkZSAicnVuLWNvbW1hbmQuaCIKKyNpbmNsdWRlICJleGVjX2NtZC5oIgorCitzdGF0aWMgaW5saW5lIHZvaWQgY2xvc2VfcGFpcihpbnQgZmRbMl0pCit7CisJY2xvc2UoZmRbMF0pOworCWNsb3NlKGZkWzFdKTsKK30KKworc3RhdGljIGlubGluZSB2b2lkIGR1cF9kZXZudWxsKGludCB0bykKK3sKKwlpbnQgZmQgPSBvcGVuKCIvZGV2L251bGwiLCBPX1JEV1IpOworCWR1cDIoZmQsIHRvKTsKKwljbG9zZShmZCk7Cit9CisKK2ludCBzdGFydF9jb21tYW5kKHN0cnVjdCBjaGlsZF9wcm9jZXNzICpjbWQpCit7CisJaW50IG5lZWRfaW4sIG5lZWRfb3V0LCBuZWVkX2VycjsKKwlpbnQgZmRpblsyXSwgZmRvdXRbMl0sIGZkZXJyWzJdOworCisJLyoKKwkgKiBJbiBjYXNlIG9mIGVycm9ycyB3ZSBtdXN0IGtlZXAgdGhlIHByb21pc2UgdG8gY2xvc2UgRkRzCisJICogdGhhdCBoYXZlIGJlZW4gcGFzc2VkIGluIHZpYSAtPmluIGFuZCAtPm91dC4KKwkgKi8KKworCW5lZWRfaW4gPSAhY21kLT5ub19zdGRpbiAmJiBjbWQtPmluIDwgMDsKKwlpZiAobmVlZF9pbikgeworCQlpZiAocGlwZShmZGluKSA8IDApIHsKKwkJCWlmIChjbWQtPm91dCA+IDApCisJCQkJY2xvc2UoY21kLT5vdXQpOworCQkJcmV0dXJuIC1FUlJfUlVOX0NPTU1BTkRfUElQRTsKKwkJfQorCQljbWQtPmluID0gZmRpblsxXTsKKwl9CisKKwluZWVkX291dCA9ICFjbWQtPm5vX3N0ZG91dAorCQkmJiAhY21kLT5zdGRvdXRfdG9fc3RkZXJyCisJCSYmIGNtZC0+b3V0IDwgMDsKKwlpZiAobmVlZF9vdXQpIHsKKwkJaWYgKHBpcGUoZmRvdXQpIDwgMCkgeworCQkJaWYgKG5lZWRfaW4pCisJCQkJY2xvc2VfcGFpcihmZGluKTsKKwkJCWVsc2UgaWYgKGNtZC0+aW4pCisJCQkJY2xvc2UoY21kLT5pbik7CisJCQlyZXR1cm4gLUVSUl9SVU5fQ09NTUFORF9QSVBFOworCQl9CisJCWNtZC0+b3V0ID0gZmRvdXRbMF07CisJfQorCisJbmVlZF9lcnIgPSAhY21kLT5ub19zdGRlcnIgJiYgY21kLT5lcnIgPCAwOworCWlmIChuZWVkX2VycikgeworCQlpZiAocGlwZShmZGVycikgPCAwKSB7CisJCQlpZiAobmVlZF9pbikKKwkJCQljbG9zZV9wYWlyKGZkaW4pOworCQkJZWxzZSBpZiAoY21kLT5pbikKKwkJCQljbG9zZShjbWQtPmluKTsKKwkJCWlmIChuZWVkX291dCkKKwkJCQljbG9zZV9wYWlyKGZkb3V0KTsKKwkJCWVsc2UgaWYgKGNtZC0+b3V0KQorCQkJCWNsb3NlKGNtZC0+b3V0KTsKKwkJCXJldHVybiAtRVJSX1JVTl9DT01NQU5EX1BJUEU7CisJCX0KKwkJY21kLT5lcnIgPSBmZGVyclswXTsKKwl9CisKKyNpZm5kZWYgX19NSU5HVzMyX18KKwlmZmx1c2goTlVMTCk7CisJY21kLT5waWQgPSBmb3JrKCk7CisJaWYgKCFjbWQtPnBpZCkgeworCQlpZiAoY21kLT5ub19zdGRpbikKKwkJCWR1cF9kZXZudWxsKDApOworCQllbHNlIGlmIChuZWVkX2luKSB7CisJCQlkdXAyKGZkaW5bMF0sIDApOworCQkJY2xvc2VfcGFpcihmZGluKTsKKwkJfSBlbHNlIGlmIChjbWQtPmluKSB7CisJCQlkdXAyKGNtZC0+aW4sIDApOworCQkJY2xvc2UoY21kLT5pbik7CisJCX0KKworCQlpZiAoY21kLT5ub19zdGRlcnIpCisJCQlkdXBfZGV2bnVsbCgyKTsKKwkJZWxzZSBpZiAobmVlZF9lcnIpIHsKKwkJCWR1cDIoZmRlcnJbMV0sIDIpOworCQkJY2xvc2VfcGFpcihmZGVycik7CisJCX0KKworCQlpZiAoY21kLT5ub19zdGRvdXQpCisJCQlkdXBfZGV2bnVsbCgxKTsKKwkJZWxzZSBpZiAoY21kLT5zdGRvdXRfdG9fc3RkZXJyKQorCQkJZHVwMigyLCAxKTsKKwkJZWxzZSBpZiAobmVlZF9vdXQpIHsKKwkJCWR1cDIoZmRvdXRbMV0sIDEpOworCQkJY2xvc2VfcGFpcihmZG91dCk7CisJCX0gZWxzZSBpZiAoY21kLT5vdXQgPiAxKSB7CisJCQlkdXAyKGNtZC0+b3V0LCAxKTsKKwkJCWNsb3NlKGNtZC0+b3V0KTsKKwkJfQorCisJCWlmIChjbWQtPmRpciAmJiBjaGRpcihjbWQtPmRpcikpCisJCQlkaWUoImV4ZWMgJXM6IGNkIHRvICVzIGZhaWxlZCAoJXMpIiwgY21kLT5hcmd2WzBdLAorCQkJICAgIGNtZC0+ZGlyLCBzdHJlcnJvcihlcnJubykpOworCQlpZiAoY21kLT5lbnYpIHsKKwkJCWZvciAoOyAqY21kLT5lbnY7IGNtZC0+ZW52KyspIHsKKwkJCQlpZiAoc3RyY2hyKCpjbWQtPmVudiwgJz0nKSkKKwkJCQkJcHV0ZW52KChjaGFyKikqY21kLT5lbnYpOworCQkJCWVsc2UKKwkJCQkJdW5zZXRlbnYoKmNtZC0+ZW52KTsKKwkJCX0KKwkJfQorCQlpZiAoY21kLT5wcmVleGVjX2NiKQorCQkJY21kLT5wcmVleGVjX2NiKCk7CisJCWlmIChjbWQtPnBlcmZfY21kKSB7CisJCQlleGVjdl9wZXJmX2NtZChjbWQtPmFyZ3YpOworCQl9IGVsc2UgeworCQkJZXhlY3ZwKGNtZC0+YXJndlswXSwgKGNoYXIgKmNvbnN0KikgY21kLT5hcmd2KTsKKwkJfQorCQlleGl0KDEyNyk7CisJfQorI2Vsc2UKKwlpbnQgczAgPSAtMSwgczEgPSAtMSwgczIgPSAtMTsJLyogYmFja3VwcyBvZiBzdGRpbiwgc3Rkb3V0LCBzdGRlcnIgKi8KKwljb25zdCBjaGFyICoqc2FyZ3YgPSBjbWQtPmFyZ3Y7CisJY2hhciAqKmVudiA9IGVudmlyb247CisKKwlpZiAoY21kLT5ub19zdGRpbikgeworCQlzMCA9IGR1cCgwKTsKKwkJZHVwX2Rldm51bGwoMCk7CisJfSBlbHNlIGlmIChuZWVkX2luKSB7CisJCXMwID0gZHVwKDApOworCQlkdXAyKGZkaW5bMF0sIDApOworCX0gZWxzZSBpZiAoY21kLT5pbikgeworCQlzMCA9IGR1cCgwKTsKKwkJZHVwMihjbWQtPmluLCAwKTsKKwl9CisKKwlpZiAoY21kLT5ub19zdGRlcnIpIHsKKwkJczIgPSBkdXAoMik7CisJCWR1cF9kZXZudWxsKDIpOworCX0gZWxzZSBpZiAobmVlZF9lcnIpIHsKKwkJczIgPSBkdXAoMik7CisJCWR1cDIoZmRlcnJbMV0sIDIpOworCX0KKworCWlmIChjbWQtPm5vX3N0ZG91dCkgeworCQlzMSA9IGR1cCgxKTsKKwkJZHVwX2Rldm51bGwoMSk7CisJfSBlbHNlIGlmIChjbWQtPnN0ZG91dF90b19zdGRlcnIpIHsKKwkJczEgPSBkdXAoMSk7CisJCWR1cDIoMiwgMSk7CisJfSBlbHNlIGlmIChuZWVkX291dCkgeworCQlzMSA9IGR1cCgxKTsKKwkJZHVwMihmZG91dFsxXSwgMSk7CisJfSBlbHNlIGlmIChjbWQtPm91dCA+IDEpIHsKKwkJczEgPSBkdXAoMSk7CisJCWR1cDIoY21kLT5vdXQsIDEpOworCX0KKworCWlmIChjbWQtPmRpcikKKwkJZGllKCJjaGRpciBpbiBzdGFydF9jb21tYW5kKCkgbm90IGltcGxlbWVudGVkIik7CisJaWYgKGNtZC0+ZW52KSB7CisJCWVudiA9IGNvcHlfZW52aXJvbigpOworCQlmb3IgKDsgKmNtZC0+ZW52OyBjbWQtPmVudisrKQorCQkJZW52ID0gZW52X3NldGVudihlbnYsICpjbWQtPmVudik7CisJfQorCisJaWYgKGNtZC0+cGVyZl9jbWQpIHsKKwkJY21kLT5hcmd2ID0gcHJlcGFyZV9wZXJmX2NtZChjbWQtPmFyZ3YpOworCX0KKworCWNtZC0+cGlkID0gbWluZ3dfc3Bhd252cGUoY21kLT5hcmd2WzBdLCBjbWQtPmFyZ3YsIGVudik7CisKKwlpZiAoY21kLT5lbnYpCisJCWZyZWVfZW52aXJvbihlbnYpOworCWlmIChjbWQtPnBlcmZfY21kKQorCQlmcmVlKGNtZC0+YXJndik7CisKKwljbWQtPmFyZ3YgPSBzYXJndjsKKwlpZiAoczAgPj0gMCkKKwkJZHVwMihzMCwgMCksIGNsb3NlKHMwKTsKKwlpZiAoczEgPj0gMCkKKwkJZHVwMihzMSwgMSksIGNsb3NlKHMxKTsKKwlpZiAoczIgPj0gMCkKKwkJZHVwMihzMiwgMiksIGNsb3NlKHMyKTsKKyNlbmRpZgorCisJaWYgKGNtZC0+cGlkIDwgMCkgeworCQlpbnQgZXJyID0gZXJybm87CisJCWlmIChuZWVkX2luKQorCQkJY2xvc2VfcGFpcihmZGluKTsKKwkJZWxzZSBpZiAoY21kLT5pbikKKwkJCWNsb3NlKGNtZC0+aW4pOworCQlpZiAobmVlZF9vdXQpCisJCQljbG9zZV9wYWlyKGZkb3V0KTsKKwkJZWxzZSBpZiAoY21kLT5vdXQpCisJCQljbG9zZShjbWQtPm91dCk7CisJCWlmIChuZWVkX2VycikKKwkJCWNsb3NlX3BhaXIoZmRlcnIpOworCQlyZXR1cm4gZXJyID09IEVOT0VOVCA/CisJCQktRVJSX1JVTl9DT01NQU5EX0VYRUMgOgorCQkJLUVSUl9SVU5fQ09NTUFORF9GT1JLOworCX0KKworCWlmIChuZWVkX2luKQorCQljbG9zZShmZGluWzBdKTsKKwllbHNlIGlmIChjbWQtPmluKQorCQljbG9zZShjbWQtPmluKTsKKworCWlmIChuZWVkX291dCkKKwkJY2xvc2UoZmRvdXRbMV0pOworCWVsc2UgaWYgKGNtZC0+b3V0KQorCQljbG9zZShjbWQtPm91dCk7CisKKwlpZiAobmVlZF9lcnIpCisJCWNsb3NlKGZkZXJyWzFdKTsKKworCXJldHVybiAwOworfQorCitzdGF0aWMgaW50IHdhaXRfb3Jfd2hpbmUocGlkX3QgcGlkKQoreworCWZvciAoOzspIHsKKwkJaW50IHN0YXR1cywgY29kZTsKKwkJcGlkX3Qgd2FpdGluZyA9IHdhaXRwaWQocGlkLCAmc3RhdHVzLCAwKTsKKworCQlpZiAod2FpdGluZyA8IDApIHsKKwkJCWlmIChlcnJubyA9PSBFSU5UUikKKwkJCQljb250aW51ZTsKKwkJCWVycm9yKCJ3YWl0cGlkIGZhaWxlZCAoJXMpIiwgc3RyZXJyb3IoZXJybm8pKTsKKwkJCXJldHVybiAtRVJSX1JVTl9DT01NQU5EX1dBSVRQSUQ7CisJCX0KKwkJaWYgKHdhaXRpbmcgIT0gcGlkKQorCQkJcmV0dXJuIC1FUlJfUlVOX0NPTU1BTkRfV0FJVFBJRF9XUk9OR19QSUQ7CisJCWlmIChXSUZTSUdOQUxFRChzdGF0dXMpKQorCQkJcmV0dXJuIC1FUlJfUlVOX0NPTU1BTkRfV0FJVFBJRF9TSUdOQUw7CisKKwkJaWYgKCFXSUZFWElURUQoc3RhdHVzKSkKKwkJCXJldHVybiAtRVJSX1JVTl9DT01NQU5EX1dBSVRQSURfTk9FWElUOworCQljb2RlID0gV0VYSVRTVEFUVVMoc3RhdHVzKTsKKwkJc3dpdGNoIChjb2RlKSB7CisJCWNhc2UgMTI3OgorCQkJcmV0dXJuIC1FUlJfUlVOX0NPTU1BTkRfRVhFQzsKKwkJY2FzZSAwOgorCQkJcmV0dXJuIDA7CisJCWRlZmF1bHQ6CisJCQlyZXR1cm4gLWNvZGU7CisJCX0KKwl9Cit9CisKK2ludCBmaW5pc2hfY29tbWFuZChzdHJ1Y3QgY2hpbGRfcHJvY2VzcyAqY21kKQoreworCXJldHVybiB3YWl0X29yX3doaW5lKGNtZC0+cGlkKTsKK30KKworaW50IHJ1bl9jb21tYW5kKHN0cnVjdCBjaGlsZF9wcm9jZXNzICpjbWQpCit7CisJaW50IGNvZGUgPSBzdGFydF9jb21tYW5kKGNtZCk7CisJaWYgKGNvZGUpCisJCXJldHVybiBjb2RlOworCXJldHVybiBmaW5pc2hfY29tbWFuZChjbWQpOworfQorCitzdGF0aWMgdm9pZCBwcmVwYXJlX3J1bl9jb21tYW5kX3Zfb3B0KHN0cnVjdCBjaGlsZF9wcm9jZXNzICpjbWQsCisJCQkJICAgICAgY29uc3QgY2hhciAqKmFyZ3YsCisJCQkJICAgICAgaW50IG9wdCkKK3sKKwltZW1zZXQoY21kLCAwLCBzaXplb2YoKmNtZCkpOworCWNtZC0+YXJndiA9IGFyZ3Y7CisJY21kLT5ub19zdGRpbiA9IG9wdCAmIFJVTl9DT01NQU5EX05PX1NURElOID8gMSA6IDA7CisJY21kLT5wZXJmX2NtZCA9IG9wdCAmIFJVTl9QRVJGX0NNRCA/IDEgOiAwOworCWNtZC0+c3Rkb3V0X3RvX3N0ZGVyciA9IG9wdCAmIFJVTl9DT01NQU5EX1NURE9VVF9UT19TVERFUlIgPyAxIDogMDsKK30KKworaW50IHJ1bl9jb21tYW5kX3Zfb3B0KGNvbnN0IGNoYXIgKiphcmd2LCBpbnQgb3B0KQoreworCXN0cnVjdCBjaGlsZF9wcm9jZXNzIGNtZDsKKwlwcmVwYXJlX3J1bl9jb21tYW5kX3Zfb3B0KCZjbWQsIGFyZ3YsIG9wdCk7CisJcmV0dXJuIHJ1bl9jb21tYW5kKCZjbWQpOworfQorCitpbnQgcnVuX2NvbW1hbmRfdl9vcHRfY2RfZW52KGNvbnN0IGNoYXIgKiphcmd2LCBpbnQgb3B0LCBjb25zdCBjaGFyICpkaXIsIGNvbnN0IGNoYXIgKmNvbnN0ICplbnYpCit7CisJc3RydWN0IGNoaWxkX3Byb2Nlc3MgY21kOworCXByZXBhcmVfcnVuX2NvbW1hbmRfdl9vcHQoJmNtZCwgYXJndiwgb3B0KTsKKwljbWQuZGlyID0gZGlyOworCWNtZC5lbnYgPSBlbnY7CisJcmV0dXJuIHJ1bl9jb21tYW5kKCZjbWQpOworfQorCisjaWZkZWYgX19NSU5HVzMyX18KK3N0YXRpYyBfX3N0ZGNhbGwgdW5zaWduZWQgcnVuX3RocmVhZCh2b2lkICpkYXRhKQoreworCXN0cnVjdCBhc3luYyAqYXN5bmMgPSBkYXRhOworCXJldHVybiBhc3luYy0+cHJvYyhhc3luYy0+ZmRfZm9yX3Byb2MsIGFzeW5jLT5kYXRhKTsKK30KKyNlbmRpZgorCitpbnQgc3RhcnRfYXN5bmMoc3RydWN0IGFzeW5jICphc3luYykKK3sKKwlpbnQgcGlwZV9vdXRbMl07CisKKwlpZiAocGlwZShwaXBlX291dCkgPCAwKQorCQlyZXR1cm4gZXJyb3IoImNhbm5vdCBjcmVhdGUgcGlwZTogJXMiLCBzdHJlcnJvcihlcnJubykpOworCWFzeW5jLT5vdXQgPSBwaXBlX291dFswXTsKKworI2lmbmRlZiBfX01JTkdXMzJfXworCS8qIEZsdXNoIHN0ZGlvIGJlZm9yZSBmb3JrKCkgdG8gYXZvaWQgY2xvbmluZyBidWZmZXJzICovCisJZmZsdXNoKE5VTEwpOworCisJYXN5bmMtPnBpZCA9IGZvcmsoKTsKKwlpZiAoYXN5bmMtPnBpZCA8IDApIHsKKwkJZXJyb3IoImZvcmsgKGFzeW5jKSBmYWlsZWQ6ICVzIiwgc3RyZXJyb3IoZXJybm8pKTsKKwkJY2xvc2VfcGFpcihwaXBlX291dCk7CisJCXJldHVybiAtMTsKKwl9CisJaWYgKCFhc3luYy0+cGlkKSB7CisJCWNsb3NlKHBpcGVfb3V0WzBdKTsKKwkJZXhpdCghIWFzeW5jLT5wcm9jKHBpcGVfb3V0WzFdLCBhc3luYy0+ZGF0YSkpOworCX0KKwljbG9zZShwaXBlX291dFsxXSk7CisjZWxzZQorCWFzeW5jLT5mZF9mb3JfcHJvYyA9IHBpcGVfb3V0WzFdOworCWFzeW5jLT50aWQgPSAoSEFORExFKSBfYmVnaW50aHJlYWRleChOVUxMLCAwLCBydW5fdGhyZWFkLCBhc3luYywgMCwgTlVMTCk7CisJaWYgKCFhc3luYy0+dGlkKSB7CisJCWVycm9yKCJjYW5ub3QgY3JlYXRlIHRocmVhZDogJXMiLCBzdHJlcnJvcihlcnJubykpOworCQljbG9zZV9wYWlyKHBpcGVfb3V0KTsKKwkJcmV0dXJuIC0xOworCX0KKyNlbmRpZgorCXJldHVybiAwOworfQorCitpbnQgZmluaXNoX2FzeW5jKHN0cnVjdCBhc3luYyAqYXN5bmMpCit7CisjaWZuZGVmIF9fTUlOR1czMl9fCisJaW50IHJldCA9IDA7CisKKwlpZiAod2FpdF9vcl93aGluZShhc3luYy0+cGlkKSkKKwkJcmV0ID0gZXJyb3IoIndhaXRwaWQgKGFzeW5jKSBmYWlsZWQiKTsKKyNlbHNlCisJRFdPUkQgcmV0ID0gMDsKKwlpZiAoV2FpdEZvclNpbmdsZU9iamVjdChhc3luYy0+dGlkLCBJTkZJTklURSkgIT0gV0FJVF9PQkpFQ1RfMCkKKwkJcmV0ID0gZXJyb3IoIndhaXRpbmcgZm9yIHRocmVhZCBmYWlsZWQ6ICVsdSIsIEdldExhc3RFcnJvcigpKTsKKwllbHNlIGlmICghR2V0RXhpdENvZGVUaHJlYWQoYXN5bmMtPnRpZCwgJnJldCkpCisJCXJldCA9IGVycm9yKCJjYW5ub3QgZ2V0IHRocmVhZCBleGl0IGNvZGU6ICVsdSIsIEdldExhc3RFcnJvcigpKTsKKwlDbG9zZUhhbmRsZShhc3luYy0+dGlkKTsKKyNlbmRpZgorCXJldHVybiByZXQ7Cit9CisKK2ludCBydW5faG9vayhjb25zdCBjaGFyICppbmRleF9maWxlLCBjb25zdCBjaGFyICpuYW1lLCAuLi4pCit7CisJc3RydWN0IGNoaWxkX3Byb2Nlc3MgaG9vazsKKwljb25zdCBjaGFyICoqYXJndiA9IE5VTEwsICplbnZbMl07CisJY2hhciBpbmRleFtQQVRIX01BWF07CisJdmFfbGlzdCBhcmdzOworCWludCByZXQ7CisJc2l6ZV90IGkgPSAwLCBhbGxvYyA9IDA7CisKKwlpZiAoYWNjZXNzKHBlcmZfcGF0aCgiaG9va3MvJXMiLCBuYW1lKSwgWF9PSykgPCAwKQorCQlyZXR1cm4gMDsKKworCXZhX3N0YXJ0KGFyZ3MsIG5hbWUpOworCUFMTE9DX0dST1coYXJndiwgaSArIDEsIGFsbG9jKTsKKwlhcmd2W2krK10gPSBwZXJmX3BhdGgoImhvb2tzLyVzIiwgbmFtZSk7CisJd2hpbGUgKGFyZ3ZbaS0xXSkgeworCQlBTExPQ19HUk9XKGFyZ3YsIGkgKyAxLCBhbGxvYyk7CisJCWFyZ3ZbaSsrXSA9IHZhX2FyZyhhcmdzLCBjb25zdCBjaGFyICopOworCX0KKwl2YV9lbmQoYXJncyk7CisKKwltZW1zZXQoJmhvb2ssIDAsIHNpemVvZihob29rKSk7CisJaG9vay5hcmd2ID0gYXJndjsKKwlob29rLm5vX3N0ZGluID0gMTsKKwlob29rLnN0ZG91dF90b19zdGRlcnIgPSAxOworCWlmIChpbmRleF9maWxlKSB7CisJCXNucHJpbnRmKGluZGV4LCBzaXplb2YoaW5kZXgpLCAiUEVSRl9JTkRFWF9GSUxFPSVzIiwgaW5kZXhfZmlsZSk7CisJCWVudlswXSA9IGluZGV4OworCQllbnZbMV0gPSBOVUxMOworCQlob29rLmVudiA9IGVudjsKKwl9CisKKwlyZXQgPSBzdGFydF9jb21tYW5kKCZob29rKTsKKwlmcmVlKGFyZ3YpOworCWlmIChyZXQpIHsKKwkJd2FybmluZygiQ291bGQgbm90IHNwYXduICVzIiwgYXJndlswXSk7CisJCXJldHVybiByZXQ7CisJfQorCXJldCA9IGZpbmlzaF9jb21tYW5kKCZob29rKTsKKwlpZiAocmV0ID09IC1FUlJfUlVOX0NPTU1BTkRfV0FJVFBJRF9TSUdOQUwpCisJCXdhcm5pbmcoIiVzIGV4aXRlZCBkdWUgdG8gdW5jYXVnaHQgc2lnbmFsIiwgYXJndlswXSk7CisKKwlyZXR1cm4gcmV0OworfQpkaWZmIC0tZ2l0IGEvdG9vbHMvcGVyZi91dGlsL3J1bi1jb21tYW5kLmggYi90b29scy9wZXJmL3V0aWwvcnVuLWNvbW1hbmQuaApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi4zMjgyODlmCi0tLSAvZGV2L251bGwKKysrIGIvdG9vbHMvcGVyZi91dGlsL3J1bi1jb21tYW5kLmgKQEAgLTAsMCArMSw5MyBAQAorI2lmbmRlZiBSVU5fQ09NTUFORF9ICisjZGVmaW5lIFJVTl9DT01NQU5EX0gKKworZW51bSB7CisJRVJSX1JVTl9DT01NQU5EX0ZPUksgPSAxMDAwMCwKKwlFUlJfUlVOX0NPTU1BTkRfRVhFQywKKwlFUlJfUlVOX0NPTU1BTkRfUElQRSwKKwlFUlJfUlVOX0NPTU1BTkRfV0FJVFBJRCwKKwlFUlJfUlVOX0NPTU1BTkRfV0FJVFBJRF9XUk9OR19QSUQsCisJRVJSX1JVTl9DT01NQU5EX1dBSVRQSURfU0lHTkFMLAorCUVSUl9SVU5fQ09NTUFORF9XQUlUUElEX05PRVhJVCwKK307CisjZGVmaW5lIElTX1JVTl9DT01NQU5EX0VSUih4KSAoLSh4KSA+PSBFUlJfUlVOX0NPTU1BTkRfRk9SSykKKworc3RydWN0IGNoaWxkX3Byb2Nlc3MgeworCWNvbnN0IGNoYXIgKiphcmd2OworCXBpZF90IHBpZDsKKwkvKgorCSAqIFVzaW5nIC5pbiwgLm91dCwgLmVycjoKKwkgKiAtIFNwZWNpZnkgMCBmb3Igbm8gcmVkaXJlY3Rpb25zIChjaGlsZCBpbmhlcml0cyBzdGRpbiwgc3Rkb3V0LAorCSAqICAgc3RkZXJyIGZyb20gcGFyZW50KS4KKwkgKiAtIFNwZWNpZnkgLTEgdG8gaGF2ZSBhIHBpcGUgYWxsb2NhdGVkIGFzIGZvbGxvd3M6CisJICogICAgIC5pbjogcmV0dXJucyB0aGUgd3JpdGFibGUgcGlwZSBlbmQ7IHBhcmVudCB3cml0ZXMgdG8gaXQsCisJICogICAgICAgICAgdGhlIHJlYWRhYmxlIHBpcGUgZW5kIGJlY29tZXMgY2hpbGQncyBzdGRpbgorCSAqICAgICAub3V0LCAuZXJyOiByZXR1cm5zIHRoZSByZWFkYWJsZSBwaXBlIGVuZDsgcGFyZW50IHJlYWRzIGZyb20KKwkgKiAgICAgICAgICBpdCwgdGhlIHdyaXRhYmxlIHBpcGUgZW5kIGJlY29tZXMgY2hpbGQncyBzdGRvdXQvc3RkZXJyCisJICogICBUaGUgY2FsbGVyIG9mIHN0YXJ0X2NvbW1hbmQoKSBtdXN0IGNsb3NlIHRoZSByZXR1cm5lZCBGRHMKKwkgKiAgIGFmdGVyIGl0IGhhcyBjb21wbGV0ZWQgcmVhZGluZyBmcm9tL3dyaXRpbmcgdG8gaXQhCisJICogLSBTcGVjaWZ5ID4gMCB0byBzZXQgYSBjaGFubmVsIHRvIGEgcGFydGljdWxhciBGRCBhcyBmb2xsb3dzOgorCSAqICAgICAuaW46IGEgcmVhZGFibGUgRkQsIGJlY29tZXMgY2hpbGQncyBzdGRpbgorCSAqICAgICAub3V0OiBhIHdyaXRhYmxlIEZELCBiZWNvbWVzIGNoaWxkJ3Mgc3Rkb3V0L3N0ZGVycgorCSAqICAgICAuZXJyID4gMCBub3Qgc3VwcG9ydGVkCisJICogICBUaGUgc3BlY2lmaWVkIEZEIGlzIGNsb3NlZCBieSBzdGFydF9jb21tYW5kKCksIGV2ZW4gaW4gY2FzZQorCSAqICAgb2YgZXJyb3JzIQorCSAqLworCWludCBpbjsKKwlpbnQgb3V0OworCWludCBlcnI7CisJY29uc3QgY2hhciAqZGlyOworCWNvbnN0IGNoYXIgKmNvbnN0ICplbnY7CisJdW5zaWduZWQgbm9fc3RkaW46MTsKKwl1bnNpZ25lZCBub19zdGRvdXQ6MTsKKwl1bnNpZ25lZCBub19zdGRlcnI6MTsKKwl1bnNpZ25lZCBwZXJmX2NtZDoxOyAvKiBpZiB0aGlzIGlzIHRvIGJlIHBlcmYgc3ViLWNvbW1hbmQgKi8KKwl1bnNpZ25lZCBzdGRvdXRfdG9fc3RkZXJyOjE7CisJdm9pZCAoKnByZWV4ZWNfY2IpKHZvaWQpOworfTsKKworaW50IHN0YXJ0X2NvbW1hbmQoc3RydWN0IGNoaWxkX3Byb2Nlc3MgKik7CitpbnQgZmluaXNoX2NvbW1hbmQoc3RydWN0IGNoaWxkX3Byb2Nlc3MgKik7CitpbnQgcnVuX2NvbW1hbmQoc3RydWN0IGNoaWxkX3Byb2Nlc3MgKik7CisKK2V4dGVybiBpbnQgcnVuX2hvb2soY29uc3QgY2hhciAqaW5kZXhfZmlsZSwgY29uc3QgY2hhciAqbmFtZSwgLi4uKTsKKworI2RlZmluZSBSVU5fQ09NTUFORF9OT19TVERJTiAxCisjZGVmaW5lIFJVTl9QRVJGX0NNRAkgICAgIDIJLypJZiB0aGlzIGlzIHRvIGJlIHBlcmYgc3ViLWNvbW1hbmQgKi8KKyNkZWZpbmUgUlVOX0NPTU1BTkRfU1RET1VUX1RPX1NUREVSUiA0CitpbnQgcnVuX2NvbW1hbmRfdl9vcHQoY29uc3QgY2hhciAqKmFyZ3YsIGludCBvcHQpOworCisvKgorICogZW52ICh0aGUgZW52aXJvbm1lbnQpIGlzIHRvIGJlIGZvcm1hdHRlZCBsaWtlIGVudmlyb246ICJWQVI9VkFMVUUiLgorICogVG8gdW5zZXQgYW4gZW52aXJvbm1lbnQgdmFyaWFibGUgdXNlIGp1c3QgIlZBUiIuCisgKi8KK2ludCBydW5fY29tbWFuZF92X29wdF9jZF9lbnYoY29uc3QgY2hhciAqKmFyZ3YsIGludCBvcHQsIGNvbnN0IGNoYXIgKmRpciwgY29uc3QgY2hhciAqY29uc3QgKmVudik7CisKKy8qCisgKiBUaGUgcHVycG9zZSBvZiB0aGUgZm9sbG93aW5nIGZ1bmN0aW9ucyBpcyB0byBmZWVkIGEgcGlwZSBieSBydW5uaW5nCisgKiBhIGZ1bmN0aW9uIGFzeW5jaHJvbm91c2x5IGFuZCBwcm92aWRpbmcgb3V0cHV0IHRoYXQgdGhlIGNhbGxlciByZWFkcy4KKyAqCisgKiBJdCBpcyBleHBlY3RlZCB0aGF0IG5vIHN5bmNocm9uaXphdGlvbiBhbmQgbXV0dWFsIGV4Y2x1c2lvbiBiZXR3ZWVuCisgKiB0aGUgY2FsbGVyIGFuZCB0aGUgZmVlZCBmdW5jdGlvbiBpcyBuZWNlc3Nhcnkgc28gdGhhdCB0aGUgZnVuY3Rpb24KKyAqIGNhbiBydW4gaW4gYSB0aHJlYWQgd2l0aG91dCBpbnRlcmZlcmluZyB3aXRoIHRoZSBjYWxsZXIuCisgKi8KK3N0cnVjdCBhc3luYyB7CisJLyoKKwkgKiBwcm9jIHdyaXRlcyB0byBmZCBhbmQgY2xvc2VzIGl0OworCSAqIHJldHVybnMgMCBvbiBzdWNjZXNzLCBub24temVybyBvbiBmYWlsdXJlCisJICovCisJaW50ICgqcHJvYykoaW50IGZkLCB2b2lkICpkYXRhKTsKKwl2b2lkICpkYXRhOworCWludCBvdXQ7CS8qIGNhbGxlciByZWFkcyBmcm9tIGhlcmUgYW5kIGNsb3NlcyBpdCAqLworI2lmbmRlZiBfX01JTkdXMzJfXworCXBpZF90IHBpZDsKKyNlbHNlCisJSEFORExFIHRpZDsKKwlpbnQgZmRfZm9yX3Byb2M7CisjZW5kaWYKK307CisKK2ludCBzdGFydF9hc3luYyhzdHJ1Y3QgYXN5bmMgKmFzeW5jKTsKK2ludCBmaW5pc2hfYXN5bmMoc3RydWN0IGFzeW5jICphc3luYyk7CisKKyNlbmRpZgpkaWZmIC0tZ2l0IGEvdG9vbHMvcGVyZi91dGlsL3NpZ2NoYWluLmMgYi90b29scy9wZXJmL3V0aWwvc2lnY2hhaW4uYwpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi4xMTE4Yjk5Ci0tLSAvZGV2L251bGwKKysrIGIvdG9vbHMvcGVyZi91dGlsL3NpZ2NoYWluLmMKQEAgLTAsMCArMSw1MiBAQAorI2luY2x1ZGUgInNpZ2NoYWluLmgiCisjaW5jbHVkZSAiY2FjaGUuaCIKKworI2RlZmluZSBTSUdDSEFJTl9NQVhfU0lHTkFMUyAzMgorCitzdHJ1Y3Qgc2lnY2hhaW5fc2lnbmFsIHsKKwlzaWdjaGFpbl9mdW4gKm9sZDsKKwlpbnQgbjsKKwlpbnQgYWxsb2M7Cit9Oworc3RhdGljIHN0cnVjdCBzaWdjaGFpbl9zaWduYWwgc2lnbmFsc1tTSUdDSEFJTl9NQVhfU0lHTkFMU107CisKK3N0YXRpYyB2b2lkIGNoZWNrX3NpZ251bShpbnQgc2lnKQoreworCWlmIChzaWcgPCAxIHx8IHNpZyA+PSBTSUdDSEFJTl9NQVhfU0lHTkFMUykKKwkJZGllKCJCVUc6IHNpZ25hbCBvdXQgb2YgcmFuZ2U6ICVkIiwgc2lnKTsKK30KKworaW50IHNpZ2NoYWluX3B1c2goaW50IHNpZywgc2lnY2hhaW5fZnVuIGYpCit7CisJc3RydWN0IHNpZ2NoYWluX3NpZ25hbCAqcyA9IHNpZ25hbHMgKyBzaWc7CisJY2hlY2tfc2lnbnVtKHNpZyk7CisKKwlBTExPQ19HUk9XKHMtPm9sZCwgcy0+biArIDEsIHMtPmFsbG9jKTsKKwlzLT5vbGRbcy0+bl0gPSBzaWduYWwoc2lnLCBmKTsKKwlpZiAocy0+b2xkW3MtPm5dID09IFNJR19FUlIpCisJCXJldHVybiAtMTsKKwlzLT5uKys7CisJcmV0dXJuIDA7Cit9CisKK2ludCBzaWdjaGFpbl9wb3AoaW50IHNpZykKK3sKKwlzdHJ1Y3Qgc2lnY2hhaW5fc2lnbmFsICpzID0gc2lnbmFscyArIHNpZzsKKwljaGVja19zaWdudW0oc2lnKTsKKwlpZiAocy0+biA8IDEpCisJCXJldHVybiAwOworCisJaWYgKHNpZ25hbChzaWcsIHMtPm9sZFtzLT5uIC0gMV0pID09IFNJR19FUlIpCisJCXJldHVybiAtMTsKKwlzLT5uLS07CisJcmV0dXJuIDA7Cit9CisKK3ZvaWQgc2lnY2hhaW5fcHVzaF9jb21tb24oc2lnY2hhaW5fZnVuIGYpCit7CisJc2lnY2hhaW5fcHVzaChTSUdJTlQsIGYpOworCXNpZ2NoYWluX3B1c2goU0lHSFVQLCBmKTsKKwlzaWdjaGFpbl9wdXNoKFNJR1RFUk0sIGYpOworCXNpZ2NoYWluX3B1c2goU0lHUVVJVCwgZik7CisJc2lnY2hhaW5fcHVzaChTSUdQSVBFLCBmKTsKK30KZGlmZiAtLWdpdCBhL3Rvb2xzL3BlcmYvdXRpbC9zaWdjaGFpbi5oIGIvdG9vbHMvcGVyZi91dGlsL3NpZ2NoYWluLmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uNjE4MDgzYmMKLS0tIC9kZXYvbnVsbAorKysgYi90b29scy9wZXJmL3V0aWwvc2lnY2hhaW4uaApAQCAtMCwwICsxLDExIEBACisjaWZuZGVmIFNJR0NIQUlOX0gKKyNkZWZpbmUgU0lHQ0hBSU5fSAorCit0eXBlZGVmIHZvaWQgKCpzaWdjaGFpbl9mdW4pKGludCk7CisKK2ludCBzaWdjaGFpbl9wdXNoKGludCBzaWcsIHNpZ2NoYWluX2Z1biBmKTsKK2ludCBzaWdjaGFpbl9wb3AoaW50IHNpZyk7CisKK3ZvaWQgc2lnY2hhaW5fcHVzaF9jb21tb24oc2lnY2hhaW5fZnVuIGYpOworCisjZW5kaWYgLyogU0lHQ0hBSU5fSCAqLwpkaWZmIC0tZ2l0IGEvdG9vbHMvcGVyZi91dGlsL3N0cmJ1Zi5jIGIvdG9vbHMvcGVyZi91dGlsL3N0cmJ1Zi5jCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLmVhYmEwOTMKLS0tIC9kZXYvbnVsbAorKysgYi90b29scy9wZXJmL3V0aWwvc3RyYnVmLmMKQEAgLTAsMCArMSwzNTkgQEAKKyNpbmNsdWRlICJjYWNoZS5oIgorCitpbnQgcHJlZml4Y21wKGNvbnN0IGNoYXIgKnN0ciwgY29uc3QgY2hhciAqcHJlZml4KQoreworCWZvciAoOyA7IHN0cisrLCBwcmVmaXgrKykKKwkJaWYgKCEqcHJlZml4KQorCQkJcmV0dXJuIDA7CisJCWVsc2UgaWYgKCpzdHIgIT0gKnByZWZpeCkKKwkJCXJldHVybiAodW5zaWduZWQgY2hhcikqcHJlZml4IC0gKHVuc2lnbmVkIGNoYXIpKnN0cjsKK30KKworLyoKKyAqIFVzZWQgYXMgdGhlIGRlZmF1bHQgLT5idWYgdmFsdWUsIHNvIHRoYXQgcGVvcGxlIGNhbiBhbHdheXMgYXNzdW1lCisgKiBidWYgaXMgbm9uIE5VTEwgYW5kIC0+YnVmIGlzIE5VTCB0ZXJtaW5hdGVkIGV2ZW4gZm9yIGEgZnJlc2hseQorICogaW5pdGlhbGl6ZWQgc3RyYnVmLgorICovCitjaGFyIHN0cmJ1Zl9zbG9wYnVmWzFdOworCit2b2lkIHN0cmJ1Zl9pbml0KHN0cnVjdCBzdHJidWYgKnNiLCBzaXplX3QgaGludCkKK3sKKwlzYi0+YWxsb2MgPSBzYi0+bGVuID0gMDsKKwlzYi0+YnVmID0gc3RyYnVmX3Nsb3BidWY7CisJaWYgKGhpbnQpCisJCXN0cmJ1Zl9ncm93KHNiLCBoaW50KTsKK30KKwordm9pZCBzdHJidWZfcmVsZWFzZShzdHJ1Y3Qgc3RyYnVmICpzYikKK3sKKwlpZiAoc2ItPmFsbG9jKSB7CisJCWZyZWUoc2ItPmJ1Zik7CisJCXN0cmJ1Zl9pbml0KHNiLCAwKTsKKwl9Cit9CisKK2NoYXIgKnN0cmJ1Zl9kZXRhY2goc3RydWN0IHN0cmJ1ZiAqc2IsIHNpemVfdCAqc3opCit7CisJY2hhciAqcmVzID0gc2ItPmFsbG9jID8gc2ItPmJ1ZiA6IE5VTEw7CisJaWYgKHN6KQorCQkqc3ogPSBzYi0+bGVuOworCXN0cmJ1Zl9pbml0KHNiLCAwKTsKKwlyZXR1cm4gcmVzOworfQorCit2b2lkIHN0cmJ1Zl9hdHRhY2goc3RydWN0IHN0cmJ1ZiAqc2IsIHZvaWQgKmJ1Ziwgc2l6ZV90IGxlbiwgc2l6ZV90IGFsbG9jKQoreworCXN0cmJ1Zl9yZWxlYXNlKHNiKTsKKwlzYi0+YnVmICAgPSBidWY7CisJc2ItPmxlbiAgID0gbGVuOworCXNiLT5hbGxvYyA9IGFsbG9jOworCXN0cmJ1Zl9ncm93KHNiLCAwKTsKKwlzYi0+YnVmW3NiLT5sZW5dID0gJ1wwJzsKK30KKwordm9pZCBzdHJidWZfZ3JvdyhzdHJ1Y3Qgc3RyYnVmICpzYiwgc2l6ZV90IGV4dHJhKQoreworCWlmIChzYi0+bGVuICsgZXh0cmEgKyAxIDw9IHNiLT5sZW4pCisJCWRpZSgieW91IHdhbnQgdG8gdXNlIHdheSB0b28gbXVjaCBtZW1vcnkiKTsKKwlpZiAoIXNiLT5hbGxvYykKKwkJc2ItPmJ1ZiA9IE5VTEw7CisJQUxMT0NfR1JPVyhzYi0+YnVmLCBzYi0+bGVuICsgZXh0cmEgKyAxLCBzYi0+YWxsb2MpOworfQorCit2b2lkIHN0cmJ1Zl90cmltKHN0cnVjdCBzdHJidWYgKnNiKQoreworCWNoYXIgKmIgPSBzYi0+YnVmOworCXdoaWxlIChzYi0+bGVuID4gMCAmJiBpc3NwYWNlKCh1bnNpZ25lZCBjaGFyKXNiLT5idWZbc2ItPmxlbiAtIDFdKSkKKwkJc2ItPmxlbi0tOworCXdoaWxlIChzYi0+bGVuID4gMCAmJiBpc3NwYWNlKCpiKSkgeworCQliKys7CisJCXNiLT5sZW4tLTsKKwl9CisJbWVtbW92ZShzYi0+YnVmLCBiLCBzYi0+bGVuKTsKKwlzYi0+YnVmW3NiLT5sZW5dID0gJ1wwJzsKK30KK3ZvaWQgc3RyYnVmX3J0cmltKHN0cnVjdCBzdHJidWYgKnNiKQoreworCXdoaWxlIChzYi0+bGVuID4gMCAmJiBpc3NwYWNlKCh1bnNpZ25lZCBjaGFyKXNiLT5idWZbc2ItPmxlbiAtIDFdKSkKKwkJc2ItPmxlbi0tOworCXNiLT5idWZbc2ItPmxlbl0gPSAnXDAnOworfQorCit2b2lkIHN0cmJ1Zl9sdHJpbShzdHJ1Y3Qgc3RyYnVmICpzYikKK3sKKwljaGFyICpiID0gc2ItPmJ1ZjsKKwl3aGlsZSAoc2ItPmxlbiA+IDAgJiYgaXNzcGFjZSgqYikpIHsKKwkJYisrOworCQlzYi0+bGVuLS07CisJfQorCW1lbW1vdmUoc2ItPmJ1ZiwgYiwgc2ItPmxlbik7CisJc2ItPmJ1ZltzYi0+bGVuXSA9ICdcMCc7Cit9CisKK3ZvaWQgc3RyYnVmX3RvbG93ZXIoc3RydWN0IHN0cmJ1ZiAqc2IpCit7CisJaW50IGk7CisJZm9yIChpID0gMDsgaSA8IHNiLT5sZW47IGkrKykKKwkJc2ItPmJ1ZltpXSA9IHRvbG93ZXIoc2ItPmJ1ZltpXSk7Cit9CisKK3N0cnVjdCBzdHJidWYgKipzdHJidWZfc3BsaXQoY29uc3Qgc3RydWN0IHN0cmJ1ZiAqc2IsIGludCBkZWxpbSkKK3sKKwlpbnQgYWxsb2MgPSAyLCBwb3MgPSAwOworCWNoYXIgKm4sICpwOworCXN0cnVjdCBzdHJidWYgKipyZXQ7CisJc3RydWN0IHN0cmJ1ZiAqdDsKKworCXJldCA9IGNhbGxvYyhhbGxvYywgc2l6ZW9mKHN0cnVjdCBzdHJidWYgKikpOworCXAgPSBuID0gc2ItPmJ1ZjsKKwl3aGlsZSAobiA8IHNiLT5idWYgKyBzYi0+bGVuKSB7CisJCWludCBsZW47CisJCW4gPSBtZW1jaHIobiwgZGVsaW0sIHNiLT5sZW4gLSAobiAtIHNiLT5idWYpKTsKKwkJaWYgKHBvcyArIDEgPj0gYWxsb2MpIHsKKwkJCWFsbG9jID0gYWxsb2MgKiAyOworCQkJcmV0ID0gcmVhbGxvYyhyZXQsIHNpemVvZihzdHJ1Y3Qgc3RyYnVmICopICogYWxsb2MpOworCQl9CisJCWlmICghbikKKwkJCW4gPSBzYi0+YnVmICsgc2ItPmxlbiAtIDE7CisJCWxlbiA9IG4gLSBwICsgMTsKKwkJdCA9IG1hbGxvYyhzaXplb2Yoc3RydWN0IHN0cmJ1ZikpOworCQlzdHJidWZfaW5pdCh0LCBsZW4pOworCQlzdHJidWZfYWRkKHQsIHAsIGxlbik7CisJCXJldFtwb3NdID0gdDsKKwkJcmV0WysrcG9zXSA9IE5VTEw7CisJCXAgPSArK247CisJfQorCXJldHVybiByZXQ7Cit9CisKK3ZvaWQgc3RyYnVmX2xpc3RfZnJlZShzdHJ1Y3Qgc3RyYnVmICoqc2JzKQoreworCXN0cnVjdCBzdHJidWYgKipzID0gc2JzOworCisJd2hpbGUgKCpzKSB7CisJCXN0cmJ1Zl9yZWxlYXNlKCpzKTsKKwkJZnJlZSgqcysrKTsKKwl9CisJZnJlZShzYnMpOworfQorCitpbnQgc3RyYnVmX2NtcChjb25zdCBzdHJ1Y3Qgc3RyYnVmICphLCBjb25zdCBzdHJ1Y3Qgc3RyYnVmICpiKQoreworCWludCBsZW4gPSBhLT5sZW4gPCBiLT5sZW4gPyBhLT5sZW46IGItPmxlbjsKKwlpbnQgY21wID0gbWVtY21wKGEtPmJ1ZiwgYi0+YnVmLCBsZW4pOworCWlmIChjbXApCisJCXJldHVybiBjbXA7CisJcmV0dXJuIGEtPmxlbiA8IGItPmxlbiA/IC0xOiBhLT5sZW4gIT0gYi0+bGVuOworfQorCit2b2lkIHN0cmJ1Zl9zcGxpY2Uoc3RydWN0IHN0cmJ1ZiAqc2IsIHNpemVfdCBwb3MsIHNpemVfdCBsZW4sCisJCQkJICAgY29uc3Qgdm9pZCAqZGF0YSwgc2l6ZV90IGRsZW4pCit7CisJaWYgKHBvcyArIGxlbiA8IHBvcykKKwkJZGllKCJ5b3Ugd2FudCB0byB1c2Ugd2F5IHRvbyBtdWNoIG1lbW9yeSIpOworCWlmIChwb3MgPiBzYi0+bGVuKQorCQlkaWUoImBwb3MnIGlzIHRvbyBmYXIgYWZ0ZXIgdGhlIGVuZCBvZiB0aGUgYnVmZmVyIik7CisJaWYgKHBvcyArIGxlbiA+IHNiLT5sZW4pCisJCWRpZSgiYHBvcyArIGxlbicgaXMgdG9vIGZhciBhZnRlciB0aGUgZW5kIG9mIHRoZSBidWZmZXIiKTsKKworCWlmIChkbGVuID49IGxlbikKKwkJc3RyYnVmX2dyb3coc2IsIGRsZW4gLSBsZW4pOworCW1lbW1vdmUoc2ItPmJ1ZiArIHBvcyArIGRsZW4sCisJCQlzYi0+YnVmICsgcG9zICsgbGVuLAorCQkJc2ItPmxlbiAtIHBvcyAtIGxlbik7CisJbWVtY3B5KHNiLT5idWYgKyBwb3MsIGRhdGEsIGRsZW4pOworCXN0cmJ1Zl9zZXRsZW4oc2IsIHNiLT5sZW4gKyBkbGVuIC0gbGVuKTsKK30KKwordm9pZCBzdHJidWZfaW5zZXJ0KHN0cnVjdCBzdHJidWYgKnNiLCBzaXplX3QgcG9zLCBjb25zdCB2b2lkICpkYXRhLCBzaXplX3QgbGVuKQoreworCXN0cmJ1Zl9zcGxpY2Uoc2IsIHBvcywgMCwgZGF0YSwgbGVuKTsKK30KKwordm9pZCBzdHJidWZfcmVtb3ZlKHN0cnVjdCBzdHJidWYgKnNiLCBzaXplX3QgcG9zLCBzaXplX3QgbGVuKQoreworCXN0cmJ1Zl9zcGxpY2Uoc2IsIHBvcywgbGVuLCBOVUxMLCAwKTsKK30KKwordm9pZCBzdHJidWZfYWRkKHN0cnVjdCBzdHJidWYgKnNiLCBjb25zdCB2b2lkICpkYXRhLCBzaXplX3QgbGVuKQoreworCXN0cmJ1Zl9ncm93KHNiLCBsZW4pOworCW1lbWNweShzYi0+YnVmICsgc2ItPmxlbiwgZGF0YSwgbGVuKTsKKwlzdHJidWZfc2V0bGVuKHNiLCBzYi0+bGVuICsgbGVuKTsKK30KKwordm9pZCBzdHJidWZfYWRkZHVwKHN0cnVjdCBzdHJidWYgKnNiLCBzaXplX3QgcG9zLCBzaXplX3QgbGVuKQoreworCXN0cmJ1Zl9ncm93KHNiLCBsZW4pOworCW1lbWNweShzYi0+YnVmICsgc2ItPmxlbiwgc2ItPmJ1ZiArIHBvcywgbGVuKTsKKwlzdHJidWZfc2V0bGVuKHNiLCBzYi0+bGVuICsgbGVuKTsKK30KKwordm9pZCBzdHJidWZfYWRkZihzdHJ1Y3Qgc3RyYnVmICpzYiwgY29uc3QgY2hhciAqZm10LCAuLi4pCit7CisJaW50IGxlbjsKKwl2YV9saXN0IGFwOworCisJaWYgKCFzdHJidWZfYXZhaWwoc2IpKQorCQlzdHJidWZfZ3JvdyhzYiwgNjQpOworCXZhX3N0YXJ0KGFwLCBmbXQpOworCWxlbiA9IHZzbnByaW50ZihzYi0+YnVmICsgc2ItPmxlbiwgc2ItPmFsbG9jIC0gc2ItPmxlbiwgZm10LCBhcCk7CisJdmFfZW5kKGFwKTsKKwlpZiAobGVuIDwgMCkKKwkJZGllKCJ5b3VyIHZzbnByaW50ZiBpcyBicm9rZW4iKTsKKwlpZiAobGVuID4gc3RyYnVmX2F2YWlsKHNiKSkgeworCQlzdHJidWZfZ3JvdyhzYiwgbGVuKTsKKwkJdmFfc3RhcnQoYXAsIGZtdCk7CisJCWxlbiA9IHZzbnByaW50ZihzYi0+YnVmICsgc2ItPmxlbiwgc2ItPmFsbG9jIC0gc2ItPmxlbiwgZm10LCBhcCk7CisJCXZhX2VuZChhcCk7CisJCWlmIChsZW4gPiBzdHJidWZfYXZhaWwoc2IpKSB7CisJCQlkaWUoInRoaXMgc2hvdWxkIG5vdCBoYXBwZW4sIHlvdXIgc25wcmludGYgaXMgYnJva2VuIik7CisJCX0KKwl9CisJc3RyYnVmX3NldGxlbihzYiwgc2ItPmxlbiArIGxlbik7Cit9CisKK3ZvaWQgc3RyYnVmX2V4cGFuZChzdHJ1Y3Qgc3RyYnVmICpzYiwgY29uc3QgY2hhciAqZm9ybWF0LCBleHBhbmRfZm5fdCBmbiwKKwkJICAgdm9pZCAqY29udGV4dCkKK3sKKwlmb3IgKDs7KSB7CisJCWNvbnN0IGNoYXIgKnBlcmNlbnQ7CisJCXNpemVfdCBjb25zdW1lZDsKKworCQlwZXJjZW50ID0gc3RyY2hybnVsKGZvcm1hdCwgJyUnKTsKKwkJc3RyYnVmX2FkZChzYiwgZm9ybWF0LCBwZXJjZW50IC0gZm9ybWF0KTsKKwkJaWYgKCEqcGVyY2VudCkKKwkJCWJyZWFrOworCQlmb3JtYXQgPSBwZXJjZW50ICsgMTsKKworCQljb25zdW1lZCA9IGZuKHNiLCBmb3JtYXQsIGNvbnRleHQpOworCQlpZiAoY29uc3VtZWQpCisJCQlmb3JtYXQgKz0gY29uc3VtZWQ7CisJCWVsc2UKKwkJCXN0cmJ1Zl9hZGRjaChzYiwgJyUnKTsKKwl9Cit9CisKK3NpemVfdCBzdHJidWZfZXhwYW5kX2RpY3RfY2Ioc3RydWN0IHN0cmJ1ZiAqc2IsIGNvbnN0IGNoYXIgKnBsYWNlaG9sZGVyLAorCQl2b2lkICpjb250ZXh0KQoreworCXN0cnVjdCBzdHJidWZfZXhwYW5kX2RpY3RfZW50cnkgKmUgPSBjb250ZXh0OworCXNpemVfdCBsZW47CisKKwlmb3IgKDsgZS0+cGxhY2Vob2xkZXIgJiYgKGxlbiA9IHN0cmxlbihlLT5wbGFjZWhvbGRlcikpOyBlKyspIHsKKwkJaWYgKCFzdHJuY21wKHBsYWNlaG9sZGVyLCBlLT5wbGFjZWhvbGRlciwgbGVuKSkgeworCQkJaWYgKGUtPnZhbHVlKQorCQkJCXN0cmJ1Zl9hZGRzdHIoc2IsIGUtPnZhbHVlKTsKKwkJCXJldHVybiBsZW47CisJCX0KKwl9CisJcmV0dXJuIDA7Cit9CisKK3NpemVfdCBzdHJidWZfZnJlYWQoc3RydWN0IHN0cmJ1ZiAqc2IsIHNpemVfdCBzaXplLCBGSUxFICpmKQoreworCXNpemVfdCByZXM7CisJc2l6ZV90IG9sZGFsbG9jID0gc2ItPmFsbG9jOworCisJc3RyYnVmX2dyb3coc2IsIHNpemUpOworCXJlcyA9IGZyZWFkKHNiLT5idWYgKyBzYi0+bGVuLCAxLCBzaXplLCBmKTsKKwlpZiAocmVzID4gMCkKKwkJc3RyYnVmX3NldGxlbihzYiwgc2ItPmxlbiArIHJlcyk7CisJZWxzZSBpZiAocmVzIDwgMCAmJiBvbGRhbGxvYyA9PSAwKQorCQlzdHJidWZfcmVsZWFzZShzYik7CisJcmV0dXJuIHJlczsKK30KKworc3NpemVfdCBzdHJidWZfcmVhZChzdHJ1Y3Qgc3RyYnVmICpzYiwgaW50IGZkLCBzaXplX3QgaGludCkKK3sKKwlzaXplX3Qgb2xkbGVuID0gc2ItPmxlbjsKKwlzaXplX3Qgb2xkYWxsb2MgPSBzYi0+YWxsb2M7CisKKwlzdHJidWZfZ3JvdyhzYiwgaGludCA/IGhpbnQgOiA4MTkyKTsKKwlmb3IgKDs7KSB7CisJCXNzaXplX3QgY250OworCisJCWNudCA9IHJlYWQoZmQsIHNiLT5idWYgKyBzYi0+bGVuLCBzYi0+YWxsb2MgLSBzYi0+bGVuIC0gMSk7CisJCWlmIChjbnQgPCAwKSB7CisJCQlpZiAob2xkYWxsb2MgPT0gMCkKKwkJCQlzdHJidWZfcmVsZWFzZShzYik7CisJCQllbHNlCisJCQkJc3RyYnVmX3NldGxlbihzYiwgb2xkbGVuKTsKKwkJCXJldHVybiAtMTsKKwkJfQorCQlpZiAoIWNudCkKKwkJCWJyZWFrOworCQlzYi0+bGVuICs9IGNudDsKKwkJc3RyYnVmX2dyb3coc2IsIDgxOTIpOworCX0KKworCXNiLT5idWZbc2ItPmxlbl0gPSAnXDAnOworCXJldHVybiBzYi0+bGVuIC0gb2xkbGVuOworfQorCisjZGVmaW5lIFNUUkJVRl9NQVhMSU5LICgyKlBBVEhfTUFYKQorCitpbnQgc3RyYnVmX3JlYWRsaW5rKHN0cnVjdCBzdHJidWYgKnNiLCBjb25zdCBjaGFyICpwYXRoLCBzaXplX3QgaGludCkKK3sKKwlzaXplX3Qgb2xkYWxsb2MgPSBzYi0+YWxsb2M7CisKKwlpZiAoaGludCA8IDMyKQorCQloaW50ID0gMzI7CisKKwl3aGlsZSAoaGludCA8IFNUUkJVRl9NQVhMSU5LKSB7CisJCWludCBsZW47CisKKwkJc3RyYnVmX2dyb3coc2IsIGhpbnQpOworCQlsZW4gPSByZWFkbGluayhwYXRoLCBzYi0+YnVmLCBoaW50KTsKKwkJaWYgKGxlbiA8IDApIHsKKwkJCWlmIChlcnJubyAhPSBFUkFOR0UpCisJCQkJYnJlYWs7CisJCX0gZWxzZSBpZiAobGVuIDwgaGludCkgeworCQkJc3RyYnVmX3NldGxlbihzYiwgbGVuKTsKKwkJCXJldHVybiAwOworCQl9CisKKwkJLyogLi4gdGhlIGJ1ZmZlciB3YXMgdG9vIHNtYWxsIC0gdHJ5IGFnYWluICovCisJCWhpbnQgKj0gMjsKKwl9CisJaWYgKG9sZGFsbG9jID09IDApCisJCXN0cmJ1Zl9yZWxlYXNlKHNiKTsKKwlyZXR1cm4gLTE7Cit9CisKK2ludCBzdHJidWZfZ2V0bGluZShzdHJ1Y3Qgc3RyYnVmICpzYiwgRklMRSAqZnAsIGludCB0ZXJtKQoreworCWludCBjaDsKKworCXN0cmJ1Zl9ncm93KHNiLCAwKTsKKwlpZiAoZmVvZihmcCkpCisJCXJldHVybiBFT0Y7CisKKwlzdHJidWZfcmVzZXQoc2IpOworCXdoaWxlICgoY2ggPSBmZ2V0YyhmcCkpICE9IEVPRikgeworCQlpZiAoY2ggPT0gdGVybSkKKwkJCWJyZWFrOworCQlzdHJidWZfZ3JvdyhzYiwgMSk7CisJCXNiLT5idWZbc2ItPmxlbisrXSA9IGNoOworCX0KKwlpZiAoY2ggPT0gRU9GICYmIHNiLT5sZW4gPT0gMCkKKwkJcmV0dXJuIEVPRjsKKworCXNiLT5idWZbc2ItPmxlbl0gPSAnXDAnOworCXJldHVybiAwOworfQorCitpbnQgc3RyYnVmX3JlYWRfZmlsZShzdHJ1Y3Qgc3RyYnVmICpzYiwgY29uc3QgY2hhciAqcGF0aCwgc2l6ZV90IGhpbnQpCit7CisJaW50IGZkLCBsZW47CisKKwlmZCA9IG9wZW4ocGF0aCwgT19SRE9OTFkpOworCWlmIChmZCA8IDApCisJCXJldHVybiAtMTsKKwlsZW4gPSBzdHJidWZfcmVhZChzYiwgZmQsIGhpbnQpOworCWNsb3NlKGZkKTsKKwlpZiAobGVuIDwgMCkKKwkJcmV0dXJuIC0xOworCisJcmV0dXJuIGxlbjsKK30KZGlmZiAtLWdpdCBhL3Rvb2xzL3BlcmYvdXRpbC9zdHJidWYuaCBiL3Rvb2xzL3BlcmYvdXRpbC9zdHJidWYuaApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi45ZWU5MDhhCi0tLSAvZGV2L251bGwKKysrIGIvdG9vbHMvcGVyZi91dGlsL3N0cmJ1Zi5oCkBAIC0wLDAgKzEsMTM3IEBACisjaWZuZGVmIFNUUkJVRl9ICisjZGVmaW5lIFNUUkJVRl9ICisKKy8qCisgKiBTdHJidWYncyBjYW4gYmUgdXNlIGluIG1hbnkgd2F5czogYXMgYSBieXRlIGFycmF5LCBvciB0byBzdG9yZSBhcmJpdHJhcnkKKyAqIGxvbmcsIG92ZXJmbG93IHNhZmUgc3RyaW5ncy4KKyAqCisgKiBTdHJidWZzIGhhcyBzb21lIGludmFyaWFudHMgdGhhdCBhcmUgdmVyeSBpbXBvcnRhbnQgdG8ga2VlcCBpbiBtaW5kOgorICoKKyAqIDEuIHRoZSAtPmJ1ZiBtZW1iZXIgaXMgYWx3YXlzIG1hbGxvYy1lZCwgaGVuY2Ugc3RyYnVmJ3MgY2FuIGJlIHVzZWQgdG8KKyAqICAgIGJ1aWxkIGNvbXBsZXggc3RyaW5ncy9idWZmZXJzIHdob3NlIGZpbmFsIHNpemUgaXNuJ3QgZWFzaWx5IGtub3duLgorICoKKyAqICAgIEl0IGlzIE5PVCBsZWdhbCB0byBjb3B5IHRoZSAtPmJ1ZiBwb2ludGVyIGF3YXkuCisgKiAgICBgc3RyYnVmX2RldGFjaCcgaXMgdGhlIG9wZXJhdGlvbiB0aGF0IGRldGFjaHMgYSBidWZmZXIgZnJvbSBpdHMgc2hlbGwKKyAqICAgIHdoaWxlIGtlZXBpbmcgdGhlIHNoZWxsIHZhbGlkIHdydCBpdHMgaW52YXJpYW50cy4KKyAqCisgKiAyLiB0aGUgLT5idWYgbWVtYmVyIGlzIGEgYnl0ZSBhcnJheSB0aGF0IGhhcyBhdCBsZWFzdCAtPmxlbiArIDEgYnl0ZXMKKyAqICAgIGFsbG9jYXRlZC4gVGhlIGV4dHJhIGJ5dGUgaXMgdXNlZCB0byBzdG9yZSBhICdcMCcsIGFsbG93aW5nIHRoZSAtPmJ1ZgorICogICAgbWVtYmVyIHRvIGJlIGEgdmFsaWQgQy1zdHJpbmcuIEV2ZXJ5IHN0cmJ1ZiBmdW5jdGlvbiBlbnN1cmUgdGhpcworICogICAgaW52YXJpYW50IGlzIHByZXNlcnZlZC4KKyAqCisgKiAgICBOb3RlIHRoYXQgaXQgaXMgT0sgdG8gInBsYXkiIHdpdGggdGhlIGJ1ZmZlciBkaXJlY3RseSBpZiB5b3Ugd29yayBpdAorICogICAgdGhhdCB3YXk6CisgKgorICogICAgc3RyYnVmX2dyb3coc2IsIFNPTUVfU0laRSk7CisgKiAgICAgICAuLi4gSGVyZSwgdGhlIG1lbW9yeSBhcnJheSBzdGFydGluZyBhdCBzYi0+YnVmLCBhbmQgb2YgbGVuZ3RoCisgKiAgICAgICAuLi4gc3RyYnVmX2F2YWlsKHNiKSBpcyBhbGwgeW91cnMsIGFuZCB5b3UgYXJlIHN1cmUgdGhhdAorICogICAgICAgLi4uIHN0cmJ1Zl9hdmFpbChzYikgaXMgYXQgbGVhc3QgU09NRV9TSVpFLgorICogICAgc3RyYnVmX3NldGxlbihzYiwgc2ItPmxlbiArIFNPTUVfT1RIRVJfU0laRSk7CisgKgorICogICAgT2YgY291cnNlLCBTT01FX09USEVSX1NJWkUgbXVzdCBiZSBzbWFsbGVyIG9yIGVxdWFsIHRvIHN0cmJ1Zl9hdmFpbChzYikuCisgKgorICogICAgRG9pbmcgc28gaXMgc2FmZSwgdGhvdWdoIGlmIGl0IGhhcyB0byBiZSBkb25lIGluIG1hbnkgcGxhY2VzLCBhZGRpbmcgdGhlCisgKiAgICBtaXNzaW5nIEFQSSB0byB0aGUgc3RyYnVmIG1vZHVsZSBpcyB0aGUgd2F5IHRvIGdvLgorICoKKyAqICAgIFhYWDogZG8gX25vdF8gYXNzdW1lIHRoYXQgdGhlIGFyZWEgdGhhdCBpcyB5b3VycyBpcyBvZiBzaXplIC0+YWxsb2MgLSAxCisgKiAgICAgICAgIGV2ZW4gaWYgaXQncyB0cnVlIGluIHRoZSBjdXJyZW50IGltcGxlbWVudGF0aW9uLiBBbGxvYyBpcyBzb21laG93IGEKKyAqICAgICAgICAgInByaXZhdGUiIG1lbWJlciB0aGF0IHNob3VsZCBub3QgYmUgbWVzc2VkIHdpdGguCisgKi8KKworI2luY2x1ZGUgPGFzc2VydC5oPgorCitleHRlcm4gY2hhciBzdHJidWZfc2xvcGJ1ZltdOworc3RydWN0IHN0cmJ1ZiB7CisJc2l6ZV90IGFsbG9jOworCXNpemVfdCBsZW47CisJY2hhciAqYnVmOworfTsKKworI2RlZmluZSBTVFJCVUZfSU5JVCAgeyAwLCAwLCBzdHJidWZfc2xvcGJ1ZiB9CisKKy8qLS0tLS0gc3RyYnVmIGxpZmUgY3ljbGUgLS0tLS0qLworZXh0ZXJuIHZvaWQgc3RyYnVmX2luaXQoc3RydWN0IHN0cmJ1ZiAqLCBzaXplX3QpOworZXh0ZXJuIHZvaWQgc3RyYnVmX3JlbGVhc2Uoc3RydWN0IHN0cmJ1ZiAqKTsKK2V4dGVybiBjaGFyICpzdHJidWZfZGV0YWNoKHN0cnVjdCBzdHJidWYgKiwgc2l6ZV90ICopOworZXh0ZXJuIHZvaWQgc3RyYnVmX2F0dGFjaChzdHJ1Y3Qgc3RyYnVmICosIHZvaWQgKiwgc2l6ZV90LCBzaXplX3QpOworc3RhdGljIGlubGluZSB2b2lkIHN0cmJ1Zl9zd2FwKHN0cnVjdCBzdHJidWYgKmEsIHN0cnVjdCBzdHJidWYgKmIpIHsKKwlzdHJ1Y3Qgc3RyYnVmIHRtcCA9ICphOworCSphID0gKmI7CisJKmIgPSB0bXA7Cit9CisKKy8qLS0tLS0gc3RyYnVmIHNpemUgcmVsYXRlZCAtLS0tLSovCitzdGF0aWMgaW5saW5lIHNpemVfdCBzdHJidWZfYXZhaWwoY29uc3Qgc3RydWN0IHN0cmJ1ZiAqc2IpIHsKKwlyZXR1cm4gc2ItPmFsbG9jID8gc2ItPmFsbG9jIC0gc2ItPmxlbiAtIDEgOiAwOworfQorCitleHRlcm4gdm9pZCBzdHJidWZfZ3JvdyhzdHJ1Y3Qgc3RyYnVmICosIHNpemVfdCk7CisKK3N0YXRpYyBpbmxpbmUgdm9pZCBzdHJidWZfc2V0bGVuKHN0cnVjdCBzdHJidWYgKnNiLCBzaXplX3QgbGVuKSB7CisJaWYgKCFzYi0+YWxsb2MpCisJCXN0cmJ1Zl9ncm93KHNiLCAwKTsKKwlhc3NlcnQobGVuIDwgc2ItPmFsbG9jKTsKKwlzYi0+bGVuID0gbGVuOworCXNiLT5idWZbbGVuXSA9ICdcMCc7Cit9CisjZGVmaW5lIHN0cmJ1Zl9yZXNldChzYikgIHN0cmJ1Zl9zZXRsZW4oc2IsIDApCisKKy8qLS0tLS0gY29udGVudCByZWxhdGVkIC0tLS0tKi8KK2V4dGVybiB2b2lkIHN0cmJ1Zl90cmltKHN0cnVjdCBzdHJidWYgKik7CitleHRlcm4gdm9pZCBzdHJidWZfcnRyaW0oc3RydWN0IHN0cmJ1ZiAqKTsKK2V4dGVybiB2b2lkIHN0cmJ1Zl9sdHJpbShzdHJ1Y3Qgc3RyYnVmICopOworZXh0ZXJuIGludCBzdHJidWZfY21wKGNvbnN0IHN0cnVjdCBzdHJidWYgKiwgY29uc3Qgc3RydWN0IHN0cmJ1ZiAqKTsKK2V4dGVybiB2b2lkIHN0cmJ1Zl90b2xvd2VyKHN0cnVjdCBzdHJidWYgKik7CisKK2V4dGVybiBzdHJ1Y3Qgc3RyYnVmICoqc3RyYnVmX3NwbGl0KGNvbnN0IHN0cnVjdCBzdHJidWYgKiwgaW50IGRlbGltKTsKK2V4dGVybiB2b2lkIHN0cmJ1Zl9saXN0X2ZyZWUoc3RydWN0IHN0cmJ1ZiAqKik7CisKKy8qLS0tLS0gYWRkIGRhdGEgaW4geW91ciBidWZmZXIgLS0tLS0qLworc3RhdGljIGlubGluZSB2b2lkIHN0cmJ1Zl9hZGRjaChzdHJ1Y3Qgc3RyYnVmICpzYiwgaW50IGMpIHsKKwlzdHJidWZfZ3JvdyhzYiwgMSk7CisJc2ItPmJ1ZltzYi0+bGVuKytdID0gYzsKKwlzYi0+YnVmW3NiLT5sZW5dID0gJ1wwJzsKK30KKworZXh0ZXJuIHZvaWQgc3RyYnVmX2luc2VydChzdHJ1Y3Qgc3RyYnVmICosIHNpemVfdCBwb3MsIGNvbnN0IHZvaWQgKiwgc2l6ZV90KTsKK2V4dGVybiB2b2lkIHN0cmJ1Zl9yZW1vdmUoc3RydWN0IHN0cmJ1ZiAqLCBzaXplX3QgcG9zLCBzaXplX3QgbGVuKTsKKworLyogc3BsaWNlIHBvcy4ucG9zK2xlbiB3aXRoIGdpdmVuIGRhdGEgKi8KK2V4dGVybiB2b2lkIHN0cmJ1Zl9zcGxpY2Uoc3RydWN0IHN0cmJ1ZiAqLCBzaXplX3QgcG9zLCBzaXplX3QgbGVuLAorICAgICAgICAgICAgICAgICAgICAgICAgICBjb25zdCB2b2lkICosIHNpemVfdCk7CisKK2V4dGVybiB2b2lkIHN0cmJ1Zl9hZGQoc3RydWN0IHN0cmJ1ZiAqLCBjb25zdCB2b2lkICosIHNpemVfdCk7CitzdGF0aWMgaW5saW5lIHZvaWQgc3RyYnVmX2FkZHN0cihzdHJ1Y3Qgc3RyYnVmICpzYiwgY29uc3QgY2hhciAqcykgeworCXN0cmJ1Zl9hZGQoc2IsIHMsIHN0cmxlbihzKSk7Cit9CitzdGF0aWMgaW5saW5lIHZvaWQgc3RyYnVmX2FkZGJ1ZihzdHJ1Y3Qgc3RyYnVmICpzYiwgY29uc3Qgc3RydWN0IHN0cmJ1ZiAqc2IyKSB7CisJc3RyYnVmX2FkZChzYiwgc2IyLT5idWYsIHNiMi0+bGVuKTsKK30KK2V4dGVybiB2b2lkIHN0cmJ1Zl9hZGRkdXAoc3RydWN0IHN0cmJ1ZiAqc2IsIHNpemVfdCBwb3MsIHNpemVfdCBsZW4pOworCit0eXBlZGVmIHNpemVfdCAoKmV4cGFuZF9mbl90KSAoc3RydWN0IHN0cmJ1ZiAqc2IsIGNvbnN0IGNoYXIgKnBsYWNlaG9sZGVyLCB2b2lkICpjb250ZXh0KTsKK2V4dGVybiB2b2lkIHN0cmJ1Zl9leHBhbmQoc3RydWN0IHN0cmJ1ZiAqc2IsIGNvbnN0IGNoYXIgKmZvcm1hdCwgZXhwYW5kX2ZuX3QgZm4sIHZvaWQgKmNvbnRleHQpOworc3RydWN0IHN0cmJ1Zl9leHBhbmRfZGljdF9lbnRyeSB7CisJY29uc3QgY2hhciAqcGxhY2Vob2xkZXI7CisJY29uc3QgY2hhciAqdmFsdWU7Cit9OworZXh0ZXJuIHNpemVfdCBzdHJidWZfZXhwYW5kX2RpY3RfY2Ioc3RydWN0IHN0cmJ1ZiAqc2IsIGNvbnN0IGNoYXIgKnBsYWNlaG9sZGVyLCB2b2lkICpjb250ZXh0KTsKKworX19hdHRyaWJ1dGVfXygoZm9ybWF0KHByaW50ZiwyLDMpKSkKK2V4dGVybiB2b2lkIHN0cmJ1Zl9hZGRmKHN0cnVjdCBzdHJidWYgKnNiLCBjb25zdCBjaGFyICpmbXQsIC4uLik7CisKK2V4dGVybiBzaXplX3Qgc3RyYnVmX2ZyZWFkKHN0cnVjdCBzdHJidWYgKiwgc2l6ZV90LCBGSUxFICopOworLyogWFhYOiBpZiByZWFkIGZhaWxzLCBhbnkgcGFydGlhbCByZWFkIGlzIHVuZG9uZSAqLworZXh0ZXJuIHNzaXplX3Qgc3RyYnVmX3JlYWQoc3RydWN0IHN0cmJ1ZiAqLCBpbnQgZmQsIHNpemVfdCBoaW50KTsKK2V4dGVybiBpbnQgc3RyYnVmX3JlYWRfZmlsZShzdHJ1Y3Qgc3RyYnVmICpzYiwgY29uc3QgY2hhciAqcGF0aCwgc2l6ZV90IGhpbnQpOworZXh0ZXJuIGludCBzdHJidWZfcmVhZGxpbmsoc3RydWN0IHN0cmJ1ZiAqc2IsIGNvbnN0IGNoYXIgKnBhdGgsIHNpemVfdCBoaW50KTsKKworZXh0ZXJuIGludCBzdHJidWZfZ2V0bGluZShzdHJ1Y3Qgc3RyYnVmICosIEZJTEUgKiwgaW50KTsKKworZXh0ZXJuIHZvaWQgc3RyaXBzcGFjZShzdHJ1Y3Qgc3RyYnVmICpidWYsIGludCBza2lwX2NvbW1lbnRzKTsKK2V4dGVybiBpbnQgbGF1bmNoX2VkaXRvcihjb25zdCBjaGFyICpwYXRoLCBzdHJ1Y3Qgc3RyYnVmICpidWZmZXIsIGNvbnN0IGNoYXIgKmNvbnN0ICplbnYpOworCitleHRlcm4gaW50IHN0cmJ1Zl9icmFuY2huYW1lKHN0cnVjdCBzdHJidWYgKnNiLCBjb25zdCBjaGFyICpuYW1lKTsKK2V4dGVybiBpbnQgc3RyYnVmX2NoZWNrX2JyYW5jaF9yZWYoc3RydWN0IHN0cmJ1ZiAqc2IsIGNvbnN0IGNoYXIgKm5hbWUpOworCisjZW5kaWYgLyogU1RSQlVGX0ggKi8KZGlmZiAtLWdpdCBhL3Rvb2xzL3BlcmYvdXRpbC9zdHJpbmcuYyBiL3Rvb2xzL3BlcmYvdXRpbC9zdHJpbmcuYwpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi5lYzMzYzBjCi0tLSAvZGV2L251bGwKKysrIGIvdG9vbHMvcGVyZi91dGlsL3N0cmluZy5jCkBAIC0wLDAgKzEsMzQgQEAKKyNpbmNsdWRlICJzdHJpbmcuaCIKKworc3RhdGljIGludCBoZXgoY2hhciBjaCkKK3sKKwlpZiAoKGNoID49ICcwJykgJiYgKGNoIDw9ICc5JykpCisJCXJldHVybiBjaCAtICcwJzsKKwlpZiAoKGNoID49ICdhJykgJiYgKGNoIDw9ICdmJykpCisJCXJldHVybiBjaCAtICdhJyArIDEwOworCWlmICgoY2ggPj0gJ0EnKSAmJiAoY2ggPD0gJ0YnKSkKKwkJcmV0dXJuIGNoIC0gJ0EnICsgMTA7CisJcmV0dXJuIC0xOworfQorCisvKgorICogV2hpbGUgd2UgZmluZCBuaWNlIGhleCBjaGFycywgYnVpbGQgYSBsb25nX3ZhbC4KKyAqIFJldHVybiBudW1iZXIgb2YgY2hhcnMgcHJvY2Vzc2VkLgorICovCitpbnQgaGV4MnU2NChjb25zdCBjaGFyICpwdHIsIF9fdTY0ICpsb25nX3ZhbCkKK3sKKwljb25zdCBjaGFyICpwID0gcHRyOworCSpsb25nX3ZhbCA9IDA7CisKKwl3aGlsZSAoKnApIHsKKwkJY29uc3QgaW50IGhleF92YWwgPSBoZXgoKnApOworCisJCWlmIChoZXhfdmFsIDwgMCkKKwkJCWJyZWFrOworCisJCSpsb25nX3ZhbCA9ICgqbG9uZ192YWwgPDwgNCkgfCBoZXhfdmFsOworCQlwKys7CisJfQorCisJcmV0dXJuIHAgLSBwdHI7Cit9CmRpZmYgLS1naXQgYS90b29scy9wZXJmL3V0aWwvc3RyaW5nLmggYi90b29scy9wZXJmL3V0aWwvc3RyaW5nLmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uNzI4MTJjMQotLS0gL2Rldi9udWxsCisrKyBiL3Rvb2xzL3BlcmYvdXRpbC9zdHJpbmcuaApAQCAtMCwwICsxLDggQEAKKyNpZm5kZWYgX1BFUkZfU1RSSU5HX0hfCisjZGVmaW5lIF9QRVJGX1NUUklOR19IXworCisjaW5jbHVkZSA8bGludXgvdHlwZXMuaD4KKworaW50IGhleDJ1NjQoY29uc3QgY2hhciAqcHRyLCBfX3U2NCAqdmFsKTsKKworI2VuZGlmCmRpZmYgLS1naXQgYS90b29scy9wZXJmL3V0aWwvc3ltYm9sLmMgYi90b29scy9wZXJmL3V0aWwvc3ltYm9sLmMKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uNDlhNTVmOAotLS0gL2Rldi9udWxsCisrKyBiL3Rvb2xzL3BlcmYvdXRpbC9zeW1ib2wuYwpAQCAtMCwwICsxLDY0MSBAQAorI2luY2x1ZGUgInV0aWwuaCIKKyNpbmNsdWRlICIuLi9wZXJmLmgiCisjaW5jbHVkZSAic3RyaW5nLmgiCisjaW5jbHVkZSAic3ltYm9sLmgiCisKKyNpbmNsdWRlIDxsaWJlbGYuaD4KKyNpbmNsdWRlIDxnZWxmLmg+CisjaW5jbHVkZSA8ZWxmLmg+CisKK2NvbnN0IGNoYXIgKnN5bV9oaXN0X2ZpbHRlcjsKKworc3RhdGljIHN0cnVjdCBzeW1ib2wgKnN5bWJvbF9fbmV3KF9fdTY0IHN0YXJ0LCBfX3U2NCBsZW4sCisJCQkJICBjb25zdCBjaGFyICpuYW1lLCB1bnNpZ25lZCBpbnQgcHJpdl9zaXplLAorCQkJCSAgX191NjQgb2JqX3N0YXJ0LCBpbnQgdmVyYm9zZSkKK3sKKwlzaXplX3QgbmFtZWxlbiA9IHN0cmxlbihuYW1lKSArIDE7CisJc3RydWN0IHN5bWJvbCAqc2VsZiA9IGNhbGxvYygxLCBwcml2X3NpemUgKyBzaXplb2YoKnNlbGYpICsgbmFtZWxlbik7CisKKwlpZiAoIXNlbGYpCisJCXJldHVybiBOVUxMOworCisJaWYgKHZlcmJvc2UgPj0gMikKKwkJcHJpbnRmKCJuZXcgc3ltYm9sOiAlMDE2THggWyUwOGx4XTogJXMsIGhpc3Q6ICVwLCBvYmpfc3RhcnQ6ICVwXG4iLAorCQkJKF9fdTY0KXN0YXJ0LCAodW5zaWduZWQgbG9uZylsZW4sIG5hbWUsIHNlbGYtPmhpc3QsICh2b2lkICopKHVuc2lnbmVkIGxvbmcpb2JqX3N0YXJ0KTsKKworCXNlbGYtPm9ial9zdGFydD0gb2JqX3N0YXJ0OworCXNlbGYtPmhpc3QgPSBOVUxMOworCXNlbGYtPmhpc3Rfc3VtID0gMDsKKworCWlmIChzeW1faGlzdF9maWx0ZXIgJiYgIXN0cmNtcChuYW1lLCBzeW1faGlzdF9maWx0ZXIpKQorCQlzZWxmLT5oaXN0ID0gY2FsbG9jKHNpemVvZihfX3U2NCksIGxlbik7CisKKwlpZiAocHJpdl9zaXplKSB7CisJCW1lbXNldChzZWxmLCAwLCBwcml2X3NpemUpOworCQlzZWxmID0gKCh2b2lkICopc2VsZikgKyBwcml2X3NpemU7CisJfQorCXNlbGYtPnN0YXJ0ID0gc3RhcnQ7CisJc2VsZi0+ZW5kICAgPSBzdGFydCArIGxlbiAtIDE7CisJbWVtY3B5KHNlbGYtPm5hbWUsIG5hbWUsIG5hbWVsZW4pOworCisJcmV0dXJuIHNlbGY7Cit9CisKK3N0YXRpYyB2b2lkIHN5bWJvbF9fZGVsZXRlKHN0cnVjdCBzeW1ib2wgKnNlbGYsIHVuc2lnbmVkIGludCBwcml2X3NpemUpCit7CisJZnJlZSgoKHZvaWQgKilzZWxmKSAtIHByaXZfc2l6ZSk7Cit9CisKK3N0YXRpYyBzaXplX3Qgc3ltYm9sX19mcHJpbnRmKHN0cnVjdCBzeW1ib2wgKnNlbGYsIEZJTEUgKmZwKQoreworCXJldHVybiBmcHJpbnRmKGZwLCAiICVsbHgtJWxseCAlc1xuIiwKKwkJICAgICAgIHNlbGYtPnN0YXJ0LCBzZWxmLT5lbmQsIHNlbGYtPm5hbWUpOworfQorCitzdHJ1Y3QgZHNvICpkc29fX25ldyhjb25zdCBjaGFyICpuYW1lLCB1bnNpZ25lZCBpbnQgc3ltX3ByaXZfc2l6ZSkKK3sKKwlzdHJ1Y3QgZHNvICpzZWxmID0gbWFsbG9jKHNpemVvZigqc2VsZikgKyBzdHJsZW4obmFtZSkgKyAxKTsKKworCWlmIChzZWxmICE9IE5VTEwpIHsKKwkJc3RyY3B5KHNlbGYtPm5hbWUsIG5hbWUpOworCQlzZWxmLT5zeW1zID0gUkJfUk9PVDsKKwkJc2VsZi0+c3ltX3ByaXZfc2l6ZSA9IHN5bV9wcml2X3NpemU7CisJCXNlbGYtPmZpbmRfc3ltYm9sID0gZHNvX19maW5kX3N5bWJvbDsKKwl9CisKKwlyZXR1cm4gc2VsZjsKK30KKworc3RhdGljIHZvaWQgZHNvX19kZWxldGVfc3ltYm9scyhzdHJ1Y3QgZHNvICpzZWxmKQoreworCXN0cnVjdCBzeW1ib2wgKnBvczsKKwlzdHJ1Y3QgcmJfbm9kZSAqbmV4dCA9IHJiX2ZpcnN0KCZzZWxmLT5zeW1zKTsKKworCXdoaWxlIChuZXh0KSB7CisJCXBvcyA9IHJiX2VudHJ5KG5leHQsIHN0cnVjdCBzeW1ib2wsIHJiX25vZGUpOworCQluZXh0ID0gcmJfbmV4dCgmcG9zLT5yYl9ub2RlKTsKKwkJcmJfZXJhc2UoJnBvcy0+cmJfbm9kZSwgJnNlbGYtPnN5bXMpOworCQlzeW1ib2xfX2RlbGV0ZShwb3MsIHNlbGYtPnN5bV9wcml2X3NpemUpOworCX0KK30KKwordm9pZCBkc29fX2RlbGV0ZShzdHJ1Y3QgZHNvICpzZWxmKQoreworCWRzb19fZGVsZXRlX3N5bWJvbHMoc2VsZik7CisJZnJlZShzZWxmKTsKK30KKworc3RhdGljIHZvaWQgZHNvX19pbnNlcnRfc3ltYm9sKHN0cnVjdCBkc28gKnNlbGYsIHN0cnVjdCBzeW1ib2wgKnN5bSkKK3sKKwlzdHJ1Y3QgcmJfbm9kZSAqKnAgPSAmc2VsZi0+c3ltcy5yYl9ub2RlOworCXN0cnVjdCByYl9ub2RlICpwYXJlbnQgPSBOVUxMOworCWNvbnN0IF9fdTY0IGlwID0gc3ltLT5zdGFydDsKKwlzdHJ1Y3Qgc3ltYm9sICpzOworCisJd2hpbGUgKCpwICE9IE5VTEwpIHsKKwkJcGFyZW50ID0gKnA7CisJCXMgPSByYl9lbnRyeShwYXJlbnQsIHN0cnVjdCBzeW1ib2wsIHJiX25vZGUpOworCQlpZiAoaXAgPCBzLT5zdGFydCkKKwkJCXAgPSAmKCpwKS0+cmJfbGVmdDsKKwkJZWxzZQorCQkJcCA9ICYoKnApLT5yYl9yaWdodDsKKwl9CisJcmJfbGlua19ub2RlKCZzeW0tPnJiX25vZGUsIHBhcmVudCwgcCk7CisJcmJfaW5zZXJ0X2NvbG9yKCZzeW0tPnJiX25vZGUsICZzZWxmLT5zeW1zKTsKK30KKworc3RydWN0IHN5bWJvbCAqZHNvX19maW5kX3N5bWJvbChzdHJ1Y3QgZHNvICpzZWxmLCBfX3U2NCBpcCkKK3sKKwlzdHJ1Y3QgcmJfbm9kZSAqbjsKKworCWlmIChzZWxmID09IE5VTEwpCisJCXJldHVybiBOVUxMOworCisJbiA9IHNlbGYtPnN5bXMucmJfbm9kZTsKKworCXdoaWxlIChuKSB7CisJCXN0cnVjdCBzeW1ib2wgKnMgPSByYl9lbnRyeShuLCBzdHJ1Y3Qgc3ltYm9sLCByYl9ub2RlKTsKKworCQlpZiAoaXAgPCBzLT5zdGFydCkKKwkJCW4gPSBuLT5yYl9sZWZ0OworCQllbHNlIGlmIChpcCA+IHMtPmVuZCkKKwkJCW4gPSBuLT5yYl9yaWdodDsKKwkJZWxzZQorCQkJcmV0dXJuIHM7CisJfQorCisJcmV0dXJuIE5VTEw7Cit9CisKK3NpemVfdCBkc29fX2ZwcmludGYoc3RydWN0IGRzbyAqc2VsZiwgRklMRSAqZnApCit7CisJc2l6ZV90IHJldCA9IGZwcmludGYoZnAsICJkc286ICVzXG4iLCBzZWxmLT5uYW1lKTsKKworCXN0cnVjdCByYl9ub2RlICpuZDsKKwlmb3IgKG5kID0gcmJfZmlyc3QoJnNlbGYtPnN5bXMpOyBuZDsgbmQgPSByYl9uZXh0KG5kKSkgeworCQlzdHJ1Y3Qgc3ltYm9sICpwb3MgPSByYl9lbnRyeShuZCwgc3RydWN0IHN5bWJvbCwgcmJfbm9kZSk7CisJCXJldCArPSBzeW1ib2xfX2ZwcmludGYocG9zLCBmcCk7CisJfQorCisJcmV0dXJuIHJldDsKK30KKworc3RhdGljIGludCBkc29fX2xvYWRfa2FsbHN5bXMoc3RydWN0IGRzbyAqc2VsZiwgc3ltYm9sX2ZpbHRlcl90IGZpbHRlciwgaW50IHZlcmJvc2UpCit7CisJc3RydWN0IHJiX25vZGUgKm5kLCAqcHJldm5kOworCWNoYXIgKmxpbmUgPSBOVUxMOworCXNpemVfdCBuOworCUZJTEUgKmZpbGUgPSBmb3BlbigiL3Byb2Mva2FsbHN5bXMiLCAiciIpOworCisJaWYgKGZpbGUgPT0gTlVMTCkKKwkJZ290byBvdXRfZmFpbHVyZTsKKworCXdoaWxlICghZmVvZihmaWxlKSkgeworCQlfX3U2NCBzdGFydDsKKwkJc3RydWN0IHN5bWJvbCAqc3ltOworCQlpbnQgbGluZV9sZW4sIGxlbjsKKwkJY2hhciBzeW1ib2xfdHlwZTsKKworCQlsaW5lX2xlbiA9IGdldGxpbmUoJmxpbmUsICZuLCBmaWxlKTsKKwkJaWYgKGxpbmVfbGVuIDwgMCkKKwkJCWJyZWFrOworCisJCWlmICghbGluZSkKKwkJCWdvdG8gb3V0X2ZhaWx1cmU7CisKKwkJbGluZVstLWxpbmVfbGVuXSA9ICdcMCc7IC8qIFxuICovCisKKwkJbGVuID0gaGV4MnU2NChsaW5lLCAmc3RhcnQpOworCisJCWxlbisrOworCQlpZiAobGVuICsgMiA+PSBsaW5lX2xlbikKKwkJCWNvbnRpbnVlOworCisJCXN5bWJvbF90eXBlID0gdG91cHBlcihsaW5lW2xlbl0pOworCQkvKgorCQkgKiBXZSdyZSBpbnRlcmVzdGVkIG9ubHkgaW4gY29kZSAoJ1QnZXh0KQorCQkgKi8KKwkJaWYgKHN5bWJvbF90eXBlICE9ICdUJyAmJiBzeW1ib2xfdHlwZSAhPSAnVycpCisJCQljb250aW51ZTsKKwkJLyoKKwkJICogV2VsbCBmaXggdXAgdGhlIGVuZCBsYXRlciwgd2hlbiB3ZSBoYXZlIGFsbCBzb3J0ZWQuCisJCSAqLworCQlzeW0gPSBzeW1ib2xfX25ldyhzdGFydCwgMHhkZWFkLCBsaW5lICsgbGVuICsgMiwKKwkJCQkgIHNlbGYtPnN5bV9wcml2X3NpemUsIDAsIHZlcmJvc2UpOworCisJCWlmIChzeW0gPT0gTlVMTCkKKwkJCWdvdG8gb3V0X2RlbGV0ZV9saW5lOworCisJCWlmIChmaWx0ZXIgJiYgZmlsdGVyKHNlbGYsIHN5bSkpCisJCQlzeW1ib2xfX2RlbGV0ZShzeW0sIHNlbGYtPnN5bV9wcml2X3NpemUpOworCQllbHNlCisJCQlkc29fX2luc2VydF9zeW1ib2woc2VsZiwgc3ltKTsKKwl9CisKKwkvKgorCSAqIE5vdyB0aGF0IHdlIGhhdmUgYWxsIHNvcnRlZCBvdXQsIGp1c3Qgc2V0IHRoZSAtPmVuZCBvZiBhbGwKKwkgKiBzeW1ib2xzCisJICovCisJcHJldm5kID0gcmJfZmlyc3QoJnNlbGYtPnN5bXMpOworCisJaWYgKHByZXZuZCA9PSBOVUxMKQorCQlnb3RvIG91dF9kZWxldGVfbGluZTsKKworCWZvciAobmQgPSByYl9uZXh0KHByZXZuZCk7IG5kOyBuZCA9IHJiX25leHQobmQpKSB7CisJCXN0cnVjdCBzeW1ib2wgKnByZXYgPSByYl9lbnRyeShwcmV2bmQsIHN0cnVjdCBzeW1ib2wsIHJiX25vZGUpLAorCQkJICAgICAgKmN1cnIgPSByYl9lbnRyeShuZCwgc3RydWN0IHN5bWJvbCwgcmJfbm9kZSk7CisKKwkJcHJldi0+ZW5kID0gY3Vyci0+c3RhcnQgLSAxOworCQlwcmV2bmQgPSBuZDsKKwl9CisKKwlmcmVlKGxpbmUpOworCWZjbG9zZShmaWxlKTsKKworCXJldHVybiAwOworCitvdXRfZGVsZXRlX2xpbmU6CisJZnJlZShsaW5lKTsKK291dF9mYWlsdXJlOgorCXJldHVybiAtMTsKK30KKworc3RhdGljIGludCBkc29fX2xvYWRfcGVyZl9tYXAoc3RydWN0IGRzbyAqc2VsZiwgc3ltYm9sX2ZpbHRlcl90IGZpbHRlciwgaW50IHZlcmJvc2UpCit7CisJY2hhciAqbGluZSA9IE5VTEw7CisJc2l6ZV90IG47CisJRklMRSAqZmlsZTsKKwlpbnQgbnJfc3ltcyA9IDA7CisKKwlmaWxlID0gZm9wZW4oc2VsZi0+bmFtZSwgInIiKTsKKwlpZiAoZmlsZSA9PSBOVUxMKQorCQlnb3RvIG91dF9mYWlsdXJlOworCisJd2hpbGUgKCFmZW9mKGZpbGUpKSB7CisJCV9fdTY0IHN0YXJ0LCBzaXplOworCQlzdHJ1Y3Qgc3ltYm9sICpzeW07CisJCWludCBsaW5lX2xlbiwgbGVuOworCisJCWxpbmVfbGVuID0gZ2V0bGluZSgmbGluZSwgJm4sIGZpbGUpOworCQlpZiAobGluZV9sZW4gPCAwKQorCQkJYnJlYWs7CisKKwkJaWYgKCFsaW5lKQorCQkJZ290byBvdXRfZmFpbHVyZTsKKworCQlsaW5lWy0tbGluZV9sZW5dID0gJ1wwJzsgLyogXG4gKi8KKworCQlsZW4gPSBoZXgydTY0KGxpbmUsICZzdGFydCk7CisKKwkJbGVuKys7CisJCWlmIChsZW4gKyAyID49IGxpbmVfbGVuKQorCQkJY29udGludWU7CisKKwkJbGVuICs9IGhleDJ1NjQobGluZSArIGxlbiwgJnNpemUpOworCisJCWxlbisrOworCQlpZiAobGVuICsgMiA+PSBsaW5lX2xlbikKKwkJCWNvbnRpbnVlOworCisJCXN5bSA9IHN5bWJvbF9fbmV3KHN0YXJ0LCBzaXplLCBsaW5lICsgbGVuLAorCQkJCSAgc2VsZi0+c3ltX3ByaXZfc2l6ZSwgc3RhcnQsIHZlcmJvc2UpOworCisJCWlmIChzeW0gPT0gTlVMTCkKKwkJCWdvdG8gb3V0X2RlbGV0ZV9saW5lOworCisJCWlmIChmaWx0ZXIgJiYgZmlsdGVyKHNlbGYsIHN5bSkpCisJCQlzeW1ib2xfX2RlbGV0ZShzeW0sIHNlbGYtPnN5bV9wcml2X3NpemUpOworCQllbHNlIHsKKwkJCWRzb19faW5zZXJ0X3N5bWJvbChzZWxmLCBzeW0pOworCQkJbnJfc3ltcysrOworCQl9CisJfQorCisJZnJlZShsaW5lKTsKKwlmY2xvc2UoZmlsZSk7CisKKwlyZXR1cm4gbnJfc3ltczsKKworb3V0X2RlbGV0ZV9saW5lOgorCWZyZWUobGluZSk7CitvdXRfZmFpbHVyZToKKwlyZXR1cm4gLTE7Cit9CisKKy8qKgorICogZWxmX3N5bXRhYl9fZm9yX2VhY2hfc3ltYm9sIC0gaXRlcmF0ZSB0aHJ1IGFsbCB0aGUgc3ltYm9scworICoKKyAqIEBzZWxmOiBzdHJ1Y3QgZWxmX3N5bXRhYiBpbnN0YW5jZSB0byBpdGVyYXRlCisgKiBAaW5kZXg6IHVpbnQzMl90IGluZGV4CisgKiBAc3ltOiBHRWxmX1N5bSBpdGVyYXRvcgorICovCisjZGVmaW5lIGVsZl9zeW10YWJfX2Zvcl9lYWNoX3N5bWJvbChzeW1zLCBucl9zeW1zLCBpbmRleCwgc3ltKSBcCisJZm9yIChpbmRleCA9IDAsIGdlbGZfZ2V0c3ltKHN5bXMsIGluZGV4LCAmc3ltKTtcCisJICAgICBpbmRleCA8IG5yX3N5bXM7IFwKKwkgICAgIGluZGV4KyssIGdlbGZfZ2V0c3ltKHN5bXMsIGluZGV4LCAmc3ltKSkKKworc3RhdGljIGlubGluZSB1aW50OF90IGVsZl9zeW1fX3R5cGUoY29uc3QgR0VsZl9TeW0gKnN5bSkKK3sKKwlyZXR1cm4gR0VMRl9TVF9UWVBFKHN5bS0+c3RfaW5mbyk7Cit9CisKK3N0YXRpYyBpbmxpbmUgaW50IGVsZl9zeW1fX2lzX2Z1bmN0aW9uKGNvbnN0IEdFbGZfU3ltICpzeW0pCit7CisJcmV0dXJuIGVsZl9zeW1fX3R5cGUoc3ltKSA9PSBTVFRfRlVOQyAmJgorCSAgICAgICBzeW0tPnN0X25hbWUgIT0gMCAmJgorCSAgICAgICBzeW0tPnN0X3NobmR4ICE9IFNITl9VTkRFRiAmJgorCSAgICAgICBzeW0tPnN0X3NpemUgIT0gMDsKK30KKworc3RhdGljIGlubGluZSBjb25zdCBjaGFyICplbGZfc3ltX19uYW1lKGNvbnN0IEdFbGZfU3ltICpzeW0sCisJCQkJCWNvbnN0IEVsZl9EYXRhICpzeW1zdHJzKQoreworCXJldHVybiBzeW1zdHJzLT5kX2J1ZiArIHN5bS0+c3RfbmFtZTsKK30KKworc3RhdGljIEVsZl9TY24gKmVsZl9zZWN0aW9uX2J5X25hbWUoRWxmICplbGYsIEdFbGZfRWhkciAqZXAsCisJCQkJICAgIEdFbGZfU2hkciAqc2hwLCBjb25zdCBjaGFyICpuYW1lLAorCQkJCSAgICBzaXplX3QgKmluZGV4KQoreworCUVsZl9TY24gKnNlYyA9IE5VTEw7CisJc2l6ZV90IGNudCA9IDE7CisKKwl3aGlsZSAoKHNlYyA9IGVsZl9uZXh0c2NuKGVsZiwgc2VjKSkgIT0gTlVMTCkgeworCQljaGFyICpzdHI7CisKKwkJZ2VsZl9nZXRzaGRyKHNlYywgc2hwKTsKKwkJc3RyID0gZWxmX3N0cnB0cihlbGYsIGVwLT5lX3Noc3RybmR4LCBzaHAtPnNoX25hbWUpOworCQlpZiAoIXN0cmNtcChuYW1lLCBzdHIpKSB7CisJCQlpZiAoaW5kZXgpCisJCQkJKmluZGV4ID0gY250OworCQkJYnJlYWs7CisJCX0KKwkJKytjbnQ7CisJfQorCisJcmV0dXJuIHNlYzsKK30KKworI2RlZmluZSBlbGZfc2VjdGlvbl9fZm9yX2VhY2hfcmVsKHJlbGRhdGEsIHBvcywgcG9zX21lbSwgaWR4LCBucl9lbnRyaWVzKSBcCisJZm9yIChpZHggPSAwLCBwb3MgPSBnZWxmX2dldHJlbChyZWxkYXRhLCAwLCAmcG9zX21lbSk7IFwKKwkgICAgIGlkeCA8IG5yX2VudHJpZXM7IFwKKwkgICAgICsraWR4LCBwb3MgPSBnZWxmX2dldHJlbChyZWxkYXRhLCBpZHgsICZwb3NfbWVtKSkKKworI2RlZmluZSBlbGZfc2VjdGlvbl9fZm9yX2VhY2hfcmVsYShyZWxkYXRhLCBwb3MsIHBvc19tZW0sIGlkeCwgbnJfZW50cmllcykgXAorCWZvciAoaWR4ID0gMCwgcG9zID0gZ2VsZl9nZXRyZWxhKHJlbGRhdGEsIDAsICZwb3NfbWVtKTsgXAorCSAgICAgaWR4IDwgbnJfZW50cmllczsgXAorCSAgICAgKytpZHgsIHBvcyA9IGdlbGZfZ2V0cmVsYShyZWxkYXRhLCBpZHgsICZwb3NfbWVtKSkKKworc3RhdGljIGludCBkc29fX3N5bnRoZXNpemVfcGx0X3N5bWJvbHMoc3RydWN0ICBkc28gKnNlbGYsIEVsZiAqZWxmLAorCQkJCSAgICAgICBHRWxmX0VoZHIgKmVoZHIsIEVsZl9TY24gKnNjbl9keW5zeW0sCisJCQkJICAgICAgIEdFbGZfU2hkciAqc2hkcl9keW5zeW0sCisJCQkJICAgICAgIHNpemVfdCBkeW5zeW1faWR4LCBpbnQgdmVyYm9zZSkKK3sKKwl1aW50MzJfdCBucl9yZWxfZW50cmllcywgaWR4OworCUdFbGZfU3ltIHN5bTsKKwlfX3U2NCBwbHRfb2Zmc2V0OworCUdFbGZfU2hkciBzaGRyX3BsdDsKKwlzdHJ1Y3Qgc3ltYm9sICpmOworCUdFbGZfU2hkciBzaGRyX3JlbF9wbHQ7CisJRWxmX0RhdGEgKnJlbGRhdGEsICpzeW1zLCAqc3ltc3RyczsKKwlFbGZfU2NuICpzY25fcGx0X3JlbCwgKnNjbl9zeW1zdHJzOworCWNoYXIgc3ltcGx0bmFtZVsxMDI0XTsKKwlpbnQgbnIgPSAwLCBzeW1pZHg7CisKKwlzY25fcGx0X3JlbCA9IGVsZl9zZWN0aW9uX2J5X25hbWUoZWxmLCBlaGRyLCAmc2hkcl9yZWxfcGx0LAorCQkJCQkgICIucmVsYS5wbHQiLCBOVUxMKTsKKwlpZiAoc2NuX3BsdF9yZWwgPT0gTlVMTCkgeworCQlzY25fcGx0X3JlbCA9IGVsZl9zZWN0aW9uX2J5X25hbWUoZWxmLCBlaGRyLCAmc2hkcl9yZWxfcGx0LAorCQkJCQkJICAiLnJlbC5wbHQiLCBOVUxMKTsKKwkJaWYgKHNjbl9wbHRfcmVsID09IE5VTEwpCisJCQlyZXR1cm4gMDsKKwl9CisKKwlpZiAoc2hkcl9yZWxfcGx0LnNoX2xpbmsgIT0gZHluc3ltX2lkeCkKKwkJcmV0dXJuIDA7CisKKwlpZiAoZWxmX3NlY3Rpb25fYnlfbmFtZShlbGYsIGVoZHIsICZzaGRyX3BsdCwgIi5wbHQiLCBOVUxMKSA9PSBOVUxMKQorCQlyZXR1cm4gMDsKKworCS8qCisJICogRmV0Y2ggdGhlIHJlbG9jYXRpb24gc2VjdGlvbiB0byBmaW5kIHRoZSBpbmRleGVzIHRvIHRoZSBHT1QKKwkgKiBhbmQgdGhlIHN5bWJvbHMgaW4gdGhlIC5keW5zeW0gdGhleSByZWZlciB0by4KKwkgKi8KKwlyZWxkYXRhID0gZWxmX2dldGRhdGEoc2NuX3BsdF9yZWwsIE5VTEwpOworCWlmIChyZWxkYXRhID09IE5VTEwpCisJCXJldHVybiAtMTsKKworCXN5bXMgPSBlbGZfZ2V0ZGF0YShzY25fZHluc3ltLCBOVUxMKTsKKwlpZiAoc3ltcyA9PSBOVUxMKQorCQlyZXR1cm4gLTE7CisKKwlzY25fc3ltc3RycyA9IGVsZl9nZXRzY24oZWxmLCBzaGRyX2R5bnN5bS0+c2hfbGluayk7CisJaWYgKHNjbl9zeW1zdHJzID09IE5VTEwpCisJCXJldHVybiAtMTsKKworCXN5bXN0cnMgPSBlbGZfZ2V0ZGF0YShzY25fc3ltc3RycywgTlVMTCk7CisJaWYgKHN5bXN0cnMgPT0gTlVMTCkKKwkJcmV0dXJuIC0xOworCisJbnJfcmVsX2VudHJpZXMgPSBzaGRyX3JlbF9wbHQuc2hfc2l6ZSAvIHNoZHJfcmVsX3BsdC5zaF9lbnRzaXplOworCXBsdF9vZmZzZXQgPSBzaGRyX3BsdC5zaF9vZmZzZXQ7CisKKwlpZiAoc2hkcl9yZWxfcGx0LnNoX3R5cGUgPT0gU0hUX1JFTEEpIHsKKwkJR0VsZl9SZWxhIHBvc19tZW0sICpwb3M7CisKKwkJZWxmX3NlY3Rpb25fX2Zvcl9lYWNoX3JlbGEocmVsZGF0YSwgcG9zLCBwb3NfbWVtLCBpZHgsCisJCQkJCSAgIG5yX3JlbF9lbnRyaWVzKSB7CisJCQlzeW1pZHggPSBHRUxGX1JfU1lNKHBvcy0+cl9pbmZvKTsKKwkJCXBsdF9vZmZzZXQgKz0gc2hkcl9wbHQuc2hfZW50c2l6ZTsKKwkJCWdlbGZfZ2V0c3ltKHN5bXMsIHN5bWlkeCwgJnN5bSk7CisJCQlzbnByaW50ZihzeW1wbHRuYW1lLCBzaXplb2Yoc3ltcGx0bmFtZSksCisJCQkJICIlc0BwbHQiLCBlbGZfc3ltX19uYW1lKCZzeW0sIHN5bXN0cnMpKTsKKworCQkJZiA9IHN5bWJvbF9fbmV3KHBsdF9vZmZzZXQsIHNoZHJfcGx0LnNoX2VudHNpemUsCisJCQkJCXN5bXBsdG5hbWUsIHNlbGYtPnN5bV9wcml2X3NpemUsIDAsIHZlcmJvc2UpOworCQkJaWYgKCFmKQorCQkJCXJldHVybiAtMTsKKworCQkJZHNvX19pbnNlcnRfc3ltYm9sKHNlbGYsIGYpOworCQkJKytucjsKKwkJfQorCX0gZWxzZSBpZiAoc2hkcl9yZWxfcGx0LnNoX3R5cGUgPT0gU0hUX1JFTCkgeworCQlHRWxmX1JlbCBwb3NfbWVtLCAqcG9zOworCQllbGZfc2VjdGlvbl9fZm9yX2VhY2hfcmVsKHJlbGRhdGEsIHBvcywgcG9zX21lbSwgaWR4LAorCQkJCQkgIG5yX3JlbF9lbnRyaWVzKSB7CisJCQlzeW1pZHggPSBHRUxGX1JfU1lNKHBvcy0+cl9pbmZvKTsKKwkJCXBsdF9vZmZzZXQgKz0gc2hkcl9wbHQuc2hfZW50c2l6ZTsKKwkJCWdlbGZfZ2V0c3ltKHN5bXMsIHN5bWlkeCwgJnN5bSk7CisJCQlzbnByaW50ZihzeW1wbHRuYW1lLCBzaXplb2Yoc3ltcGx0bmFtZSksCisJCQkJICIlc0BwbHQiLCBlbGZfc3ltX19uYW1lKCZzeW0sIHN5bXN0cnMpKTsKKworCQkJZiA9IHN5bWJvbF9fbmV3KHBsdF9vZmZzZXQsIHNoZHJfcGx0LnNoX2VudHNpemUsCisJCQkJCXN5bXBsdG5hbWUsIHNlbGYtPnN5bV9wcml2X3NpemUsIDAsIHZlcmJvc2UpOworCQkJaWYgKCFmKQorCQkJCXJldHVybiAtMTsKKworCQkJZHNvX19pbnNlcnRfc3ltYm9sKHNlbGYsIGYpOworCQkJKytucjsKKwkJfQorCX0gZWxzZSB7CisJCS8qCisJCSAqIFRPRE86IFRoZXJlIGFyZSBzdGlsbCBvbmUgbW9yZSBzaGRyX3JlbF9wbHQuc2hfdHlwZQorCQkgKiBJIGhhdmUgdG8gaW52ZXN0aWdhdGUsIGJ1dCBwcm9iYWJseSBzaG91bGQgYmUgaWdub3JlZC4KKwkJICovCisJfQorCisJcmV0dXJuIG5yOworfQorCitzdGF0aWMgaW50IGRzb19fbG9hZF9zeW0oc3RydWN0IGRzbyAqc2VsZiwgaW50IGZkLCBjb25zdCBjaGFyICpuYW1lLAorCQkJIHN5bWJvbF9maWx0ZXJfdCBmaWx0ZXIsIGludCB2ZXJib3NlKQoreworCUVsZl9EYXRhICpzeW1zdHJzOworCXVpbnQzMl90IG5yX3N5bXM7CisJaW50IGVyciA9IC0xOworCXVpbnQzMl90IGluZGV4OworCUdFbGZfRWhkciBlaGRyOworCUdFbGZfU2hkciBzaGRyOworCUVsZl9EYXRhICpzeW1zOworCUdFbGZfU3ltIHN5bTsKKwlFbGZfU2NuICpzZWMsICpzZWNfZHluc3ltOworCUVsZiAqZWxmOworCXNpemVfdCBkeW5zeW1faWR4OworCWludCBuciA9IDA7CisKKwllbGYgPSBlbGZfYmVnaW4oZmQsIEVMRl9DX1JFQURfTU1BUCwgTlVMTCk7CisJaWYgKGVsZiA9PSBOVUxMKSB7CisJCWlmICh2ZXJib3NlKQorCQkJZnByaW50ZihzdGRlcnIsICIlczogY2Fubm90IHJlYWQgJXMgRUxGIGZpbGUuXG4iLAorCQkJCV9fZnVuY19fLCBuYW1lKTsKKwkJZ290byBvdXRfY2xvc2U7CisJfQorCisJaWYgKGdlbGZfZ2V0ZWhkcihlbGYsICZlaGRyKSA9PSBOVUxMKSB7CisJCWlmICh2ZXJib3NlKQorCQkJZnByaW50ZihzdGRlcnIsICIlczogY2Fubm90IGdldCBlbGYgaGVhZGVyLlxuIiwgX19mdW5jX18pOworCQlnb3RvIG91dF9lbGZfZW5kOworCX0KKworCS8qCisJICogV2UgbmVlZCB0byBjaGVjayBpZiB3ZSBoYXZlIGEgLmR5bnN5bSwgc28gdGhhdCB3ZSBjYW4gaGFuZGxlIHRoZQorCSAqIC5wbHQsIHN5bnRoZXNpemluZyBpdHMgc3ltYm9scywgdGhhdCBhcmVuJ3Qgb24gdGhlIHN5bXRhYnMgKGJlIGl0CisJICogLmR5bnN5bSBvciAuc3ltdGFiKQorCSAqLworCXNlY19keW5zeW0gPSBlbGZfc2VjdGlvbl9ieV9uYW1lKGVsZiwgJmVoZHIsICZzaGRyLAorCQkJCQkgIi5keW5zeW0iLCAmZHluc3ltX2lkeCk7CisJaWYgKHNlY19keW5zeW0gIT0gTlVMTCkgeworCQluciA9IGRzb19fc3ludGhlc2l6ZV9wbHRfc3ltYm9scyhzZWxmLCBlbGYsICZlaGRyLAorCQkJCQkJIHNlY19keW5zeW0sICZzaGRyLAorCQkJCQkJIGR5bnN5bV9pZHgsIHZlcmJvc2UpOworCQlpZiAobnIgPCAwKQorCQkJZ290byBvdXRfZWxmX2VuZDsKKwl9CisKKwkvKgorCSAqIEJ1dCBpZiB3ZSBoYXZlIGEgZnVsbCAuc3ltdGFiICh0aGF0IGlzIGEgc3VwZXJzZXQgb2YgLmR5bnN5bSkgd2UKKwkgKiBzaG91bGQgYWRkIHRoZSBzeW1ib2xzIG5vdCBpbiB0aGUgLmR5bnN5bgorCSAqLworCXNlYyA9IGVsZl9zZWN0aW9uX2J5X25hbWUoZWxmLCAmZWhkciwgJnNoZHIsICIuc3ltdGFiIiwgTlVMTCk7CisJaWYgKHNlYyA9PSBOVUxMKSB7CisJCWlmIChzZWNfZHluc3ltID09IE5VTEwpCisJCQlnb3RvIG91dF9lbGZfZW5kOworCisJCXNlYyA9IHNlY19keW5zeW07CisJCWdlbGZfZ2V0c2hkcihzZWMsICZzaGRyKTsKKwl9CisKKwlzeW1zID0gZWxmX2dldGRhdGEoc2VjLCBOVUxMKTsKKwlpZiAoc3ltcyA9PSBOVUxMKQorCQlnb3RvIG91dF9lbGZfZW5kOworCisJc2VjID0gZWxmX2dldHNjbihlbGYsIHNoZHIuc2hfbGluayk7CisJaWYgKHNlYyA9PSBOVUxMKQorCQlnb3RvIG91dF9lbGZfZW5kOworCisJc3ltc3RycyA9IGVsZl9nZXRkYXRhKHNlYywgTlVMTCk7CisJaWYgKHN5bXN0cnMgPT0gTlVMTCkKKwkJZ290byBvdXRfZWxmX2VuZDsKKworCW5yX3N5bXMgPSBzaGRyLnNoX3NpemUgLyBzaGRyLnNoX2VudHNpemU7CisKKwltZW1zZXQoJnN5bSwgMCwgc2l6ZW9mKHN5bSkpOworCisJZWxmX3N5bXRhYl9fZm9yX2VhY2hfc3ltYm9sKHN5bXMsIG5yX3N5bXMsIGluZGV4LCBzeW0pIHsKKwkJc3RydWN0IHN5bWJvbCAqZjsKKwkJX191NjQgb2JqX3N0YXJ0OworCisJCWlmICghZWxmX3N5bV9faXNfZnVuY3Rpb24oJnN5bSkpCisJCQljb250aW51ZTsKKworCQlzZWMgPSBlbGZfZ2V0c2NuKGVsZiwgc3ltLnN0X3NobmR4KTsKKwkJaWYgKCFzZWMpCisJCQlnb3RvIG91dF9lbGZfZW5kOworCisJCWdlbGZfZ2V0c2hkcihzZWMsICZzaGRyKTsKKwkJb2JqX3N0YXJ0ID0gc3ltLnN0X3ZhbHVlOworCisJCXN5bS5zdF92YWx1ZSAtPSBzaGRyLnNoX2FkZHIgLSBzaGRyLnNoX29mZnNldDsKKworCQlmID0gc3ltYm9sX19uZXcoc3ltLnN0X3ZhbHVlLCBzeW0uc3Rfc2l6ZSwKKwkJCQllbGZfc3ltX19uYW1lKCZzeW0sIHN5bXN0cnMpLAorCQkJCXNlbGYtPnN5bV9wcml2X3NpemUsIG9ial9zdGFydCwgdmVyYm9zZSk7CisJCWlmICghZikKKwkJCWdvdG8gb3V0X2VsZl9lbmQ7CisKKwkJaWYgKGZpbHRlciAmJiBmaWx0ZXIoc2VsZiwgZikpCisJCQlzeW1ib2xfX2RlbGV0ZShmLCBzZWxmLT5zeW1fcHJpdl9zaXplKTsKKwkJZWxzZSB7CisJCQlkc29fX2luc2VydF9zeW1ib2woc2VsZiwgZik7CisJCQlucisrOworCQl9CisJfQorCisJZXJyID0gbnI7CitvdXRfZWxmX2VuZDoKKwllbGZfZW5kKGVsZik7CitvdXRfY2xvc2U6CisJcmV0dXJuIGVycjsKK30KKworaW50IGRzb19fbG9hZChzdHJ1Y3QgZHNvICpzZWxmLCBzeW1ib2xfZmlsdGVyX3QgZmlsdGVyLCBpbnQgdmVyYm9zZSkKK3sKKwlpbnQgc2l6ZSA9IHN0cmxlbihzZWxmLT5uYW1lKSArIHNpemVvZigiL3Vzci9saWIvZGVidWclcy5kZWJ1ZyIpOworCWNoYXIgKm5hbWUgPSBtYWxsb2Moc2l6ZSk7CisJaW50IHZhcmlhbnQgPSAwOworCWludCByZXQgPSAtMTsKKwlpbnQgZmQ7CisKKwlpZiAoIW5hbWUpCisJCXJldHVybiAtMTsKKworCWlmIChzdHJuY21wKHNlbGYtPm5hbWUsICIvdG1wL3BlcmYtIiwgMTApID09IDApCisJCXJldHVybiBkc29fX2xvYWRfcGVyZl9tYXAoc2VsZiwgZmlsdGVyLCB2ZXJib3NlKTsKKworbW9yZToKKwlkbyB7CisJCXN3aXRjaCAodmFyaWFudCkgeworCQljYXNlIDA6IC8qIEZlZG9yYSAqLworCQkJc25wcmludGYobmFtZSwgc2l6ZSwgIi91c3IvbGliL2RlYnVnJXMuZGVidWciLCBzZWxmLT5uYW1lKTsKKwkJCWJyZWFrOworCQljYXNlIDE6IC8qIFVidW50dSAqLworCQkJc25wcmludGYobmFtZSwgc2l6ZSwgIi91c3IvbGliL2RlYnVnJXMiLCBzZWxmLT5uYW1lKTsKKwkJCWJyZWFrOworCQljYXNlIDI6IC8qIFNhbmUgcGVvcGxlICovCisJCQlzbnByaW50ZihuYW1lLCBzaXplLCAiJXMiLCBzZWxmLT5uYW1lKTsKKwkJCWJyZWFrOworCisJCWRlZmF1bHQ6CisJCQlnb3RvIG91dDsKKwkJfQorCQl2YXJpYW50Kys7CisKKwkJZmQgPSBvcGVuKG5hbWUsIE9fUkRPTkxZKTsKKwl9IHdoaWxlIChmZCA8IDApOworCisJcmV0ID0gZHNvX19sb2FkX3N5bShzZWxmLCBmZCwgbmFtZSwgZmlsdGVyLCB2ZXJib3NlKTsKKwljbG9zZShmZCk7CisKKwkvKgorCSAqIFNvbWUgcGVvcGxlIHNlZW0gdG8gaGF2ZSBkZWJ1Z2luZm8gZmlsZXMgX1dJVEhPVVRfIGRlYnVnIGluZm8hPyE/CisJICovCisJaWYgKCFyZXQpCisJCWdvdG8gbW9yZTsKKworb3V0OgorCWZyZWUobmFtZSk7CisJcmV0dXJuIHJldDsKK30KKworc3RhdGljIGludCBkc29fX2xvYWRfdm1saW51eChzdHJ1Y3QgZHNvICpzZWxmLCBjb25zdCBjaGFyICp2bWxpbnV4LAorCQkJICAgICBzeW1ib2xfZmlsdGVyX3QgZmlsdGVyLCBpbnQgdmVyYm9zZSkKK3sKKwlpbnQgZXJyLCBmZCA9IG9wZW4odm1saW51eCwgT19SRE9OTFkpOworCisJaWYgKGZkIDwgMCkKKwkJcmV0dXJuIC0xOworCisJZXJyID0gZHNvX19sb2FkX3N5bShzZWxmLCBmZCwgdm1saW51eCwgZmlsdGVyLCB2ZXJib3NlKTsKKwljbG9zZShmZCk7CisKKwlyZXR1cm4gZXJyOworfQorCitpbnQgZHNvX19sb2FkX2tlcm5lbChzdHJ1Y3QgZHNvICpzZWxmLCBjb25zdCBjaGFyICp2bWxpbnV4LAorCQkgICAgIHN5bWJvbF9maWx0ZXJfdCBmaWx0ZXIsIGludCB2ZXJib3NlKQoreworCWludCBlcnIgPSAtMTsKKworCWlmICh2bWxpbnV4KQorCQllcnIgPSBkc29fX2xvYWRfdm1saW51eChzZWxmLCB2bWxpbnV4LCBmaWx0ZXIsIHZlcmJvc2UpOworCisJaWYgKGVycikKKwkJZXJyID0gZHNvX19sb2FkX2thbGxzeW1zKHNlbGYsIGZpbHRlciwgdmVyYm9zZSk7CisKKwlyZXR1cm4gZXJyOworfQorCit2b2lkIHN5bWJvbF9faW5pdCh2b2lkKQoreworCWVsZl92ZXJzaW9uKEVWX0NVUlJFTlQpOworfQpkaWZmIC0tZ2l0IGEvdG9vbHMvcGVyZi91dGlsL3N5bWJvbC5oIGIvdG9vbHMvcGVyZi91dGlsL3N5bWJvbC5oCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjBkMTI5MmIKLS0tIC9kZXYvbnVsbAorKysgYi90b29scy9wZXJmL3V0aWwvc3ltYm9sLmgKQEAgLTAsMCArMSw0NyBAQAorI2lmbmRlZiBfUEVSRl9TWU1CT0xfCisjZGVmaW5lIF9QRVJGX1NZTUJPTF8gMQorCisjaW5jbHVkZSA8bGludXgvdHlwZXMuaD4KKyNpbmNsdWRlICJsaXN0LmgiCisjaW5jbHVkZSAicmJ0cmVlLmgiCisKK3N0cnVjdCBzeW1ib2wgeworCXN0cnVjdCByYl9ub2RlCXJiX25vZGU7CisJX191NjQJCXN0YXJ0OworCV9fdTY0CQllbmQ7CisJX191NjQJCW9ial9zdGFydDsKKwlfX3U2NAkJaGlzdF9zdW07CisJX191NjQJCSpoaXN0OworCWNoYXIJCW5hbWVbMF07Cit9OworCitzdHJ1Y3QgZHNvIHsKKwlzdHJ1Y3QgbGlzdF9oZWFkIG5vZGU7CisJc3RydWN0IHJiX3Jvb3QJIHN5bXM7CisJdW5zaWduZWQgaW50CSBzeW1fcHJpdl9zaXplOworCXN0cnVjdCBzeW1ib2wgICAgKigqZmluZF9zeW1ib2wpKHN0cnVjdCBkc28gKiwgX191NjQgaXApOworCWNoYXIJCSBuYW1lWzBdOworfTsKKworY29uc3QgY2hhciAqc3ltX2hpc3RfZmlsdGVyOworCit0eXBlZGVmIGludCAoKnN5bWJvbF9maWx0ZXJfdCkoc3RydWN0IGRzbyAqc2VsZiwgc3RydWN0IHN5bWJvbCAqc3ltKTsKKworc3RydWN0IGRzbyAqZHNvX19uZXcoY29uc3QgY2hhciAqbmFtZSwgdW5zaWduZWQgaW50IHN5bV9wcml2X3NpemUpOwordm9pZCBkc29fX2RlbGV0ZShzdHJ1Y3QgZHNvICpzZWxmKTsKKworc3RhdGljIGlubGluZSB2b2lkICpkc29fX3N5bV9wcml2KHN0cnVjdCBkc28gKnNlbGYsIHN0cnVjdCBzeW1ib2wgKnN5bSkKK3sKKwlyZXR1cm4gKCh2b2lkICopc3ltKSAtIHNlbGYtPnN5bV9wcml2X3NpemU7Cit9CisKK3N0cnVjdCBzeW1ib2wgKmRzb19fZmluZF9zeW1ib2woc3RydWN0IGRzbyAqc2VsZiwgX191NjQgaXApOworCitpbnQgZHNvX19sb2FkX2tlcm5lbChzdHJ1Y3QgZHNvICpzZWxmLCBjb25zdCBjaGFyICp2bWxpbnV4LAorCQkgICAgIHN5bWJvbF9maWx0ZXJfdCBmaWx0ZXIsIGludCB2ZXJib3NlKTsKK2ludCBkc29fX2xvYWQoc3RydWN0IGRzbyAqc2VsZiwgc3ltYm9sX2ZpbHRlcl90IGZpbHRlciwgaW50IHZlcmJvc2UpOworCitzaXplX3QgZHNvX19mcHJpbnRmKHN0cnVjdCBkc28gKnNlbGYsIEZJTEUgKmZwKTsKKwordm9pZCBzeW1ib2xfX2luaXQodm9pZCk7CisjZW5kaWYgLyogX1BFUkZfU1lNQk9MXyAqLwpkaWZmIC0tZ2l0IGEvdG9vbHMvcGVyZi91dGlsL3VzYWdlLmMgYi90b29scy9wZXJmL3V0aWwvdXNhZ2UuYwpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi5lMTZiZjlhNwotLS0gL2Rldi9udWxsCisrKyBiL3Rvb2xzL3BlcmYvdXRpbC91c2FnZS5jCkBAIC0wLDAgKzEsODAgQEAKKy8qCisgKiBHSVQgLSBUaGUgaW5mb3JtYXRpb24gbWFuYWdlciBmcm9tIGhlbGwKKyAqCisgKiBDb3B5cmlnaHQgKEMpIExpbnVzIFRvcnZhbGRzLCAyMDA1CisgKi8KKyNpbmNsdWRlICJ1dGlsLmgiCisKK3N0YXRpYyB2b2lkIHJlcG9ydChjb25zdCBjaGFyICpwcmVmaXgsIGNvbnN0IGNoYXIgKmVyciwgdmFfbGlzdCBwYXJhbXMpCit7CisJY2hhciBtc2dbMTAyNF07CisJdnNucHJpbnRmKG1zZywgc2l6ZW9mKG1zZyksIGVyciwgcGFyYW1zKTsKKwlmcHJpbnRmKHN0ZGVyciwgIiAlcyVzXG4iLCBwcmVmaXgsIG1zZyk7Cit9CisKK3N0YXRpYyBOT1JFVFVSTiB2b2lkIHVzYWdlX2J1aWx0aW4oY29uc3QgY2hhciAqZXJyKQoreworCWZwcmludGYoc3RkZXJyLCAiXG4gVXNhZ2U6ICVzXG4iLCBlcnIpOworCWV4aXQoMTI5KTsKK30KKworc3RhdGljIE5PUkVUVVJOIHZvaWQgZGllX2J1aWx0aW4oY29uc3QgY2hhciAqZXJyLCB2YV9saXN0IHBhcmFtcykKK3sKKwlyZXBvcnQoIiBGYXRhbDogIiwgZXJyLCBwYXJhbXMpOworCWV4aXQoMTI4KTsKK30KKworc3RhdGljIHZvaWQgZXJyb3JfYnVpbHRpbihjb25zdCBjaGFyICplcnIsIHZhX2xpc3QgcGFyYW1zKQoreworCXJlcG9ydCgiIEVycm9yOiAiLCBlcnIsIHBhcmFtcyk7Cit9CisKK3N0YXRpYyB2b2lkIHdhcm5fYnVpbHRpbihjb25zdCBjaGFyICp3YXJuLCB2YV9saXN0IHBhcmFtcykKK3sKKwlyZXBvcnQoIiBXYXJuaW5nOiAiLCB3YXJuLCBwYXJhbXMpOworfQorCisvKiBJZiB3ZSBhcmUgaW4gYSBkbG9wZW4oKWVkIC5zbyB3cml0ZSB0byBhIGdsb2JhbCB2YXJpYWJsZSB3b3VsZCBzZWdmYXVsdAorICogKHVnaCksIHNvIGtlZXAgdGhpbmdzIHN0YXRpYy4gKi8KK3N0YXRpYyB2b2lkICgqdXNhZ2Vfcm91dGluZSkoY29uc3QgY2hhciAqZXJyKSBOT1JFVFVSTiA9IHVzYWdlX2J1aWx0aW47CitzdGF0aWMgdm9pZCAoKmRpZV9yb3V0aW5lKShjb25zdCBjaGFyICplcnIsIHZhX2xpc3QgcGFyYW1zKSBOT1JFVFVSTiA9IGRpZV9idWlsdGluOworc3RhdGljIHZvaWQgKCplcnJvcl9yb3V0aW5lKShjb25zdCBjaGFyICplcnIsIHZhX2xpc3QgcGFyYW1zKSA9IGVycm9yX2J1aWx0aW47CitzdGF0aWMgdm9pZCAoKndhcm5fcm91dGluZSkoY29uc3QgY2hhciAqZXJyLCB2YV9saXN0IHBhcmFtcykgPSB3YXJuX2J1aWx0aW47CisKK3ZvaWQgc2V0X2RpZV9yb3V0aW5lKHZvaWQgKCpyb3V0aW5lKShjb25zdCBjaGFyICplcnIsIHZhX2xpc3QgcGFyYW1zKSBOT1JFVFVSTikKK3sKKwlkaWVfcm91dGluZSA9IHJvdXRpbmU7Cit9CisKK3ZvaWQgdXNhZ2UoY29uc3QgY2hhciAqZXJyKQoreworCXVzYWdlX3JvdXRpbmUoZXJyKTsKK30KKwordm9pZCBkaWUoY29uc3QgY2hhciAqZXJyLCAuLi4pCit7CisJdmFfbGlzdCBwYXJhbXM7CisKKwl2YV9zdGFydChwYXJhbXMsIGVycik7CisJZGllX3JvdXRpbmUoZXJyLCBwYXJhbXMpOworCXZhX2VuZChwYXJhbXMpOworfQorCitpbnQgZXJyb3IoY29uc3QgY2hhciAqZXJyLCAuLi4pCit7CisJdmFfbGlzdCBwYXJhbXM7CisKKwl2YV9zdGFydChwYXJhbXMsIGVycik7CisJZXJyb3Jfcm91dGluZShlcnIsIHBhcmFtcyk7CisJdmFfZW5kKHBhcmFtcyk7CisJcmV0dXJuIC0xOworfQorCit2b2lkIHdhcm5pbmcoY29uc3QgY2hhciAqd2FybiwgLi4uKQoreworCXZhX2xpc3QgcGFyYW1zOworCisJdmFfc3RhcnQocGFyYW1zLCB3YXJuKTsKKwl3YXJuX3JvdXRpbmUod2FybiwgcGFyYW1zKTsKKwl2YV9lbmQocGFyYW1zKTsKK30KZGlmZiAtLWdpdCBhL3Rvb2xzL3BlcmYvdXRpbC91dGlsLmggYi90b29scy9wZXJmL3V0aWwvdXRpbC5oCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjc2NTkwYTEKLS0tIC9kZXYvbnVsbAorKysgYi90b29scy9wZXJmL3V0aWwvdXRpbC5oCkBAIC0wLDAgKzEsNDEwIEBACisjaWZuZGVmIEdJVF9DT01QQVRfVVRJTF9ICisjZGVmaW5lIEdJVF9DT01QQVRfVVRJTF9ICisKKyNkZWZpbmUgX0ZJTEVfT0ZGU0VUX0JJVFMgNjQKKworI2lmbmRlZiBGTEVYX0FSUkFZCisvKgorICogU2VlIGlmIG91ciBjb21waWxlciBpcyBrbm93biB0byBzdXBwb3J0IGZsZXhpYmxlIGFycmF5IG1lbWJlcnMuCisgKi8KKyNpZiBkZWZpbmVkKF9fU1REQ19WRVJTSU9OX18pICYmIChfX1NURENfVkVSU0lPTl9fID49IDE5OTkwMUwpCisjIGRlZmluZSBGTEVYX0FSUkFZIC8qIGVtcHR5ICovCisjZWxpZiBkZWZpbmVkKF9fR05VQ19fKQorIyBpZiAoX19HTlVDX18gPj0gMykKKyMgIGRlZmluZSBGTEVYX0FSUkFZIC8qIGVtcHR5ICovCisjIGVsc2UKKyMgIGRlZmluZSBGTEVYX0FSUkFZIDAgLyogb2xkZXIgR05VIGV4dGVuc2lvbiAqLworIyBlbmRpZgorI2VuZGlmCisKKy8qCisgKiBPdGhlcndpc2UsIGRlZmF1bHQgdG8gc2FmZXIgYnV0IGEgYml0IHdhc3RlZnVsIHRyYWRpdGlvbmFsIHN0eWxlCisgKi8KKyNpZm5kZWYgRkxFWF9BUlJBWQorIyBkZWZpbmUgRkxFWF9BUlJBWSAxCisjZW5kaWYKKyNlbmRpZgorCisjZGVmaW5lIEFSUkFZX1NJWkUoeCkgKHNpemVvZih4KS9zaXplb2YoeFswXSkpCisKKyNpZmRlZiBfX0dOVUNfXworI2RlZmluZSBUWVBFT0YoeCkgKF9fdHlwZW9mX18oeCkpCisjZWxzZQorI2RlZmluZSBUWVBFT0YoeCkKKyNlbmRpZgorCisjZGVmaW5lIE1TQih4LCBiaXRzKSAoKHgpICYgVFlQRU9GKHgpKH4wVUxMIDw8IChzaXplb2YoeCkgKiA4IC0gKGJpdHMpKSkpCisjZGVmaW5lIEhBU19NVUxUSV9CSVRTKGkpICAoKGkpICYgKChpKSAtIDEpKSAgLyogY2hlY2tzIGlmIGFuIGludGVnZXIgaGFzIG1vcmUgdGhhbiAxIGJpdCBzZXQgKi8KKworLyogQXBwcm94aW1hdGlvbiBvZiB0aGUgbGVuZ3RoIG9mIHRoZSBkZWNpbWFsIHJlcHJlc2VudGF0aW9uIG9mIHRoaXMgdHlwZS4gKi8KKyNkZWZpbmUgZGVjaW1hbF9sZW5ndGgoeCkJKChpbnQpKHNpemVvZih4KSAqIDIuNTYgKyAwLjUpICsgMSkKKworI2lmICFkZWZpbmVkKF9fQVBQTEVfXykgJiYgIWRlZmluZWQoX19GcmVlQlNEX18pICAmJiAhZGVmaW5lZChfX1VTTENfXykgJiYgIWRlZmluZWQoX01fVU5JWCkKKyNkZWZpbmUgX1hPUEVOX1NPVVJDRSA2MDAgLyogZ2xpYmMyIGFuZCBBSVggNS4zTCBuZWVkIDUwMCwgT3BlbkJTRCBuZWVkcyA2MDAgZm9yIFNfSVNMTksoKSAqLworI2RlZmluZSBfWE9QRU5fU09VUkNFX0VYVEVOREVEIDEgLyogQUlYIDUuM0wgbmVlZHMgdGhpcyAqLworI2VuZGlmCisjZGVmaW5lIF9BTExfU09VUkNFIDEKKyNkZWZpbmUgX0dOVV9TT1VSQ0UgMQorI2RlZmluZSBfQlNEX1NPVVJDRSAxCisKKyNpbmNsdWRlIDx1bmlzdGQuaD4KKyNpbmNsdWRlIDxzdGRpby5oPgorI2luY2x1ZGUgPHN5cy9zdGF0Lmg+CisjaW5jbHVkZSA8ZmNudGwuaD4KKyNpbmNsdWRlIDxzdGRkZWYuaD4KKyNpbmNsdWRlIDxzdGRsaWIuaD4KKyNpbmNsdWRlIDxzdGRhcmcuaD4KKyNpbmNsdWRlIDxzdHJpbmcuaD4KKyNpbmNsdWRlIDxlcnJuby5oPgorI2luY2x1ZGUgPGxpbWl0cy5oPgorI2luY2x1ZGUgPHN5cy9wYXJhbS5oPgorI2luY2x1ZGUgPHN5cy90eXBlcy5oPgorI2luY2x1ZGUgPGRpcmVudC5oPgorI2luY2x1ZGUgPHN5cy90aW1lLmg+CisjaW5jbHVkZSA8dGltZS5oPgorI2luY2x1ZGUgPHNpZ25hbC5oPgorI2luY2x1ZGUgPGZubWF0Y2guaD4KKyNpbmNsdWRlIDxhc3NlcnQuaD4KKyNpbmNsdWRlIDxyZWdleC5oPgorI2luY2x1ZGUgPHV0aW1lLmg+CisjaWZuZGVmIF9fTUlOR1czMl9fCisjaW5jbHVkZSA8c3lzL3dhaXQuaD4KKyNpbmNsdWRlIDxzeXMvcG9sbC5oPgorI2luY2x1ZGUgPHN5cy9zb2NrZXQuaD4KKyNpbmNsdWRlIDxzeXMvaW9jdGwuaD4KKyNpZm5kZWYgTk9fU1lTX1NFTEVDVF9ICisjaW5jbHVkZSA8c3lzL3NlbGVjdC5oPgorI2VuZGlmCisjaW5jbHVkZSA8bmV0aW5ldC9pbi5oPgorI2luY2x1ZGUgPG5ldGluZXQvdGNwLmg+CisjaW5jbHVkZSA8YXJwYS9pbmV0Lmg+CisjaW5jbHVkZSA8bmV0ZGIuaD4KKyNpbmNsdWRlIDxwd2QuaD4KKyNpbmNsdWRlIDxpbnR0eXBlcy5oPgorI2lmIGRlZmluZWQoX19DWUdXSU5fXykKKyN1bmRlZiBfWE9QRU5fU09VUkNFCisjaW5jbHVkZSA8Z3JwLmg+CisjZGVmaW5lIF9YT1BFTl9TT1VSQ0UgNjAwCisjaW5jbHVkZSAiY29tcGF0L2N5Z3dpbi5oIgorI2Vsc2UKKyN1bmRlZiBfQUxMX1NPVVJDRSAvKiBBSVggNS4zTCBkZWZpbmVzIGEgc3RydWN0IGxpc3Qgd2l0aCBfQUxMX1NPVVJDRS4gKi8KKyNpbmNsdWRlIDxncnAuaD4KKyNkZWZpbmUgX0FMTF9TT1VSQ0UgMQorI2VuZGlmCisjZWxzZSAJLyogX19NSU5HVzMyX18gKi8KKy8qIHB1bGwgaW4gV2luZG93cyBjb21wYXRpYmlsaXR5IHN0dWZmICovCisjaW5jbHVkZSAiY29tcGF0L21pbmd3LmgiCisjZW5kaWYJLyogX19NSU5HVzMyX18gKi8KKworI2lmbmRlZiBOT19JQ09OVgorI2luY2x1ZGUgPGljb252Lmg+CisjZW5kaWYKKworI2lmbmRlZiBOT19PUEVOU1NMCisjaW5jbHVkZSA8b3BlbnNzbC9zc2wuaD4KKyNpbmNsdWRlIDxvcGVuc3NsL2Vyci5oPgorI2VuZGlmCisKKy8qIE9uIG1vc3Qgc3lzdGVtcyA8bGltaXRzLmg+IHdvdWxkIGhhdmUgZ2l2ZW4gdXMgdGhpcywgYnV0CisgKiBub3Qgb24gc29tZSBzeXN0ZW1zIChlLmcuIEdOVS9IdXJkKS4KKyAqLworI2lmbmRlZiBQQVRIX01BWAorI2RlZmluZSBQQVRIX01BWCA0MDk2CisjZW5kaWYKKworI2lmbmRlZiBQUkl1TUFYCisjZGVmaW5lIFBSSXVNQVggImxsdSIKKyNlbmRpZgorCisjaWZuZGVmIFBSSXUzMgorI2RlZmluZSBQUkl1MzIgInUiCisjZW5kaWYKKworI2lmbmRlZiBQUkl4MzIKKyNkZWZpbmUgUFJJeDMyICJ4IgorI2VuZGlmCisKKyNpZm5kZWYgUEFUSF9TRVAKKyNkZWZpbmUgUEFUSF9TRVAgJzonCisjZW5kaWYKKworI2lmbmRlZiBTVFJJUF9FWFRFTlNJT04KKyNkZWZpbmUgU1RSSVBfRVhURU5TSU9OICIiCisjZW5kaWYKKworI2lmbmRlZiBoYXNfZG9zX2RyaXZlX3ByZWZpeAorI2RlZmluZSBoYXNfZG9zX2RyaXZlX3ByZWZpeChwYXRoKSAwCisjZW5kaWYKKworI2lmbmRlZiBpc19kaXJfc2VwCisjZGVmaW5lIGlzX2Rpcl9zZXAoYykgKChjKSA9PSAnLycpCisjZW5kaWYKKworI2lmZGVmIF9fR05VQ19fCisjZGVmaW5lIE5PUkVUVVJOIF9fYXR0cmlidXRlX18oKF9fbm9yZXR1cm5fXykpCisjZWxzZQorI2RlZmluZSBOT1JFVFVSTgorI2lmbmRlZiBfX2F0dHJpYnV0ZV9fCisjZGVmaW5lIF9fYXR0cmlidXRlX18oeCkKKyNlbmRpZgorI2VuZGlmCisKKy8qIEdlbmVyYWwgaGVscGVyIGZ1bmN0aW9ucyAqLworZXh0ZXJuIHZvaWQgdXNhZ2UoY29uc3QgY2hhciAqZXJyKSBOT1JFVFVSTjsKK2V4dGVybiB2b2lkIGRpZShjb25zdCBjaGFyICplcnIsIC4uLikgTk9SRVRVUk4gX19hdHRyaWJ1dGVfXygoZm9ybWF0IChwcmludGYsIDEsIDIpKSk7CitleHRlcm4gaW50IGVycm9yKGNvbnN0IGNoYXIgKmVyciwgLi4uKSBfX2F0dHJpYnV0ZV9fKChmb3JtYXQgKHByaW50ZiwgMSwgMikpKTsKK2V4dGVybiB2b2lkIHdhcm5pbmcoY29uc3QgY2hhciAqZXJyLCAuLi4pIF9fYXR0cmlidXRlX18oKGZvcm1hdCAocHJpbnRmLCAxLCAyKSkpOworCitleHRlcm4gdm9pZCBzZXRfZGllX3JvdXRpbmUodm9pZCAoKnJvdXRpbmUpKGNvbnN0IGNoYXIgKmVyciwgdmFfbGlzdCBwYXJhbXMpIE5PUkVUVVJOKTsKKworZXh0ZXJuIGludCBwcmVmaXhjbXAoY29uc3QgY2hhciAqc3RyLCBjb25zdCBjaGFyICpwcmVmaXgpOworZXh0ZXJuIHRpbWVfdCB0bV90b190aW1lX3QoY29uc3Qgc3RydWN0IHRtICp0bSk7CisKK3N0YXRpYyBpbmxpbmUgY29uc3QgY2hhciAqc2tpcF9wcmVmaXgoY29uc3QgY2hhciAqc3RyLCBjb25zdCBjaGFyICpwcmVmaXgpCit7CisJc2l6ZV90IGxlbiA9IHN0cmxlbihwcmVmaXgpOworCXJldHVybiBzdHJuY21wKHN0ciwgcHJlZml4LCBsZW4pID8gTlVMTCA6IHN0ciArIGxlbjsKK30KKworI2lmIGRlZmluZWQoTk9fTU1BUCkgfHwgZGVmaW5lZChVU0VfV0lOMzJfTU1BUCkKKworI2lmbmRlZiBQUk9UX1JFQUQKKyNkZWZpbmUgUFJPVF9SRUFEIDEKKyNkZWZpbmUgUFJPVF9XUklURSAyCisjZGVmaW5lIE1BUF9QUklWQVRFIDEKKyNkZWZpbmUgTUFQX0ZBSUxFRCAoKHZvaWQqKS0xKQorI2VuZGlmCisKKyNkZWZpbmUgbW1hcCBnaXRfbW1hcAorI2RlZmluZSBtdW5tYXAgZ2l0X211bm1hcAorZXh0ZXJuIHZvaWQgKmdpdF9tbWFwKHZvaWQgKnN0YXJ0LCBzaXplX3QgbGVuZ3RoLCBpbnQgcHJvdCwgaW50IGZsYWdzLCBpbnQgZmQsIG9mZl90IG9mZnNldCk7CitleHRlcm4gaW50IGdpdF9tdW5tYXAodm9pZCAqc3RhcnQsIHNpemVfdCBsZW5ndGgpOworCisjZWxzZSAvKiBOT19NTUFQIHx8IFVTRV9XSU4zMl9NTUFQICovCisKKyNpbmNsdWRlIDxzeXMvbW1hbi5oPgorCisjZW5kaWYgLyogTk9fTU1BUCB8fCBVU0VfV0lOMzJfTU1BUCAqLworCisjaWZkZWYgTk9fTU1BUAorCisvKiBUaGlzIHZhbHVlIG11c3QgYmUgbXVsdGlwbGUgb2YgKHBhZ2VzaXplICogMikgKi8KKyNkZWZpbmUgREVGQVVMVF9QQUNLRURfR0lUX1dJTkRPV19TSVpFICgxICogMTAyNCAqIDEwMjQpCisKKyNlbHNlIC8qIE5PX01NQVAgKi8KKworLyogVGhpcyB2YWx1ZSBtdXN0IGJlIG11bHRpcGxlIG9mIChwYWdlc2l6ZSAqIDIpICovCisjZGVmaW5lIERFRkFVTFRfUEFDS0VEX0dJVF9XSU5ET1dfU0laRSBcCisJKHNpemVvZih2b2lkKikgPj0gOCBcCisJCT8gIDEgKiAxMDI0ICogMTAyNCAqIDEwMjQgXAorCQk6IDMyICogMTAyNCAqIDEwMjQpCisKKyNlbmRpZiAvKiBOT19NTUFQICovCisKKyNpZmRlZiBOT19TVF9CTE9DS1NfSU5fU1RSVUNUX1NUQVQKKyNkZWZpbmUgb25fZGlza19ieXRlcyhzdCkgKChzdCkuc3Rfc2l6ZSkKKyNlbHNlCisjZGVmaW5lIG9uX2Rpc2tfYnl0ZXMoc3QpICgoc3QpLnN0X2Jsb2NrcyAqIDUxMikKKyNlbmRpZgorCisjZGVmaW5lIERFRkFVTFRfUEFDS0VEX0dJVF9MSU1JVCBcCisJKCgxMDI0TCAqIDEwMjRMKSAqIChzaXplb2Yodm9pZCopID49IDggPyA4MTkyIDogMjU2KSkKKworI2lmZGVmIE5PX1BSRUFECisjZGVmaW5lIHByZWFkIGdpdF9wcmVhZAorZXh0ZXJuIHNzaXplX3QgZ2l0X3ByZWFkKGludCBmZCwgdm9pZCAqYnVmLCBzaXplX3QgY291bnQsIG9mZl90IG9mZnNldCk7CisjZW5kaWYKKy8qCisgKiBGb3J3YXJkIGRlY2wgdGhhdCB3aWxsIHJlbWluZCB1cyBpZiBpdHMgdHdpbiBpbiBjYWNoZS5oIGNoYW5nZXMuCisgKiBUaGlzIGZ1bmN0aW9uIGlzIHVzZWQgaW4gY29tcGF0L3ByZWFkLmMuICBCdXQgd2UgY2FuJ3QgaW5jbHVkZQorICogY2FjaGUuaCB0aGVyZS4KKyAqLworZXh0ZXJuIHNzaXplX3QgcmVhZF9pbl9mdWxsKGludCBmZCwgdm9pZCAqYnVmLCBzaXplX3QgY291bnQpOworCisjaWZkZWYgTk9fU0VURU5WCisjZGVmaW5lIHNldGVudiBnaXRzZXRlbnYKK2V4dGVybiBpbnQgZ2l0c2V0ZW52KGNvbnN0IGNoYXIgKiwgY29uc3QgY2hhciAqLCBpbnQpOworI2VuZGlmCisKKyNpZmRlZiBOT19NS0RURU1QCisjZGVmaW5lIG1rZHRlbXAgZ2l0bWtkdGVtcAorZXh0ZXJuIGNoYXIgKmdpdG1rZHRlbXAoY2hhciAqKTsKKyNlbmRpZgorCisjaWZkZWYgTk9fVU5TRVRFTlYKKyNkZWZpbmUgdW5zZXRlbnYgZ2l0dW5zZXRlbnYKK2V4dGVybiB2b2lkIGdpdHVuc2V0ZW52KGNvbnN0IGNoYXIgKik7CisjZW5kaWYKKworI2lmZGVmIE5PX1NUUkNBU0VTVFIKKyNkZWZpbmUgc3RyY2FzZXN0ciBnaXRzdHJjYXNlc3RyCitleHRlcm4gY2hhciAqZ2l0c3RyY2FzZXN0cihjb25zdCBjaGFyICpoYXlzdGFjaywgY29uc3QgY2hhciAqbmVlZGxlKTsKKyNlbmRpZgorCisjaWZkZWYgTk9fU1RSTENQWQorI2RlZmluZSBzdHJsY3B5IGdpdHN0cmxjcHkKK2V4dGVybiBzaXplX3QgZ2l0c3RybGNweShjaGFyICosIGNvbnN0IGNoYXIgKiwgc2l6ZV90KTsKKyNlbmRpZgorCisjaWZkZWYgTk9fU1RSVE9VTUFYCisjZGVmaW5lIHN0cnRvdW1heCBnaXRzdHJ0b3VtYXgKK2V4dGVybiB1aW50bWF4X3QgZ2l0c3RydG91bWF4KGNvbnN0IGNoYXIgKiwgY2hhciAqKiwgaW50KTsKKyNlbmRpZgorCisjaWZkZWYgTk9fSFNUUkVSUk9SCisjZGVmaW5lIGhzdHJlcnJvciBnaXRoc3RyZXJyb3IKK2V4dGVybiBjb25zdCBjaGFyICpnaXRoc3RyZXJyb3IoaW50IGhlcnJvcik7CisjZW5kaWYKKworI2lmZGVmIE5PX01FTU1FTQorI2RlZmluZSBtZW1tZW0gZ2l0bWVtbWVtCit2b2lkICpnaXRtZW1tZW0oY29uc3Qgdm9pZCAqaGF5c3RhY2ssIHNpemVfdCBoYXlzdGFja2xlbiwKKyAgICAgICAgICAgICAgICBjb25zdCB2b2lkICpuZWVkbGUsIHNpemVfdCBuZWVkbGVsZW4pOworI2VuZGlmCisKKyNpZmRlZiBGUkVBRF9SRUFEU19ESVJFQ1RPUklFUworI2lmZGVmIGZvcGVuCisjdW5kZWYgZm9wZW4KKyNlbmRpZgorI2RlZmluZSBmb3BlbihhLGIpIGdpdF9mb3BlbihhLGIpCitleHRlcm4gRklMRSAqZ2l0X2ZvcGVuKGNvbnN0IGNoYXIqLCBjb25zdCBjaGFyKik7CisjZW5kaWYKKworI2lmZGVmIFNOUFJJTlRGX1JFVFVSTlNfQk9HVVMKKyNkZWZpbmUgc25wcmludGYgZ2l0X3NucHJpbnRmCitleHRlcm4gaW50IGdpdF9zbnByaW50ZihjaGFyICpzdHIsIHNpemVfdCBtYXhzaXplLAorCQkJY29uc3QgY2hhciAqZm9ybWF0LCAuLi4pOworI2RlZmluZSB2c25wcmludGYgZ2l0X3ZzbnByaW50ZgorZXh0ZXJuIGludCBnaXRfdnNucHJpbnRmKGNoYXIgKnN0ciwgc2l6ZV90IG1heHNpemUsCisJCQkgY29uc3QgY2hhciAqZm9ybWF0LCB2YV9saXN0IGFwKTsKKyNlbmRpZgorCisjaWZkZWYgX19HTElCQ19QUkVSRVEKKyNpZiBfX0dMSUJDX1BSRVJFUSgyLCAxKQorI2RlZmluZSBIQVZFX1NUUkNIUk5VTAorI2VuZGlmCisjZW5kaWYKKworI2lmbmRlZiBIQVZFX1NUUkNIUk5VTAorI2RlZmluZSBzdHJjaHJudWwgZ2l0c3RyY2hybnVsCitzdGF0aWMgaW5saW5lIGNoYXIgKmdpdHN0cmNocm51bChjb25zdCBjaGFyICpzLCBpbnQgYykKK3sKKwl3aGlsZSAoKnMgJiYgKnMgIT0gYykKKwkJcysrOworCXJldHVybiAoY2hhciAqKXM7Cit9CisjZW5kaWYKKworLyoKKyAqIFdyYXBwZXJzOgorICovCitleHRlcm4gY2hhciAqeHN0cmR1cChjb25zdCBjaGFyICpzdHIpOworZXh0ZXJuIHZvaWQgKnhtYWxsb2Moc2l6ZV90IHNpemUpOworZXh0ZXJuIHZvaWQgKnhtZW1kdXB6KGNvbnN0IHZvaWQgKmRhdGEsIHNpemVfdCBsZW4pOworZXh0ZXJuIGNoYXIgKnhzdHJuZHVwKGNvbnN0IGNoYXIgKnN0ciwgc2l6ZV90IGxlbik7CitleHRlcm4gdm9pZCAqeHJlYWxsb2Modm9pZCAqcHRyLCBzaXplX3Qgc2l6ZSk7CitleHRlcm4gdm9pZCAqeGNhbGxvYyhzaXplX3Qgbm1lbWIsIHNpemVfdCBzaXplKTsKK2V4dGVybiB2b2lkICp4bW1hcCh2b2lkICpzdGFydCwgc2l6ZV90IGxlbmd0aCwgaW50IHByb3QsIGludCBmbGFncywgaW50IGZkLCBvZmZfdCBvZmZzZXQpOworZXh0ZXJuIHNzaXplX3QgeHJlYWQoaW50IGZkLCB2b2lkICpidWYsIHNpemVfdCBsZW4pOworZXh0ZXJuIHNzaXplX3QgeHdyaXRlKGludCBmZCwgY29uc3Qgdm9pZCAqYnVmLCBzaXplX3QgbGVuKTsKK2V4dGVybiBpbnQgeGR1cChpbnQgZmQpOworZXh0ZXJuIEZJTEUgKnhmZG9wZW4oaW50IGZkLCBjb25zdCBjaGFyICptb2RlKTsKK2V4dGVybiBpbnQgeG1rc3RlbXAoY2hhciAqdGVtcGxhdGUpOworCitzdGF0aWMgaW5saW5lIHNpemVfdCB4c2l6ZV90KG9mZl90IGxlbikKK3sKKwlyZXR1cm4gKHNpemVfdClsZW47Cit9CisKK3N0YXRpYyBpbmxpbmUgaW50IGhhc19leHRlbnNpb24oY29uc3QgY2hhciAqZmlsZW5hbWUsIGNvbnN0IGNoYXIgKmV4dCkKK3sKKwlzaXplX3QgbGVuID0gc3RybGVuKGZpbGVuYW1lKTsKKwlzaXplX3QgZXh0bGVuID0gc3RybGVuKGV4dCk7CisJcmV0dXJuIGxlbiA+IGV4dGxlbiAmJiAhbWVtY21wKGZpbGVuYW1lICsgbGVuIC0gZXh0bGVuLCBleHQsIGV4dGxlbik7Cit9CisKKy8qIFNhbmUgY3R5cGUgLSBubyBsb2NhbGUsIGFuZCB3b3JrcyB3aXRoIHNpZ25lZCBjaGFycyAqLworI3VuZGVmIGlzYXNjaWkKKyN1bmRlZiBpc3NwYWNlCisjdW5kZWYgaXNkaWdpdAorI3VuZGVmIGlzYWxwaGEKKyN1bmRlZiBpc2FsbnVtCisjdW5kZWYgdG9sb3dlcgorI3VuZGVmIHRvdXBwZXIKK2V4dGVybiB1bnNpZ25lZCBjaGFyIHNhbmVfY3R5cGVbMjU2XTsKKyNkZWZpbmUgR0lUX1NQQUNFIDB4MDEKKyNkZWZpbmUgR0lUX0RJR0lUIDB4MDIKKyNkZWZpbmUgR0lUX0FMUEhBIDB4MDQKKyNkZWZpbmUgR0lUX0dMT0JfU1BFQ0lBTCAweDA4CisjZGVmaW5lIEdJVF9SRUdFWF9TUEVDSUFMIDB4MTAKKyNkZWZpbmUgc2FuZV9pc3Rlc3QoeCxtYXNrKSAoKHNhbmVfY3R5cGVbKHVuc2lnbmVkIGNoYXIpKHgpXSAmIChtYXNrKSkgIT0gMCkKKyNkZWZpbmUgaXNhc2NpaSh4KSAoKCh4KSAmIH4weDdmKSA9PSAwKQorI2RlZmluZSBpc3NwYWNlKHgpIHNhbmVfaXN0ZXN0KHgsR0lUX1NQQUNFKQorI2RlZmluZSBpc2RpZ2l0KHgpIHNhbmVfaXN0ZXN0KHgsR0lUX0RJR0lUKQorI2RlZmluZSBpc2FscGhhKHgpIHNhbmVfaXN0ZXN0KHgsR0lUX0FMUEhBKQorI2RlZmluZSBpc2FsbnVtKHgpIHNhbmVfaXN0ZXN0KHgsR0lUX0FMUEhBIHwgR0lUX0RJR0lUKQorI2RlZmluZSBpc19nbG9iX3NwZWNpYWwoeCkgc2FuZV9pc3Rlc3QoeCxHSVRfR0xPQl9TUEVDSUFMKQorI2RlZmluZSBpc19yZWdleF9zcGVjaWFsKHgpIHNhbmVfaXN0ZXN0KHgsR0lUX0dMT0JfU1BFQ0lBTCB8IEdJVF9SRUdFWF9TUEVDSUFMKQorI2RlZmluZSB0b2xvd2VyKHgpIHNhbmVfY2FzZSgodW5zaWduZWQgY2hhcikoeCksIDB4MjApCisjZGVmaW5lIHRvdXBwZXIoeCkgc2FuZV9jYXNlKCh1bnNpZ25lZCBjaGFyKSh4KSwgMCkKKworc3RhdGljIGlubGluZSBpbnQgc2FuZV9jYXNlKGludCB4LCBpbnQgaGlnaCkKK3sKKwlpZiAoc2FuZV9pc3Rlc3QoeCwgR0lUX0FMUEhBKSkKKwkJeCA9ICh4ICYgfjB4MjApIHwgaGlnaDsKKwlyZXR1cm4geDsKK30KKworc3RhdGljIGlubGluZSBpbnQgc3RydG91bF91aShjaGFyIGNvbnN0ICpzLCBpbnQgYmFzZSwgdW5zaWduZWQgaW50ICpyZXN1bHQpCit7CisJdW5zaWduZWQgbG9uZyB1bDsKKwljaGFyICpwOworCisJZXJybm8gPSAwOworCXVsID0gc3RydG91bChzLCAmcCwgYmFzZSk7CisJaWYgKGVycm5vIHx8ICpwIHx8IHAgPT0gcyB8fCAodW5zaWduZWQgaW50KSB1bCAhPSB1bCkKKwkJcmV0dXJuIC0xOworCSpyZXN1bHQgPSB1bDsKKwlyZXR1cm4gMDsKK30KKworc3RhdGljIGlubGluZSBpbnQgc3RydG9sX2koY2hhciBjb25zdCAqcywgaW50IGJhc2UsIGludCAqcmVzdWx0KQoreworCWxvbmcgdWw7CisJY2hhciAqcDsKKworCWVycm5vID0gMDsKKwl1bCA9IHN0cnRvbChzLCAmcCwgYmFzZSk7CisJaWYgKGVycm5vIHx8ICpwIHx8IHAgPT0gcyB8fCAoaW50KSB1bCAhPSB1bCkKKwkJcmV0dXJuIC0xOworCSpyZXN1bHQgPSB1bDsKKwlyZXR1cm4gMDsKK30KKworI2lmZGVmIElOVEVSTkFMX1FTT1JUCit2b2lkIGdpdF9xc29ydCh2b2lkICpiYXNlLCBzaXplX3Qgbm1lbWIsIHNpemVfdCBzaXplLAorCSAgICAgICBpbnQoKmNvbXBhcikoY29uc3Qgdm9pZCAqLCBjb25zdCB2b2lkICopKTsKKyNkZWZpbmUgcXNvcnQgZ2l0X3Fzb3J0CisjZW5kaWYKKworI2lmbmRlZiBESVJfSEFTX0JTRF9HUk9VUF9TRU1BTlRJQ1MKKyMgZGVmaW5lIEZPUkNFX0RJUl9TRVRfR0lEIFNfSVNHSUQKKyNlbHNlCisjIGRlZmluZSBGT1JDRV9ESVJfU0VUX0dJRCAwCisjZW5kaWYKKworI2lmZGVmIE5PX05TRUMKKyN1bmRlZiBVU0VfTlNFQworI2RlZmluZSBTVF9DVElNRV9OU0VDKHN0KSAwCisjZGVmaW5lIFNUX01USU1FX05TRUMoc3QpIDAKKyNlbHNlCisjaWZkZWYgVVNFX1NUX1RJTUVTUEVDCisjZGVmaW5lIFNUX0NUSU1FX05TRUMoc3QpICgodW5zaWduZWQgaW50KSgoc3QpLnN0X2N0aW1lc3BlYy50dl9uc2VjKSkKKyNkZWZpbmUgU1RfTVRJTUVfTlNFQyhzdCkgKCh1bnNpZ25lZCBpbnQpKChzdCkuc3RfbXRpbWVzcGVjLnR2X25zZWMpKQorI2Vsc2UKKyNkZWZpbmUgU1RfQ1RJTUVfTlNFQyhzdCkgKCh1bnNpZ25lZCBpbnQpKChzdCkuc3RfY3RpbS50dl9uc2VjKSkKKyNkZWZpbmUgU1RfTVRJTUVfTlNFQyhzdCkgKCh1bnNpZ25lZCBpbnQpKChzdCkuc3RfbXRpbS50dl9uc2VjKSkKKyNlbmRpZgorI2VuZGlmCisKKyNlbmRpZgpkaWZmIC0tZ2l0IGEvdG9vbHMvcGVyZi91dGlsL3dyYXBwZXIuYyBiL3Rvb2xzL3BlcmYvdXRpbC93cmFwcGVyLmMKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uNjM1MGQ2NQotLS0gL2Rldi9udWxsCisrKyBiL3Rvb2xzL3BlcmYvdXRpbC93cmFwcGVyLmMKQEAgLTAsMCArMSwyMDYgQEAKKy8qCisgKiBWYXJpb3VzIHRyaXZpYWwgaGVscGVyIHdyYXBwZXJzIGFyb3VuZCBzdGFuZGFyZCBmdW5jdGlvbnMKKyAqLworI2luY2x1ZGUgImNhY2hlLmgiCisKKy8qCisgKiBUaGVyZSdzIG5vIHBhY2sgbWVtb3J5IHRvIHJlbGVhc2UgLSBidXQgc3RheSBjbG9zZSB0byB0aGUgR2l0CisgKiB2ZXJzaW9uIHNvIHdyYXAgdGhpcyBhd2F5OgorICovCitzdGF0aWMgaW5saW5lIHZvaWQgcmVsZWFzZV9wYWNrX21lbW9yeShzaXplX3Qgc2l6ZSwgaW50IGZsYWcpCit7Cit9CisKK2NoYXIgKnhzdHJkdXAoY29uc3QgY2hhciAqc3RyKQoreworCWNoYXIgKnJldCA9IHN0cmR1cChzdHIpOworCWlmICghcmV0KSB7CisJCXJlbGVhc2VfcGFja19tZW1vcnkoc3RybGVuKHN0cikgKyAxLCAtMSk7CisJCXJldCA9IHN0cmR1cChzdHIpOworCQlpZiAoIXJldCkKKwkJCWRpZSgiT3V0IG9mIG1lbW9yeSwgc3RyZHVwIGZhaWxlZCIpOworCX0KKwlyZXR1cm4gcmV0OworfQorCit2b2lkICp4bWFsbG9jKHNpemVfdCBzaXplKQoreworCXZvaWQgKnJldCA9IG1hbGxvYyhzaXplKTsKKwlpZiAoIXJldCAmJiAhc2l6ZSkKKwkJcmV0ID0gbWFsbG9jKDEpOworCWlmICghcmV0KSB7CisJCXJlbGVhc2VfcGFja19tZW1vcnkoc2l6ZSwgLTEpOworCQlyZXQgPSBtYWxsb2Moc2l6ZSk7CisJCWlmICghcmV0ICYmICFzaXplKQorCQkJcmV0ID0gbWFsbG9jKDEpOworCQlpZiAoIXJldCkKKwkJCWRpZSgiT3V0IG9mIG1lbW9yeSwgbWFsbG9jIGZhaWxlZCIpOworCX0KKyNpZmRlZiBYTUFMTE9DX1BPSVNPTgorCW1lbXNldChyZXQsIDB4QTUsIHNpemUpOworI2VuZGlmCisJcmV0dXJuIHJldDsKK30KKworLyoKKyAqIHhtZW1kdXB6KCkgYWxsb2NhdGVzIChsZW4gKyAxKSBieXRlcyBvZiBtZW1vcnksIGR1cGxpY2F0ZXMgImxlbiIgYnl0ZXMgb2YKKyAqICJkYXRhIiB0byB0aGUgYWxsb2NhdGVkIG1lbW9yeSwgemVybyB0ZXJtaW5hdGVzIHRoZSBhbGxvY2F0ZWQgbWVtb3J5LAorICogYW5kIHJldHVybnMgYSBwb2ludGVyIHRvIHRoZSBhbGxvY2F0ZWQgbWVtb3J5LiBJZiB0aGUgYWxsb2NhdGlvbiBmYWlscywKKyAqIHRoZSBwcm9ncmFtIGRpZXMuCisgKi8KK3ZvaWQgKnhtZW1kdXB6KGNvbnN0IHZvaWQgKmRhdGEsIHNpemVfdCBsZW4pCit7CisJY2hhciAqcCA9IHhtYWxsb2MobGVuICsgMSk7CisJbWVtY3B5KHAsIGRhdGEsIGxlbik7CisJcFtsZW5dID0gJ1wwJzsKKwlyZXR1cm4gcDsKK30KKworY2hhciAqeHN0cm5kdXAoY29uc3QgY2hhciAqc3RyLCBzaXplX3QgbGVuKQoreworCWNoYXIgKnAgPSBtZW1jaHIoc3RyLCAnXDAnLCBsZW4pOworCXJldHVybiB4bWVtZHVweihzdHIsIHAgPyBwIC0gc3RyIDogbGVuKTsKK30KKwordm9pZCAqeHJlYWxsb2Modm9pZCAqcHRyLCBzaXplX3Qgc2l6ZSkKK3sKKwl2b2lkICpyZXQgPSByZWFsbG9jKHB0ciwgc2l6ZSk7CisJaWYgKCFyZXQgJiYgIXNpemUpCisJCXJldCA9IHJlYWxsb2MocHRyLCAxKTsKKwlpZiAoIXJldCkgeworCQlyZWxlYXNlX3BhY2tfbWVtb3J5KHNpemUsIC0xKTsKKwkJcmV0ID0gcmVhbGxvYyhwdHIsIHNpemUpOworCQlpZiAoIXJldCAmJiAhc2l6ZSkKKwkJCXJldCA9IHJlYWxsb2MocHRyLCAxKTsKKwkJaWYgKCFyZXQpCisJCQlkaWUoIk91dCBvZiBtZW1vcnksIHJlYWxsb2MgZmFpbGVkIik7CisJfQorCXJldHVybiByZXQ7Cit9CisKK3ZvaWQgKnhjYWxsb2Moc2l6ZV90IG5tZW1iLCBzaXplX3Qgc2l6ZSkKK3sKKwl2b2lkICpyZXQgPSBjYWxsb2Mobm1lbWIsIHNpemUpOworCWlmICghcmV0ICYmICghbm1lbWIgfHwgIXNpemUpKQorCQlyZXQgPSBjYWxsb2MoMSwgMSk7CisJaWYgKCFyZXQpIHsKKwkJcmVsZWFzZV9wYWNrX21lbW9yeShubWVtYiAqIHNpemUsIC0xKTsKKwkJcmV0ID0gY2FsbG9jKG5tZW1iLCBzaXplKTsKKwkJaWYgKCFyZXQgJiYgKCFubWVtYiB8fCAhc2l6ZSkpCisJCQlyZXQgPSBjYWxsb2MoMSwgMSk7CisJCWlmICghcmV0KQorCQkJZGllKCJPdXQgb2YgbWVtb3J5LCBjYWxsb2MgZmFpbGVkIik7CisJfQorCXJldHVybiByZXQ7Cit9CisKK3ZvaWQgKnhtbWFwKHZvaWQgKnN0YXJ0LCBzaXplX3QgbGVuZ3RoLAorCWludCBwcm90LCBpbnQgZmxhZ3MsIGludCBmZCwgb2ZmX3Qgb2Zmc2V0KQoreworCXZvaWQgKnJldCA9IG1tYXAoc3RhcnQsIGxlbmd0aCwgcHJvdCwgZmxhZ3MsIGZkLCBvZmZzZXQpOworCWlmIChyZXQgPT0gTUFQX0ZBSUxFRCkgeworCQlpZiAoIWxlbmd0aCkKKwkJCXJldHVybiBOVUxMOworCQlyZWxlYXNlX3BhY2tfbWVtb3J5KGxlbmd0aCwgZmQpOworCQlyZXQgPSBtbWFwKHN0YXJ0LCBsZW5ndGgsIHByb3QsIGZsYWdzLCBmZCwgb2Zmc2V0KTsKKwkJaWYgKHJldCA9PSBNQVBfRkFJTEVEKQorCQkJZGllKCJPdXQgb2YgbWVtb3J5PyBtbWFwIGZhaWxlZDogJXMiLCBzdHJlcnJvcihlcnJubykpOworCX0KKwlyZXR1cm4gcmV0OworfQorCisvKgorICogeHJlYWQoKSBpcyB0aGUgc2FtZSBhIHJlYWQoKSwgYnV0IGl0IGF1dG9tYXRpY2FsbHkgcmVzdGFydHMgcmVhZCgpCisgKiBvcGVyYXRpb25zIHdpdGggYSByZWNvdmVyYWJsZSBlcnJvciAoRUFHQUlOIGFuZCBFSU5UUikuIHhyZWFkKCkKKyAqIERPRVMgTk9UIEdVQVJBTlRFRSB0aGF0ICJsZW4iIGJ5dGVzIGlzIHJlYWQgZXZlbiBpZiB0aGUgZGF0YSBpcyBhdmFpbGFibGUuCisgKi8KK3NzaXplX3QgeHJlYWQoaW50IGZkLCB2b2lkICpidWYsIHNpemVfdCBsZW4pCit7CisJc3NpemVfdCBucjsKKwl3aGlsZSAoMSkgeworCQluciA9IHJlYWQoZmQsIGJ1ZiwgbGVuKTsKKwkJaWYgKChuciA8IDApICYmIChlcnJubyA9PSBFQUdBSU4gfHwgZXJybm8gPT0gRUlOVFIpKQorCQkJY29udGludWU7CisJCXJldHVybiBucjsKKwl9Cit9CisKKy8qCisgKiB4d3JpdGUoKSBpcyB0aGUgc2FtZSBhIHdyaXRlKCksIGJ1dCBpdCBhdXRvbWF0aWNhbGx5IHJlc3RhcnRzIHdyaXRlKCkKKyAqIG9wZXJhdGlvbnMgd2l0aCBhIHJlY292ZXJhYmxlIGVycm9yIChFQUdBSU4gYW5kIEVJTlRSKS4geHdyaXRlKCkgRE9FUyBOT1QKKyAqIEdVQVJBTlRFRSB0aGF0ICJsZW4iIGJ5dGVzIGlzIHdyaXR0ZW4gZXZlbiBpZiB0aGUgb3BlcmF0aW9uIGlzIHN1Y2Nlc3NmdWwuCisgKi8KK3NzaXplX3QgeHdyaXRlKGludCBmZCwgY29uc3Qgdm9pZCAqYnVmLCBzaXplX3QgbGVuKQoreworCXNzaXplX3QgbnI7CisJd2hpbGUgKDEpIHsKKwkJbnIgPSB3cml0ZShmZCwgYnVmLCBsZW4pOworCQlpZiAoKG5yIDwgMCkgJiYgKGVycm5vID09IEVBR0FJTiB8fCBlcnJubyA9PSBFSU5UUikpCisJCQljb250aW51ZTsKKwkJcmV0dXJuIG5yOworCX0KK30KKworc3NpemVfdCByZWFkX2luX2Z1bGwoaW50IGZkLCB2b2lkICpidWYsIHNpemVfdCBjb3VudCkKK3sKKwljaGFyICpwID0gYnVmOworCXNzaXplX3QgdG90YWwgPSAwOworCisJd2hpbGUgKGNvdW50ID4gMCkgeworCQlzc2l6ZV90IGxvYWRlZCA9IHhyZWFkKGZkLCBwLCBjb3VudCk7CisJCWlmIChsb2FkZWQgPD0gMCkKKwkJCXJldHVybiB0b3RhbCA/IHRvdGFsIDogbG9hZGVkOworCQljb3VudCAtPSBsb2FkZWQ7CisJCXAgKz0gbG9hZGVkOworCQl0b3RhbCArPSBsb2FkZWQ7CisJfQorCisJcmV0dXJuIHRvdGFsOworfQorCitzc2l6ZV90IHdyaXRlX2luX2Z1bGwoaW50IGZkLCBjb25zdCB2b2lkICpidWYsIHNpemVfdCBjb3VudCkKK3sKKwljb25zdCBjaGFyICpwID0gYnVmOworCXNzaXplX3QgdG90YWwgPSAwOworCisJd2hpbGUgKGNvdW50ID4gMCkgeworCQlzc2l6ZV90IHdyaXR0ZW4gPSB4d3JpdGUoZmQsIHAsIGNvdW50KTsKKwkJaWYgKHdyaXR0ZW4gPCAwKQorCQkJcmV0dXJuIC0xOworCQlpZiAoIXdyaXR0ZW4pIHsKKwkJCWVycm5vID0gRU5PU1BDOworCQkJcmV0dXJuIC0xOworCQl9CisJCWNvdW50IC09IHdyaXR0ZW47CisJCXAgKz0gd3JpdHRlbjsKKwkJdG90YWwgKz0gd3JpdHRlbjsKKwl9CisKKwlyZXR1cm4gdG90YWw7Cit9CisKK2ludCB4ZHVwKGludCBmZCkKK3sKKwlpbnQgcmV0ID0gZHVwKGZkKTsKKwlpZiAocmV0IDwgMCkKKwkJZGllKCJkdXAgZmFpbGVkOiAlcyIsIHN0cmVycm9yKGVycm5vKSk7CisJcmV0dXJuIHJldDsKK30KKworRklMRSAqeGZkb3BlbihpbnQgZmQsIGNvbnN0IGNoYXIgKm1vZGUpCit7CisJRklMRSAqc3RyZWFtID0gZmRvcGVuKGZkLCBtb2RlKTsKKwlpZiAoc3RyZWFtID09IE5VTEwpCisJCWRpZSgiT3V0IG9mIG1lbW9yeT8gZmRvcGVuIGZhaWxlZDogJXMiLCBzdHJlcnJvcihlcnJubykpOworCXJldHVybiBzdHJlYW07Cit9CisKK2ludCB4bWtzdGVtcChjaGFyICp0ZW1wbGF0ZSkKK3sKKwlpbnQgZmQ7CisKKwlmZCA9IG1rc3RlbXAodGVtcGxhdGUpOworCWlmIChmZCA8IDApCisJCWRpZSgiVW5hYmxlIHRvIGNyZWF0ZSB0ZW1wb3JhcnkgZmlsZTogJXMiLCBzdHJlcnJvcihlcnJubykpOworCXJldHVybiBmZDsKK30K