LyoKICogQXV0aG9yczoKICogQ29weXJpZ2h0IDIwMDEsIDIwMDIgYnkgUm9iZXJ0IE9sc3NvbiA8cm9iZXJ0Lm9sc3NvbkBpdHMudXUuc2U+CiAqICAgICAgICAgICAgICAgICAgICAgICAgICAgICBVcHBzYWxhIFVuaXZlcnNpdHkgYW5kCiAqICAgICAgICAgICAgICAgICAgICAgICAgICAgICBTd2VkaXNoIFVuaXZlcnNpdHkgb2YgQWdyaWN1bHR1cmFsIFNjaWVuY2VzCiAqCiAqIEFsZXhleSBLdXpuZXRzb3YgIDxrdXpuZXRAbXMyLmluci5hYy5ydT4KICogQmVuIEdyZWVhciA8Z3JlZWFyYkBjYW5kZWxhdGVjaC5jb20+CiAqIEplbnMgTOXlcyA8amVucy5sYWFzQGRhdGEuc2x1LnNlPgogKgogKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yCiAqIG1vZGlmeSBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlCiAqIGFzIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uOyBlaXRoZXIgdmVyc2lvbgogKiAyIG9mIHRoZSBMaWNlbnNlLCBvciAoYXQgeW91ciBvcHRpb24pIGFueSBsYXRlciB2ZXJzaW9uLgogKgogKgogKiBBIHRvb2wgZm9yIGxvYWRpbmcgdGhlIG5ldHdvcmsgd2l0aCBwcmVjb25maWd1cmF0ZWQgcGFja2V0cy4KICogVGhlIHRvb2wgaXMgaW1wbGVtZW50ZWQgYXMgYSBsaW51eCBtb2R1bGUuICBQYXJhbWV0ZXJzIGFyZSBvdXRwdXQgCiAqIGRldmljZSwgZGVsYXkgKHRvIGhhcmRfeG1pdCksIG51bWJlciBvZiBwYWNrZXRzLCBhbmQgd2hldGhlcgogKiB0byB1c2UgbXVsdGlwbGUgU0tCcyBvciBqdXN0IHRoZSBzYW1lIG9uZS4KICogcGt0Z2VuIHVzZXMgdGhlIGluc3RhbGxlZCBpbnRlcmZhY2UncyBvdXRwdXQgcm91dGluZS4KICoKICogQWRkaXRpb25hbCBoYWNraW5nIGJ5OgogKgogKiBKZW5zLkxhYXNAZGF0YS5zbHUuc2UKICogSW1wcm92ZWQgYnkgQU5LLiAwMTAxMjAuCiAqIEltcHJvdmVkIGJ5IEFOSyBldmVuIG1vcmUuIDAxMDIxMi4KICogTUFDIGFkZHJlc3MgdHlwbyBmaXhlZC4gMDEwNDE3IC0tcm8KICogSW50ZWdyYXRlZC4gIDAyMDMwMSAtLURhdmVNCiAqIEFkZGVkIG11bHRpc2tiIG9wdGlvbiAwMjAzMDEgLS1EYXZlTQogKiBTY2FsaW5nIG9mIHJlc3VsdHMuIDAyMDQxNy0tc2lndXJkdXJAbGlucHJvLm5vCiAqIFNpZ25pZmljYW50IHJlLXdvcmsgb2YgdGhlIG1vZHVsZToKICogICAqICBDb252ZXJ0IHRvIHRocmVhZGVkIG1vZGVsIHRvIG1vcmUgZWZmaWNpZW50bHkgYmUgYWJsZSB0byB0cmFuc21pdAogKiAgICAgICBhbmQgcmVjZWl2ZSBvbiBtdWx0aXBsZSBpbnRlcmZhY2VzIGF0IG9uY2UuCiAqICAgKiAgQ29udmVydGVkIG1hbnkgY291bnRlcnMgdG8gX191NjQgdG8gYWxsb3cgbG9uZ2VyIHJ1bnMuCiAqICAgKiAgQWxsb3cgY29uZmlndXJhdGlvbiBvZiByYW5nZXMsIGxpa2UgbWluL21heCBJUCBhZGRyZXNzLCBNQUNzLAogKiAgICAgICBhbmQgVURQLXBvcnRzLCBmb3IgYm90aCBzb3VyY2UgYW5kIGRlc3RpbmF0aW9uLCBhbmQgY2FuCiAqICAgICAgIHNldCB0byB1c2UgYSByYW5kb20gZGlzdHJpYnV0aW9uIG9yIHNlcXVlbnRpYWxseSB3YWxrIHRoZSByYW5nZS4KICogICAqICBDYW4gbm93IGNoYW5nZSBtb3N0IHZhbHVlcyBhZnRlciBzdGFydGluZy4KICogICAqICBQbGFjZSAxMi1ieXRlIHBhY2tldCBpbiBVRFAgcGF5bG9hZCB3aXRoIG1hZ2ljIG51bWJlciwKICogICAgICAgc2VxdWVuY2UgbnVtYmVyLCBhbmQgdGltZXN0YW1wLgogKiAgICogIEFkZCByZWNlaXZlciBjb2RlIHRoYXQgZGV0ZWN0cyBkcm9wcGVkIHBrdHMsIHJlLW9yZGVyZWQgcGt0cywgYW5kCiAqICAgICAgIGxhdGVuY2llcyAod2l0aCBtaWNyby1zZWNvbmQpIHByZWNpc2lvbi4KICogICAqICBBZGQgSU9DVEwgaW50ZXJmYWNlIHRvIGVhc2lseSBnZXQgY291bnRlcnMgJiBjb25maWd1cmF0aW9uLgogKiAgIC0tQmVuIEdyZWVhciA8Z3JlZWFyYkBjYW5kZWxhdGVjaC5jb20+CiAqCiAqIFJlbmFtZWQgbXVsdGlza2IgdG8gY2xvbmVfc2tiIGFuZCBjbGVhbmVkIHVwIHNlbmRpbmcgY29yZSBmb3IgdHdvIGRpc3RpbmN0IAogKiBza2IgbW9kZXMuIEEgY2xvbmVfc2tiPTAgbW9kZSBmb3IgQmVuICJyYW5nZXMiIHdvcmsgYW5kIGEgY2xvbmVfc2tiICE9IDAgCiAqIGFzIGEgImZhc3RwYXRoIiB3aXRoIGEgY29uZmlndXJhYmxlIG51bWJlciBvZiBjbG9uZXMgYWZ0ZXIgYWxsb2Mncy4KICogY2xvbmVfc2tiPTAgbWVhbnMgYWxsIHBhY2tldHMgYXJlIGFsbG9jYXRlZCB0aGlzIGFsc28gbWVhbnMgcmFuZ2VzIHRpbWUgCiAqIHN0YW1wcyBldGMgY2FuIGJlIHVzZWQuIGNsb25lX3NrYj0xMDAgbWVhbnMgMSBtYWxsb2MgaXMgZm9sbG93ZWQgYnkgMTAwIAogKiBjbG9uZXMuCiAqCiAqIEFsc28gbW92ZWQgdG8gL3Byb2MvbmV0L3BrdGdlbi8gCiAqIC0tcm8KICoKICogU2VwdCAxMDogIEZpeGVkIHRocmVhZGluZy9sb2NraW5nLiAgTG90cyBvZiBib25lLWhlYWRlZCBhbmQgbW9yZSBjbGV2ZXIKICogICAgbWlzdGFrZXMuICBBbHNvIG1lcmdlZCBpbiBEYXZlTSdzIHBhdGNoIGluIHRoZSAtcHJlNiBwYXRjaC4KICogLS1CZW4gR3JlZWFyIDxncmVlYXJiQGNhbmRlbGF0ZWNoLmNvbT4KICoKICogSW50ZWdyYXRlZCB0byAyLjUueCAwMjEwMjkgLS1MdWNpbyBNYWNpZWwgKGx1Y2lvbWFjaWVsQHppcG1haWwuY29tLmJyKQogKgogKiAKICogMDIxMTI0IEZpbmlzaGVkIG1ham9yIHJlZGVzaWduIGFuZCByZXdyaXRlIGZvciBuZXcgZnVuY3Rpb25hbGl0eS4KICogU2VlIERvY3VtZW50YXRpb24vbmV0d29ya2luZy9wa3RnZW4udHh0IGZvciBob3cgdG8gdXNlIHRoaXMuCiAqCiAqIFRoZSBuZXcgb3BlcmF0aW9uOgogKiBGb3IgZWFjaCBDUFUgb25lIHRocmVhZC9wcm9jZXNzIGlzIGNyZWF0ZWQgYXQgc3RhcnQuIFRoaXMgcHJvY2VzcyBjaGVja3MgCiAqIGZvciBydW5uaW5nIGRldmljZXMgaW4gdGhlIGlmX2xpc3QgYW5kIHNlbmRzIHBhY2tldHMgdW50aWwgY291bnQgaXMgMCBpdCAKICogYWxzbyB0aGUgdGhyZWFkIGNoZWNrcyB0aGUgdGhyZWFkLT5jb250cm9sIHdoaWNoIGlzIHVzZWQgZm9yIGludGVyLXByb2Nlc3MgCiAqIGNvbW11bmljYXRpb24uIGNvbnRyb2xsaW5nIHByb2Nlc3MgInBvc3RzIiBvcGVyYXRpb25zIHRvIHRoZSB0aHJlYWRzIHRoaXMgCiAqIHdheS4gVGhlIGlmX2xvY2sgc2hvdWxkIGJlIHBvc3NpYmxlIHRvIHJlbW92ZSB3aGVuIGFkZC9yZW1fZGV2aWNlIGlzIG1lcmdlZAogKiBpbnRvIHRoaXMgdG9vLgogKgogKiBCeSBkZXNpZ24gdGhlcmUgc2hvdWxkIG9ubHkgYmUgKm9uZSogImNvbnRyb2xsaW5nIiBwcm9jZXNzLiBJbiBwcmFjdGljZSAKICogbXVsdGlwbGUgd3JpdGUgYWNjZXNzZXMgZ2l2ZXMgdW5wcmVkaWN0YWJsZSByZXN1bHQuIFVuZGVyc3Rvb2QgYnkgIndyaXRlIiAKICogdG8gL3Byb2MgZ2l2ZXMgcmVzdWx0IGNvZGUgdGhhdHMgc2hvdWxkIGJlIHJlYWQgYmUgdGhlICJ3cml0ZXIiLgogKiBGb3IgcHJhY3RpY2FsIHVzZSB0aGlzIHNob3VsZCBiZSBubyBwcm9ibGVtLgogKgogKiBOb3RlIHdoZW4gYWRkaW5nIGRldmljZXMgdG8gYSBzcGVjaWZpYyBDUFUgdGhlcmUgZ29vZCBpZGVhIHRvIGFsc28gYXNzaWduIAogKiAvcHJvYy9pcnEvWFgvc21wX2FmZmluaXR5IHNvIFRYLWludGVycnVwdHMgZ2V0cyBib3VuZCB0byB0aGUgc2FtZSBDUFUuIAogKiAtLXJvCiAqCiAqIEZpeCByZWZjb3VudCBvZmYgYnkgb25lIGlmIGZpcnN0IHBhY2tldCBmYWlscywgcG90ZW50aWFsIG51bGwgZGVyZWYsIAogKiBtZW1sZWFrIDAzMDcxMC0gS0pQCiAqCiAqIEZpcnN0ICJyYW5nZXMiIGZ1bmN0aW9uYWxpdHkgZm9yIGlwdjYgMDMwNzI2IC0tcm8KICoKICogSW5jbHVkZWQgZmxvdyBzdXBwb3J0LiAwMzA4MDIgQU5LLgogKgogKiBGaXhlZCB1bmFsaWduZWQgYWNjZXNzIG9uIElBLTY0IEdyYW50IEdydW5kbGVyIDxncnVuZGxlckBwYXJpc2MtbGludXgub3JnPgogKiAKICogUmVtb3ZlIGlmIGZpeCBmcm9tIGFkZGVkIEhhcmFsZCBXZWx0ZSA8bGFmb3JnZUBuZXRmaWx0ZXIub3JnPiAwNDA0MTkKICogaWE2NCBjb21waWxhdGlvbiBmaXggZnJvbSAgQXJvbiBHcmlmZmlzIDxhcm9uQGhwLmNvbT4gMDQwNjA0CiAqCiAqIE5ldyB4bWl0KCkgcmV0dXJuLCBkb19kaXYgYW5kIG1pc2MgY2xlYW4gdXAgYnkgU3RlcGhlbiBIZW1taW5nZXIgCiAqIDxzaGVtbWluZ2VyQG9zZGwub3JnPiAwNDA5MjMKICoKICogUmFuZHkgRHVubGFwIGZpeGVkIHU2NCBwcmludGsgY29tcGlsZXIgd2FyaW5nIAogKgogKiBSZW1vdmUgRkNTIGZyb20gQlcgY2FsY3VsYXRpb24uICBMZW5uZXJ0IEJ1eXRlbmhlayA8YnV5dGVuaEB3YW50c3RvZmx5Lm9yZz4KICogTmV3IHRpbWUgaGFuZGxpbmcuIExlbm5lcnQgQnV5dGVuaGVrIDxidXl0ZW5oQHdhbnRzdG9mbHkub3JnPiAwNDEyMTMKICoKICogQ29ycmVjdGlvbnMgZnJvbSBOaWtvbGFpIE1hbHlraCAobm1hbHlraEBiaWxpbS5jb20pIAogKiBSZW1vdmVkIHVudXNlZCBmbGFncyBGX1NFVF9TUkNNQUMgJiBGX1NFVF9TUkNJUCAwNDEyMzAKICoKICogaW50ZXJydXB0aWJsZV9zbGVlcF9vbl90aW1lb3V0KCkgcmVwbGFjZWQgTmlzaGFudGggQXJhdmFtdWRhbiA8bmFjY0B1cy5pYm0uY29tPiAKICogMDUwMTAzCiAqCiAqIE1QTFMgc3VwcG9ydCBieSBTdGV2ZW4gV2hpdGVob3VzZSA8c3RldmVAY2h5Z3d5bi5jb20+CiAqCiAqIDgwMi4xUS9RLWluLVEgc3VwcG9ydCBieSBGcmFuY2VzY28gRm9uZGVsbGkgKEZGKSA8ZnJhbmNlc2NvLmZvbmRlbGxpQGdtYWlsLmNvbT4KICoKICovCiNpbmNsdWRlIDxsaW51eC9zeXMuaD4KI2luY2x1ZGUgPGxpbnV4L3R5cGVzLmg+CiNpbmNsdWRlIDxsaW51eC9tb2R1bGUuaD4KI2luY2x1ZGUgPGxpbnV4L21vZHVsZXBhcmFtLmg+CiNpbmNsdWRlIDxsaW51eC9rZXJuZWwuaD4KI2luY2x1ZGUgPGxpbnV4L3NtcF9sb2NrLmg+CiNpbmNsdWRlIDxsaW51eC9tdXRleC5oPgojaW5jbHVkZSA8bGludXgvc2NoZWQuaD4KI2luY2x1ZGUgPGxpbnV4L3NsYWIuaD4KI2luY2x1ZGUgPGxpbnV4L3ZtYWxsb2MuaD4KI2luY2x1ZGUgPGxpbnV4L3VuaXN0ZC5oPgojaW5jbHVkZSA8bGludXgvc3RyaW5nLmg+CiNpbmNsdWRlIDxsaW51eC9wdHJhY2UuaD4KI2luY2x1ZGUgPGxpbnV4L2Vycm5vLmg+CiNpbmNsdWRlIDxsaW51eC9pb3BvcnQuaD4KI2luY2x1ZGUgPGxpbnV4L2ludGVycnVwdC5oPgojaW5jbHVkZSA8bGludXgvY2FwYWJpbGl0eS5oPgojaW5jbHVkZSA8bGludXgvZGVsYXkuaD4KI2luY2x1ZGUgPGxpbnV4L3RpbWVyLmg+CiNpbmNsdWRlIDxsaW51eC9saXN0Lmg+CiNpbmNsdWRlIDxsaW51eC9pbml0Lmg+CiNpbmNsdWRlIDxsaW51eC9za2J1ZmYuaD4KI2luY2x1ZGUgPGxpbnV4L25ldGRldmljZS5oPgojaW5jbHVkZSA8bGludXgvaW5ldC5oPgojaW5jbHVkZSA8bGludXgvaW5ldGRldmljZS5oPgojaW5jbHVkZSA8bGludXgvcnRuZXRsaW5rLmg+CiNpbmNsdWRlIDxsaW51eC9pZl9hcnAuaD4KI2luY2x1ZGUgPGxpbnV4L2lmX3ZsYW4uaD4KI2luY2x1ZGUgPGxpbnV4L2luLmg+CiNpbmNsdWRlIDxsaW51eC9pcC5oPgojaW5jbHVkZSA8bGludXgvaXB2Ni5oPgojaW5jbHVkZSA8bGludXgvdWRwLmg+CiNpbmNsdWRlIDxsaW51eC9wcm9jX2ZzLmg+CiNpbmNsdWRlIDxsaW51eC9zZXFfZmlsZS5oPgojaW5jbHVkZSA8bGludXgvd2FpdC5oPgojaW5jbHVkZSA8bGludXgvZXRoZXJkZXZpY2UuaD4KI2luY2x1ZGUgPG5ldC9jaGVja3N1bS5oPgojaW5jbHVkZSA8bmV0L2lwdjYuaD4KI2luY2x1ZGUgPG5ldC9hZGRyY29uZi5oPgojaW5jbHVkZSA8YXNtL2J5dGVvcmRlci5oPgojaW5jbHVkZSA8bGludXgvcmN1cGRhdGUuaD4KI2luY2x1ZGUgPGFzbS9iaXRvcHMuaD4KI2luY2x1ZGUgPGFzbS9pby5oPgojaW5jbHVkZSA8YXNtL2RtYS5oPgojaW5jbHVkZSA8YXNtL3VhY2Nlc3MuaD4KI2luY2x1ZGUgPGFzbS9kaXY2NC5oPgkJLyogZG9fZGl2ICovCiNpbmNsdWRlIDxhc20vdGltZXguaD4KCiNkZWZpbmUgVkVSU0lPTiAgInBrdGdlbiB2Mi42ODogUGFja2V0IEdlbmVyYXRvciBmb3IgcGFja2V0IHBlcmZvcm1hbmNlIHRlc3RpbmcuXG4iCgovKiAjZGVmaW5lIFBHX0RFQlVHKGEpIGEgKi8KI2RlZmluZSBQR19ERUJVRyhhKQoKLyogVGhlIGJ1Y2tldHMgYXJlIGV4cG9uZW50aWFsIGluICd3aWR0aCcgKi8KI2RlZmluZSBMQVRfQlVDS0VUU19NQVggMzIKI2RlZmluZSBJUF9OQU1FX1NaIDMyCiNkZWZpbmUgTUFYX01QTFNfTEFCRUxTIDE2IC8qIFRoaXMgaXMgdGhlIG1heCBsYWJlbCBzdGFjayBkZXB0aCAqLwojZGVmaW5lIE1QTFNfU1RBQ0tfQk9UVE9NIF9fY29uc3RhbnRfaHRvbmwoMHgwMDAwMDEwMCkKCi8qIERldmljZSBmbGFnIGJpdHMgKi8KI2RlZmluZSBGX0lQU1JDX1JORCAgICgxPDwwKQkvKiBJUC1TcmMgUmFuZG9tICAqLwojZGVmaW5lIEZfSVBEU1RfUk5EICAgKDE8PDEpCS8qIElQLURzdCBSYW5kb20gICovCiNkZWZpbmUgRl9VRFBTUkNfUk5EICAoMTw8MikJLyogVURQLVNyYyBSYW5kb20gKi8KI2RlZmluZSBGX1VEUERTVF9STkQgICgxPDwzKQkvKiBVRFAtRHN0IFJhbmRvbSAqLwojZGVmaW5lIEZfTUFDU1JDX1JORCAgKDE8PDQpCS8qIE1BQy1TcmMgUmFuZG9tICovCiNkZWZpbmUgRl9NQUNEU1RfUk5EICAoMTw8NSkJLyogTUFDLURzdCBSYW5kb20gKi8KI2RlZmluZSBGX1RYU0laRV9STkQgICgxPDw2KQkvKiBUcmFuc21pdCBzaXplIGlzIHJhbmRvbSAqLwojZGVmaW5lIEZfSVBWNiAgICAgICAgKDE8PDcpCS8qIEludGVyZmFjZSBpbiBJUFY2IE1vZGUgKi8KI2RlZmluZSBGX01QTFNfUk5EICAgICgxPDw4KQkvKiBSYW5kb20gTVBMUyBsYWJlbHMgKi8KI2RlZmluZSBGX1ZJRF9STkQgICAgICgxPDw5KQkvKiBSYW5kb20gVkxBTiBJRCAqLwojZGVmaW5lIEZfU1ZJRF9STkQgICAgKDE8PDEwKQkvKiBSYW5kb20gU1ZMQU4gSUQgKi8KCi8qIFRocmVhZCBjb250cm9sIGZsYWcgYml0cyAqLwojZGVmaW5lIFRfVEVSTUlOQVRFICAgKDE8PDApCiNkZWZpbmUgVF9TVE9QICAgICAgICAoMTw8MSkJLyogU3RvcCBydW4gKi8KI2RlZmluZSBUX1JVTiAgICAgICAgICgxPDwyKQkvKiBTdGFydCBydW4gKi8KI2RlZmluZSBUX1JFTURFVkFMTCAgICgxPDwzKQkvKiBSZW1vdmUgYWxsIGRldnMgKi8KI2RlZmluZSBUX1JFTURFViAgICAgICgxPDw0KQkvKiBSZW1vdmUgb25lIGRldiAqLwoKLyogSWYgbG9jayAtLSBjYW4gYmUgcmVtb3ZlZCBhZnRlciBzb21lIHdvcmsgKi8KI2RlZmluZSAgIGlmX2xvY2sodCkgICAgICAgICAgIHNwaW5fbG9jaygmKHQtPmlmX2xvY2spKTsKI2RlZmluZSAgIGlmX3VubG9jayh0KSAgICAgICAgICAgc3Bpbl91bmxvY2soJih0LT5pZl9sb2NrKSk7CgovKiBVc2VkIHRvIGhlbHAgd2l0aCBkZXRlcm1pbmluZyB0aGUgcGt0cyBvbiByZWNlaXZlICovCiNkZWZpbmUgUEtUR0VOX01BR0lDIDB4YmU5YmU5NTUKI2RlZmluZSBQR19QUk9DX0RJUiAicGt0Z2VuIgojZGVmaW5lIFBHQ1RSTAkgICAgInBnY3RybCIKc3RhdGljIHN0cnVjdCBwcm9jX2Rpcl9lbnRyeSAqcGdfcHJvY19kaXIgPSBOVUxMOwoKI2RlZmluZSBNQVhfQ0ZMT1dTICA2NTUzNgoKI2RlZmluZSBWTEFOX1RBR19TSVpFKHgpICgoeCktPnZsYW5faWQgPT0gMHhmZmZmID8gMCA6IDQpCiNkZWZpbmUgU1ZMQU5fVEFHX1NJWkUoeCkgKCh4KS0+c3ZsYW5faWQgPT0gMHhmZmZmID8gMCA6IDQpCgpzdHJ1Y3QgZmxvd19zdGF0ZSB7CglfX2JlMzIgY3VyX2RhZGRyOwoJaW50IGNvdW50Owp9OwoKc3RydWN0IHBrdGdlbl9kZXYgewoKCS8qCgkgKiBUcnkgdG8ga2VlcCBmcmVxdWVudC9pbmZyZXF1ZW50IHVzZWQgdmFycy4gc2VwYXJhdGVkLgoJICovCgoJY2hhciBpZm5hbWVbSUZOQU1TSVpdOwoJY2hhciByZXN1bHRbNTEyXTsKCglzdHJ1Y3QgcGt0Z2VuX3RocmVhZCAqcGdfdGhyZWFkOwkvKiB0aGUgb3duZXIgKi8KCXN0cnVjdCBsaXN0X2hlYWQgbGlzdDsJCS8qIFVzZWQgZm9yIGNoYWluaW5nIGluIHRoZSB0aHJlYWQncyBydW4tcXVldWUgKi8KCglpbnQgcnVubmluZzsJCS8qIGlmIHRoaXMgY2hhbmdlcyB0byBmYWxzZSwgdGhlIHRlc3Qgd2lsbCBzdG9wICovCgoJLyogSWYgbWluICE9IG1heCwgdGhlbiB3ZSB3aWxsIGVpdGhlciBkbyBhIGxpbmVhciBpdGVyYXRpb24sIG9yCgkgKiB3ZSB3aWxsIGRvIGEgcmFuZG9tIHNlbGVjdGlvbiBmcm9tIHdpdGhpbiB0aGUgcmFuZ2UuCgkgKi8KCV9fdTMyIGZsYWdzOwoJaW50IHJlbW92YWxfbWFyazsJLyogbm9uLXplcm8gPT4gdGhlIGRldmljZSBpcyBtYXJrZWQgZm9yCgkJCQkgKiByZW1vdmFsIGJ5IHdvcmtlciB0aHJlYWQgKi8KCglpbnQgbWluX3BrdF9zaXplOwkvKiA9IEVUSF9aTEVOOyAqLwoJaW50IG1heF9wa3Rfc2l6ZTsJLyogPSBFVEhfWkxFTjsgKi8KCWludCBuZnJhZ3M7CglfX3UzMiBkZWxheV91czsJCS8qIERlZmF1bHQgZGVsYXkgKi8KCV9fdTMyIGRlbGF5X25zOwoJX191NjQgY291bnQ7CQkvKiBEZWZhdWx0IE5vIHBhY2tldHMgdG8gc2VuZCAqLwoJX191NjQgc29mYXI7CQkvKiBIb3cgbWFueSBwa3RzIHdlJ3ZlIHNlbnQgc28gZmFyICovCglfX3U2NCB0eF9ieXRlczsJCS8qIEhvdyBtYW55IGJ5dGVzIHdlJ3ZlIHRyYW5zbWl0dGVkICovCglfX3U2NCBlcnJvcnM7CQkvKiBFcnJvcnMgd2hlbiB0cnlpbmcgdG8gdHJhbnNtaXQsIHBrdHMgd2lsbCBiZSByZS1zZW50ICovCgoJLyogcnVudGltZSBjb3VudGVycyByZWxhdGluZyB0byBjbG9uZV9za2IgKi8KCV9fdTY0IG5leHRfdHhfdXM7CS8qIHRpbWVzdGFtcCBvZiB3aGVuIHRvIHR4IG5leHQgKi8KCV9fdTMyIG5leHRfdHhfbnM7CgoJX191NjQgYWxsb2NhdGVkX3NrYnM7CglfX3UzMiBjbG9uZV9jb3VudDsKCWludCBsYXN0X29rOwkJLyogV2FzIGxhc3Qgc2tiIHNlbnQ/CgkJCQkgKiBPciBhIGZhaWxlZCB0cmFuc21pdCBvZiBzb21lIHNvcnQ/ICBUaGlzIHdpbGwga2VlcAoJCQkJICogc2VxdWVuY2UgbnVtYmVycyBpbiBvcmRlciwgZm9yIGV4YW1wbGUuCgkJCQkgKi8KCV9fdTY0IHN0YXJ0ZWRfYXQ7CS8qIG1pY3JvLXNlY29uZHMgKi8KCV9fdTY0IHN0b3BwZWRfYXQ7CS8qIG1pY3JvLXNlY29uZHMgKi8KCV9fdTY0IGlkbGVfYWNjOwkJLyogbWljcm8tc2Vjb25kcyAqLwoJX191MzIgc2VxX251bTsKCglpbnQgY2xvbmVfc2tiOwkJLyogVXNlIG11bHRpcGxlIFNLQnMgZHVyaW5nIHBhY2tldCBnZW4uICBJZiB0aGlzIG51bWJlcgoJCQkJICogaXMgZ3JlYXRlciB0aGFuIDEsIHRoZW4gdGhhdCBtYW55IGNvcGllcyBvZiB0aGUgc2FtZQoJCQkJICogcGFja2V0IHdpbGwgYmUgc2VudCBiZWZvcmUgYSBuZXcgcGFja2V0IGlzIGFsbG9jYXRlZC4KCQkJCSAqIEZvciBpbnN0YW5jZSwgaWYgeW91IHdhbnQgdG8gc2VuZCAxMDI0IGlkZW50aWNhbCBwYWNrZXRzCgkJCQkgKiBiZWZvcmUgY3JlYXRpbmcgYSBuZXcgcGFja2V0LCBzZXQgY2xvbmVfc2tiIHRvIDEwMjQuCgkJCQkgKi8KCgljaGFyIGRzdF9taW5bSVBfTkFNRV9TWl07CS8qIElQLCBpZSAxLjIuMy40ICovCgljaGFyIGRzdF9tYXhbSVBfTkFNRV9TWl07CS8qIElQLCBpZSAxLjIuMy40ICovCgljaGFyIHNyY19taW5bSVBfTkFNRV9TWl07CS8qIElQLCBpZSAxLjIuMy40ICovCgljaGFyIHNyY19tYXhbSVBfTkFNRV9TWl07CS8qIElQLCBpZSAxLjIuMy40ICovCgoJc3RydWN0IGluNl9hZGRyIGluNl9zYWRkcjsKCXN0cnVjdCBpbjZfYWRkciBpbjZfZGFkZHI7CglzdHJ1Y3QgaW42X2FkZHIgY3VyX2luNl9kYWRkcjsKCXN0cnVjdCBpbjZfYWRkciBjdXJfaW42X3NhZGRyOwoJLyogRm9yIHJhbmdlcyAqLwoJc3RydWN0IGluNl9hZGRyIG1pbl9pbjZfZGFkZHI7CglzdHJ1Y3QgaW42X2FkZHIgbWF4X2luNl9kYWRkcjsKCXN0cnVjdCBpbjZfYWRkciBtaW5faW42X3NhZGRyOwoJc3RydWN0IGluNl9hZGRyIG1heF9pbjZfc2FkZHI7CgoJLyogSWYgd2UncmUgZG9pbmcgcmFuZ2VzLCByYW5kb20gb3IgaW5jcmVtZW50YWwsIHRoZW4gdGhpcwoJICogZGVmaW5lcyB0aGUgbWluL21heCBmb3IgdGhvc2UgcmFuZ2VzLgoJICovCglfX2JlMzIgc2FkZHJfbWluOwkvKiBpbmNsdXNpdmUsIHNvdXJjZSBJUCBhZGRyZXNzICovCglfX2JlMzIgc2FkZHJfbWF4OwkvKiBleGNsdXNpdmUsIHNvdXJjZSBJUCBhZGRyZXNzICovCglfX2JlMzIgZGFkZHJfbWluOwkvKiBpbmNsdXNpdmUsIGRlc3QgSVAgYWRkcmVzcyAqLwoJX19iZTMyIGRhZGRyX21heDsJLyogZXhjbHVzaXZlLCBkZXN0IElQIGFkZHJlc3MgKi8KCglfX3UxNiB1ZHBfc3JjX21pbjsJLyogaW5jbHVzaXZlLCBzb3VyY2UgVURQIHBvcnQgKi8KCV9fdTE2IHVkcF9zcmNfbWF4OwkvKiBleGNsdXNpdmUsIHNvdXJjZSBVRFAgcG9ydCAqLwoJX191MTYgdWRwX2RzdF9taW47CS8qIGluY2x1c2l2ZSwgZGVzdCBVRFAgcG9ydCAqLwoJX191MTYgdWRwX2RzdF9tYXg7CS8qIGV4Y2x1c2l2ZSwgZGVzdCBVRFAgcG9ydCAqLwoKCS8qIERTQ1AgKyBFQ04gKi8KCV9fdTggdG9zOyAgICAgICAgICAgIC8qIHNpeCBtb3N0IHNpZ25pZmljYW50IGJpdHMgb2YgKGZvcm1lcikgSVB2NCBUT1MgYXJlIGZvciBkc2NwIGNvZGVwb2ludCAqLwoJX191OCB0cmFmZmljX2NsYXNzOyAgLyogZGl0dG8gZm9yIHRoZSAoZm9ybWVyKSBUcmFmZmljIENsYXNzIGluIElQdjYgKHNlZSBSRkMgMzI2MCwgc2VjLiA0KSAqLwoKCS8qIE1QTFMgKi8KCXVuc2lnbmVkIG5yX2xhYmVsczsJLyogRGVwdGggb2Ygc3RhY2ssIDAgPSBubyBNUExTICovCglfX2JlMzIgbGFiZWxzW01BWF9NUExTX0xBQkVMU107CgoJLyogVkxBTi9TVkxBTiAoODAyLjFRL1EtaW4tUSkgKi8KCV9fdTggIHZsYW5fcDsKCV9fdTggIHZsYW5fY2ZpOwoJX191MTYgdmxhbl9pZDsgIC8qIDB4ZmZmZiBtZWFucyBubyB2bGFuIHRhZyAqLwoKCV9fdTggIHN2bGFuX3A7CglfX3U4ICBzdmxhbl9jZmk7CglfX3UxNiBzdmxhbl9pZDsgLyogMHhmZmZmIG1lYW5zIG5vIHN2bGFuIHRhZyAqLwoKCV9fdTMyIHNyY19tYWNfY291bnQ7CS8qIEhvdyBtYW55IE1BQ3MgdG8gaXRlcmF0ZSB0aHJvdWdoICovCglfX3UzMiBkc3RfbWFjX2NvdW50OwkvKiBIb3cgbWFueSBNQUNzIHRvIGl0ZXJhdGUgdGhyb3VnaCAqLwoKCXVuc2lnbmVkIGNoYXIgZHN0X21hY1tFVEhfQUxFTl07Cgl1bnNpZ25lZCBjaGFyIHNyY19tYWNbRVRIX0FMRU5dOwoKCV9fdTMyIGN1cl9kc3RfbWFjX29mZnNldDsKCV9fdTMyIGN1cl9zcmNfbWFjX29mZnNldDsKCV9fYmUzMiBjdXJfc2FkZHI7CglfX2JlMzIgY3VyX2RhZGRyOwoJX191MTYgY3VyX3VkcF9kc3Q7CglfX3UxNiBjdXJfdWRwX3NyYzsKCV9fdTMyIGN1cl9wa3Rfc2l6ZTsKCglfX3U4IGhoWzE0XTsKCS8qID0gewoJICAgMHgwMCwgMHg4MCwgMHhDOCwgMHg3OSwgMHhCMywgMHhDQiwKCgkgICBXZSBmaWxsIGluIFNSQyBhZGRyZXNzIGxhdGVyCgkgICAweDAwLCAweDAwLCAweDAwLCAweDAwLCAweDAwLCAweDAwLAoJICAgMHgwOCwgMHgwMAoJICAgfTsKCSAqLwoJX191MTYgcGFkOwkJLyogcGFkIG91dCB0aGUgaGggc3RydWN0IHRvIGFuIGV2ZW4gMTYgYnl0ZXMgKi8KCglzdHJ1Y3Qgc2tfYnVmZiAqc2tiOwkvKiBza2Igd2UgYXJlIHRvIHRyYW5zbWl0IG5leHQsIG1haW5seSB1c2VkIGZvciB3aGVuIHdlCgkJCQkgKiBhcmUgdHJhbnNtaXR0aW5nIHRoZSBzYW1lIG9uZSBtdWx0aXBsZSB0aW1lcwoJCQkJICovCglzdHJ1Y3QgbmV0X2RldmljZSAqb2RldjsJLyogVGhlIG91dC1nb2luZyBkZXZpY2UuICBOb3RlIHRoYXQgdGhlIGRldmljZSBzaG91bGQKCQkJCQkgKiBoYXZlIGl0J3MgcGdfaW5mbyBwb2ludGVyIHBvaW50aW5nIGJhY2sgdG8gdGhpcwoJCQkJCSAqIGRldmljZS4gIFRoaXMgd2lsbCBiZSBzZXQgd2hlbiB0aGUgdXNlciBzcGVjaWZpZXMKCQkJCQkgKiB0aGUgb3V0LWdvaW5nIGRldmljZSBuYW1lIChub3Qgd2hlbiB0aGUgaW5qZWN0IGlzCgkJCQkJICogc3RhcnRlZCBhcyBpdCB1c2VkIHRvIGRvLikKCQkJCQkgKi8KCXN0cnVjdCBmbG93X3N0YXRlICpmbG93czsKCXVuc2lnbmVkIGNmbG93czsJLyogQ29uY3VycmVudCBmbG93cyAoY29uZmlnKSAqLwoJdW5zaWduZWQgbGZsb3c7CQkvKiBGbG93IGxlbmd0aCAgKGNvbmZpZykgKi8KCXVuc2lnbmVkIG5mbG93czsJLyogYWNjdW11bGF0ZWQgZmxvd3MgKHN0YXRzKSAqLwp9OwoKc3RydWN0IHBrdGdlbl9oZHIgewoJX19iZTMyIHBnaF9tYWdpYzsKCV9fYmUzMiBzZXFfbnVtOwoJX19iZTMyIHR2X3NlYzsKCV9fYmUzMiB0dl91c2VjOwp9OwoKc3RydWN0IHBrdGdlbl90aHJlYWQgewoJc3BpbmxvY2tfdCBpZl9sb2NrOwoJc3RydWN0IGxpc3RfaGVhZCBpZl9saXN0OwkvKiBBbGwgZGV2aWNlIGhlcmUgKi8KCXN0cnVjdCBsaXN0X2hlYWQgdGhfbGlzdDsKCWludCByZW1vdmVkOwoJY2hhciBuYW1lWzMyXTsKCWNoYXIgcmVzdWx0WzUxMl07Cgl1MzIgbWF4X2JlZm9yZV9zb2Z0aXJxOwkvKiBXZSdsbCBjYWxsIGRvX3NvZnRpcnEgdG8gcHJldmVudCBzdGFydmF0aW9uLiAqLwoKCS8qIEZpZWxkIGZvciB0aHJlYWQgdG8gcmVjZWl2ZSAicG9zdGVkIiBldmVudHMgdGVybWluYXRlLCBzdG9wIGlmcyBldGMuICovCgoJdTMyIGNvbnRyb2w7CglpbnQgcGlkOwoJaW50IGNwdTsKCgl3YWl0X3F1ZXVlX2hlYWRfdCBxdWV1ZTsKfTsKCiNkZWZpbmUgUkVNT1ZFIDEKI2RlZmluZSBGSU5EICAgMAoKLyogIFRoaXMgY29kZSB3b3JrcyBhcm91bmQgdGhlIGZhY3QgdGhhdCBkb19kaXYgY2Fubm90IGhhbmRsZSB0d28gNjQtYml0CiAgICBudW1iZXJzLCBhbmQgcmVndWxhciA2NC1iaXQgZGl2aXNpb24gZG9lc24ndCB3b3JrIG9uIHg4NiBrZXJuZWxzLgogICAgLS1CZW4KKi8KCiNkZWZpbmUgUEdfRElWIDAKCi8qIFRoaXMgd2FzIGVtYWlsZWQgdG8gTE1LTCBieTogQ2hyaXMgQ2FwdXRvIDxjY2FwdXRvQGFsdC5uZXQ+CiAqIEZ1bmN0aW9uIGNvcGllZC9hZGFwdGVkL29wdGltaXplZCBmcm9tOgogKgogKiAgbmVtZXNpcy5zb3VyY2Vmb3JnZS5uZXQvYnJvd3NlL2xpYi9zdGF0aWMvaW50bWF0aC9peDg2L2ludG1hdGguYy5odG1sCiAqCiAqIENvcHlyaWdodCAxOTk0LCBVbml2ZXJzaXR5IG9mIENhbWJyaWRnZSBDb21wdXRlciBMYWJvcmF0b3J5CiAqIEFsbCBSaWdodHMgUmVzZXJ2ZWQuCiAqCiAqLwpzdGF0aWMgaW5saW5lIHM2NCBkaXZyZW1kaTMoczY0IHgsIHM2NCB5LCBpbnQgdHlwZSkKewoJdTY0IGEgPSAoeCA8IDApID8gLXggOiB4OwoJdTY0IGIgPSAoeSA8IDApID8gLXkgOiB5OwoJdTY0IHJlcyA9IDAsIGQgPSAxOwoKCWlmIChiID4gMCkgewoJCXdoaWxlIChiIDwgYSkgewoJCQliIDw8PSAxOwoJCQlkIDw8PSAxOwoJCX0KCX0KCglkbyB7CgkJaWYgKGEgPj0gYikgewoJCQlhIC09IGI7CgkJCXJlcyArPSBkOwoJCX0KCQliID4+PSAxOwoJCWQgPj49IDE7Cgl9Cgl3aGlsZSAoZCk7CgoJaWYgKFBHX0RJViA9PSB0eXBlKSB7CgkJcmV0dXJuICgoKHggXiB5KSAmICgxbGwgPDwgNjMpKSA9PSAwKSA/IHJlcyA6IC0oczY0KSByZXM7Cgl9IGVsc2UgewoJCXJldHVybiAoKHggJiAoMWxsIDw8IDYzKSkgPT0gMCkgPyBhIDogLShzNjQpIGE7Cgl9Cn0KCi8qIEVuZCBvZiBoYWNrcyB0byBkZWFsIHdpdGggNjQtYml0IG1hdGggb24geDg2ICovCgovKiogQ29udmVydCB0byBtaWxsaXNlY29uZHMgKi8Kc3RhdGljIGlubGluZSBfX3U2NCB0dl90b19tcyhjb25zdCBzdHJ1Y3QgdGltZXZhbCAqdHYpCnsKCV9fdTY0IG1zID0gdHYtPnR2X3VzZWMgLyAxMDAwOwoJbXMgKz0gKF9fdTY0KSB0di0+dHZfc2VjICogKF9fdTY0KSAxMDAwOwoJcmV0dXJuIG1zOwp9CgovKiogQ29udmVydCB0byBtaWNyby1zZWNvbmRzICovCnN0YXRpYyBpbmxpbmUgX191NjQgdHZfdG9fdXMoY29uc3Qgc3RydWN0IHRpbWV2YWwgKnR2KQp7CglfX3U2NCB1cyA9IHR2LT50dl91c2VjOwoJdXMgKz0gKF9fdTY0KSB0di0+dHZfc2VjICogKF9fdTY0KSAxMDAwMDAwOwoJcmV0dXJuIHVzOwp9CgpzdGF0aWMgaW5saW5lIF9fdTY0IHBnX2RpdihfX3U2NCBuLCBfX3UzMiBiYXNlKQp7CglfX3U2NCB0bXAgPSBuOwoJZG9fZGl2KHRtcCwgYmFzZSk7CgkvKiBwcmludGsoInBrdGdlbjogcGdfZGl2LCBuOiAlbGx1ICBiYXNlOiAlZCAgcnY6ICVsbHVcbiIsCgkgICBuLCBiYXNlLCB0bXApOyAqLwoJcmV0dXJuIHRtcDsKfQoKc3RhdGljIGlubGluZSBfX3U2NCBwZ19kaXY2NChfX3U2NCBuLCBfX3U2NCBiYXNlKQp7CglfX3U2NCB0bXAgPSBuOwovKgogKiBIb3cgZG8gd2Uga25vdyBpZiB0aGUgYXJjaGl0ZWN0dXJlIHdlIGFyZSBydW5uaW5nIG9uCiAqIHN1cHBvcnRzIGRpdmlzaW9uIHdpdGggNjQgYml0IGJhc2U/CiAqIAogKi8KI2lmIGRlZmluZWQoX19zcGFyY192OV9fKSB8fCBkZWZpbmVkKF9fcG93ZXJwYzY0X18pIHx8IGRlZmluZWQoX19hbHBoYV9fKSB8fCBkZWZpbmVkKF9feDg2XzY0X18pIHx8IGRlZmluZWQoX19pYTY0X18pCgoJZG9fZGl2KHRtcCwgYmFzZSk7CiNlbHNlCgl0bXAgPSBkaXZyZW1kaTMobiwgYmFzZSwgUEdfRElWKTsKI2VuZGlmCglyZXR1cm4gdG1wOwp9CgpzdGF0aWMgaW5saW5lIHUzMiBwa3RnZW5fcmFuZG9tKHZvaWQpCnsKI2lmIDAKCV9fdTMyIG47CglnZXRfcmFuZG9tX2J5dGVzKCZuLCA0KTsKCXJldHVybiBuOwojZWxzZQoJcmV0dXJuIG5ldF9yYW5kb20oKTsKI2VuZGlmCn0KCnN0YXRpYyBpbmxpbmUgX191NjQgZ2V0Q3VyTXModm9pZCkKewoJc3RydWN0IHRpbWV2YWwgdHY7Cglkb19nZXR0aW1lb2ZkYXkoJnR2KTsKCXJldHVybiB0dl90b19tcygmdHYpOwp9CgpzdGF0aWMgaW5saW5lIF9fdTY0IGdldEN1clVzKHZvaWQpCnsKCXN0cnVjdCB0aW1ldmFsIHR2OwoJZG9fZ2V0dGltZW9mZGF5KCZ0dik7CglyZXR1cm4gdHZfdG9fdXMoJnR2KTsKfQoKc3RhdGljIGlubGluZSBfX3U2NCB0dl9kaWZmKGNvbnN0IHN0cnVjdCB0aW1ldmFsICphLCBjb25zdCBzdHJ1Y3QgdGltZXZhbCAqYikKewoJcmV0dXJuIHR2X3RvX3VzKGEpIC0gdHZfdG9fdXMoYik7Cn0KCi8qIG9sZCBpbmNsdWRlIGVuZCAqLwoKc3RhdGljIGNoYXIgdmVyc2lvbltdIF9faW5pdGRhdGEgPSBWRVJTSU9OOwoKc3RhdGljIGludCBwa3RnZW5fcmVtb3ZlX2RldmljZShzdHJ1Y3QgcGt0Z2VuX3RocmVhZCAqdCwgc3RydWN0IHBrdGdlbl9kZXYgKmkpOwpzdGF0aWMgaW50IHBrdGdlbl9hZGRfZGV2aWNlKHN0cnVjdCBwa3RnZW5fdGhyZWFkICp0LCBjb25zdCBjaGFyICppZm5hbWUpOwpzdGF0aWMgc3RydWN0IHBrdGdlbl9kZXYgKnBrdGdlbl9maW5kX2RldihzdHJ1Y3QgcGt0Z2VuX3RocmVhZCAqdCwKCQkJCQkgIGNvbnN0IGNoYXIgKmlmbmFtZSk7CnN0YXRpYyBpbnQgcGt0Z2VuX2RldmljZV9ldmVudChzdHJ1Y3Qgbm90aWZpZXJfYmxvY2sgKiwgdW5zaWduZWQgbG9uZywgdm9pZCAqKTsKc3RhdGljIHZvaWQgcGt0Z2VuX3J1bl9hbGxfdGhyZWFkcyh2b2lkKTsKc3RhdGljIHZvaWQgcGt0Z2VuX3N0b3BfYWxsX3RocmVhZHNfaWZzKHZvaWQpOwpzdGF0aWMgaW50IHBrdGdlbl9zdG9wX2RldmljZShzdHJ1Y3QgcGt0Z2VuX2RldiAqcGt0X2Rldik7CnN0YXRpYyB2b2lkIHBrdGdlbl9zdG9wKHN0cnVjdCBwa3RnZW5fdGhyZWFkICp0KTsKc3RhdGljIHZvaWQgcGt0Z2VuX2NsZWFyX2NvdW50ZXJzKHN0cnVjdCBwa3RnZW5fZGV2ICpwa3RfZGV2KTsKc3RhdGljIGludCBwa3RnZW5fbWFya19kZXZpY2UoY29uc3QgY2hhciAqaWZuYW1lKTsKc3RhdGljIHVuc2lnbmVkIGludCBzY2FuX2lwNihjb25zdCBjaGFyICpzLCBjaGFyIGlwWzE2XSk7CnN0YXRpYyB1bnNpZ25lZCBpbnQgZm10X2lwNihjaGFyICpzLCBjb25zdCBjaGFyIGlwWzE2XSk7CgovKiBNb2R1bGUgcGFyYW1ldGVycywgZGVmYXVsdHMuICovCnN0YXRpYyBpbnQgcGdfY291bnRfZCA9IDEwMDA7CS8qIDEwMDAgcGt0cyBieSBkZWZhdWx0ICovCnN0YXRpYyBpbnQgcGdfZGVsYXlfZDsKc3RhdGljIGludCBwZ19jbG9uZV9za2JfZDsKc3RhdGljIGludCBkZWJ1ZzsKCnN0YXRpYyBERUZJTkVfTVVURVgocGt0Z2VuX3RocmVhZF9sb2NrKTsKc3RhdGljIExJU1RfSEVBRChwa3RnZW5fdGhyZWFkcyk7CgpzdGF0aWMgc3RydWN0IG5vdGlmaWVyX2Jsb2NrIHBrdGdlbl9ub3RpZmllcl9ibG9jayA9IHsKCS5ub3RpZmllcl9jYWxsID0gcGt0Z2VuX2RldmljZV9ldmVudCwKfTsKCi8qCiAqIC9wcm9jIGhhbmRsaW5nIGZ1bmN0aW9ucyAKICoKICovCgpzdGF0aWMgaW50IHBnY3RybF9zaG93KHN0cnVjdCBzZXFfZmlsZSAqc2VxLCB2b2lkICp2KQp7CglzZXFfcHV0cyhzZXEsIFZFUlNJT04pOwoJcmV0dXJuIDA7Cn0KCnN0YXRpYyBzc2l6ZV90IHBnY3RybF93cml0ZShzdHJ1Y3QgZmlsZSAqZmlsZSwgY29uc3QgY2hhciBfX3VzZXIgKiBidWYsCgkJCSAgICBzaXplX3QgY291bnQsIGxvZmZfdCAqIHBwb3MpCnsKCWludCBlcnIgPSAwOwoJY2hhciBkYXRhWzEyOF07CgoJaWYgKCFjYXBhYmxlKENBUF9ORVRfQURNSU4pKSB7CgkJZXJyID0gLUVQRVJNOwoJCWdvdG8gb3V0OwoJfQoKCWlmIChjb3VudCA+IHNpemVvZihkYXRhKSkKCQljb3VudCA9IHNpemVvZihkYXRhKTsKCglpZiAoY29weV9mcm9tX3VzZXIoZGF0YSwgYnVmLCBjb3VudCkpIHsKCQllcnIgPSAtRUZBVUxUOwoJCWdvdG8gb3V0OwoJfQoJZGF0YVtjb3VudCAtIDFdID0gMDsJLyogTWFrZSBzdHJpbmcgKi8KCglpZiAoIXN0cmNtcChkYXRhLCAic3RvcCIpKQoJCXBrdGdlbl9zdG9wX2FsbF90aHJlYWRzX2lmcygpOwoKCWVsc2UgaWYgKCFzdHJjbXAoZGF0YSwgInN0YXJ0IikpCgkJcGt0Z2VuX3J1bl9hbGxfdGhyZWFkcygpOwoKCWVsc2UKCQlwcmludGsoInBrdGdlbjogVW5rbm93biBjb21tYW5kOiAlc1xuIiwgZGF0YSk7CgoJZXJyID0gY291bnQ7CgpvdXQ6CglyZXR1cm4gZXJyOwp9CgpzdGF0aWMgaW50IHBnY3RybF9vcGVuKHN0cnVjdCBpbm9kZSAqaW5vZGUsIHN0cnVjdCBmaWxlICpmaWxlKQp7CglyZXR1cm4gc2luZ2xlX29wZW4oZmlsZSwgcGdjdHJsX3Nob3csIFBERShpbm9kZSktPmRhdGEpOwp9CgpzdGF0aWMgc3RydWN0IGZpbGVfb3BlcmF0aW9ucyBwa3RnZW5fZm9wcyA9IHsKCS5vd25lciAgID0gVEhJU19NT0RVTEUsCgkub3BlbiAgICA9IHBnY3RybF9vcGVuLAoJLnJlYWQgICAgPSBzZXFfcmVhZCwKCS5sbHNlZWsgID0gc2VxX2xzZWVrLAoJLndyaXRlICAgPSBwZ2N0cmxfd3JpdGUsCgkucmVsZWFzZSA9IHNpbmdsZV9yZWxlYXNlLAp9OwoKc3RhdGljIGludCBwa3RnZW5faWZfc2hvdyhzdHJ1Y3Qgc2VxX2ZpbGUgKnNlcSwgdm9pZCAqdikKewoJaW50IGk7CglzdHJ1Y3QgcGt0Z2VuX2RldiAqcGt0X2RldiA9IHNlcS0+cHJpdmF0ZTsKCV9fdTY0IHNhOwoJX191NjQgc3RvcHBlZDsKCV9fdTY0IG5vdyA9IGdldEN1clVzKCk7CgoJc2VxX3ByaW50ZihzZXEsCgkJICAgIlBhcmFtczogY291bnQgJWxsdSAgbWluX3BrdF9zaXplOiAldSAgbWF4X3BrdF9zaXplOiAldVxuIiwKCQkgICAodW5zaWduZWQgbG9uZyBsb25nKXBrdF9kZXYtPmNvdW50LCBwa3RfZGV2LT5taW5fcGt0X3NpemUsCgkJICAgcGt0X2Rldi0+bWF4X3BrdF9zaXplKTsKCglzZXFfcHJpbnRmKHNlcSwKCQkgICAiICAgICBmcmFnczogJWQgIGRlbGF5OiAldSAgY2xvbmVfc2tiOiAlZCAgaWZuYW1lOiAlc1xuIiwKCQkgICBwa3RfZGV2LT5uZnJhZ3MsCgkJICAgMTAwMCAqIHBrdF9kZXYtPmRlbGF5X3VzICsgcGt0X2Rldi0+ZGVsYXlfbnMsCgkJICAgcGt0X2Rldi0+Y2xvbmVfc2tiLCBwa3RfZGV2LT5pZm5hbWUpOwoKCXNlcV9wcmludGYoc2VxLCAiICAgICBmbG93czogJXUgZmxvd2xlbjogJXVcbiIsIHBrdF9kZXYtPmNmbG93cywKCQkgICBwa3RfZGV2LT5sZmxvdyk7CgoJaWYgKHBrdF9kZXYtPmZsYWdzICYgRl9JUFY2KSB7CgkJY2hhciBiMVsxMjhdLCBiMlsxMjhdLCBiM1sxMjhdOwoJCWZtdF9pcDYoYjEsIHBrdF9kZXYtPmluNl9zYWRkci5zNl9hZGRyKTsKCQlmbXRfaXA2KGIyLCBwa3RfZGV2LT5taW5faW42X3NhZGRyLnM2X2FkZHIpOwoJCWZtdF9pcDYoYjMsIHBrdF9kZXYtPm1heF9pbjZfc2FkZHIuczZfYWRkcik7CgkJc2VxX3ByaW50ZihzZXEsCgkJCSAgICIgICAgIHNhZGRyOiAlcyAgbWluX3NhZGRyOiAlcyAgbWF4X3NhZGRyOiAlc1xuIiwgYjEsCgkJCSAgIGIyLCBiMyk7CgoJCWZtdF9pcDYoYjEsIHBrdF9kZXYtPmluNl9kYWRkci5zNl9hZGRyKTsKCQlmbXRfaXA2KGIyLCBwa3RfZGV2LT5taW5faW42X2RhZGRyLnM2X2FkZHIpOwoJCWZtdF9pcDYoYjMsIHBrdF9kZXYtPm1heF9pbjZfZGFkZHIuczZfYWRkcik7CgkJc2VxX3ByaW50ZihzZXEsCgkJCSAgICIgICAgIGRhZGRyOiAlcyAgbWluX2RhZGRyOiAlcyAgbWF4X2RhZGRyOiAlc1xuIiwgYjEsCgkJCSAgIGIyLCBiMyk7CgoJfSBlbHNlCgkJc2VxX3ByaW50ZihzZXEsCgkJCSAgICIgICAgIGRzdF9taW46ICVzICBkc3RfbWF4OiAlc1xuICAgICBzcmNfbWluOiAlcyAgc3JjX21heDogJXNcbiIsCgkJCSAgIHBrdF9kZXYtPmRzdF9taW4sIHBrdF9kZXYtPmRzdF9tYXgsIHBrdF9kZXYtPnNyY19taW4sCgkJCSAgIHBrdF9kZXYtPnNyY19tYXgpOwoKCXNlcV9wdXRzKHNlcSwgIiAgICAgc3JjX21hYzogIik7CgoJaWYgKGlzX3plcm9fZXRoZXJfYWRkcihwa3RfZGV2LT5zcmNfbWFjKSkKCQlmb3IgKGkgPSAwOyBpIDwgNjsgaSsrKQoJCQlzZXFfcHJpbnRmKHNlcSwgIiUwMlglcyIsIHBrdF9kZXYtPm9kZXYtPmRldl9hZGRyW2ldLAoJCQkJICAgaSA9PSA1ID8gIiAgIiA6ICI6Iik7CgllbHNlCgkJZm9yIChpID0gMDsgaSA8IDY7IGkrKykKCQkJc2VxX3ByaW50ZihzZXEsICIlMDJYJXMiLCBwa3RfZGV2LT5zcmNfbWFjW2ldLAoJCQkJICAgaSA9PSA1ID8gIiAgIiA6ICI6Iik7CgoJc2VxX3ByaW50ZihzZXEsICJkc3RfbWFjOiAiKTsKCWZvciAoaSA9IDA7IGkgPCA2OyBpKyspCgkJc2VxX3ByaW50ZihzZXEsICIlMDJYJXMiLCBwa3RfZGV2LT5kc3RfbWFjW2ldLAoJCQkgICBpID09IDUgPyAiXG4iIDogIjoiKTsKCglzZXFfcHJpbnRmKHNlcSwKCQkgICAiICAgICB1ZHBfc3JjX21pbjogJWQgIHVkcF9zcmNfbWF4OiAlZCAgdWRwX2RzdF9taW46ICVkICB1ZHBfZHN0X21heDogJWRcbiIsCgkJICAgcGt0X2Rldi0+dWRwX3NyY19taW4sIHBrdF9kZXYtPnVkcF9zcmNfbWF4LAoJCSAgIHBrdF9kZXYtPnVkcF9kc3RfbWluLCBwa3RfZGV2LT51ZHBfZHN0X21heCk7CgoJc2VxX3ByaW50ZihzZXEsCgkJICAgIiAgICAgc3JjX21hY19jb3VudDogJWQgIGRzdF9tYWNfY291bnQ6ICVkXG4iLAoJCSAgIHBrdF9kZXYtPnNyY19tYWNfY291bnQsIHBrdF9kZXYtPmRzdF9tYWNfY291bnQpOwoKCWlmIChwa3RfZGV2LT5ucl9sYWJlbHMpIHsKCQl1bnNpZ25lZCBpOwoJCXNlcV9wcmludGYoc2VxLCAiICAgICBtcGxzOiAiKTsKCQlmb3IoaSA9IDA7IGkgPCBwa3RfZGV2LT5ucl9sYWJlbHM7IGkrKykKCQkJc2VxX3ByaW50ZihzZXEsICIlMDh4JXMiLCBudG9obChwa3RfZGV2LT5sYWJlbHNbaV0pLAoJCQkJICAgaSA9PSBwa3RfZGV2LT5ucl9sYWJlbHMtMSA/ICJcbiIgOiAiLCAiKTsKCX0KCglpZiAocGt0X2Rldi0+dmxhbl9pZCAhPSAweGZmZmYpIHsKCQlzZXFfcHJpbnRmKHNlcSwgIiAgICAgdmxhbl9pZDogJXUgIHZsYW5fcDogJXUgIHZsYW5fY2ZpOiAldVxuIiwKCQkJICAgcGt0X2Rldi0+dmxhbl9pZCwgcGt0X2Rldi0+dmxhbl9wLCBwa3RfZGV2LT52bGFuX2NmaSk7Cgl9CgoJaWYgKHBrdF9kZXYtPnN2bGFuX2lkICE9IDB4ZmZmZikgewoJCXNlcV9wcmludGYoc2VxLCAiICAgICBzdmxhbl9pZDogJXUgIHZsYW5fcDogJXUgIHZsYW5fY2ZpOiAldVxuIiwKCQkJICAgcGt0X2Rldi0+c3ZsYW5faWQsIHBrdF9kZXYtPnN2bGFuX3AsIHBrdF9kZXYtPnN2bGFuX2NmaSk7Cgl9CgoJaWYgKHBrdF9kZXYtPnRvcykgewoJCXNlcV9wcmludGYoc2VxLCAiICAgICB0b3M6IDB4JTAyeFxuIiwgcGt0X2Rldi0+dG9zKTsKCX0KCglpZiAocGt0X2Rldi0+dHJhZmZpY19jbGFzcykgewoJCXNlcV9wcmludGYoc2VxLCAiICAgICB0cmFmZmljX2NsYXNzOiAweCUwMnhcbiIsIHBrdF9kZXYtPnRyYWZmaWNfY2xhc3MpOwoJfQoKCXNlcV9wcmludGYoc2VxLCAiICAgICBGbGFnczogIik7CgoJaWYgKHBrdF9kZXYtPmZsYWdzICYgRl9JUFY2KQoJCXNlcV9wcmludGYoc2VxLCAiSVBWNiAgIik7CgoJaWYgKHBrdF9kZXYtPmZsYWdzICYgRl9JUFNSQ19STkQpCgkJc2VxX3ByaW50ZihzZXEsICJJUFNSQ19STkQgICIpOwoKCWlmIChwa3RfZGV2LT5mbGFncyAmIEZfSVBEU1RfUk5EKQoJCXNlcV9wcmludGYoc2VxLCAiSVBEU1RfUk5EICAiKTsKCglpZiAocGt0X2Rldi0+ZmxhZ3MgJiBGX1RYU0laRV9STkQpCgkJc2VxX3ByaW50ZihzZXEsICJUWFNJWkVfUk5EICAiKTsKCglpZiAocGt0X2Rldi0+ZmxhZ3MgJiBGX1VEUFNSQ19STkQpCgkJc2VxX3ByaW50ZihzZXEsICJVRFBTUkNfUk5EICAiKTsKCglpZiAocGt0X2Rldi0+ZmxhZ3MgJiBGX1VEUERTVF9STkQpCgkJc2VxX3ByaW50ZihzZXEsICJVRFBEU1RfUk5EICAiKTsKCglpZiAocGt0X2Rldi0+ZmxhZ3MgJiBGX01QTFNfUk5EKQoJCXNlcV9wcmludGYoc2VxLCAgIk1QTFNfUk5EICAiKTsKCglpZiAocGt0X2Rldi0+ZmxhZ3MgJiBGX01BQ1NSQ19STkQpCgkJc2VxX3ByaW50ZihzZXEsICJNQUNTUkNfUk5EICAiKTsKCglpZiAocGt0X2Rldi0+ZmxhZ3MgJiBGX01BQ0RTVF9STkQpCgkJc2VxX3ByaW50ZihzZXEsICJNQUNEU1RfUk5EICAiKTsKCglpZiAocGt0X2Rldi0+ZmxhZ3MgJiBGX1ZJRF9STkQpCgkJc2VxX3ByaW50ZihzZXEsICJWSURfUk5EICAiKTsKCglpZiAocGt0X2Rldi0+ZmxhZ3MgJiBGX1NWSURfUk5EKQoJCXNlcV9wcmludGYoc2VxLCAiU1ZJRF9STkQgICIpOwoKCXNlcV9wdXRzKHNlcSwgIlxuIik7CgoJc2EgPSBwa3RfZGV2LT5zdGFydGVkX2F0OwoJc3RvcHBlZCA9IHBrdF9kZXYtPnN0b3BwZWRfYXQ7CglpZiAocGt0X2Rldi0+cnVubmluZykKCQlzdG9wcGVkID0gbm93OwkvKiBub3QgcmVhbGx5IHN0b3BwZWQsIG1vcmUgbGlrZSBsYXN0LXJ1bm5pbmctYXQgKi8KCglzZXFfcHJpbnRmKHNlcSwKCQkgICAiQ3VycmVudDpcbiAgICAgcGt0cy1zb2ZhcjogJWxsdSAgZXJyb3JzOiAlbGx1XG4gICAgIHN0YXJ0ZWQ6ICVsbHV1cyAgc3RvcHBlZDogJWxsdXVzIGlkbGU6ICVsbHV1c1xuIiwKCQkgICAodW5zaWduZWQgbG9uZyBsb25nKXBrdF9kZXYtPnNvZmFyLAoJCSAgICh1bnNpZ25lZCBsb25nIGxvbmcpcGt0X2Rldi0+ZXJyb3JzLCAodW5zaWduZWQgbG9uZyBsb25nKXNhLAoJCSAgICh1bnNpZ25lZCBsb25nIGxvbmcpc3RvcHBlZCwKCQkgICAodW5zaWduZWQgbG9uZyBsb25nKXBrdF9kZXYtPmlkbGVfYWNjKTsKCglzZXFfcHJpbnRmKHNlcSwKCQkgICAiICAgICBzZXFfbnVtOiAlZCAgY3VyX2RzdF9tYWNfb2Zmc2V0OiAlZCAgY3VyX3NyY19tYWNfb2Zmc2V0OiAlZFxuIiwKCQkgICBwa3RfZGV2LT5zZXFfbnVtLCBwa3RfZGV2LT5jdXJfZHN0X21hY19vZmZzZXQsCgkJICAgcGt0X2Rldi0+Y3VyX3NyY19tYWNfb2Zmc2V0KTsKCglpZiAocGt0X2Rldi0+ZmxhZ3MgJiBGX0lQVjYpIHsKCQljaGFyIGIxWzEyOF0sIGIyWzEyOF07CgkJZm10X2lwNihiMSwgcGt0X2Rldi0+Y3VyX2luNl9kYWRkci5zNl9hZGRyKTsKCQlmbXRfaXA2KGIyLCBwa3RfZGV2LT5jdXJfaW42X3NhZGRyLnM2X2FkZHIpOwoJCXNlcV9wcmludGYoc2VxLCAiICAgICBjdXJfc2FkZHI6ICVzICBjdXJfZGFkZHI6ICVzXG4iLCBiMiwgYjEpOwoJfSBlbHNlCgkJc2VxX3ByaW50ZihzZXEsICIgICAgIGN1cl9zYWRkcjogMHgleCAgY3VyX2RhZGRyOiAweCV4XG4iLAoJCQkgICBwa3RfZGV2LT5jdXJfc2FkZHIsIHBrdF9kZXYtPmN1cl9kYWRkcik7CgoJc2VxX3ByaW50ZihzZXEsICIgICAgIGN1cl91ZHBfZHN0OiAlZCAgY3VyX3VkcF9zcmM6ICVkXG4iLAoJCSAgIHBrdF9kZXYtPmN1cl91ZHBfZHN0LCBwa3RfZGV2LT5jdXJfdWRwX3NyYyk7CgoJc2VxX3ByaW50ZihzZXEsICIgICAgIGZsb3dzOiAldVxuIiwgcGt0X2Rldi0+bmZsb3dzKTsKCglpZiAocGt0X2Rldi0+cmVzdWx0WzBdKQoJCXNlcV9wcmludGYoc2VxLCAiUmVzdWx0OiAlc1xuIiwgcGt0X2Rldi0+cmVzdWx0KTsKCWVsc2UKCQlzZXFfcHJpbnRmKHNlcSwgIlJlc3VsdDogSWRsZVxuIik7CgoJcmV0dXJuIDA7Cn0KCgpzdGF0aWMgaW50IGhleDMyX2FyZyhjb25zdCBjaGFyIF9fdXNlciAqdXNlcl9idWZmZXIsIHVuc2lnbmVkIGxvbmcgbWF4bGVuLCBfX3UzMiAqbnVtKQp7CglpbnQgaSA9IDA7CgkqbnVtID0gMDsKCglmb3IoOyBpIDwgbWF4bGVuOyBpKyspIHsKCQljaGFyIGM7CgkJKm51bSA8PD0gNDsKCQlpZiAoZ2V0X3VzZXIoYywgJnVzZXJfYnVmZmVyW2ldKSkKCQkJcmV0dXJuIC1FRkFVTFQ7CgkJaWYgKChjID49ICcwJykgJiYgKGMgPD0gJzknKSkKCQkJKm51bSB8PSBjIC0gJzAnOwoJCWVsc2UgaWYgKChjID49ICdhJykgJiYgKGMgPD0gJ2YnKSkKCQkJKm51bSB8PSBjIC0gJ2EnICsgMTA7CgkJZWxzZSBpZiAoKGMgPj0gJ0EnKSAmJiAoYyA8PSAnRicpKQoJCQkqbnVtIHw9IGMgLSAnQScgKyAxMDsKCQllbHNlCgkJCWJyZWFrOwoJfQoJcmV0dXJuIGk7Cn0KCnN0YXRpYyBpbnQgY291bnRfdHJhaWxfY2hhcnMoY29uc3QgY2hhciBfX3VzZXIgKiB1c2VyX2J1ZmZlciwKCQkJICAgICB1bnNpZ25lZCBpbnQgbWF4bGVuKQp7CglpbnQgaTsKCglmb3IgKGkgPSAwOyBpIDwgbWF4bGVuOyBpKyspIHsKCQljaGFyIGM7CgkJaWYgKGdldF91c2VyKGMsICZ1c2VyX2J1ZmZlcltpXSkpCgkJCXJldHVybiAtRUZBVUxUOwoJCXN3aXRjaCAoYykgewoJCWNhc2UgJ1wiJzoKCQljYXNlICdcbic6CgkJY2FzZSAnXHInOgoJCWNhc2UgJ1x0JzoKCQljYXNlICcgJzoKCQljYXNlICc9JzoKCQkJYnJlYWs7CgkJZGVmYXVsdDoKCQkJZ290byBkb25lOwoJCX07Cgl9CmRvbmU6CglyZXR1cm4gaTsKfQoKc3RhdGljIHVuc2lnbmVkIGxvbmcgbnVtX2FyZyhjb25zdCBjaGFyIF9fdXNlciAqIHVzZXJfYnVmZmVyLAoJCQkgICAgIHVuc2lnbmVkIGxvbmcgbWF4bGVuLCB1bnNpZ25lZCBsb25nICpudW0pCnsKCWludCBpID0gMDsKCSpudW0gPSAwOwoKCWZvciAoOyBpIDwgbWF4bGVuOyBpKyspIHsKCQljaGFyIGM7CgkJaWYgKGdldF91c2VyKGMsICZ1c2VyX2J1ZmZlcltpXSkpCgkJCXJldHVybiAtRUZBVUxUOwoJCWlmICgoYyA+PSAnMCcpICYmIChjIDw9ICc5JykpIHsKCQkJKm51bSAqPSAxMDsKCQkJKm51bSArPSBjIC0gJzAnOwoJCX0gZWxzZQoJCQlicmVhazsKCX0KCXJldHVybiBpOwp9CgpzdGF0aWMgaW50IHN0cm5fbGVuKGNvbnN0IGNoYXIgX191c2VyICogdXNlcl9idWZmZXIsIHVuc2lnbmVkIGludCBtYXhsZW4pCnsKCWludCBpID0gMDsKCglmb3IgKDsgaSA8IG1heGxlbjsgaSsrKSB7CgkJY2hhciBjOwoJCWlmIChnZXRfdXNlcihjLCAmdXNlcl9idWZmZXJbaV0pKQoJCQlyZXR1cm4gLUVGQVVMVDsKCQlzd2l0Y2ggKGMpIHsKCQljYXNlICdcIic6CgkJY2FzZSAnXG4nOgoJCWNhc2UgJ1xyJzoKCQljYXNlICdcdCc6CgkJY2FzZSAnICc6CgkJCWdvdG8gZG9uZV9zdHI7CgkJCWJyZWFrOwoJCWRlZmF1bHQ6CgkJCWJyZWFrOwoJCX07Cgl9CmRvbmVfc3RyOgoJcmV0dXJuIGk7Cn0KCnN0YXRpYyBzc2l6ZV90IGdldF9sYWJlbHMoY29uc3QgY2hhciBfX3VzZXIgKmJ1ZmZlciwgc3RydWN0IHBrdGdlbl9kZXYgKnBrdF9kZXYpCnsKCXVuc2lnbmVkIG4gPSAwOwoJY2hhciBjOwoJc3NpemVfdCBpID0gMDsKCWludCBsZW47CgoJcGt0X2Rldi0+bnJfbGFiZWxzID0gMDsKCWRvIHsKCQlfX3UzMiB0bXA7CgkJbGVuID0gaGV4MzJfYXJnKCZidWZmZXJbaV0sIDgsICZ0bXApOwoJCWlmIChsZW4gPD0gMCkKCQkJcmV0dXJuIGxlbjsKCQlwa3RfZGV2LT5sYWJlbHNbbl0gPSBodG9ubCh0bXApOwoJCWlmIChwa3RfZGV2LT5sYWJlbHNbbl0gJiBNUExTX1NUQUNLX0JPVFRPTSkKCQkJcGt0X2Rldi0+ZmxhZ3MgfD0gRl9NUExTX1JORDsKCQlpICs9IGxlbjsKCQlpZiAoZ2V0X3VzZXIoYywgJmJ1ZmZlcltpXSkpCgkJCXJldHVybiAtRUZBVUxUOwoJCWkrKzsKCQluKys7CgkJaWYgKG4gPj0gTUFYX01QTFNfTEFCRUxTKQoJCQlyZXR1cm4gLUUyQklHOwoJfSB3aGlsZShjID09ICcsJyk7CgoJcGt0X2Rldi0+bnJfbGFiZWxzID0gbjsKCXJldHVybiBpOwp9CgpzdGF0aWMgc3NpemVfdCBwa3RnZW5faWZfd3JpdGUoc3RydWN0IGZpbGUgKmZpbGUsCgkJCSAgICAgICBjb25zdCBjaGFyIF9fdXNlciAqIHVzZXJfYnVmZmVyLCBzaXplX3QgY291bnQsCgkJCSAgICAgICBsb2ZmX3QgKiBvZmZzZXQpCnsKCXN0cnVjdCBzZXFfZmlsZSAqc2VxID0gKHN0cnVjdCBzZXFfZmlsZSAqKWZpbGUtPnByaXZhdGVfZGF0YTsKCXN0cnVjdCBwa3RnZW5fZGV2ICpwa3RfZGV2ID0gc2VxLT5wcml2YXRlOwoJaW50IGkgPSAwLCBtYXgsIGxlbjsKCWNoYXIgbmFtZVsxNl0sIHZhbHN0clszMl07Cgl1bnNpZ25lZCBsb25nIHZhbHVlID0gMDsKCWNoYXIgKnBnX3Jlc3VsdCA9IE5VTEw7CglpbnQgdG1wID0gMDsKCWNoYXIgYnVmWzEyOF07CgoJcGdfcmVzdWx0ID0gJihwa3RfZGV2LT5yZXN1bHRbMF0pOwoKCWlmIChjb3VudCA8IDEpIHsKCQlwcmludGsoInBrdGdlbjogd3JvbmcgY29tbWFuZCBmb3JtYXRcbiIpOwoJCXJldHVybiAtRUlOVkFMOwoJfQoKCW1heCA9IGNvdW50IC0gaTsKCXRtcCA9IGNvdW50X3RyYWlsX2NoYXJzKCZ1c2VyX2J1ZmZlcltpXSwgbWF4KTsKCWlmICh0bXAgPCAwKSB7CgkJcHJpbnRrKCJwa3RnZW46IGlsbGVnYWwgZm9ybWF0XG4iKTsKCQlyZXR1cm4gdG1wOwoJfQoJaSArPSB0bXA7CgoJLyogUmVhZCB2YXJpYWJsZSBuYW1lICovCgoJbGVuID0gc3Rybl9sZW4oJnVzZXJfYnVmZmVyW2ldLCBzaXplb2YobmFtZSkgLSAxKTsKCWlmIChsZW4gPCAwKSB7CgkJcmV0dXJuIGxlbjsKCX0KCW1lbXNldChuYW1lLCAwLCBzaXplb2YobmFtZSkpOwoJaWYgKGNvcHlfZnJvbV91c2VyKG5hbWUsICZ1c2VyX2J1ZmZlcltpXSwgbGVuKSkKCQlyZXR1cm4gLUVGQVVMVDsKCWkgKz0gbGVuOwoKCW1heCA9IGNvdW50IC0gaTsKCWxlbiA9IGNvdW50X3RyYWlsX2NoYXJzKCZ1c2VyX2J1ZmZlcltpXSwgbWF4KTsKCWlmIChsZW4gPCAwKQoJCXJldHVybiBsZW47CgoJaSArPSBsZW47CgoJaWYgKGRlYnVnKSB7CgkJY2hhciB0Yltjb3VudCArIDFdOwoJCWlmIChjb3B5X2Zyb21fdXNlcih0YiwgdXNlcl9idWZmZXIsIGNvdW50KSkKCQkJcmV0dXJuIC1FRkFVTFQ7CgkJdGJbY291bnRdID0gMDsKCQlwcmludGsoInBrdGdlbjogJXMsJWx1ICBidWZmZXIgLTolczotXG4iLCBuYW1lLAoJCSAgICAgICAodW5zaWduZWQgbG9uZyljb3VudCwgdGIpOwoJfQoKCWlmICghc3RyY21wKG5hbWUsICJtaW5fcGt0X3NpemUiKSkgewoJCWxlbiA9IG51bV9hcmcoJnVzZXJfYnVmZmVyW2ldLCAxMCwgJnZhbHVlKTsKCQlpZiAobGVuIDwgMCkgewoJCQlyZXR1cm4gbGVuOwoJCX0KCQlpICs9IGxlbjsKCQlpZiAodmFsdWUgPCAxNCArIDIwICsgOCkKCQkJdmFsdWUgPSAxNCArIDIwICsgODsKCQlpZiAodmFsdWUgIT0gcGt0X2Rldi0+bWluX3BrdF9zaXplKSB7CgkJCXBrdF9kZXYtPm1pbl9wa3Rfc2l6ZSA9IHZhbHVlOwoJCQlwa3RfZGV2LT5jdXJfcGt0X3NpemUgPSB2YWx1ZTsKCQl9CgkJc3ByaW50ZihwZ19yZXN1bHQsICJPSzogbWluX3BrdF9zaXplPSV1IiwKCQkJcGt0X2Rldi0+bWluX3BrdF9zaXplKTsKCQlyZXR1cm4gY291bnQ7Cgl9CgoJaWYgKCFzdHJjbXAobmFtZSwgIm1heF9wa3Rfc2l6ZSIpKSB7CgkJbGVuID0gbnVtX2FyZygmdXNlcl9idWZmZXJbaV0sIDEwLCAmdmFsdWUpOwoJCWlmIChsZW4gPCAwKSB7CgkJCXJldHVybiBsZW47CgkJfQoJCWkgKz0gbGVuOwoJCWlmICh2YWx1ZSA8IDE0ICsgMjAgKyA4KQoJCQl2YWx1ZSA9IDE0ICsgMjAgKyA4OwoJCWlmICh2YWx1ZSAhPSBwa3RfZGV2LT5tYXhfcGt0X3NpemUpIHsKCQkJcGt0X2Rldi0+bWF4X3BrdF9zaXplID0gdmFsdWU7CgkJCXBrdF9kZXYtPmN1cl9wa3Rfc2l6ZSA9IHZhbHVlOwoJCX0KCQlzcHJpbnRmKHBnX3Jlc3VsdCwgIk9LOiBtYXhfcGt0X3NpemU9JXUiLAoJCQlwa3RfZGV2LT5tYXhfcGt0X3NpemUpOwoJCXJldHVybiBjb3VudDsKCX0KCgkvKiBTaG9ydGN1dCBmb3IgbWluID0gbWF4ICovCgoJaWYgKCFzdHJjbXAobmFtZSwgInBrdF9zaXplIikpIHsKCQlsZW4gPSBudW1fYXJnKCZ1c2VyX2J1ZmZlcltpXSwgMTAsICZ2YWx1ZSk7CgkJaWYgKGxlbiA8IDApIHsKCQkJcmV0dXJuIGxlbjsKCQl9CgkJaSArPSBsZW47CgkJaWYgKHZhbHVlIDwgMTQgKyAyMCArIDgpCgkJCXZhbHVlID0gMTQgKyAyMCArIDg7CgkJaWYgKHZhbHVlICE9IHBrdF9kZXYtPm1pbl9wa3Rfc2l6ZSkgewoJCQlwa3RfZGV2LT5taW5fcGt0X3NpemUgPSB2YWx1ZTsKCQkJcGt0X2Rldi0+bWF4X3BrdF9zaXplID0gdmFsdWU7CgkJCXBrdF9kZXYtPmN1cl9wa3Rfc2l6ZSA9IHZhbHVlOwoJCX0KCQlzcHJpbnRmKHBnX3Jlc3VsdCwgIk9LOiBwa3Rfc2l6ZT0ldSIsIHBrdF9kZXYtPm1pbl9wa3Rfc2l6ZSk7CgkJcmV0dXJuIGNvdW50OwoJfQoKCWlmICghc3RyY21wKG5hbWUsICJkZWJ1ZyIpKSB7CgkJbGVuID0gbnVtX2FyZygmdXNlcl9idWZmZXJbaV0sIDEwLCAmdmFsdWUpOwoJCWlmIChsZW4gPCAwKSB7CgkJCXJldHVybiBsZW47CgkJfQoJCWkgKz0gbGVuOwoJCWRlYnVnID0gdmFsdWU7CgkJc3ByaW50ZihwZ19yZXN1bHQsICJPSzogZGVidWc9JXUiLCBkZWJ1Zyk7CgkJcmV0dXJuIGNvdW50OwoJfQoKCWlmICghc3RyY21wKG5hbWUsICJmcmFncyIpKSB7CgkJbGVuID0gbnVtX2FyZygmdXNlcl9idWZmZXJbaV0sIDEwLCAmdmFsdWUpOwoJCWlmIChsZW4gPCAwKSB7CgkJCXJldHVybiBsZW47CgkJfQoJCWkgKz0gbGVuOwoJCXBrdF9kZXYtPm5mcmFncyA9IHZhbHVlOwoJCXNwcmludGYocGdfcmVzdWx0LCAiT0s6IGZyYWdzPSV1IiwgcGt0X2Rldi0+bmZyYWdzKTsKCQlyZXR1cm4gY291bnQ7Cgl9CglpZiAoIXN0cmNtcChuYW1lLCAiZGVsYXkiKSkgewoJCWxlbiA9IG51bV9hcmcoJnVzZXJfYnVmZmVyW2ldLCAxMCwgJnZhbHVlKTsKCQlpZiAobGVuIDwgMCkgewoJCQlyZXR1cm4gbGVuOwoJCX0KCQlpICs9IGxlbjsKCQlpZiAodmFsdWUgPT0gMHg3RkZGRkZGRikgewoJCQlwa3RfZGV2LT5kZWxheV91cyA9IDB4N0ZGRkZGRkY7CgkJCXBrdF9kZXYtPmRlbGF5X25zID0gMDsKCQl9IGVsc2UgewoJCQlwa3RfZGV2LT5kZWxheV91cyA9IHZhbHVlIC8gMTAwMDsKCQkJcGt0X2Rldi0+ZGVsYXlfbnMgPSB2YWx1ZSAlIDEwMDA7CgkJfQoJCXNwcmludGYocGdfcmVzdWx0LCAiT0s6IGRlbGF5PSV1IiwKCQkJMTAwMCAqIHBrdF9kZXYtPmRlbGF5X3VzICsgcGt0X2Rldi0+ZGVsYXlfbnMpOwoJCXJldHVybiBjb3VudDsKCX0KCWlmICghc3RyY21wKG5hbWUsICJ1ZHBfc3JjX21pbiIpKSB7CgkJbGVuID0gbnVtX2FyZygmdXNlcl9idWZmZXJbaV0sIDEwLCAmdmFsdWUpOwoJCWlmIChsZW4gPCAwKSB7CgkJCXJldHVybiBsZW47CgkJfQoJCWkgKz0gbGVuOwoJCWlmICh2YWx1ZSAhPSBwa3RfZGV2LT51ZHBfc3JjX21pbikgewoJCQlwa3RfZGV2LT51ZHBfc3JjX21pbiA9IHZhbHVlOwoJCQlwa3RfZGV2LT5jdXJfdWRwX3NyYyA9IHZhbHVlOwoJCX0KCQlzcHJpbnRmKHBnX3Jlc3VsdCwgIk9LOiB1ZHBfc3JjX21pbj0ldSIsIHBrdF9kZXYtPnVkcF9zcmNfbWluKTsKCQlyZXR1cm4gY291bnQ7Cgl9CglpZiAoIXN0cmNtcChuYW1lLCAidWRwX2RzdF9taW4iKSkgewoJCWxlbiA9IG51bV9hcmcoJnVzZXJfYnVmZmVyW2ldLCAxMCwgJnZhbHVlKTsKCQlpZiAobGVuIDwgMCkgewoJCQlyZXR1cm4gbGVuOwoJCX0KCQlpICs9IGxlbjsKCQlpZiAodmFsdWUgIT0gcGt0X2Rldi0+dWRwX2RzdF9taW4pIHsKCQkJcGt0X2Rldi0+dWRwX2RzdF9taW4gPSB2YWx1ZTsKCQkJcGt0X2Rldi0+Y3VyX3VkcF9kc3QgPSB2YWx1ZTsKCQl9CgkJc3ByaW50ZihwZ19yZXN1bHQsICJPSzogdWRwX2RzdF9taW49JXUiLCBwa3RfZGV2LT51ZHBfZHN0X21pbik7CgkJcmV0dXJuIGNvdW50OwoJfQoJaWYgKCFzdHJjbXAobmFtZSwgInVkcF9zcmNfbWF4IikpIHsKCQlsZW4gPSBudW1fYXJnKCZ1c2VyX2J1ZmZlcltpXSwgMTAsICZ2YWx1ZSk7CgkJaWYgKGxlbiA8IDApIHsKCQkJcmV0dXJuIGxlbjsKCQl9CgkJaSArPSBsZW47CgkJaWYgKHZhbHVlICE9IHBrdF9kZXYtPnVkcF9zcmNfbWF4KSB7CgkJCXBrdF9kZXYtPnVkcF9zcmNfbWF4ID0gdmFsdWU7CgkJCXBrdF9kZXYtPmN1cl91ZHBfc3JjID0gdmFsdWU7CgkJfQoJCXNwcmludGYocGdfcmVzdWx0LCAiT0s6IHVkcF9zcmNfbWF4PSV1IiwgcGt0X2Rldi0+dWRwX3NyY19tYXgpOwoJCXJldHVybiBjb3VudDsKCX0KCWlmICghc3RyY21wKG5hbWUsICJ1ZHBfZHN0X21heCIpKSB7CgkJbGVuID0gbnVtX2FyZygmdXNlcl9idWZmZXJbaV0sIDEwLCAmdmFsdWUpOwoJCWlmIChsZW4gPCAwKSB7CgkJCXJldHVybiBsZW47CgkJfQoJCWkgKz0gbGVuOwoJCWlmICh2YWx1ZSAhPSBwa3RfZGV2LT51ZHBfZHN0X21heCkgewoJCQlwa3RfZGV2LT51ZHBfZHN0X21heCA9IHZhbHVlOwoJCQlwa3RfZGV2LT5jdXJfdWRwX2RzdCA9IHZhbHVlOwoJCX0KCQlzcHJpbnRmKHBnX3Jlc3VsdCwgIk9LOiB1ZHBfZHN0X21heD0ldSIsIHBrdF9kZXYtPnVkcF9kc3RfbWF4KTsKCQlyZXR1cm4gY291bnQ7Cgl9CglpZiAoIXN0cmNtcChuYW1lLCAiY2xvbmVfc2tiIikpIHsKCQlsZW4gPSBudW1fYXJnKCZ1c2VyX2J1ZmZlcltpXSwgMTAsICZ2YWx1ZSk7CgkJaWYgKGxlbiA8IDApIHsKCQkJcmV0dXJuIGxlbjsKCQl9CgkJaSArPSBsZW47CgkJcGt0X2Rldi0+Y2xvbmVfc2tiID0gdmFsdWU7CgoJCXNwcmludGYocGdfcmVzdWx0LCAiT0s6IGNsb25lX3NrYj0lZCIsIHBrdF9kZXYtPmNsb25lX3NrYik7CgkJcmV0dXJuIGNvdW50OwoJfQoJaWYgKCFzdHJjbXAobmFtZSwgImNvdW50IikpIHsKCQlsZW4gPSBudW1fYXJnKCZ1c2VyX2J1ZmZlcltpXSwgMTAsICZ2YWx1ZSk7CgkJaWYgKGxlbiA8IDApIHsKCQkJcmV0dXJuIGxlbjsKCQl9CgkJaSArPSBsZW47CgkJcGt0X2Rldi0+Y291bnQgPSB2YWx1ZTsKCQlzcHJpbnRmKHBnX3Jlc3VsdCwgIk9LOiBjb3VudD0lbGx1IiwKCQkJKHVuc2lnbmVkIGxvbmcgbG9uZylwa3RfZGV2LT5jb3VudCk7CgkJcmV0dXJuIGNvdW50OwoJfQoJaWYgKCFzdHJjbXAobmFtZSwgInNyY19tYWNfY291bnQiKSkgewoJCWxlbiA9IG51bV9hcmcoJnVzZXJfYnVmZmVyW2ldLCAxMCwgJnZhbHVlKTsKCQlpZiAobGVuIDwgMCkgewoJCQlyZXR1cm4gbGVuOwoJCX0KCQlpICs9IGxlbjsKCQlpZiAocGt0X2Rldi0+c3JjX21hY19jb3VudCAhPSB2YWx1ZSkgewoJCQlwa3RfZGV2LT5zcmNfbWFjX2NvdW50ID0gdmFsdWU7CgkJCXBrdF9kZXYtPmN1cl9zcmNfbWFjX29mZnNldCA9IDA7CgkJfQoJCXNwcmludGYocGdfcmVzdWx0LCAiT0s6IHNyY19tYWNfY291bnQ9JWQiLAoJCQlwa3RfZGV2LT5zcmNfbWFjX2NvdW50KTsKCQlyZXR1cm4gY291bnQ7Cgl9CglpZiAoIXN0cmNtcChuYW1lLCAiZHN0X21hY19jb3VudCIpKSB7CgkJbGVuID0gbnVtX2FyZygmdXNlcl9idWZmZXJbaV0sIDEwLCAmdmFsdWUpOwoJCWlmIChsZW4gPCAwKSB7CgkJCXJldHVybiBsZW47CgkJfQoJCWkgKz0gbGVuOwoJCWlmIChwa3RfZGV2LT5kc3RfbWFjX2NvdW50ICE9IHZhbHVlKSB7CgkJCXBrdF9kZXYtPmRzdF9tYWNfY291bnQgPSB2YWx1ZTsKCQkJcGt0X2Rldi0+Y3VyX2RzdF9tYWNfb2Zmc2V0ID0gMDsKCQl9CgkJc3ByaW50ZihwZ19yZXN1bHQsICJPSzogZHN0X21hY19jb3VudD0lZCIsCgkJCXBrdF9kZXYtPmRzdF9tYWNfY291bnQpOwoJCXJldHVybiBjb3VudDsKCX0KCWlmICghc3RyY21wKG5hbWUsICJmbGFnIikpIHsKCQljaGFyIGZbMzJdOwoJCW1lbXNldChmLCAwLCAzMik7CgkJbGVuID0gc3Rybl9sZW4oJnVzZXJfYnVmZmVyW2ldLCBzaXplb2YoZikgLSAxKTsKCQlpZiAobGVuIDwgMCkgewoJCQlyZXR1cm4gbGVuOwoJCX0KCQlpZiAoY29weV9mcm9tX3VzZXIoZiwgJnVzZXJfYnVmZmVyW2ldLCBsZW4pKQoJCQlyZXR1cm4gLUVGQVVMVDsKCQlpICs9IGxlbjsKCQlpZiAoc3RyY21wKGYsICJJUFNSQ19STkQiKSA9PSAwKQoJCQlwa3RfZGV2LT5mbGFncyB8PSBGX0lQU1JDX1JORDsKCgkJZWxzZSBpZiAoc3RyY21wKGYsICIhSVBTUkNfUk5EIikgPT0gMCkKCQkJcGt0X2Rldi0+ZmxhZ3MgJj0gfkZfSVBTUkNfUk5EOwoKCQllbHNlIGlmIChzdHJjbXAoZiwgIlRYU0laRV9STkQiKSA9PSAwKQoJCQlwa3RfZGV2LT5mbGFncyB8PSBGX1RYU0laRV9STkQ7CgoJCWVsc2UgaWYgKHN0cmNtcChmLCAiIVRYU0laRV9STkQiKSA9PSAwKQoJCQlwa3RfZGV2LT5mbGFncyAmPSB+Rl9UWFNJWkVfUk5EOwoKCQllbHNlIGlmIChzdHJjbXAoZiwgIklQRFNUX1JORCIpID09IDApCgkJCXBrdF9kZXYtPmZsYWdzIHw9IEZfSVBEU1RfUk5EOwoKCQllbHNlIGlmIChzdHJjbXAoZiwgIiFJUERTVF9STkQiKSA9PSAwKQoJCQlwa3RfZGV2LT5mbGFncyAmPSB+Rl9JUERTVF9STkQ7CgoJCWVsc2UgaWYgKHN0cmNtcChmLCAiVURQU1JDX1JORCIpID09IDApCgkJCXBrdF9kZXYtPmZsYWdzIHw9IEZfVURQU1JDX1JORDsKCgkJZWxzZSBpZiAoc3RyY21wKGYsICIhVURQU1JDX1JORCIpID09IDApCgkJCXBrdF9kZXYtPmZsYWdzICY9IH5GX1VEUFNSQ19STkQ7CgoJCWVsc2UgaWYgKHN0cmNtcChmLCAiVURQRFNUX1JORCIpID09IDApCgkJCXBrdF9kZXYtPmZsYWdzIHw9IEZfVURQRFNUX1JORDsKCgkJZWxzZSBpZiAoc3RyY21wKGYsICIhVURQRFNUX1JORCIpID09IDApCgkJCXBrdF9kZXYtPmZsYWdzICY9IH5GX1VEUERTVF9STkQ7CgoJCWVsc2UgaWYgKHN0cmNtcChmLCAiTUFDU1JDX1JORCIpID09IDApCgkJCXBrdF9kZXYtPmZsYWdzIHw9IEZfTUFDU1JDX1JORDsKCgkJZWxzZSBpZiAoc3RyY21wKGYsICIhTUFDU1JDX1JORCIpID09IDApCgkJCXBrdF9kZXYtPmZsYWdzICY9IH5GX01BQ1NSQ19STkQ7CgoJCWVsc2UgaWYgKHN0cmNtcChmLCAiTUFDRFNUX1JORCIpID09IDApCgkJCXBrdF9kZXYtPmZsYWdzIHw9IEZfTUFDRFNUX1JORDsKCgkJZWxzZSBpZiAoc3RyY21wKGYsICIhTUFDRFNUX1JORCIpID09IDApCgkJCXBrdF9kZXYtPmZsYWdzICY9IH5GX01BQ0RTVF9STkQ7CgoJCWVsc2UgaWYgKHN0cmNtcChmLCAiTVBMU19STkQiKSA9PSAwKQoJCQlwa3RfZGV2LT5mbGFncyB8PSBGX01QTFNfUk5EOwoKCQllbHNlIGlmIChzdHJjbXAoZiwgIiFNUExTX1JORCIpID09IDApCgkJCXBrdF9kZXYtPmZsYWdzICY9IH5GX01QTFNfUk5EOwoKCQllbHNlIGlmIChzdHJjbXAoZiwgIlZJRF9STkQiKSA9PSAwKQoJCQlwa3RfZGV2LT5mbGFncyB8PSBGX1ZJRF9STkQ7CgoJCWVsc2UgaWYgKHN0cmNtcChmLCAiIVZJRF9STkQiKSA9PSAwKQoJCQlwa3RfZGV2LT5mbGFncyAmPSB+Rl9WSURfUk5EOwoKCQllbHNlIGlmIChzdHJjbXAoZiwgIlNWSURfUk5EIikgPT0gMCkKCQkJcGt0X2Rldi0+ZmxhZ3MgfD0gRl9TVklEX1JORDsKCgkJZWxzZSBpZiAoc3RyY21wKGYsICIhU1ZJRF9STkQiKSA9PSAwKQoJCQlwa3RfZGV2LT5mbGFncyAmPSB+Rl9TVklEX1JORDsKCgkJZWxzZSBpZiAoc3RyY21wKGYsICIhSVBWNiIpID09IDApCgkJCXBrdF9kZXYtPmZsYWdzICY9IH5GX0lQVjY7CgoJCWVsc2UgewoJCQlzcHJpbnRmKHBnX3Jlc3VsdCwKCQkJCSJGbGFnIC06JXM6LSB1bmtub3duXG5BdmFpbGFibGUgZmxhZ3MsIChwcmVwZW5kICEgdG8gdW4tc2V0IGZsYWcpOlxuJXMiLAoJCQkJZiwKCQkJCSJJUFNSQ19STkQsIElQRFNUX1JORCwgVURQU1JDX1JORCwgVURQRFNUX1JORCwgIgoJCQkJIk1BQ1NSQ19STkQsIE1BQ0RTVF9STkQsIFRYU0laRV9STkQsIElQVjYsIE1QTFNfUk5ELCBWSURfUk5ELCBTVklEX1JORFxuIik7CgkJCXJldHVybiBjb3VudDsKCQl9CgkJc3ByaW50ZihwZ19yZXN1bHQsICJPSzogZmxhZ3M9MHgleCIsIHBrdF9kZXYtPmZsYWdzKTsKCQlyZXR1cm4gY291bnQ7Cgl9CglpZiAoIXN0cmNtcChuYW1lLCAiZHN0X21pbiIpIHx8ICFzdHJjbXAobmFtZSwgImRzdCIpKSB7CgkJbGVuID0gc3Rybl9sZW4oJnVzZXJfYnVmZmVyW2ldLCBzaXplb2YocGt0X2Rldi0+ZHN0X21pbikgLSAxKTsKCQlpZiAobGVuIDwgMCkgewoJCQlyZXR1cm4gbGVuOwoJCX0KCgkJaWYgKGNvcHlfZnJvbV91c2VyKGJ1ZiwgJnVzZXJfYnVmZmVyW2ldLCBsZW4pKQoJCQlyZXR1cm4gLUVGQVVMVDsKCQlidWZbbGVuXSA9IDA7CgkJaWYgKHN0cmNtcChidWYsIHBrdF9kZXYtPmRzdF9taW4pICE9IDApIHsKCQkJbWVtc2V0KHBrdF9kZXYtPmRzdF9taW4sIDAsIHNpemVvZihwa3RfZGV2LT5kc3RfbWluKSk7CgkJCXN0cm5jcHkocGt0X2Rldi0+ZHN0X21pbiwgYnVmLCBsZW4pOwoJCQlwa3RfZGV2LT5kYWRkcl9taW4gPSBpbl9hdG9uKHBrdF9kZXYtPmRzdF9taW4pOwoJCQlwa3RfZGV2LT5jdXJfZGFkZHIgPSBwa3RfZGV2LT5kYWRkcl9taW47CgkJfQoJCWlmIChkZWJ1ZykKCQkJcHJpbnRrKCJwa3RnZW46IGRzdF9taW4gc2V0IHRvOiAlc1xuIiwKCQkJICAgICAgIHBrdF9kZXYtPmRzdF9taW4pOwoJCWkgKz0gbGVuOwoJCXNwcmludGYocGdfcmVzdWx0LCAiT0s6IGRzdF9taW49JXMiLCBwa3RfZGV2LT5kc3RfbWluKTsKCQlyZXR1cm4gY291bnQ7Cgl9CglpZiAoIXN0cmNtcChuYW1lLCAiZHN0X21heCIpKSB7CgkJbGVuID0gc3Rybl9sZW4oJnVzZXJfYnVmZmVyW2ldLCBzaXplb2YocGt0X2Rldi0+ZHN0X21heCkgLSAxKTsKCQlpZiAobGVuIDwgMCkgewoJCQlyZXR1cm4gbGVuOwoJCX0KCgkJaWYgKGNvcHlfZnJvbV91c2VyKGJ1ZiwgJnVzZXJfYnVmZmVyW2ldLCBsZW4pKQoJCQlyZXR1cm4gLUVGQVVMVDsKCgkJYnVmW2xlbl0gPSAwOwoJCWlmIChzdHJjbXAoYnVmLCBwa3RfZGV2LT5kc3RfbWF4KSAhPSAwKSB7CgkJCW1lbXNldChwa3RfZGV2LT5kc3RfbWF4LCAwLCBzaXplb2YocGt0X2Rldi0+ZHN0X21heCkpOwoJCQlzdHJuY3B5KHBrdF9kZXYtPmRzdF9tYXgsIGJ1ZiwgbGVuKTsKCQkJcGt0X2Rldi0+ZGFkZHJfbWF4ID0gaW5fYXRvbihwa3RfZGV2LT5kc3RfbWF4KTsKCQkJcGt0X2Rldi0+Y3VyX2RhZGRyID0gcGt0X2Rldi0+ZGFkZHJfbWF4OwoJCX0KCQlpZiAoZGVidWcpCgkJCXByaW50aygicGt0Z2VuOiBkc3RfbWF4IHNldCB0bzogJXNcbiIsCgkJCSAgICAgICBwa3RfZGV2LT5kc3RfbWF4KTsKCQlpICs9IGxlbjsKCQlzcHJpbnRmKHBnX3Jlc3VsdCwgIk9LOiBkc3RfbWF4PSVzIiwgcGt0X2Rldi0+ZHN0X21heCk7CgkJcmV0dXJuIGNvdW50OwoJfQoJaWYgKCFzdHJjbXAobmFtZSwgImRzdDYiKSkgewoJCWxlbiA9IHN0cm5fbGVuKCZ1c2VyX2J1ZmZlcltpXSwgc2l6ZW9mKGJ1ZikgLSAxKTsKCQlpZiAobGVuIDwgMCkKCQkJcmV0dXJuIGxlbjsKCgkJcGt0X2Rldi0+ZmxhZ3MgfD0gRl9JUFY2OwoKCQlpZiAoY29weV9mcm9tX3VzZXIoYnVmLCAmdXNlcl9idWZmZXJbaV0sIGxlbikpCgkJCXJldHVybiAtRUZBVUxUOwoJCWJ1ZltsZW5dID0gMDsKCgkJc2Nhbl9pcDYoYnVmLCBwa3RfZGV2LT5pbjZfZGFkZHIuczZfYWRkcik7CgkJZm10X2lwNihidWYsIHBrdF9kZXYtPmluNl9kYWRkci5zNl9hZGRyKTsKCgkJaXB2Nl9hZGRyX2NvcHkoJnBrdF9kZXYtPmN1cl9pbjZfZGFkZHIsICZwa3RfZGV2LT5pbjZfZGFkZHIpOwoKCQlpZiAoZGVidWcpCgkJCXByaW50aygicGt0Z2VuOiBkc3Q2IHNldCB0bzogJXNcbiIsIGJ1Zik7CgoJCWkgKz0gbGVuOwoJCXNwcmludGYocGdfcmVzdWx0LCAiT0s6IGRzdDY9JXMiLCBidWYpOwoJCXJldHVybiBjb3VudDsKCX0KCWlmICghc3RyY21wKG5hbWUsICJkc3Q2X21pbiIpKSB7CgkJbGVuID0gc3Rybl9sZW4oJnVzZXJfYnVmZmVyW2ldLCBzaXplb2YoYnVmKSAtIDEpOwoJCWlmIChsZW4gPCAwKQoJCQlyZXR1cm4gbGVuOwoKCQlwa3RfZGV2LT5mbGFncyB8PSBGX0lQVjY7CgoJCWlmIChjb3B5X2Zyb21fdXNlcihidWYsICZ1c2VyX2J1ZmZlcltpXSwgbGVuKSkKCQkJcmV0dXJuIC1FRkFVTFQ7CgkJYnVmW2xlbl0gPSAwOwoKCQlzY2FuX2lwNihidWYsIHBrdF9kZXYtPm1pbl9pbjZfZGFkZHIuczZfYWRkcik7CgkJZm10X2lwNihidWYsIHBrdF9kZXYtPm1pbl9pbjZfZGFkZHIuczZfYWRkcik7CgoJCWlwdjZfYWRkcl9jb3B5KCZwa3RfZGV2LT5jdXJfaW42X2RhZGRyLAoJCQkgICAgICAgJnBrdF9kZXYtPm1pbl9pbjZfZGFkZHIpOwoJCWlmIChkZWJ1ZykKCQkJcHJpbnRrKCJwa3RnZW46IGRzdDZfbWluIHNldCB0bzogJXNcbiIsIGJ1Zik7CgoJCWkgKz0gbGVuOwoJCXNwcmludGYocGdfcmVzdWx0LCAiT0s6IGRzdDZfbWluPSVzIiwgYnVmKTsKCQlyZXR1cm4gY291bnQ7Cgl9CglpZiAoIXN0cmNtcChuYW1lLCAiZHN0Nl9tYXgiKSkgewoJCWxlbiA9IHN0cm5fbGVuKCZ1c2VyX2J1ZmZlcltpXSwgc2l6ZW9mKGJ1ZikgLSAxKTsKCQlpZiAobGVuIDwgMCkKCQkJcmV0dXJuIGxlbjsKCgkJcGt0X2Rldi0+ZmxhZ3MgfD0gRl9JUFY2OwoKCQlpZiAoY29weV9mcm9tX3VzZXIoYnVmLCAmdXNlcl9idWZmZXJbaV0sIGxlbikpCgkJCXJldHVybiAtRUZBVUxUOwoJCWJ1ZltsZW5dID0gMDsKCgkJc2Nhbl9pcDYoYnVmLCBwa3RfZGV2LT5tYXhfaW42X2RhZGRyLnM2X2FkZHIpOwoJCWZtdF9pcDYoYnVmLCBwa3RfZGV2LT5tYXhfaW42X2RhZGRyLnM2X2FkZHIpOwoKCQlpZiAoZGVidWcpCgkJCXByaW50aygicGt0Z2VuOiBkc3Q2X21heCBzZXQgdG86ICVzXG4iLCBidWYpOwoKCQlpICs9IGxlbjsKCQlzcHJpbnRmKHBnX3Jlc3VsdCwgIk9LOiBkc3Q2X21heD0lcyIsIGJ1Zik7CgkJcmV0dXJuIGNvdW50OwoJfQoJaWYgKCFzdHJjbXAobmFtZSwgInNyYzYiKSkgewoJCWxlbiA9IHN0cm5fbGVuKCZ1c2VyX2J1ZmZlcltpXSwgc2l6ZW9mKGJ1ZikgLSAxKTsKCQlpZiAobGVuIDwgMCkKCQkJcmV0dXJuIGxlbjsKCgkJcGt0X2Rldi0+ZmxhZ3MgfD0gRl9JUFY2OwoKCQlpZiAoY29weV9mcm9tX3VzZXIoYnVmLCAmdXNlcl9idWZmZXJbaV0sIGxlbikpCgkJCXJldHVybiAtRUZBVUxUOwoJCWJ1ZltsZW5dID0gMDsKCgkJc2Nhbl9pcDYoYnVmLCBwa3RfZGV2LT5pbjZfc2FkZHIuczZfYWRkcik7CgkJZm10X2lwNihidWYsIHBrdF9kZXYtPmluNl9zYWRkci5zNl9hZGRyKTsKCgkJaXB2Nl9hZGRyX2NvcHkoJnBrdF9kZXYtPmN1cl9pbjZfc2FkZHIsICZwa3RfZGV2LT5pbjZfc2FkZHIpOwoKCQlpZiAoZGVidWcpCgkJCXByaW50aygicGt0Z2VuOiBzcmM2IHNldCB0bzogJXNcbiIsIGJ1Zik7CgoJCWkgKz0gbGVuOwoJCXNwcmludGYocGdfcmVzdWx0LCAiT0s6IHNyYzY9JXMiLCBidWYpOwoJCXJldHVybiBjb3VudDsKCX0KCWlmICghc3RyY21wKG5hbWUsICJzcmNfbWluIikpIHsKCQlsZW4gPSBzdHJuX2xlbigmdXNlcl9idWZmZXJbaV0sIHNpemVvZihwa3RfZGV2LT5zcmNfbWluKSAtIDEpOwoJCWlmIChsZW4gPCAwKSB7CgkJCXJldHVybiBsZW47CgkJfQoJCWlmIChjb3B5X2Zyb21fdXNlcihidWYsICZ1c2VyX2J1ZmZlcltpXSwgbGVuKSkKCQkJcmV0dXJuIC1FRkFVTFQ7CgkJYnVmW2xlbl0gPSAwOwoJCWlmIChzdHJjbXAoYnVmLCBwa3RfZGV2LT5zcmNfbWluKSAhPSAwKSB7CgkJCW1lbXNldChwa3RfZGV2LT5zcmNfbWluLCAwLCBzaXplb2YocGt0X2Rldi0+c3JjX21pbikpOwoJCQlzdHJuY3B5KHBrdF9kZXYtPnNyY19taW4sIGJ1ZiwgbGVuKTsKCQkJcGt0X2Rldi0+c2FkZHJfbWluID0gaW5fYXRvbihwa3RfZGV2LT5zcmNfbWluKTsKCQkJcGt0X2Rldi0+Y3VyX3NhZGRyID0gcGt0X2Rldi0+c2FkZHJfbWluOwoJCX0KCQlpZiAoZGVidWcpCgkJCXByaW50aygicGt0Z2VuOiBzcmNfbWluIHNldCB0bzogJXNcbiIsCgkJCSAgICAgICBwa3RfZGV2LT5zcmNfbWluKTsKCQlpICs9IGxlbjsKCQlzcHJpbnRmKHBnX3Jlc3VsdCwgIk9LOiBzcmNfbWluPSVzIiwgcGt0X2Rldi0+c3JjX21pbik7CgkJcmV0dXJuIGNvdW50OwoJfQoJaWYgKCFzdHJjbXAobmFtZSwgInNyY19tYXgiKSkgewoJCWxlbiA9IHN0cm5fbGVuKCZ1c2VyX2J1ZmZlcltpXSwgc2l6ZW9mKHBrdF9kZXYtPnNyY19tYXgpIC0gMSk7CgkJaWYgKGxlbiA8IDApIHsKCQkJcmV0dXJuIGxlbjsKCQl9CgkJaWYgKGNvcHlfZnJvbV91c2VyKGJ1ZiwgJnVzZXJfYnVmZmVyW2ldLCBsZW4pKQoJCQlyZXR1cm4gLUVGQVVMVDsKCQlidWZbbGVuXSA9IDA7CgkJaWYgKHN0cmNtcChidWYsIHBrdF9kZXYtPnNyY19tYXgpICE9IDApIHsKCQkJbWVtc2V0KHBrdF9kZXYtPnNyY19tYXgsIDAsIHNpemVvZihwa3RfZGV2LT5zcmNfbWF4KSk7CgkJCXN0cm5jcHkocGt0X2Rldi0+c3JjX21heCwgYnVmLCBsZW4pOwoJCQlwa3RfZGV2LT5zYWRkcl9tYXggPSBpbl9hdG9uKHBrdF9kZXYtPnNyY19tYXgpOwoJCQlwa3RfZGV2LT5jdXJfc2FkZHIgPSBwa3RfZGV2LT5zYWRkcl9tYXg7CgkJfQoJCWlmIChkZWJ1ZykKCQkJcHJpbnRrKCJwa3RnZW46IHNyY19tYXggc2V0IHRvOiAlc1xuIiwKCQkJICAgICAgIHBrdF9kZXYtPnNyY19tYXgpOwoJCWkgKz0gbGVuOwoJCXNwcmludGYocGdfcmVzdWx0LCAiT0s6IHNyY19tYXg9JXMiLCBwa3RfZGV2LT5zcmNfbWF4KTsKCQlyZXR1cm4gY291bnQ7Cgl9CglpZiAoIXN0cmNtcChuYW1lLCAiZHN0X21hYyIpKSB7CgkJY2hhciAqdiA9IHZhbHN0cjsKCQl1bnNpZ25lZCBjaGFyIG9sZF9kbWFjW0VUSF9BTEVOXTsKCQl1bnNpZ25lZCBjaGFyICptID0gcGt0X2Rldi0+ZHN0X21hYzsKCQltZW1jcHkob2xkX2RtYWMsIHBrdF9kZXYtPmRzdF9tYWMsIEVUSF9BTEVOKTsKCgkJbGVuID0gc3Rybl9sZW4oJnVzZXJfYnVmZmVyW2ldLCBzaXplb2YodmFsc3RyKSAtIDEpOwoJCWlmIChsZW4gPCAwKSB7CgkJCXJldHVybiBsZW47CgkJfQoJCW1lbXNldCh2YWxzdHIsIDAsIHNpemVvZih2YWxzdHIpKTsKCQlpZiAoY29weV9mcm9tX3VzZXIodmFsc3RyLCAmdXNlcl9idWZmZXJbaV0sIGxlbikpCgkJCXJldHVybiAtRUZBVUxUOwoJCWkgKz0gbGVuOwoKCQlmb3IgKCptID0gMDsgKnYgJiYgbSA8IHBrdF9kZXYtPmRzdF9tYWMgKyA2OyB2KyspIHsKCQkJaWYgKCp2ID49ICcwJyAmJiAqdiA8PSAnOScpIHsKCQkJCSptICo9IDE2OwoJCQkJKm0gKz0gKnYgLSAnMCc7CgkJCX0KCQkJaWYgKCp2ID49ICdBJyAmJiAqdiA8PSAnRicpIHsKCQkJCSptICo9IDE2OwoJCQkJKm0gKz0gKnYgLSAnQScgKyAxMDsKCQkJfQoJCQlpZiAoKnYgPj0gJ2EnICYmICp2IDw9ICdmJykgewoJCQkJKm0gKj0gMTY7CgkJCQkqbSArPSAqdiAtICdhJyArIDEwOwoJCQl9CgkJCWlmICgqdiA9PSAnOicpIHsKCQkJCW0rKzsKCQkJCSptID0gMDsKCQkJfQoJCX0KCgkJLyogU2V0IHVwIERlc3QgTUFDICovCgkJaWYgKGNvbXBhcmVfZXRoZXJfYWRkcihvbGRfZG1hYywgcGt0X2Rldi0+ZHN0X21hYykpCgkJCW1lbWNweSgmKHBrdF9kZXYtPmhoWzBdKSwgcGt0X2Rldi0+ZHN0X21hYywgRVRIX0FMRU4pOwoKCQlzcHJpbnRmKHBnX3Jlc3VsdCwgIk9LOiBkc3RtYWMiKTsKCQlyZXR1cm4gY291bnQ7Cgl9CglpZiAoIXN0cmNtcChuYW1lLCAic3JjX21hYyIpKSB7CgkJY2hhciAqdiA9IHZhbHN0cjsKCQl1bnNpZ25lZCBjaGFyICptID0gcGt0X2Rldi0+c3JjX21hYzsKCgkJbGVuID0gc3Rybl9sZW4oJnVzZXJfYnVmZmVyW2ldLCBzaXplb2YodmFsc3RyKSAtIDEpOwoJCWlmIChsZW4gPCAwKSB7CgkJCXJldHVybiBsZW47CgkJfQoJCW1lbXNldCh2YWxzdHIsIDAsIHNpemVvZih2YWxzdHIpKTsKCQlpZiAoY29weV9mcm9tX3VzZXIodmFsc3RyLCAmdXNlcl9idWZmZXJbaV0sIGxlbikpCgkJCXJldHVybiAtRUZBVUxUOwoJCWkgKz0gbGVuOwoKCQlmb3IgKCptID0gMDsgKnYgJiYgbSA8IHBrdF9kZXYtPnNyY19tYWMgKyA2OyB2KyspIHsKCQkJaWYgKCp2ID49ICcwJyAmJiAqdiA8PSAnOScpIHsKCQkJCSptICo9IDE2OwoJCQkJKm0gKz0gKnYgLSAnMCc7CgkJCX0KCQkJaWYgKCp2ID49ICdBJyAmJiAqdiA8PSAnRicpIHsKCQkJCSptICo9IDE2OwoJCQkJKm0gKz0gKnYgLSAnQScgKyAxMDsKCQkJfQoJCQlpZiAoKnYgPj0gJ2EnICYmICp2IDw9ICdmJykgewoJCQkJKm0gKj0gMTY7CgkJCQkqbSArPSAqdiAtICdhJyArIDEwOwoJCQl9CgkJCWlmICgqdiA9PSAnOicpIHsKCQkJCW0rKzsKCQkJCSptID0gMDsKCQkJfQoJCX0KCgkJc3ByaW50ZihwZ19yZXN1bHQsICJPSzogc3JjbWFjIik7CgkJcmV0dXJuIGNvdW50OwoJfQoKCWlmICghc3RyY21wKG5hbWUsICJjbGVhcl9jb3VudGVycyIpKSB7CgkJcGt0Z2VuX2NsZWFyX2NvdW50ZXJzKHBrdF9kZXYpOwoJCXNwcmludGYocGdfcmVzdWx0LCAiT0s6IENsZWFyaW5nIGNvdW50ZXJzLlxuIik7CgkJcmV0dXJuIGNvdW50OwoJfQoKCWlmICghc3RyY21wKG5hbWUsICJmbG93cyIpKSB7CgkJbGVuID0gbnVtX2FyZygmdXNlcl9idWZmZXJbaV0sIDEwLCAmdmFsdWUpOwoJCWlmIChsZW4gPCAwKSB7CgkJCXJldHVybiBsZW47CgkJfQoJCWkgKz0gbGVuOwoJCWlmICh2YWx1ZSA+IE1BWF9DRkxPV1MpCgkJCXZhbHVlID0gTUFYX0NGTE9XUzsKCgkJcGt0X2Rldi0+Y2Zsb3dzID0gdmFsdWU7CgkJc3ByaW50ZihwZ19yZXN1bHQsICJPSzogZmxvd3M9JXUiLCBwa3RfZGV2LT5jZmxvd3MpOwoJCXJldHVybiBjb3VudDsKCX0KCglpZiAoIXN0cmNtcChuYW1lLCAiZmxvd2xlbiIpKSB7CgkJbGVuID0gbnVtX2FyZygmdXNlcl9idWZmZXJbaV0sIDEwLCAmdmFsdWUpOwoJCWlmIChsZW4gPCAwKSB7CgkJCXJldHVybiBsZW47CgkJfQoJCWkgKz0gbGVuOwoJCXBrdF9kZXYtPmxmbG93ID0gdmFsdWU7CgkJc3ByaW50ZihwZ19yZXN1bHQsICJPSzogZmxvd2xlbj0ldSIsIHBrdF9kZXYtPmxmbG93KTsKCQlyZXR1cm4gY291bnQ7Cgl9CgoJaWYgKCFzdHJjbXAobmFtZSwgIm1wbHMiKSkgewoJCXVuc2lnbmVkIG4sIG9mZnNldDsKCQlsZW4gPSBnZXRfbGFiZWxzKCZ1c2VyX2J1ZmZlcltpXSwgcGt0X2Rldik7CgkJaWYgKGxlbiA8IDApIHsgcmV0dXJuIGxlbjsgfQoJCWkgKz0gbGVuOwoJCW9mZnNldCA9IHNwcmludGYocGdfcmVzdWx0LCAiT0s6IG1wbHM9Iik7CgkJZm9yKG4gPSAwOyBuIDwgcGt0X2Rldi0+bnJfbGFiZWxzOyBuKyspCgkJCW9mZnNldCArPSBzcHJpbnRmKHBnX3Jlc3VsdCArIG9mZnNldCwKCQkJCQkgICIlMDh4JXMiLCBudG9obChwa3RfZGV2LT5sYWJlbHNbbl0pLAoJCQkJCSAgbiA9PSBwa3RfZGV2LT5ucl9sYWJlbHMtMSA/ICIiIDogIiwiKTsKCgkJaWYgKHBrdF9kZXYtPm5yX2xhYmVscyAmJiBwa3RfZGV2LT52bGFuX2lkICE9IDB4ZmZmZikgewoJCQlwa3RfZGV2LT52bGFuX2lkID0gMHhmZmZmOyAvKiB0dXJuIG9mZiBWTEFOL1NWTEFOICovCgkJCXBrdF9kZXYtPnN2bGFuX2lkID0gMHhmZmZmOwoKCQkJaWYgKGRlYnVnKQoJCQkJcHJpbnRrKCJwa3RnZW46IFZMQU4vU1ZMQU4gYXV0byB0dXJuZWQgb2ZmXG4iKTsKCQl9CgkJcmV0dXJuIGNvdW50OwoJfQoKCWlmICghc3RyY21wKG5hbWUsICJ2bGFuX2lkIikpIHsKCQlsZW4gPSBudW1fYXJnKCZ1c2VyX2J1ZmZlcltpXSwgNCwgJnZhbHVlKTsKCQlpZiAobGVuIDwgMCkgewoJCQlyZXR1cm4gbGVuOwoJCX0KCQlpICs9IGxlbjsKCQlpZiAodmFsdWUgPD0gNDA5NSkgewoJCQlwa3RfZGV2LT52bGFuX2lkID0gdmFsdWU7ICAvKiB0dXJuIG9uIFZMQU4gKi8KCgkJCWlmIChkZWJ1ZykKCQkJCXByaW50aygicGt0Z2VuOiBWTEFOIHR1cm5lZCBvblxuIik7CgoJCQlpZiAoZGVidWcgJiYgcGt0X2Rldi0+bnJfbGFiZWxzKQoJCQkJcHJpbnRrKCJwa3RnZW46IE1QTFMgYXV0byB0dXJuZWQgb2ZmXG4iKTsKCgkJCXBrdF9kZXYtPm5yX2xhYmVscyA9IDA7ICAgIC8qIHR1cm4gb2ZmIE1QTFMgKi8KCQkJc3ByaW50ZihwZ19yZXN1bHQsICJPSzogdmxhbl9pZD0ldSIsIHBrdF9kZXYtPnZsYW5faWQpOwoJCX0gZWxzZSB7CgkJCXBrdF9kZXYtPnZsYW5faWQgPSAweGZmZmY7IC8qIHR1cm4gb2ZmIFZMQU4vU1ZMQU4gKi8KCQkJcGt0X2Rldi0+c3ZsYW5faWQgPSAweGZmZmY7CgoJCQlpZiAoZGVidWcpCgkJCQlwcmludGsoInBrdGdlbjogVkxBTi9TVkxBTiB0dXJuZWQgb2ZmXG4iKTsKCQl9CgkJcmV0dXJuIGNvdW50OwoJfQoKCWlmICghc3RyY21wKG5hbWUsICJ2bGFuX3AiKSkgewoJCWxlbiA9IG51bV9hcmcoJnVzZXJfYnVmZmVyW2ldLCAxLCAmdmFsdWUpOwoJCWlmIChsZW4gPCAwKSB7CgkJCXJldHVybiBsZW47CgkJfQoJCWkgKz0gbGVuOwoJCWlmICgodmFsdWUgPD0gNykgJiYgKHBrdF9kZXYtPnZsYW5faWQgIT0gMHhmZmZmKSkgewoJCQlwa3RfZGV2LT52bGFuX3AgPSB2YWx1ZTsKCQkJc3ByaW50ZihwZ19yZXN1bHQsICJPSzogdmxhbl9wPSV1IiwgcGt0X2Rldi0+dmxhbl9wKTsKCQl9IGVsc2UgewoJCQlzcHJpbnRmKHBnX3Jlc3VsdCwgIkVSUk9SOiB2bGFuX3AgbXVzdCBiZSAwLTciKTsKCQl9CgkJcmV0dXJuIGNvdW50OwoJfQoKCWlmICghc3RyY21wKG5hbWUsICJ2bGFuX2NmaSIpKSB7CgkJbGVuID0gbnVtX2FyZygmdXNlcl9idWZmZXJbaV0sIDEsICZ2YWx1ZSk7CgkJaWYgKGxlbiA8IDApIHsKCQkJcmV0dXJuIGxlbjsKCQl9CgkJaSArPSBsZW47CgkJaWYgKCh2YWx1ZSA8PSAxKSAmJiAocGt0X2Rldi0+dmxhbl9pZCAhPSAweGZmZmYpKSB7CgkJCXBrdF9kZXYtPnZsYW5fY2ZpID0gdmFsdWU7CgkJCXNwcmludGYocGdfcmVzdWx0LCAiT0s6IHZsYW5fY2ZpPSV1IiwgcGt0X2Rldi0+dmxhbl9jZmkpOwoJCX0gZWxzZSB7CgkJCXNwcmludGYocGdfcmVzdWx0LCAiRVJST1I6IHZsYW5fY2ZpIG11c3QgYmUgMC0xIik7CgkJfQoJCXJldHVybiBjb3VudDsKCX0KCglpZiAoIXN0cmNtcChuYW1lLCAic3ZsYW5faWQiKSkgewoJCWxlbiA9IG51bV9hcmcoJnVzZXJfYnVmZmVyW2ldLCA0LCAmdmFsdWUpOwoJCWlmIChsZW4gPCAwKSB7CgkJCXJldHVybiBsZW47CgkJfQoJCWkgKz0gbGVuOwoJCWlmICgodmFsdWUgPD0gNDA5NSkgJiYgKChwa3RfZGV2LT52bGFuX2lkICE9IDB4ZmZmZikpKSB7CgkJCXBrdF9kZXYtPnN2bGFuX2lkID0gdmFsdWU7ICAvKiB0dXJuIG9uIFNWTEFOICovCgoJCQlpZiAoZGVidWcpCgkJCQlwcmludGsoInBrdGdlbjogU1ZMQU4gdHVybmVkIG9uXG4iKTsKCgkJCWlmIChkZWJ1ZyAmJiBwa3RfZGV2LT5ucl9sYWJlbHMpCgkJCQlwcmludGsoInBrdGdlbjogTVBMUyBhdXRvIHR1cm5lZCBvZmZcbiIpOwoKCQkJcGt0X2Rldi0+bnJfbGFiZWxzID0gMDsgICAgLyogdHVybiBvZmYgTVBMUyAqLwoJCQlzcHJpbnRmKHBnX3Jlc3VsdCwgIk9LOiBzdmxhbl9pZD0ldSIsIHBrdF9kZXYtPnN2bGFuX2lkKTsKCQl9IGVsc2UgewoJCQlwa3RfZGV2LT52bGFuX2lkID0gMHhmZmZmOyAvKiB0dXJuIG9mZiBWTEFOL1NWTEFOICovCgkJCXBrdF9kZXYtPnN2bGFuX2lkID0gMHhmZmZmOwoKCQkJaWYgKGRlYnVnKQoJCQkJcHJpbnRrKCJwa3RnZW46IFZMQU4vU1ZMQU4gdHVybmVkIG9mZlxuIik7CgkJfQoJCXJldHVybiBjb3VudDsKCX0KCglpZiAoIXN0cmNtcChuYW1lLCAic3ZsYW5fcCIpKSB7CgkJbGVuID0gbnVtX2FyZygmdXNlcl9idWZmZXJbaV0sIDEsICZ2YWx1ZSk7CgkJaWYgKGxlbiA8IDApIHsKCQkJcmV0dXJuIGxlbjsKCQl9CgkJaSArPSBsZW47CgkJaWYgKCh2YWx1ZSA8PSA3KSAmJiAocGt0X2Rldi0+c3ZsYW5faWQgIT0gMHhmZmZmKSkgewoJCQlwa3RfZGV2LT5zdmxhbl9wID0gdmFsdWU7CgkJCXNwcmludGYocGdfcmVzdWx0LCAiT0s6IHN2bGFuX3A9JXUiLCBwa3RfZGV2LT5zdmxhbl9wKTsKCQl9IGVsc2UgewoJCQlzcHJpbnRmKHBnX3Jlc3VsdCwgIkVSUk9SOiBzdmxhbl9wIG11c3QgYmUgMC03Iik7CgkJfQoJCXJldHVybiBjb3VudDsKCX0KCglpZiAoIXN0cmNtcChuYW1lLCAic3ZsYW5fY2ZpIikpIHsKCQlsZW4gPSBudW1fYXJnKCZ1c2VyX2J1ZmZlcltpXSwgMSwgJnZhbHVlKTsKCQlpZiAobGVuIDwgMCkgewoJCQlyZXR1cm4gbGVuOwoJCX0KCQlpICs9IGxlbjsKCQlpZiAoKHZhbHVlIDw9IDEpICYmIChwa3RfZGV2LT5zdmxhbl9pZCAhPSAweGZmZmYpKSB7CgkJCXBrdF9kZXYtPnN2bGFuX2NmaSA9IHZhbHVlOwoJCQlzcHJpbnRmKHBnX3Jlc3VsdCwgIk9LOiBzdmxhbl9jZmk9JXUiLCBwa3RfZGV2LT5zdmxhbl9jZmkpOwoJCX0gZWxzZSB7CgkJCXNwcmludGYocGdfcmVzdWx0LCAiRVJST1I6IHN2bGFuX2NmaSBtdXN0IGJlIDAtMSIpOwoJCX0KCQlyZXR1cm4gY291bnQ7Cgl9CgoJaWYgKCFzdHJjbXAobmFtZSwgInRvcyIpKSB7CgkJX191MzIgdG1wX3ZhbHVlID0gMDsKCQlsZW4gPSBoZXgzMl9hcmcoJnVzZXJfYnVmZmVyW2ldLCAyLCAmdG1wX3ZhbHVlKTsKCQlpZiAobGVuIDwgMCkgewoJCQlyZXR1cm4gbGVuOwoJCX0KCQlpICs9IGxlbjsKCQlpZiAobGVuID09IDIpIHsKCQkJcGt0X2Rldi0+dG9zID0gdG1wX3ZhbHVlOwoJCQlzcHJpbnRmKHBnX3Jlc3VsdCwgIk9LOiB0b3M9MHglMDJ4IiwgcGt0X2Rldi0+dG9zKTsKCQl9IGVsc2UgewoJCQlzcHJpbnRmKHBnX3Jlc3VsdCwgIkVSUk9SOiB0b3MgbXVzdCBiZSAwMC1mZiIpOwoJCX0KCQlyZXR1cm4gY291bnQ7Cgl9CgoJaWYgKCFzdHJjbXAobmFtZSwgInRyYWZmaWNfY2xhc3MiKSkgewoJCV9fdTMyIHRtcF92YWx1ZSA9IDA7CgkJbGVuID0gaGV4MzJfYXJnKCZ1c2VyX2J1ZmZlcltpXSwgMiwgJnRtcF92YWx1ZSk7CgkJaWYgKGxlbiA8IDApIHsKCQkJcmV0dXJuIGxlbjsKCQl9CgkJaSArPSBsZW47CgkJaWYgKGxlbiA9PSAyKSB7CgkJCXBrdF9kZXYtPnRyYWZmaWNfY2xhc3MgPSB0bXBfdmFsdWU7CgkJCXNwcmludGYocGdfcmVzdWx0LCAiT0s6IHRyYWZmaWNfY2xhc3M9MHglMDJ4IiwgcGt0X2Rldi0+dHJhZmZpY19jbGFzcyk7CgkJfSBlbHNlIHsKCQkJc3ByaW50ZihwZ19yZXN1bHQsICJFUlJPUjogdHJhZmZpY19jbGFzcyBtdXN0IGJlIDAwLWZmIik7CgkJfQoJCXJldHVybiBjb3VudDsKCX0KCglzcHJpbnRmKHBrdF9kZXYtPnJlc3VsdCwgIk5vIHN1Y2ggcGFyYW1ldGVyIFwiJXNcIiIsIG5hbWUpOwoJcmV0dXJuIC1FSU5WQUw7Cn0KCnN0YXRpYyBpbnQgcGt0Z2VuX2lmX29wZW4oc3RydWN0IGlub2RlICppbm9kZSwgc3RydWN0IGZpbGUgKmZpbGUpCnsKCXJldHVybiBzaW5nbGVfb3BlbihmaWxlLCBwa3RnZW5faWZfc2hvdywgUERFKGlub2RlKS0+ZGF0YSk7Cn0KCnN0YXRpYyBzdHJ1Y3QgZmlsZV9vcGVyYXRpb25zIHBrdGdlbl9pZl9mb3BzID0gewoJLm93bmVyICAgPSBUSElTX01PRFVMRSwKCS5vcGVuICAgID0gcGt0Z2VuX2lmX29wZW4sCgkucmVhZCAgICA9IHNlcV9yZWFkLAoJLmxsc2VlayAgPSBzZXFfbHNlZWssCgkud3JpdGUgICA9IHBrdGdlbl9pZl93cml0ZSwKCS5yZWxlYXNlID0gc2luZ2xlX3JlbGVhc2UsCn07CgpzdGF0aWMgaW50IHBrdGdlbl90aHJlYWRfc2hvdyhzdHJ1Y3Qgc2VxX2ZpbGUgKnNlcSwgdm9pZCAqdikKewoJc3RydWN0IHBrdGdlbl90aHJlYWQgKnQgPSBzZXEtPnByaXZhdGU7CglzdHJ1Y3QgcGt0Z2VuX2RldiAqcGt0X2RldjsKCglCVUdfT04oIXQpOwoKCXNlcV9wcmludGYoc2VxLCAiTmFtZTogJXMgIG1heF9iZWZvcmVfc29mdGlycTogJWRcbiIsCgkJICAgdC0+bmFtZSwgdC0+bWF4X2JlZm9yZV9zb2Z0aXJxKTsKCglzZXFfcHJpbnRmKHNlcSwgIlJ1bm5pbmc6ICIpOwoKCWlmX2xvY2sodCk7CglsaXN0X2Zvcl9lYWNoX2VudHJ5KHBrdF9kZXYsICZ0LT5pZl9saXN0LCBsaXN0KQoJCWlmIChwa3RfZGV2LT5ydW5uaW5nKQoJCQlzZXFfcHJpbnRmKHNlcSwgIiVzICIsIHBrdF9kZXYtPmlmbmFtZSk7CgoJc2VxX3ByaW50ZihzZXEsICJcblN0b3BwZWQ6ICIpOwoKCWxpc3RfZm9yX2VhY2hfZW50cnkocGt0X2RldiwgJnQtPmlmX2xpc3QsIGxpc3QpCgkJaWYgKCFwa3RfZGV2LT5ydW5uaW5nKQoJCQlzZXFfcHJpbnRmKHNlcSwgIiVzICIsIHBrdF9kZXYtPmlmbmFtZSk7CgoJaWYgKHQtPnJlc3VsdFswXSkKCQlzZXFfcHJpbnRmKHNlcSwgIlxuUmVzdWx0OiAlc1xuIiwgdC0+cmVzdWx0KTsKCWVsc2UKCQlzZXFfcHJpbnRmKHNlcSwgIlxuUmVzdWx0OiBOQVxuIik7CgoJaWZfdW5sb2NrKHQpOwoKCXJldHVybiAwOwp9CgpzdGF0aWMgc3NpemVfdCBwa3RnZW5fdGhyZWFkX3dyaXRlKHN0cnVjdCBmaWxlICpmaWxlLAoJCQkJICAgY29uc3QgY2hhciBfX3VzZXIgKiB1c2VyX2J1ZmZlciwKCQkJCSAgIHNpemVfdCBjb3VudCwgbG9mZl90ICogb2Zmc2V0KQp7CglzdHJ1Y3Qgc2VxX2ZpbGUgKnNlcSA9IChzdHJ1Y3Qgc2VxX2ZpbGUgKilmaWxlLT5wcml2YXRlX2RhdGE7CglzdHJ1Y3QgcGt0Z2VuX3RocmVhZCAqdCA9IHNlcS0+cHJpdmF0ZTsKCWludCBpID0gMCwgbWF4LCBsZW4sIHJldDsKCWNoYXIgbmFtZVs0MF07CgljaGFyICpwZ19yZXN1bHQ7Cgl1bnNpZ25lZCBsb25nIHZhbHVlID0gMDsKCglpZiAoY291bnQgPCAxKSB7CgkJLy8gICAgICBzcHJpbnRmKHBnX3Jlc3VsdCwgIldyb25nIGNvbW1hbmQgZm9ybWF0Iik7CgkJcmV0dXJuIC1FSU5WQUw7Cgl9CgoJbWF4ID0gY291bnQgLSBpOwoJbGVuID0gY291bnRfdHJhaWxfY2hhcnMoJnVzZXJfYnVmZmVyW2ldLCBtYXgpOwoJaWYgKGxlbiA8IDApCgkJcmV0dXJuIGxlbjsKCglpICs9IGxlbjsKCgkvKiBSZWFkIHZhcmlhYmxlIG5hbWUgKi8KCglsZW4gPSBzdHJuX2xlbigmdXNlcl9idWZmZXJbaV0sIHNpemVvZihuYW1lKSAtIDEpOwoJaWYgKGxlbiA8IDApCgkJcmV0dXJuIGxlbjsKCgltZW1zZXQobmFtZSwgMCwgc2l6ZW9mKG5hbWUpKTsKCWlmIChjb3B5X2Zyb21fdXNlcihuYW1lLCAmdXNlcl9idWZmZXJbaV0sIGxlbikpCgkJcmV0dXJuIC1FRkFVTFQ7CglpICs9IGxlbjsKCgltYXggPSBjb3VudCAtIGk7CglsZW4gPSBjb3VudF90cmFpbF9jaGFycygmdXNlcl9idWZmZXJbaV0sIG1heCk7CglpZiAobGVuIDwgMCkKCQlyZXR1cm4gbGVuOwoKCWkgKz0gbGVuOwoKCWlmIChkZWJ1ZykKCQlwcmludGsoInBrdGdlbjogdD0lcywgY291bnQ9JWx1XG4iLCBuYW1lLCAodW5zaWduZWQgbG9uZyljb3VudCk7CgoJaWYgKCF0KSB7CgkJcHJpbnRrKCJwa3RnZW46IEVSUk9SOiBObyB0aHJlYWRcbiIpOwoJCXJldCA9IC1FSU5WQUw7CgkJZ290byBvdXQ7Cgl9CgoJcGdfcmVzdWx0ID0gJih0LT5yZXN1bHRbMF0pOwoKCWlmICghc3RyY21wKG5hbWUsICJhZGRfZGV2aWNlIikpIHsKCQljaGFyIGZbMzJdOwoJCW1lbXNldChmLCAwLCAzMik7CgkJbGVuID0gc3Rybl9sZW4oJnVzZXJfYnVmZmVyW2ldLCBzaXplb2YoZikgLSAxKTsKCQlpZiAobGVuIDwgMCkgewoJCQlyZXQgPSBsZW47CgkJCWdvdG8gb3V0OwoJCX0KCQlpZiAoY29weV9mcm9tX3VzZXIoZiwgJnVzZXJfYnVmZmVyW2ldLCBsZW4pKQoJCQlyZXR1cm4gLUVGQVVMVDsKCQlpICs9IGxlbjsKCQltdXRleF9sb2NrKCZwa3RnZW5fdGhyZWFkX2xvY2spOwoJCXBrdGdlbl9hZGRfZGV2aWNlKHQsIGYpOwoJCW11dGV4X3VubG9jaygmcGt0Z2VuX3RocmVhZF9sb2NrKTsKCQlyZXQgPSBjb3VudDsKCQlzcHJpbnRmKHBnX3Jlc3VsdCwgIk9LOiBhZGRfZGV2aWNlPSVzIiwgZik7CgkJZ290byBvdXQ7Cgl9CgoJaWYgKCFzdHJjbXAobmFtZSwgInJlbV9kZXZpY2VfYWxsIikpIHsKCQltdXRleF9sb2NrKCZwa3RnZW5fdGhyZWFkX2xvY2spOwoJCXQtPmNvbnRyb2wgfD0gVF9SRU1ERVZBTEw7CgkJbXV0ZXhfdW5sb2NrKCZwa3RnZW5fdGhyZWFkX2xvY2spOwoJCXNjaGVkdWxlX3RpbWVvdXRfaW50ZXJydXB0aWJsZShtc2Vjc190b19qaWZmaWVzKDEyNSkpOwkvKiBQcm9wYWdhdGUgdGhyZWFkLT5jb250cm9sICAqLwoJCXJldCA9IGNvdW50OwoJCXNwcmludGYocGdfcmVzdWx0LCAiT0s6IHJlbV9kZXZpY2VfYWxsIik7CgkJZ290byBvdXQ7Cgl9CgoJaWYgKCFzdHJjbXAobmFtZSwgIm1heF9iZWZvcmVfc29mdGlycSIpKSB7CgkJbGVuID0gbnVtX2FyZygmdXNlcl9idWZmZXJbaV0sIDEwLCAmdmFsdWUpOwoJCW11dGV4X2xvY2soJnBrdGdlbl90aHJlYWRfbG9jayk7CgkJdC0+bWF4X2JlZm9yZV9zb2Z0aXJxID0gdmFsdWU7CgkJbXV0ZXhfdW5sb2NrKCZwa3RnZW5fdGhyZWFkX2xvY2spOwoJCXJldCA9IGNvdW50OwoJCXNwcmludGYocGdfcmVzdWx0LCAiT0s6IG1heF9iZWZvcmVfc29mdGlycT0lbHUiLCB2YWx1ZSk7CgkJZ290byBvdXQ7Cgl9CgoJcmV0ID0gLUVJTlZBTDsKb3V0OgoJcmV0dXJuIHJldDsKfQoKc3RhdGljIGludCBwa3RnZW5fdGhyZWFkX29wZW4oc3RydWN0IGlub2RlICppbm9kZSwgc3RydWN0IGZpbGUgKmZpbGUpCnsKCXJldHVybiBzaW5nbGVfb3BlbihmaWxlLCBwa3RnZW5fdGhyZWFkX3Nob3csIFBERShpbm9kZSktPmRhdGEpOwp9CgpzdGF0aWMgc3RydWN0IGZpbGVfb3BlcmF0aW9ucyBwa3RnZW5fdGhyZWFkX2ZvcHMgPSB7Cgkub3duZXIgICA9IFRISVNfTU9EVUxFLAoJLm9wZW4gICAgPSBwa3RnZW5fdGhyZWFkX29wZW4sCgkucmVhZCAgICA9IHNlcV9yZWFkLAoJLmxsc2VlayAgPSBzZXFfbHNlZWssCgkud3JpdGUgICA9IHBrdGdlbl90aHJlYWRfd3JpdGUsCgkucmVsZWFzZSA9IHNpbmdsZV9yZWxlYXNlLAp9OwoKLyogVGhpbmsgZmluZCBvciByZW1vdmUgZm9yIE5OICovCnN0YXRpYyBzdHJ1Y3QgcGt0Z2VuX2RldiAqX19wa3RnZW5fTk5fdGhyZWFkcyhjb25zdCBjaGFyICppZm5hbWUsIGludCByZW1vdmUpCnsKCXN0cnVjdCBwa3RnZW5fdGhyZWFkICp0OwoJc3RydWN0IHBrdGdlbl9kZXYgKnBrdF9kZXYgPSBOVUxMOwoKCWxpc3RfZm9yX2VhY2hfZW50cnkodCwgJnBrdGdlbl90aHJlYWRzLCB0aF9saXN0KSB7CgkJcGt0X2RldiA9IHBrdGdlbl9maW5kX2Rldih0LCBpZm5hbWUpOwoJCWlmIChwa3RfZGV2KSB7CgkJCWlmIChyZW1vdmUpIHsKCQkJCWlmX2xvY2sodCk7CgkJCQlwa3RfZGV2LT5yZW1vdmFsX21hcmsgPSAxOwoJCQkJdC0+Y29udHJvbCB8PSBUX1JFTURFVjsKCQkJCWlmX3VubG9jayh0KTsKCQkJfQoJCQlicmVhazsKCQl9Cgl9CglyZXR1cm4gcGt0X2RldjsKfQoKLyoKICogbWFyayBhIGRldmljZSBmb3IgcmVtb3ZhbAogKi8Kc3RhdGljIGludCBwa3RnZW5fbWFya19kZXZpY2UoY29uc3QgY2hhciAqaWZuYW1lKQp7CglzdHJ1Y3QgcGt0Z2VuX2RldiAqcGt0X2RldiA9IE5VTEw7Cgljb25zdCBpbnQgbWF4X3RyaWVzID0gMTAsIG1zZWNfcGVyX3RyeSA9IDEyNTsKCWludCBpID0gMDsKCWludCByZXQgPSAwOwoKCW11dGV4X2xvY2soJnBrdGdlbl90aHJlYWRfbG9jayk7CglQR19ERUJVRyhwcmludGsoInBrdGdlbjogcGt0Z2VuX21hcmtfZGV2aWNlIG1hcmtpbmcgJXMgZm9yIHJlbW92YWxcbiIsCgkJCWlmbmFtZSkpOwoKCXdoaWxlICgxKSB7CgoJCXBrdF9kZXYgPSBfX3BrdGdlbl9OTl90aHJlYWRzKGlmbmFtZSwgUkVNT1ZFKTsKCQlpZiAocGt0X2RldiA9PSBOVUxMKQoJCQlicmVhazsJLyogc3VjY2VzcyAqLwoKCQltdXRleF91bmxvY2soJnBrdGdlbl90aHJlYWRfbG9jayk7CgkJUEdfREVCVUcocHJpbnRrKCJwa3RnZW46IHBrdGdlbl9tYXJrX2RldmljZSB3YWl0aW5nIGZvciAlcyAiCgkJCQkidG8gZGlzYXBwZWFyLi4uLlxuIiwgaWZuYW1lKSk7CgkJc2NoZWR1bGVfdGltZW91dF9pbnRlcnJ1cHRpYmxlKG1zZWNzX3RvX2ppZmZpZXMobXNlY19wZXJfdHJ5KSk7CgkJbXV0ZXhfbG9jaygmcGt0Z2VuX3RocmVhZF9sb2NrKTsKCgkJaWYgKCsraSA+PSBtYXhfdHJpZXMpIHsKCQkJcHJpbnRrKCJwa3RnZW5fbWFya19kZXZpY2U6IHRpbWVkIG91dCBhZnRlciB3YWl0aW5nICIKCQkJICAgICAgICIlZCBtc2VjIGZvciBkZXZpY2UgJXMgdG8gYmUgcmVtb3ZlZFxuIiwKCQkJICAgICAgIG1zZWNfcGVyX3RyeSAqIGksIGlmbmFtZSk7CgkJCXJldCA9IDE7CgkJCWJyZWFrOwoJCX0KCgl9CgoJbXV0ZXhfdW5sb2NrKCZwa3RnZW5fdGhyZWFkX2xvY2spOwoKCXJldHVybiByZXQ7Cn0KCnN0YXRpYyBpbnQgcGt0Z2VuX2RldmljZV9ldmVudChzdHJ1Y3Qgbm90aWZpZXJfYmxvY2sgKnVudXNlZCwKCQkJICAgICAgIHVuc2lnbmVkIGxvbmcgZXZlbnQsIHZvaWQgKnB0cikKewoJc3RydWN0IG5ldF9kZXZpY2UgKmRldiA9IChzdHJ1Y3QgbmV0X2RldmljZSAqKShwdHIpOwoKCS8qIEl0IGlzIE9LIHRoYXQgd2UgZG8gbm90IGhvbGQgdGhlIGdyb3VwIGxvY2sgcmlnaHQgbm93LAoJICogYXMgd2UgcnVuIHVuZGVyIHRoZSBSVE5MIGxvY2suCgkgKi8KCglzd2l0Y2ggKGV2ZW50KSB7CgljYXNlIE5FVERFVl9DSEFOR0VBRERSOgoJY2FzZSBORVRERVZfR09JTkdfRE9XTjoKCWNhc2UgTkVUREVWX0RPV046CgljYXNlIE5FVERFVl9VUDoKCQkvKiBJZ25vcmUgZm9yIG5vdyAqLwoJCWJyZWFrOwoKCWNhc2UgTkVUREVWX1VOUkVHSVNURVI6CgkJcGt0Z2VuX21hcmtfZGV2aWNlKGRldi0+bmFtZSk7CgkJYnJlYWs7Cgl9OwoKCXJldHVybiBOT1RJRllfRE9ORTsKfQoKLyogQXNzb2NpYXRlIHBrdGdlbl9kZXYgd2l0aCBhIGRldmljZS4gKi8KCnN0YXRpYyBzdHJ1Y3QgbmV0X2RldmljZSAqcGt0Z2VuX3NldHVwX2RldihzdHJ1Y3QgcGt0Z2VuX2RldiAqcGt0X2RldikKewoJc3RydWN0IG5ldF9kZXZpY2UgKm9kZXY7CgoJLyogQ2xlYW4gb2xkIHNldHVwcyAqLwoKCWlmIChwa3RfZGV2LT5vZGV2KSB7CgkJZGV2X3B1dChwa3RfZGV2LT5vZGV2KTsKCQlwa3RfZGV2LT5vZGV2ID0gTlVMTDsKCX0KCglvZGV2ID0gZGV2X2dldF9ieV9uYW1lKHBrdF9kZXYtPmlmbmFtZSk7CgoJaWYgKCFvZGV2KSB7CgkJcHJpbnRrKCJwa3RnZW46IG5vIHN1Y2ggbmV0ZGV2aWNlOiBcIiVzXCJcbiIsIHBrdF9kZXYtPmlmbmFtZSk7CgkJZ290byBvdXQ7Cgl9CglpZiAob2Rldi0+dHlwZSAhPSBBUlBIUkRfRVRIRVIpIHsKCQlwcmludGsoInBrdGdlbjogbm90IGFuIGV0aGVybmV0IGRldmljZTogXCIlc1wiXG4iLAoJCSAgICAgICBwa3RfZGV2LT5pZm5hbWUpOwoJCWdvdG8gb3V0X3B1dDsKCX0KCWlmICghbmV0aWZfcnVubmluZyhvZGV2KSkgewoJCXByaW50aygicGt0Z2VuOiBkZXZpY2UgaXMgZG93bjogXCIlc1wiXG4iLCBwa3RfZGV2LT5pZm5hbWUpOwoJCWdvdG8gb3V0X3B1dDsKCX0KCXBrdF9kZXYtPm9kZXYgPSBvZGV2OwoKCXJldHVybiBwa3RfZGV2LT5vZGV2OwoKb3V0X3B1dDoKCWRldl9wdXQob2Rldik7Cm91dDoKCXJldHVybiBOVUxMOwoKfQoKLyogUmVhZCBwa3RfZGV2IGZyb20gdGhlIGludGVyZmFjZSBhbmQgc2V0IHVwIGludGVybmFsIHBrdGdlbl9kZXYKICogc3RydWN0dXJlIHRvIGhhdmUgdGhlIHJpZ2h0IGluZm9ybWF0aW9uIHRvIGNyZWF0ZS9zZW5kIHBhY2tldHMKICovCnN0YXRpYyB2b2lkIHBrdGdlbl9zZXR1cF9pbmplY3Qoc3RydWN0IHBrdGdlbl9kZXYgKnBrdF9kZXYpCnsKCS8qIFRyeSBvbmNlIG1vcmUsIGp1c3QgaW4gY2FzZSBpdCB3b3JrcyBub3cuICovCglpZiAoIXBrdF9kZXYtPm9kZXYpCgkJcGt0Z2VuX3NldHVwX2Rldihwa3RfZGV2KTsKCglpZiAoIXBrdF9kZXYtPm9kZXYpIHsKCQlwcmludGsoInBrdGdlbjogRVJST1I6IHBrdF9kZXYtPm9kZXYgPT0gTlVMTCBpbiBzZXR1cF9pbmplY3QuXG4iKTsKCQlzcHJpbnRmKHBrdF9kZXYtPnJlc3VsdCwKCQkJIkVSUk9SOiBwa3RfZGV2LT5vZGV2ID09IE5VTEwgaW4gc2V0dXBfaW5qZWN0LlxuIik7CgkJcmV0dXJuOwoJfQoKCS8qIERlZmF1bHQgdG8gdGhlIGludGVyZmFjZSdzIG1hYyBpZiBub3QgZXhwbGljaXRseSBzZXQuICovCgoJaWYgKGlzX3plcm9fZXRoZXJfYWRkcihwa3RfZGV2LT5zcmNfbWFjKSkKCQltZW1jcHkoJihwa3RfZGV2LT5oaFs2XSksIHBrdF9kZXYtPm9kZXYtPmRldl9hZGRyLCBFVEhfQUxFTik7CgoJLyogU2V0IHVwIERlc3QgTUFDICovCgltZW1jcHkoJihwa3RfZGV2LT5oaFswXSksIHBrdF9kZXYtPmRzdF9tYWMsIEVUSF9BTEVOKTsKCgkvKiBTZXQgdXAgcGt0IHNpemUgKi8KCXBrdF9kZXYtPmN1cl9wa3Rfc2l6ZSA9IHBrdF9kZXYtPm1pbl9wa3Rfc2l6ZTsKCglpZiAocGt0X2Rldi0+ZmxhZ3MgJiBGX0lQVjYpIHsKCQkvKgoJCSAqIFNraXAgdGhpcyBhdXRvbWF0aWMgYWRkcmVzcyBzZXR0aW5nIHVudGlsIGxvY2tzIG9yIGZ1bmN0aW9ucyAKCQkgKiBnZXRzIGV4cG9ydGVkCgkJICovCgojaWZkZWYgTk9UTk9XCgkJaW50IGksIHNldCA9IDAsIGVyciA9IDE7CgkJc3RydWN0IGluZXQ2X2RldiAqaWRldjsKCgkJZm9yIChpID0gMDsgaSA8IElONl9BRERSX0hTSVpFOyBpKyspCgkJCWlmIChwa3RfZGV2LT5jdXJfaW42X3NhZGRyLnM2X2FkZHJbaV0pIHsKCQkJCXNldCA9IDE7CgkJCQlicmVhazsKCQkJfQoKCQlpZiAoIXNldCkgewoKCQkJLyoKCQkJICogVXNlIGxpbmtsZXZlbCBhZGRyZXNzIGlmIHVuY29uZmlndXJlZC4KCQkJICoKCQkJICogdXNlIGlwdjZfZ2V0X2xsYWRkciBpZi93aGVuIGl0J3MgZ2V0IGV4cG9ydGVkCgkJCSAqLwoKCQkJcmN1X3JlYWRfbG9jaygpOwoJCQlpZiAoKGlkZXYgPSBfX2luNl9kZXZfZ2V0KHBrdF9kZXYtPm9kZXYpKSAhPSBOVUxMKSB7CgkJCQlzdHJ1Y3QgaW5ldDZfaWZhZGRyICppZnA7CgoJCQkJcmVhZF9sb2NrX2JoKCZpZGV2LT5sb2NrKTsKCQkJCWZvciAoaWZwID0gaWRldi0+YWRkcl9saXN0OyBpZnA7CgkJCQkgICAgIGlmcCA9IGlmcC0+aWZfbmV4dCkgewoJCQkJCWlmIChpZnAtPnNjb3BlID09IElGQV9MSU5LCgkJCQkJICAgICYmICEoaWZwLT4KCQkJCQkJIGZsYWdzICYgSUZBX0ZfVEVOVEFUSVZFKSkgewoJCQkJCQlpcHY2X2FkZHJfY29weSgmcGt0X2Rldi0+CgkJCQkJCQkgICAgICAgY3VyX2luNl9zYWRkciwKCQkJCQkJCSAgICAgICAmaWZwLT5hZGRyKTsKCQkJCQkJZXJyID0gMDsKCQkJCQkJYnJlYWs7CgkJCQkJfQoJCQkJfQoJCQkJcmVhZF91bmxvY2tfYmgoJmlkZXYtPmxvY2spOwoJCQl9CgkJCXJjdV9yZWFkX3VubG9jaygpOwoJCQlpZiAoZXJyKQoJCQkJcHJpbnRrKCJwa3RnZW46IEVSUk9SOiBJUHY2IGxpbmsgYWRkcmVzcyBub3QgYXZhaWxibGUuXG4iKTsKCQl9CiNlbmRpZgoJfSBlbHNlIHsKCQlwa3RfZGV2LT5zYWRkcl9taW4gPSAwOwoJCXBrdF9kZXYtPnNhZGRyX21heCA9IDA7CgkJaWYgKHN0cmxlbihwa3RfZGV2LT5zcmNfbWluKSA9PSAwKSB7CgoJCQlzdHJ1Y3QgaW5fZGV2aWNlICppbl9kZXY7CgoJCQlyY3VfcmVhZF9sb2NrKCk7CgkJCWluX2RldiA9IF9faW5fZGV2X2dldF9yY3UocGt0X2Rldi0+b2Rldik7CgkJCWlmIChpbl9kZXYpIHsKCQkJCWlmIChpbl9kZXYtPmlmYV9saXN0KSB7CgkJCQkJcGt0X2Rldi0+c2FkZHJfbWluID0KCQkJCQkgICAgaW5fZGV2LT5pZmFfbGlzdC0+aWZhX2FkZHJlc3M7CgkJCQkJcGt0X2Rldi0+c2FkZHJfbWF4ID0gcGt0X2Rldi0+c2FkZHJfbWluOwoJCQkJfQoJCQl9CgkJCXJjdV9yZWFkX3VubG9jaygpOwoJCX0gZWxzZSB7CgkJCXBrdF9kZXYtPnNhZGRyX21pbiA9IGluX2F0b24ocGt0X2Rldi0+c3JjX21pbik7CgkJCXBrdF9kZXYtPnNhZGRyX21heCA9IGluX2F0b24ocGt0X2Rldi0+c3JjX21heCk7CgkJfQoKCQlwa3RfZGV2LT5kYWRkcl9taW4gPSBpbl9hdG9uKHBrdF9kZXYtPmRzdF9taW4pOwoJCXBrdF9kZXYtPmRhZGRyX21heCA9IGluX2F0b24ocGt0X2Rldi0+ZHN0X21heCk7Cgl9CgkvKiBJbml0aWFsaXplIGN1cnJlbnQgdmFsdWVzLiAqLwoJcGt0X2Rldi0+Y3VyX2RzdF9tYWNfb2Zmc2V0ID0gMDsKCXBrdF9kZXYtPmN1cl9zcmNfbWFjX29mZnNldCA9IDA7Cglwa3RfZGV2LT5jdXJfc2FkZHIgPSBwa3RfZGV2LT5zYWRkcl9taW47Cglwa3RfZGV2LT5jdXJfZGFkZHIgPSBwa3RfZGV2LT5kYWRkcl9taW47Cglwa3RfZGV2LT5jdXJfdWRwX2RzdCA9IHBrdF9kZXYtPnVkcF9kc3RfbWluOwoJcGt0X2Rldi0+Y3VyX3VkcF9zcmMgPSBwa3RfZGV2LT51ZHBfc3JjX21pbjsKCXBrdF9kZXYtPm5mbG93cyA9IDA7Cn0KCnN0YXRpYyB2b2lkIHNwaW4oc3RydWN0IHBrdGdlbl9kZXYgKnBrdF9kZXYsIF9fdTY0IHNwaW5fdW50aWxfdXMpCnsKCV9fdTY0IHN0YXJ0OwoJX191NjQgbm93OwoKCXN0YXJ0ID0gbm93ID0gZ2V0Q3VyVXMoKTsKCXByaW50ayhLRVJOX0lORk8gInNsZWVwaW5nIGZvciAlZFxuIiwgKGludCkoc3Bpbl91bnRpbF91cyAtIG5vdykpOwoJd2hpbGUgKG5vdyA8IHNwaW5fdW50aWxfdXMpIHsKCQkvKiBUT0RPOiBvcHRpbWl6ZSBzbGVlcGluZyBiZWhhdmlvciAqLwoJCWlmIChzcGluX3VudGlsX3VzIC0gbm93ID4gamlmZmllc190b191c2VjcygxKSArIDEpCgkJCXNjaGVkdWxlX3RpbWVvdXRfaW50ZXJydXB0aWJsZSgxKTsKCQllbHNlIGlmIChzcGluX3VudGlsX3VzIC0gbm93ID4gMTAwKSB7CgkJCWRvX3NvZnRpcnEoKTsKCQkJaWYgKCFwa3RfZGV2LT5ydW5uaW5nKQoJCQkJcmV0dXJuOwoJCQlpZiAobmVlZF9yZXNjaGVkKCkpCgkJCQlzY2hlZHVsZSgpOwoJCX0KCgkJbm93ID0gZ2V0Q3VyVXMoKTsKCX0KCglwa3RfZGV2LT5pZGxlX2FjYyArPSBub3cgLSBzdGFydDsKfQoKLyogSW5jcmVtZW50L3JhbmRvbWl6ZSBoZWFkZXJzIGFjY29yZGluZyB0byBmbGFncyBhbmQgY3VycmVudCB2YWx1ZXMKICogZm9yIElQIHNyYy9kZXN0LCBVRFAgc3JjL2RzdCBwb3J0LCBNQUMtQWRkciBzcmMvZHN0CiAqLwpzdGF0aWMgdm9pZCBtb2RfY3VyX2hlYWRlcnMoc3RydWN0IHBrdGdlbl9kZXYgKnBrdF9kZXYpCnsKCV9fdTMyIGltbjsKCV9fdTMyIGlteDsKCWludCBmbG93ID0gMDsKCglpZiAocGt0X2Rldi0+Y2Zsb3dzKSB7CgkJZmxvdyA9IHBrdGdlbl9yYW5kb20oKSAlIHBrdF9kZXYtPmNmbG93czsKCgkJaWYgKHBrdF9kZXYtPmZsb3dzW2Zsb3ddLmNvdW50ID4gcGt0X2Rldi0+bGZsb3cpCgkJCXBrdF9kZXYtPmZsb3dzW2Zsb3ddLmNvdW50ID0gMDsKCX0KCgkvKiAgRGVhbCB3aXRoIHNvdXJjZSBNQUMgKi8KCWlmIChwa3RfZGV2LT5zcmNfbWFjX2NvdW50ID4gMSkgewoJCV9fdTMyIG1jOwoJCV9fdTMyIHRtcDsKCgkJaWYgKHBrdF9kZXYtPmZsYWdzICYgRl9NQUNTUkNfUk5EKQoJCQltYyA9IHBrdGdlbl9yYW5kb20oKSAlIChwa3RfZGV2LT5zcmNfbWFjX2NvdW50KTsKCQllbHNlIHsKCQkJbWMgPSBwa3RfZGV2LT5jdXJfc3JjX21hY19vZmZzZXQrKzsKCQkJaWYgKHBrdF9kZXYtPmN1cl9zcmNfbWFjX29mZnNldCA+CgkJCSAgICBwa3RfZGV2LT5zcmNfbWFjX2NvdW50KQoJCQkJcGt0X2Rldi0+Y3VyX3NyY19tYWNfb2Zmc2V0ID0gMDsKCQl9CgoJCXRtcCA9IHBrdF9kZXYtPnNyY19tYWNbNV0gKyAobWMgJiAweEZGKTsKCQlwa3RfZGV2LT5oaFsxMV0gPSB0bXA7CgkJdG1wID0gKHBrdF9kZXYtPnNyY19tYWNbNF0gKyAoKG1jID4+IDgpICYgMHhGRikgKyAodG1wID4+IDgpKTsKCQlwa3RfZGV2LT5oaFsxMF0gPSB0bXA7CgkJdG1wID0gKHBrdF9kZXYtPnNyY19tYWNbM10gKyAoKG1jID4+IDE2KSAmIDB4RkYpICsgKHRtcCA+PiA4KSk7CgkJcGt0X2Rldi0+aGhbOV0gPSB0bXA7CgkJdG1wID0gKHBrdF9kZXYtPnNyY19tYWNbMl0gKyAoKG1jID4+IDI0KSAmIDB4RkYpICsgKHRtcCA+PiA4KSk7CgkJcGt0X2Rldi0+aGhbOF0gPSB0bXA7CgkJdG1wID0gKHBrdF9kZXYtPnNyY19tYWNbMV0gKyAodG1wID4+IDgpKTsKCQlwa3RfZGV2LT5oaFs3XSA9IHRtcDsKCX0KCgkvKiAgRGVhbCB3aXRoIERlc3RpbmF0aW9uIE1BQyAqLwoJaWYgKHBrdF9kZXYtPmRzdF9tYWNfY291bnQgPiAxKSB7CgkJX191MzIgbWM7CgkJX191MzIgdG1wOwoKCQlpZiAocGt0X2Rldi0+ZmxhZ3MgJiBGX01BQ0RTVF9STkQpCgkJCW1jID0gcGt0Z2VuX3JhbmRvbSgpICUgKHBrdF9kZXYtPmRzdF9tYWNfY291bnQpOwoKCQllbHNlIHsKCQkJbWMgPSBwa3RfZGV2LT5jdXJfZHN0X21hY19vZmZzZXQrKzsKCQkJaWYgKHBrdF9kZXYtPmN1cl9kc3RfbWFjX29mZnNldCA+CgkJCSAgICBwa3RfZGV2LT5kc3RfbWFjX2NvdW50KSB7CgkJCQlwa3RfZGV2LT5jdXJfZHN0X21hY19vZmZzZXQgPSAwOwoJCQl9CgkJfQoKCQl0bXAgPSBwa3RfZGV2LT5kc3RfbWFjWzVdICsgKG1jICYgMHhGRik7CgkJcGt0X2Rldi0+aGhbNV0gPSB0bXA7CgkJdG1wID0gKHBrdF9kZXYtPmRzdF9tYWNbNF0gKyAoKG1jID4+IDgpICYgMHhGRikgKyAodG1wID4+IDgpKTsKCQlwa3RfZGV2LT5oaFs0XSA9IHRtcDsKCQl0bXAgPSAocGt0X2Rldi0+ZHN0X21hY1szXSArICgobWMgPj4gMTYpICYgMHhGRikgKyAodG1wID4+IDgpKTsKCQlwa3RfZGV2LT5oaFszXSA9IHRtcDsKCQl0bXAgPSAocGt0X2Rldi0+ZHN0X21hY1syXSArICgobWMgPj4gMjQpICYgMHhGRikgKyAodG1wID4+IDgpKTsKCQlwa3RfZGV2LT5oaFsyXSA9IHRtcDsKCQl0bXAgPSAocGt0X2Rldi0+ZHN0X21hY1sxXSArICh0bXAgPj4gOCkpOwoJCXBrdF9kZXYtPmhoWzFdID0gdG1wOwoJfQoKCWlmIChwa3RfZGV2LT5mbGFncyAmIEZfTVBMU19STkQpIHsKCQl1bnNpZ25lZCBpOwoJCWZvcihpID0gMDsgaSA8IHBrdF9kZXYtPm5yX2xhYmVsczsgaSsrKQoJCQlpZiAocGt0X2Rldi0+bGFiZWxzW2ldICYgTVBMU19TVEFDS19CT1RUT00pCgkJCQlwa3RfZGV2LT5sYWJlbHNbaV0gPSBNUExTX1NUQUNLX0JPVFRPTSB8CgkJCQkJICAgICAoKF9fZm9yY2UgX19iZTMyKXBrdGdlbl9yYW5kb20oKSAmCgkJCQkJCSAgICAgIGh0b25sKDB4MDAwZmZmZmYpKTsKCX0KCglpZiAoKHBrdF9kZXYtPmZsYWdzICYgRl9WSURfUk5EKSAmJiAocGt0X2Rldi0+dmxhbl9pZCAhPSAweGZmZmYpKSB7CgkJcGt0X2Rldi0+dmxhbl9pZCA9IHBrdGdlbl9yYW5kb20oKSAlIDQwOTY7Cgl9CgoJaWYgKChwa3RfZGV2LT5mbGFncyAmIEZfU1ZJRF9STkQpICYmIChwa3RfZGV2LT5zdmxhbl9pZCAhPSAweGZmZmYpKSB7CgkJcGt0X2Rldi0+c3ZsYW5faWQgPSBwa3RnZW5fcmFuZG9tKCkgJSA0MDk2OwoJfQoKCWlmIChwa3RfZGV2LT51ZHBfc3JjX21pbiA8IHBrdF9kZXYtPnVkcF9zcmNfbWF4KSB7CgkJaWYgKHBrdF9kZXYtPmZsYWdzICYgRl9VRFBTUkNfUk5EKQoJCQlwa3RfZGV2LT5jdXJfdWRwX3NyYyA9CgkJCSAgICAoKHBrdGdlbl9yYW5kb20oKSAlCgkJCSAgICAgIChwa3RfZGV2LT51ZHBfc3JjX21heCAtIHBrdF9kZXYtPnVkcF9zcmNfbWluKSkgKwoJCQkgICAgIHBrdF9kZXYtPnVkcF9zcmNfbWluKTsKCgkJZWxzZSB7CgkJCXBrdF9kZXYtPmN1cl91ZHBfc3JjKys7CgkJCWlmIChwa3RfZGV2LT5jdXJfdWRwX3NyYyA+PSBwa3RfZGV2LT51ZHBfc3JjX21heCkKCQkJCXBrdF9kZXYtPmN1cl91ZHBfc3JjID0gcGt0X2Rldi0+dWRwX3NyY19taW47CgkJfQoJfQoKCWlmIChwa3RfZGV2LT51ZHBfZHN0X21pbiA8IHBrdF9kZXYtPnVkcF9kc3RfbWF4KSB7CgkJaWYgKHBrdF9kZXYtPmZsYWdzICYgRl9VRFBEU1RfUk5EKSB7CgkJCXBrdF9kZXYtPmN1cl91ZHBfZHN0ID0KCQkJICAgICgocGt0Z2VuX3JhbmRvbSgpICUKCQkJICAgICAgKHBrdF9kZXYtPnVkcF9kc3RfbWF4IC0gcGt0X2Rldi0+dWRwX2RzdF9taW4pKSArCgkJCSAgICAgcGt0X2Rldi0+dWRwX2RzdF9taW4pOwoJCX0gZWxzZSB7CgkJCXBrdF9kZXYtPmN1cl91ZHBfZHN0Kys7CgkJCWlmIChwa3RfZGV2LT5jdXJfdWRwX2RzdCA+PSBwa3RfZGV2LT51ZHBfZHN0X21heCkKCQkJCXBrdF9kZXYtPmN1cl91ZHBfZHN0ID0gcGt0X2Rldi0+dWRwX2RzdF9taW47CgkJfQoJfQoKCWlmICghKHBrdF9kZXYtPmZsYWdzICYgRl9JUFY2KSkgewoKCQlpZiAoKGltbiA9IG50b2hsKHBrdF9kZXYtPnNhZGRyX21pbikpIDwgKGlteCA9CgkJCQkJCQkgbnRvaGwocGt0X2Rldi0+CgkJCQkJCQkgICAgICAgc2FkZHJfbWF4KSkpIHsKCQkJX191MzIgdDsKCQkJaWYgKHBrdF9kZXYtPmZsYWdzICYgRl9JUFNSQ19STkQpCgkJCQl0ID0gKChwa3RnZW5fcmFuZG9tKCkgJSAoaW14IC0gaW1uKSkgKyBpbW4pOwoJCQllbHNlIHsKCQkJCXQgPSBudG9obChwa3RfZGV2LT5jdXJfc2FkZHIpOwoJCQkJdCsrOwoJCQkJaWYgKHQgPiBpbXgpIHsKCQkJCQl0ID0gaW1uOwoJCQkJfQoJCQl9CgkJCXBrdF9kZXYtPmN1cl9zYWRkciA9IGh0b25sKHQpOwoJCX0KCgkJaWYgKHBrdF9kZXYtPmNmbG93cyAmJiBwa3RfZGV2LT5mbG93c1tmbG93XS5jb3VudCAhPSAwKSB7CgkJCXBrdF9kZXYtPmN1cl9kYWRkciA9IHBrdF9kZXYtPmZsb3dzW2Zsb3ddLmN1cl9kYWRkcjsKCQl9IGVsc2UgewoJCQlpbW4gPSBudG9obChwa3RfZGV2LT5kYWRkcl9taW4pOwoJCQlpbXggPSBudG9obChwa3RfZGV2LT5kYWRkcl9tYXgpOwoJCQlpZiAoaW1uIDwgaW14KSB7CgkJCQlfX3UzMiB0OwoJCQkJX19iZTMyIHM7CgkJCQlpZiAocGt0X2Rldi0+ZmxhZ3MgJiBGX0lQRFNUX1JORCkgewoKCQkJCQl0ID0gcGt0Z2VuX3JhbmRvbSgpICUgKGlteCAtIGltbikgKyBpbW47CgkJCQkJcyA9IGh0b25sKHQpOwoKCQkJCQl3aGlsZSAoTE9PUEJBQ0socykgfHwgTVVMVElDQVNUKHMpCgkJCQkJICAgICAgIHx8IEJBRENMQVNTKHMpIHx8IFpFUk9ORVQocykKCQkJCQkgICAgICAgfHwgTE9DQUxfTUNBU1QocykpIHsKCQkJCQkJdCA9IChwa3RnZW5fcmFuZG9tKCkgJQoJCQkJCQkgICAgICAoaW14IC0gaW1uKSkgKyBpbW47CgkJCQkJCXMgPSBodG9ubCh0KTsKCQkJCQl9CgkJCQkJcGt0X2Rldi0+Y3VyX2RhZGRyID0gczsKCQkJCX0gZWxzZSB7CgkJCQkJdCA9IG50b2hsKHBrdF9kZXYtPmN1cl9kYWRkcik7CgkJCQkJdCsrOwoJCQkJCWlmICh0ID4gaW14KSB7CgkJCQkJCXQgPSBpbW47CgkJCQkJfQoJCQkJCXBrdF9kZXYtPmN1cl9kYWRkciA9IGh0b25sKHQpOwoJCQkJfQoJCQl9CgkJCWlmIChwa3RfZGV2LT5jZmxvd3MpIHsKCQkJCXBrdF9kZXYtPmZsb3dzW2Zsb3ddLmN1cl9kYWRkciA9CgkJCQkgICAgcGt0X2Rldi0+Y3VyX2RhZGRyOwoJCQkJcGt0X2Rldi0+bmZsb3dzKys7CgkJCX0KCQl9Cgl9IGVsc2UgewkJLyogSVBWNiAqICovCgoJCWlmIChwa3RfZGV2LT5taW5faW42X2RhZGRyLnM2X2FkZHIzMlswXSA9PSAwICYmCgkJICAgIHBrdF9kZXYtPm1pbl9pbjZfZGFkZHIuczZfYWRkcjMyWzFdID09IDAgJiYKCQkgICAgcGt0X2Rldi0+bWluX2luNl9kYWRkci5zNl9hZGRyMzJbMl0gPT0gMCAmJgoJCSAgICBwa3RfZGV2LT5taW5faW42X2RhZGRyLnM2X2FkZHIzMlszXSA9PSAwKSA7CgkJZWxzZSB7CgkJCWludCBpOwoKCQkJLyogT25seSByYW5kb20gZGVzdGluYXRpb25zIHlldCAqLwoKCQkJZm9yIChpID0gMDsgaSA8IDQ7IGkrKykgewoJCQkJcGt0X2Rldi0+Y3VyX2luNl9kYWRkci5zNl9hZGRyMzJbaV0gPQoJCQkJICAgICgoKF9fZm9yY2UgX19iZTMyKXBrdGdlbl9yYW5kb20oKSB8CgkJCQkgICAgICBwa3RfZGV2LT5taW5faW42X2RhZGRyLnM2X2FkZHIzMltpXSkgJgoJCQkJICAgICBwa3RfZGV2LT5tYXhfaW42X2RhZGRyLnM2X2FkZHIzMltpXSk7CgkJCX0KCQl9Cgl9CgoJaWYgKHBrdF9kZXYtPm1pbl9wa3Rfc2l6ZSA8IHBrdF9kZXYtPm1heF9wa3Rfc2l6ZSkgewoJCV9fdTMyIHQ7CgkJaWYgKHBrdF9kZXYtPmZsYWdzICYgRl9UWFNJWkVfUk5EKSB7CgkJCXQgPSAoKHBrdGdlbl9yYW5kb20oKSAlCgkJCSAgICAgIChwa3RfZGV2LT5tYXhfcGt0X3NpemUgLSBwa3RfZGV2LT5taW5fcGt0X3NpemUpKQoJCQkgICAgICsgcGt0X2Rldi0+bWluX3BrdF9zaXplKTsKCQl9IGVsc2UgewoJCQl0ID0gcGt0X2Rldi0+Y3VyX3BrdF9zaXplICsgMTsKCQkJaWYgKHQgPiBwa3RfZGV2LT5tYXhfcGt0X3NpemUpCgkJCQl0ID0gcGt0X2Rldi0+bWluX3BrdF9zaXplOwoJCX0KCQlwa3RfZGV2LT5jdXJfcGt0X3NpemUgPSB0OwoJfQoKCXBrdF9kZXYtPmZsb3dzW2Zsb3ddLmNvdW50Kys7Cn0KCnN0YXRpYyB2b2lkIG1wbHNfcHVzaChfX2JlMzIgKm1wbHMsIHN0cnVjdCBwa3RnZW5fZGV2ICpwa3RfZGV2KQp7Cgl1bnNpZ25lZCBpOwoJZm9yKGkgPSAwOyBpIDwgcGt0X2Rldi0+bnJfbGFiZWxzOyBpKyspIHsKCQkqbXBscysrID0gcGt0X2Rldi0+bGFiZWxzW2ldICYgfk1QTFNfU1RBQ0tfQk9UVE9NOwoJfQoJbXBscy0tOwoJKm1wbHMgfD0gTVBMU19TVEFDS19CT1RUT007Cn0KCnN0YXRpYyBpbmxpbmUgX19iZTE2IGJ1aWxkX3RjaSh1bnNpZ25lZCBpbnQgaWQsIHVuc2lnbmVkIGludCBjZmksCgkJCSAgICAgICB1bnNpZ25lZCBpbnQgcHJpbykKewoJcmV0dXJuIGh0b25zKGlkIHwgKGNmaSA8PCAxMikgfCAocHJpbyA8PCAxMykpOwp9CgpzdGF0aWMgc3RydWN0IHNrX2J1ZmYgKmZpbGxfcGFja2V0X2lwdjQoc3RydWN0IG5ldF9kZXZpY2UgKm9kZXYsCgkJCQkJc3RydWN0IHBrdGdlbl9kZXYgKnBrdF9kZXYpCnsKCXN0cnVjdCBza19idWZmICpza2IgPSBOVUxMOwoJX191OCAqZXRoOwoJc3RydWN0IHVkcGhkciAqdWRwaDsKCWludCBkYXRhbGVuLCBpcGxlbjsKCXN0cnVjdCBpcGhkciAqaXBoOwoJc3RydWN0IHBrdGdlbl9oZHIgKnBnaCA9IE5VTEw7CglfX2JlMTYgcHJvdG9jb2wgPSBfX2NvbnN0YW50X2h0b25zKEVUSF9QX0lQKTsKCV9fYmUzMiAqbXBsczsKCV9fYmUxNiAqdmxhbl90Y2kgPSBOVUxMOyAgICAgICAgICAgICAgICAgLyogRW5jYXBzdWxhdGVzIHByaW9yaXR5IGFuZCBWTEFOIElEICovCglfX2JlMTYgKnZsYW5fZW5jYXBzdWxhdGVkX3Byb3RvID0gTlVMTDsgIC8qIHBhY2tldCB0eXBlIElEIGZpZWxkIChvciBsZW4pIGZvciBWTEFOIHRhZyAqLwoJX19iZTE2ICpzdmxhbl90Y2kgPSBOVUxMOyAgICAgICAgICAgICAgICAvKiBFbmNhcHN1bGF0ZXMgcHJpb3JpdHkgYW5kIFNWTEFOIElEICovCglfX2JlMTYgKnN2bGFuX2VuY2Fwc3VsYXRlZF9wcm90byA9IE5VTEw7IC8qIHBhY2tldCB0eXBlIElEIGZpZWxkIChvciBsZW4pIGZvciBTVkxBTiB0YWcgKi8KCgoJaWYgKHBrdF9kZXYtPm5yX2xhYmVscykKCQlwcm90b2NvbCA9IF9fY29uc3RhbnRfaHRvbnMoRVRIX1BfTVBMU19VQyk7CgoJaWYgKHBrdF9kZXYtPnZsYW5faWQgIT0gMHhmZmZmKQoJCXByb3RvY29sID0gX19jb25zdGFudF9odG9ucyhFVEhfUF84MDIxUSk7CgoJLyogVXBkYXRlIGFueSBvZiB0aGUgdmFsdWVzLCB1c2VkIHdoZW4gd2UncmUgaW5jcmVtZW50aW5nIHZhcmlvdXMKCSAqIGZpZWxkcy4KCSAqLwoJbW9kX2N1cl9oZWFkZXJzKHBrdF9kZXYpOwoKCWRhdGFsZW4gPSAob2Rldi0+aGFyZF9oZWFkZXJfbGVuICsgMTYpICYgfjB4ZjsKCXNrYiA9IGFsbG9jX3NrYihwa3RfZGV2LT5jdXJfcGt0X3NpemUgKyA2NCArIGRhdGFsZW4gKwoJCQlwa3RfZGV2LT5ucl9sYWJlbHMqc2l6ZW9mKHUzMikgKwoJCQlWTEFOX1RBR19TSVpFKHBrdF9kZXYpICsgU1ZMQU5fVEFHX1NJWkUocGt0X2RldiksCgkJCUdGUF9BVE9NSUMpOwoJaWYgKCFza2IpIHsKCQlzcHJpbnRmKHBrdF9kZXYtPnJlc3VsdCwgIk5vIG1lbW9yeSIpOwoJCXJldHVybiBOVUxMOwoJfQoKCXNrYl9yZXNlcnZlKHNrYiwgZGF0YWxlbik7CgoJLyogIFJlc2VydmUgZm9yIGV0aGVybmV0IGFuZCBJUCBoZWFkZXIgICovCglldGggPSAoX191OCAqKSBza2JfcHVzaChza2IsIDE0KTsKCW1wbHMgPSAoX19iZTMyICopc2tiX3B1dChza2IsIHBrdF9kZXYtPm5yX2xhYmVscypzaXplb2YoX191MzIpKTsKCWlmIChwa3RfZGV2LT5ucl9sYWJlbHMpCgkJbXBsc19wdXNoKG1wbHMsIHBrdF9kZXYpOwoKCWlmIChwa3RfZGV2LT52bGFuX2lkICE9IDB4ZmZmZikgewoJCWlmKHBrdF9kZXYtPnN2bGFuX2lkICE9IDB4ZmZmZikgewoJCQlzdmxhbl90Y2kgPSAoX19iZTE2ICopc2tiX3B1dChza2IsIHNpemVvZihfX2JlMTYpKTsKCQkJKnN2bGFuX3RjaSA9IGJ1aWxkX3RjaShwa3RfZGV2LT5zdmxhbl9pZCwKCQkJCQkgICAgICAgcGt0X2Rldi0+c3ZsYW5fY2ZpLAoJCQkJCSAgICAgICBwa3RfZGV2LT5zdmxhbl9wKTsKCQkJc3ZsYW5fZW5jYXBzdWxhdGVkX3Byb3RvID0gKF9fYmUxNiAqKXNrYl9wdXQoc2tiLCBzaXplb2YoX19iZTE2KSk7CgkJCSpzdmxhbl9lbmNhcHN1bGF0ZWRfcHJvdG8gPSBfX2NvbnN0YW50X2h0b25zKEVUSF9QXzgwMjFRKTsKCQl9CgkJdmxhbl90Y2kgPSAoX19iZTE2ICopc2tiX3B1dChza2IsIHNpemVvZihfX2JlMTYpKTsKCQkqdmxhbl90Y2kgPSBidWlsZF90Y2kocGt0X2Rldi0+dmxhbl9pZCwKCQkJCSAgICAgIHBrdF9kZXYtPnZsYW5fY2ZpLAoJCQkJICAgICAgcGt0X2Rldi0+dmxhbl9wKTsKCQl2bGFuX2VuY2Fwc3VsYXRlZF9wcm90byA9IChfX2JlMTYgKilza2JfcHV0KHNrYiwgc2l6ZW9mKF9fYmUxNikpOwoJCSp2bGFuX2VuY2Fwc3VsYXRlZF9wcm90byA9IF9fY29uc3RhbnRfaHRvbnMoRVRIX1BfSVApOwoJfQoKCWlwaCA9IChzdHJ1Y3QgaXBoZHIgKilza2JfcHV0KHNrYiwgc2l6ZW9mKHN0cnVjdCBpcGhkcikpOwoJdWRwaCA9IChzdHJ1Y3QgdWRwaGRyICopc2tiX3B1dChza2IsIHNpemVvZihzdHJ1Y3QgdWRwaGRyKSk7CgoJbWVtY3B5KGV0aCwgcGt0X2Rldi0+aGgsIDEyKTsKCSooX19iZTE2ICopICYgZXRoWzEyXSA9IHByb3RvY29sOwoKCS8qIEV0aCArIElQaCArIFVEUGggKyBtcGxzICovCglkYXRhbGVuID0gcGt0X2Rldi0+Y3VyX3BrdF9zaXplIC0gMTQgLSAyMCAtIDggLQoJCSAgcGt0X2Rldi0+bnJfbGFiZWxzKnNpemVvZih1MzIpIC0gVkxBTl9UQUdfU0laRShwa3RfZGV2KSAtIFNWTEFOX1RBR19TSVpFKHBrdF9kZXYpOwoJaWYgKGRhdGFsZW4gPCBzaXplb2Yoc3RydWN0IHBrdGdlbl9oZHIpKQoJCWRhdGFsZW4gPSBzaXplb2Yoc3RydWN0IHBrdGdlbl9oZHIpOwoKCXVkcGgtPnNvdXJjZSA9IGh0b25zKHBrdF9kZXYtPmN1cl91ZHBfc3JjKTsKCXVkcGgtPmRlc3QgPSBodG9ucyhwa3RfZGV2LT5jdXJfdWRwX2RzdCk7Cgl1ZHBoLT5sZW4gPSBodG9ucyhkYXRhbGVuICsgOCk7CS8qIERBVEEgKyB1ZHBoZHIgKi8KCXVkcGgtPmNoZWNrID0gMDsJLyogTm8gY2hlY2tzdW0gKi8KCglpcGgtPmlobCA9IDU7CglpcGgtPnZlcnNpb24gPSA0OwoJaXBoLT50dGwgPSAzMjsKCWlwaC0+dG9zID0gcGt0X2Rldi0+dG9zOwoJaXBoLT5wcm90b2NvbCA9IElQUFJPVE9fVURQOwkvKiBVRFAgKi8KCWlwaC0+c2FkZHIgPSBwa3RfZGV2LT5jdXJfc2FkZHI7CglpcGgtPmRhZGRyID0gcGt0X2Rldi0+Y3VyX2RhZGRyOwoJaXBoLT5mcmFnX29mZiA9IDA7CglpcGxlbiA9IDIwICsgOCArIGRhdGFsZW47CglpcGgtPnRvdF9sZW4gPSBodG9ucyhpcGxlbik7CglpcGgtPmNoZWNrID0gMDsKCWlwaC0+Y2hlY2sgPSBpcF9mYXN0X2NzdW0oKHZvaWQgKilpcGgsIGlwaC0+aWhsKTsKCXNrYi0+cHJvdG9jb2wgPSBwcm90b2NvbDsKCXNrYi0+bWFjLnJhdyA9ICgodTggKikgaXBoKSAtIDE0IC0gcGt0X2Rldi0+bnJfbGFiZWxzKnNpemVvZih1MzIpIC0KCQlWTEFOX1RBR19TSVpFKHBrdF9kZXYpIC0gU1ZMQU5fVEFHX1NJWkUocGt0X2Rldik7Cglza2ItPmRldiA9IG9kZXY7Cglza2ItPnBrdF90eXBlID0gUEFDS0VUX0hPU1Q7Cglza2ItPm5oLmlwaCA9IGlwaDsKCXNrYi0+aC51aCA9IHVkcGg7CgoJaWYgKHBrdF9kZXYtPm5mcmFncyA8PSAwKQoJCXBnaCA9IChzdHJ1Y3QgcGt0Z2VuX2hkciAqKXNrYl9wdXQoc2tiLCBkYXRhbGVuKTsKCWVsc2UgewoJCWludCBmcmFncyA9IHBrdF9kZXYtPm5mcmFnczsKCQlpbnQgaTsKCgkJcGdoID0gKHN0cnVjdCBwa3RnZW5faGRyICopKCgoY2hhciAqKSh1ZHBoKSkgKyA4KTsKCgkJaWYgKGZyYWdzID4gTUFYX1NLQl9GUkFHUykKCQkJZnJhZ3MgPSBNQVhfU0tCX0ZSQUdTOwoJCWlmIChkYXRhbGVuID4gZnJhZ3MgKiBQQUdFX1NJWkUpIHsKCQkJc2tiX3B1dChza2IsIGRhdGFsZW4gLSBmcmFncyAqIFBBR0VfU0laRSk7CgkJCWRhdGFsZW4gPSBmcmFncyAqIFBBR0VfU0laRTsKCQl9CgoJCWkgPSAwOwoJCXdoaWxlIChkYXRhbGVuID4gMCkgewoJCQlzdHJ1Y3QgcGFnZSAqcGFnZSA9IGFsbG9jX3BhZ2VzKEdGUF9LRVJORUwsIDApOwoJCQlza2Jfc2hpbmZvKHNrYiktPmZyYWdzW2ldLnBhZ2UgPSBwYWdlOwoJCQlza2Jfc2hpbmZvKHNrYiktPmZyYWdzW2ldLnBhZ2Vfb2Zmc2V0ID0gMDsKCQkJc2tiX3NoaW5mbyhza2IpLT5mcmFnc1tpXS5zaXplID0KCQkJICAgIChkYXRhbGVuIDwgUEFHRV9TSVpFID8gZGF0YWxlbiA6IFBBR0VfU0laRSk7CgkJCWRhdGFsZW4gLT0gc2tiX3NoaW5mbyhza2IpLT5mcmFnc1tpXS5zaXplOwoJCQlza2ItPmxlbiArPSBza2Jfc2hpbmZvKHNrYiktPmZyYWdzW2ldLnNpemU7CgkJCXNrYi0+ZGF0YV9sZW4gKz0gc2tiX3NoaW5mbyhza2IpLT5mcmFnc1tpXS5zaXplOwoJCQlpKys7CgkJCXNrYl9zaGluZm8oc2tiKS0+bnJfZnJhZ3MgPSBpOwoJCX0KCgkJd2hpbGUgKGkgPCBmcmFncykgewoJCQlpbnQgcmVtOwoKCQkJaWYgKGkgPT0gMCkKCQkJCWJyZWFrOwoKCQkJcmVtID0gc2tiX3NoaW5mbyhza2IpLT5mcmFnc1tpIC0gMV0uc2l6ZSAvIDI7CgkJCWlmIChyZW0gPT0gMCkKCQkJCWJyZWFrOwoKCQkJc2tiX3NoaW5mbyhza2IpLT5mcmFnc1tpIC0gMV0uc2l6ZSAtPSByZW07CgoJCQlza2Jfc2hpbmZvKHNrYiktPmZyYWdzW2ldID0KCQkJICAgIHNrYl9zaGluZm8oc2tiKS0+ZnJhZ3NbaSAtIDFdOwoJCQlnZXRfcGFnZShza2Jfc2hpbmZvKHNrYiktPmZyYWdzW2ldLnBhZ2UpOwoJCQlza2Jfc2hpbmZvKHNrYiktPmZyYWdzW2ldLnBhZ2UgPQoJCQkgICAgc2tiX3NoaW5mbyhza2IpLT5mcmFnc1tpIC0gMV0ucGFnZTsKCQkJc2tiX3NoaW5mbyhza2IpLT5mcmFnc1tpXS5wYWdlX29mZnNldCArPQoJCQkgICAgc2tiX3NoaW5mbyhza2IpLT5mcmFnc1tpIC0gMV0uc2l6ZTsKCQkJc2tiX3NoaW5mbyhza2IpLT5mcmFnc1tpXS5zaXplID0gcmVtOwoJCQlpKys7CgkJCXNrYl9zaGluZm8oc2tiKS0+bnJfZnJhZ3MgPSBpOwoJCX0KCX0KCgkvKiBTdGFtcCB0aGUgdGltZSwgYW5kIHNlcXVlbmNlIG51bWJlciwgY29udmVydCB0aGVtIHRvIG5ldHdvcmsgYnl0ZSBvcmRlciAqLwoKCWlmIChwZ2gpIHsKCQlzdHJ1Y3QgdGltZXZhbCB0aW1lc3RhbXA7CgoJCXBnaC0+cGdoX21hZ2ljID0gaHRvbmwoUEtUR0VOX01BR0lDKTsKCQlwZ2gtPnNlcV9udW0gPSBodG9ubChwa3RfZGV2LT5zZXFfbnVtKTsKCgkJZG9fZ2V0dGltZW9mZGF5KCZ0aW1lc3RhbXApOwoJCXBnaC0+dHZfc2VjID0gaHRvbmwodGltZXN0YW1wLnR2X3NlYyk7CgkJcGdoLT50dl91c2VjID0gaHRvbmwodGltZXN0YW1wLnR2X3VzZWMpOwoJfQoKCXJldHVybiBza2I7Cn0KCi8qCiAqIHNjYW5faXA2LCBmbXRfaXAgdGFrZW4gZnJvbSBkaWV0bGliYy0wLjIxIAogKiBBdXRob3IgRmVsaXggdm9uIExlaXRuZXIgPGZlbGl4LWRpZXRsaWJjQGZlZmUuZGU+CiAqCiAqIFNsaWdodGx5IG1vZGlmaWVkIGZvciBrZXJuZWwuIAogKiBTaG91bGQgYmUgY2FuZGlkYXRlIGZvciBuZXQvaXB2NC91dGlscy5jCiAqIC0tcm8KICovCgpzdGF0aWMgdW5zaWduZWQgaW50IHNjYW5faXA2KGNvbnN0IGNoYXIgKnMsIGNoYXIgaXBbMTZdKQp7Cgl1bnNpZ25lZCBpbnQgaTsKCXVuc2lnbmVkIGludCBsZW4gPSAwOwoJdW5zaWduZWQgbG9uZyB1OwoJY2hhciBzdWZmaXhbMTZdOwoJdW5zaWduZWQgaW50IHByZWZpeGxlbiA9IDA7Cgl1bnNpZ25lZCBpbnQgc3VmZml4bGVuID0gMDsKCV9fYmUzMiB0bXA7CgoJZm9yIChpID0gMDsgaSA8IDE2OyBpKyspCgkJaXBbaV0gPSAwOwoKCWZvciAoOzspIHsKCQlpZiAoKnMgPT0gJzonKSB7CgkJCWxlbisrOwoJCQlpZiAoc1sxXSA9PSAnOicpIHsJLyogRm91bmQgIjo6Iiwgc2tpcCB0byBwYXJ0IDIgKi8KCQkJCXMgKz0gMjsKCQkJCWxlbisrOwoJCQkJYnJlYWs7CgkJCX0KCQkJcysrOwoJCX0KCQl7CgkJCWNoYXIgKnRtcDsKCQkJdSA9IHNpbXBsZV9zdHJ0b3VsKHMsICZ0bXAsIDE2KTsKCQkJaSA9IHRtcCAtIHM7CgkJfQoKCQlpZiAoIWkpCgkJCXJldHVybiAwOwoJCWlmIChwcmVmaXhsZW4gPT0gMTIgJiYgc1tpXSA9PSAnLicpIHsKCgkJCS8qIHRoZSBsYXN0IDQgYnl0ZXMgbWF5IGJlIHdyaXR0ZW4gYXMgSVB2NCBhZGRyZXNzICovCgoJCQl0bXAgPSBpbl9hdG9uKHMpOwoJCQltZW1jcHkoKHN0cnVjdCBpbl9hZGRyICopKGlwICsgMTIpLCAmdG1wLCBzaXplb2YodG1wKSk7CgkJCXJldHVybiBpICsgbGVuOwoJCX0KCQlpcFtwcmVmaXhsZW4rK10gPSAodSA+PiA4KTsKCQlpcFtwcmVmaXhsZW4rK10gPSAodSAmIDI1NSk7CgkJcyArPSBpOwoJCWxlbiArPSBpOwoJCWlmIChwcmVmaXhsZW4gPT0gMTYpCgkJCXJldHVybiBsZW47Cgl9CgovKiBwYXJ0IDIsIGFmdGVyICI6OiIgKi8KCWZvciAoOzspIHsKCQlpZiAoKnMgPT0gJzonKSB7CgkJCWlmIChzdWZmaXhsZW4gPT0gMCkKCQkJCWJyZWFrOwoJCQlzKys7CgkJCWxlbisrOwoJCX0gZWxzZSBpZiAoc3VmZml4bGVuICE9IDApCgkJCWJyZWFrOwoJCXsKCQkJY2hhciAqdG1wOwoJCQl1ID0gc2ltcGxlX3N0cnRvbChzLCAmdG1wLCAxNik7CgkJCWkgPSB0bXAgLSBzOwoJCX0KCQlpZiAoIWkpIHsKCQkJaWYgKCpzKQoJCQkJbGVuLS07CgkJCWJyZWFrOwoJCX0KCQlpZiAoc3VmZml4bGVuICsgcHJlZml4bGVuIDw9IDEyICYmIHNbaV0gPT0gJy4nKSB7CgkJCXRtcCA9IGluX2F0b24ocyk7CgkJCW1lbWNweSgoc3RydWN0IGluX2FkZHIgKikoc3VmZml4ICsgc3VmZml4bGVuKSwgJnRtcCwKCQkJICAgICAgIHNpemVvZih0bXApKTsKCQkJc3VmZml4bGVuICs9IDQ7CgkJCWxlbiArPSBzdHJsZW4ocyk7CgkJCWJyZWFrOwoJCX0KCQlzdWZmaXhbc3VmZml4bGVuKytdID0gKHUgPj4gOCk7CgkJc3VmZml4W3N1ZmZpeGxlbisrXSA9ICh1ICYgMjU1KTsKCQlzICs9IGk7CgkJbGVuICs9IGk7CgkJaWYgKHByZWZpeGxlbiArIHN1ZmZpeGxlbiA9PSAxNikKCQkJYnJlYWs7Cgl9Cglmb3IgKGkgPSAwOyBpIDwgc3VmZml4bGVuOyBpKyspCgkJaXBbMTYgLSBzdWZmaXhsZW4gKyBpXSA9IHN1ZmZpeFtpXTsKCXJldHVybiBsZW47Cn0KCnN0YXRpYyBjaGFyIHRvaGV4KGNoYXIgaGV4ZGlnaXQpCnsKCXJldHVybiBoZXhkaWdpdCA+IDkgPyBoZXhkaWdpdCArICdhJyAtIDEwIDogaGV4ZGlnaXQgKyAnMCc7Cn0KCnN0YXRpYyBpbnQgZm10X3hsb25nKGNoYXIgKnMsIHVuc2lnbmVkIGludCBpKQp7CgljaGFyICpiYWsgPSBzOwoJKnMgPSB0b2hleCgoaSA+PiAxMikgJiAweGYpOwoJaWYgKHMgIT0gYmFrIHx8ICpzICE9ICcwJykKCQkrK3M7CgkqcyA9IHRvaGV4KChpID4+IDgpICYgMHhmKTsKCWlmIChzICE9IGJhayB8fCAqcyAhPSAnMCcpCgkJKytzOwoJKnMgPSB0b2hleCgoaSA+PiA0KSAmIDB4Zik7CglpZiAocyAhPSBiYWsgfHwgKnMgIT0gJzAnKQoJCSsrczsKCSpzID0gdG9oZXgoaSAmIDB4Zik7CglyZXR1cm4gcyAtIGJhayArIDE7Cn0KCnN0YXRpYyB1bnNpZ25lZCBpbnQgZm10X2lwNihjaGFyICpzLCBjb25zdCBjaGFyIGlwWzE2XSkKewoJdW5zaWduZWQgaW50IGxlbjsKCXVuc2lnbmVkIGludCBpOwoJdW5zaWduZWQgaW50IHRlbXA7Cgl1bnNpZ25lZCBpbnQgY29tcHJlc3Npbmc7CglpbnQgajsKCglsZW4gPSAwOwoJY29tcHJlc3NpbmcgPSAwOwoJZm9yIChqID0gMDsgaiA8IDE2OyBqICs9IDIpIHsKCiNpZmRlZiBWNE1BUFBFRFBSRUZJWAoJCWlmIChqID09IDEyICYmICFtZW1jbXAoaXAsIFY0bWFwcGVkcHJlZml4LCAxMikpIHsKCQkJaW5ldF9udG9hX3IoKihzdHJ1Y3QgaW5fYWRkciAqKShpcCArIDEyKSwgcyk7CgkJCXRlbXAgPSBzdHJsZW4ocyk7CgkJCXJldHVybiBsZW4gKyB0ZW1wOwoJCX0KI2VuZGlmCgkJdGVtcCA9ICgodW5zaWduZWQgbG9uZykodW5zaWduZWQgY2hhcilpcFtqXSA8PCA4KSArCgkJICAgICh1bnNpZ25lZCBsb25nKSh1bnNpZ25lZCBjaGFyKWlwW2ogKyAxXTsKCQlpZiAodGVtcCA9PSAwKSB7CgkJCWlmICghY29tcHJlc3NpbmcpIHsKCQkJCWNvbXByZXNzaW5nID0gMTsKCQkJCWlmIChqID09IDApIHsKCQkJCQkqcysrID0gJzonOwoJCQkJCSsrbGVuOwoJCQkJfQoJCQl9CgkJfSBlbHNlIHsKCQkJaWYgKGNvbXByZXNzaW5nKSB7CgkJCQljb21wcmVzc2luZyA9IDA7CgkJCQkqcysrID0gJzonOwoJCQkJKytsZW47CgkJCX0KCQkJaSA9IGZtdF94bG9uZyhzLCB0ZW1wKTsKCQkJbGVuICs9IGk7CgkJCXMgKz0gaTsKCQkJaWYgKGogPCAxNCkgewoJCQkJKnMrKyA9ICc6JzsKCQkJCSsrbGVuOwoJCQl9CgkJfQoJfQoJaWYgKGNvbXByZXNzaW5nKSB7CgkJKnMrKyA9ICc6JzsKCQkrK2xlbjsKCX0KCSpzID0gMDsKCXJldHVybiBsZW47Cn0KCnN0YXRpYyBzdHJ1Y3Qgc2tfYnVmZiAqZmlsbF9wYWNrZXRfaXB2NihzdHJ1Y3QgbmV0X2RldmljZSAqb2RldiwKCQkJCQlzdHJ1Y3QgcGt0Z2VuX2RldiAqcGt0X2RldikKewoJc3RydWN0IHNrX2J1ZmYgKnNrYiA9IE5VTEw7CglfX3U4ICpldGg7CglzdHJ1Y3QgdWRwaGRyICp1ZHBoOwoJaW50IGRhdGFsZW47CglzdHJ1Y3QgaXB2NmhkciAqaXBoOwoJc3RydWN0IHBrdGdlbl9oZHIgKnBnaCA9IE5VTEw7CglfX2JlMTYgcHJvdG9jb2wgPSBfX2NvbnN0YW50X2h0b25zKEVUSF9QX0lQVjYpOwoJX19iZTMyICptcGxzOwoJX19iZTE2ICp2bGFuX3RjaSA9IE5VTEw7ICAgICAgICAgICAgICAgICAvKiBFbmNhcHN1bGF0ZXMgcHJpb3JpdHkgYW5kIFZMQU4gSUQgKi8KCV9fYmUxNiAqdmxhbl9lbmNhcHN1bGF0ZWRfcHJvdG8gPSBOVUxMOyAgLyogcGFja2V0IHR5cGUgSUQgZmllbGQgKG9yIGxlbikgZm9yIFZMQU4gdGFnICovCglfX2JlMTYgKnN2bGFuX3RjaSA9IE5VTEw7ICAgICAgICAgICAgICAgIC8qIEVuY2Fwc3VsYXRlcyBwcmlvcml0eSBhbmQgU1ZMQU4gSUQgKi8KCV9fYmUxNiAqc3ZsYW5fZW5jYXBzdWxhdGVkX3Byb3RvID0gTlVMTDsgLyogcGFja2V0IHR5cGUgSUQgZmllbGQgKG9yIGxlbikgZm9yIFNWTEFOIHRhZyAqLwoKCWlmIChwa3RfZGV2LT5ucl9sYWJlbHMpCgkJcHJvdG9jb2wgPSBfX2NvbnN0YW50X2h0b25zKEVUSF9QX01QTFNfVUMpOwoKCWlmIChwa3RfZGV2LT52bGFuX2lkICE9IDB4ZmZmZikKCQlwcm90b2NvbCA9IF9fY29uc3RhbnRfaHRvbnMoRVRIX1BfODAyMVEpOwoKCS8qIFVwZGF0ZSBhbnkgb2YgdGhlIHZhbHVlcywgdXNlZCB3aGVuIHdlJ3JlIGluY3JlbWVudGluZyB2YXJpb3VzCgkgKiBmaWVsZHMuCgkgKi8KCW1vZF9jdXJfaGVhZGVycyhwa3RfZGV2KTsKCglza2IgPSBhbGxvY19za2IocGt0X2Rldi0+Y3VyX3BrdF9zaXplICsgNjQgKyAxNiArCgkJCXBrdF9kZXYtPm5yX2xhYmVscypzaXplb2YodTMyKSArCgkJCVZMQU5fVEFHX1NJWkUocGt0X2RldikgKyBTVkxBTl9UQUdfU0laRShwa3RfZGV2KSwKCQkJR0ZQX0FUT01JQyk7CglpZiAoIXNrYikgewoJCXNwcmludGYocGt0X2Rldi0+cmVzdWx0LCAiTm8gbWVtb3J5Iik7CgkJcmV0dXJuIE5VTEw7Cgl9CgoJc2tiX3Jlc2VydmUoc2tiLCAxNik7CgoJLyogIFJlc2VydmUgZm9yIGV0aGVybmV0IGFuZCBJUCBoZWFkZXIgICovCglldGggPSAoX191OCAqKSBza2JfcHVzaChza2IsIDE0KTsKCW1wbHMgPSAoX19iZTMyICopc2tiX3B1dChza2IsIHBrdF9kZXYtPm5yX2xhYmVscypzaXplb2YoX191MzIpKTsKCWlmIChwa3RfZGV2LT5ucl9sYWJlbHMpCgkJbXBsc19wdXNoKG1wbHMsIHBrdF9kZXYpOwoKCWlmIChwa3RfZGV2LT52bGFuX2lkICE9IDB4ZmZmZikgewoJCWlmKHBrdF9kZXYtPnN2bGFuX2lkICE9IDB4ZmZmZikgewoJCQlzdmxhbl90Y2kgPSAoX19iZTE2ICopc2tiX3B1dChza2IsIHNpemVvZihfX2JlMTYpKTsKCQkJKnN2bGFuX3RjaSA9IGJ1aWxkX3RjaShwa3RfZGV2LT5zdmxhbl9pZCwKCQkJCQkgICAgICAgcGt0X2Rldi0+c3ZsYW5fY2ZpLAoJCQkJCSAgICAgICBwa3RfZGV2LT5zdmxhbl9wKTsKCQkJc3ZsYW5fZW5jYXBzdWxhdGVkX3Byb3RvID0gKF9fYmUxNiAqKXNrYl9wdXQoc2tiLCBzaXplb2YoX19iZTE2KSk7CgkJCSpzdmxhbl9lbmNhcHN1bGF0ZWRfcHJvdG8gPSBfX2NvbnN0YW50X2h0b25zKEVUSF9QXzgwMjFRKTsKCQl9CgkJdmxhbl90Y2kgPSAoX19iZTE2ICopc2tiX3B1dChza2IsIHNpemVvZihfX2JlMTYpKTsKCQkqdmxhbl90Y2kgPSBidWlsZF90Y2kocGt0X2Rldi0+dmxhbl9pZCwKCQkJCSAgICAgIHBrdF9kZXYtPnZsYW5fY2ZpLAoJCQkJICAgICAgcGt0X2Rldi0+dmxhbl9wKTsKCQl2bGFuX2VuY2Fwc3VsYXRlZF9wcm90byA9IChfX2JlMTYgKilza2JfcHV0KHNrYiwgc2l6ZW9mKF9fYmUxNikpOwoJCSp2bGFuX2VuY2Fwc3VsYXRlZF9wcm90byA9IF9fY29uc3RhbnRfaHRvbnMoRVRIX1BfSVBWNik7Cgl9CgoJaXBoID0gKHN0cnVjdCBpcHY2aGRyICopc2tiX3B1dChza2IsIHNpemVvZihzdHJ1Y3QgaXB2NmhkcikpOwoJdWRwaCA9IChzdHJ1Y3QgdWRwaGRyICopc2tiX3B1dChza2IsIHNpemVvZihzdHJ1Y3QgdWRwaGRyKSk7CgoJbWVtY3B5KGV0aCwgcGt0X2Rldi0+aGgsIDEyKTsKCSooX19iZTE2ICopICYgZXRoWzEyXSA9IHByb3RvY29sOwoKCS8qIEV0aCArIElQaCArIFVEUGggKyBtcGxzICovCglkYXRhbGVuID0gcGt0X2Rldi0+Y3VyX3BrdF9zaXplIC0gMTQgLQoJCSAgc2l6ZW9mKHN0cnVjdCBpcHY2aGRyKSAtIHNpemVvZihzdHJ1Y3QgdWRwaGRyKSAtCgkJICBwa3RfZGV2LT5ucl9sYWJlbHMqc2l6ZW9mKHUzMikgLSBWTEFOX1RBR19TSVpFKHBrdF9kZXYpIC0gU1ZMQU5fVEFHX1NJWkUocGt0X2Rldik7CgoJaWYgKGRhdGFsZW4gPCBzaXplb2Yoc3RydWN0IHBrdGdlbl9oZHIpKSB7CgkJZGF0YWxlbiA9IHNpemVvZihzdHJ1Y3QgcGt0Z2VuX2hkcik7CgkJaWYgKG5ldF9yYXRlbGltaXQoKSkKCQkJcHJpbnRrKEtFUk5fSU5GTyAicGt0Z2VuOiBpbmNyZWFzZWQgZGF0YWxlbiB0byAlZFxuIiwKCQkJICAgICAgIGRhdGFsZW4pOwoJfQoKCXVkcGgtPnNvdXJjZSA9IGh0b25zKHBrdF9kZXYtPmN1cl91ZHBfc3JjKTsKCXVkcGgtPmRlc3QgPSBodG9ucyhwa3RfZGV2LT5jdXJfdWRwX2RzdCk7Cgl1ZHBoLT5sZW4gPSBodG9ucyhkYXRhbGVuICsgc2l6ZW9mKHN0cnVjdCB1ZHBoZHIpKTsKCXVkcGgtPmNoZWNrID0gMDsJLyogTm8gY2hlY2tzdW0gKi8KCgkqKF9fYmUzMiAqKSBpcGggPSBfX2NvbnN0YW50X2h0b25sKDB4NjAwMDAwMDApOwkvKiBWZXJzaW9uICsgZmxvdyAqLwoKCWlmIChwa3RfZGV2LT50cmFmZmljX2NsYXNzKSB7CgkJLyogVmVyc2lvbiArIHRyYWZmaWMgY2xhc3MgKyBmbG93ICgwKSAqLwoJCSooX19iZTMyICopaXBoIHw9IGh0b25sKDB4NjAwMDAwMDAgfCAocGt0X2Rldi0+dHJhZmZpY19jbGFzcyA8PCAyMCkpOwoJfQoKCWlwaC0+aG9wX2xpbWl0ID0gMzI7CgoJaXBoLT5wYXlsb2FkX2xlbiA9IGh0b25zKHNpemVvZihzdHJ1Y3QgdWRwaGRyKSArIGRhdGFsZW4pOwoJaXBoLT5uZXh0aGRyID0gSVBQUk9UT19VRFA7CgoJaXB2Nl9hZGRyX2NvcHkoJmlwaC0+ZGFkZHIsICZwa3RfZGV2LT5jdXJfaW42X2RhZGRyKTsKCWlwdjZfYWRkcl9jb3B5KCZpcGgtPnNhZGRyLCAmcGt0X2Rldi0+Y3VyX2luNl9zYWRkcik7CgoJc2tiLT5tYWMucmF3ID0gKCh1OCAqKSBpcGgpIC0gMTQgLSBwa3RfZGV2LT5ucl9sYWJlbHMqc2l6ZW9mKHUzMikgLQoJCVZMQU5fVEFHX1NJWkUocGt0X2RldikgLSBTVkxBTl9UQUdfU0laRShwa3RfZGV2KTsKCXNrYi0+cHJvdG9jb2wgPSBwcm90b2NvbDsKCXNrYi0+ZGV2ID0gb2RldjsKCXNrYi0+cGt0X3R5cGUgPSBQQUNLRVRfSE9TVDsKCXNrYi0+bmguaXB2NmggPSBpcGg7Cglza2ItPmgudWggPSB1ZHBoOwoKCWlmIChwa3RfZGV2LT5uZnJhZ3MgPD0gMCkKCQlwZ2ggPSAoc3RydWN0IHBrdGdlbl9oZHIgKilza2JfcHV0KHNrYiwgZGF0YWxlbik7CgllbHNlIHsKCQlpbnQgZnJhZ3MgPSBwa3RfZGV2LT5uZnJhZ3M7CgkJaW50IGk7CgoJCXBnaCA9IChzdHJ1Y3QgcGt0Z2VuX2hkciAqKSgoKGNoYXIgKikodWRwaCkpICsgOCk7CgoJCWlmIChmcmFncyA+IE1BWF9TS0JfRlJBR1MpCgkJCWZyYWdzID0gTUFYX1NLQl9GUkFHUzsKCQlpZiAoZGF0YWxlbiA+IGZyYWdzICogUEFHRV9TSVpFKSB7CgkJCXNrYl9wdXQoc2tiLCBkYXRhbGVuIC0gZnJhZ3MgKiBQQUdFX1NJWkUpOwoJCQlkYXRhbGVuID0gZnJhZ3MgKiBQQUdFX1NJWkU7CgkJfQoKCQlpID0gMDsKCQl3aGlsZSAoZGF0YWxlbiA+IDApIHsKCQkJc3RydWN0IHBhZ2UgKnBhZ2UgPSBhbGxvY19wYWdlcyhHRlBfS0VSTkVMLCAwKTsKCQkJc2tiX3NoaW5mbyhza2IpLT5mcmFnc1tpXS5wYWdlID0gcGFnZTsKCQkJc2tiX3NoaW5mbyhza2IpLT5mcmFnc1tpXS5wYWdlX29mZnNldCA9IDA7CgkJCXNrYl9zaGluZm8oc2tiKS0+ZnJhZ3NbaV0uc2l6ZSA9CgkJCSAgICAoZGF0YWxlbiA8IFBBR0VfU0laRSA/IGRhdGFsZW4gOiBQQUdFX1NJWkUpOwoJCQlkYXRhbGVuIC09IHNrYl9zaGluZm8oc2tiKS0+ZnJhZ3NbaV0uc2l6ZTsKCQkJc2tiLT5sZW4gKz0gc2tiX3NoaW5mbyhza2IpLT5mcmFnc1tpXS5zaXplOwoJCQlza2ItPmRhdGFfbGVuICs9IHNrYl9zaGluZm8oc2tiKS0+ZnJhZ3NbaV0uc2l6ZTsKCQkJaSsrOwoJCQlza2Jfc2hpbmZvKHNrYiktPm5yX2ZyYWdzID0gaTsKCQl9CgoJCXdoaWxlIChpIDwgZnJhZ3MpIHsKCQkJaW50IHJlbTsKCgkJCWlmIChpID09IDApCgkJCQlicmVhazsKCgkJCXJlbSA9IHNrYl9zaGluZm8oc2tiKS0+ZnJhZ3NbaSAtIDFdLnNpemUgLyAyOwoJCQlpZiAocmVtID09IDApCgkJCQlicmVhazsKCgkJCXNrYl9zaGluZm8oc2tiKS0+ZnJhZ3NbaSAtIDFdLnNpemUgLT0gcmVtOwoKCQkJc2tiX3NoaW5mbyhza2IpLT5mcmFnc1tpXSA9CgkJCSAgICBza2Jfc2hpbmZvKHNrYiktPmZyYWdzW2kgLSAxXTsKCQkJZ2V0X3BhZ2Uoc2tiX3NoaW5mbyhza2IpLT5mcmFnc1tpXS5wYWdlKTsKCQkJc2tiX3NoaW5mbyhza2IpLT5mcmFnc1tpXS5wYWdlID0KCQkJICAgIHNrYl9zaGluZm8oc2tiKS0+ZnJhZ3NbaSAtIDFdLnBhZ2U7CgkJCXNrYl9zaGluZm8oc2tiKS0+ZnJhZ3NbaV0ucGFnZV9vZmZzZXQgKz0KCQkJICAgIHNrYl9zaGluZm8oc2tiKS0+ZnJhZ3NbaSAtIDFdLnNpemU7CgkJCXNrYl9zaGluZm8oc2tiKS0+ZnJhZ3NbaV0uc2l6ZSA9IHJlbTsKCQkJaSsrOwoJCQlza2Jfc2hpbmZvKHNrYiktPm5yX2ZyYWdzID0gaTsKCQl9Cgl9CgoJLyogU3RhbXAgdGhlIHRpbWUsIGFuZCBzZXF1ZW5jZSBudW1iZXIsIGNvbnZlcnQgdGhlbSB0byBuZXR3b3JrIGJ5dGUgb3JkZXIgKi8KCS8qIHNob3VsZCB3ZSB1cGRhdGUgY2xvbmVkIHBhY2tldHMgdG9vID8gKi8KCWlmIChwZ2gpIHsKCQlzdHJ1Y3QgdGltZXZhbCB0aW1lc3RhbXA7CgoJCXBnaC0+cGdoX21hZ2ljID0gaHRvbmwoUEtUR0VOX01BR0lDKTsKCQlwZ2gtPnNlcV9udW0gPSBodG9ubChwa3RfZGV2LT5zZXFfbnVtKTsKCgkJZG9fZ2V0dGltZW9mZGF5KCZ0aW1lc3RhbXApOwoJCXBnaC0+dHZfc2VjID0gaHRvbmwodGltZXN0YW1wLnR2X3NlYyk7CgkJcGdoLT50dl91c2VjID0gaHRvbmwodGltZXN0YW1wLnR2X3VzZWMpOwoJfQoJLyogcGt0X2Rldi0+c2VxX251bSsrOyBGRjogeW91IHJlYWxseSBtZWFuIHRoaXM/ICovCgoJcmV0dXJuIHNrYjsKfQoKc3RhdGljIGlubGluZSBzdHJ1Y3Qgc2tfYnVmZiAqZmlsbF9wYWNrZXQoc3RydWN0IG5ldF9kZXZpY2UgKm9kZXYsCgkJCQkJICBzdHJ1Y3QgcGt0Z2VuX2RldiAqcGt0X2RldikKewoJaWYgKHBrdF9kZXYtPmZsYWdzICYgRl9JUFY2KQoJCXJldHVybiBmaWxsX3BhY2tldF9pcHY2KG9kZXYsIHBrdF9kZXYpOwoJZWxzZQoJCXJldHVybiBmaWxsX3BhY2tldF9pcHY0KG9kZXYsIHBrdF9kZXYpOwp9CgpzdGF0aWMgdm9pZCBwa3RnZW5fY2xlYXJfY291bnRlcnMoc3RydWN0IHBrdGdlbl9kZXYgKnBrdF9kZXYpCnsKCXBrdF9kZXYtPnNlcV9udW0gPSAxOwoJcGt0X2Rldi0+aWRsZV9hY2MgPSAwOwoJcGt0X2Rldi0+c29mYXIgPSAwOwoJcGt0X2Rldi0+dHhfYnl0ZXMgPSAwOwoJcGt0X2Rldi0+ZXJyb3JzID0gMDsKfQoKLyogU2V0IHVwIHN0cnVjdHVyZSBmb3Igc2VuZGluZyBwa3RzLCBjbGVhciBjb3VudGVycyAqLwoKc3RhdGljIHZvaWQgcGt0Z2VuX3J1bihzdHJ1Y3QgcGt0Z2VuX3RocmVhZCAqdCkKewoJc3RydWN0IHBrdGdlbl9kZXYgKnBrdF9kZXY7CglpbnQgc3RhcnRlZCA9IDA7CgoJUEdfREVCVUcocHJpbnRrKCJwa3RnZW46IGVudGVyaW5nIHBrdGdlbl9ydW4uICVwXG4iLCB0KSk7CgoJaWZfbG9jayh0KTsKCWxpc3RfZm9yX2VhY2hfZW50cnkocGt0X2RldiwgJnQtPmlmX2xpc3QsIGxpc3QpIHsKCgkJLyoKCQkgKiBzZXR1cCBvZGV2IGFuZCBjcmVhdGUgaW5pdGlhbCBwYWNrZXQuCgkJICovCgkJcGt0Z2VuX3NldHVwX2luamVjdChwa3RfZGV2KTsKCgkJaWYgKHBrdF9kZXYtPm9kZXYpIHsKCQkJcGt0Z2VuX2NsZWFyX2NvdW50ZXJzKHBrdF9kZXYpOwoJCQlwa3RfZGV2LT5ydW5uaW5nID0gMTsJLyogQ3JhbmtlIHllc2VsZiEgKi8KCQkJcGt0X2Rldi0+c2tiID0gTlVMTDsKCQkJcGt0X2Rldi0+c3RhcnRlZF9hdCA9IGdldEN1clVzKCk7CgkJCXBrdF9kZXYtPm5leHRfdHhfdXMgPSBnZXRDdXJVcygpOwkvKiBUcmFuc21pdCBpbW1lZGlhdGVseSAqLwoJCQlwa3RfZGV2LT5uZXh0X3R4X25zID0gMDsKCgkJCXN0cmNweShwa3RfZGV2LT5yZXN1bHQsICJTdGFydGluZyIpOwoJCQlzdGFydGVkKys7CgkJfSBlbHNlCgkJCXN0cmNweShwa3RfZGV2LT5yZXN1bHQsICJFcnJvciBzdGFydGluZyIpOwoJfQoJaWZfdW5sb2NrKHQpOwoJaWYgKHN0YXJ0ZWQpCgkJdC0+Y29udHJvbCAmPSB+KFRfU1RPUCk7Cn0KCnN0YXRpYyB2b2lkIHBrdGdlbl9zdG9wX2FsbF90aHJlYWRzX2lmcyh2b2lkKQp7CglzdHJ1Y3QgcGt0Z2VuX3RocmVhZCAqdDsKCglQR19ERUJVRyhwcmludGsoInBrdGdlbjogZW50ZXJpbmcgcGt0Z2VuX3N0b3BfYWxsX3RocmVhZHNfaWZzLlxuIikpOwoKCW11dGV4X2xvY2soJnBrdGdlbl90aHJlYWRfbG9jayk7CgoJbGlzdF9mb3JfZWFjaF9lbnRyeSh0LCAmcGt0Z2VuX3RocmVhZHMsIHRoX2xpc3QpCgkJdC0+Y29udHJvbCB8PSBUX1NUT1A7CgoJbXV0ZXhfdW5sb2NrKCZwa3RnZW5fdGhyZWFkX2xvY2spOwp9CgpzdGF0aWMgaW50IHRocmVhZF9pc19ydW5uaW5nKHN0cnVjdCBwa3RnZW5fdGhyZWFkICp0KQp7CglzdHJ1Y3QgcGt0Z2VuX2RldiAqcGt0X2RldjsKCWludCByZXMgPSAwOwoKCWxpc3RfZm9yX2VhY2hfZW50cnkocGt0X2RldiwgJnQtPmlmX2xpc3QsIGxpc3QpCgkJaWYgKHBrdF9kZXYtPnJ1bm5pbmcpIHsKCQkJcmVzID0gMTsKCQkJYnJlYWs7CgkJfQoJcmV0dXJuIHJlczsKfQoKc3RhdGljIGludCBwa3RnZW5fd2FpdF90aHJlYWRfcnVuKHN0cnVjdCBwa3RnZW5fdGhyZWFkICp0KQp7CglpZl9sb2NrKHQpOwoKCXdoaWxlICh0aHJlYWRfaXNfcnVubmluZyh0KSkgewoKCQlpZl91bmxvY2sodCk7CgoJCW1zbGVlcF9pbnRlcnJ1cHRpYmxlKDEwMCk7CgoJCWlmIChzaWduYWxfcGVuZGluZyhjdXJyZW50KSkKCQkJZ290byBzaWduYWw7CgkJaWZfbG9jayh0KTsKCX0KCWlmX3VubG9jayh0KTsKCXJldHVybiAxOwpzaWduYWw6CglyZXR1cm4gMDsKfQoKc3RhdGljIGludCBwa3RnZW5fd2FpdF9hbGxfdGhyZWFkc19ydW4odm9pZCkKewoJc3RydWN0IHBrdGdlbl90aHJlYWQgKnQ7CglpbnQgc2lnID0gMTsKCgltdXRleF9sb2NrKCZwa3RnZW5fdGhyZWFkX2xvY2spOwoKCWxpc3RfZm9yX2VhY2hfZW50cnkodCwgJnBrdGdlbl90aHJlYWRzLCB0aF9saXN0KSB7CgkJc2lnID0gcGt0Z2VuX3dhaXRfdGhyZWFkX3J1bih0KTsKCQlpZiAoc2lnID09IDApCgkJCWJyZWFrOwoJfQoKCWlmIChzaWcgPT0gMCkKCQlsaXN0X2Zvcl9lYWNoX2VudHJ5KHQsICZwa3RnZW5fdGhyZWFkcywgdGhfbGlzdCkKCQkJdC0+Y29udHJvbCB8PSAoVF9TVE9QKTsKCgltdXRleF91bmxvY2soJnBrdGdlbl90aHJlYWRfbG9jayk7CglyZXR1cm4gc2lnOwp9CgpzdGF0aWMgdm9pZCBwa3RnZW5fcnVuX2FsbF90aHJlYWRzKHZvaWQpCnsKCXN0cnVjdCBwa3RnZW5fdGhyZWFkICp0OwoKCVBHX0RFQlVHKHByaW50aygicGt0Z2VuOiBlbnRlcmluZyBwa3RnZW5fcnVuX2FsbF90aHJlYWRzLlxuIikpOwoKCW11dGV4X2xvY2soJnBrdGdlbl90aHJlYWRfbG9jayk7CgoJbGlzdF9mb3JfZWFjaF9lbnRyeSh0LCAmcGt0Z2VuX3RocmVhZHMsIHRoX2xpc3QpCgkJdC0+Y29udHJvbCB8PSAoVF9SVU4pOwoKCW11dGV4X3VubG9jaygmcGt0Z2VuX3RocmVhZF9sb2NrKTsKCglzY2hlZHVsZV90aW1lb3V0X2ludGVycnVwdGlibGUobXNlY3NfdG9famlmZmllcygxMjUpKTsJLyogUHJvcGFnYXRlIHRocmVhZC0+Y29udHJvbCAgKi8KCglwa3RnZW5fd2FpdF9hbGxfdGhyZWFkc19ydW4oKTsKfQoKc3RhdGljIHZvaWQgc2hvd19yZXN1bHRzKHN0cnVjdCBwa3RnZW5fZGV2ICpwa3RfZGV2LCBpbnQgbnJfZnJhZ3MpCnsKCV9fdTY0IHRvdGFsX3VzLCBicHMsIG1icHMsIHBwcywgaWRsZTsKCWNoYXIgKnAgPSBwa3RfZGV2LT5yZXN1bHQ7CgoJdG90YWxfdXMgPSBwa3RfZGV2LT5zdG9wcGVkX2F0IC0gcGt0X2Rldi0+c3RhcnRlZF9hdDsKCglpZGxlID0gcGt0X2Rldi0+aWRsZV9hY2M7CgoJcCArPSBzcHJpbnRmKHAsICJPSzogJWxsdShjJWxsdStkJWxsdSkgdXNlYywgJWxsdSAoJWRieXRlLCVkZnJhZ3MpXG4iLAoJCSAgICAgKHVuc2lnbmVkIGxvbmcgbG9uZyl0b3RhbF91cywKCQkgICAgICh1bnNpZ25lZCBsb25nIGxvbmcpKHRvdGFsX3VzIC0gaWRsZSksCgkJICAgICAodW5zaWduZWQgbG9uZyBsb25nKWlkbGUsCgkJICAgICAodW5zaWduZWQgbG9uZyBsb25nKXBrdF9kZXYtPnNvZmFyLAoJCSAgICAgcGt0X2Rldi0+Y3VyX3BrdF9zaXplLCBucl9mcmFncyk7CgoJcHBzID0gcGt0X2Rldi0+c29mYXIgKiBVU0VDX1BFUl9TRUM7CgoJd2hpbGUgKCh0b3RhbF91cyA+PiAzMikgIT0gMCkgewoJCXBwcyA+Pj0gMTsKCQl0b3RhbF91cyA+Pj0gMTsKCX0KCglkb19kaXYocHBzLCB0b3RhbF91cyk7CgoJYnBzID0gcHBzICogOCAqIHBrdF9kZXYtPmN1cl9wa3Rfc2l6ZTsKCgltYnBzID0gYnBzOwoJZG9fZGl2KG1icHMsIDEwMDAwMDApOwoJcCArPSBzcHJpbnRmKHAsICIgICVsbHVwcHMgJWxsdU1iL3NlYyAoJWxsdWJwcykgZXJyb3JzOiAlbGx1IiwKCQkgICAgICh1bnNpZ25lZCBsb25nIGxvbmcpcHBzLAoJCSAgICAgKHVuc2lnbmVkIGxvbmcgbG9uZyltYnBzLAoJCSAgICAgKHVuc2lnbmVkIGxvbmcgbG9uZylicHMsCgkJICAgICAodW5zaWduZWQgbG9uZyBsb25nKXBrdF9kZXYtPmVycm9ycyk7Cn0KCi8qIFNldCBzdG9wcGVkLWF0IHRpbWVyLCByZW1vdmUgZnJvbSBydW5uaW5nIGxpc3QsIGRvIGNvdW50ZXJzICYgc3RhdGlzdGljcyAqLwoKc3RhdGljIGludCBwa3RnZW5fc3RvcF9kZXZpY2Uoc3RydWN0IHBrdGdlbl9kZXYgKnBrdF9kZXYpCnsKCWludCBucl9mcmFncyA9IHBrdF9kZXYtPnNrYiA/IHNrYl9zaGluZm8ocGt0X2Rldi0+c2tiKS0+bnJfZnJhZ3MgOiAtMTsKCglpZiAoIXBrdF9kZXYtPnJ1bm5pbmcpIHsKCQlwcmludGsoInBrdGdlbjogaW50ZXJmYWNlOiAlcyBpcyBhbHJlYWR5IHN0b3BwZWRcbiIsCgkJICAgICAgIHBrdF9kZXYtPmlmbmFtZSk7CgkJcmV0dXJuIC1FSU5WQUw7Cgl9CgoJcGt0X2Rldi0+c3RvcHBlZF9hdCA9IGdldEN1clVzKCk7Cglwa3RfZGV2LT5ydW5uaW5nID0gMDsKCglzaG93X3Jlc3VsdHMocGt0X2RldiwgbnJfZnJhZ3MpOwoKCXJldHVybiAwOwp9CgpzdGF0aWMgc3RydWN0IHBrdGdlbl9kZXYgKm5leHRfdG9fcnVuKHN0cnVjdCBwa3RnZW5fdGhyZWFkICp0KQp7CglzdHJ1Y3QgcGt0Z2VuX2RldiAqcGt0X2RldiwgKmJlc3QgPSBOVUxMOwoKCWlmX2xvY2sodCk7CgoJbGlzdF9mb3JfZWFjaF9lbnRyeShwa3RfZGV2LCAmdC0+aWZfbGlzdCwgbGlzdCkgewoJCWlmICghcGt0X2Rldi0+cnVubmluZykKCQkJY29udGludWU7CgkJaWYgKGJlc3QgPT0gTlVMTCkKCQkJYmVzdCA9IHBrdF9kZXY7CgkJZWxzZSBpZiAocGt0X2Rldi0+bmV4dF90eF91cyA8IGJlc3QtPm5leHRfdHhfdXMpCgkJCWJlc3QgPSBwa3RfZGV2OwoJfQoJaWZfdW5sb2NrKHQpOwoJcmV0dXJuIGJlc3Q7Cn0KCnN0YXRpYyB2b2lkIHBrdGdlbl9zdG9wKHN0cnVjdCBwa3RnZW5fdGhyZWFkICp0KQp7CglzdHJ1Y3QgcGt0Z2VuX2RldiAqcGt0X2RldjsKCglQR19ERUJVRyhwcmludGsoInBrdGdlbjogZW50ZXJpbmcgcGt0Z2VuX3N0b3BcbiIpKTsKCglpZl9sb2NrKHQpOwoKCWxpc3RfZm9yX2VhY2hfZW50cnkocGt0X2RldiwgJnQtPmlmX2xpc3QsIGxpc3QpIHsKCQlwa3RnZW5fc3RvcF9kZXZpY2UocGt0X2Rldik7CgkJaWYgKHBrdF9kZXYtPnNrYikKCQkJa2ZyZWVfc2tiKHBrdF9kZXYtPnNrYik7CgoJCXBrdF9kZXYtPnNrYiA9IE5VTEw7Cgl9CgoJaWZfdW5sb2NrKHQpOwp9CgovKgogKiBvbmUgb2Ygb3VyIGRldmljZXMgbmVlZHMgdG8gYmUgcmVtb3ZlZCAtIGZpbmQgaXQKICogYW5kIHJlbW92ZSBpdAogKi8Kc3RhdGljIHZvaWQgcGt0Z2VuX3JlbV9vbmVfaWYoc3RydWN0IHBrdGdlbl90aHJlYWQgKnQpCnsKCXN0cnVjdCBsaXN0X2hlYWQgKnEsICpuOwoJc3RydWN0IHBrdGdlbl9kZXYgKmN1cjsKCglQR19ERUJVRyhwcmludGsoInBrdGdlbjogZW50ZXJpbmcgcGt0Z2VuX3JlbV9vbmVfaWZcbiIpKTsKCglpZl9sb2NrKHQpOwoKCWxpc3RfZm9yX2VhY2hfc2FmZShxLCBuLCAmdC0+aWZfbGlzdCkgewoJCWN1ciA9IGxpc3RfZW50cnkocSwgc3RydWN0IHBrdGdlbl9kZXYsIGxpc3QpOwoKCQlpZiAoIWN1ci0+cmVtb3ZhbF9tYXJrKQoJCQljb250aW51ZTsKCgkJaWYgKGN1ci0+c2tiKQoJCQlrZnJlZV9za2IoY3VyLT5za2IpOwoJCWN1ci0+c2tiID0gTlVMTDsKCgkJcGt0Z2VuX3JlbW92ZV9kZXZpY2UodCwgY3VyKTsKCgkJYnJlYWs7Cgl9CgoJaWZfdW5sb2NrKHQpOwp9CgpzdGF0aWMgdm9pZCBwa3RnZW5fcmVtX2FsbF9pZnMoc3RydWN0IHBrdGdlbl90aHJlYWQgKnQpCnsKCXN0cnVjdCBsaXN0X2hlYWQgKnEsICpuOwoJc3RydWN0IHBrdGdlbl9kZXYgKmN1cjsKCgkvKiBSZW1vdmUgYWxsIGRldmljZXMsIGZyZWUgbWVtICovCgoJUEdfREVCVUcocHJpbnRrKCJwa3RnZW46IGVudGVyaW5nIHBrdGdlbl9yZW1fYWxsX2lmc1xuIikpOwoJaWZfbG9jayh0KTsKCglsaXN0X2Zvcl9lYWNoX3NhZmUocSwgbiwgJnQtPmlmX2xpc3QpIHsKCQljdXIgPSBsaXN0X2VudHJ5KHEsIHN0cnVjdCBwa3RnZW5fZGV2LCBsaXN0KTsKCgkJaWYgKGN1ci0+c2tiKQoJCQlrZnJlZV9za2IoY3VyLT5za2IpOwoJCWN1ci0+c2tiID0gTlVMTDsKCgkJcGt0Z2VuX3JlbW92ZV9kZXZpY2UodCwgY3VyKTsKCX0KCglpZl91bmxvY2sodCk7Cn0KCnN0YXRpYyB2b2lkIHBrdGdlbl9yZW1fdGhyZWFkKHN0cnVjdCBwa3RnZW5fdGhyZWFkICp0KQp7CgkvKiBSZW1vdmUgZnJvbSB0aGUgdGhyZWFkIGxpc3QgKi8KCglyZW1vdmVfcHJvY19lbnRyeSh0LT5uYW1lLCBwZ19wcm9jX2Rpcik7CgoJbXV0ZXhfbG9jaygmcGt0Z2VuX3RocmVhZF9sb2NrKTsKCglsaXN0X2RlbCgmdC0+dGhfbGlzdCk7CgoJbXV0ZXhfdW5sb2NrKCZwa3RnZW5fdGhyZWFkX2xvY2spOwp9CgpzdGF0aWMgX19pbmxpbmVfXyB2b2lkIHBrdGdlbl94bWl0KHN0cnVjdCBwa3RnZW5fZGV2ICpwa3RfZGV2KQp7CglzdHJ1Y3QgbmV0X2RldmljZSAqb2RldiA9IE5VTEw7CglfX3U2NCBpZGxlX3N0YXJ0ID0gMDsKCWludCByZXQ7CgoJb2RldiA9IHBrdF9kZXYtPm9kZXY7CgoJaWYgKHBrdF9kZXYtPmRlbGF5X3VzIHx8IHBrdF9kZXYtPmRlbGF5X25zKSB7CgkJdTY0IG5vdzsKCgkJbm93ID0gZ2V0Q3VyVXMoKTsKCQlpZiAobm93IDwgcGt0X2Rldi0+bmV4dF90eF91cykKCQkJc3Bpbihwa3RfZGV2LCBwa3RfZGV2LT5uZXh0X3R4X3VzKTsKCgkJLyogVGhpcyBpcyBtYXggREVMQVksIHRoaXMgaGFzIHNwZWNpYWwgbWVhbmluZyBvZgoJCSAqICJuZXZlciB0cmFuc21pdCIKCQkgKi8KCQlpZiAocGt0X2Rldi0+ZGVsYXlfdXMgPT0gMHg3RkZGRkZGRikgewoJCQlwa3RfZGV2LT5uZXh0X3R4X3VzID0gZ2V0Q3VyVXMoKSArIHBrdF9kZXYtPmRlbGF5X3VzOwoJCQlwa3RfZGV2LT5uZXh0X3R4X25zID0gcGt0X2Rldi0+ZGVsYXlfbnM7CgkJCWdvdG8gb3V0OwoJCX0KCX0KCglpZiAobmV0aWZfcXVldWVfc3RvcHBlZChvZGV2KSB8fCBuZWVkX3Jlc2NoZWQoKSkgewoJCWlkbGVfc3RhcnQgPSBnZXRDdXJVcygpOwoKCQlpZiAoIW5ldGlmX3J1bm5pbmcob2RldikpIHsKCQkJcGt0Z2VuX3N0b3BfZGV2aWNlKHBrdF9kZXYpOwoJCQlpZiAocGt0X2Rldi0+c2tiKQoJCQkJa2ZyZWVfc2tiKHBrdF9kZXYtPnNrYik7CgkJCXBrdF9kZXYtPnNrYiA9IE5VTEw7CgkJCWdvdG8gb3V0OwoJCX0KCQlpZiAobmVlZF9yZXNjaGVkKCkpCgkJCXNjaGVkdWxlKCk7CgoJCXBrdF9kZXYtPmlkbGVfYWNjICs9IGdldEN1clVzKCkgLSBpZGxlX3N0YXJ0OwoKCQlpZiAobmV0aWZfcXVldWVfc3RvcHBlZChvZGV2KSkgewoJCQlwa3RfZGV2LT5uZXh0X3R4X3VzID0gZ2V0Q3VyVXMoKTsJLyogVE9ETyAqLwoJCQlwa3RfZGV2LT5uZXh0X3R4X25zID0gMDsKCQkJZ290byBvdXQ7CS8qIFRyeSB0aGUgbmV4dCBpbnRlcmZhY2UgKi8KCQl9Cgl9CgoJaWYgKHBrdF9kZXYtPmxhc3Rfb2sgfHwgIXBrdF9kZXYtPnNrYikgewoJCWlmICgoKytwa3RfZGV2LT5jbG9uZV9jb3VudCA+PSBwa3RfZGV2LT5jbG9uZV9za2IpCgkJICAgIHx8ICghcGt0X2Rldi0+c2tiKSkgewoJCQkvKiBidWlsZCBhIG5ldyBwa3QgKi8KCQkJaWYgKHBrdF9kZXYtPnNrYikKCQkJCWtmcmVlX3NrYihwa3RfZGV2LT5za2IpOwoKCQkJcGt0X2Rldi0+c2tiID0gZmlsbF9wYWNrZXQob2RldiwgcGt0X2Rldik7CgkJCWlmIChwa3RfZGV2LT5za2IgPT0gTlVMTCkgewoJCQkJcHJpbnRrKCJwa3RnZW46IEVSUk9SOiBjb3VsZG4ndCBhbGxvY2F0ZSBza2IgaW4gZmlsbF9wYWNrZXQuXG4iKTsKCQkJCXNjaGVkdWxlKCk7CgkJCQlwa3RfZGV2LT5jbG9uZV9jb3VudC0tOwkvKiBiYWNrIG91dCBpbmNyZW1lbnQsIE9PTSAqLwoJCQkJZ290byBvdXQ7CgkJCX0KCQkJcGt0X2Rldi0+YWxsb2NhdGVkX3NrYnMrKzsKCQkJcGt0X2Rldi0+Y2xvbmVfY291bnQgPSAwOwkvKiByZXNldCBjb3VudGVyICovCgkJfQoJfQoKCW5ldGlmX3R4X2xvY2tfYmgob2Rldik7CglpZiAoIW5ldGlmX3F1ZXVlX3N0b3BwZWQob2RldikpIHsKCgkJYXRvbWljX2luYygmKHBrdF9kZXYtPnNrYi0+dXNlcnMpKTsKCSAgICAgIHJldHJ5X25vdzoKCQlyZXQgPSBvZGV2LT5oYXJkX3N0YXJ0X3htaXQocGt0X2Rldi0+c2tiLCBvZGV2KTsKCQlpZiAobGlrZWx5KHJldCA9PSBORVRERVZfVFhfT0spKSB7CgkJCXBrdF9kZXYtPmxhc3Rfb2sgPSAxOwoJCQlwa3RfZGV2LT5zb2ZhcisrOwoJCQlwa3RfZGV2LT5zZXFfbnVtKys7CgkJCXBrdF9kZXYtPnR4X2J5dGVzICs9IHBrdF9kZXYtPmN1cl9wa3Rfc2l6ZTsKCgkJfSBlbHNlIGlmIChyZXQgPT0gTkVUREVWX1RYX0xPQ0tFRAoJCQkgICAmJiAob2Rldi0+ZmVhdHVyZXMgJiBORVRJRl9GX0xMVFgpKSB7CgkJCWNwdV9yZWxheCgpOwoJCQlnb3RvIHJldHJ5X25vdzsKCQl9IGVsc2UgewkvKiBSZXRyeSBpdCBuZXh0IHRpbWUgKi8KCgkJCWF0b21pY19kZWMoJihwa3RfZGV2LT5za2ItPnVzZXJzKSk7CgoJCQlpZiAoZGVidWcgJiYgbmV0X3JhdGVsaW1pdCgpKQoJCQkJcHJpbnRrKEtFUk5fSU5GTyAicGt0Z2VuOiBIYXJkIHhtaXQgZXJyb3JcbiIpOwoKCQkJcGt0X2Rldi0+ZXJyb3JzKys7CgkJCXBrdF9kZXYtPmxhc3Rfb2sgPSAwOwoJCX0KCgkJcGt0X2Rldi0+bmV4dF90eF91cyA9IGdldEN1clVzKCk7CgkJcGt0X2Rldi0+bmV4dF90eF9ucyA9IDA7CgoJCXBrdF9kZXYtPm5leHRfdHhfdXMgKz0gcGt0X2Rldi0+ZGVsYXlfdXM7CgkJcGt0X2Rldi0+bmV4dF90eF9ucyArPSBwa3RfZGV2LT5kZWxheV9uczsKCgkJaWYgKHBrdF9kZXYtPm5leHRfdHhfbnMgPiAxMDAwKSB7CgkJCXBrdF9kZXYtPm5leHRfdHhfdXMrKzsKCQkJcGt0X2Rldi0+bmV4dF90eF9ucyAtPSAxMDAwOwoJCX0KCX0KCgllbHNlIHsJCQkvKiBSZXRyeSBpdCBuZXh0IHRpbWUgKi8KCQlwa3RfZGV2LT5sYXN0X29rID0gMDsKCQlwa3RfZGV2LT5uZXh0X3R4X3VzID0gZ2V0Q3VyVXMoKTsJLyogVE9ETyAqLwoJCXBrdF9kZXYtPm5leHRfdHhfbnMgPSAwOwoJfQoKCW5ldGlmX3R4X3VubG9ja19iaChvZGV2KTsKCgkvKiBJZiBwa3RfZGV2LT5jb3VudCBpcyB6ZXJvLCB0aGVuIHJ1biBmb3JldmVyICovCglpZiAoKHBrdF9kZXYtPmNvdW50ICE9IDApICYmIChwa3RfZGV2LT5zb2ZhciA+PSBwa3RfZGV2LT5jb3VudCkpIHsKCQlpZiAoYXRvbWljX3JlYWQoJihwa3RfZGV2LT5za2ItPnVzZXJzKSkgIT0gMSkgewoJCQlpZGxlX3N0YXJ0ID0gZ2V0Q3VyVXMoKTsKCQkJd2hpbGUgKGF0b21pY19yZWFkKCYocGt0X2Rldi0+c2tiLT51c2VycykpICE9IDEpIHsKCQkJCWlmIChzaWduYWxfcGVuZGluZyhjdXJyZW50KSkgewoJCQkJCWJyZWFrOwoJCQkJfQoJCQkJc2NoZWR1bGUoKTsKCQkJfQoJCQlwa3RfZGV2LT5pZGxlX2FjYyArPSBnZXRDdXJVcygpIC0gaWRsZV9zdGFydDsKCQl9CgoJCS8qIERvbmUgd2l0aCB0aGlzICovCgkJcGt0Z2VuX3N0b3BfZGV2aWNlKHBrdF9kZXYpOwoJCWlmIChwa3RfZGV2LT5za2IpCgkJCWtmcmVlX3NrYihwa3RfZGV2LT5za2IpOwoJCXBrdF9kZXYtPnNrYiA9IE5VTEw7Cgl9Cm91dDo7Cn0KCi8qIAogKiBNYWluIGxvb3Agb2YgdGhlIHRocmVhZCBnb2VzIGhlcmUKICovCgpzdGF0aWMgdm9pZCBwa3RnZW5fdGhyZWFkX3dvcmtlcihzdHJ1Y3QgcGt0Z2VuX3RocmVhZCAqdCkKewoJREVGSU5FX1dBSVQod2FpdCk7CglzdHJ1Y3QgcGt0Z2VuX2RldiAqcGt0X2RldiA9IE5VTEw7CglpbnQgY3B1ID0gdC0+Y3B1OwoJc2lnc2V0X3QgdG1wc2lnOwoJdTMyIG1heF9iZWZvcmVfc29mdGlycTsKCXUzMiB0eF9zaW5jZV9zb2Z0aXJxID0gMDsKCglkYWVtb25pemUoInBrdGdlbi8lZCIsIGNwdSk7CgoJLyogQmxvY2sgYWxsIHNpZ25hbHMgZXhjZXB0IFNJR0tJTEwsIFNJR1NUT1AgYW5kIFNJR1RFUk0gKi8KCglzcGluX2xvY2tfaXJxKCZjdXJyZW50LT5zaWdoYW5kLT5zaWdsb2NrKTsKCXRtcHNpZyA9IGN1cnJlbnQtPmJsb2NrZWQ7CglzaWdpbml0c2V0aW52KCZjdXJyZW50LT5ibG9ja2VkLAoJCSAgICAgIHNpZ21hc2soU0lHS0lMTCkgfCBzaWdtYXNrKFNJR1NUT1ApIHwgc2lnbWFzayhTSUdURVJNKSk7CgoJcmVjYWxjX3NpZ3BlbmRpbmcoKTsKCXNwaW5fdW5sb2NrX2lycSgmY3VycmVudC0+c2lnaGFuZC0+c2lnbG9jayk7CgoJLyogTWlncmF0ZSB0byB0aGUgcmlnaHQgQ1BVICovCglzZXRfY3B1c19hbGxvd2VkKGN1cnJlbnQsIGNwdW1hc2tfb2ZfY3B1KGNwdSkpOwoJaWYgKHNtcF9wcm9jZXNzb3JfaWQoKSAhPSBjcHUpCgkJQlVHKCk7CgoJaW5pdF93YWl0cXVldWVfaGVhZCgmdC0+cXVldWUpOwoKCXQtPmNvbnRyb2wgJj0gfihUX1RFUk1JTkFURSk7Cgl0LT5jb250cm9sICY9IH4oVF9SVU4pOwoJdC0+Y29udHJvbCAmPSB+KFRfU1RPUCk7Cgl0LT5jb250cm9sICY9IH4oVF9SRU1ERVZBTEwpOwoJdC0+Y29udHJvbCAmPSB+KFRfUkVNREVWKTsKCgl0LT5waWQgPSBjdXJyZW50LT5waWQ7CgoJUEdfREVCVUcocHJpbnRrKCJwa3RnZW46IHN0YXJ0aW5nIHBrdGdlbi8lZDogIHBpZD0lZFxuIiwgY3B1LCBjdXJyZW50LT5waWQpKTsKCgltYXhfYmVmb3JlX3NvZnRpcnEgPSB0LT5tYXhfYmVmb3JlX3NvZnRpcnE7CgoJX19zZXRfY3VycmVudF9zdGF0ZShUQVNLX0lOVEVSUlVQVElCTEUpOwoJbWIoKTsKCgl3aGlsZSAoMSkgewoKCQlfX3NldF9jdXJyZW50X3N0YXRlKFRBU0tfUlVOTklORyk7CgoJCS8qCgkJICogR2V0IG5leHQgZGV2IHRvIHhtaXQgLS0gaWYgYW55LgoJCSAqLwoKCQlwa3RfZGV2ID0gbmV4dF90b19ydW4odCk7CgoJCWlmIChwa3RfZGV2KSB7CgoJCQlwa3RnZW5feG1pdChwa3RfZGV2KTsKCgkJCS8qCgkJCSAqIFdlIGxpa2UgdG8gc3RheSBSVU5OSU5HIGJ1dCBtdXN0IGFsc28gZ2l2ZQoJCQkgKiBvdGhlcnMgZmFpciBzaGFyZS4KCQkJICovCgoJCQl0eF9zaW5jZV9zb2Z0aXJxICs9IHBrdF9kZXYtPmxhc3Rfb2s7CgoJCQlpZiAodHhfc2luY2Vfc29mdGlycSA+IG1heF9iZWZvcmVfc29mdGlycSkgewoJCQkJaWYgKGxvY2FsX3NvZnRpcnFfcGVuZGluZygpKQoJCQkJCWRvX3NvZnRpcnEoKTsKCQkJCXR4X3NpbmNlX3NvZnRpcnEgPSAwOwoJCQl9CgkJfSBlbHNlIHsKCQkJcHJlcGFyZV90b193YWl0KCYodC0+cXVldWUpLCAmd2FpdCwgVEFTS19JTlRFUlJVUFRJQkxFKTsKCQkJc2NoZWR1bGVfdGltZW91dChIWiAvIDEwKTsKCQkJZmluaXNoX3dhaXQoJih0LT5xdWV1ZSksICZ3YWl0KTsKCQl9CgoJCS8qCgkJICogQmFjayBmcm9tIHNsZWVwLCBlaXRoZXIgZHVlIHRvIHRoZSB0aW1lb3V0IG9yIHNpZ25hbC4KCQkgKiBXZSBjaGVjayBpZiB3ZSBoYXZlIGFueSAicG9zdGVkIiB3b3JrIGZvciB1cy4KCQkgKi8KCgkJaWYgKHQtPmNvbnRyb2wgJiBUX1RFUk1JTkFURSB8fCBzaWduYWxfcGVuZGluZyhjdXJyZW50KSkKCQkJLyogd2UgcmVjZWl2ZWQgYSByZXF1ZXN0IHRvIHRlcm1pbmF0ZSBvdXJzZWxmICovCgkJCWJyZWFrOwoKCQlpZiAodC0+Y29udHJvbCAmIFRfU1RPUCkgewoJCQlwa3RnZW5fc3RvcCh0KTsKCQkJdC0+Y29udHJvbCAmPSB+KFRfU1RPUCk7CgkJfQoKCQlpZiAodC0+Y29udHJvbCAmIFRfUlVOKSB7CgkJCXBrdGdlbl9ydW4odCk7CgkJCXQtPmNvbnRyb2wgJj0gfihUX1JVTik7CgkJfQoKCQlpZiAodC0+Y29udHJvbCAmIFRfUkVNREVWQUxMKSB7CgkJCXBrdGdlbl9yZW1fYWxsX2lmcyh0KTsKCQkJdC0+Y29udHJvbCAmPSB+KFRfUkVNREVWQUxMKTsKCQl9CgoJCWlmICh0LT5jb250cm9sICYgVF9SRU1ERVYpIHsKCQkJcGt0Z2VuX3JlbV9vbmVfaWYodCk7CgkJCXQtPmNvbnRyb2wgJj0gfihUX1JFTURFVik7CgkJfQoKCQlpZiAobmVlZF9yZXNjaGVkKCkpCgkJCXNjaGVkdWxlKCk7Cgl9CgoJUEdfREVCVUcocHJpbnRrKCJwa3RnZW46ICVzIHN0b3BwaW5nIGFsbCBkZXZpY2VcbiIsIHQtPm5hbWUpKTsKCXBrdGdlbl9zdG9wKHQpOwoKCVBHX0RFQlVHKHByaW50aygicGt0Z2VuOiAlcyByZW1vdmluZyBhbGwgZGV2aWNlXG4iLCB0LT5uYW1lKSk7Cglwa3RnZW5fcmVtX2FsbF9pZnModCk7CgoJUEdfREVCVUcocHJpbnRrKCJwa3RnZW46ICVzIHJlbW92aW5nIHRocmVhZC5cbiIsIHQtPm5hbWUpKTsKCXBrdGdlbl9yZW1fdGhyZWFkKHQpOwoKCXQtPnJlbW92ZWQgPSAxOwp9CgpzdGF0aWMgc3RydWN0IHBrdGdlbl9kZXYgKnBrdGdlbl9maW5kX2RldihzdHJ1Y3QgcGt0Z2VuX3RocmVhZCAqdCwKCQkJCQkgIGNvbnN0IGNoYXIgKmlmbmFtZSkKewoJc3RydWN0IHBrdGdlbl9kZXYgKnAsICpwa3RfZGV2ID0gTlVMTDsKCWlmX2xvY2sodCk7CgoJbGlzdF9mb3JfZWFjaF9lbnRyeShwLCAmdC0+aWZfbGlzdCwgbGlzdCkKCQlpZiAoc3RybmNtcChwLT5pZm5hbWUsIGlmbmFtZSwgSUZOQU1TSVopID09IDApIHsKCQkJcGt0X2RldiA9IHA7CgkJCWJyZWFrOwoJCX0KCglpZl91bmxvY2sodCk7CglQR19ERUJVRyhwcmludGsoInBrdGdlbjogZmluZF9kZXYoJXMpIHJldHVybmluZyAlcFxuIiwgaWZuYW1lLCBwa3RfZGV2KSk7CglyZXR1cm4gcGt0X2RldjsKfQoKLyogCiAqIEFkZHMgYSBkZXYgYXQgZnJvbnQgb2YgaWZfbGlzdC4gCiAqLwoKc3RhdGljIGludCBhZGRfZGV2X3RvX3RocmVhZChzdHJ1Y3QgcGt0Z2VuX3RocmVhZCAqdCwKCQkJICAgICBzdHJ1Y3QgcGt0Z2VuX2RldiAqcGt0X2RldikKewoJaW50IHJ2ID0gMDsKCglpZl9sb2NrKHQpOwoKCWlmIChwa3RfZGV2LT5wZ190aHJlYWQpIHsKCQlwcmludGsoInBrdGdlbjogRVJST1I6ICBhbHJlYWR5IGFzc2lnbmVkIHRvIGEgdGhyZWFkLlxuIik7CgkJcnYgPSAtRUJVU1k7CgkJZ290byBvdXQ7Cgl9CgoJbGlzdF9hZGQoJnBrdF9kZXYtPmxpc3QsICZ0LT5pZl9saXN0KTsKCXBrdF9kZXYtPnBnX3RocmVhZCA9IHQ7Cglwa3RfZGV2LT5ydW5uaW5nID0gMDsKCm91dDoKCWlmX3VubG9jayh0KTsKCXJldHVybiBydjsKfQoKLyogQ2FsbGVkIHVuZGVyIHRocmVhZCBsb2NrICovCgpzdGF0aWMgaW50IHBrdGdlbl9hZGRfZGV2aWNlKHN0cnVjdCBwa3RnZW5fdGhyZWFkICp0LCBjb25zdCBjaGFyICppZm5hbWUpCnsKCXN0cnVjdCBwa3RnZW5fZGV2ICpwa3RfZGV2OwoJc3RydWN0IHByb2NfZGlyX2VudHJ5ICpwZTsKCgkvKiBXZSBkb24ndCBhbGxvdyBhIGRldmljZSB0byBiZSBvbiBzZXZlcmFsIHRocmVhZHMgKi8KCglwa3RfZGV2ID0gX19wa3RnZW5fTk5fdGhyZWFkcyhpZm5hbWUsIEZJTkQpOwoJaWYgKHBrdF9kZXYpIHsKCQlwcmludGsoInBrdGdlbjogRVJST1I6IGludGVyZmFjZSBhbHJlYWR5IHVzZWQuXG4iKTsKCQlyZXR1cm4gLUVCVVNZOwoJfQoKCXBrdF9kZXYgPSBremFsbG9jKHNpemVvZihzdHJ1Y3QgcGt0Z2VuX2RldiksIEdGUF9LRVJORUwpOwoJaWYgKCFwa3RfZGV2KQoJCXJldHVybiAtRU5PTUVNOwoKCXBrdF9kZXYtPmZsb3dzID0gdm1hbGxvYyhNQVhfQ0ZMT1dTICogc2l6ZW9mKHN0cnVjdCBmbG93X3N0YXRlKSk7CglpZiAocGt0X2Rldi0+Zmxvd3MgPT0gTlVMTCkgewoJCWtmcmVlKHBrdF9kZXYpOwoJCXJldHVybiAtRU5PTUVNOwoJfQoJbWVtc2V0KHBrdF9kZXYtPmZsb3dzLCAwLCBNQVhfQ0ZMT1dTICogc2l6ZW9mKHN0cnVjdCBmbG93X3N0YXRlKSk7CgoJcGt0X2Rldi0+cmVtb3ZhbF9tYXJrID0gMDsKCXBrdF9kZXYtPm1pbl9wa3Rfc2l6ZSA9IEVUSF9aTEVOOwoJcGt0X2Rldi0+bWF4X3BrdF9zaXplID0gRVRIX1pMRU47Cglwa3RfZGV2LT5uZnJhZ3MgPSAwOwoJcGt0X2Rldi0+Y2xvbmVfc2tiID0gcGdfY2xvbmVfc2tiX2Q7Cglwa3RfZGV2LT5kZWxheV91cyA9IHBnX2RlbGF5X2QgLyAxMDAwOwoJcGt0X2Rldi0+ZGVsYXlfbnMgPSBwZ19kZWxheV9kICUgMTAwMDsKCXBrdF9kZXYtPmNvdW50ID0gcGdfY291bnRfZDsKCXBrdF9kZXYtPnNvZmFyID0gMDsKCXBrdF9kZXYtPnVkcF9zcmNfbWluID0gOTsJLyogc2luayBwb3J0ICovCglwa3RfZGV2LT51ZHBfc3JjX21heCA9IDk7Cglwa3RfZGV2LT51ZHBfZHN0X21pbiA9IDk7Cglwa3RfZGV2LT51ZHBfZHN0X21heCA9IDk7CgoJcGt0X2Rldi0+dmxhbl9wID0gMDsKCXBrdF9kZXYtPnZsYW5fY2ZpID0gMDsKCXBrdF9kZXYtPnZsYW5faWQgPSAweGZmZmY7Cglwa3RfZGV2LT5zdmxhbl9wID0gMDsKCXBrdF9kZXYtPnN2bGFuX2NmaSA9IDA7Cglwa3RfZGV2LT5zdmxhbl9pZCA9IDB4ZmZmZjsKCglzdHJuY3B5KHBrdF9kZXYtPmlmbmFtZSwgaWZuYW1lLCBJRk5BTVNJWik7CgoJaWYgKCFwa3RnZW5fc2V0dXBfZGV2KHBrdF9kZXYpKSB7CgkJcHJpbnRrKCJwa3RnZW46IEVSUk9SOiBwa3RnZW5fc2V0dXBfZGV2IGZhaWxlZC5cbiIpOwoJCWlmIChwa3RfZGV2LT5mbG93cykKCQkJdmZyZWUocGt0X2Rldi0+Zmxvd3MpOwoJCWtmcmVlKHBrdF9kZXYpOwoJCXJldHVybiAtRU5PREVWOwoJfQoKCXBlID0gY3JlYXRlX3Byb2NfZW50cnkoaWZuYW1lLCAwNjAwLCBwZ19wcm9jX2Rpcik7CglpZiAoIXBlKSB7CgkJcHJpbnRrKCJwa3RnZW46IGNhbm5vdCBjcmVhdGUgJXMvJXMgcHJvY2ZzIGVudHJ5LlxuIiwKCQkgICAgICAgUEdfUFJPQ19ESVIsIGlmbmFtZSk7CgkJaWYgKHBrdF9kZXYtPmZsb3dzKQoJCQl2ZnJlZShwa3RfZGV2LT5mbG93cyk7CgkJa2ZyZWUocGt0X2Rldik7CgkJcmV0dXJuIC1FSU5WQUw7Cgl9CglwZS0+cHJvY19mb3BzID0gJnBrdGdlbl9pZl9mb3BzOwoJcGUtPmRhdGEgPSBwa3RfZGV2OwoKCXJldHVybiBhZGRfZGV2X3RvX3RocmVhZCh0LCBwa3RfZGV2KTsKfQoKc3RhdGljIHN0cnVjdCBwa3RnZW5fdGhyZWFkICpfX2luaXQgcGt0Z2VuX2ZpbmRfdGhyZWFkKGNvbnN0IGNoYXIgKm5hbWUpCnsKCXN0cnVjdCBwa3RnZW5fdGhyZWFkICp0OwoKCW11dGV4X2xvY2soJnBrdGdlbl90aHJlYWRfbG9jayk7CgoJbGlzdF9mb3JfZWFjaF9lbnRyeSh0LCAmcGt0Z2VuX3RocmVhZHMsIHRoX2xpc3QpCgkJaWYgKHN0cmNtcCh0LT5uYW1lLCBuYW1lKSA9PSAwKSB7CgkJCW11dGV4X3VubG9jaygmcGt0Z2VuX3RocmVhZF9sb2NrKTsKCQkJcmV0dXJuIHQ7CgkJfQoKCW11dGV4X3VubG9jaygmcGt0Z2VuX3RocmVhZF9sb2NrKTsKCXJldHVybiBOVUxMOwp9CgpzdGF0aWMgaW50IF9faW5pdCBwa3RnZW5fY3JlYXRlX3RocmVhZChjb25zdCBjaGFyICpuYW1lLCBpbnQgY3B1KQp7CglpbnQgZXJyOwoJc3RydWN0IHBrdGdlbl90aHJlYWQgKnQgPSBOVUxMOwoJc3RydWN0IHByb2NfZGlyX2VudHJ5ICpwZTsKCglpZiAoc3RybGVuKG5hbWUpID4gMzEpIHsKCQlwcmludGsoInBrdGdlbjogRVJST1I6ICBUaHJlYWQgbmFtZSBjYW5ub3QgYmUgbW9yZSB0aGFuIDMxIGNoYXJhY3RlcnMuXG4iKTsKCQlyZXR1cm4gLUVJTlZBTDsKCX0KCglpZiAocGt0Z2VuX2ZpbmRfdGhyZWFkKG5hbWUpKSB7CgkJcHJpbnRrKCJwa3RnZW46IEVSUk9SOiB0aHJlYWQ6ICVzIGFscmVhZHkgZXhpc3RzXG4iLCBuYW1lKTsKCQlyZXR1cm4gLUVJTlZBTDsKCX0KCgl0ID0ga3phbGxvYyhzaXplb2Yoc3RydWN0IHBrdGdlbl90aHJlYWQpLCBHRlBfS0VSTkVMKTsKCWlmICghdCkgewoJCXByaW50aygicGt0Z2VuOiBFUlJPUjogb3V0IG9mIG1lbW9yeSwgY2FuJ3QgY3JlYXRlIG5ldyB0aHJlYWQuXG4iKTsKCQlyZXR1cm4gLUVOT01FTTsKCX0KCglzdHJjcHkodC0+bmFtZSwgbmFtZSk7CglzcGluX2xvY2tfaW5pdCgmdC0+aWZfbG9jayk7Cgl0LT5jcHUgPSBjcHU7CgoJcGUgPSBjcmVhdGVfcHJvY19lbnRyeSh0LT5uYW1lLCAwNjAwLCBwZ19wcm9jX2Rpcik7CglpZiAoIXBlKSB7CgkJcHJpbnRrKCJwa3RnZW46IGNhbm5vdCBjcmVhdGUgJXMvJXMgcHJvY2ZzIGVudHJ5LlxuIiwKCQkgICAgICAgUEdfUFJPQ19ESVIsIHQtPm5hbWUpOwoJCWtmcmVlKHQpOwoJCXJldHVybiAtRUlOVkFMOwoJfQoKCXBlLT5wcm9jX2ZvcHMgPSAmcGt0Z2VuX3RocmVhZF9mb3BzOwoJcGUtPmRhdGEgPSB0OwoKCUlOSVRfTElTVF9IRUFEKCZ0LT5pZl9saXN0KTsKCglsaXN0X2FkZF90YWlsKCZ0LT50aF9saXN0LCAmcGt0Z2VuX3RocmVhZHMpOwoKCXQtPnJlbW92ZWQgPSAwOwoKCWVyciA9IGtlcm5lbF90aHJlYWQoKHZvaWQgKilwa3RnZW5fdGhyZWFkX3dvcmtlciwgKHZvaWQgKil0LAoJCQkgIENMT05FX0ZTIHwgQ0xPTkVfRklMRVMgfCBDTE9ORV9TSUdIQU5EKTsKCWlmIChlcnIgPCAwKSB7CgkJcHJpbnRrKCJwa3RnZW46IGtlcm5lbF90aHJlYWQoKSBmYWlsZWQgZm9yIGNwdSAlZFxuIiwgdC0+Y3B1KTsKCQlyZW1vdmVfcHJvY19lbnRyeSh0LT5uYW1lLCBwZ19wcm9jX2Rpcik7CgkJbGlzdF9kZWwoJnQtPnRoX2xpc3QpOwoJCWtmcmVlKHQpOwoJCXJldHVybiBlcnI7Cgl9CgoJcmV0dXJuIDA7Cn0KCi8qIAogKiBSZW1vdmVzIGEgZGV2aWNlIGZyb20gdGhlIHRocmVhZCBpZl9saXN0LiAKICovCnN0YXRpYyB2b2lkIF9yZW1fZGV2X2Zyb21faWZfbGlzdChzdHJ1Y3QgcGt0Z2VuX3RocmVhZCAqdCwKCQkJCSAgc3RydWN0IHBrdGdlbl9kZXYgKnBrdF9kZXYpCnsKCXN0cnVjdCBsaXN0X2hlYWQgKnEsICpuOwoJc3RydWN0IHBrdGdlbl9kZXYgKnA7CgoJbGlzdF9mb3JfZWFjaF9zYWZlKHEsIG4sICZ0LT5pZl9saXN0KSB7CgkJcCA9IGxpc3RfZW50cnkocSwgc3RydWN0IHBrdGdlbl9kZXYsIGxpc3QpOwoJCWlmIChwID09IHBrdF9kZXYpCgkJCWxpc3RfZGVsKCZwLT5saXN0KTsKCX0KfQoKc3RhdGljIGludCBwa3RnZW5fcmVtb3ZlX2RldmljZShzdHJ1Y3QgcGt0Z2VuX3RocmVhZCAqdCwKCQkJCXN0cnVjdCBwa3RnZW5fZGV2ICpwa3RfZGV2KQp7CgoJUEdfREVCVUcocHJpbnRrKCJwa3RnZW46IHJlbW92ZV9kZXZpY2UgcGt0X2Rldj0lcFxuIiwgcGt0X2RldikpOwoKCWlmIChwa3RfZGV2LT5ydW5uaW5nKSB7CgkJcHJpbnRrKCJwa3RnZW46V0FSTklORzogdHJ5aW5nIHRvIHJlbW92ZSBhIHJ1bm5pbmcgaW50ZXJmYWNlLCBzdG9wcGluZyBpdCBub3cuXG4iKTsKCQlwa3RnZW5fc3RvcF9kZXZpY2UocGt0X2Rldik7Cgl9CgoJLyogRGlzLWFzc29jaWF0ZSBmcm9tIHRoZSBpbnRlcmZhY2UgKi8KCglpZiAocGt0X2Rldi0+b2RldikgewoJCWRldl9wdXQocGt0X2Rldi0+b2Rldik7CgkJcGt0X2Rldi0+b2RldiA9IE5VTEw7Cgl9CgoJLyogQW5kIHVwZGF0ZSB0aGUgdGhyZWFkIGlmX2xpc3QgKi8KCglfcmVtX2Rldl9mcm9tX2lmX2xpc3QodCwgcGt0X2Rldik7CgoJLyogQ2xlYW4gdXAgcHJvYyBmaWxlIHN5c3RlbSAqLwoKCXJlbW92ZV9wcm9jX2VudHJ5KHBrdF9kZXYtPmlmbmFtZSwgcGdfcHJvY19kaXIpOwoKCWlmIChwa3RfZGV2LT5mbG93cykKCQl2ZnJlZShwa3RfZGV2LT5mbG93cyk7CglrZnJlZShwa3RfZGV2KTsKCXJldHVybiAwOwp9CgpzdGF0aWMgaW50IF9faW5pdCBwZ19pbml0KHZvaWQpCnsKCWludCBjcHU7CglzdHJ1Y3QgcHJvY19kaXJfZW50cnkgKnBlOwoKCXByaW50ayh2ZXJzaW9uKTsKCglwZ19wcm9jX2RpciA9IHByb2NfbWtkaXIoUEdfUFJPQ19ESVIsIHByb2NfbmV0KTsKCWlmICghcGdfcHJvY19kaXIpCgkJcmV0dXJuIC1FTk9ERVY7CglwZ19wcm9jX2Rpci0+b3duZXIgPSBUSElTX01PRFVMRTsKCglwZSA9IGNyZWF0ZV9wcm9jX2VudHJ5KFBHQ1RSTCwgMDYwMCwgcGdfcHJvY19kaXIpOwoJaWYgKHBlID09IE5VTEwpIHsKCQlwcmludGsoInBrdGdlbjogRVJST1I6IGNhbm5vdCBjcmVhdGUgJXMgcHJvY2ZzIGVudHJ5LlxuIiwKCQkgICAgICAgUEdDVFJMKTsKCQlwcm9jX25ldF9yZW1vdmUoUEdfUFJPQ19ESVIpOwoJCXJldHVybiAtRUlOVkFMOwoJfQoKCXBlLT5wcm9jX2ZvcHMgPSAmcGt0Z2VuX2ZvcHM7CglwZS0+ZGF0YSA9IE5VTEw7CgoJLyogUmVnaXN0ZXIgdXMgdG8gcmVjZWl2ZSBuZXRkZXZpY2UgZXZlbnRzICovCglyZWdpc3Rlcl9uZXRkZXZpY2Vfbm90aWZpZXIoJnBrdGdlbl9ub3RpZmllcl9ibG9jayk7CgoJZm9yX2VhY2hfb25saW5lX2NwdShjcHUpIHsKCQlpbnQgZXJyOwoJCWNoYXIgYnVmWzMwXTsKCgkJc3ByaW50ZihidWYsICJrcGt0Z2VuZF8laSIsIGNwdSk7CgkJZXJyID0gcGt0Z2VuX2NyZWF0ZV90aHJlYWQoYnVmLCBjcHUpOwoJCWlmIChlcnIpCgkJCXByaW50aygicGt0Z2VuOiBXQVJOSU5HOiBDYW5ub3QgY3JlYXRlIHRocmVhZCBmb3IgY3B1ICVkICglZClcbiIsCgkJCQkJY3B1LCBlcnIpOwoJfQoKCWlmIChsaXN0X2VtcHR5KCZwa3RnZW5fdGhyZWFkcykpIHsKCQlwcmludGsoInBrdGdlbjogRVJST1I6IEluaXRpYWxpemF0aW9uIGZhaWxlZCBmb3IgYWxsIHRocmVhZHNcbiIpOwoJCXVucmVnaXN0ZXJfbmV0ZGV2aWNlX25vdGlmaWVyKCZwa3RnZW5fbm90aWZpZXJfYmxvY2spOwoJCXJlbW92ZV9wcm9jX2VudHJ5KFBHQ1RSTCwgcGdfcHJvY19kaXIpOwoJCXByb2NfbmV0X3JlbW92ZShQR19QUk9DX0RJUik7CgkJcmV0dXJuIC1FTk9ERVY7Cgl9CgoJcmV0dXJuIDA7Cn0KCnN0YXRpYyB2b2lkIF9fZXhpdCBwZ19jbGVhbnVwKHZvaWQpCnsKCXN0cnVjdCBwa3RnZW5fdGhyZWFkICp0OwoJc3RydWN0IGxpc3RfaGVhZCAqcSwgKm47Cgl3YWl0X3F1ZXVlX2hlYWRfdCBxdWV1ZTsKCWluaXRfd2FpdHF1ZXVlX2hlYWQoJnF1ZXVlKTsKCgkvKiBTdG9wIGFsbCBpbnRlcmZhY2VzICYgdGhyZWFkcyAqLwoKCWxpc3RfZm9yX2VhY2hfc2FmZShxLCBuLCAmcGt0Z2VuX3RocmVhZHMpIHsKCQl0ID0gbGlzdF9lbnRyeShxLCBzdHJ1Y3QgcGt0Z2VuX3RocmVhZCwgdGhfbGlzdCk7CgkJdC0+Y29udHJvbCB8PSAoVF9URVJNSU5BVEUpOwoKCQl3YWl0X2V2ZW50X2ludGVycnVwdGlibGVfdGltZW91dChxdWV1ZSwgKHQtPnJlbW92ZWQgPT0gMSksIEhaKTsKCX0KCgkvKiBVbi1yZWdpc3RlciB1cyBmcm9tIHJlY2VpdmluZyBuZXRkZXZpY2UgZXZlbnRzICovCgl1bnJlZ2lzdGVyX25ldGRldmljZV9ub3RpZmllcigmcGt0Z2VuX25vdGlmaWVyX2Jsb2NrKTsKCgkvKiBDbGVhbiB1cCBwcm9jIGZpbGUgc3lzdGVtICovCglyZW1vdmVfcHJvY19lbnRyeShQR0NUUkwsIHBnX3Byb2NfZGlyKTsKCXByb2NfbmV0X3JlbW92ZShQR19QUk9DX0RJUik7Cn0KCm1vZHVsZV9pbml0KHBnX2luaXQpOwptb2R1bGVfZXhpdChwZ19jbGVhbnVwKTsKCk1PRFVMRV9BVVRIT1IoIlJvYmVydCBPbHNzb24gPHJvYmVydC5vbHNzb25AaXRzLnV1LnNlIik7Ck1PRFVMRV9ERVNDUklQVElPTigiUGFja2V0IEdlbmVyYXRvciB0b29sIik7Ck1PRFVMRV9MSUNFTlNFKCJHUEwiKTsKbW9kdWxlX3BhcmFtKHBnX2NvdW50X2QsIGludCwgMCk7Cm1vZHVsZV9wYXJhbShwZ19kZWxheV9kLCBpbnQsIDApOwptb2R1bGVfcGFyYW0ocGdfY2xvbmVfc2tiX2QsIGludCwgMCk7Cm1vZHVsZV9wYXJhbShkZWJ1ZywgaW50LCAwKTsK