LyogaXA2dGFibGVzIG1hdGNoIGV4dGVuc2lvbiBmb3IgbGltaXRpbmcgcGFja2V0cyBwZXIgZGVzdGluYXRpb24KICoKICogKEMpIDIwMDMtMjAwNCBieSBIYXJhbGQgV2VsdGUgPGxhZm9yZ2VAbmV0ZmlsdGVyLm9yZz4KICoKICogRGV2ZWxvcG1lbnQgb2YgdGhpcyBjb2RlIHdhcyBmdW5kZWQgYnkgQXN0YXJvIEFHLCBodHRwOi8vd3d3LmFzdGFyby5jb20vCiAqCiAqIEJhc2VkIG9uIGlwdF9saW1pdC5jIGJ5CiAqIErpcvRtZSBkZSBWaXZpZSAgIDxkZXZpdmllQGluZm8uZW5zZXJiLnUtYm9yZGVhdXguZnI+CiAqIEhlcnbpIEV5Y2hlbm5lICAgIDxydkB3YWxsZmlyZS5vcmc+CiAqIAogKiBFcnJvciBjb3JlY3Rpb25zIGJ5IG5tYWx5a2hAYmlsaW0uY29tICgyMi4wMS4yMDA1KQogKi8KI2luY2x1ZGUgPHN0ZGJvb2wuaD4KI2luY2x1ZGUgPHN0ZGlvLmg+CiNpbmNsdWRlIDxzdHJpbmcuaD4KI2luY2x1ZGUgPHN0ZGxpYi5oPgojaW5jbHVkZSA8Z2V0b3B0Lmg+CiNpbmNsdWRlIDx4dGFibGVzLmg+CiNpbmNsdWRlIDxzdGRkZWYuaD4KI2luY2x1ZGUgPGxpbnV4L25ldGZpbHRlci94X3RhYmxlcy5oPgojaW5jbHVkZSA8bGludXgvbmV0ZmlsdGVyL3h0X2hhc2hsaW1pdC5oPgoKI2RlZmluZSBYVF9IQVNITElNSVRfQlVSU1QJNQoKLyogbWlsaXNlY29uZHMgKi8KI2RlZmluZSBYVF9IQVNITElNSVRfR0NJTlRFUlZBTAkxMDAwCiNkZWZpbmUgWFRfSEFTSExJTUlUX0VYUElSRQkxMDAwMAoKLyogRnVuY3Rpb24gd2hpY2ggcHJpbnRzIG91dCB1c2FnZSBtZXNzYWdlLiAqLwpzdGF0aWMgdm9pZCBoYXNobGltaXRfaGVscCh2b2lkKQp7CglwcmludGYoCiJoYXNobGltaXQgbWF0Y2ggb3B0aW9uczpcbiIKIi0taGFzaGxpbWl0IDxhdmc+CQltYXggYXZlcmFnZSBtYXRjaCByYXRlXG4iCiIgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIFtQYWNrZXRzIHBlciBzZWNvbmQgdW5sZXNzIGZvbGxvd2VkIGJ5IFxuIgoiICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAvc2VjIC9taW51dGUgL2hvdXIgL2RheSBwb3N0Zml4ZXNdXG4iCiItLWhhc2hsaW1pdC1tb2RlIDxtb2RlPgkJbW9kZSBpcyBhIGNvbW1hLXNlcGFyYXRlZCBsaXN0IG9mXG4iCiIJCQkJCWRzdGlwLHNyY2lwLGRzdHBvcnQsc3JjcG9ydFxuIgoiLS1oYXNobGltaXQtbmFtZSA8bmFtZT4JCW5hbWUgZm9yIC9wcm9jL25ldC9pcHRfaGFzaGxpbWl0L1xuIgoiWy0taGFzaGxpbWl0LWJ1cnN0IDxudW0+XQludW1iZXIgdG8gbWF0Y2ggaW4gYSBidXJzdCwgZGVmYXVsdCAldVxuIgoiWy0taGFzaGxpbWl0LWh0YWJsZS1zaXplIDxudW0+XQludW1iZXIgb2YgaGFzaHRhYmxlIGJ1Y2tldHNcbiIKIlstLWhhc2hsaW1pdC1odGFibGUtbWF4IDxudW0+XQludW1iZXIgb2YgaGFzaHRhYmxlIGVudHJpZXNcbiIKIlstLWhhc2hsaW1pdC1odGFibGUtZ2NpbnRlcnZhbF0JaW50ZXJ2YWwgYmV0d2VlbiBnYXJiYWdlIGNvbGxlY3Rpb24gcnVuc1xuIgoiWy0taGFzaGxpbWl0LWh0YWJsZS1leHBpcmVdCWFmdGVyIHdoaWNoIHRpbWUgYXJlIGlkbGUgZW50cmllcyBleHBpcmVkP1xuIiwKWFRfSEFTSExJTUlUX0JVUlNUKTsKfQoKc3RhdGljIHZvaWQgaGFzaGxpbWl0X210X2hlbHAodm9pZCkKewoJcHJpbnRmKAoiaGFzaGxpbWl0IG1hdGNoIG9wdGlvbnM6XG4iCiIgIC0taGFzaGxpbWl0LXVwdG8gPGF2Zz4gICAgICAgICAgIG1heCBhdmVyYWdlIG1hdGNoIHJhdGVcbiIKIiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgW1BhY2tldHMgcGVyIHNlY29uZCB1bmxlc3MgZm9sbG93ZWQgYnkgXG4iCiIgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIC9zZWMgL21pbnV0ZSAvaG91ciAvZGF5IHBvc3RmaXhlc11cbiIKIiAgLS1oYXNobGltaXQtYWJvdmUgPGF2Zz4gICAgICAgICAgbWluIGF2ZXJhZ2UgbWF0Y2ggcmF0ZVxuIgoiICAtLWhhc2hsaW1pdC1tb2RlIDxtb2RlPiAgICAgICAgICBtb2RlIGlzIGEgY29tbWEtc2VwYXJhdGVkIGxpc3Qgb2ZcbiIKIiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgZHN0aXAsc3JjaXAsZHN0cG9ydCxzcmNwb3J0IChvciBub25lKVxuIgoiICAtLWhhc2hsaW1pdC1zcmNtYXNrIDxsZW5ndGg+ICAgICBzb3VyY2UgYWRkcmVzcyBncm91cGluZyBwcmVmaXggbGVuZ3RoXG4iCiIgIC0taGFzaGxpbWl0LWRzdG1hc2sgPGxlbmd0aD4gICAgIGRlc3RpbmF0aW9uIGFkZHJlc3MgZ3JvdXBpbmcgcHJlZml4IGxlbmd0aFxuIgoiICAtLWhhc2hsaW1pdC1uYW1lIDxuYW1lPiAgICAgICAgICBuYW1lIGZvciAvcHJvYy9uZXQvaXB0X2hhc2hsaW1pdFxuIgoiICAtLWhhc2hsaW1pdC1idXJzdCA8bnVtPgkgICAgbnVtYmVyIHRvIG1hdGNoIGluIGEgYnVyc3QsIGRlZmF1bHQgJXVcbiIKIiAgLS1oYXNobGltaXQtaHRhYmxlLXNpemUgPG51bT4gICAgbnVtYmVyIG9mIGhhc2h0YWJsZSBidWNrZXRzXG4iCiIgIC0taGFzaGxpbWl0LWh0YWJsZS1tYXggPG51bT4gICAgIG51bWJlciBvZiBoYXNodGFibGUgZW50cmllc1xuIgoiICAtLWhhc2hsaW1pdC1odGFibGUtZ2NpbnRlcnZhbCAgICBpbnRlcnZhbCBiZXR3ZWVuIGdhcmJhZ2UgY29sbGVjdGlvbiBydW5zXG4iCiIgIC0taGFzaGxpbWl0LWh0YWJsZS1leHBpcmUgICAgICAgIGFmdGVyIHdoaWNoIHRpbWUgYXJlIGlkbGUgZW50cmllcyBleHBpcmVkP1xuIgoiXG4iLCBYVF9IQVNITElNSVRfQlVSU1QpOwp9CgpzdGF0aWMgY29uc3Qgc3RydWN0IG9wdGlvbiBoYXNobGltaXRfb3B0c1tdID0gewoJeyAiaGFzaGxpbWl0IiwgMSwgTlVMTCwgJyUnIH0sCgl7ICJoYXNobGltaXQtYnVyc3QiLCAxLCBOVUxMLCAnJCcgfSwKCXsgImhhc2hsaW1pdC1odGFibGUtc2l6ZSIsIDEsIE5VTEwsICcmJyB9LAoJeyAiaGFzaGxpbWl0LWh0YWJsZS1tYXgiLCAxLCBOVUxMLCAnKicgfSwKCXsgImhhc2hsaW1pdC1odGFibGUtZ2NpbnRlcnZhbCIsIDEsIE5VTEwsICcoJyB9LAoJeyAiaGFzaGxpbWl0LWh0YWJsZS1leHBpcmUiLCAxLCBOVUxMLCAnKScgfSwKCXsgImhhc2hsaW1pdC1tb2RlIiwgMSwgTlVMTCwgJ18nIH0sCgl7ICJoYXNobGltaXQtbmFtZSIsIDEsIE5VTEwsICciJyB9LAoJeyAubmFtZSA9IE5VTEwgfQp9OwoKc3RhdGljIGNvbnN0IHN0cnVjdCBvcHRpb24gaGFzaGxpbWl0X210X29wdHNbXSA9IHsKCXsubmFtZSA9ICJoYXNobGltaXQtdXB0byIsICAgICAgICAgICAgICAuaGFzX2FyZyA9IHRydWUsIC52YWwgPSAnJSd9LAoJey5uYW1lID0gImhhc2hsaW1pdC1hYm92ZSIsICAgICAgICAgICAgIC5oYXNfYXJnID0gdHJ1ZSwgLnZhbCA9ICdeJ30sCgl7Lm5hbWUgPSAiaGFzaGxpbWl0IiwgICAgICAgICAgICAgICAgICAgLmhhc19hcmcgPSB0cnVlLCAudmFsID0gJyUnfSwKCXsubmFtZSA9ICJoYXNobGltaXQtc3JjbWFzayIsICAgICAgICAgICAuaGFzX2FyZyA9IHRydWUsIC52YWwgPSAnPCd9LAoJey5uYW1lID0gImhhc2hsaW1pdC1kc3RtYXNrIiwgICAgICAgICAgIC5oYXNfYXJnID0gdHJ1ZSwgLnZhbCA9ICc+J30sCgl7Lm5hbWUgPSAiaGFzaGxpbWl0LWJ1cnN0IiwgICAgICAgICAgICAgLmhhc19hcmcgPSB0cnVlLCAudmFsID0gJyQnfSwKCXsubmFtZSA9ICJoYXNobGltaXQtaHRhYmxlLXNpemUiLCAgICAgICAuaGFzX2FyZyA9IHRydWUsIC52YWwgPSAnJid9LAoJey5uYW1lID0gImhhc2hsaW1pdC1odGFibGUtbWF4IiwgICAgICAgIC5oYXNfYXJnID0gdHJ1ZSwgLnZhbCA9ICcqJ30sCgl7Lm5hbWUgPSAiaGFzaGxpbWl0LWh0YWJsZS1nY2ludGVydmFsIiwgLmhhc19hcmcgPSB0cnVlLCAudmFsID0gJygnfSwKCXsubmFtZSA9ICJoYXNobGltaXQtaHRhYmxlLWV4cGlyZSIsICAgICAuaGFzX2FyZyA9IHRydWUsIC52YWwgPSAnKSd9LAoJey5uYW1lID0gImhhc2hsaW1pdC1tb2RlIiwgICAgICAgICAgICAgIC5oYXNfYXJnID0gdHJ1ZSwgLnZhbCA9ICdfJ30sCgl7Lm5hbWUgPSAiaGFzaGxpbWl0LW5hbWUiLCAgICAgICAgICAgICAgLmhhc19hcmcgPSB0cnVlLCAudmFsID0gJyInfSwKCXt9LAp9OwoKc3RhdGljCmludCBwYXJzZV9yYXRlKGNvbnN0IGNoYXIgKnJhdGUsIHVfaW50MzJfdCAqdmFsKQp7Cgljb25zdCBjaGFyICpkZWxpbTsKCXVfaW50MzJfdCByOwoJdV9pbnQzMl90IG11bHQgPSAxOyAgLyogU2Vjb25kcyBieSBkZWZhdWx0LiAqLwoKCWRlbGltID0gc3RyY2hyKHJhdGUsICcvJyk7CglpZiAoZGVsaW0pIHsKCQlpZiAoc3RybGVuKGRlbGltKzEpID09IDApCgkJCXJldHVybiAwOwoKCQlpZiAoc3RybmNhc2VjbXAoZGVsaW0rMSwgInNlY29uZCIsIHN0cmxlbihkZWxpbSsxKSkgPT0gMCkKCQkJbXVsdCA9IDE7CgkJZWxzZSBpZiAoc3RybmNhc2VjbXAoZGVsaW0rMSwgIm1pbnV0ZSIsIHN0cmxlbihkZWxpbSsxKSkgPT0gMCkKCQkJbXVsdCA9IDYwOwoJCWVsc2UgaWYgKHN0cm5jYXNlY21wKGRlbGltKzEsICJob3VyIiwgc3RybGVuKGRlbGltKzEpKSA9PSAwKQoJCQltdWx0ID0gNjAqNjA7CgkJZWxzZSBpZiAoc3RybmNhc2VjbXAoZGVsaW0rMSwgImRheSIsIHN0cmxlbihkZWxpbSsxKSkgPT0gMCkKCQkJbXVsdCA9IDI0KjYwKjYwOwoJCWVsc2UKCQkJcmV0dXJuIDA7Cgl9CglyID0gYXRvaShyYXRlKTsKCWlmICghcikKCQlyZXR1cm4gMDsKCgkvKiBUaGlzIHdvdWxkIGdldCBtYXBwZWQgdG8gaW5maW5pdGUgKDEvZGF5IGlzIG1pbmltdW0gdGhleQogICAgICAgICAgIGNhbiBzcGVjaWZ5LCBzbyB3ZSdyZSBvayBhdCB0aGF0IGVuZCkuICovCglpZiAociAvIG11bHQgPiBYVF9IQVNITElNSVRfU0NBTEUpCgkJZXhpdF9lcnJvcihQQVJBTUVURVJfUFJPQkxFTSwgIlJhdGUgdG9vIGZhc3QgYCVzJ1xuIiwgcmF0ZSk7CgoJKnZhbCA9IFhUX0hBU0hMSU1JVF9TQ0FMRSAqIG11bHQgLyByOwoJcmV0dXJuIDE7Cn0KCi8qIEluaXRpYWxpemUgdGhlIG1hdGNoLiAqLwpzdGF0aWMgdm9pZCBoYXNobGltaXRfaW5pdChzdHJ1Y3QgeHRfZW50cnlfbWF0Y2ggKm0pCnsKCXN0cnVjdCB4dF9oYXNobGltaXRfaW5mbyAqciA9IChzdHJ1Y3QgeHRfaGFzaGxpbWl0X2luZm8gKiltLT5kYXRhOwoKCXItPmNmZy5tb2RlID0gMDsKCXItPmNmZy5idXJzdCA9IFhUX0hBU0hMSU1JVF9CVVJTVDsKCXItPmNmZy5nY19pbnRlcnZhbCA9IFhUX0hBU0hMSU1JVF9HQ0lOVEVSVkFMOwoJci0+Y2ZnLmV4cGlyZSA9IFhUX0hBU0hMSU1JVF9FWFBJUkU7Cgp9CgpzdGF0aWMgdm9pZCBoYXNobGltaXRfbXQ0X2luaXQoc3RydWN0IHh0X2VudHJ5X21hdGNoICptYXRjaCkKewoJc3RydWN0IHh0X2hhc2hsaW1pdF9tdGluZm8xICppbmZvID0gKHZvaWQgKiltYXRjaC0+ZGF0YTsKCglpbmZvLT5jZmcubW9kZSAgICAgICAgPSAwOwoJaW5mby0+Y2ZnLmJ1cnN0ICAgICAgID0gWFRfSEFTSExJTUlUX0JVUlNUOwoJaW5mby0+Y2ZnLmdjX2ludGVydmFsID0gWFRfSEFTSExJTUlUX0dDSU5URVJWQUw7CglpbmZvLT5jZmcuZXhwaXJlICAgICAgPSBYVF9IQVNITElNSVRfRVhQSVJFOwoJaW5mby0+Y2ZnLnNyY21hc2sgICAgID0gMzI7CglpbmZvLT5jZmcuZHN0bWFzayAgICAgPSAzMjsKfQoKc3RhdGljIHZvaWQgaGFzaGxpbWl0X210Nl9pbml0KHN0cnVjdCB4dF9lbnRyeV9tYXRjaCAqbWF0Y2gpCnsKCXN0cnVjdCB4dF9oYXNobGltaXRfbXRpbmZvMSAqaW5mbyA9ICh2b2lkICopbWF0Y2gtPmRhdGE7CgoJaW5mby0+Y2ZnLm1vZGUgICAgICAgID0gMDsKCWluZm8tPmNmZy5idXJzdCAgICAgICA9IFhUX0hBU0hMSU1JVF9CVVJTVDsKCWluZm8tPmNmZy5nY19pbnRlcnZhbCA9IFhUX0hBU0hMSU1JVF9HQ0lOVEVSVkFMOwoJaW5mby0+Y2ZnLmV4cGlyZSAgICAgID0gWFRfSEFTSExJTUlUX0VYUElSRTsKCWluZm8tPmNmZy5zcmNtYXNrICAgICA9IDEyODsKCWluZm8tPmNmZy5kc3RtYXNrICAgICA9IDEyODsKfQoKLyogUGFyc2UgYSAnbW9kZScgcGFyYW1ldGVyIGludG8gdGhlIHJlcXVpcmVkIGJpdG1hc2sgKi8Kc3RhdGljIGludCBwYXJzZV9tb2RlKHVpbnQzMl90ICptb2RlLCBjaGFyICpvcHRpb25fYXJnKQp7CgljaGFyICp0b2s7CgljaGFyICphcmcgPSBzdHJkdXAob3B0aW9uX2FyZyk7CgoJaWYgKCFhcmcpCgkJcmV0dXJuIC0xOwoKCWZvciAodG9rID0gc3RydG9rKGFyZywgIix8Iik7CgkgICAgIHRvazsKCSAgICAgdG9rID0gc3RydG9rKE5VTEwsICIsfCIpKSB7CgkJaWYgKCFzdHJjbXAodG9rLCAiZHN0aXAiKSkKCQkJKm1vZGUgfD0gWFRfSEFTSExJTUlUX0hBU0hfRElQOwoJCWVsc2UgaWYgKCFzdHJjbXAodG9rLCAic3JjaXAiKSkKCQkJKm1vZGUgfD0gWFRfSEFTSExJTUlUX0hBU0hfU0lQOwoJCWVsc2UgaWYgKCFzdHJjbXAodG9rLCAic3JjcG9ydCIpKQoJCQkqbW9kZSB8PSBYVF9IQVNITElNSVRfSEFTSF9TUFQ7CgkJZWxzZSBpZiAoIXN0cmNtcCh0b2ssICJkc3Rwb3J0IikpCgkJCSptb2RlIHw9IFhUX0hBU0hMSU1JVF9IQVNIX0RQVDsKCQllbHNlIHsKCQkJZnJlZShhcmcpOwoJCQlyZXR1cm4gLTE7CgkJfQoJfQoJZnJlZShhcmcpOwoJcmV0dXJuIDA7Cn0KCmVudW0gewoJUEFSQU1fTElNSVQgICAgICA9IDEgPDwgMCwKCVBBUkFNX0JVUlNUICAgICAgPSAxIDw8IDEsCglQQVJBTV9NT0RFICAgICAgID0gMSA8PCAyLAoJUEFSQU1fTkFNRSAgICAgICA9IDEgPDwgMywKCVBBUkFNX1NJWkUgICAgICAgPSAxIDw8IDQsCglQQVJBTV9NQVggICAgICAgID0gMSA8PCA1LAoJUEFSQU1fR0NJTlRFUlZBTCA9IDEgPDwgNiwKCVBBUkFNX0VYUElSRSAgICAgPSAxIDw8IDcsCglQQVJBTV9TUkNNQVNLICAgID0gMSA8PCA4LAoJUEFSQU1fRFNUTUFTSyAgICA9IDEgPDwgOSwKfTsKCi8qIEZ1bmN0aW9uIHdoaWNoIHBhcnNlcyBjb21tYW5kIG9wdGlvbnM7IHJldHVybnMgdHJ1ZSBpZiBpdAogICBhdGUgYW4gb3B0aW9uICovCnN0YXRpYyBpbnQKaGFzaGxpbWl0X3BhcnNlKGludCBjLCBjaGFyICoqYXJndiwgaW50IGludmVydCwgdW5zaWduZWQgaW50ICpmbGFncywKICAgICAgICAgICAgICAgIGNvbnN0IHZvaWQgKmVudHJ5LCBzdHJ1Y3QgeHRfZW50cnlfbWF0Y2ggKiptYXRjaCkKewoJc3RydWN0IHh0X2hhc2hsaW1pdF9pbmZvICpyID0gCgkJCShzdHJ1Y3QgeHRfaGFzaGxpbWl0X2luZm8gKikoKm1hdGNoKS0+ZGF0YTsKCXVuc2lnbmVkIGludCBudW07CgoJc3dpdGNoKGMpIHsKCWNhc2UgJyUnOgoJCXBhcmFtX2FjdChQX09OTFlfT05DRSwgImhhc2hsaW1pdCIsICItLWhhc2hsaW1pdCIsCgkJICAgICAgICAgICpmbGFncyAmIFBBUkFNX0xJTUlUKTsKCQlpZiAoY2hlY2tfaW52ZXJzZShhcmd2W29wdGluZC0xXSwgJmludmVydCwgJm9wdGluZCwgMCkpIGJyZWFrOwoJCWlmICghcGFyc2VfcmF0ZShvcHRhcmcsICZyLT5jZmcuYXZnKSkKCQkJZXhpdF9lcnJvcihQQVJBTUVURVJfUFJPQkxFTSwKCQkJCSAgICJiYWQgcmF0ZSBgJXMnIiwgb3B0YXJnKTsKCQkqZmxhZ3MgfD0gUEFSQU1fTElNSVQ7CgkJYnJlYWs7CgoJY2FzZSAnJCc6CgkJcGFyYW1fYWN0KFBfT05MWV9PTkNFLCAiaGFzaGxpbWl0IiwgIi0taGFzaGxpbWl0LWJ1cnN0IiwKCQkgICAgICAgICAgKmZsYWdzICYgUEFSQU1fQlVSU1QpOwoJCWlmIChjaGVja19pbnZlcnNlKGFyZ3Zbb3B0aW5kLTFdLCAmaW52ZXJ0LCAmb3B0aW5kLCAwKSkgYnJlYWs7CgkJaWYgKHN0cmluZ190b19udW1iZXIob3B0YXJnLCAwLCAxMDAwMCwgJm51bSkgPT0gLTEpCgkJCWV4aXRfZXJyb3IoUEFSQU1FVEVSX1BST0JMRU0sCgkJCQkgICAiYmFkIC0taGFzaGxpbWl0LWJ1cnN0IGAlcyciLCBvcHRhcmcpOwoJCXItPmNmZy5idXJzdCA9IG51bTsKCQkqZmxhZ3MgfD0gUEFSQU1fQlVSU1Q7CgkJYnJlYWs7CgljYXNlICcmJzoKCQlwYXJhbV9hY3QoUF9PTkxZX09OQ0UsICJoYXNobGltaXQiLCAiLS1oYXNobGltaXQtaHRhYmxlLXNpemUiLAoJCSAgICAgICAgICAqZmxhZ3MgJiBQQVJBTV9TSVpFKTsKCQlpZiAoY2hlY2tfaW52ZXJzZShhcmd2W29wdGluZC0xXSwgJmludmVydCwgJm9wdGluZCwgMCkpIGJyZWFrOwoJCWlmIChzdHJpbmdfdG9fbnVtYmVyKG9wdGFyZywgMCwgMHhmZmZmZmZmZiwgJm51bSkgPT0gLTEpCgkJCWV4aXRfZXJyb3IoUEFSQU1FVEVSX1BST0JMRU0sCgkJCQkiYmFkIC0taGFzaGxpbWl0LWh0YWJsZS1zaXplOiBgJXMnIiwgb3B0YXJnKTsKCQlyLT5jZmcuc2l6ZSA9IG51bTsKCQkqZmxhZ3MgfD0gUEFSQU1fU0laRTsKCQlicmVhazsKCWNhc2UgJyonOgoJCXBhcmFtX2FjdChQX09OTFlfT05DRSwgImhhc2hsaW1pdCIsICItLWhhc2hsaW1pdC1odGFibGUtbWF4IiwKCQkgICAgICAgICAgKmZsYWdzICYgUEFSQU1fTUFYKTsKCQlpZiAoY2hlY2tfaW52ZXJzZShhcmd2W29wdGluZC0xXSwgJmludmVydCwgJm9wdGluZCwgMCkpIGJyZWFrOwoJCWlmIChzdHJpbmdfdG9fbnVtYmVyKG9wdGFyZywgMCwgMHhmZmZmZmZmZiwgJm51bSkgPT0gLTEpCgkJCWV4aXRfZXJyb3IoUEFSQU1FVEVSX1BST0JMRU0sCgkJCQkiYmFkIC0taGFzaGxpbWl0LWh0YWJsZS1tYXg6IGAlcyciLCBvcHRhcmcpOwoJCXItPmNmZy5tYXggPSBudW07CgkJKmZsYWdzIHw9IFBBUkFNX01BWDsKCQlicmVhazsKCWNhc2UgJygnOgoJCXBhcmFtX2FjdChQX09OTFlfT05DRSwgImhhc2hsaW1pdCIsCgkJICAgICAgICAgICItLWhhc2hsaW1pdC1odGFibGUtZ2NpbnRlcnZhbCIsCgkJICAgICAgICAgICpmbGFncyAmIFBBUkFNX0dDSU5URVJWQUwpOwoJCWlmIChjaGVja19pbnZlcnNlKGFyZ3Zbb3B0aW5kLTFdLCAmaW52ZXJ0LCAmb3B0aW5kLCAwKSkgYnJlYWs7CgkJaWYgKHN0cmluZ190b19udW1iZXIob3B0YXJnLCAwLCAweGZmZmZmZmZmLCAmbnVtKSA9PSAtMSkKCQkJZXhpdF9lcnJvcihQQVJBTUVURVJfUFJPQkxFTSwKCQkJCSJiYWQgLS1oYXNobGltaXQtaHRhYmxlLWdjaW50ZXJ2YWw6IGAlcyciLCAKCQkJCW9wdGFyZyk7CgkJLyogRklYTUU6IG5vdCBIWiBkZXBlbmRlbnQhISAqLwoJCXItPmNmZy5nY19pbnRlcnZhbCA9IG51bTsKCQkqZmxhZ3MgfD0gUEFSQU1fR0NJTlRFUlZBTDsKCQlicmVhazsKCWNhc2UgJyknOgoJCXBhcmFtX2FjdChQX09OTFlfT05DRSwgImhhc2hsaW1pdCIsCgkJICAgICAgICAgICItLWhhc2hsaW1pdC1odGFibGUtZXhwaXJlIiwgKmZsYWdzICYgUEFSQU1fRVhQSVJFKTsKCQlpZiAoY2hlY2tfaW52ZXJzZShhcmd2W29wdGluZC0xXSwgJmludmVydCwgJm9wdGluZCwgMCkpIGJyZWFrOwoJCWlmIChzdHJpbmdfdG9fbnVtYmVyKG9wdGFyZywgMCwgMHhmZmZmZmZmZiwgJm51bSkgPT0gLTEpCgkJCWV4aXRfZXJyb3IoUEFSQU1FVEVSX1BST0JMRU0sCgkJCQkiYmFkIC0taGFzaGxpbWl0LWh0YWJsZS1leHBpcmU6IGAlcyciLCBvcHRhcmcpOwoJCS8qIEZJWE1FOiBub3QgSFogZGVwZW5kZW50ICovCgkJci0+Y2ZnLmV4cGlyZSA9IG51bTsKCQkqZmxhZ3MgfD0gUEFSQU1fRVhQSVJFOwoJCWJyZWFrOwoJY2FzZSAnXyc6CgkJcGFyYW1fYWN0KFBfT05MWV9PTkNFLCAiaGFzaGxpbWl0IiwgIi0taGFzaGxpbWl0LW1vZGUiLAoJCSAgICAgICAgICAqZmxhZ3MgJiBQQVJBTV9NT0RFKTsKCQlpZiAoY2hlY2tfaW52ZXJzZShhcmd2W29wdGluZC0xXSwgJmludmVydCwgJm9wdGluZCwgMCkpIGJyZWFrOwoJCWlmIChwYXJzZV9tb2RlKCZyLT5jZmcubW9kZSwgb3B0YXJnKSA8IDApCgkJCWV4aXRfZXJyb3IoUEFSQU1FVEVSX1BST0JMRU0sIAoJCQkJICAgImJhZCAtLWhhc2hsaW1pdC1tb2RlOiBgJXMnXG4iLCBvcHRhcmcpOwoJCSpmbGFncyB8PSBQQVJBTV9NT0RFOwoJCWJyZWFrOwoJY2FzZSAnIic6CgkJcGFyYW1fYWN0KFBfT05MWV9PTkNFLCAiaGFzaGxpbWl0IiwgIi0taGFzaGxpbWl0LW5hbWUiLAoJCSAgICAgICAgICAqZmxhZ3MgJiBQQVJBTV9OQU1FKTsKCQlpZiAoY2hlY2tfaW52ZXJzZShhcmd2W29wdGluZC0xXSwgJmludmVydCwgJm9wdGluZCwgMCkpIGJyZWFrOwoJCWlmIChzdHJsZW4ob3B0YXJnKSA9PSAwKQoJCQlleGl0X2Vycm9yKFBBUkFNRVRFUl9QUk9CTEVNLCAiWmVyby1sZW5ndGggbmFtZT8iKTsKCQlzdHJuY3B5KHItPm5hbWUsIG9wdGFyZywgc2l6ZW9mKHItPm5hbWUpKTsKCQkqZmxhZ3MgfD0gUEFSQU1fTkFNRTsKCQlicmVhazsKCWRlZmF1bHQ6CgkJcmV0dXJuIDA7Cgl9CgoJaWYgKGludmVydCkKCQlleGl0X2Vycm9yKFBBUkFNRVRFUl9QUk9CTEVNLAoJCQkgICAiaGFzaGxpbWl0IGRvZXMgbm90IHN1cHBvcnQgaW52ZXJ0Iik7CgoJcmV0dXJuIDE7Cn0KCnN0YXRpYyBpbnQKaGFzaGxpbWl0X210X3BhcnNlKHN0cnVjdCB4dF9oYXNobGltaXRfbXRpbmZvMSAqaW5mbywgdW5zaWduZWQgaW50ICpmbGFncywKICAgICAgICAgICAgICAgICAgIGludCBjLCBpbnQgaW52ZXJ0LCB1bnNpZ25lZCBpbnQgbWF4bWFzaykKewoJdW5zaWduZWQgaW50IG51bTsKCglzd2l0Y2goYykgewoJY2FzZSAnJSc6IC8qIC0taGFzaGxpbWl0IC8gLS1oYXNobGltaXQtYmVsb3cgKi8KCQlwYXJhbV9hY3QoUF9PTkxZX09OQ0UsICJoYXNobGltaXQiLCAiLS1oYXNobGltaXQtdXB0byIsCgkJICAgICAgICAgICpmbGFncyAmIFBBUkFNX0xJTUlUKTsKCQlpZiAoaW52ZXJ0KQoJCQlpbmZvLT5jZmcubW9kZSB8PSBYVF9IQVNITElNSVRfSU5WRVJUOwoJCWlmICghcGFyc2VfcmF0ZShvcHRhcmcsICZpbmZvLT5jZmcuYXZnKSkKCQkJcGFyYW1fYWN0KFBfQkFEX1ZBTFVFLCAiaGFzaGxpbWl0IiwKCQkJICAgICAgICAgICItLWhhc2hsaW1pdC11cHRvIiwgb3B0YXJnKTsKCQkqZmxhZ3MgfD0gUEFSQU1fTElNSVQ7CgkJcmV0dXJuIHRydWU7CgoJY2FzZSAnXic6IC8qIC0taGFzaGxpbWl0LWFib3ZlID09ICEtLWhhc2hsaW1pdC1iZWxvdyAqLwoJCXBhcmFtX2FjdChQX09OTFlfT05DRSwgImhhc2hsaW1pdCIsICItLWhhc2hsaW1pdC1hYm92ZSIsCgkJICAgICAgICAgICpmbGFncyAmIFBBUkFNX0xJTUlUKTsKCQlpZiAoIWludmVydCkKCQkJaW5mby0+Y2ZnLm1vZGUgfD0gWFRfSEFTSExJTUlUX0lOVkVSVDsKCQlpZiAoIXBhcnNlX3JhdGUob3B0YXJnLCAmaW5mby0+Y2ZnLmF2ZykpCgkJCXBhcmFtX2FjdChQX0JBRF9WQUxVRSwgImhhc2hsaW1pdCIsCgkJCSAgICAgICAgICAiLS1oYXNobGltaXQtYWJvdmUiLCBvcHRhcmcpOwoJCSpmbGFncyB8PSBQQVJBTV9MSU1JVDsKCQlyZXR1cm4gdHJ1ZTsKCgljYXNlICckJzogLyogLS1oYXNobGltaXQtYnVyc3QgKi8KCQlwYXJhbV9hY3QoUF9PTkxZX09OQ0UsICJoYXNobGltaXQiLCAiLS1oYXNobGltaXQtYnVyc3QiLAoJCSAgICAgICAgICAqZmxhZ3MgJiBQQVJBTV9CVVJTVCk7CgkJaWYgKCFzdHJ0b251bShvcHRhcmcsIE5VTEwsICZudW0sIDAsIDEwMDAwKSkKCQkJcGFyYW1fYWN0KFBfQkFEX1ZBTFVFLCAiaGFzaGxpbWl0IiwKCQkJICAgICAgICAgICItLWhhc2hsaW1pdC1idXJzdCIsIG9wdGFyZyk7CgkJaW5mby0+Y2ZnLmJ1cnN0ID0gbnVtOwoJCSpmbGFncyB8PSBQQVJBTV9CVVJTVDsKCQlyZXR1cm4gdHJ1ZTsKCgljYXNlICcmJzogLyogLS1oYXNobGltaXQtaHRhYmxlLXNpemUgKi8KCQlwYXJhbV9hY3QoUF9PTkxZX09OQ0UsICJoYXNobGltaXQiLCAiLS1oYXNobGltaXQtaHRhYmxlLXNpemUiLAoJCSAgICAgICAgICAqZmxhZ3MgJiBQQVJBTV9TSVpFKTsKCQlpZiAoIXN0cnRvbnVtKG9wdGFyZywgTlVMTCwgJm51bSwgMCwgMHhmZmZmZmZmZikpCgkJCXBhcmFtX2FjdChQX0JBRF9WQUxVRSwgImhhc2hsaW1pdCIsCgkJCSAgICAgICAgICAiLS1oYXNobGltaXQtaHRhYmxlLXNpemUiLCBvcHRhcmcpOwoJCWluZm8tPmNmZy5zaXplID0gbnVtOwoJCSpmbGFncyB8PSBQQVJBTV9TSVpFOwoJCXJldHVybiB0cnVlOwoKCWNhc2UgJyonOiAvKiAtLWhhc2hsaW1pdC1odGFibGUtbWF4ICovCgkJcGFyYW1fYWN0KFBfT05MWV9PTkNFLCAiaGFzaGxpbWl0IiwgIi0taGFzaGxpbWl0LWh0YWJsZS1tYXgiLAoJCSAgICAgICAgICAqZmxhZ3MgJiBQQVJBTV9NQVgpOwoJCWlmICghc3RydG9udW0ob3B0YXJnLCBOVUxMLCAmbnVtLCAwLCAweGZmZmZmZmZmKSkKCQkJcGFyYW1fYWN0KFBfQkFEX1ZBTFVFLCAiaGFzaGxpbWl0IiwKCQkJICAgICAgICAgICItLWhhc2hsaW1pdC1odGFibGUtbWF4Iiwgb3B0YXJnKTsKCQlpbmZvLT5jZmcubWF4ID0gbnVtOwoJCSpmbGFncyB8PSBQQVJBTV9NQVg7CgkJcmV0dXJuIHRydWU7CgoJY2FzZSAnKCc6IC8qIC0taGFzaGxpbWl0LWh0YWJsZS1nY2ludGVydmFsICovCgkJcGFyYW1fYWN0KFBfT05MWV9PTkNFLCAiaGFzaGxpbWl0IiwKCQkgICAgICAgICAgIi0taGFzaGxpbWl0LWh0YWJsZS1nY2ludGVydmFsIiwKCQkgICAgICAgICAgKmZsYWdzICYgUEFSQU1fR0NJTlRFUlZBTCk7CgkJaWYgKCFzdHJ0b251bShvcHRhcmcsIE5VTEwsICZudW0sIDAsIDB4ZmZmZmZmZmYpKQoJCQlwYXJhbV9hY3QoUF9CQURfVkFMVUUsICJoYXNobGltaXQiLAoJCQkgICAgICAgICAgIi0taGFzaGxpbWl0LWh0YWJsZS1nY2ludGVydmFsIiwgb3B0YXJnKTsKCQkvKiBGSVhNRTogbm90IEhaIGRlcGVuZGVudCEhICovCgkJaW5mby0+Y2ZnLmdjX2ludGVydmFsID0gbnVtOwoJCSpmbGFncyB8PSBQQVJBTV9HQ0lOVEVSVkFMOwoJCXJldHVybiB0cnVlOwoKCWNhc2UgJyknOiAvKiAtLWhhc2hsaW1pdC1odGFibGUtZXhwaXJlICovCgkJcGFyYW1fYWN0KFBfT05MWV9PTkNFLCAiaGFzaGxpbWl0IiwKCQkgICAgICAgICAgIi0taGFzaGxpbWl0LWh0YWJsZS1leHBpcmUiLCAqZmxhZ3MgJiBQQVJBTV9FWFBJUkUpOwoJCWlmICghc3RydG9udW0ob3B0YXJnLCBOVUxMLCAmbnVtLCAwLCAweGZmZmZmZmZmKSkKCQkJcGFyYW1fYWN0KFBfQkFEX1ZBTFVFLCAiaGFzaGxpbWl0IiwKCQkJICAgICAgICAgICItLWhhc2hsaW1pdC1odGFibGUtZXhwaXJlIiwgb3B0YXJnKTsKCQkvKiBGSVhNRTogbm90IEhaIGRlcGVuZGVudCAqLwoJCWluZm8tPmNmZy5leHBpcmUgPSBudW07CgkJKmZsYWdzIHw9IFBBUkFNX0VYUElSRTsKCQlyZXR1cm4gdHJ1ZTsKCgljYXNlICdfJzoKCQlwYXJhbV9hY3QoUF9PTkxZX09OQ0UsICJoYXNobGltaXQiLCAiLS1oYXNobGltaXQtbW9kZSIsCgkJICAgICAgICAgICpmbGFncyAmIFBBUkFNX01PREUpOwoJCWlmIChwYXJzZV9tb2RlKCZpbmZvLT5jZmcubW9kZSwgb3B0YXJnKSA8IDApCgkJCXBhcmFtX2FjdChQX0JBRF9WQUxVRSwgImhhc2hsaW1pdCIsCgkJCSAgICAgICAgICAiLS1oYXNobGltaXQtbW9kZSIsIG9wdGFyZyk7CgkJKmZsYWdzIHw9IFBBUkFNX01PREU7CgkJcmV0dXJuIHRydWU7CgoJY2FzZSAnIic6IC8qIC0taGFzaGxpbWl0LW5hbWUgKi8KCQlwYXJhbV9hY3QoUF9PTkxZX09OQ0UsICJoYXNobGltaXQiLCAiLS1oYXNobGltaXQtbmFtZSIsCgkJICAgICAgICAgICpmbGFncyAmIFBBUkFNX05BTUUpOwoJCWlmIChzdHJsZW4ob3B0YXJnKSA9PSAwKQoJCQlleGl0X2Vycm9yKFBBUkFNRVRFUl9QUk9CTEVNLCAiWmVyby1sZW5ndGggbmFtZT8iKTsKCQlzdHJuY3B5KGluZm8tPm5hbWUsIG9wdGFyZywgc2l6ZW9mKGluZm8tPm5hbWUpKTsKCQlpbmZvLT5uYW1lW3NpemVvZihpbmZvLT5uYW1lKS0xXSA9ICdcMCc7CgkJKmZsYWdzIHw9IFBBUkFNX05BTUU7CgkJcmV0dXJuIHRydWU7CgoJY2FzZSAnPCc6IC8qIC0taGFzaGxpbWl0LXNyY21hc2sgKi8KCQlwYXJhbV9hY3QoUF9PTkxZX09OQ0UsICJoYXNobGltaXQiLCAiLS1oYXNobGltaXQtc3JjbWFzayIsCgkJICAgICAgICAgICpmbGFncyAmIFBBUkFNX1NSQ01BU0spOwoJCWlmICghc3RydG9udW0ob3B0YXJnLCBOVUxMLCAmbnVtLCAwLCBtYXhtYXNrKSkKCQkJcGFyYW1fYWN0KFBfQkFEX1ZBTFVFLCAiaGFzaGxpbWl0IiwKCQkJICAgICAgICAgICItLWhhc2hsaW1pdC1zcmNtYXNrIiwgb3B0YXJnKTsKCQlpbmZvLT5jZmcuc3JjbWFzayA9IG51bTsKCQkqZmxhZ3MgfD0gUEFSQU1fU1JDTUFTSzsKCQlyZXR1cm4gdHJ1ZTsKCgljYXNlICc+JzogLyogLS1oYXNobGltaXQtZHN0bWFzayAqLwoJCXBhcmFtX2FjdChQX09OTFlfT05DRSwgImhhc2hsaW1pdCIsICItLWhhc2hsaW1pdC1kc3RtYXNrIiwKCQkgICAgICAgICAgKmZsYWdzICYgUEFSQU1fRFNUTUFTSyk7CgkJaWYgKCFzdHJ0b251bShvcHRhcmcsIE5VTEwsICZudW0sIDAsIG1heG1hc2spKQoJCQlwYXJhbV9hY3QoUF9CQURfVkFMVUUsICJoYXNobGltaXQiLAoJCQkgICAgICAgICAgIi0taGFzaGxpbWl0LWRzdG1hc2siLCBvcHRhcmcpOwoJCWluZm8tPmNmZy5kc3RtYXNrID0gbnVtOwoJCSpmbGFncyB8PSBQQVJBTV9EU1RNQVNLOwoJCXJldHVybiB0cnVlOwoJfQoJcmV0dXJuIGZhbHNlOwp9CgpzdGF0aWMgaW50Cmhhc2hsaW1pdF9tdDRfcGFyc2UoaW50IGMsIGNoYXIgKiphcmd2LCBpbnQgaW52ZXJ0LCB1bnNpZ25lZCBpbnQgKmZsYWdzLAogICAgICAgICAgICAgICAgICAgIGNvbnN0IHZvaWQgKmVudHJ5LCBzdHJ1Y3QgeHRfZW50cnlfbWF0Y2ggKiptYXRjaCkKewoJcmV0dXJuIGhhc2hsaW1pdF9tdF9wYXJzZSgodm9pZCAqKSgqbWF0Y2gpLT5kYXRhLAoJICAgICAgIGZsYWdzLCBjLCBpbnZlcnQsIDMyKTsKfQoKc3RhdGljIGludApoYXNobGltaXRfbXQ2X3BhcnNlKGludCBjLCBjaGFyICoqYXJndiwgaW50IGludmVydCwgdW5zaWduZWQgaW50ICpmbGFncywKICAgICAgICAgICAgICAgICAgICBjb25zdCB2b2lkICplbnRyeSwgc3RydWN0IHh0X2VudHJ5X21hdGNoICoqbWF0Y2gpCnsKCXJldHVybiBoYXNobGltaXRfbXRfcGFyc2UoKHZvaWQgKikoKm1hdGNoKS0+ZGF0YSwKCSAgICAgICBmbGFncywgYywgaW52ZXJ0LCAxMjgpOwp9CgovKiBGaW5hbCBjaGVjazsgbm90aGluZy4gKi8Kc3RhdGljIHZvaWQgaGFzaGxpbWl0X2NoZWNrKHVuc2lnbmVkIGludCBmbGFncykKewoJaWYgKCEoZmxhZ3MgJiBQQVJBTV9MSU1JVCkpCgkJZXhpdF9lcnJvcihQQVJBTUVURVJfUFJPQkxFTSwKCQkJCSJZb3UgaGF2ZSB0byBzcGVjaWZ5IC0taGFzaGxpbWl0Iik7CglpZiAoIShmbGFncyAmIFBBUkFNX01PREUpKQoJCWV4aXRfZXJyb3IoUEFSQU1FVEVSX1BST0JMRU0sCgkJCQkiWW91IGhhdmUgdG8gc3BlY2lmeSAtLWhhc2hsaW1pdC1tb2RlIik7CglpZiAoIShmbGFncyAmIFBBUkFNX05BTUUpKQoJCWV4aXRfZXJyb3IoUEFSQU1FVEVSX1BST0JMRU0sCgkJCQkiWW91IGhhdmUgdG8gc3BlY2lmeSAtLWhhc2hsaW1pdC1uYW1lIik7Cn0KCnN0YXRpYyB2b2lkIGhhc2hsaW1pdF9tdF9jaGVjayh1bnNpZ25lZCBpbnQgZmxhZ3MpCnsKCWlmICghKGZsYWdzICYgUEFSQU1fTElNSVQpKQoJCWV4aXRfZXJyb3IoUEFSQU1FVEVSX1BST0JMRU0sICJZb3UgaGF2ZSB0byBzcGVjaWZ5ICIKCQkgICAgICAgICAgICItLWhhc2hsaW1pdC11cHRvIG9yIC0taGFzaGxpbWl0LWFib3ZlIik7CglpZiAoIShmbGFncyAmIFBBUkFNX05BTUUpKQoJCWV4aXRfZXJyb3IoUEFSQU1FVEVSX1BST0JMRU0sCgkJICAgICAgICAgICAiWW91IGhhdmUgdG8gc3BlY2lmeSAtLWhhc2hsaW1pdC1uYW1lIik7Cn0KCnN0YXRpYyBjb25zdCBzdHJ1Y3QgcmF0ZXMKewoJY29uc3QgY2hhciAqbmFtZTsKCXVfaW50MzJfdCBtdWx0Owp9IHJhdGVzW10gPSB7IHsgImRheSIsIFhUX0hBU0hMSU1JVF9TQ0FMRSoyNCo2MCo2MCB9LAoJICAgICAgeyAiaG91ciIsIFhUX0hBU0hMSU1JVF9TQ0FMRSo2MCo2MCB9LAoJICAgICAgeyAibWluIiwgWFRfSEFTSExJTUlUX1NDQUxFKjYwIH0sCgkgICAgICB7ICJzZWMiLCBYVF9IQVNITElNSVRfU0NBTEUgfSB9OwoKc3RhdGljIHZvaWQgcHJpbnRfcmF0ZSh1X2ludDMyX3QgcGVyaW9kKQp7Cgl1bnNpZ25lZCBpbnQgaTsKCglmb3IgKGkgPSAxOyBpIDwgc2l6ZW9mKHJhdGVzKS9zaXplb2Yoc3RydWN0IHJhdGVzKTsgaSsrKSB7CgkJaWYgKHBlcmlvZCA+IHJhdGVzW2ldLm11bHQKICAgICAgICAgICAgfHwgcmF0ZXNbaV0ubXVsdC9wZXJpb2QgPCByYXRlc1tpXS5tdWx0JXBlcmlvZCkKCQkJYnJlYWs7Cgl9CgoJcHJpbnRmKCIldS8lcyAiLCByYXRlc1tpLTFdLm11bHQgLyBwZXJpb2QsIHJhdGVzW2ktMV0ubmFtZSk7Cn0KCnN0YXRpYyB2b2lkIHByaW50X21vZGUodW5zaWduZWQgaW50IG1vZGUsIGNoYXIgc2VwYXJhdG9yKQp7Cglib29sIHByZXZtb2RlID0gZmFsc2U7CgoJaWYgKG1vZGUgJiBYVF9IQVNITElNSVRfSEFTSF9TSVApIHsKCQlmcHV0cygic3JjaXAiLCBzdGRvdXQpOwoJCXByZXZtb2RlID0gMTsKCX0KCWlmIChtb2RlICYgWFRfSEFTSExJTUlUX0hBU0hfU1BUKSB7CgkJaWYgKHByZXZtb2RlKQoJCQlwdXRjaGFyKHNlcGFyYXRvcik7CgkJZnB1dHMoInNyY3BvcnQiLCBzdGRvdXQpOwoJCXByZXZtb2RlID0gMTsKCX0KCWlmIChtb2RlICYgWFRfSEFTSExJTUlUX0hBU0hfRElQKSB7CgkJaWYgKHByZXZtb2RlKQoJCQlwdXRjaGFyKHNlcGFyYXRvcik7CgkJZnB1dHMoImRzdGlwIiwgc3Rkb3V0KTsKCQlwcmV2bW9kZSA9IDE7Cgl9CglpZiAobW9kZSAmIFhUX0hBU0hMSU1JVF9IQVNIX0RQVCkgewoJCWlmIChwcmV2bW9kZSkKCQkJcHV0Y2hhcihzZXBhcmF0b3IpOwoJCWZwdXRzKCJkc3Rwb3J0Iiwgc3Rkb3V0KTsKCX0KCXB1dGNoYXIoJyAnKTsKfQoKLyogUHJpbnRzIG91dCB0aGUgbWF0Y2hpbmZvLiAqLwpzdGF0aWMgdm9pZCBoYXNobGltaXRfcHJpbnQoY29uc3Qgdm9pZCAqaXAsCiAgICAgICAgICAgICAgICAgICAgICAgICAgICBjb25zdCBzdHJ1Y3QgeHRfZW50cnlfbWF0Y2ggKm1hdGNoLCBpbnQgbnVtZXJpYykKewoJc3RydWN0IHh0X2hhc2hsaW1pdF9pbmZvICpyID0gCgkJKHN0cnVjdCB4dF9oYXNobGltaXRfaW5mbyAqKW1hdGNoLT5kYXRhOwoJZnB1dHMoImxpbWl0OiBhdmcgIiwgc3Rkb3V0KTsgcHJpbnRfcmF0ZShyLT5jZmcuYXZnKTsKCXByaW50ZigiYnVyc3QgJXUgIiwgci0+Y2ZnLmJ1cnN0KTsKCWZwdXRzKCJtb2RlICIsIHN0ZG91dCk7CglwcmludF9tb2RlKHItPmNmZy5tb2RlLCAnLScpOwoJaWYgKHItPmNmZy5zaXplKQoJCXByaW50ZigiaHRhYmxlLXNpemUgJXUgIiwgci0+Y2ZnLnNpemUpOwoJaWYgKHItPmNmZy5tYXgpCgkJcHJpbnRmKCJodGFibGUtbWF4ICV1ICIsIHItPmNmZy5tYXgpOwoJaWYgKHItPmNmZy5nY19pbnRlcnZhbCAhPSBYVF9IQVNITElNSVRfR0NJTlRFUlZBTCkKCQlwcmludGYoImh0YWJsZS1nY2ludGVydmFsICV1ICIsIHItPmNmZy5nY19pbnRlcnZhbCk7CglpZiAoci0+Y2ZnLmV4cGlyZSAhPSBYVF9IQVNITElNSVRfRVhQSVJFKQoJCXByaW50ZigiaHRhYmxlLWV4cGlyZSAldSAiLCByLT5jZmcuZXhwaXJlKTsKfQoKc3RhdGljIHZvaWQKaGFzaGxpbWl0X210X3ByaW50KGNvbnN0IHN0cnVjdCB4dF9oYXNobGltaXRfbXRpbmZvMSAqaW5mbywgdW5zaWduZWQgaW50IGRtYXNrKQp7CglpZiAoaW5mby0+Y2ZnLm1vZGUgJiBYVF9IQVNITElNSVRfSU5WRVJUKQoJCWZwdXRzKCJsaW1pdDogYWJvdmUgIiwgc3Rkb3V0KTsKCWVsc2UKCQlmcHV0cygibGltaXQ6IHVwIHRvICIsIHN0ZG91dCk7CglwcmludF9yYXRlKGluZm8tPmNmZy5hdmcpOwoJcHJpbnRmKCJidXJzdCAldSAiLCBpbmZvLT5jZmcuYnVyc3QpOwoJaWYgKGluZm8tPmNmZy5tb2RlICYgKFhUX0hBU0hMSU1JVF9IQVNIX1NJUCB8IFhUX0hBU0hMSU1JVF9IQVNIX1NQVCB8CgkgICAgWFRfSEFTSExJTUlUX0hBU0hfRElQIHwgWFRfSEFTSExJTUlUX0hBU0hfRFBUKSkgewoJCWZwdXRzKCJtb2RlICIsIHN0ZG91dCk7CgkJcHJpbnRfbW9kZShpbmZvLT5jZmcubW9kZSwgJy0nKTsKCX0KCWlmIChpbmZvLT5jZmcuc2l6ZSAhPSAwKQoJCXByaW50ZigiaHRhYmxlLXNpemUgJXUgIiwgaW5mby0+Y2ZnLnNpemUpOwoJaWYgKGluZm8tPmNmZy5tYXggIT0gMCkKCQlwcmludGYoImh0YWJsZS1tYXggJXUgIiwgaW5mby0+Y2ZnLm1heCk7CglpZiAoaW5mby0+Y2ZnLmdjX2ludGVydmFsICE9IFhUX0hBU0hMSU1JVF9HQ0lOVEVSVkFMKQoJCXByaW50ZigiaHRhYmxlLWdjaW50ZXJ2YWwgJXUgIiwgaW5mby0+Y2ZnLmdjX2ludGVydmFsKTsKCWlmIChpbmZvLT5jZmcuZXhwaXJlICE9IFhUX0hBU0hMSU1JVF9FWFBJUkUpCgkJcHJpbnRmKCJodGFibGUtZXhwaXJlICV1ICIsIGluZm8tPmNmZy5leHBpcmUpOwoKCWlmIChpbmZvLT5jZmcuc3JjbWFzayAhPSBkbWFzaykKCQlwcmludGYoInNyY21hc2sgJXUgIiwgaW5mby0+Y2ZnLnNyY21hc2spOwoJaWYgKGluZm8tPmNmZy5kc3RtYXNrICE9IGRtYXNrKQoJCXByaW50ZigiZHN0bWFzayAldSAiLCBpbmZvLT5jZmcuZHN0bWFzayk7Cn0KCnN0YXRpYyB2b2lkCmhhc2hsaW1pdF9tdDRfcHJpbnQoY29uc3Qgdm9pZCAqaXAsIGNvbnN0IHN0cnVjdCB4dF9lbnRyeV9tYXRjaCAqbWF0Y2gsCiAgICAgICAgICAgICAgICAgICBpbnQgbnVtZXJpYykKewoJY29uc3Qgc3RydWN0IHh0X2hhc2hsaW1pdF9tdGluZm8xICppbmZvID0gKGNvbnN0IHZvaWQgKiltYXRjaC0+ZGF0YTsKCgloYXNobGltaXRfbXRfcHJpbnQoaW5mbywgMzIpOwp9CgpzdGF0aWMgdm9pZApoYXNobGltaXRfbXQ2X3ByaW50KGNvbnN0IHZvaWQgKmlwLCBjb25zdCBzdHJ1Y3QgeHRfZW50cnlfbWF0Y2ggKm1hdGNoLAogICAgICAgICAgICAgICAgICAgaW50IG51bWVyaWMpCnsKCWNvbnN0IHN0cnVjdCB4dF9oYXNobGltaXRfbXRpbmZvMSAqaW5mbyA9IChjb25zdCB2b2lkICopbWF0Y2gtPmRhdGE7CgoJaGFzaGxpbWl0X210X3ByaW50KGluZm8sIDEyOCk7Cn0KCi8qIEZJWE1FOiBNYWtlIG1pbmltYWxpc3Q6IG9ubHkgcHJpbnQgcmF0ZSBpZiBub3QgZGVmYXVsdCAtLVJSICovCnN0YXRpYyB2b2lkIGhhc2hsaW1pdF9zYXZlKGNvbnN0IHZvaWQgKmlwLCBjb25zdCBzdHJ1Y3QgeHRfZW50cnlfbWF0Y2ggKm1hdGNoKQp7CglzdHJ1Y3QgeHRfaGFzaGxpbWl0X2luZm8gKnIgPSAKCQkoc3RydWN0IHh0X2hhc2hsaW1pdF9pbmZvICopbWF0Y2gtPmRhdGE7CgoJZnB1dHMoIi0taGFzaGxpbWl0ICIsIHN0ZG91dCk7IHByaW50X3JhdGUoci0+Y2ZnLmF2Zyk7CglpZiAoci0+Y2ZnLmJ1cnN0ICE9IFhUX0hBU0hMSU1JVF9CVVJTVCkKCQlwcmludGYoIi0taGFzaGxpbWl0LWJ1cnN0ICV1ICIsIHItPmNmZy5idXJzdCk7CgoJZnB1dHMoIi0taGFzaGxpbWl0LW1vZGUgIiwgc3Rkb3V0KTsKCXByaW50X21vZGUoci0+Y2ZnLm1vZGUsICcsJyk7CgkKCXByaW50ZigiLS1oYXNobGltaXQtbmFtZSAlcyAiLCByLT5uYW1lKTsKCglpZiAoci0+Y2ZnLnNpemUpCgkJcHJpbnRmKCItLWhhc2hsaW1pdC1odGFibGUtc2l6ZSAldSAiLCByLT5jZmcuc2l6ZSk7CglpZiAoci0+Y2ZnLm1heCkKCQlwcmludGYoIi0taGFzaGxpbWl0LWh0YWJsZS1tYXggJXUgIiwgci0+Y2ZnLm1heCk7CglpZiAoci0+Y2ZnLmdjX2ludGVydmFsICE9IFhUX0hBU0hMSU1JVF9HQ0lOVEVSVkFMKQoJCXByaW50ZigiLS1oYXNobGltaXQtaHRhYmxlLWdjaW50ZXJ2YWwgJXUiLCByLT5jZmcuZ2NfaW50ZXJ2YWwpOwoJaWYgKHItPmNmZy5leHBpcmUgIT0gWFRfSEFTSExJTUlUX0VYUElSRSkKCQlwcmludGYoIi0taGFzaGxpbWl0LWh0YWJsZS1leHBpcmUgJXUgIiwgci0+Y2ZnLmV4cGlyZSk7Cn0KCnN0YXRpYyB2b2lkCmhhc2hsaW1pdF9tdF9zYXZlKGNvbnN0IHN0cnVjdCB4dF9oYXNobGltaXRfbXRpbmZvMSAqaW5mbywgdW5zaWduZWQgaW50IGRtYXNrKQp7CglpZiAoaW5mby0+Y2ZnLm1vZGUgJiBYVF9IQVNITElNSVRfSU5WRVJUKQoJCWZwdXRzKCItLWhhc2hsaW1pdC1hYm92ZSAiLCBzdGRvdXQpOwoJZWxzZQoJCWZwdXRzKCItLWhhc2hsaW1pdC11cHRvICIsIHN0ZG91dCk7CglwcmludF9yYXRlKGluZm8tPmNmZy5hdmcpOwoJaWYgKGluZm8tPmNmZy5idXJzdCAhPSBYVF9IQVNITElNSVRfQlVSU1QpCgkJcHJpbnRmKCItLWhhc2hsaW1pdC1idXJzdCAldSAiLCBpbmZvLT5jZmcuYnVyc3QpOwoKCWlmIChpbmZvLT5jZmcubW9kZSAmIChYVF9IQVNITElNSVRfSEFTSF9TSVAgfCBYVF9IQVNITElNSVRfSEFTSF9TUFQgfAoJICAgIFhUX0hBU0hMSU1JVF9IQVNIX0RJUCB8IFhUX0hBU0hMSU1JVF9IQVNIX0RQVCkpIHsKCQlmcHV0cygiLS1oYXNobGltaXQtbW9kZSAiLCBzdGRvdXQpOwoJCXByaW50X21vZGUoaW5mby0+Y2ZnLm1vZGUsICcsJyk7Cgl9CgoJcHJpbnRmKCItLWhhc2hsaW1pdC1uYW1lICVzICIsIGluZm8tPm5hbWUpOwoKCWlmIChpbmZvLT5jZmcuc2l6ZSAhPSAwKQoJCXByaW50ZigiLS1oYXNobGltaXQtaHRhYmxlLXNpemUgJXUgIiwgaW5mby0+Y2ZnLnNpemUpOwoJaWYgKGluZm8tPmNmZy5tYXggIT0gMCkKCQlwcmludGYoIi0taGFzaGxpbWl0LWh0YWJsZS1tYXggJXUgIiwgaW5mby0+Y2ZnLm1heCk7CglpZiAoaW5mby0+Y2ZnLmdjX2ludGVydmFsICE9IFhUX0hBU0hMSU1JVF9HQ0lOVEVSVkFMKQoJCXByaW50ZigiLS1oYXNobGltaXQtaHRhYmxlLWdjaW50ZXJ2YWwgJXUiLCBpbmZvLT5jZmcuZ2NfaW50ZXJ2YWwpOwoJaWYgKGluZm8tPmNmZy5leHBpcmUgIT0gWFRfSEFTSExJTUlUX0VYUElSRSkKCQlwcmludGYoIi0taGFzaGxpbWl0LWh0YWJsZS1leHBpcmUgJXUgIiwgaW5mby0+Y2ZnLmV4cGlyZSk7CgoJaWYgKGluZm8tPmNmZy5zcmNtYXNrICE9IGRtYXNrKQoJCXByaW50ZigiLS1oYXNobGltaXQtc3JjbWFzayAldSAiLCBpbmZvLT5jZmcuc3JjbWFzayk7CglpZiAoaW5mby0+Y2ZnLmRzdG1hc2sgIT0gZG1hc2spCgkJcHJpbnRmKCItLWhhc2hsaW1pdC1kc3RtYXNrICV1ICIsIGluZm8tPmNmZy5kc3RtYXNrKTsKfQoKc3RhdGljIHZvaWQKaGFzaGxpbWl0X210NF9zYXZlKGNvbnN0IHZvaWQgKmlwLCBjb25zdCBzdHJ1Y3QgeHRfZW50cnlfbWF0Y2ggKm1hdGNoKQp7Cgljb25zdCBzdHJ1Y3QgeHRfaGFzaGxpbWl0X210aW5mbzEgKmluZm8gPSAoY29uc3Qgdm9pZCAqKW1hdGNoLT5kYXRhOwoKCWhhc2hsaW1pdF9tdF9zYXZlKGluZm8sIDMyKTsKfQoKc3RhdGljIHZvaWQKaGFzaGxpbWl0X210Nl9zYXZlKGNvbnN0IHZvaWQgKmlwLCBjb25zdCBzdHJ1Y3QgeHRfZW50cnlfbWF0Y2ggKm1hdGNoKQp7Cgljb25zdCBzdHJ1Y3QgeHRfaGFzaGxpbWl0X210aW5mbzEgKmluZm8gPSAoY29uc3Qgdm9pZCAqKW1hdGNoLT5kYXRhOwoKCWhhc2hsaW1pdF9tdF9zYXZlKGluZm8sIDEyOCk7Cn0KCnN0YXRpYyBzdHJ1Y3QgeHRhYmxlc19tYXRjaCBoYXNobGltaXRfbWF0Y2ggPSB7CgkuZmFtaWx5CQk9IEFGX0lORVQsCgkubmFtZQkJPSAiaGFzaGxpbWl0IiwKCS52ZXJzaW9uCT0gWFRBQkxFU19WRVJTSU9OLAoJLnJldmlzaW9uCT0gMCwKCS5zaXplCQk9IFhUX0FMSUdOKHNpemVvZihzdHJ1Y3QgeHRfaGFzaGxpbWl0X2luZm8pKSwKCS51c2Vyc3BhY2VzaXplCT0gb2Zmc2V0b2Yoc3RydWN0IHh0X2hhc2hsaW1pdF9pbmZvLCBoaW5mbyksCgkuaGVscAkJPSBoYXNobGltaXRfaGVscCwKCS5pbml0CQk9IGhhc2hsaW1pdF9pbml0LAoJLnBhcnNlCQk9IGhhc2hsaW1pdF9wYXJzZSwKCS5maW5hbF9jaGVjawk9IGhhc2hsaW1pdF9jaGVjaywKCS5wcmludAkJPSBoYXNobGltaXRfcHJpbnQsCgkuc2F2ZQkJPSBoYXNobGltaXRfc2F2ZSwKCS5leHRyYV9vcHRzCT0gaGFzaGxpbWl0X29wdHMsCn07CgpzdGF0aWMgc3RydWN0IHh0YWJsZXNfbWF0Y2ggaGFzaGxpbWl0X21hdGNoNiA9IHsKCS5mYW1pbHkJCT0gQUZfSU5FVDYsCgkubmFtZQkJPSAiaGFzaGxpbWl0IiwKCS52ZXJzaW9uCT0gWFRBQkxFU19WRVJTSU9OLAoJLnJldmlzaW9uCT0gMCwKCS5zaXplCQk9IFhUX0FMSUdOKHNpemVvZihzdHJ1Y3QgeHRfaGFzaGxpbWl0X2luZm8pKSwKCS51c2Vyc3BhY2VzaXplCT0gb2Zmc2V0b2Yoc3RydWN0IHh0X2hhc2hsaW1pdF9pbmZvLCBoaW5mbyksCgkuaGVscAkJPSBoYXNobGltaXRfaGVscCwKCS5pbml0CQk9IGhhc2hsaW1pdF9pbml0LAoJLnBhcnNlCQk9IGhhc2hsaW1pdF9wYXJzZSwKCS5maW5hbF9jaGVjawk9IGhhc2hsaW1pdF9jaGVjaywKCS5wcmludAkJPSBoYXNobGltaXRfcHJpbnQsCgkuc2F2ZQkJPSBoYXNobGltaXRfc2F2ZSwKCS5leHRyYV9vcHRzCT0gaGFzaGxpbWl0X29wdHMsCn07CgpzdGF0aWMgc3RydWN0IHh0YWJsZXNfbWF0Y2ggaGFzaGxpbWl0X210X3JlZyA9IHsKCS52ZXJzaW9uICAgICAgICA9IFhUQUJMRVNfVkVSU0lPTiwKCS5uYW1lICAgICAgICAgICA9ICJoYXNobGltaXQiLAoJLnJldmlzaW9uICAgICAgID0gMSwKCS5mYW1pbHkgICAgICAgICA9IEFGX0lORVQsCgkuc2l6ZSAgICAgICAgICAgPSBYVF9BTElHTihzaXplb2Yoc3RydWN0IHh0X2hhc2hsaW1pdF9tdGluZm8xKSksCgkudXNlcnNwYWNlc2l6ZSAgPSBvZmZzZXRvZihzdHJ1Y3QgeHRfaGFzaGxpbWl0X210aW5mbzEsIGhpbmZvKSwKCS5oZWxwICAgICAgICAgICA9IGhhc2hsaW1pdF9tdF9oZWxwLAoJLmluaXQgICAgICAgICAgID0gaGFzaGxpbWl0X210NF9pbml0LAoJLnBhcnNlICAgICAgICAgID0gaGFzaGxpbWl0X210NF9wYXJzZSwKCS5maW5hbF9jaGVjawk9IGhhc2hsaW1pdF9tdF9jaGVjaywKCS5wcmludCAgICAgICAgICA9IGhhc2hsaW1pdF9tdDRfcHJpbnQsCgkuc2F2ZSAgICAgICAgICAgPSBoYXNobGltaXRfbXQ0X3NhdmUsCgkuZXh0cmFfb3B0cyAgICAgPSBoYXNobGltaXRfbXRfb3B0cywKfTsKCnN0YXRpYyBzdHJ1Y3QgeHRhYmxlc19tYXRjaCBoYXNobGltaXRfbXQ2X3JlZyA9IHsKCS52ZXJzaW9uICAgICAgICA9IFhUQUJMRVNfVkVSU0lPTiwKCS5uYW1lICAgICAgICAgICA9ICJoYXNobGltaXQiLAoJLnJldmlzaW9uICAgICAgID0gMSwKCS5mYW1pbHkgICAgICAgICA9IEFGX0lORVQ2LAoJLnNpemUgICAgICAgICAgID0gWFRfQUxJR04oc2l6ZW9mKHN0cnVjdCB4dF9oYXNobGltaXRfbXRpbmZvMSkpLAoJLnVzZXJzcGFjZXNpemUgID0gb2Zmc2V0b2Yoc3RydWN0IHh0X2hhc2hsaW1pdF9tdGluZm8xLCBoaW5mbyksCgkuaGVscCAgICAgICAgICAgPSBoYXNobGltaXRfbXRfaGVscCwKCS5pbml0ICAgICAgICAgICA9IGhhc2hsaW1pdF9tdDZfaW5pdCwKCS5wYXJzZSAgICAgICAgICA9IGhhc2hsaW1pdF9tdDZfcGFyc2UsCgkuZmluYWxfY2hlY2sJPSBoYXNobGltaXRfbXRfY2hlY2ssCgkucHJpbnQgICAgICAgICAgPSBoYXNobGltaXRfbXQ2X3ByaW50LAoJLnNhdmUgICAgICAgICAgID0gaGFzaGxpbWl0X210Nl9zYXZlLAoJLmV4dHJhX29wdHMgICAgID0gaGFzaGxpbWl0X210X29wdHMsCn07Cgp2b2lkIF9pbml0KHZvaWQpCnsKCXh0YWJsZXNfcmVnaXN0ZXJfbWF0Y2goJmhhc2hsaW1pdF9tYXRjaCk7Cgl4dGFibGVzX3JlZ2lzdGVyX21hdGNoKCZoYXNobGltaXRfbWF0Y2g2KTsKCXh0YWJsZXNfcmVnaXN0ZXJfbWF0Y2goJmhhc2hsaW1pdF9tdF9yZWcpOwoJeHRhYmxlc19yZWdpc3Rlcl9tYXRjaCgmaGFzaGxpbWl0X210Nl9yZWcpOwp9Cg==